private void DrawEntity(WindowRenderTarget device, Player currentPlayer, Entity entity)
        {
            if (entity == null)
                return;
            if (entity.Address == currentPlayer.Address)
                return;
            if (!entity.IsValid())
                return;
            //if (!Geometry.PointSeesPoint(currentPlayer.Vector2, entity.Vector2, Player.FOV_DEGREE, currentPlayer.Yaw))
            //    return;

            Color brushColor = lifeBarForeground;
            Vector2 point = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, entity.Vector3);
            if (point == Vector2.Zero)
                return;
            Vector3 entPoint = entity.Vector3;
            float distance = Geometry.GetDistanceToPoint(currentPlayer.Vector3, entity.Vector3);
            float distanceMeter = currentPlayer.DistanceToOtherEntityInMetres(entity);
            float boxBorder = 6400f / distance;
            float scale = 0.5f / distanceMeter;
            float rectX = point.X, rectY = point.Y, rectW = 24f * scale, rectH = 24f * scale;

            switch (entity.ClassID)
            {
                case Data.Enums.ClassID.Weapon:
                    brushColor = Color.Green;
                    if (csgo.GetValue<YesNo>("espDrawWeapons") == YesNo.No)
                        return;
                    if (entity.OwnerEntity != -1)
                        return;
                    break;
                case Data.Enums.ClassID.Hostage:
                    brushColor = Color.LemonChiffon;
                    return;
                case Data.Enums.ClassID.C4:
                    if (currentPlayer.Index == entity.OwnerEntity)
                        return;
                    brushColor = Color.DarkRed;
                    //if (entity.OwnerEntity > -1 && entity.OwnerEntity < csgo.Players.Length - 1)
                    //{
                    //    point = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, csgo.Players[entity.OwnerEntity - 1].Skeleton.Spine4);
                    //    rectX = point.X;
                    //    rectY = point.Y;
                    //    FillEllipse(device, Color.DarkRed * 0.25f, point.X, point.Y, csgo.ScreenSize.Height / 2f, csgo.ScreenSize.Height / 2f, true);
                    //    entPoint = csgo.Players[entity.OwnerEntity - 1].Skeleton.Spine4;
                    //}
                    break;
                case Data.Enums.ClassID.PlantedC4:
                    brushColor = Color.DarkRed;
                    //FillEllipse(device, Color.DarkRed * 0.25f, point.X, point.Y, csgo.ScreenSize.Height / 2f, csgo.ScreenSize.Height / 2f, true);
                    break;
                default:
                    return;
            }
            if (entity.ClassID == Data.Enums.ClassID.Chicken || entity.ClassID == Data.Enums.ClassID.Hostage)
            {
                //Paint bones
                //List<Vector3> allBones = new List<Vector3>();
                //if (distanceMeter < 20)
                //    allBones.AddRange(entity.Skeleton.Arms);
                //allBones.AddRange(entity.Skeleton.Legs);
                //allBones.AddRange(entity.Skeleton.Spine);
                //allBones.Add(entity.Skeleton.Neck);
                //for (int i = allBones.Count - 1; i >= 0; i--)
                //    if (allBones[i] == Vector3.Zero)
                //        allBones.RemoveAt(i);

                //Vector2[] all = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, allBones.ToArray());
                //allBones.Clear();
                //allBones = null;

                //rectX = GetSmallestX(all);
                //rectW = GetBiggestX(all);
                //rectY = GetSmallestY(all);
                //rectH = GetBiggestY(all);
                //rectW -= rectX;
                //rectH -= rectY;
            }

            rectX -= boxBorder;
            rectY -= boxBorder;
            rectW += boxBorder * 2f;
            rectH += boxBorder * 2f;

            #region glow
            if (csgo.GetValue<YesNo>("espGlowEnabled") == YesNo.Yes)
            {
                if (csgo.GlowObjects != null)
                {
                    CSGOGameController controller = (CSGOGameController)Program.GameController;
                    int idx = controller.MemoryUpdater.GetGlowObjectByAddress((int)entity.Address);
                    if (idx != -1)
                    {
                        GlowObjectDefinition def = csgo.GlowObjects[idx];
                        def.a = 1f;// (float)(brushColor.A / 255f);
                        def.r = (float)(brushColor.R / 255f);
                        def.g = (float)(brushColor.G / 255f);
                        def.b = (float)(brushColor.B / 255f);
                        def.m_bRenderWhenOccluded = true;
                        def.m_bRenderWhenUnoccluded = true;
                        controller.MemoryUpdater.WriteGlowObject(def, idx);
                    }
                }
            }
            #endregion

            if (point != Vector2.Zero)
            {
                #region box
                if (csgo.GetValue<OnOff>("espDrawBox") == OnOff.On)
                {
                    //Draw box
                    DrawW2SBox(device,
                        brushColor,
                        entPoint - Vector3.UnitZ * 8,
                        16f,
                        16f,
                        entity.Yaw + 45f,
                        15f / distanceMeter);
                }
                #endregion

                #region distance
                if (csgo.GetValue<OnOff>("espDrawDistance") == OnOff.On)
                {
                    ////Draw text
                    DrawText(device,
                        foreColor,
                        backColor,
                        rectX,
                        rectY + rectH,
                        100f,
                        20f,
                        1f,
                        1f,
                        Math.Round(distanceMeter, 0).ToString() + "m",
                        FactoryManager.GetFont("smallSegoe"));
                }
                #endregion
                string name = entity.Name;
                if (
                    entity.ClassID != Data.Enums.ClassID.Chicken &&
                    entity.ClassID != Data.Enums.ClassID.Hostage &&
                    entity.ClassID != Data.Enums.ClassID.CSPlayer &&
                    entity.ClassID != Data.Enums.ClassID.Weapon &&
                    entity.ClassID != Data.Enums.ClassID.C4 &&
                    entity.ClassID != Data.Enums.ClassID.PlantedC4)
                    name = String.Format("{0} (ID#{1})", name, entity.ClassID);
                DrawText(device,
                    foreColor,
                    backColor,
                    rectX,
                    rectY - 20f,
                    100f,
                    20f,
                    1f,
                    1f,
                    name,
                    FactoryManager.GetFont("smallSegoe"));

            }
        }
        private void DrawPlayer(WindowRenderTarget device, Player currentPlayer, Player player)
        {
            if (player == null)
                return;
            if (player.Index == currentPlayer.Index)
                return;
            if (!player.IsValid())
                return;
            if (csgo.GetValue<Target>("espDrawTarget") == Target.Enemies && player.InTeam == currentPlayer.InTeam)
                return;
            if (csgo.GetValue<Target>("espDrawTarget") == Target.Allies && player.InTeam != currentPlayer.InTeam)
                return;

            player.CheckYaw();

            Vector2 point = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, (player.Vector3));
            if (point == Vector2.Zero)
                return;
            float distance = Geometry.GetDistanceToPoint(currentPlayer.Vector3, player.Vector3);
            float height = 36000f / distance;
            float width = 18100f / distance;
            Color colorPlayer = player.InTeam == Team.Terrorists ?
                (player.SeenBy(currentPlayer) ? colorTSpotted : colorT) :
                (player.SeenBy(currentPlayer) ? colorCTSpotted : colorCT);

            float distanceMeter = currentPlayer.DistanceToOtherEntityInMetres(player);
            float head = 3200f / distance;
            float boxBorder = 6400f / distance;
            bool highlighted = csgo.Highlighted[player.Index - 1];
            //Paint bones
            List<Vector3> allBones = new List<Vector3>();

            allBones.AddRange(player.Skeleton.Legs);
            allBones.AddRange(player.Skeleton.Spine);
            allBones.Add(player.Skeleton.HeadEnd);

            Vector2[] all = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, allBones.ToArray());
            foreach (Vector2 vec in all)
                if (vec == Vector2.Zero)
                    return;
            Vector2[] arms = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, player.Skeleton.Arms);
            Vector2[] legs = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, player.Skeleton.Legs);
            Vector2[] spine = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, player.Skeleton.Spine);
            allBones.Clear();
            allBones = null;

            float rectX = GetSmallestX(all) + 5, rectW = GetBiggestX(all) + 5, rectY = GetSmallestY(all) + 5, rectH = GetBiggestY(all) + 5;
            //rectW -= rectX;
            rectH -= rectY;
            rectW = rectH * 0.3f;
            rectX = point.X - rectW / 2f;
            #region glow
            if (csgo.GetValue<YesNo>("espGlowEnabled") == YesNo.Yes)
            {
                if (csgo.GlowObjects != null)
                {
                    CSGOGameController controller = (CSGOGameController)Program.GameController;
                    int idx = controller.MemoryUpdater.GetGlowObjectByAddress((int)player.Address);
                    if (idx != -1)
                    {
                        GlowObjectDefinition def = csgo.GlowObjects[idx];
                        def.a = (float)(colorPlayer.A / 255f);
                        def.r = (float)(colorPlayer.R / 255f);
                        def.g = (float)(colorPlayer.G / 255f);
                        def.b = (float)(colorPlayer.B / 255f);
                        def.m_bRenderWhenOccluded = true;
                        def.m_bRenderWhenUnoccluded = true;
                        def.m_bFullBloom = false;
                        if (csgo.GetValue<YesNo>("espGlowFadingEnabled") == YesNo.Yes)
                        {
                            float dist = currentPlayer.DistanceToOtherEntityInMetres(player);
                            float range = csgo.GetValue<float>("espGlowFadingDistance");
                            if (dist <= range)
                            {
                                def.a = 1f - 1f / range * dist;
                                controller.MemoryUpdater.WriteGlowObject(def, idx);
                            }
                        }
                        else
                        {
                            controller.MemoryUpdater.WriteGlowObject(def, idx);
                        }
                    }
                }
            }
            #endregion
            #region skeleton
            if (csgo.GetValue<OnOff>("espDrawSkeleton") == OnOff.On)
            {
                if (distanceMeter < 20)
                    DrawBones(device,
                        colorPlayer,
                        arms,
                        1.5f,
                        player.InTeam
                        );
                DrawBones(device,
                    colorPlayer,
                    legs,
                    1.5f,
                    player.InTeam
                    );
                DrawBones(device,
                    colorPlayer,
                    spine,
                    1.5f,
                    player.InTeam
                    );
            }
            if (player.Skeleton.AllBones != null)
            {
                for (int i = 0; i < player.Skeleton.AllBones.Length; i++)
                {
                    Vector2 boneHead = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, player.Skeleton.AllBones[i]);
                    DrawText(device,
                        foreColor,
                        backColor,
                        boneHead.X,
                        boneHead.Y,
                        100f,
                        20f,
                        1f,
                        1f,
                        i.ToString(),
                        FactoryManager.GetFont("largeSegoe"));
                }
            }
            #endregion
            #region lines
            if (csgo.GetValue<OnOff>("espDrawLines") == OnOff.On)
            {
                Color color = colorPlayer;
                if (!player.IsSpotted)
                {
                    color *= 0.5f;
                }
                else
                {
                    color *= (0.75f + 0.25f * GetColorMultiplier());
                }
                FillPolygon(device,
                    color,
                    new Vector2(csgo.ScreenSize.Width / 2f, csgo.ScreenSize.Height),
                    new Vector2(point.X - width / 2f, point.Y),
                    new Vector2(point.X + width / 2f, point.Y));
            }
            #endregion
            #region box
            //Draw box
            if (csgo.GetValue<OnOff>("espDrawBox") == OnOff.On)
            {
                this.DrawRectangle(device,
                    colorPlayer,
                    rectX,
                    rectY,
                    rectW,
                    rectH,
                    1f);
            }
            #endregion
            #region circle
            if (csgo.GetValue<OnOff>("espDrawCircle") == OnOff.On)
            {
                Vector3[] circPoints = Geometry.Create3DFlatCircle(
                    player.Vector3,
                    32f + (player.IsSpotted ? 16f * GetColorMultiplier() : 0f),
                    32);
                Vector2[] scrCircPoints = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, circPoints);
                DrawLines(device, colorPlayer, 15f / distanceMeter, scrCircPoints);
            }
            #endregion
            #region distance
            if (csgo.GetValue<OnOff>("espDrawDistance") == OnOff.On)
            {
                string distString = Math.Round(distanceMeter, 0).ToString() + "m";
                RectangleF distSize = Control.MeasureString(this.Font, distString);
                //Draw text
                DrawText(device,
                    foreColor,
                    backColor,
                    rectX + rectW / 2f - distSize.Width / 2f,
                    rectY + rectH,
                    100f,
                    20f,
                    1f,
                    1f,
                    distString,
                    FactoryManager.GetFont("smallSegoe"));
            }
            #endregion
            #region highlight
            if (highlighted)
            {
                float size = (float)Math.Max(rectW + boxBorder, rectH + boxBorder) * 2f;
                Color color = (colorPlayer) * (0.5f + 0.5f * GetColorMultiplier());
                FillEllipse(
                    device,
                    color * 0.5f,
                    rectX + rectW / 2f,
                    rectY + rectH / 2f,
                    size,
                    size,
                    true);
                DrawEllipse(device,
                    color, //* (DateTime.Now.Millisecond % 1000f / 1000f),
                    rectX + rectW / 2f,
                    rectY + rectH / 2f,
                    size,
                    size,
                    true,
                    1.5f);
            }
            #endregion
            #region name
            if (csgo.GetValue<OnOff>("espDrawName") == OnOff.On)
            {
                ////Name
                //DrawText(device,
                //    foreColor,
                //    backColor,
                //    rectX + rectW,
                //    rectY - boxBorder,
                //    100f,
                //    20f,
                //    1f,
                //    1f,
                //    (player.IsDormant ? "[DORMANT] " : "") + player.Name,
                //    FactoryManager.GetFont("smallSegoe"));
                ////Info
                //string weaponInfo = "-";
                //if (player.WeaponIndex >= 0 && player.WeaponIndex < csgo.Entities.Length)
                //{
                //    if (csgo.Entities[player.WeaponIndex] != null)
                //        weaponInfo = csgo.Entities[player.WeaponIndex].Name;
                //}

                //string data = String.Format(
                //"Weapon: {0}",
                //    /*player.Health, player.Armor,*/ weaponInfo);

                //if (csgo.GetValue<OnOff>("espDrawDetails") == OnOff.On)
                //    data = String.Format("{0}\n" +
                //    "Balance: ${1}\n" +
                //    "Kills: {2}\n" +
                //    "Assists: {3}\n" +
                //    "Deaths: {4}\n" +
                //    "Score: {5}",
                //    data, player.Money, player.Kills, player.Assists, player.Deaths, player.Score);

                //DrawText(device,
                //    foreColor,
                //    backColor,
                //    rectX + rectW,
                //    rectY - boxBorder + 16f,
                //    100f,
                //    20f,
                //    1f,
                //    1f,
                //    data,
                //    FactoryManager.GetFont("tinySegoe"));
                string weaponInfo = "-";
                if (player.WeaponIndex >= 0 && player.WeaponIndex < csgo.Entities.Length)
                {
                    if (csgo.Entities[player.WeaponIndex] != null)
                        weaponInfo = csgo.Entities[player.WeaponIndex].Name;
                }
                string str = string.Format("{0}\n[{1}]", player.Name, weaponInfo);
                RectangleF size = Control.MeasureString(this.Font, str);
                //Name
                DrawText(device,
                    foreColor,
                    backColor,
                    rectX + rectW / 2f - size.Width / 2f,
                    rectY - 40,
                    100f,
                    20f,
                    2f,
                    2f,
                    str,
                    FactoryManager.GetFont("smallSegoe"));
            }
            #endregion
            #region health
            if (csgo.GetValue<OnOff>("espDrawHealth") == OnOff.On)
            {
                ////HP
                //FillRectangle(device,
                //        lifeBarBackground,
                //        rectX,
                //        rectY - lifeBarHeight * 3f,
                //        width, //rectW,
                //        lifeBarHeight /*10f*/);
                //FillRectangle(device,
                //        lifeBarForeground,
                //        rectX,
                //        rectY - lifeBarHeight * 3f,
                //    /*rectW*/ width / 100f * player.Health,
                //        lifeBarHeight /*10f*/);
                //DrawText(device,
                //    lifeBarForeground,
                //    backColor,
                //    rectX + width,
                //    rectY - lifeBarHeight * 3f - 2f,
                //    100f,
                //    20f,
                //    1f,
                //    1f,
                //    player.Health.ToString(),
                //    FactoryManager.GetFont("miniSegoe"));
                ////Armor
                //FillRectangle(device,
                //        lifeBarBackground,
                //        rectX,
                //        rectY - lifeBarHeight * 2f,
                //        width, //rectW,
                //        lifeBarHeight /*10f*/);
                //FillRectangle(device,
                //        viewColorOutline,
                //        rectX,
                //        rectY - lifeBarHeight * 2f,
                //    /*rectW*/ width / 100f * player.Armor,
                //        lifeBarHeight /*10f*/);
                //DrawText(device,
                //    viewColorOutline,
                //    backColor,
                //    rectX + width,
                //    rectY - lifeBarHeight * 2f - 2f,
                //    100f,
                //    20f,
                //    1f,
                //    1f,
                //    player.Armor.ToString(),
                //    FactoryManager.GetFont("miniSegoe"));
                //HP
                FillRectangle(device,
                        lifeBarBackground,
                        rectX - lifeBarWidth,
                        rectY,
                        lifeBarWidth, //rectW,
                        rectH /*10f*/);
                FillRectangle(device,
                        lifeBarForeground,
                        rectX - lifeBarWidth,
                        rectY,
                        lifeBarWidth,
                        rectH / 100f * player.Health /*10f*/);
                DrawText(device,
                    lifeBarForeground,
                    backColor,
                    rectX - lifeBarWidth,
                    rectY + rectH,
                    100f,
                    20f,
                    1f,
                    1f,
                    player.Health.ToString(),
                    FactoryManager.GetFont("miniSegoe"));
                //Armor
                FillRectangle(device,
                        lifeBarBackground,
                        rectX + rectW,
                        rectY,
                        lifeBarWidth, //rectW,
                        rectH /*10f*/);
                FillRectangle(device,
                        viewColorOutline,
                        rectX + rectW,
                        rectY,
                        lifeBarWidth,
                        rectH / 100f * player.Armor /*10f*/);
                DrawText(device,
                    viewColorOutline,
                    backColor,
                    rectX + rectW,
                    rectY + rectH,
                    100f,
                    20f,
                    1f,
                    1f,
                    player.Armor.ToString(),
                    FactoryManager.GetFont("miniSegoe"));
            }
            #endregion
            #region rank
            if (player.Rank > 0)
            {
                //Scaling
                float boxWidth = rectW, boxHeight = rectW * aspect;
                /*
                 * Args:
                 * 1 actual bitmap
                 * 2 destination-rectangle
                 * 3 opacity
                 * 4 interpolation mode
                 * 5 source-rectangle - easy access using rank as index
                 */
                if (ranksBmp != null)
                {
                    device.DrawBitmap(
                    ranksBmp,
                    new RectangleF(point.X - boxWidth / 2f, point.Y + 20f, boxWidth, boxHeight),
                    0.7f,
                    BitmapInterpolationMode.Linear,
                    new RectangleF(0f, 80f * (player.Rank - 1), 200f, 80f));
                    if (boxWidth > 50f)
                        DrawText(device, foreColor, point.X - boxWidth / 2f, point.Y + 20f + boxHeight + 4f, 200f, 100f, string.Format("MM-wins: {0}", player.Wins.ToString()), this.Font);
                }
            }
            #endregion
        }