bool ScreenTransformD3D(const Vector& vOrigin, Vector& vOut)
        {
            bool behind = true;;
            float width;

            //const D3DXMATRIX& WorldToScreen = *(D3DXMATRIX*)(*(PDWORD)(pOffset->dwMatrixOffset)+988);

        //  DWORD MM = (DWORD)&pEngine->WorldToScreenMatrix();
        //  pOffset->dwMatrixOffset = (MM + 0x40);

            D3DXMATRIX * pWorldToScreen = nullptr;// *(D3DXMATRIX*)(*(PDWORD)(pOffset->dwMatrixOffset) + 988);


            static float* ViewMatrixOld = nullptr;
        //  float* ViewMatrix = nullptr;

            if (!ViewMatrixOld)
            {
                ViewMatrixOld = GetW2SEngine();
            }
            else
            {
                pWorldToScreen = (D3DXMATRIX*)(*(PDWORD)(ViewMatrixOld)+0x3DC);
                if ((DWORD)pWorldToScreen <= (DWORD) GetModuleHandle(0))
                {
                    pWorldToScreen = nullptr;
                    ViewMatrixOld = GetW2SEngine();
                    ConColorMsg(Color::Red(), "[WARNING] D3D Matrix failed! %X\n", pWorldToScreen);
                }
            //  else
            //      Utils::DebugMSG("%x", &*pWorldToScreen);
            }

            if (pWorldToScreen && *pWorldToScreen)
            {
                D3DXMATRIX W2S = *pWorldToScreen;

                vOut.X = W2S._11 * vOrigin.X + W2S._12 * vOrigin.Y + W2S._13 * vOrigin.Z + W2S._14;
                vOut.Y = W2S._21 * vOrigin.X + W2S._22 * vOrigin.Y + W2S._23 * vOrigin.Z + W2S._24;

                width = W2S._41 * vOrigin.X + W2S._42 * vOrigin.Y + W2S._43 * vOrigin.Z + W2S._44;

                vOut.Z = 0;

                if (width < 0.001f)
                {
                    behind = true;

                    vOut.X *= 100000;
                    vOut.Y *= 100000;
                }
                else
                {
                    behind = false;

                    float invWidth = 1.0 / width;

                    vOut.X *= invWidth;
                    vOut.Y *= invWidth;
                }

            }

            return behind;
        }

        bool ScreenTransform(const Vector& point, Vector& screen)
        {
        //  if (nTransformType == RENDERTYPES::ENGINE)
        //return ScreenTransformEngine(point, screen);

        //  if (nTransformType == RENDERTYPES::D3D)
                return ScreenTransformD3D(point, screen);

            return false;
        }

        bool WorldToScreen(CONST Vector &origin, OUT Vector &screen)
        {
            //return !pDebugOverlay->ScreenPosition(origin, screen);

            BOOL bRet = FALSE;

            if (!ScreenTransform(origin, screen))
            {
                INT width, height;
                pEngine->GetScreenSize(width, height);

                fScreenX = width / 2;
                fScreenY = height / 2;

                fScreenX += 0.5f * screen.X * width + 0.5f;
                fScreenY -= 0.5f * screen.Y * height + 0.5f;

                screen.X = fScreenX;
                screen.Y = fScreenY;

                bRet = TRUE;
            }

            return bRet;
        }



		for (int i = 0; i <= pEntityList()->GetHigestEntityIndex(); i++)
		{
			CBaseEntity* pEntity = (CBaseEntity*)pEntityList()->GetClientEntity(i);