/// <summary>
        /// The render method used in RenderBoat that renders the boat model.
        /// </summary>
        public virtual void DoRenderBoat(EntityBoat par1EntityBoat, double par2, double par4, double par6, float par8, float par9)
        {
            //GL.PushMatrix();
            //GL.Translate((float)par2, (float)par4, (float)par6);
            //GL.Rotate(180F - par8, 0.0F, 1.0F, 0.0F);
            float f  = (float)par1EntityBoat.GetTimeSinceHit() - par9;
            float f1 = (float)par1EntityBoat.GetDamageTaken() - par9;

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

            if (f > 0.0F)
            {
                //GL.Rotate(((MathHelper.Sin(f) * f * f1) / 10F) * (float)par1EntityBoat.GetForwardDirection(), 1.0F, 0.0F, 0.0F);
            }

            LoadTexture("/terrain.png");
            float f2 = 0.75F;

            //GL.Scale(f2, f2, f2);
            //GL.Scale(1.0F / f2, 1.0F / f2, 1.0F / f2);
            LoadTexture("/item/boat.png");
            //GL.Scale(-1F, -1F, 1.0F);
            ModelBoat.Render(par1EntityBoat, 0.0F, 0.0F, -0.1F, 0.0F, 0.0F, 0.0625F);
            //GL.PopMatrix();
        }
        public virtual void Func_41035_a(EntityEnderCrystal par1EntityEnderCrystal, double par2, double par4, double par6, float par8, float par9)
        {
            if (Field_41037_a != 1)
            {
                Field_41036_b = new ModelEnderCrystal(0.0F);
                Field_41037_a = 1;
            }

            float f = (float)par1EntityEnderCrystal.InnerRotation + par9;

            //GL.PushMatrix();
            //GL.Translate((float)par2, (float)par4, (float)par6);
            LoadTexture("/mob/enderdragon/crystal.png");
            float f1 = MathHelper2.Sin(f * 0.2F) / 2.0F + 0.5F;

            f1 = f1 * f1 + f1;
            Field_41036_b.Render(par1EntityEnderCrystal, 0.0F, f * 3F, f1 * 0.2F, 0.0F, 0.0F, 0.0625F);
            //GL.PopMatrix();
        }
Beispiel #3
0
        public virtual void DoRenderLiving(EntityLiving par1EntityLiving, double par2, double par4, double par6, float par8, float par9)
        {
            //GL.PushMatrix();
            //GL.Disable(EnableCap.CullFace);
            MainModel.OnGround = RenderSwingProgress(par1EntityLiving, par9);

            if (RenderPassModel != null)
            {
                RenderPassModel.OnGround = MainModel.OnGround;
            }

            MainModel.IsRiding = par1EntityLiving.IsRiding();

            if (RenderPassModel != null)
            {
                RenderPassModel.IsRiding = MainModel.IsRiding;
            }

            MainModel.IsChild = par1EntityLiving.IsChild();

            if (RenderPassModel != null)
            {
                RenderPassModel.IsChild = MainModel.IsChild;
            }

            try
            {
                float f  = Func_48418_a(par1EntityLiving.PrevRenderYawOffset, par1EntityLiving.RenderYawOffset, par9);
                float f1 = Func_48418_a(par1EntityLiving.PrevRotationYawHead, par1EntityLiving.RotationYawHead, par9);
                float f2 = par1EntityLiving.PrevRotationPitch + (par1EntityLiving.RotationPitch - par1EntityLiving.PrevRotationPitch) * par9;
                RenderLivingAt(par1EntityLiving, par2, par4, par6);
                float f3 = HandleRotationFloat(par1EntityLiving, par9);
                RotateCorpse(par1EntityLiving, f3, f, par9);
                float f4 = 0.0625F;
                //GL.Enable(EnableCap.RescaleNormal);
                //GL.Scale(-1F, -1F, 1.0F);
                PreRenderCallback(par1EntityLiving, par9);
                //GL.Translate(0.0F, -24F * f4 - 0.0078125F, 0.0F);
                float f5 = par1EntityLiving.Field_705_Q + (par1EntityLiving.Field_704_R - par1EntityLiving.Field_705_Q) * par9;
                float f6 = par1EntityLiving.Field_703_S - par1EntityLiving.Field_704_R * (1.0F - par9);

                if (par1EntityLiving.IsChild())
                {
                    f6 *= 3F;
                }

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

                //GL.Enable(EnableCap.AlphaTest);
                MainModel.SetLivingAnimations(par1EntityLiving, f6, f5, par9);
                RenderModel(par1EntityLiving, f6, f5, f3, f1 - f, f2, f4);

                for (int i = 0; i < 4; i++)
                {
                    int j = ShouldRenderPass(par1EntityLiving, i, par9);

                    if (j <= 0)
                    {
                        continue;
                    }

                    RenderPassModel.SetLivingAnimations(par1EntityLiving, f6, f5, par9);
                    RenderPassModel.Render(par1EntityLiving, f6, f5, f3, f1 - f, f2, f4);

                    if (j == 15)
                    {
                        float f8 = (float)par1EntityLiving.TicksExisted + par9;
                        LoadTexture("%blur%/misc/glint.png");
                        //GL.Enable(EnableCap.Blend);
                        float f10 = 0.5F;
                        //GL.Color4(f10, f10, f10, 1.0F);
                        //GL.DepthFunc(DepthFunction.Equal);
                        //GL.DepthMask(false);

                        for (int i1 = 0; i1 < 2; i1++)
                        {
                            //GL.Disable(EnableCap.Lighting);
                            float f13 = 0.76F;
                            //GL.Color4(0.5F * f13, 0.25F * f13, 0.8F * f13, 1.0F);
                            //GL.BlendFunc(BlendingFactorSrc.One, BlendingFactorDest.One);
                            //GL.MatrixMode(MatrixMode.Texture);
                            //GL.LoadIdentity();
                            float f15 = f8 * (0.001F + (float)i1 * 0.003F) * 20F;
                            float f16 = 0.3333333F;
                            //GL.Scale(f16, f16, f16);
                            //GL.Rotate(30F - (float)i1 * 60F, 0.0F, 0.0F, 1.0F);
                            //GL.Translate(0.0F, f15, 0.0F);
                            //GL.MatrixMode(MatrixMode.Modelview);
                            RenderPassModel.Render(par1EntityLiving, f6, f5, f3, f1 - f, f2, f4);
                        }

                        //GL.Color4(1.0F, 1.0F, 1.0F, 1.0F);
                        //GL.MatrixMode(MatrixMode.Texture);
                        //GL.DepthMask(true);
                        //GL.LoadIdentity();
                        //GL.MatrixMode(MatrixMode.Modelview);
                        //GL.Enable(EnableCap.Lighting);
                        //GL.Disable(EnableCap.Blend);
                        //GL.DepthFunc(DepthFunction.Lequal);
                    }

                    //GL.Disable(EnableCap.Blend);
                    //GL.Enable(EnableCap.AlphaTest);
                }

                RenderEquippedItems(par1EntityLiving, par9);
                float f7 = par1EntityLiving.GetBrightness(par9);
                int   k  = GetColorMultiplier(par1EntityLiving, f7, par9);
                OpenGlHelper.SetActiveTexture(OpenGlHelper.LightmapTexUnit);
                //GL.Disable(EnableCap.Texture2D);
                OpenGlHelper.SetActiveTexture(OpenGlHelper.DefaultTexUnit);

                if ((k >> 24 & 0xff) > 0 || par1EntityLiving.HurtTime > 0 || par1EntityLiving.DeathTime > 0)
                {
                    //GL.Disable(EnableCap.Texture2D);
                    //GL.Disable(EnableCap.AlphaTest);
                    //GL.Enable(EnableCap.Blend);
                    //GL.BlendFunc(BlendingFactorSrc.SrcAlpha, BlendingFactorDest.OneMinusSrcAlpha);
                    //GL.DepthFunc(DepthFunction.Equal);

                    if (par1EntityLiving.HurtTime > 0 || par1EntityLiving.DeathTime > 0)
                    {
                        //GL.Color4(f7, 0.0F, 0.0F, 0.4F);
                        MainModel.Render(par1EntityLiving, f6, f5, f3, f1 - f, f2, f4);

                        for (int l = 0; l < 4; l++)
                        {
                            if (InheritRenderPass(par1EntityLiving, l, par9) >= 0)
                            {
                                //GL.Color4(f7, 0.0F, 0.0F, 0.4F);
                                RenderPassModel.Render(par1EntityLiving, f6, f5, f3, f1 - f, f2, f4);
                            }
                        }
                    }

                    if ((k >> 24 & 0xff) > 0)
                    {
                        float f9  = (float)(k >> 16 & 0xff) / 255F;
                        float f11 = (float)(k >> 8 & 0xff) / 255F;
                        float f12 = (float)(k & 0xff) / 255F;
                        float f14 = (float)(k >> 24 & 0xff) / 255F;
                        //GL.Color4(f9, f11, f12, f14);
                        MainModel.Render(par1EntityLiving, f6, f5, f3, f1 - f, f2, f4);

                        for (int j1 = 0; j1 < 4; j1++)
                        {
                            if (InheritRenderPass(par1EntityLiving, j1, par9) >= 0)
                            {
                                //GL.Color4(f9, f11, f12, f14);
                                RenderPassModel.Render(par1EntityLiving, f6, f5, f3, f1 - f, f2, f4);
                            }
                        }
                    }

                    //GL.DepthFunc(DepthFunction.Lequal);
                    //GL.Disable(EnableCap.Blend);
                    //GL.Enable(EnableCap.AlphaTest);
                    //GL.Enable(EnableCap.Texture2D);
                }

                //GL.Disable(EnableCap.RescaleNormal);
            }
            catch (Exception exception)
            {
                Console.WriteLine(exception.ToString());
                Console.Write(exception.StackTrace);
            }

            OpenGlHelper.SetActiveTexture(OpenGlHelper.LightmapTexUnit);
            //GL.Enable(EnableCap.Texture2D);
            OpenGlHelper.SetActiveTexture(OpenGlHelper.DefaultTexUnit);
            //GL.Enable(EnableCap.CullFace);
            //GL.PopMatrix();
            PassSpecialRender(par1EntityLiving, par2, par4, par6);
        }
        public virtual void Func_152_a(EntityMinecart par1EntityMinecart, double par2, double par4, double par6, float par8, float par9)
        {
            //GL.PushMatrix();
            long l = (long)par1EntityMinecart.EntityId * 0x1d66f537L;

            l = l * l * 0x105cb26d1L + l * 0x181c9L;
            float f  = (((float)(l >> 16 & 7L) + 0.5F) / 8F - 0.5F) * 0.004F;
            float f1 = (((float)(l >> 20 & 7L) + 0.5F) / 8F - 0.5F) * 0.004F;
            float f2 = (((float)(l >> 24 & 7L) + 0.5F) / 8F - 0.5F) * 0.004F;
            //GL.Translate(f, f1, f2);
            double d     = par1EntityMinecart.LastTickPosX + (par1EntityMinecart.PosX - par1EntityMinecart.LastTickPosX) * (double)par9;
            double d1    = par1EntityMinecart.LastTickPosY + (par1EntityMinecart.PosY - par1EntityMinecart.LastTickPosY) * (double)par9;
            double d2    = par1EntityMinecart.LastTickPosZ + (par1EntityMinecart.PosZ - par1EntityMinecart.LastTickPosZ) * (double)par9;
            double d3    = 0.30000001192092896D;
            Vec3D  vec3d = par1EntityMinecart.Func_514_g(d, d1, d2);
            float  f3    = par1EntityMinecart.PrevRotationPitch + (par1EntityMinecart.RotationPitch - par1EntityMinecart.PrevRotationPitch) * par9;

            if (vec3d != null)
            {
                Vec3D vec3d1 = par1EntityMinecart.Func_515_a(d, d1, d2, d3);
                Vec3D vec3d2 = par1EntityMinecart.Func_515_a(d, d1, d2, -d3);

                if (vec3d1 == null)
                {
                    vec3d1 = vec3d;
                }

                if (vec3d2 == null)
                {
                    vec3d2 = vec3d;
                }

                par2 += vec3d.XCoord - d;
                par4 += (vec3d1.YCoord + vec3d2.YCoord) / 2D - d1;
                par6 += vec3d.ZCoord - d2;
                Vec3D vec3d3 = vec3d2.AddVector(-vec3d1.XCoord, -vec3d1.YCoord, -vec3d1.ZCoord);

                if (vec3d3.LengthVector() != 0.0F)
                {
                    vec3d3 = vec3d3.Normalize();
                    par8   = (float)((Math.Atan2(vec3d3.ZCoord, vec3d3.XCoord) * 180D) / Math.PI);
                    f3     = (float)(Math.Atan(vec3d3.YCoord) * 73D);
                }
            }

            //GL.Translate((float)par2, (float)par4, (float)par6);
            //GL.Rotate(180F - par8, 0.0F, 1.0F, 0.0F);
            //GL.Rotate(-f3, 0.0F, 0.0F, 1.0F);
            float f4 = (float)par1EntityMinecart.Func_41023_l() - par9;
            float f5 = (float)par1EntityMinecart.Func_41025_i() - par9;

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

            if (f4 > 0.0F)
            {
                //GL.Rotate(((MathHelper.Sin(f4) * f4 * f5) / 10F) * (float)par1EntityMinecart.Func_41030_m(), 1.0F, 0.0F, 0.0F);
            }

            if (par1EntityMinecart.MinecartType != 0)
            {
                LoadTexture("/terrain.png");
                float f6 = 0.75F;
                //GL.Scale(f6, f6, f6);

                if (par1EntityMinecart.MinecartType == 1)
                {
                    //GL.Translate(-0.5F, 0.0F, 0.5F);
                    //GL.Rotate(90F, 0.0F, 1.0F, 0.0F);
                    (new RenderBlocks()).RenderBlockAsItem(Block.Chest, 0, par1EntityMinecart.GetBrightness(par9));
                    //GL.Rotate(-90F, 0.0F, 1.0F, 0.0F);
                    //GL.Translate(0.5F, 0.0F, -0.5F);
                    //GL.Color4(1.0F, 1.0F, 1.0F, 1.0F);
                }
                else if (par1EntityMinecart.MinecartType == 2)
                {
                    //GL.Translate(0.0F, 0.3125F, 0.0F);
                    //GL.Rotate(90F, 0.0F, 1.0F, 0.0F);
                    (new RenderBlocks()).RenderBlockAsItem(Block.StoneOvenIdle, 0, par1EntityMinecart.GetBrightness(par9));
                    //GL.Rotate(-90F, 0.0F, 1.0F, 0.0F);
                    //GL.Translate(0.0F, -0.3125F, 0.0F);
                    //GL.Color4(1.0F, 1.0F, 1.0F, 1.0F);
                }

                //GL.Scale(1.0F / f6, 1.0F / f6, 1.0F / f6);
            }

            LoadTexture("/item/cart.png");
            //GL.Scale(-1F, -1F, 1.0F);
            ModelMinecart.Render(par1EntityMinecart, 0.0F, 0.0F, -0.1F, 0.0F, 0.0F, 0.0625F);
            //GL.PopMatrix();
        }