/// <summary>
        /// Renders the animation for when an enderdragon dies
        /// </summary>
        protected virtual void RenderDragonDying(EntityDragon par1EntityDragon, float par2)
        {
            base.RenderEquippedItems(par1EntityDragon, par2);
            Tessellator tessellator = Tessellator.Instance;

            if (par1EntityDragon.Field_40178_aA > 0)
            {
                RenderHelper.DisableStandardItemLighting();
                float f  = ((float)par1EntityDragon.Field_40178_aA + par2) / 200F;
                float f1 = 0.0F;

                if (f > 0.8F)
                {
                    f1 = (f - 0.8F) / 0.2F;
                }

                Random random = new Random(432);
                //GL.Disable(EnableCap.Texture2D);
                //GL.ShadeModel(ShadingModel.Smooth);
                //GL.Enable(EnableCap.Blend);
                //GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.One);
                //GL.Disable(EnableCap.AlphaTest);
                //GL.Enable(EnableCap.CullFace);
                //GL.DepthMask(false);
                //GL.PushMatrix();
                //GL.Translate(0.0F, -1F, -2F);

                for (int i = 0; (float)i < ((f + f * f) / 2.0F) * 60F; i++)
                {
                    //GL.Rotate(random.NextDouble() * 360F, 1.0F, 0.0F, 0.0F);
                    //GL.Rotate(random.NextDouble() * 360F, 0.0F, 1.0F, 0.0F);
                    //GL.Rotate(random.NextDouble() * 360F, 0.0F, 0.0F, 1.0F);
                    //GL.Rotate(random.NextDouble() * 360F, 1.0F, 0.0F, 0.0F);
                    //GL.Rotate(random.NextDouble() * 360F, 0.0F, 1.0F, 0.0F);
                    //GL.Rotate(random.NextDouble() * 360F + f * 90F, 0.0F, 0.0F, 1.0F);
                    tessellator.StartDrawing(6);
                    float f2 = (float)random.NextDouble() * 20F + 5F + f1 * 10F;
                    float f3 = (float)random.NextDouble() * 2.0F + 1.0F + f1 * 2.0F;
                    tessellator.SetColorRGBA_I(0xffffff, (int)(255F * (1.0F - f1)));
                    tessellator.AddVertex(0.0F, 0.0F, 0.0F);
                    tessellator.SetColorRGBA_I(0xff00ff, 0);
                    tessellator.AddVertex(-0.86599999999999999D * (double)f3, f2, -0.5F * f3);
                    tessellator.AddVertex(0.86599999999999999D * (double)f3, f2, -0.5F * f3);
                    tessellator.AddVertex(0.0F, f2, 1.0F * f3);
                    tessellator.AddVertex(-0.86599999999999999D * (double)f3, f2, -0.5F * f3);
                    tessellator.Draw();
                }

                //GL.PopMatrix();
                //GL.DepthMask(true);
                //GL.Disable(EnableCap.CullFace);
                //GL.Disable(EnableCap.Blend);
                //GL.ShadeModel(ShadingModel.Flat);
                //GL.Color4(1.0F, 1.0F, 1.0F, 1.0F);
                //GL.Enable(EnableCap.Texture2D);
                //GL.Enable(EnableCap.AlphaTest);
                RenderHelper.EnableStandardItemLighting();
            }
        }
 /// <summary>
 /// Draws the item sprite on top of the background sprite.
 /// </summary>
 private void DrawItemSprite(int par1, int par2, int par3)
 {
     DrawButtonBackground(par1 + 1, par2 + 1);
     //GL.Enable(EnableCap.RescaleNormal);
     RenderHelper.EnableGUIStandardItemLighting();
     RenderItem.DrawItemIntoGui(FontRenderer, Mc.RenderEngineOld, par3, 0, Item.ItemsList[par3].GetIconFromDamage(0), par1 + 2, par2 + 2);
     RenderHelper.DisableStandardItemLighting();
     //GL.Disable(EnableCap.RescaleNormal);
 }
        /// <summary>
        /// Renders the dragon, along with its dying animation
        /// </summary>
        public virtual void DoRenderDragon(EntityDragon par1EntityDragon, double par2, double par4, double par6, float par8, float par9)
        {
            EntityDragon = par1EntityDragon;

            if (Field_40284_d != 4)
            {
                MainModel     = new ModelDragon(0.0F);
                Field_40284_d = 4;
            }

            base.DoRenderLiving(par1EntityDragon, par2, par4, par6, par8, par9);

            if (par1EntityDragon.HealingEnderCrystal != null)
            {
                float f  = (float)par1EntityDragon.HealingEnderCrystal.InnerRotation + par9;
                float f1 = MathHelper2.Sin(f * 0.2F) / 2.0F + 0.5F;
                f1 = (f1 * f1 + f1) * 0.2F;
                float f2 = (float)(par1EntityDragon.HealingEnderCrystal.PosX - par1EntityDragon.PosX - (par1EntityDragon.PrevPosX - par1EntityDragon.PosX) * (double)(1.0F - par9));
                float f3 = (float)(((double)f1 + par1EntityDragon.HealingEnderCrystal.PosY) - 1.0D - par1EntityDragon.PosY - (par1EntityDragon.PrevPosY - par1EntityDragon.PosY) * (double)(1.0F - par9));
                float f4 = (float)(par1EntityDragon.HealingEnderCrystal.PosZ - par1EntityDragon.PosZ - (par1EntityDragon.PrevPosZ - par1EntityDragon.PosZ) * (double)(1.0F - par9));
                float f5 = MathHelper2.Sqrt_float(f2 * f2 + f4 * f4);
                float f6 = MathHelper2.Sqrt_float(f2 * f2 + f3 * f3 + f4 * f4);
                //GL.PushMatrix();
                //GL.Translate((float)par2, (float)par4 + 2.0F, (float)par6);
                //GL.Rotate(((float)(-Math.Atan2(f4, f2)) * 180F) / (float)Math.PI - 90F, 0.0F, 1.0F, 0.0F);
                //GL.Rotate(((float)(-Math.Atan2(f5, f3)) * 180F) / (float)Math.PI - 90F, 1.0F, 0.0F, 0.0F);
                Tessellator tessellator = Tessellator.Instance;
                RenderHelper.DisableStandardItemLighting();
                //GL.Disable(EnableCap.CullFace);
                LoadTexture("/mob/enderdragon/beam.png");
                //GL.ShadeModel(ShadingModel.Smooth);
                float f7 = 0.0F - ((float)par1EntityDragon.TicksExisted + par9) * 0.01F;
                float f8 = MathHelper2.Sqrt_float(f2 * f2 + f3 * f3 + f4 * f4) / 32F - ((float)par1EntityDragon.TicksExisted + par9) * 0.01F;
                tessellator.StartDrawing(5);
                int i = 8;

                for (int j = 0; j <= i; j++)
                {
                    float f9  = MathHelper2.Sin(((float)(j % i) * (float)Math.PI * 2.0F) / (float)i) * 0.75F;
                    float f10 = MathHelper2.Cos(((float)(j % i) * (float)Math.PI * 2.0F) / (float)i) * 0.75F;
                    float f11 = ((float)(j % i) * 1.0F) / (float)i;
                    tessellator.SetColorOpaque_I(0);
                    tessellator.AddVertexWithUV(f9 * 0.2F, f10 * 0.2F, 0.0F, f11, f8);
                    tessellator.SetColorOpaque_I(0xffffff);
                    tessellator.AddVertexWithUV(f9, f10, f6, f11, f7);
                }

                tessellator.Draw();
                //GL.Enable(EnableCap.CullFace);
                //GL.ShadeModel(ShadingModel.Flat);
                RenderHelper.EnableStandardItemLighting();
                //GL.PopMatrix();
            }
        }
Beispiel #4
0
        public virtual void RenderPiston(TileEntityPiston par1TileEntityPiston, double par2, double par4, double par6, float par8)
        {
            Block block = Block.BlocksList[par1TileEntityPiston.GetStoredBlockID()];

            if (block != null && par1TileEntityPiston.GetProgress(par8) < 1.0F)
            {
                Tessellator tessellator = Tessellator.Instance;
                BindTextureByName("/terrain.png");
                RenderHelper.DisableStandardItemLighting();
                //GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
                //GL.Enable(EnableCap.Blend);
                //GL.Disable(EnableCap.CullFace);

                if (Minecraft.IsAmbientOcclusionEnabled())
                {
                    //GL.ShadeModel(ShadingModel.Smooth);
                }
                else
                {
                    //GL.ShadeModel(ShadingModel.Flat);
                }

                tessellator.StartDrawingQuads();
                tessellator.SetTranslation(((float)par2 - (float)par1TileEntityPiston.XCoord) + par1TileEntityPiston.GetOffsetX(par8), ((float)par4 - (float)par1TileEntityPiston.YCoord) + par1TileEntityPiston.GetOffsetY(par8), ((float)par6 - (float)par1TileEntityPiston.ZCoord) + par1TileEntityPiston.GetOffsetZ(par8));
                tessellator.SetColorOpaque(1, 1, 1);

                if (block == Block.PistonExtension && par1TileEntityPiston.GetProgress(par8) < 0.5F)
                {
                    BlockRenderer.RenderPistonExtensionAllFaces(block, par1TileEntityPiston.XCoord, par1TileEntityPiston.YCoord, par1TileEntityPiston.ZCoord, false);
                }
                else if (par1TileEntityPiston.ShouldRenderHead() && !par1TileEntityPiston.IsExtending())
                {
                    Block.PistonExtension.SetHeadTexture(((BlockPistonBase)block).GetPistonExtensionTexture());
                    BlockRenderer.RenderPistonExtensionAllFaces(Block.PistonExtension, par1TileEntityPiston.XCoord, par1TileEntityPiston.YCoord, par1TileEntityPiston.ZCoord, par1TileEntityPiston.GetProgress(par8) < 0.5F);
                    Block.PistonExtension.ClearHeadTexture();
                    tessellator.SetTranslation((float)par2 - (float)par1TileEntityPiston.XCoord, (float)par4 - (float)par1TileEntityPiston.YCoord, (float)par6 - (float)par1TileEntityPiston.ZCoord);
                    BlockRenderer.RenderPistonBaseAllFaces(block, par1TileEntityPiston.XCoord, par1TileEntityPiston.YCoord, par1TileEntityPiston.ZCoord);
                }
                else
                {
                    BlockRenderer.RenderBlockAllFaces(block, par1TileEntityPiston.XCoord, par1TileEntityPiston.YCoord, par1TileEntityPiston.ZCoord);
                }

                tessellator.SetTranslation(0.0F, 0.0F, 0.0F);
                tessellator.Draw();
                RenderHelper.EnableStandardItemLighting();
            }
        }
        /// <summary>
        /// Draw the background layer for the GuiContainer (everything behind the items)
        /// </summary>
        protected override void DrawGuiContainerBackgroundLayer(float par1, int par2, int par3)
        {
            int i = Mc.RenderEngineOld.GetTexture("/gui/inventory.png");

            //GL.Color4(1.0F, 1.0F, 1.0F, 1.0F);
            Mc.RenderEngineOld.BindTexture(i);
            int j = GuiLeft;
            int k = GuiTop;

            DrawTexturedModalRect(j, k, 0, 0, XSize, YSize);
            DisplayDebuffEffects();
            //GL.Enable(EnableCap.RescaleNormal);
            //GL.Enable(EnableCap.ColorMaterial);
            //GL.PushMatrix();
            //GL.Translate(j + 51, k + 75, 50F);
            float f = 30F;
            //GL.Scale(-f, f, f);
            //GL.Rotate(180F, 0.0F, 0.0F, 1.0F);
            float f1 = Mc.ThePlayer.RenderYawOffset;
            float f2 = Mc.ThePlayer.RotationYaw;
            float f3 = Mc.ThePlayer.RotationPitch;
            float f4 = (float)(j + 51) - XSize_lo;
            float f5 = (float)((k + 75) - 50) - YSize_lo;

            //GL.Rotate(135F, 0.0F, 1.0F, 0.0F);
            RenderHelper.EnableStandardItemLighting();
            //GL.Rotate(-135F, 0.0F, 1.0F, 0.0F);
            //GL.Rotate(-(float)Math.Atan(f5 / 40F) * 20F, 1.0F, 0.0F, 0.0F);
            Mc.ThePlayer.RenderYawOffset = (float)Math.Atan(f4 / 40F) * 20F;
            Mc.ThePlayer.RotationYaw     = (float)Math.Atan(f4 / 40F) * 40F;
            Mc.ThePlayer.RotationPitch   = -(float)Math.Atan(f5 / 40F) * 20F;
            Mc.ThePlayer.RotationYawHead = Mc.ThePlayer.RotationYaw;
            //GL.Translate(0.0F, Mc.ThePlayer.YOffset, 0.0F);
            RenderManager.Instance.PlayerViewY = 180F;
            RenderManager.Instance.RenderEntityWithPosYaw(Mc.ThePlayer, 0.0F, 0.0F, 0.0F, 0.0F, 1.0F);
            Mc.ThePlayer.RenderYawOffset = f1;
            Mc.ThePlayer.RotationYaw     = f2;
            Mc.ThePlayer.RotationPitch   = f3;
            //GL.PopMatrix();
            RenderHelper.DisableStandardItemLighting();
            //GL.Disable(EnableCap.RescaleNormal);
        }
        public override void RenderParticle(Tessellator par1Tessellator, float par2, float par3, float par4, float par5, float par6, float par7)
        {
            int i = (int)((((float)Field_35130_a + par2) * 15F) / (float)Field_35129_ay);

            if (i > 15)
            {
                return;
            }
            else
            {
                Field_35128_az.BindTexture("misc.explosion.png");
                float f  = (float)(i % 4) / 4F;
                float f1 = f + 0.24975F;
                float f2 = (float)(i / 4) / 4F;
                float f3 = f2 + 0.24975F;
                float f4 = 2.0F * Field_35131_aA;
                float f5 = (float)((PrevPosX + (PosX - PrevPosX) * (double)par2) - InterpPosX);
                float f6 = (float)((PrevPosY + (PosY - PrevPosY) * (double)par2) - InterpPosY);
                float f7 = (float)((PrevPosZ + (PosZ - PrevPosZ) * (double)par2) - InterpPosZ);
                //GL.Color4(1.0F, 1.0F, 1.0F, 1.0F);
                //GL.Disable(EnableCap.Lighting);
                RenderHelper.DisableStandardItemLighting();
                par1Tessellator.StartDrawingQuads();
                par1Tessellator.SetColorRGBA_F(ParticleRed, ParticleGreen, ParticleBlue, 1.0F);
                par1Tessellator.SetNormal(0.0F, 1.0F, 0.0F);
                par1Tessellator.SetBrightness(240);
                par1Tessellator.AddVertexWithUV(f5 - par3 * f4 - par6 * f4, f6 - par4 * f4, f7 - par5 * f4 - par7 * f4, f1, f3);
                par1Tessellator.AddVertexWithUV((f5 - par3 * f4) + par6 * f4, f6 + par4 * f4, (f7 - par5 * f4) + par7 * f4, f1, f2);
                par1Tessellator.AddVertexWithUV(f5 + par3 * f4 + par6 * f4, f6 + par4 * f4, f7 + par5 * f4 + par7 * f4, f, f2);
                par1Tessellator.AddVertexWithUV((f5 + par3 * f4) - par6 * f4, f6 - par4 * f4, (f7 + par5 * f4) - par7 * f4, f, f3);
                par1Tessellator.Draw();
                //GL.PolygonOffset(0.0F, 0.0F);
                //GL.Enable(EnableCap.Lighting);
                return;
            }
        }
Beispiel #7
0
        protected void GenAchievementBackground(int par1, int par2, float par3)
        {
            int i = MathHelper2.Floor_double(Field_27116_m + (GuiMapX - Field_27116_m) * (double)par3);
            int j = MathHelper2.Floor_double(Field_27115_n + (GuiMapY - Field_27115_n) * (double)par3);

            if (i < guiMapTop)
            {
                i = guiMapTop;
            }

            if (j < guiMapLeft)
            {
                j = guiMapLeft;
            }

            if (i >= guiMapBottom)
            {
                i = guiMapBottom - 1;
            }

            if (j >= guiMapRight)
            {
                j = guiMapRight - 1;
            }

            int k  = Mc.RenderEngineOld.GetTexture("/terrain.png");
            int l  = Mc.RenderEngineOld.GetTexture("/achievement/bg.png");
            int i1 = (Width - AchievementsPaneWidth) / 2;
            int j1 = (Height - AchievementsPaneHeight) / 2;
            int k1 = i1 + 16;
            int l1 = j1 + 17;

            ZLevel = 0.0F;
            //GL.DepthFunc(DepthFunction.Gequal);
            //GL.PushMatrix();
            //GL.Translate(0.0F, 0.0F, -200F);
            //GL.Enable(EnableCap.Texture2D);
            //GL.Disable(EnableCap.Lighting);
            //GL.Enable(EnableCap.RescaleNormal);
            //GL.Enable(EnableCap.ColorMaterial);
            Mc.RenderEngineOld.BindTexture(k);
            int    i2     = i + 288 >> 4;
            int    j2     = j + 288 >> 4;
            int    k2     = (i + 288) % 16;
            int    l2     = (j + 288) % 16;
            Random random = new Random();

            for (int i3 = 0; i3 * 16 - l2 < 155; i3++)
            {
                float f = 0.6F - ((float)(j2 + i3) / 25F) * 0.3F;
                //GL.Color4(f, f, f, 1.0F);

                for (int k3 = 0; k3 * 16 - k2 < 224; k3++)
                {
                    random = new Random(1234 + i2 + k3);
                    random.Next();
                    int j4 = random.Next(1 + j2 + i3) + (j2 + i3) / 2;
                    int l4 = Block.Sand.BlockIndexInTexture;

                    if (j4 > 37 || j2 + i3 == 35)
                    {
                        l4 = Block.Bedrock.BlockIndexInTexture;
                    }
                    else if (j4 == 22)
                    {
                        if (random.Next(2) == 0)
                        {
                            l4 = Block.OreDiamond.BlockIndexInTexture;
                        }
                        else
                        {
                            l4 = Block.OreRedstone.BlockIndexInTexture;
                        }
                    }
                    else if (j4 == 10)
                    {
                        l4 = Block.OreIron.BlockIndexInTexture;
                    }
                    else if (j4 == 8)
                    {
                        l4 = Block.OreCoal.BlockIndexInTexture;
                    }
                    else if (j4 > 4)
                    {
                        l4 = Block.Stone.BlockIndexInTexture;
                    }
                    else if (j4 > 0)
                    {
                        l4 = Block.Dirt.BlockIndexInTexture;
                    }

                    DrawTexturedModalRect((k1 + k3 * 16) - k2, (l1 + i3 * 16) - l2, l4 % 16 << 4, (l4 >> 4) << 4, 16, 16);
                }
            }

            //GL.Enable(EnableCap.DepthTest);
            //GL.DepthFunc(DepthFunction.Lequal);
            //GL.Disable(EnableCap.Texture2D);

            for (int j3 = 0; j3 < AchievementList.Achievements.Count; j3++)
            {
                Achievement achievement1 = (Achievement)AchievementList.Achievements[j3];

                if (achievement1.ParentAchievement == null)
                {
                    continue;
                }

                int  l3    = (achievement1.DisplayColumn * 24 - i) + 11 + k1;
                int  k4    = (achievement1.DisplayRow * 24 - j) + 11 + l1;
                int  i5    = (achievement1.ParentAchievement.DisplayColumn * 24 - i) + 11 + k1;
                int  l5    = (achievement1.ParentAchievement.DisplayRow * 24 - j) + 11 + l1;
                bool flag  = statFileWriter.HasAchievementUnlocked(achievement1);
                bool flag1 = statFileWriter.CanUnlockAchievement(achievement1);
                int  c     = Math.Sin(((double)(JavaHelper.CurrentTimeMillis() % 600L) / 600D) * Math.PI * 2D) <= 0.59999999999999998D ? 202 : 377;
                long i8    = 0xff000000;

                if (flag)
                {
                    i8 = 0xff707070;
                }
                else if (flag1)
                {
                    i8 = 65280 + (c << 24);
                }

                DrawHorizontalLine(l3, i5, k4, (int)i8);
                DrawVerticalLine(i5, k4, l5, (int)i8);
            }

            Achievement achievement = null;
            RenderItem  renderitem  = new RenderItem();

            RenderHelper.EnableGUIStandardItemLighting();
            //GL.Disable(EnableCap.Lighting);
            //GL.Enable(EnableCap.RescaleNormal);
            //GL.Enable(EnableCap.ColorMaterial);

            for (int i4 = 0; i4 < AchievementList.Achievements.Count; i4++)
            {
                Achievement achievement2 = (Achievement)AchievementList.Achievements[i4];
                int         j5           = achievement2.DisplayColumn * 24 - i;
                int         i6           = achievement2.DisplayRow * 24 - j;

                if (j5 < -24 || i6 < -24 || j5 > 224 || i6 > 155)
                {
                    continue;
                }

                if (statFileWriter.HasAchievementUnlocked(achievement2))
                {
                    float f1 = 1.0F;
                    //GL.Color4(f1, f1, f1, 1.0F);
                }
                else if (statFileWriter.CanUnlockAchievement(achievement2))
                {
                    float f2 = Math.Sin(((double)(JavaHelper.CurrentTimeMillis() % 600L) / 600D) * Math.PI * 2D) >= 0.59999999999999998D ? 0.8F : 0.6F;
                    //GL.Color4(f2, f2, f2, 1.0F);
                }
                else
                {
                    float f3 = 0.3F;
                    //GL.Color4(f3, f3, f3, 1.0F);
                }

                Mc.RenderEngineOld.BindTexture(l);
                int k6 = k1 + j5;
                int j7 = l1 + i6;

                if (achievement2.GetSpecial())
                {
                    DrawTexturedModalRect(k6 - 2, j7 - 2, 26, 202, 26, 26);
                }
                else
                {
                    DrawTexturedModalRect(k6 - 2, j7 - 2, 0, 202, 26, 26);
                }

                if (!statFileWriter.CanUnlockAchievement(achievement2))
                {
                    float f4 = 0.1F;
                    //GL.Color4(f4, f4, f4, 1.0F);
                    renderitem.Field_27004_a = false;
                }

                //GL.Enable(EnableCap.Lighting);
                //GL.Enable(EnableCap.CullFace);
                renderitem.RenderItemIntoGUI(Mc.FontRenderer, Mc.RenderEngineOld, achievement2.TheItemStack, k6 + 3, j7 + 3);
                //GL.Disable(EnableCap.Lighting);

                if (!statFileWriter.CanUnlockAchievement(achievement2))
                {
                    renderitem.Field_27004_a = true;
                }

                //GL.Color4(1.0F, 1.0F, 1.0F, 1.0F);

                if (par1 >= k1 && par2 >= l1 && par1 < k1 + 224 && par2 < l1 + 155 && par1 >= k6 && par1 <= k6 + 22 && par2 >= j7 && par2 <= j7 + 22)
                {
                    achievement = achievement2;
                }
            }

            //GL.Disable(EnableCap.DepthTest);
            //GL.Enable(EnableCap.Blend);
            //GL.Color4(1.0F, 1.0F, 1.0F, 1.0F);
            Mc.RenderEngineOld.BindTexture(l);
            DrawTexturedModalRect(i1, j1, 0, 0, AchievementsPaneWidth, AchievementsPaneHeight);
            //GL.PopMatrix();
            ZLevel = 0.0F;
            //GL.DepthFunc(DepthFunction.Lequal);
            //GL.Disable(EnableCap.DepthTest);
            //GL.Enable(EnableCap.Texture2D);
            base.DrawScreen(par1, par2, par3);

            if (achievement != null)
            {
                string s  = StatCollector.TranslateToLocal(achievement.GetName());
                string s1 = achievement.GetDescription();
                int    k5 = par1 + 12;
                int    j6 = par2 - 4;

                if (statFileWriter.CanUnlockAchievement(achievement))
                {
                    int l6 = Math.Max(FontRenderer.GetStringWidth(s), 120);
                    int k7 = FontRenderer.SplitStringWidth(s1, l6);

                    if (statFileWriter.HasAchievementUnlocked(achievement))
                    {
                        k7 += 12;
                    }

                    DrawGradientRect(k5 - 3, j6 - 3, k5 + l6 + 3, j6 + k7 + 3 + 12, 0xc000000, 0xc000000);
                    FontRenderer.DrawSplitString(s1, k5, j6 + 12, l6, 0xffa0a0a);

                    if (statFileWriter.HasAchievementUnlocked(achievement))
                    {
                        FontRenderer.DrawStringWithShadow(StatCollector.TranslateToLocal("achievement.taken"), k5, j6 + k7 + 4, 0xff9090f);
                    }
                }
                else
                {
                    int    i7 = Math.Max(FontRenderer.GetStringWidth(s), 120);
                    string s2 = StatCollector.TranslateToLocalFormatted("achievement.requires", new Object[]
                    {
                        StatCollector.TranslateToLocal(achievement.ParentAchievement.GetName())
                    });
                    int l7 = FontRenderer.SplitStringWidth(s2, i7);
                    DrawGradientRect(k5 - 3, j6 - 3, k5 + i7 + 3, j6 + l7 + 12 + 3, 0xc000000, 0xc000000);
                    FontRenderer.DrawSplitString(s2, k5, j6 + 12, i7, 0xff70505);
                }

                FontRenderer.DrawStringWithShadow(s, k5, j6, statFileWriter.CanUnlockAchievement(achievement) ? achievement.GetSpecial() ? -128 : -1 : achievement.GetSpecial() ? 0xff80804 : 0xff80808);
            }

            //GL.Enable(EnableCap.DepthTest);
            //GL.Enable(EnableCap.Lighting);
            RenderHelper.DisableStandardItemLighting();
        }
Beispiel #8
0
        /// <summary>
        /// Renders the active item in the player's hand when in first person mode. Args: partialTickTime
        /// </summary>
        public virtual void RenderItemInFirstPerson(float par1)
        {
            float          f = PrevEquippedProgress + (EquippedProgress - PrevEquippedProgress) * par1;
            EntityPlayerSP entityplayersp = Mc.ThePlayer;
            float          f1             = ((EntityPlayer)(entityplayersp)).PrevRotationPitch + (((EntityPlayer)(entityplayersp)).RotationPitch - ((EntityPlayer)(entityplayersp)).PrevRotationPitch) * par1;

            //GL.PushMatrix();
            //GL.Rotate(f1, 1.0F, 0.0F, 0.0F);
            //GL.Rotate(((EntityPlayer)(entityplayersp)).PrevRotationYaw + (((EntityPlayer)(entityplayersp)).RotationYaw - ((EntityPlayer)(entityplayersp)).PrevRotationYaw) * par1, 0.0F, 1.0F, 0.0F);
            RenderHelper.EnableStandardItemLighting();
            //GL.PopMatrix();

            if (entityplayersp is EntityPlayerSP)
            {
                EntityPlayerSP entityplayersp1 = (EntityPlayerSP)entityplayersp;
                float          f2 = entityplayersp1.PrevRenderArmPitch + (entityplayersp1.RenderArmPitch - entityplayersp1.PrevRenderArmPitch) * par1;
                float          f4 = entityplayersp1.PrevRenderArmYaw + (entityplayersp1.RenderArmYaw - entityplayersp1.PrevRenderArmYaw) * par1;
                //GL.Rotate((((EntityPlayer)(entityplayersp)).RotationPitch - f2) * 0.1F, 1.0F, 0.0F, 0.0F);
                //GL.Rotate((((EntityPlayer)(entityplayersp)).RotationYaw - f4) * 0.1F, 0.0F, 1.0F, 0.0F);
            }

            ItemStack itemstack = ItemToRender;
            float     f3        = Mc.TheWorld.GetLightBrightness(MathHelper2.Floor_double(((EntityPlayer)(entityplayersp)).PosX), MathHelper2.Floor_double(((EntityPlayer)(entityplayersp)).PosY), MathHelper2.Floor_double(((EntityPlayer)(entityplayersp)).PosZ));

            f3 = 1.0F;
            int i = Mc.TheWorld.GetLightBrightnessForSkyBlocks(MathHelper2.Floor_double(((EntityPlayer)(entityplayersp)).PosX), MathHelper2.Floor_double(((EntityPlayer)(entityplayersp)).PosY), MathHelper2.Floor_double(((EntityPlayer)(entityplayersp)).PosZ), 0);
            int k = i % 0x10000;
            int l = i / 0x10000;

            OpenGlHelper.SetLightmapTextureCoords(OpenGlHelper.LightmapTexUnit, (float)k / 1.0F, (float)l / 1.0F);
            //GL.Color4(1.0F, 1.0F, 1.0F, 1.0F);

            if (itemstack != null)
            {
                int   j   = Item.ItemsList[itemstack.ItemID].GetColorFromDamage(itemstack.GetItemDamage(), 0);
                float f8  = (float)(j >> 16 & 0xff) / 255F;
                float f13 = (float)(j >> 8 & 0xff) / 255F;
                float f19 = (float)(j & 0xff) / 255F;
                //GL.Color4(f3 * f8, f3 * f13, f3 * f19, 1.0F);
            }
            else
            {
                //GL.Color4(f3, f3, f3, 1.0F);
            }

            if (itemstack != null && itemstack.ItemID == Item.Map.ShiftedIndex)
            {
                //GL.PushMatrix();
                //	float f5 = 0.8F;
                float f9  = entityplayersp.GetSwingProgress(par1);
                float f14 = MathHelper2.Sin(f9 * (float)Math.PI);
                float f20 = MathHelper2.Sin(MathHelper2.Sqrt_float(f9) * (float)Math.PI);
                //GL.Translate(-f20 * 0.4F, MathHelper.Sin(MathHelper.Sqrt_float(f9) * (float)Math.PI * 2.0F) * 0.2F, -f14 * 0.2F);
                f9 = (1.0F - f1 / 45F) + 0.1F;

                if (f9 < 0.0F)
                {
                    f9 = 0.0F;
                }

                if (f9 > 1.0F)
                {
                    f9 = 1.0F;
                }

                f9 = -MathHelper2.Cos(f9 * (float)Math.PI) * 0.5F + 0.5F;
                //GL.Translate(0.0F, (0.0F * f5 - (1.0F - f) * 1.2F - f9 * 0.5F) + 0.04F, -0.9F * f5);
                //GL.Rotate(90F, 0.0F, 1.0F, 0.0F);
                //GL.Rotate(f9 * -85F, 0.0F, 0.0F, 1.0F);
                //GL.Enable(EnableCap.RescaleNormal);
                //GL.BindTexture(TextureTarget.Texture2D, Mc.RenderEngineOld.GetTextureForDownloadableImage(Mc.ThePlayer.SkinUrl, Mc.ThePlayer.GetTexture()));

                for (f14 = 0; f14 < 2; f14++)
                {
                    f20 = f14 * 2 - 1;
                    //GL.PushMatrix();
                    //GL.Translate(-0F, -0.6F, 1.1F * (float)f20);
                    //GL.Rotate(-45 * f20, 1.0F, 0.0F, 0.0F);
                    //GL.Rotate(-90F, 0.0F, 0.0F, 1.0F);
                    //GL.Rotate(59F, 0.0F, 0.0F, 1.0F);
                    //GL.Rotate(-65 * f20, 0.0F, 1.0F, 0.0F);
                    Render       render1       = RenderManager.Instance.GetEntityRenderObject(Mc.ThePlayer);
                    RenderPlayer renderplayer1 = (RenderPlayer)render1;
                    //	float f34 = 1.0F;
                    //GL.Scale(f34, f34, f34);
                    renderplayer1.DrawFirstPersonHand();
                    //GL.PopMatrix();
                }

                f14 = entityplayersp.GetSwingProgress(par1);
                f20 = MathHelper2.Sin(f14 * f14 * (float)Math.PI);
                float f27 = MathHelper2.Sin(MathHelper2.Sqrt_float(f14) * (float)Math.PI);
                //GL.Rotate(-f20 * 20F, 0.0F, 1.0F, 0.0F);
                //GL.Rotate(-f27 * 20F, 0.0F, 0.0F, 1.0F);
                //GL.Rotate(-f27 * 80F, 1.0F, 0.0F, 0.0F);
                f14 = 0.38F;
                //GL.Scale(f14, f14, f14);
                //GL.Rotate(90F, 0.0F, 1.0F, 0.0F);
                //GL.Rotate(180F, 0.0F, 0.0F, 1.0F);
                //GL.Translate(-1F, -1F, 0.0F);
                f20 = 0.015625F;
                //GL.Scale(f20, f20, f20);
                Mc.RenderEngineOld.BindTexture(Mc.RenderEngineOld.GetTexture("/misc/mapbg.png"));
                Tessellator tessellator = Tessellator.Instance;
                //GL.Normal3(0.0F, 0.0F, -1F);
                tessellator.StartDrawingQuads();
                sbyte byte0 = 7;
                tessellator.AddVertexWithUV(0 - byte0, 128 + byte0, 0.0F, 0.0F, 1.0D);
                tessellator.AddVertexWithUV(128 + byte0, 128 + byte0, 0.0F, 1.0D, 1.0D);
                tessellator.AddVertexWithUV(128 + byte0, 0 - byte0, 0.0F, 1.0D, 0.0F);
                tessellator.AddVertexWithUV(0 - byte0, 0 - byte0, 0.0F, 0.0F, 0.0F);
                tessellator.Draw();
                MapData mapdata = Item.Map.GetMapData(itemstack, Mc.TheWorld);
                MapItemRenderer.RenderMap(Mc.ThePlayer, Mc.RenderEngineOld, mapdata);
                //GL.PopMatrix();
            }
            else if (itemstack != null)
            {
                //GL.PushMatrix();
                //	float f6 = 0.8F;

                if (entityplayersp.GetItemInUseCount() > 0)
                {
                    EnumAction enumaction = itemstack.GetItemUseAction();

                    if (enumaction == EnumAction.Eat || enumaction == EnumAction.Drink)
                    {
                        float f15 = ((float)entityplayersp.GetItemInUseCount() - par1) + 1.0F;
                        float f21 = 1.0F - f15 / (float)itemstack.GetMaxItemUseDuration();
                        float f28 = f21;
                        float f31 = 1.0F - f28;
                        f31 = f31 * f31 * f31;
                        f31 = f31 * f31 * f31;
                        f31 = f31 * f31 * f31;
                        float f35 = 1.0F - f31;
                        //GL.Translate(0.0F, MathHelper.Abs(MathHelper.Cos((f15 / 4F) * (float)Math.PI) * 0.1F) * (float)((double)f28 <= 0.20000000000000001D ? 0 : 1), 0.0F);
                        //GL.Translate(f35 * 0.6F, -f35 * 0.5F, 0.0F);
                        //GL.Rotate(f35 * 90F, 0.0F, 1.0F, 0.0F);
                        //GL.Rotate(f35 * 10F, 1.0F, 0.0F, 0.0F);
                        //GL.Rotate(f35 * 30F, 0.0F, 0.0F, 1.0F);
                    }
                }
                else
                {
                    float f10 = entityplayersp.GetSwingProgress(par1);
                    float f16 = MathHelper2.Sin(f10 * (float)Math.PI);
                    float f22 = MathHelper2.Sin(MathHelper2.Sqrt_float(f10) * (float)Math.PI);
                    //GL.Translate(-f22 * 0.4F, MathHelper.Sin(MathHelper.Sqrt_float(f10) * (float)Math.PI * 2.0F) * 0.2F, -f16 * 0.2F);
                }

                //GL.Translate(0.7F * f6, -0.65F * f6 - (1.0F - f) * 0.6F, -0.9F * f6);
                //GL.Rotate(45F, 0.0F, 1.0F, 0.0F);
                //GL.Enable(EnableCap.RescaleNormal);
                float f11 = entityplayersp.GetSwingProgress(par1);
                float f17 = MathHelper2.Sin(f11 * f11 * (float)Math.PI);
                float f23 = MathHelper2.Sin(MathHelper2.Sqrt_float(f11) * (float)Math.PI);
                //GL.Rotate(-f17 * 20F, 0.0F, 1.0F, 0.0F);
                //GL.Rotate(-f23 * 20F, 0.0F, 0.0F, 1.0F);
                //GL.Rotate(-f23 * 80F, 1.0F, 0.0F, 0.0F);
                f11 = 0.4F;
                //GL.Scale(f11, f11, f11);

                if (entityplayersp.GetItemInUseCount() > 0)
                {
                    EnumAction enumaction1 = itemstack.GetItemUseAction();

                    if (enumaction1 == EnumAction.Block)
                    {
                        //GL.Translate(-0.5F, 0.2F, 0.0F);
                        //GL.Rotate(30F, 0.0F, 1.0F, 0.0F);
                        //GL.Rotate(-80F, 1.0F, 0.0F, 0.0F);
                        //GL.Rotate(60F, 0.0F, 1.0F, 0.0F);
                    }
                    else if (enumaction1 == EnumAction.Bow)
                    {
                        //GL.Rotate(-18F, 0.0F, 0.0F, 1.0F);
                        //GL.Rotate(-12F, 0.0F, 1.0F, 0.0F);
                        //GL.Rotate(-8F, 1.0F, 0.0F, 0.0F);
                        //GL.Translate(-0.9F, 0.2F, 0.0F);
                        float f24 = (float)itemstack.GetMaxItemUseDuration() - (((float)entityplayersp.GetItemInUseCount() - par1) + 1.0F);
                        float f29 = f24 / 20F;
                        f29 = (f29 * f29 + f29 * 2.0F) / 3F;

                        if (f29 > 1.0F)
                        {
                            f29 = 1.0F;
                        }

                        if (f29 > 0.1F)
                        {
                            //GL.Translate(0.0F, MathHelper.Sin((f24 - 0.1F) * 1.3F) * 0.01F * (f29 - 0.1F), 0.0F);
                        }

                        //GL.Translate(0.0F, 0.0F, f29 * 0.1F);
                        //GL.Rotate(-335F, 0.0F, 0.0F, 1.0F);
                        //GL.Rotate(-50F, 0.0F, 1.0F, 0.0F);
                        //GL.Translate(0.0F, 0.5F, 0.0F);
                        float f32 = 1.0F + f29 * 0.2F;
                        //GL.Scale(1.0F, 1.0F, f32);
                        //GL.Translate(0.0F, -0.5F, 0.0F);
                        //GL.Rotate(50F, 0.0F, 1.0F, 0.0F);
                        //GL.Rotate(335F, 0.0F, 0.0F, 1.0F);
                    }
                }

                if (itemstack.GetItem().ShouldRotateAroundWhenRendering())
                {
                    //GL.Rotate(180F, 0.0F, 1.0F, 0.0F);
                }

                if (itemstack.GetItem().Func_46058_c())
                {
                    RenderItem(entityplayersp, itemstack, 0);
                    int   i1  = Item.ItemsList[itemstack.ItemID].GetColorFromDamage(itemstack.GetItemDamage(), 1);
                    float f25 = (float)(i1 >> 16 & 0xff) / 255F;
                    float f30 = (float)(i1 >> 8 & 0xff) / 255F;
                    float f33 = (float)(i1 & 0xff) / 255F;
                    //GL.Color4(f3 * f25, f3 * f30, f3 * f33, 1.0F);
                    RenderItem(entityplayersp, itemstack, 1);
                }
                else
                {
                    RenderItem(entityplayersp, itemstack, 0);
                }

                //GL.PopMatrix();
            }
            else
            {
                //GL.PushMatrix();
                //	float f7 = 0.8F;
                float f12 = entityplayersp.GetSwingProgress(par1);
                float f18 = MathHelper2.Sin(f12 * (float)Math.PI);
                float f26 = MathHelper2.Sin(MathHelper2.Sqrt_float(f12) * (float)Math.PI);
                //GL.Translate(-f26 * 0.3F, MathHelper.Sin(MathHelper.Sqrt_float(f12) * (float)Math.PI * 2.0F) * 0.4F, -f18 * 0.4F);
                //GL.Translate(0.8F * f7, -0.75F * f7 - (1.0F - f) * 0.6F, -0.9F * f7);
                //GL.Rotate(45F, 0.0F, 1.0F, 0.0F);
                //GL.Enable(EnableCap.RescaleNormal);
                f12 = entityplayersp.GetSwingProgress(par1);
                f18 = MathHelper2.Sin(f12 * f12 * (float)Math.PI);
                f26 = MathHelper2.Sin(MathHelper2.Sqrt_float(f12) * (float)Math.PI);
                //GL.Rotate(f26 * 70F, 0.0F, 1.0F, 0.0F);
                //GL.Rotate(-f18 * 20F, 0.0F, 0.0F, 1.0F);
                //GL.BindTexture(TextureTarget.Texture2D, Mc.RenderEngineOld.GetTextureForDownloadableImage(Mc.ThePlayer.SkinUrl, Mc.ThePlayer.GetTexture()));
                //GL.Translate(-1F, 3.6F, 3.5F);
                //GL.Rotate(120F, 0.0F, 0.0F, 1.0F);
                //GL.Rotate(200F, 1.0F, 0.0F, 0.0F);
                //GL.Rotate(-135F, 0.0F, 1.0F, 0.0F);
                //GL.Scale(1.0F, 1.0F, 1.0F);
                //GL.Translate(5.6F, 0.0F, 0.0F);
                Render       render       = RenderManager.Instance.GetEntityRenderObject(Mc.ThePlayer);
                RenderPlayer renderplayer = (RenderPlayer)render;
                f26 = 1.0F;
                //GL.Scale(f26, f26, f26);
                renderplayer.DrawFirstPersonHand();
                //GL.PopMatrix();
            }

            //GL.Disable(EnableCap.RescaleNormal);
            RenderHelper.DisableStandardItemLighting();
        }
Beispiel #9
0
        /// <summary>
        /// Draw the background layer for the GuiContainer (everything behind the items)
        /// </summary>
        protected override void DrawGuiContainerBackgroundLayer(float par1, int par2, int par3)
        {
            int i = Mc.RenderEngineOld.GetTexture("/gui/enchant.png");

            //GL.Color4(1.0F, 1.0F, 1.0F, 1.0F);
            Mc.RenderEngineOld.BindTexture(i);
            int j = (Width - XSize) / 2;
            int k = (Height - YSize) / 2;

            DrawTexturedModalRect(j, k, 0, 0, XSize, YSize);
            //GL.PushMatrix();
            //GL.MatrixMode(MatrixMode.Projection);
            //GL.PushMatrix();
            //GL.LoadIdentity();
            ScaledResolution scaledresolution = new ScaledResolution(Mc.GameSettings, Mc.DisplayWidth, Mc.DisplayHeight);

            //GL.Viewport(((scaledresolution.GetScaledWidth() - 320) / 2) * scaledresolution.ScaleFactor, ((scaledresolution.GetScaledHeight() - 240) / 2) * scaledresolution.ScaleFactor, 320 * scaledresolution.ScaleFactor, 240 * scaledresolution.ScaleFactor);
            //GL.Translate(-0.34F, 0.23F, 0.0F);
            Matrix.CreatePerspectiveFieldOfView(90F, 1.333333F, 9F, 80F);
            float f = 1.0F;

            //GL.MatrixMode(MatrixMode.Modelview);
            //GL.LoadIdentity();
            RenderHelper.EnableStandardItemLighting();
            //GL.Translate(0.0F, 3.3F, -16F);
            //GL.Scale(f, f, f);
            float f1 = 5F;

            //GL.Scale(f1, f1, f1);
            //GL.Rotate(180F, 0.0F, 0.0F, 1.0F);
            Mc.RenderEngineOld.BindTexture(Mc.RenderEngineOld.GetTexture("/item/book.png"));
            //GL.Rotate(20F, 1.0F, 0.0F, 0.0F);
            float f2 = Field_40221_n + (Field_40224_m - Field_40221_n) * par1;
            //GL.Translate((1.0F - f2) * 0.2F, (1.0F - f2) * 0.1F, (1.0F - f2) * 0.25F);
            //GL.Rotate(-(1.0F - f2) * 90F - 90F, 0.0F, 1.0F, 0.0F);
            //GL.Rotate(180F, 1.0F, 0.0F, 0.0F);
            float f3 = Field_40225_j + (Field_40229_i - Field_40225_j) * par1 + 0.25F;
            float f4 = Field_40225_j + (Field_40229_i - Field_40225_j) * par1 + 0.75F;

            f3 = (f3 - (float)MathHelper2.Func_40346_b(f3)) * 1.6F - 0.3F;
            f4 = (f4 - (float)MathHelper2.Func_40346_b(f4)) * 1.6F - 0.3F;

            if (f3 < 0.0F)
            {
                f3 = 0.0F;
            }

            if (f4 < 0.0F)
            {
                f4 = 0.0F;
            }

            if (f3 > 1.0F)
            {
                f3 = 1.0F;
            }

            if (f4 > 1.0F)
            {
                f4 = 1.0F;
            }

            //GL.Enable(EnableCap.RescaleNormal);
            BookModel.Render(null, 0.0F, f3, f4, f2, 0.0F, 0.0625F);
            //GL.Disable(EnableCap.RescaleNormal);
            RenderHelper.DisableStandardItemLighting();
            //GL.MatrixMode(MatrixMode.Projection);
            //GL.Viewport(0, 0, Mc.DisplayWidth, Mc.DisplayHeight);
            //GL.PopMatrix();
            //GL.MatrixMode(MatrixMode.Modelview);
            //GL.PopMatrix();
            RenderHelper.DisableStandardItemLighting();
            //GL.Color4(1.0F, 1.0F, 1.0F, 1.0F);
            Mc.RenderEngineOld.BindTexture(i);
            EnchantmentNameParts.Instance.SetRandSeed(ContainerEnchantment.NameSeed);

            for (int l = 0; l < 3; l++)
            {
                string s = EnchantmentNameParts.Instance.GenerateRandomEnchantName();
                ZLevel = 0.0F;
                Mc.RenderEngineOld.BindTexture(i);
                int i1 = ContainerEnchantment.EnchantLevels[l];
                //GL.Color4(1.0F, 1.0F, 1.0F, 1.0F);

                if (i1 == 0)
                {
                    DrawTexturedModalRect(j + 60, k + 14 + 19 * l, 0, 185, 108, 19);
                    continue;
                }

                string          s1           = (new StringBuilder()).Append("").Append(i1).ToString();
                FontRendererOld fontrenderer = Mc.StandardGalacticFontRenderer;
                int             j1           = 0x685e4a;

                if (Mc.ThePlayer.ExperienceLevel < i1 && !Mc.ThePlayer.Capabilities.IsCreativeMode)
                {
                    DrawTexturedModalRect(j + 60, k + 14 + 19 * l, 0, 185, 108, 19);
                    fontrenderer.DrawSplitString(s, j + 62, k + 16 + 19 * l, 104, (j1 & 0xfefefe) >> 1);
                    fontrenderer = Mc.FontRendererOld;
                    j1           = 0x407f10;
                    fontrenderer.DrawStringWithShadow(s1, (j + 62 + 104) - fontrenderer.GetStringWidth(s1), k + 16 + 19 * l + 7, j1);
                    continue;
                }

                int k1 = par2 - (j + 60);
                int l1 = par3 - (k + 14 + 19 * l);

                if (k1 >= 0 && l1 >= 0 && k1 < 108 && l1 < 19)
                {
                    DrawTexturedModalRect(j + 60, k + 14 + 19 * l, 0, 204, 108, 19);
                    j1 = 0xffff80;
                }
                else
                {
                    DrawTexturedModalRect(j + 60, k + 14 + 19 * l, 0, 166, 108, 19);
                }

                fontrenderer.DrawSplitString(s, j + 62, k + 16 + 19 * l, 104, j1);
                fontrenderer = Mc.FontRendererOld;
                j1           = 0x80ff20;
                fontrenderer.DrawStringWithShadow(s1, (j + 62 + 104) - fontrenderer.GetStringWidth(s1), k + 16 + 19 * l + 7, j1);
            }
        }
        /// <summary>
        /// Draws the screen and all the components in it.
        /// </summary>
        public override void DrawScreen(int par1, int par2, float par3)
        {
            DrawDefaultBackground();
            int i = GuiLeft;
            int j = GuiTop;

            DrawGuiContainerBackgroundLayer(par3, par1, par2);
            RenderHelper.EnableGUIStandardItemLighting();
            //GL.PushMatrix();
            //GL.Translate(i, j, 0.0F);
            //GL.Color4(1.0F, 1.0F, 1.0F, 1.0F);
            //GL.Enable(EnableCap.RescaleNormal);
            Slot slot = null;
            int  k    = 240;
            int  i1   = 240;

            OpenGlHelper.SetLightmapTextureCoords(OpenGlHelper.LightmapTexUnit, (float)k / 1.0F, (float)i1 / 1.0F);
            //GL.Color4(1.0F, 1.0F, 1.0F, 1.0F);

            for (int l = 0; l < InventorySlots.InventorySlots.Count; l++)
            {
                Slot slot1 = (Slot)InventorySlots.InventorySlots[l];
                DrawSlotInventory(slot1);

                if (IsMouseOverSlot(slot1, par1, par2))
                {
                    slot = slot1;
                    //GL.Disable(EnableCap.Lighting);
                    //GL.Disable(EnableCap.DepthTest);
                    int j1 = slot1.XDisplayPosition;
                    int k1 = slot1.YDisplayPosition;
                    DrawGradientRect(j1, k1, j1 + 16, k1 + 16, 0x80fffff, 0x80fffff);
                    //GL.Enable(EnableCap.Lighting);
                    //GL.Enable(EnableCap.DepthTest);
                }
            }

            DrawGuiContainerForegroundLayer();
            InventoryPlayer inventoryplayer = Mc.ThePlayer.Inventory;

            if (inventoryplayer.GetItemStack() != null)
            {
                //GL.Translate(0.0F, 0.0F, 32F);
                ZLevel = 200F;
                ItemRenderer.ZLevel = 200F;
                ItemRenderer.RenderItemIntoGUI(FontRenderer, Mc.RenderEngineOld, inventoryplayer.GetItemStack(), par1 - i - 8, par2 - j - 8);
                ItemRenderer.RenderItemOverlayIntoGUI(FontRenderer, Mc.RenderEngineOld, inventoryplayer.GetItemStack(), par1 - i - 8, par2 - j - 8);
                ZLevel = 0.0F;
                ItemRenderer.ZLevel = 0.0F;
            }

            //GL.Disable(EnableCap.RescaleNormal);
            RenderHelper.DisableStandardItemLighting();
            //GL.Disable(EnableCap.Lighting);
            //GL.Disable(EnableCap.DepthTest);

            if (inventoryplayer.GetItemStack() == null && slot != null && slot.GetHasStack())
            {
                ItemStack     itemstack = slot.GetStack();
                List <string> list      = itemstack.GetItemNameandInformation();

                if (list.Count > 0)
                {
                    int l1 = 0;

                    for (int i2 = 0; i2 < list.Count; i2++)
                    {
                        int k2 = FontRenderer.GetStringWidth(list[i2]);

                        if (k2 > l1)
                        {
                            l1 = k2;
                        }
                    }

                    int j2 = (par1 - i) + 12;
                    int l2 = par2 - j - 12;
                    int i3 = l1;
                    int j3 = 8;

                    if (list.Count > 1)
                    {
                        j3 += 2 + (list.Count - 1) * 10;
                    }

                    ZLevel = 300F;
                    ItemRenderer.ZLevel = 300F;
                    int k3 = 0xf010001;
                    DrawGradientRect(j2 - 3, l2 - 4, j2 + i3 + 3, l2 - 3, k3, k3);
                    DrawGradientRect(j2 - 3, l2 + j3 + 3, j2 + i3 + 3, l2 + j3 + 4, k3, k3);
                    DrawGradientRect(j2 - 3, l2 - 3, j2 + i3 + 3, l2 + j3 + 3, k3, k3);
                    DrawGradientRect(j2 - 4, l2 - 3, j2 - 3, l2 + j3 + 3, k3, k3);
                    DrawGradientRect(j2 + i3 + 3, l2 - 3, j2 + i3 + 4, l2 + j3 + 3, k3, k3);
                    int l3 = 0x505000ff;
                    int i4 = (l3 & 0xfefefe) >> 1 | l3 & 0xff00000;
                    DrawGradientRect(j2 - 3, (l2 - 3) + 1, (j2 - 3) + 1, (l2 + j3 + 3) - 1, l3, i4);
                    DrawGradientRect(j2 + i3 + 2, (l2 - 3) + 1, j2 + i3 + 3, (l2 + j3 + 3) - 1, l3, i4);
                    DrawGradientRect(j2 - 3, l2 - 3, j2 + i3 + 3, (l2 - 3) + 1, l3, l3);
                    DrawGradientRect(j2 - 3, l2 + j3 + 2, j2 + i3 + 3, l2 + j3 + 3, i4, i4);

                    for (int j4 = 0; j4 < list.Count; j4++)
                    {
                        string s = list[j4];

                        if (j4 == 0)
                        {
                            //s = (new StringBuilder()).Append((char)0xa7).Append(int.ToHexString(itemstack.GetRarity().NameColor)).Append(s).ToString();
                        }
                        else
                        {
                            s = (new StringBuilder()).Append((char)0xa7).Append(s).ToString();
                        }

                        FontRenderer.DrawStringWithShadow(s, j2, l2, -1);

                        if (j4 == 0)
                        {
                            l2 += 2;
                        }

                        l2 += 10;
                    }

                    ZLevel = 0.0F;
                    ItemRenderer.ZLevel = 0.0F;
                }
            }

            //GL.PopMatrix();
            base.DrawScreen(par1, par2, par3);
            //GL.Enable(EnableCap.Lighting);
            //GL.Enable(EnableCap.DepthTest);
        }
Beispiel #11
0
        /// <summary>
        /// Render the ingame overlay with quick icon bar, ...
        /// </summary>
        public virtual void RenderGameOverlay(float par1, bool par2, int par3, int par4)
        {
            ScaledResolution scaledresolution = new ScaledResolution(mc.GameSettings, mc.DisplayWidth, mc.DisplayHeight);
            int          i            = scaledresolution.GetScaledWidth();
            int          j            = scaledresolution.GetScaledHeight();
            FontRenderer fontrenderer = mc.FontRenderer;

            mc.EntityRenderer.SetupOverlayRendering();
            //GL.Enable(EnableCap.Blend);

            if (Minecraft.IsFancyGraphicsEnabled())
            {
                RenderVignette(mc.ThePlayer.GetBrightness(par1), i, j);
            }
            else
            {
                //GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
            }

            ItemStack itemstack = mc.ThePlayer.Inventory.ArmorItemInSlot(3);

            if (mc.GameSettings.ThirdPersonView == 0 && itemstack != null && itemstack.ItemID == Block.Pumpkin.BlockID)
            {
                RenderPumpkinBlur(i, j);
            }

            if (!mc.ThePlayer.IsPotionActive(Potion.Confusion))
            {
                float f = mc.ThePlayer.PrevTimeInPortal + (mc.ThePlayer.TimeInPortal - mc.ThePlayer.PrevTimeInPortal) * par1;

                if (f > 0.0F)
                {
                    RenderPortalOverlay(f, i, j);
                }
            }

            if (!mc.PlayerController.Func_35643_e())
            {
                //GL.Color4(1.0F, 1.0F, 1.0F, 1.0F);
                //GL.BindTexture(TextureTarget.Texture2D, mc.RenderEngineOld.GetTexture("/gui/gui.png"));
                InventoryPlayer inventoryplayer = mc.ThePlayer.Inventory;
                ZLevel = -90F;
                DrawTexturedModalRect(i / 2 - 91, j - 22, 0, 0, 182, 22);
                DrawTexturedModalRect((i / 2 - 91 - 1) + inventoryplayer.CurrentItem * 20, j - 22 - 1, 0, 22, 24, 22);
                //GL.BindTexture(TextureTarget.Texture2D, mc.RenderEngineOld.GetTexture("/gui/icons.png"));
                //GL.Enable(EnableCap.Blend);
                //GL.BlendFunc(BlendingFactorSrc.OneMinusDstColor, BlendingFactorDest.OneMinusSrcColor);
                DrawTexturedModalRect(i / 2 - 7, j / 2 - 7, 0, 0, 16, 16);
                //GL.Disable(EnableCap.Blend);
                bool flag = (mc.ThePlayer.HeartsLife / 3) % 2 == 1;

                if (mc.ThePlayer.HeartsLife < 10)
                {
                    flag = false;
                }

                int i1 = mc.ThePlayer.GetHealth();
                int i2 = mc.ThePlayer.PrevHealth;
                rand.SetSeed(updateCounter * 0x4c627);
                bool      flag2     = false;
                FoodStats foodstats = mc.ThePlayer.GetFoodStats();
                int       j4        = foodstats.GetFoodLevel();
                int       l4        = foodstats.GetPrevFoodLevel();
                RenderBossHealth();

                if (mc.PlayerController.ShouldDrawHUD())
                {
                    int j5 = i / 2 - 91;
                    int i6 = i / 2 + 91;
                    int l6 = mc.ThePlayer.XpBarCap();

                    if (l6 > 0)
                    {
                        int c  = 0xb6;
                        int j8 = (int)(mc.ThePlayer.Experience * (float)(c + 1));
                        int i9 = (j - 32) + 3;
                        DrawTexturedModalRect(j5, i9, 0, 64, c, 5);

                        if (j8 > 0)
                        {
                            DrawTexturedModalRect(j5, i9, 0, 69, j8, 5);
                        }
                    }

                    int k7  = j - 39;
                    int k8  = k7 - 10;
                    int j9  = mc.ThePlayer.GetTotalArmorValue();
                    int i10 = -1;

                    if (mc.ThePlayer.IsPotionActive(Potion.Regeneration))
                    {
                        i10 = updateCounter % 25;
                    }

                    for (int j10 = 0; j10 < 10; j10++)
                    {
                        if (j9 > 0)
                        {
                            int i11 = j5 + j10 * 8;

                            if (j10 * 2 + 1 < j9)
                            {
                                DrawTexturedModalRect(i11, k8, 34, 9, 9, 9);
                            }

                            if (j10 * 2 + 1 == j9)
                            {
                                DrawTexturedModalRect(i11, k8, 25, 9, 9, 9);
                            }

                            if (j10 * 2 + 1 > j9)
                            {
                                DrawTexturedModalRect(i11, k8, 16, 9, 9, 9);
                            }
                        }

                        int j11 = 16;

                        if (mc.ThePlayer.IsPotionActive(Potion.Poison))
                        {
                            j11 += 36;
                        }

                        int i12 = 0;

                        if (flag)
                        {
                            i12 = 1;
                        }

                        int l12 = j5 + j10 * 8;
                        int j13 = k7;

                        if (i1 <= 4)
                        {
                            j13 += rand.Next(2);
                        }

                        if (j10 == i10)
                        {
                            j13 -= 2;
                        }

                        byte byte3 = 0;

                        if (mc.TheWorld.GetWorldInfo().IsHardcoreModeEnabled())
                        {
                            byte3 = 5;
                        }

                        DrawTexturedModalRect(l12, j13, 16 + i12 * 9, 9 * byte3, 9, 9);

                        if (flag)
                        {
                            if (j10 * 2 + 1 < i2)
                            {
                                DrawTexturedModalRect(l12, j13, j11 + 54, 9 * byte3, 9, 9);
                            }

                            if (j10 * 2 + 1 == i2)
                            {
                                DrawTexturedModalRect(l12, j13, j11 + 63, 9 * byte3, 9, 9);
                            }
                        }

                        if (j10 * 2 + 1 < i1)
                        {
                            DrawTexturedModalRect(l12, j13, j11 + 36, 9 * byte3, 9, 9);
                        }

                        if (j10 * 2 + 1 == i1)
                        {
                            DrawTexturedModalRect(l12, j13, j11 + 45, 9 * byte3, 9, 9);
                        }
                    }

                    for (int k10 = 0; k10 < 10; k10++)
                    {
                        int  k11   = k7;
                        int  j12   = 16;
                        byte byte2 = 0;

                        if (mc.ThePlayer.IsPotionActive(Potion.Hunger))
                        {
                            j12  += 36;
                            byte2 = 13;
                        }

                        if (mc.ThePlayer.GetFoodStats().GetSaturationLevel() <= 0.0F && updateCounter % (j4 * 3 + 1) == 0)
                        {
                            k11 += rand.Next(3) - 1;
                        }

                        if (flag2)
                        {
                            byte2 = 1;
                        }

                        int k13 = i6 - k10 * 8 - 9;
                        DrawTexturedModalRect(k13, k11, 16 + byte2 * 9, 27, 9, 9);

                        if (flag2)
                        {
                            if (k10 * 2 + 1 < l4)
                            {
                                DrawTexturedModalRect(k13, k11, j12 + 54, 27, 9, 9);
                            }

                            if (k10 * 2 + 1 == l4)
                            {
                                DrawTexturedModalRect(k13, k11, j12 + 63, 27, 9, 9);
                            }
                        }

                        if (k10 * 2 + 1 < j4)
                        {
                            DrawTexturedModalRect(k13, k11, j12 + 36, 27, 9, 9);
                        }

                        if (k10 * 2 + 1 == j4)
                        {
                            DrawTexturedModalRect(k13, k11, j12 + 45, 27, 9, 9);
                        }
                    }

                    if (mc.ThePlayer.IsInsideOfMaterial(Material.Water))
                    {
                        int l10 = mc.ThePlayer.GetAir();
                        int l11 = (int)Math.Ceiling(((double)(l10 - 2) * 10D) / 300D);
                        int k12 = (int)Math.Ceiling(((double)l10 * 10D) / 300D) - l11;

                        for (int i13 = 0; i13 < l11 + k12; i13++)
                        {
                            if (i13 < l11)
                            {
                                DrawTexturedModalRect(i6 - i13 * 8 - 9, k8, 16, 18, 9, 9);
                            }
                            else
                            {
                                DrawTexturedModalRect(i6 - i13 * 8 - 9, k8, 25, 18, 9, 9);
                            }
                        }
                    }
                }

                //GL.Disable(EnableCap.Blend);
                //GL.Enable(EnableCap.RescaleNormal);
                RenderHelper.EnableGUIStandardItemLighting();

                for (int k5 = 0; k5 < 9; k5++)
                {
                    int j6 = (i / 2 - 90) + k5 * 20 + 2;
                    int i7 = j - 16 - 3;
                    RenderInventorySlot(k5, j6, i7, par1);
                }

                RenderHelper.DisableStandardItemLighting();
                //GL.Disable(EnableCap.RescaleNormal);
            }

            if (mc.ThePlayer.GetSleepTimer() > 0)
            {
                //GL.Disable(EnableCap.DepthTest);
                //GL.Disable(EnableCap.AlphaTest);
                int   k  = mc.ThePlayer.GetSleepTimer();
                float f1 = (float)k / 100F;

                if (f1 > 1.0F)
                {
                    f1 = 1.0F - (float)(k - 100) / 10F;
                }

                int j1 = (int)(220F * f1) << 24 | 0x101020;
                DrawRect(0, 0, i, j, j1);
                //GL.Enable(EnableCap.AlphaTest);
                //GL.Enable(EnableCap.DepthTest);
            }

            if (mc.PlayerController.Func_35642_f() && mc.ThePlayer.ExperienceLevel > 0)
            {
                bool   flag1 = false;
                int    k1    = flag1 ? 0xffffff : 0x80ff20;
                String s     = (new StringBuilder()).Append("").Append(mc.ThePlayer.ExperienceLevel).ToString();
                int    i3    = (i - fontrenderer.GetStringWidth(s)) / 2;
                int    k3    = j - 31 - 4;
                fontrenderer.DrawString(s, i3 + 1, k3, 0);
                fontrenderer.DrawString(s, i3 - 1, k3, 0);
                fontrenderer.DrawString(s, i3, k3 + 1, 0);
                fontrenderer.DrawString(s, i3, k3 - 1, 0);
                fontrenderer.DrawString(s, i3, k3, k1);
            }

            if (mc.GameSettings.ShowDebugInfo)
            {
                //GL.PushMatrix();

                if (Minecraft.HasPaidCheckTime > 0L)
                {
                    //GL.Translate(0.0F, 32F, 0.0F);
                }

                fontrenderer.DrawStringWithShadow((new StringBuilder()).Append("Minecraft 1.2.5 (").Append(mc.Debug).Append(")").ToString(), 2, 2, 0xffffff);
                fontrenderer.DrawStringWithShadow(mc.DebugInfoRenders(), 2, 12, 0xffffff);
                fontrenderer.DrawStringWithShadow(mc.GetEntityDebug(), 2, 22, 0xffffff);
                fontrenderer.DrawStringWithShadow(mc.DebugInfoEntities(), 2, 32, 0xffffff);
                fontrenderer.DrawStringWithShadow(mc.GetWorldProviderName(), 2, 42, 0xffffff);
                //long l = Runtime.getRuntime().maxMemory();
                long l2 = GC.GetTotalMemory(false);
                //long l3 = Runtime.getRuntime().freeMemory();
                //long l5 = l2 - l3;
                //string s1 = (new StringBuilder()).Append("Used memory: ").Append((l5 * 100L) / l).Append("% (").Append(l5 / 1024L / 1024L).Append("MB) of ").Append(l / 1024L / 1024L).Append("MB").ToString();
                //DrawString(fontrenderer, s1, i - fontrenderer.GetStringWidth(s1) - 2, 2, 0xe0e0e0);
                //s1 = (new StringBuilder()).Append("Allocated memory: ").Append((l2 * 100L) / l).Append("% (").Append(l2 / 1024L / 1024L).Append("MB)").ToString();
                //DrawString(fontrenderer, s1, i - fontrenderer.GetStringWidth(s1) - 2, 12, 0xe0e0e0);
                DrawString(fontrenderer, (new StringBuilder()).Append("x: ").Append(mc.ThePlayer.PosX).ToString(), 2, 64, 0xe0e0e0);
                DrawString(fontrenderer, (new StringBuilder()).Append("y: ").Append(mc.ThePlayer.PosY).ToString(), 2, 72, 0xe0e0e0);
                DrawString(fontrenderer, (new StringBuilder()).Append("z: ").Append(mc.ThePlayer.PosZ).ToString(), 2, 80, 0xe0e0e0);
                DrawString(fontrenderer, (new StringBuilder()).Append("f: ").Append((int)Math.Floor((double)((mc.ThePlayer.RotationYaw * 4F) / 360F) + 0.5D) & 3).ToString(), 2, 88, 0xe0e0e0);
                int l7 = (int)Math.Floor(mc.ThePlayer.PosX);
                int l8 = (int)Math.Floor(mc.ThePlayer.PosY);
                int k9 = (int)Math.Floor(mc.ThePlayer.PosZ);

                if (mc.TheWorld != null && mc.TheWorld.BlockExists(l7, l8, k9))
                {
                    Chunk chunk = mc.TheWorld.GetChunkFromBlockCoords(l7, k9);
                    DrawString(fontrenderer, (new StringBuilder()).Append("lc: ").Append(chunk.GetTopFilledSegment() + 15).Append(" b: ").Append(chunk.Func_48490_a(l7 & 0xf, k9 & 0xf, mc.TheWorld.GetWorldChunkManager()).BiomeName).Append(" bl: ").Append(chunk.GetSavedLightValue(SkyBlock.Block, l7 & 0xf, l8, k9 & 0xf)).Append(" sl: ").Append(chunk.GetSavedLightValue(SkyBlock.Sky, l7 & 0xf, l8, k9 & 0xf)).Append(" rl: ").Append(chunk.GetBlockLightValue(l7 & 0xf, l8, k9 & 0xf, 0)).ToString(), 2, 96, 0xe0e0e0);
                }

                if (!mc.TheWorld.IsRemote)
                {
                    DrawString(fontrenderer, (new StringBuilder()).Append("Seed: ").Append(mc.TheWorld.GetSeed()).ToString(), 2, 112, 0xe0e0e0);
                }

                //GL.PopMatrix();
            }

            if (recordPlayingUpFor > 0)
            {
                float f2 = (float)recordPlayingUpFor - par1;
                int   l1 = (int)((f2 * 256F) / 20F);

                if (l1 > 255)
                {
                    l1 = 255;
                }

                if (l1 > 0)
                {
                    //GL.PushMatrix();
                    //GL.Translate(i / 2, j - 48, 0.0F);
                    //GL.Enable(EnableCap.Blend);
                    //GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
                    int j2 = 0xffffff;

                    /*
                     * if (recordIsPlaying)
                     * {
                     *  j2 = Color.HSBtoRGB(f2 / 50F, 0.7F, 0.6F) & 0xffffff;
                     * }
                     */
                    fontrenderer.DrawString(recordPlaying, -(int)fontrenderer.GetStringWidth(recordPlaying) / 2, -4, j2 + (l1 << 24));
                    //GL.Disable(EnableCap.Blend);
                    //GL.PopMatrix();
                }
            }

            //GL.Enable(EnableCap.Blend);
            //GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
            //GL.Disable(EnableCap.AlphaTest);
            //GL.PushMatrix();
            //GL.Translate(0.0F, j - 48, 0.0F);
            Func_50010_a(fontrenderer);
            //GL.PopMatrix();

            if ((mc.ThePlayer is EntityClientPlayerMP) && mc.GameSettings.KeyBindPlayerList.Pressed)
            {
                NetClientHandler     netclienthandler = ((EntityClientPlayerMP)mc.ThePlayer).SendQueue;
                List <GuiPlayerInfo> list             = netclienthandler.PlayerNames;
                int k2 = netclienthandler.CurrentServerMaxPlayers;
                int j3 = k2;
                int i4 = 1;

                for (; j3 > 20; j3 = ((k2 + i4) - 1) / i4)
                {
                    i4++;
                }

                int k4 = 300 / i4;

                if (k4 > 150)
                {
                    k4 = 150;
                }

                int  i5    = (i - i4 * k4) / 2;
                byte byte0 = 10;
                DrawRect(i5 - 1, byte0 - 1, i5 + k4 * i4, byte0 + 9 * j3, 0x8000000);

                for (int k6 = 0; k6 < k2; k6++)
                {
                    int j7 = i5 + (k6 % i4) * k4;
                    int i8 = byte0 + (k6 / i4) * 9;
                    DrawRect(j7, i8, (j7 + k4) - 1, i8 + 8, 0x20ffffff);
                    //GL.Color4(1.0F, 1.0F, 1.0F, 1.0F);
                    //GL.Enable(EnableCap.AlphaTest);

                    if (k6 >= list.Count)
                    {
                        continue;
                    }

                    GuiPlayerInfo guiplayerinfo = (GuiPlayerInfo)list[k6];
                    fontrenderer.DrawStringWithShadow(guiplayerinfo.Name, j7, i8, 0xffffff);
                    mc.RenderEngineOld.BindTexture(mc.RenderEngineOld.GetTexture("/gui/icons.png"));
                    int  l9    = 0;
                    byte byte1 = 0;

                    if (guiplayerinfo.ResponseTime < 0)
                    {
                        byte1 = 5;
                    }
                    else if (guiplayerinfo.ResponseTime < 150)
                    {
                        byte1 = 0;
                    }
                    else if (guiplayerinfo.ResponseTime < 300)
                    {
                        byte1 = 1;
                    }
                    else if (guiplayerinfo.ResponseTime < 600)
                    {
                        byte1 = 2;
                    }
                    else if (guiplayerinfo.ResponseTime < 1000)
                    {
                        byte1 = 3;
                    }
                    else
                    {
                        byte1 = 4;
                    }

                    ZLevel += 100F;
                    DrawTexturedModalRect((j7 + k4) - 12, i8, 0 + l9 * 10, 176 + byte1 * 8, 10, 8);
                    ZLevel -= 100F;
                }
            }

            //GL.Color4(1.0F, 1.0F, 1.0F, 1.0F);
            //GL.Disable(EnableCap.Lighting);
            //GL.Enable(EnableCap.AlphaTest);
        }