/// <summary>
        /// Sets the models various rotation angles then renders the model.
        /// </summary>
        public override void Render(Entity par1Entity, float par2, float par3, float par4, float par5, float par6, float par7)
        {
            SetRotationAngles(par2, par3, par4, par5, par6, par7);

            if (IsChild)
            {
                float f = 2.0F;
                //GL.PushMatrix();
                //GL.Translate(0.0F, 5F * par7, 2.0F * par7);
                Head.Render(par7);
                Bill.Render(par7);
                Chin.Render(par7);
                //GL.PopMatrix();
                //GL.PushMatrix();
                //GL.Scale(1.0F / f, 1.0F / f, 1.0F / f);
                //GL.Translate(0.0F, 24F * par7, 0.0F);
                Body.Render(par7);
                RightLeg.Render(par7);
                LeftLeg.Render(par7);
                RightWing.Render(par7);
                LeftWing.Render(par7);
                //GL.PopMatrix();
            }
            else
            {
                Head.Render(par7);
                Bill.Render(par7);
                Chin.Render(par7);
                Body.Render(par7);
                RightLeg.Render(par7);
                LeftLeg.Render(par7);
                RightWing.Render(par7);
                LeftWing.Render(par7);
            }
        }
        /// <summary>
        /// Sets the models various rotation angles then renders the model.
        /// </summary>
        public override void Render(Entity par1Entity, float par2, float par3, float par4, float par5, float par6, float par7)
        {
            SetRotationAngles(par2, par3, par4, par5, par6, par7);

            if (IsChild)
            {
                float f = 2.0F;
                //GL.PushMatrix();
                //GL.Translate(0.0F, Field_40331_g * par7, Field_40332_n * par7);
                Head.Render(par7);
                //GL.PopMatrix();
                //GL.PushMatrix();
                //GL.Scale(1.0F / f, 1.0F / f, 1.0F / f);
                //GL.Translate(0.0F, 24F * par7, 0.0F);
                Body.Render(par7);
                Leg1.Render(par7);
                Leg2.Render(par7);
                Leg3.Render(par7);
                Leg4.Render(par7);
                //GL.PopMatrix();
            }
            else
            {
                Head.Render(par7);
                Body.Render(par7);
                Leg1.Render(par7);
                Leg2.Render(par7);
                Leg3.Render(par7);
                Leg4.Render(par7);
            }
        }
 /// <summary>
 /// renders the ears (specifically, deadmau5's)
 /// </summary>
 public virtual void RenderEars(float par1)
 {
     BipedEars.RotateAngleY   = BipedHead.RotateAngleY;
     BipedEars.RotateAngleX   = BipedHead.RotateAngleX;
     BipedEars.RotationPointX = 0.0F;
     BipedEars.RotationPointY = 0.0F;
     BipedEars.Render(par1);
 }
 /// <summary>
 /// Sets the models various rotation angles then renders the model.
 /// </summary>
 public override void Render(Entity par1Entity, float par2, float par3, float par4, float par5, float par6, float par7)
 {
     SetRotationAngles(par2, par3, par4, par5, par6, par7);
     Field_40340_a.Render(par7);
     Field_40338_b.Render(par7);
     Field_40336_d.Render(par7);
     Field_40337_e.Render(par7);
     Field_40339_c.Render(par7);
 }
 /// <summary>
 /// Sets the models various rotation angles then renders the model.
 /// </summary>
 public override void Render(Entity par1Entity, float par2, float par3, float par4, float par5, float par6, float par7)
 {
     SetRotationAngles(par2, par3, par4, par5, par6, par7);
     Field_40306_a.Render(par7);
     Field_40304_b.Render(par7);
     Field_40305_c.Render(par7);
     Field_40302_d.Render(par7);
     Field_40303_e.Render(par7);
 }
Exemple #6
0
        /// <summary>
        /// Sets the models various rotation angles then renders the model.
        /// </summary>
        public override void Render(Entity par1Entity, float par2, float par3, float par4, float par5, float par6, float par7)
        {
            SetRotationAngles(par2, par3, par4, par5, par6, par7);
            SquidBody.Render(par7);

            for (int i = 0; i < SquidTentacles.Length; i++)
            {
                SquidTentacles[i].Render(par7);
            }
        }
Exemple #7
0
 ///<summary>
 /// Sets the models various rotation angles then renders the model.
 ///</summary>
 public void Render(Entity par1Entity, float par2, float par3, float par4, float par5, float par6, float par7)
 {
     SetRotationAngles(par2, par3, par4, par5, par6, par7);
     Field_48234_a.Render(par7);
     Field_48232_b.Render(par7);
     Field_48231_e.Render(par7);
     Field_48229_f.Render(par7);
     Field_48233_c.Render(par7);
     Field_48230_d.Render(par7);
 }
Exemple #8
0
        /// <summary>
        /// Sets the models various rotation angles then renders the model.
        /// </summary>
        public override void Render(Entity par1Entity, float par2, float par3, float par4, float par5, float par6, float par7)
        {
            SetRotationAngles(par2, par3, par4, par5, par6, par7);
            Field_40322_b.Render(par7);

            for (int i = 0; i < Field_40323_a.Length; i++)
            {
                Field_40323_a[i].Render(par7);
            }
        }
Exemple #9
0
 /// <summary>
 /// Sets the models various rotation angles then renders the model.
 /// </summary>
 public override void Render(Entity par1Entity, float par2, float par3, float par4, float par5, float par6, float par7)
 {
     SetRotationAngles(par2, par3, par4, par5, par6, par7);
     Head.Render(par7);
     Body.Render(par7);
     Leg1.Render(par7);
     Leg2.Render(par7);
     Leg3.Render(par7);
     Leg4.Render(par7);
 }
 /// <summary>
 /// Sets the models various rotation angles then renders the model.
 /// </summary>
 public override void Render(Entity par1Entity, float par2, float par3, float par4, float par5, float par6, float par7)
 {
     SetRotationAngles(par2, par3, par4, par5, par6, par7);
     BipedHead.Render(par7);
     BipedBody.Render(par7);
     BipedRightArm.Render(par7);
     BipedLeftArm.Render(par7);
     BipedRightLeg.Render(par7);
     BipedLeftLeg.Render(par7);
     BipedHeadwear.Render(par7);
 }
Exemple #11
0
 /// <summary>
 /// Sets the models various rotation angles then renders the model.
 /// </summary>
 public override void Render(Entity par1Entity, float par2, float par3, float par4, float par5, float par6, float par7)
 {
     SetRotationAngles(par2, par3, par4, par5, par6, par7);
     CoverRight.Render(par7);
     CoverLeft.Render(par7);
     BookSpine.Render(par7);
     PagesRight.Render(par7);
     PagesLeft.Render(par7);
     FlippingPageRight.Render(par7);
     FlippingPageLeft.Render(par7);
 }
        /// <summary>
        /// Sets the models various rotation angles then renders the model.
        /// </summary>
        public override void Render(Entity par1Entity, float par2, float par3, float par4, float par5, float par6, float par7)
        {
            //GL.PushMatrix();
            //GL.Scale(2.0F, 2.0F, 2.0F);
            //GL.Translate(0.0F, -0.5F, 0.0F);
            Field_41059_i.Render(par7);
            //GL.Rotate(par3, 0.0F, 1.0F, 0.0F);
            //GL.Translate(0.0F, 0.8F + par4, 0.0F);
            //GL.Rotate(60F, 0.7071F, 0.0F, 0.7071F);
            Field_41058_h.Render(par7);
            float f = 0.875F;

            //GL.Scale(f, f, f);
            //GL.Rotate(60F, 0.7071F, 0.0F, 0.7071F);
            //GL.Rotate(par3, 0.0F, 1.0F, 0.0F);
            Field_41058_h.Render(par7);
            //GL.Scale(f, f, f);
            //GL.Rotate(60F, 0.7071F, 0.0F, 0.7071F);
            //GL.Rotate(par3, 0.0F, 1.0F, 0.0F);
            Field_41057_g.Render(par7);
            //GL.PopMatrix();
        }
Exemple #13
0
 /// <summary>
 /// Sets the models various rotation angles then renders the model.
 /// </summary>
 public override void Render(Entity par1Entity, float par2, float par3, float par4, float par5, float par6, float par7)
 {
     SetRotationAngles(par2, par3, par4, par5, par6, par7);
     SpiderHead.Render(par7);
     SpiderNeck.Render(par7);
     SpiderBody.Render(par7);
     SpiderLeg1.Render(par7);
     SpiderLeg2.Render(par7);
     SpiderLeg3.Render(par7);
     SpiderLeg4.Render(par7);
     SpiderLeg5.Render(par7);
     SpiderLeg6.Render(par7);
     SpiderLeg7.Render(par7);
     SpiderLeg8.Render(par7);
 }
        /// <summary>
        /// Sets the models various rotation angles then renders the model.
        /// </summary>
        public override void Render(Entity par1Entity, float par2, float par3, float par4, float par5, float par6, float par7)
        {
            SetRotationAngles(par2, par3, par4, par5, par6, par7);

            if (IsChild)
            {
                float f = 2.0F;
                //GL.PushMatrix();
                //GL.Scale(1.5F / f, 1.5F / f, 1.5F / f);
                //GL.Translate(0.0F, 10F * par7, 4F * par7);
                Field_48220_g.Render(par7);
                //GL.PopMatrix();
                //GL.PushMatrix();
                //GL.Scale(1.0F / f, 1.0F / f, 1.0F / f);
                //GL.Translate(0.0F, 24F * par7, 0.0F);
                Field_48226_n.Render(par7);
                Field_48225_a.Render(par7);
                Field_48223_b.Render(par7);
                Field_48224_c.Render(par7);
                Field_48221_d.Render(par7);
                Field_48222_e.Render(par7);
                Field_48219_f.Render(par7);
                //GL.PopMatrix();
            }
            else
            {
                Field_48220_g.Render(par7);
                Field_48226_n.Render(par7);
                Field_48222_e.Render(par7);
                Field_48219_f.Render(par7);
                Field_48225_a.Render(par7);
                Field_48223_b.Render(par7);
                Field_48224_c.Render(par7);
                Field_48221_d.Render(par7);
            }
        }
        /// <summary>
        /// Sets the models various rotation angles then renders the model.
        /// </summary>
        public override void Render(Entity par1Entity, float par2, float par3, float par4, float par5, float par6, float par7)
        {
            base.Render(par1Entity, par2, par3, par4, par5, par6, par7);
            SetRotationAngles(par2, par3, par4, par5, par6, par7);

            if (IsChild)
            {
                float f = 2.0F;
                //GL.PushMatrix();
                //GL.Translate(0.0F, 5F * par7, 2.0F * par7);
                WolfHeadMain.RenderWithRotation(par7);
                //GL.PopMatrix();
                //GL.PushMatrix();
                //GL.Scale(1.0F / f, 1.0F / f, 1.0F / f);
                //GL.Translate(0.0F, 24F * par7, 0.0F);
                WolfBody.Render(par7);
                WolfLeg1.Render(par7);
                WolfLeg2.Render(par7);
                WolfLeg3.Render(par7);
                WolfLeg4.Render(par7);
                WolfTail.RenderWithRotation(par7);
                WolfMane.Render(par7);
                //GL.PopMatrix();
            }
            else
            {
                WolfHeadMain.RenderWithRotation(par7);
                WolfBody.Render(par7);
                WolfLeg1.Render(par7);
                WolfLeg2.Render(par7);
                WolfLeg3.Render(par7);
                WolfLeg4.Render(par7);
                WolfTail.RenderWithRotation(par7);
                WolfMane.Render(par7);
            }
        }
Exemple #16
0
        /// <summary>
        /// Sets the models various rotation angles then renders the model.
        /// </summary>
        public override void Render(Entity par1Entity, float par2, float par3, float par4, float par5, float par6, float par7)
        {
            SetRotationAngles(par2, par3, par4, par5, par6, par7);
            //GL.PushMatrix();
            //GL.Translate(0.0F, 0.6F, 0.0F);
            Body.Render(par7);
            ModelRenderer[] amodelrenderer = Tentacles;
            int             i = amodelrenderer.Length;

            for (int j = 0; j < i; j++)
            {
                ModelRenderer modelrenderer = amodelrenderer[j];
                modelrenderer.Render(par7);
            }

            //GL.PopMatrix();
        }
        /// <summary>
        /// Sets the models various rotation angles then renders the model.
        /// </summary>
        public override void Render(Entity par1Entity, float par2, float par3, float par4, float par5, float par6, float par7)
        {
            //GL.PushMatrix();
            EntityDragon entitydragon = (EntityDragon)par1Entity;
            float        f            = entitydragon.Field_40173_aw + (entitydragon.Field_40172_ax - entitydragon.Field_40173_aw) * Field_40317_s;

            Jaw.RotateAngleX = (float)(Math.Sin(f * (float)Math.PI * 2.0F) + 1.0D) * 0.2F;
            float f1 = (float)(Math.Sin(f * (float)Math.PI * 2.0F - 1.0F) + 1.0D);

            f1 = (f1 * f1 * 1.0F + f1 * 2.0F) * 0.05F;
            //GL.Translate(0.0F, f1 - 2.0F, -3F);
            //GL.Rotate(f1 * 2.0F, 1.0F, 0.0F, 0.0F);
            float f2 = -30F;
            float f4 = 0.0F;
            float f5 = 1.5F;

            float[] ad = entitydragon.Func_40160_a(6, Field_40317_s);
            float   f6 = UpdateRotations(entitydragon.Func_40160_a(5, Field_40317_s)[0] - entitydragon.Func_40160_a(10, Field_40317_s)[0]);
            float   f7 = UpdateRotations(entitydragon.Func_40160_a(5, Field_40317_s)[0] + (f6 / 2.0F));

            f2 += 2.0F;
            float f8 = f * (float)Math.PI * 2.0F;

            f2 = 20F;
            float f3 = -12F;

            for (int i = 0; i < 5; i++)
            {
                float[] ad3 = entitydragon.Func_40160_a(5 - i, Field_40317_s);
                float   f10 = (float)Math.Cos((float)i * 0.45F + f8) * 0.15F;
                Neck.RotateAngleY   = ((UpdateRotations(ad3[0] - ad[0]) * (float)Math.PI) / 180F) * f5;
                Neck.RotateAngleX   = f10 + (((float)(ad3[1] - ad[1]) * (float)Math.PI) / 180F) * f5 * 5F;
                Neck.RotateAngleZ   = ((-UpdateRotations(ad3[0] - f7) * (float)Math.PI) / 180F) * f5;
                Neck.RotationPointY = f2;
                Neck.RotationPointZ = f3;
                Neck.RotationPointX = f4;
                f2 = (float)(f2 + Math.Sin(Neck.RotateAngleX) * 10);
                f3 = (float)(f3 - Math.Cos(Neck.RotateAngleY) * Math.Cos(Neck.RotateAngleX) * 10);
                f4 = (float)(f4 - Math.Sin(Neck.RotateAngleY) * Math.Cos(Neck.RotateAngleX) * 10);
                Neck.Render(par7);
            }

            Head.RotationPointY = f2;
            Head.RotationPointZ = f3;
            Head.RotationPointX = f4;
            float[] ad1 = entitydragon.Func_40160_a(0, Field_40317_s);
            Head.RotateAngleY = ((UpdateRotations(ad1[0] - ad[0]) * (float)Math.PI) / 180F) * 1.0F;
            Head.RotateAngleZ = ((-UpdateRotations(ad1[0] - f7) * (float)Math.PI) / 180F) * 1.0F;
            Head.Render(par7);
            //GL.PushMatrix();
            //GL.Translate(0.0F, 1.0F, 0.0F);
            //GL.Rotate(-f6 * f5 * 1.0F, 0.0F, 0.0F, 1.0F);
            //GL.Translate(0.0F, -1F, 0.0F);
            Body.RotateAngleZ = 0.0F;
            Body.Render(par7);

            for (int j = 0; j < 2; j++)
            {
                //GL.Enable(EnableCap.CullFace);
                float f11 = f * (float)Math.PI * 2.0F;
                Wing.RotateAngleX        = 0.125F - (float)Math.Cos(f11) * 0.2F;
                Wing.RotateAngleY        = 0.25F;
                Wing.RotateAngleZ        = (float)(Math.Sin(f11) + 0.125D) * 0.8F;
                WingTip.RotateAngleZ     = -(float)(Math.Sin(f11 + 2.0F) + 0.5D) * 0.75F;
                RearLeg.RotateAngleX     = 1.0F + f1 * 0.1F;
                RearLegTip.RotateAngleX  = 0.5F + f1 * 0.1F;
                RearFoot.RotateAngleX    = 0.75F + f1 * 0.1F;
                FrontLeg.RotateAngleX    = 1.3F + f1 * 0.1F;
                FrontLegTip.RotateAngleX = -0.5F - f1 * 0.1F;
                FrontFoot.RotateAngleX   = 0.75F + f1 * 0.1F;
                Wing.Render(par7);
                FrontLeg.Render(par7);
                RearLeg.Render(par7);
                //GL.Scale(-1F, 1.0F, 1.0F);

                if (j == 0)
                {
                    //GL.CullFace(CullFaceMode.Front);
                }
            }

            //GL.PopMatrix();
            //GL.CullFace(CullFaceMode.Back);
            //GL.Disable(EnableCap.CullFace);
            float f9 = -(float)Math.Sin(f * (float)Math.PI * 2.0F) * 0.0F;

            f8 = f * (float)Math.PI * 2.0F;
            f2 = 10F;
            f3 = 60F;
            f4 = 0.0F;
            ad = entitydragon.Func_40160_a(11, Field_40317_s);

            for (int k = 0; k < 12; k++)
            {
                float[] ad2 = entitydragon.Func_40160_a(12 + k, Field_40317_s);
                f9 = (float)((double)f9 + Math.Sin((float)k * 0.45F + f8) * 0.05000000074505806D);
                Neck.RotateAngleY   = ((UpdateRotations(ad2[0] - ad[0]) * f5 + 180F) * (float)Math.PI) / 180F;
                Neck.RotateAngleX   = f9 + (((float)(ad2[1] - ad[1]) * (float)Math.PI) / 180F) * f5 * 5F;
                Neck.RotateAngleZ   = ((UpdateRotations(ad2[0] - (double)f7) * (float)Math.PI) / 180F) * f5;
                Neck.RotationPointY = f2;
                Neck.RotationPointZ = f3;
                Neck.RotationPointX = f4;
                f2 = (float)(f2 + Math.Sin(Neck.RotateAngleX) * 10D);
                f3 = (float)(f3 - Math.Cos(Neck.RotateAngleY) * Math.Cos(Neck.RotateAngleX) * 10D);
                f4 = (float)(f4 - Math.Sin(Neck.RotateAngleY) * Math.Cos(Neck.RotateAngleX) * 10D);
                Neck.Render(par7);
            }

            //GL.PopMatrix();
        }
 /// <summary>
 /// Renders the cloak of the current biped (in most cases, it's a player)
 /// </summary>
 public virtual void RenderCloak(float par1)
 {
     BipedCloak.Render(par1);
 }