Base Modding support

Author: Alphalaneous

README.md

@@ -45,6 +45,34 @@ class $nodeModify(MyCustomCreatorLayer, CustomCreatorLayer) {
 };
 ```
 
+## Modifying Base Classes of CCNodes
+
+Using $baseModify, you can modify all nodes that inheret some class. In the following example, we modify all FLAlertLayers, not just FLAlertLayer itself. These are different than the above $nodeModify and $cobjectModify, as it requires a valid type to be passed in, thus it does not natively support modifying other mod's nodes without declaring the class beforehand.
+
+```c++
+class $baseModify(MyFLAlertLayer, FLAlertLayer) {
+
+	void modify() {
+		setScale(2.f);
+	}
+
+}
+```
+
+If you still wish to modify another mod's nodes by their base class, you can do the following.
+Let's say we had a node called AlphasEpicNode, which in itself inherets CCNode, that a lot of nodes from AlphasEpicMod inherit. Because we are defining it beforehand (make sure the definition matches that of how it is in said mod), the mod can deduce it and it's own base class names and it will work as expected.
+
+```c++
+class AlphasEpicNode : public CCNode {};
+class $baseModify(MyAlphasEpicNode, AlphasEpicNode) {
+
+	void modify() {
+		setScale(2.f);
+	}
+
+}
+```
+
 ## General Utils
 
 ### AlphaUtils::Cocos namespace:

about.md

@@ -45,6 +45,34 @@ class $nodeModify(MyCustomCreatorLayer, CustomCreatorLayer) {
 };
 ```
 
+## Modifying Base Classes of CCNodes
+
+Using $baseModify, you can modify all nodes that inheret some class. In the following example, we modify all FLAlertLayers, not just FLAlertLayer itself. These are different than the above $nodeModify and $cobjectModify, as it requires a valid type to be passed in, thus it does not natively support modifying other mod's nodes without declaring the class beforehand.
+
+```c++
+class $baseModify(MyFLAlertLayer, FLAlertLayer) {
+
+	void modify() {
+		setScale(2.f);
+	}
+
+}
+```
+
+If you still wish to modify another mod's nodes by their base class, you can do the following.
+Let's say we had a node called AlphasEpicNode, which in itself inherets CCNode, that a lot of nodes from AlphasEpicMod inherit. Because we are defining it beforehand (make sure the definition matches that of how it is in said mod), the mod can deduce it and it's own base class names and it will work as expected.
+
+```c++
+class AlphasEpicNode : public CCNode {};
+class $baseModify(MyAlphasEpicNode, AlphasEpicNode) {
+
+	void modify() {
+		setScale(2.f);
+	}
+
+}
+```
+
 ## General Utils
 
 ### AlphaUtils::Cocos namespace:

include/NodeModding.h

@@ -6,6 +6,7 @@
 #include <Geode/cocos/base_nodes/CCNode.h>
 #include "CCObject.h"
 #include "Fields.h"
+#include "Utils.h"
 
 #ifdef GEODE_IS_WINDOWS
     #ifdef ALPHALANEOUS_UTILS_API_EXPORTING
@@ -53,6 +54,40 @@ namespace AlphaUtils {
         }
     };
 
+    struct ModifyBaseInfo {
+        int priority;
+        std::function<void(FieldCCObject*)> method;
+    };
+
+    template <class Derived, class Type>
+    struct BaseWrapper : public Type {
+        geode::modifier::FieldIntermediate<Derived, Type> m_fields;
+        static int modifyPrio() { return 0; }
+    };
+
+    class ALPHA_UTILS_API_DLL BaseModding {
+    protected:
+        std::unordered_map<std::string, std::vector<ModifyBaseInfo>> m_basesToModify;
+    public:
+        bool m_lock;
+        static BaseModding* get();
+        std::unordered_map<std::string, std::vector<ModifyBaseInfo>> getBasesToModify();
+        void addBaseToModify(std::string className, int prio, std::function<void(FieldCCObject*)> func);
+        void handleBase(FieldCCObject* object);
+    };  
+
+    template <class T, class Type>
+    class ModifyBaseLoad {
+    public:
+        ModifyBaseLoad() {
+            BaseModding::get()->addBaseToModify(AlphaUtils::Cocos::getClassNameByType<Type>(), T::modifyPrio(), [](FieldCCObject* self) {
+                BaseModding::get()->m_lock = true;
+                reinterpret_cast<T*>(self)->T::modify();
+                BaseModding::get()->m_lock = false;
+            });
+        }
+    };
+
     //remnants for compat
     struct ModifyInfo {
         int priority;
@@ -105,14 +140,29 @@ class GEODE_CONCAT(GEODE_CONCAT(derived, Hook), __LINE__) : AlphaUtils::NodeWrap
 };\
 struct derived : AlphaUtils::NodeWrapper<derived>
 
+#define ALPHA_BASE_MODIFY_DECLARE(base, derived) \
+GEODE_CONCAT(GEODE_CONCAT(derived, __LINE__), Dummy);\
+struct derived;\
+class GEODE_CONCAT(GEODE_CONCAT(derived, Hook), __LINE__) : AlphaUtils::BaseWrapper<derived, base> {\
+    private:\
+    static inline AlphaUtils::ModifyBaseLoad<derived, base> s_apply{};\
+};\
+struct derived : AlphaUtils::BaseWrapper<derived, base>
+
 #define MODIFY1(base) ALPHA_MODIFY_DECLARE(base, GEODE_CONCAT(hook, __LINE__))
 #define MODIFY2(derived, base) ALPHA_MODIFY_DECLARE(base, derived)
 
 #define MODIFYNODE1(base) ALPHA_NODE_MODIFY_DECLARE(base, GEODE_CONCAT(hook, __LINE__))
 #define MODIFYNODE2(derived, base) ALPHA_NODE_MODIFY_DECLARE(base, derived)
 
+#define MODIFYBASE1(base) ALPHA_BASE_MODIFY_DECLARE(base, GEODE_CONCAT(hook, __LINE__))
+#define MODIFYBASE2(derived, base) ALPHA_BASE_MODIFY_DECLARE(base, derived)
+
 #define $nodeModify(...) \
     GEODE_INVOKE(GEODE_CONCAT(MODIFYNODE, GEODE_NUMBER_OF_ARGS(__VA_ARGS__)), __VA_ARGS__)
 
 #define $objectModify(...) \
     GEODE_INVOKE(GEODE_CONCAT(MODIFY, GEODE_NUMBER_OF_ARGS(__VA_ARGS__)), __VA_ARGS__)
+
+#define $baseModify(...) \
+    GEODE_INVOKE(GEODE_CONCAT(MODIFYBASE, GEODE_NUMBER_OF_ARGS(__VA_ARGS__)), __VA_ARGS__)

include/Utils.h

@@ -5,6 +5,7 @@
 #include <Geode/cocos/base_nodes/CCNode.h>
 #include <Geode/cocos/include/CCProtocols.h>
 #include <Geode/utils/cocos.hpp>
+#include <Geode/utils/casts.hpp>
 #include <random>
 
 #define public_cast(value, member) [](auto* v) { \
@@ -48,6 +49,67 @@ namespace AlphaUtils {
             return ret;
         }
 
+        static inline bool checkBaseClassNames(cocos2d::CCObject* obj, const std::string& name) {
+            if (!obj) return false;
+
+            auto basePtr = dynamic_cast<void*>(obj);
+            auto vftable = *reinterpret_cast<geode::cast::VftableType**>(basePtr);
+
+            auto metaPtr = static_cast<geode::cast::MetaPointerType*>(static_cast<geode::cast::CompleteVftableType*>(vftable));
+
+        #ifdef GEODE_IS_X64
+            auto locatorOffset = metaPtr->m_completeLocator->m_locatorOffset;
+            auto base = reinterpret_cast<uintptr_t>(metaPtr->m_completeLocator) - locatorOffset;
+        #else
+            auto base = 0;
+        #endif
+
+            auto classDesc = metaPtr->m_completeLocator->m_classDescriptor.into(base);
+            auto baseClassArray = classDesc->m_baseClassArray.into(base);
+            for (int32_t i = 0; i < classDesc->m_numBaseClasses; ++i) {
+                auto descriptorEntry = baseClassArray->m_descriptorEntries[i].into(base);
+                auto typeDesc = descriptorEntry->m_typeDescriptor.into(base);
+                auto optionIdent = static_cast<char const*>(
+                    typeDesc->m_typeDescriptorName
+                );
+                
+                if (std::strcmp(name.c_str(), optionIdent) == 0) {
+                    return true;
+                }
+            }
+      
+            return false;
+        }
+
+        template <class T>
+        static inline T getObject() {
+            static T obj;
+            return obj;
+        }
+
+        template <class T>
+        static inline std::string getClassNameByType() {
+            auto basePtr = dynamic_cast<void*>(getObject<T>());
+            auto vftable = *reinterpret_cast<geode::cast::VftableType**>(basePtr);
+
+            auto metaPtr = static_cast<geode::cast::MetaPointerType*>(static_cast<geode::cast::CompleteVftableType*>(vftable));
+
+        #ifdef GEODE_IS_X64
+            auto locatorOffset = metaPtr->m_completeLocator->m_locatorOffset;
+            auto base = reinterpret_cast<uintptr_t>(metaPtr->m_completeLocator) - locatorOffset;
+        #else
+            auto base = 0;
+        #endif
+
+            auto classDesc = metaPtr->m_completeLocator->m_classDescriptor.into(base);
+            auto entry = classDesc->m_baseClassArray.into(base)->m_descriptorEntries[0].into(base);
+            auto optionIdent = static_cast<char const*>(
+                entry->m_typeDescriptor.into(base)->m_typeDescriptorName
+            );
+ 
+            return optionIdent;
+        }
+
         //getChildByType but using a string instead for dynamic use.
         static inline std::optional<cocos2d::CCNode*> getChildByClassName(cocos2d::CCNode* node, std::string name, int index = 0) {
             size_t indexCounter = 0;

mod.json

@@ -8,7 +8,7 @@
 	},
 	"id": "alphalaneous.alphas_geode_utils",
 	"name": "Alpha's Geode Utils",
-	"version": "v1.1.5",
+	"version": "v1.1.6",
 	"developer": "Alphalaneous",
 	"description": "Miscellaneous utilities for Geode Modding",
 	"api": {

src/NodeModding.cpp

@@ -35,6 +35,36 @@ ObjectModding* ObjectModding::get() {
     return instance;
 }
 
+std::unordered_map<std::string, std::vector<ModifyBaseInfo>> BaseModding::getBasesToModify() {
+    return m_basesToModify;
+}
+
+void BaseModding::addBaseToModify(std::string className, int prio, std::function<void(FieldCCObject*)> func) {
+    m_basesToModify[className].push_back({prio, func});
+}
+
+void BaseModding::handleBase(FieldCCObject* object) {
+    if (m_lock) return;
+    for (auto& [key, methods] : m_basesToModify) {
+        if (AlphaUtils::Cocos::checkBaseClassNames(object, key)) {
+            std::sort(methods.begin(), methods.end(), [](auto& left, auto& right) {
+                return left.priority < right.priority;
+            });
+            for (auto& pair : methods) {
+                pair.method(object);
+            }
+        }
+    }
+}
+
+BaseModding* BaseModding::get() {
+    static BaseModding* instance = nullptr;
+    if (!instance) {
+        instance = new BaseModding();
+    }
+    return instance;
+}
+
 std::unordered_map<std::string, std::vector<ModifyInfo>> NodeModding::getNodesToModify() {
     return m_nodesToModify;
 }

src/hooks/CCObject.cpp

@@ -50,6 +50,7 @@ class $modify(CCObject) {
         FieldCCObject* obj = reinterpret_cast<FieldCCObject*>(this);
         obj->tryCreateData();
         ObjectModding::get()->handleObject(obj);
+        BaseModding::get()->handleBase(obj);
         return CCObject::autorelease();
     }
 };