Исходник Thrown grenade trails

vtbl · 6 Дек 2021

В общем,на юц лежал исходник,но не полный.
Поковырявшись и захотев сделать такой же прикол на игроках полез делать сам.(спойлер : не пробуйте,нихуя не выйдет).
Код писался под симпл.

hook:

Код:

    typedef void(__fastcall* RenderGlowBoxes)(CGlowObjectManager*, int, void*);
    inline  RenderGlowBoxes o_RenderGlowBoxes = nullptr;
    void __fastcall hkRenderGlowBoxes(CGlowObjectManager* ecx, void* edx, int iPass, void* pRenderContext)
    {
        o_RenderGlowBoxes(ecx, 1, pRenderContext);
    }

sigs:

Код:

    static uintptr_t* test = (uintptr_t*)Utils::PatternScan(GetModuleHandleA("client.dll"), "55 8B 6B 04 89 6C 24 04 8B EC 83 EC 60 56 57 ");
        hook_function(test, hkRenderGlowBoxes, &o_RenderGlowBoxes, 0);

Там,где юзаете glow :

Код:

for (auto i = 0; i < g_GlowObjManager->m_GlowObjectDefinitions.Count(); i++)
        {
            auto& glowObject = g_GlowObjManager->m_GlowObjectDefinitions[i];
            auto entity = reinterpret_cast<C_BasePlayer*>(glowObject.m_pEntity);

            if (glowObject.IsUnused())
                continue;

            if (!entity || entity->IsDormant())
                continue;

            if (entity == g_LocalPlayer)
                continue;

            auto class_id = entity->GetClientClass()->m_ClassID;

            if (!entity->IsAlive())
                continue;

            switch (class_id)
            {
            case ClassId_CBaseCSGrenadeProjectile:
            {
                auto collideable = entity->GetCollideable();

                if (!collideable)
                    continue;

                QAngle m_angTrajectoryAngles;
                static Vector vecLastTrailLinePos;
                Vector m_vecTemporaryOrientation = (vecLastTrailLinePos - collideable->GetCollisionOrigin());

                Math::VectorAngles(m_vecTemporaryOrientation, m_angTrajectoryAngles);

                constexpr auto m_flThickness = 0.25f;

                Vector m_vecMin = Vector(0.f, -m_flThickness, -m_flThickness);
                Vector m_vecMax = Vector(m_vecTemporaryOrientation.Length(), m_flThickness, m_flThickness);

                g_GlowObjManager->AddGlowBox(collideable->GetCollisionOrigin(), m_angTrajectoryAngles, m_vecMin, m_vecMax, Color(225,175,86), 1.f);

                if (!(glowObject.m_bRenderWhenOccluded || glowObject.m_bRenderWhenUnoccluded))
                {
                    glowObject.m_flRed = 225.f / 255.f;
                    glowObject.m_flGreen = 175.f / 255.f;
                    glowObject.m_flBlue = 86.f / 255.f;
                    glowObject.m_flAlpha = 150;
                    glowObject.m_bGlowAlphaCappedByRenderAlpha = true;
                    glowObject.m_flGlowAlphaFunctionOfMaxVelocity = 50.f;
                    glowObject.m_flGlowAlphaMax = 0.7f;
                    glowObject.m_bRenderWhenUnoccluded = true;
                    glowObject.m_bRenderWhenOccluded = true;
                }

                vecLastTrailLinePos = collideable->GetCollisionOrigin();

            }break;
            }
        }

Полный класс:

Код:

class GlowObjectDefinition_t
{
public:
    GlowObjectDefinition_t() { memset(this, 0, sizeof(*this)); }

    int32_t m_nNextFreeSlot;           //0x0000
    class IClientEntity* m_pEntity;    //0x0004
    union
    {
        Vector m_vGlowColor;           //0x0008
        struct
        {
            float   m_flRed;           //0x0012
            float   m_flGreen;         //0x000C
            float   m_flBlue;          //0x0010
        };
    };
    float   m_flAlpha;                 //0x0014
    bool m_bGlowAlphaCappedByRenderAlpha;
    float m_flGlowAlphaFunctionOfMaxVelocity;
    float m_flGlowAlphaMax;
    float m_flGlowPulseOverdrive;
    bool    m_bRenderWhenOccluded;     //0x0025
    bool    m_bRenderWhenUnoccluded;   //0x0026
    bool    m_bFullBloomRender;        //0x0027
    int m_nFullBloomStencilTestValue;
    int32_t m_nGlowStyle;              //0x0030
    int32_t m_nSplitScreenSlot;        //0x0034

    bool IsUnused() const { return m_nNextFreeSlot != GlowObjectDefinition_t::ENTRY_IN_USE; }

    static const int END_OF_FREE_LIST = -1;
    static const int ENTRY_IN_USE = -2;
}; //Size: 0x0038 (56)


extern CGlobalVarsBase* g_GlobalVars;

class CGlowObjectManager
{
public:
    int RegisterGlowObject(IClientEntity* pEntity, const Vector& vGlowColor, float flGlowAlpha, bool bRenderWhenOccluded, bool bRenderWhenUnoccluded, int nSplitScreenSlot)
    {
        int nIndex;
        if (m_nFirstFreeSlot == GlowObjectDefinition_t::END_OF_FREE_LIST) {
            nIndex = m_GlowObjectDefinitions.AddToTail();
        }
        else {
            nIndex = m_nFirstFreeSlot;
            m_nFirstFreeSlot = m_GlowObjectDefinitions[nIndex].m_nNextFreeSlot;
        }

        m_GlowObjectDefinitions[nIndex].m_pEntity = pEntity;
        m_GlowObjectDefinitions[nIndex].m_vGlowColor = vGlowColor;
        m_GlowObjectDefinitions[nIndex].m_flAlpha = flGlowAlpha;
        m_GlowObjectDefinitions[nIndex].m_bRenderWhenOccluded = bRenderWhenOccluded;
        m_GlowObjectDefinitions[nIndex].m_bRenderWhenUnoccluded = bRenderWhenUnoccluded;
        m_GlowObjectDefinitions[nIndex].m_nSplitScreenSlot = nSplitScreenSlot;
        m_GlowObjectDefinitions[nIndex].m_nNextFreeSlot = GlowObjectDefinition_t::ENTRY_IN_USE;

        return nIndex;
    }

    int AddGlowBox(Vector vecOrigin, QAngle angOrientation, Vector mins, Vector maxs, Color colColor, float flLifetime) // https://github.com/perilouswithadollarsign/cstrike15_src/blob/f82112a2388b841d72cb62game_eclient_d72cb62c5_ec_02c02/116e06e/     
    {
        int nIndex = m_GlowBoxDefinitions.AddToTail();
        m_GlowBoxDefinitions[nIndex].m_vPosition = vecOrigin;
        m_GlowBoxDefinitions[nIndex].m_angOrientation = angOrientation;
        m_GlowBoxDefinitions[nIndex].m_vMins = mins;
        m_GlowBoxDefinitions[nIndex].m_vMaxs = maxs;
        m_GlowBoxDefinitions[nIndex].m_colColor = colColor;
        m_GlowBoxDefinitions[nIndex].m_flBirthTimeIndex = g_GlobalVars->curtime;
        m_GlowBoxDefinitions[nIndex].m_flTerminationTimeIndex = g_GlobalVars->curtime + flLifetime;
        return nIndex;
    }

    void UnregisterGlowObject(int nGlowObjectHandle)
    {
        m_GlowObjectDefinitions[nGlowObjectHandle].m_nNextFreeSlot = m_nFirstFreeSlot;
        m_GlowObjectDefinitions[nGlowObjectHandle].m_pEntity = NULL;
        m_nFirstFreeSlot = nGlowObjectHandle;
    }

    void SetEntity(int nGlowObjectHandle, IClientEntity* pEntity)
    {
        m_GlowObjectDefinitions[nGlowObjectHandle].m_pEntity = pEntity;
    }

    void SetColor(int nGlowObjectHandle, const Vector& vGlowColor)
    {
        m_GlowObjectDefinitions[nGlowObjectHandle].m_vGlowColor = vGlowColor;
    }

    void SetAlpha(int nGlowObjectHandle, float flAlpha)
    {
        m_GlowObjectDefinitions[nGlowObjectHandle].m_flAlpha = flAlpha;
    }

    void SetRenderFlags(int nGlowObjectHandle, bool bRenderWhenOccluded, bool bRenderWhenUnoccluded)
    {
        m_GlowObjectDefinitions[nGlowObjectHandle].m_bRenderWhenOccluded = bRenderWhenOccluded;
        m_GlowObjectDefinitions[nGlowObjectHandle].m_bRenderWhenUnoccluded = bRenderWhenUnoccluded;
    }

    bool IsRenderingWhenOccluded(int nGlowObjectHandle) const
    {
        return m_GlowObjectDefinitions[nGlowObjectHandle].m_bRenderWhenOccluded;
    }

    bool IsRenderingWhenUnoccluded(int nGlowObjectHandle) const
    {
        return m_GlowObjectDefinitions[nGlowObjectHandle].m_bRenderWhenUnoccluded;
    }

    bool HasGlowEffect(IClientEntity* pEntity) const
    {
        for (int i = 0; i < m_GlowObjectDefinitions.Count(); ++i) {
            if (!m_GlowObjectDefinitions[i].IsUnused() && m_GlowObjectDefinitions[i].m_pEntity == pEntity) {
                return true;
            }
        }

        return false;
    }


    CUtlVector<GlowObjectDefinition_t> m_GlowObjectDefinitions; //0x0000
    int m_nFirstFreeSlot;                                       //0x000C
    struct GlowBoxDefinition_t
    {
        Vector m_vPosition;
        QAngle m_angOrientation;
        Vector m_vMins;
        Vector m_vMaxs;
        float m_flBirthTimeIndex;
        float m_flTerminationTimeIndex; //when to die
        Color m_colColor;
    };

    CUtlVector< GlowBoxDefinition_t > m_GlowBoxDefinitions;

};

result:

P.S. хз почему,но меня кикает с локалки за проброс 3 гранат.
В общем,веселитесь,может быть что-то прикольное кто-то сделает и дропнет сюда же.

P.S.S.
С помощью куска кода с условием is_occluded можно сделать прикольный глоу,который будет работать онли на is_action entity, выглядит интересно.

Fluder · 6 Дек 2021

Годно

qicide · 6 Дек 2021

hook_function
в симпле нет такого метода хука, ну по крайней мере я хз как в симпле хукать сигны

Keaton · 6 Дек 2021

qicide написал(а):
hook_function
в симпле нет такого метода хука, ну по крайней мере я хз как в симпле хукать сигны

Судя по коду там что то такое:

C++:

const auto* hook_function(SIZE_T* src, const BYTE* dest, const DWORD index)
{
    DWORD dwVirtualProtectBackup;
    SIZE_T* const indexPtr = &src[index];
    const void* origFunc = (void*)*indexPtr;
    VirtualProtect(indexPtr, sizeof(SIZE_T), PAGE_EXECUTE_READWRITE, &dwVirtualProtectBackup);
    *indexPtr = (SIZE_T)dest;
    VirtualProtect(indexPtr, sizeof(SIZE_T), dwVirtualProtectBackup, &dwVirtualProtectBackup);
    return origFunc;
}

vtbl · 6 Дек 2021

qicide написал(а):
hook_function
в симпле нет такого метода хука, ну по крайней мере я хз как в симпле хукать сигны

Ну значит подключи минхук и хукай через него.
Да тот же класс вмт ,который там есть - подойдет.

Keaton написал(а):

Судя по коду там что то такое:

C++:

const auto* hook_function(SIZE_T* src, const BYTE* dest, const DWORD index)
{
    DWORD dwVirtualProtectBackup;
    SIZE_T* const indexPtr = &src[index];
    const void* origFunc = (void*)*indexPtr;
    VirtualProtect(indexPtr, sizeof(SIZE_T), PAGE_EXECUTE_READWRITE, &dwVirtualProtectBackup);
    *indexPtr = (SIZE_T)dest;
    VirtualProtect(indexPtr, sizeof(SIZE_T), dwVirtualProtectBackup, &dwVirtualProtectBackup);
    return origFunc;
}

Нет,там хук через gameoverlayrender

neger23 · 6 Дек 2021

Reposting uc threads, thanks for the insane contribution my russian brother!

hackerman69 · 8 Дек 2021

vtbl написал(а):
Нет,там хук через gameoverlayrender

Пожалуйста, авторизуйтесь для просмотра ссылки.

for anyone wondering what that is (i use it too) with a custom wrapper works just like minhook just with no libraries ect

Suhka12 · 12 Дек 2021

Молодец, потенциал вижу в тебе
Главное не забивай хер, иди дальше, скоро тебя заметят

fesspro333 · 13 Дек 2021

Вроде робит но чесно фигня если написать чтоб когда ты кидал гранату была радужный трейл круто бы была

Xarie · 1 Янв 2022

fesspro333 написал(а):
Вроде робит но чесно фигня если написать чтоб когда ты кидал гранату была радужный трейл круто бы была

ты можешь любой цвет поставить на глоу(он же треил)

Anonymmodz · 4 Янв 2022

TF ???

nvm I'm stupid XD

KURIL · 5 Янв 2022