Вопрос TraceRay

[nekit___1472]

У кого есть обновленные структуры ?

 struct Ray_t
 {
 public:
     Vector3 m_vecStart;
     Vector3 m_vecEnd;
     Vector3 m_vecMins;
     Vector3 m_vecMaxs;
 private: char pad_061[0x4]; public:;
        std::uint8_t UnkType;
 };
 static_assert(sizeof(Ray_t) == 0x38);

 struct SurfaceData_t
 {
 public:
 private: char pad_0170[0x8]; public:
     float m_flPenetrationModifier;
     float m_flDamageModifier;
 private: char pad_0172[0x4]; public:
     int m_iMaterial;
 };
 static_assert(sizeof(SurfaceData_t) == 0x18);

 struct TraceHitboxData_t
 {
 public:
 private: char pad_049[0x38]; public:;
        int m_nHitGroup;
 private: char pad_048[0x4]; public:;
        int m_nHitboxId;
 };
 static_assert(sizeof(TraceHitboxData_t) == 0x44);

 struct GameTrace_t
 {
 public:
     GameTrace_t() = default;

     SurfaceData_t* GetSurfaceData()
     {
         using fnGetSurfaceData = std::uint64_t(__fastcall*)(void*);
         static fnGetSurfaceData oGetSurfaceData = reinterpret_cast<fnGetSurfaceData>(Pattern("E8 ? ? ? ? 48 85 C0 74 ? 44 38 68").scanNow("client.dll").getAbs(0x1,0x0).as<fnGetSurfaceData>());


         static_cast<void>(!!(oGetSurfaceData != nullptr) || (__debugbreak(), 0));


         return reinterpret_cast<SurfaceData_t*>(oGetSurfaceData(m_pSurface));
     }

     int GetHitboxId()
     {
         if (m_pHitboxData)
             return m_pHitboxData->m_nHitboxId;
         return 0;
     }
     int GetHitgroup()
     {
         if (m_pHitboxData)
             return m_pHitboxData->m_nHitGroup;
         return 0;
     }

     bool IsVisible() const
     {
         return (m_flFraction > 0.97f);
     }

     void* m_pSurface;
     C_CSPlayerPawn* m_pHitEntity;
     TraceHitboxData_t* m_pHitboxData;
 private: char pad_0133[0x38]; public:;
        std::uint32_t m_uContents;
 private: char pad_0138[0x24]; public:;
        Vector3 m_vecStartPos;
        Vector3 m_vecEndPos;
        Vector3 m_vecNormal;
        Vector3 m_vecPosition;
 private: char pad_059[0x4]; public:;
        float m_flFraction;
 private: char pad_062[0x6]; public:;
        bool m_bAllSolid;
 private: char pad_034[0x4D]; public:
 }; // Size: 0x108

 static_assert(sizeof(GameTrace_t) == 0x108);

 struct TraceFilter_t
 {
 public:
 private: char pad_031[0x8]; public:;
        std::int64_t m_uTraceMask;
        std::uint64_t m_v1[2];
        std::uint32_t m_arrSkipHandles[4];
        std::uint16_t m_arrCollisions[2];
        std::int16_t m_v2;
        std::uint8_t m_v3;
        std::uint8_t m_v4;
        std::uint8_t m_v5;
        std::uint8_t m_Collision;
 

        TraceFilter_t() = default;
        TraceFilter_t(std::uint64_t uMask, C_CSPlayerPawn* pSkip1, C_CSPlayerPawn* pSkip2, int nLayer)
        {
            m_uTraceMask = uMask;
            m_v1[0] = m_v1[1] = 0;
            m_v2 = 15;
            m_v3 = nLayer;
            m_v4 = 0x49;
            m_v5 = 0;

            if (pSkip1 != nullptr)
            {
                m_arrSkipHandles[0] = pSkip1->GetRefEHandle().GetEntryIndex();
                m_arrSkipHandles[2] = pSkip1->GetOwnerHandleIndex();
                m_arrCollisions[0] = pSkip1->m_pCollision()->CollisionMask();
            }

            if (pSkip2 != nullptr)
            {
                m_arrSkipHandles[0] = pSkip2->GetRefEHandle().GetEntryIndex();
                m_arrSkipHandles[2] = pSkip2->GetOwnerHandleIndex();
                m_arrCollisions[0] = pSkip2->m_pCollision()->CollisionMask();
            }
        }
 };

 static_assert(sizeof(TraceFilter_t) == 0x40);
 
class CTraceManager
 {
 public:
     bool TraceShape(Ray_t* pRay, Vector3 vecStart, Vector3 vecEnd, TraceFilter_t* pFilter, GameTrace_t* pGameTrace)
     {
         using fnTraceShape = bool(__fastcall*)(CTraceManager*, Ray_t*, Vector3*, Vector3*, TraceFilter_t*, GameTrace_t*);
         // Credit: https://www.unknowncheats.me/forum/4265752-post6333.html
         static fnTraceShape oTraceShape = reinterpret_cast<fnTraceShape>(Pattern("48 89 5C 24 ? 48 89 4C 24 ? 55 57").scanNow("client.dll").getAddress());


         static_cast<void>(!!(oTraceShape != nullptr) || (__debugbreak(), 0));


         return oTraceShape(this, pRay, &vecStart, &vecEnd, pFilter, pGameTrace);
     }

     bool ClipRayToEntity(Ray_t* pRay, Vector3 vecStart, Vector3 vecEnd, C_CSPlayerPawn* pPawn, TraceFilter_t* pFilter, GameTrace_t* pGameTrace)
     {
         using fnClipRayToEntity = bool(__fastcall*)(CTraceManager*, Ray_t*, Vector3*, Vector3*, C_CSPlayerPawn*, TraceFilter_t*, GameTrace_t*);
         static fnClipRayToEntity oClipRayToEntity = reinterpret_cast<fnClipRayToEntity>(Pattern("48 8B C4 48 89 58 ? 55 56 57 41 54 41 56 48 8D 68 ? 48 81 EC ? ? ? ? 48 8B 5D").scanNow("client.dll").getAddress());


         static_cast<void>(!!(oClipRayToEntity != nullptr) || (__debugbreak(), 0));


         return oClipRayToEntity(this, pRay, &vecStart, &vecEnd, pPawn, pFilter, pGameTrace);
     }
 };