Implement player model glow feature

danielkrupinski · Nov 13, 2024 · 71aca7c · 71aca7c
1 parent d0c0de9
commit 71aca7c
Show file tree

Hide file tree

Showing 31 changed files with 375 additions and 12 deletions.
diff --git a/Source/CS2/Classes/CSceneObject.h b/Source/CS2/Classes/CSceneObject.h
@@ -9,9 +9,16 @@ enum SceneObjectFlags {
     SceneObjectFlag_IsDeleted = 0x20
 };
 
+struct SceneObjectAttributes {
+    struct FloatAttributes {};
+
+    FloatAttributes floatAttributes;
+};
+
 struct CSceneObject {
     using m_nObjectClass = std::uint8_t;
     using flags = std::uint8_t;
+    using attributes = SceneObjectAttributes*;
 };
 
 }
diff --git a/Source/CS2/Classes/CSceneSystem.h b/Source/CS2/Classes/CSceneSystem.h
@@ -7,6 +7,7 @@ struct CSceneObject;
 
 struct CSceneSystem {
     using DeleteSceneObject = void(CSceneSystem* sceneSystem, CSceneObject* sceneObject);
+    using AllocateAttributeList = void(CSceneSystem* sceneSystem, CSceneObject* sceneObject);
 };
 
 }
diff --git a/Source/CS2/Classes/Entities/C_CSPlayerPawn.h b/Source/CS2/Classes/Entities/C_CSPlayerPawn.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <CS2/Classes/EntitySystem/CEntityHandle.h>
+#include <CS2/Classes/SceneObjectUpdaterHandle_t.h>
 #include <Platform/Macros/PlatformSpecific.h>
 
 #include "C_BaseModelEntity.h"
@@ -19,6 +20,7 @@ struct C_CSPlayerPawn : C_BaseModelEntity {
     using m_bIsGrabbingHostage = bool;
     using m_pHostageServices = CCSPlayer_HostageServices*;
     using m_flFlashBangTime = float;
+    using sceneObjectUpdaterHandle = SceneObjectUpdaterHandle_t*;
 };
 
 }
diff --git a/Source/CS2/Classes/SceneObjectUpdaterHandle_t.h b/Source/CS2/Classes/SceneObjectUpdaterHandle_t.h
@@ -1,12 +1,17 @@
 #pragma once
 
+#include <cstdint>
+
 namespace cs2
 {
 
 struct CSceneObject;
 
 struct SceneObjectUpdaterHandle_t {
    using sceneObject = CSceneObject*;
+
+   void* updaterFunctionParameter;
+   std::uint64_t(*updaterFunction)(void* parameter);
 };
 
 }
diff --git a/Source/Endpoints.h b/Source/Endpoints.h
@@ -32,4 +32,12 @@ void ViewRenderHook_onRenderStart_cpp(cs2::CViewRender* thisptr) noexcept
     dependencies.make<GlowSceneObjects>().removeUnreferencedObjects();
 }
 
+#if IS_LINUX()
+[[gnu::aligned(2)]]
+#endif
+std::uint64_t PlayerPawn_sceneObjectUpdater_cpp(cs2::C_CSPlayerPawn* playerPawn) noexcept
+{
+    return GlobalContext::instance().playerPawnSceneObjectUpdater(playerPawn);
+}
+
 }
diff --git a/Source/FeatureHelpers/RenderingHookEntityLoop.h b/Source/FeatureHelpers/RenderingHookEntityLoop.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <CS2/Classes/Entities/CEntityInstance.h>
+#include <Features/Visuals/ModelGlow/ModelGlow.h>
 #include <Features/Visuals/OutlineGlow/OutlineGlow.h>
 #include <Features/Visuals/PlayerInfoInWorld/PlayerInfoInWorld.h>
 
@@ -16,6 +17,7 @@ class RenderingHookEntityLoop {
     void run() const noexcept
     {
         hookContext.template make<EntitySystem>().iterateEntities([this](auto& entity) { handleEntity(entity); });
+        hookContext.template make<ModelGlow>().onEntityListTraversed();
     }
 
 private:
@@ -25,9 +27,10 @@ class RenderingHookEntityLoop {
 
         const auto entityTypeInfo = hookContext.entityClassifier().classifyEntity(hookContext.gameDependencies().entitiesVMTs, entity.vmt);
 
-        if (entityTypeInfo.typeIndex == utils::typeIndex<cs2::C_CSPlayerPawn, KnownEntityTypes>()) {
+        if (entityTypeInfo.template is<cs2::C_CSPlayerPawn>()) {
             auto&& playerPawn = hookContext.template make<PlayerPawn>(static_cast<cs2::C_CSPlayerPawn*>(&entity));
             playerInformationThroughWalls.drawPlayerInformation(playerPawn);
+            hookContext.template make<ModelGlow>().updateSceneObjectUpdaterHook(playerPawn);
         }
 
         if (entityTypeInfo.isModelEntity())

diff --git a/Source/Features/Visuals/ModelGlow/ModelGlow.h b/Source/Features/Visuals/ModelGlow/ModelGlow.h
@@ -0,0 +1,112 @@
+#pragma once
+
+#include <CS2/Constants/ColorConstants.h>
+#include <FeatureHelpers/TeamNumber.h>
+
+#include "ModelGlowState.h"
+
+extern "C" std::uint64_t PlayerPawn_sceneObjectUpdater_asm(cs2::C_CSPlayerPawn* playerPawn) noexcept;
+extern "C" std::uint64_t PlayerPawn_sceneObjectUpdater_cpp(cs2::C_CSPlayerPawn* playerPawn) noexcept;
+
+template <typename HookContext>
+class ModelGlow {
+public:
+    ModelGlow(HookContext& hookContext) noexcept
+        : hookContext{hookContext}
+    {
+    }
+
+    void updateSceneObjectUpdaterHook(auto&& playerPawn) const noexcept
+    {
+        if (!shouldUpdateSceneObjectUpdaterHook())
+            return;
+
+        if (shouldGlowPlayerModel(playerPawn))
+            hookPlayerSceneObjectUpdater(playerPawn);
+        else
+            unhookPlayerSceneObjectUpdater(playerPawn);
+    }
+
+    void applyModelGlow(auto&& playerPawn) const noexcept
+    {
+        if (shouldRun() && shouldGlowPlayerModel(playerPawn))
+            playerPawn.baseEntity().applySpawnProtectionEffectRecursively(getColor(playerPawn));
+    }
+
+    void onEntityListTraversed() const noexcept
+    {
+        if (state().masterSwitch == ModelGlowState::State::Disabling) {
+            state().masterSwitch = ModelGlowState::State::Disabled;
+            hookContext.hooks().viewRenderHook.decrementReferenceCount();
+        }
+
+        if (state().playerModelGlow == ModelGlowState::State::Disabling)
+            state().playerModelGlow = ModelGlowState::State::Disabled;
+    }
+
+private:
+    [[nodiscard]] bool shouldUpdateSceneObjectUpdaterHook() const noexcept
+    {
+        return state().masterSwitch != ModelGlowState::State::Disabled && state().playerModelGlow != ModelGlowState::State::Disabled;
+    }
+
+    [[nodiscard]] bool shouldRun() const noexcept
+    {
+        return state().masterSwitch == ModelGlowState::State::Enabled && state().playerModelGlow == ModelGlowState::State::Enabled;
+    }
+
+    void hookPlayerSceneObjectUpdater(auto&& playerPawn) const noexcept
+    {
+        if (!hasSceneObjectUpdaterHooked(playerPawn)) {
+            storeOriginalSceneObjectUpdater(playerPawn);
+            hookSceneObjectUpdater(playerPawn);
+        }
+    }
+
+    void unhookPlayerSceneObjectUpdater(auto&& playerPawn) const noexcept
+    {
+        if (hasSceneObjectUpdaterHooked(playerPawn))
+            playerPawn.setSceneObjectUpdater(state().originalPlayerPawnSceneObjectUpdater);
+    }
+
+    void storeOriginalSceneObjectUpdater(auto&& playerPawn) const noexcept
+    {
+        if (state().originalPlayerPawnSceneObjectUpdater == nullptr)
+            state().originalPlayerPawnSceneObjectUpdater = playerPawn.getSceneObjectUpdater();
+    }
+
+    [[nodiscard]] bool hasSceneObjectUpdaterHooked(auto&& playerPawn) const noexcept
+    {
+        return playerPawn.getSceneObjectUpdater() == &PlayerPawn_sceneObjectUpdater_cpp;
+    }
+
+    void hookSceneObjectUpdater(auto&& playerPawn) const noexcept
+    {
+        playerPawn.setSceneObjectUpdater(&PlayerPawn_sceneObjectUpdater_cpp);
+    }
+
+    [[nodiscard]] bool shouldGlowPlayerModel(auto&& playerPawn) const noexcept
+    {
+        return playerPawn.isAlive().value_or(true)
+            && playerPawn.health().greaterThan(0).valueOr(true)
+            && !playerPawn.isControlledByLocalPlayer()
+            && playerPawn.isTTorCT()
+            && (!state().showOnlyEnemies || playerPawn.isEnemy().value_or(true));
+    }
+
+    [[nodiscard]] auto& state() const noexcept
+    {
+        return hookContext.featuresStates().visualFeaturesStates.modelGlowState;
+    }
+
+    [[nodiscard]] cs2::Color getColor(auto&& playerPawn) const noexcept
+    {
+        switch (playerPawn.teamNumber()) {
+        case TeamNumber::TT: return cs2::Color{255, 179, 0};
+        case TeamNumber::CT: return cs2::Color{0, 127, 255};
+        default: return cs2::kColorWhite;
+        }
+    }
+
+    HookContext& hookContext;
+};
diff --git a/Source/Features/Visuals/ModelGlow/ModelGlowState.h b/Source/Features/Visuals/ModelGlow/ModelGlowState.h
@@ -0,0 +1,18 @@
+#pragma once
+
+#include <cstdint>
+#include <CS2/Classes/Entities/C_CSPlayerPawn.h>
+
+struct ModelGlowState {
+    enum class State : std::uint8_t {
+        Enabled,
+        Disabling,
+        Disabled
+    };
+
+    State masterSwitch{State::Disabled};
+    State playerModelGlow{State::Enabled};
+    bool showOnlyEnemies{true};
+
+    std::uint64_t(*originalPlayerPawnSceneObjectUpdater)(cs2::C_CSPlayerPawn* playerPawn){nullptr};
+};
diff --git a/Source/Features/Visuals/ModelGlow/ModelGlowToggle.h b/Source/Features/Visuals/ModelGlow/ModelGlowToggle.h
@@ -0,0 +1,42 @@
+#pragma once
+
+#include <FeatureHelpers/FeatureToggle.h>
+
+template <typename HookContext>
+class ModelGlowToggle {
+public:
+    ModelGlowToggle(HookContext& hookContext) noexcept
+        : hookContext{hookContext}
+    {
+    }
+
+    void updateMasterSwitch(char option) noexcept
+    {
+        switch (option) {
+        case '0':
+            state().masterSwitch = ModelGlowState::State::Enabled;
+            hookContext.hooks().viewRenderHook.incrementReferenceCount();
+            break;
+        case '1':
+            state().masterSwitch = ModelGlowState::State::Disabling;
+            break;
+        }
+    }
+
+    void updatePlayerModelGlowToggle(char option) noexcept
+    {
+        switch (option) {
+        case '0': state().playerModelGlow = ModelGlowState::State::Enabled; state().showOnlyEnemies = true; break;
+        case '1': state().playerModelGlow = ModelGlowState::State::Enabled; state().showOnlyEnemies = false; break;
+        case '2': state().playerModelGlow = ModelGlowState::State::Disabling; break;
+        }
+    }
+
+private:
+    [[nodiscard]] auto& state() const noexcept
+    {
+        return hookContext.featuresStates().visualFeaturesStates.modelGlowState;
+    }
+
+    HookContext& hookContext;
+};
diff --git a/Source/Features/Visuals/VisualFeatures.h b/Source/Features/Visuals/VisualFeatures.h
@@ -1,6 +1,7 @@
 #pragma once
 
 #include <FeatureHelpers/FeatureHelpers.h>
+#include "ModelGlow/ModelGlowToggle.h"
 #include "PlayerInfoInWorld/PlayerInfoInWorld.h"
 #include "OutlineGlow/DefuseKitOutlineGlow/DefuseKitOutlineGlowToggle.h"
 #include "OutlineGlow/DroppedBombOutlineGlow/DroppedBombOutlineGlowToggle.h"
@@ -128,6 +129,11 @@ struct VisualFeatures {
         return hookContext.template make<HostageOutlineGlowToggle>();
     }
 
+    [[nodiscard]] decltype(auto) modelGlowToggle() const noexcept
+    {
+        return hookContext.template make<ModelGlowToggle>();
+    }
+
     HookContext& hookContext;
     VisualFeaturesStates& states;
     ViewRenderHook& viewRenderHook;

diff --git a/Source/Features/Visuals/VisualFeaturesStates.h b/Source/Features/Visuals/VisualFeaturesStates.h
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "ModelGlow/ModelGlowState.h"
 #include "PlayerInfoInWorld/PlayerInfoInWorldState.h"
 #include "OutlineGlow/DefuseKitOutlineGlow/DefuseKitOutlineGlowState.h"
 #include "OutlineGlow/DroppedBombOutlineGlow/DroppedBombOutlineGlowState.h"
@@ -20,4 +21,5 @@ struct VisualFeaturesStates {
     DroppedBombOutlineGlowState droppedBombOutlineGlowState;
     TickingBombOutlineGlowState tickingBombOutlineGlowState;
     HostageOutlineGlowState hostageOutlineGlowState;
+    ModelGlowState modelGlowState;
 };
diff --git a/Source/GameClasses/BaseEntity.h b/Source/GameClasses/BaseEntity.h
@@ -66,13 +66,35 @@ class BaseEntity {
 
     void applyGlow(cs2::Color color, int glowRange = 0) const noexcept
     {
-        renderComponent().sceneObjectUpdaters().forEachSceneObject([this, color, glowRange](auto&& sceneObject){
+        renderComponent().sceneObjectUpdaters().forEachSceneObject([this, color, glowRange](auto&& sceneObject) {
             auto&& glowSceneObject = hookContext.template make<GlowSceneObjects>().getGlowSceneObject(sceneObject);
             glowSceneObject.apply(sceneObject, color, glowRange);
             glowSceneObject.setGlowEntity(*this);
         });
     }
 
+    void applySpawnProtectionEffect(cs2::Color color) const noexcept
+    {
+        renderComponent().sceneObjectUpdaters().forEachSceneObject([this, color](auto&& sceneObject) {
+#if IS_WIN64()
+            const auto unknownEntityAttribute = getAttributeInt(0x8AD232BC, 0); // todo: find out the attribute name
+#else
+            const auto unknownEntityAttribute = 0;
+#endif
+            if (unknownEntityAttribute == 0) {
+                auto&& sceneObjectAttributes = sceneObject.attributes();
+                sceneObjectAttributes.setAttributeFloat(0x244EC9B0, 1.0f); // "SpawnInvulnerability"
+                sceneObjectAttributes.setAttributeColor3(0xB2CAF4DF, color); // "InvulnerabilityColor"
+            }
+        });
+    }
+
+    void applySpawnProtectionEffectRecursively(cs2::Color color) const noexcept
+    {
+        applySpawnProtectionEffect(color);
+        forEachChild([color](auto&& entity) { entity.applySpawnProtectionEffect(color); });
+    }
+
     [[nodiscard]] auto hasOwner() const noexcept
     {
         return hookContext.clientPatternSearchResults().template get<OffsetToOwnerEntity>().of(entity).toOptional().notEqual(cs2::CEntityHandle{cs2::INVALID_EHANDLE_INDEX});
@@ -82,7 +104,7 @@ class BaseEntity {
     {
         return TeamNumber{hookContext.clientPatternSearchResults().template get<OffsetToTeamNumber>().of(entity).valueOr({})};
     }
-    
+
     [[nodiscard]] auto vData() const noexcept
     {
         return hookContext.clientPatternSearchResults().template get<OffsetToVData>().of(entity).toOptional();
@@ -107,6 +129,13 @@ class BaseEntity {
     }
 
 private:
+    [[nodiscard]] int getAttributeInt(unsigned int attributeNameHash, int defaultValue) const noexcept
+    {
+        if (entity)
+            return hookContext.clientPatternSearchResults().template get<GetEntityAttributeInt>()(entity, attributeNameHash, defaultValue, nullptr);
+        return defaultValue;
+    }
+
     [[nodiscard]] auto invokeWithGameSceneNodeOwner(auto& f) const noexcept
     {
         return [&f](auto&& gameSceneNode) { f(gameSceneNode.owner()); };

diff --git a/Source/GameClasses/PlayerPawn.h b/Source/GameClasses/PlayerPawn.h
@@ -146,7 +146,23 @@ class PlayerPawn {
         return weaponServices().getActiveWeapon();
     }
 
+    [[nodiscard]] auto getSceneObjectUpdater() const noexcept
+    {
+        return reinterpret_cast<std::uint64_t(*)(cs2::C_CSPlayerPawn*)>(sceneObjectUpdaterHandle() ? sceneObjectUpdaterHandle()->updaterFunction : nullptr);
+    }
+
+    void setSceneObjectUpdater(auto x) const noexcept
+    {
+        if (sceneObjectUpdaterHandle())
+            sceneObjectUpdaterHandle()->updaterFunction = reinterpret_cast<std::uint64_t(*)(void*)>(x);
+    }
+
 private:
+    [[nodiscard]] auto sceneObjectUpdaterHandle() const noexcept
+    {
+        return hookContext.clientPatternSearchResults().template get<OffsetToPlayerPawnSceneObjectUpdaterHandle>().of(playerPawn).valueOr(nullptr);
+    }
+
     [[nodiscard]] decltype(auto) hostageServices() const noexcept
     {
         return hookContext.template make<HostageServices>(hookContext.clientPatternSearchResults().template get<OffsetToHostageServices>().of(playerPawn).valueOr(nullptr));