Merge branch 'main' into main

matcool · web-flow · commit d2b0e9e7dd5c · 2025-10-02T14:11:19.000-03:00
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -17,6 +17,10 @@ add_library(${PROJECT_NAME} SHARED ${SOURCES} src/platform/Mac.mm)
 
 set_source_files_properties(src/platform/Mac.mm PROPERTIES SKIP_PRECOMPILE_HEADERS ON)
 
+if ("${CMAKE_SYSTEM_NAME}" STREQUAL "iOS" OR IOS)
+    target_link_libraries(${PROJECT_NAME} "-framework CoreGraphics")
+endif()
+
 if (NOT DEFINED ENV{GEODE_SDK})
     message(FATAL_ERROR "Unable to find Geode SDK! Please define GEODE_SDK environment variable to point to Geode")
 else()
diff --git a/README.md b/README.md
@@ -27,7 +27,8 @@ public:
     };
 
     static void registerDevTools() {
-        // 
+        // The lambda provided will run every frame (given the node is selected)
+        // for any node that is typeinfo_cast able into MySprite
         devtools::registerNode<MySprite>([](MySprite* node) {
             devtools::label("My Sprite");
             devtools::property("Some Flag", node->m_someFlag);
@@ -60,6 +61,8 @@ private:
 $on_mod(Loaded) {
     // makes sure DevTools is loaded before registering
     devtools::waitForDevTools([] {
+        // use a static method on the class itself
+        // so it can access private members
         MySprite::registerDevTools();
     });
 }
diff --git a/changelog.md b/changelog.md
@@ -1,3 +1,8 @@
+## v1.11.0
+* Made properties api use drag inputs
+* Fix waitForDevTools on mods that load before DevTools
+* Add screenshot button to nodes (#65)
+
 ## v1.10.0
 * Add node properties api (#63)
 * Fix a crash when removing layouts and layout options (#58)
diff --git a/include/API.hpp b/include/API.hpp
@@ -68,7 +68,7 @@ namespace devtools {
             callback();
         } else {
             auto devtools = geode::Loader::get()->getInstalledMod("geode.devtools");
-            if (!devtools || !devtools->isEnabled()) return;
+            if (!devtools) return;
 
             new geode::EventListener(
                 [callback = std::forward<F>(callback)](geode::ModStateEvent*) {
diff --git a/mod.json b/mod.json
@@ -1,6 +1,6 @@
 {
-	"geode": "4.8.0",
-	"version": "v1.10.0",
+	"geode": "4.9.0",
+	"version": "v1.11.0",
 	"gd": {
 		"win": "2.2074",
 		"android": "*",
diff --git a/src/API.cpp b/src/API.cpp
@@ -9,12 +9,15 @@ template <typename T>
 static void handleType() {
     new EventListener<EventFilter<devtools::PropertyFnEvent<T>>>(+[](devtools::PropertyFnEvent<T>* event) {
         constexpr bool isSigned = std::is_signed_v<T>;
-        constexpr ImGuiDataType dataType = sizeof(T) == 1 ? (isSigned ? ImGuiDataType_S8 : ImGuiDataType_U8) :
-                                           sizeof(T) == 2 ? (isSigned ? ImGuiDataType_S16 : ImGuiDataType_U16) :
-                                           sizeof(T) == 4 ? (isSigned ? ImGuiDataType_S32 : ImGuiDataType_U32) :
-                                           isSigned ? ImGuiDataType_S64 : ImGuiDataType_U64;
+        constexpr ImGuiDataType dataType =
+            std::is_same_v<T, float> ? ImGuiDataType_Float :
+            std::is_same_v<T, double> ? ImGuiDataType_Double :
+            sizeof(T) == 1 ? (isSigned ? ImGuiDataType_S8 : ImGuiDataType_U8) :
+            sizeof(T) == 2 ? (isSigned ? ImGuiDataType_S16 : ImGuiDataType_U16) :
+            sizeof(T) == 4 ? (isSigned ? ImGuiDataType_S32 : ImGuiDataType_U32) :
+            isSigned ? ImGuiDataType_S64 : ImGuiDataType_U64;
         event->fn = +[](const char* name, T& prop) {
-            return ImGui::InputScalar(name, dataType, &prop);
+            return ImGui::DragScalar(name, dataType, &prop);
         };
         return ListenerResult::Stop;
     });
@@ -57,6 +60,8 @@ static void handleType() {
     handleType<unsigned long long>();
     handleType<long>();
     handleType<unsigned long>();
+    handleType<float>();
+    handleType<double>();
 
     // checkbox
     new EventListener<EventFilter<devtools::PropertyFnEvent<bool>>>(+[](devtools::PropertyFnEvent<bool>* event) {
@@ -66,20 +71,6 @@ static void handleType() {
         return ListenerResult::Stop;
     });
 
-    // float and double
-    new EventListener<EventFilter<devtools::PropertyFnEvent<float>>>(+[](devtools::PropertyFnEvent<float>* event) {
-        event->fn = +[](const char* name, float& prop) {
-            return ImGui::InputFloat(name, &prop);
-        };
-        return ListenerResult::Stop;
-    });
-    new EventListener<EventFilter<devtools::PropertyFnEvent<double>>>(+[](devtools::PropertyFnEvent<double>* event) {
-        event->fn = +[](const char* name, double& prop) {
-            return ImGui::InputDouble(name, &prop);
-        };
-        return ListenerResult::Stop;
-    });
-
     // string
     new EventListener<EventFilter<devtools::PropertyFnEvent<std::string>>>(+[](devtools::PropertyFnEvent<std::string>* event) {
         event->fn = +[](const char* name, std::string& prop) {
@@ -136,20 +127,20 @@ static void handleType() {
     // points/sizes
     new EventListener<EventFilter<devtools::PropertyFnEvent<CCPoint>>>(+[](devtools::PropertyFnEvent<CCPoint>* event) {
         event->fn = +[](const char* name, CCPoint& prop) {
-            return ImGui::InputFloat2(name, reinterpret_cast<float*>(&prop));
+            return ImGui::DragFloat2(name, reinterpret_cast<float*>(&prop));
         };
         return ListenerResult::Stop;
     });
 
     new EventListener<EventFilter<devtools::PropertyFnEvent<CCSize>>>(+[](devtools::PropertyFnEvent<CCSize>* event) {
         event->fn = +[](const char* name, CCSize& prop) {
-            return ImGui::InputFloat2(name, reinterpret_cast<float*>(&prop));
+            return ImGui::DragFloat2(name, reinterpret_cast<float*>(&prop));
         };
         return ListenerResult::Stop;
     });
     new EventListener<EventFilter<devtools::PropertyFnEvent<CCRect>>>(+[](devtools::PropertyFnEvent<CCRect>* event) {
         event->fn = +[](const char* name, CCRect& prop) {
-            return ImGui::InputFloat4(name, reinterpret_cast<float*>(&prop));
+            return ImGui::DragFloat4(name, reinterpret_cast<float*>(&prop));
         };
         return ListenerResult::Stop;
     });
diff --git a/src/DevTools.cpp b/src/DevTools.cpp
@@ -289,6 +289,10 @@ void DevTools::toggle() {
     this->show(!m_visible);
 }
 
+bool DevTools::isVisible() {
+    return m_visible;
+}
+
 void DevTools::sceneChanged() {
     m_selectedNode = nullptr;
 }
diff --git a/src/DevTools.hpp b/src/DevTools.hpp
@@ -124,4 +124,6 @@ class DevTools {
 
     void show(bool visible);
     void toggle();
+
+    bool isVisible();
 };
diff --git a/src/main.cpp b/src/main.cpp
@@ -6,6 +6,7 @@
 #include <Geode/modify/CCDirector.hpp>
 #include <Geode/modify/CCEGLView.hpp>
 #include <Geode/modify/CCNode.hpp>
+#include <Geode/modify/GameToolbox.hpp>
 #include "DevTools.hpp"
 #include <imgui.h>
 #include "ImGui.hpp"
@@ -55,6 +56,31 @@ class $modify(CCScene) {
 
 #endif
 
+class $modify(GameToolbox) {
+    static void preVisitWithClippingRect(CCNode* node, CCRect clipRect) {
+        if (!node->isVisible() || !DevTools::get()->isVisible())
+            return GameToolbox::preVisitWithClippingRect(node, clipRect);
+
+        glEnable(GL_SCISSOR_TEST);
+
+        clipRect.origin = node->convertToWorldSpace(clipRect.origin);
+
+        kmMat4 mat;
+        kmGLGetMatrix(KM_GL_PROJECTION, &mat);
+        if (mat.mat[5] < 0) {
+            auto ws = CCDirector::get()->getWinSize();
+            clipRect.origin.y = ws.height - (clipRect.origin.y + node->getContentSize().height);
+        }
+
+        CCEGLView::get()->setScissorInPoints(
+            clipRect.origin.x,
+            clipRect.origin.y,
+            clipRect.size.width,
+            clipRect.size.height
+        );
+    }
+
+};
 
 
 class $modify(CCDirector) {
diff --git a/src/pages/Attributes.cpp b/src/pages/Attributes.cpp
@@ -7,13 +7,15 @@
 #include <ccTypes.h>
 #include <Geode/ui/SimpleAxisLayout.hpp>
 #include <Geode/ui/Layout.hpp>
+#include <Geode/utils/file.hpp>
 
 using namespace geode::prelude;
 
 #define AXIS_GET(Name_) \
     &AxisLayoutOptions::get##Name_, \
     &AxisLayoutOptions::set##Name_
 
+
 template <class T, class R>
 bool checkbox(const char* text, T* ptr, bool(T::* get)(), R(T::* set)(bool)) {
     bool value = (ptr->*get)();
@@ -72,8 +74,26 @@ void DevTools::drawBasicAttributes(CCNode* node) {
     }
     ImGui::SameLine();
     if (ImGui::Button(U8STR(FEATHER_COPY " Copy Class Name"))) {
-        clipboard::write(getNodeName(node));
+        clipboard::write(std::string(geode::cocos::getObjectName(node)));
+    }
+    ImGui::SameLine();
+    if (ImGui::Button(U8STR(FEATHER_SAVE " Screenshot"))) {
+        file::pick(file::PickMode::SaveFile, file::FilePickOptions {
+            .filters = {{ .description = "PNG Image", .files = {"*.png"} }}
+        }).listen([node](auto choice) {
+            if (auto file = choice->ok()) {
+                int width, height;
+                auto bytes = renderToBytes(node, width, height);
+
+                auto path = string::pathToString(*file);
+                if (!path.ends_with(".png")) {
+                    path += ".png";
+                }
+                saveRenderToFile(bytes, width, height, path.c_str());
+            }
+        });
     }
+
     ImGui::Text("Address: %s", fmt::to_string(fmt::ptr(node)).c_str());
     ImGui::SameLine();
     if (ImGui::Button(U8STR(FEATHER_COPY " Copy"))) {
diff --git a/src/pages/Tree.cpp b/src/pages/Tree.cpp
@@ -37,7 +37,7 @@ void DevTools::drawTreeBranch(CCNode* node, size_t index) {
     }
 
     std::stringstream name;
-    name << "[" << index << "] " << getNodeName(node) << " ";
+    name << "[" << index << "] " << geode::cocos::getObjectName(node) << " ";
     if (node->getTag() != -1) {
         name << "(" << node->getTag() << ") ";
     }
diff --git a/src/platform/Android.cpp b/src/platform/Android.cpp
@@ -7,9 +7,10 @@ using namespace geode::prelude;
 #include "utils.hpp"
 
 std::string formatAddressIntoOffsetImpl(uintptr_t addr, bool module) {
-    if (addr > base::get() && addr - 0x1000000 < base::get())
+    if (addr > base::get() && addr - 0x1000000 < base::get()) {
         if(module) return fmt::format("libcocos2d.so + {:#x}", addr - base::get());
         else return fmt::format("{:#x}", addr - base::get());
+    }
     return fmt::format("{:#x}", addr);
 }
 
diff --git a/src/platform/Mac.mm b/src/platform/Mac.mm
@@ -5,6 +5,8 @@
 #include "utils.hpp"
 
 #include <Geode/utils/string.hpp>
+#include <Geode/utils/file.hpp>
+#include <Geode/loader/Log.hpp>
 #include <array>
 #include <thread>
 #include <execinfo.h>
@@ -18,6 +20,13 @@
 #include <mach-o/dyld.h>
 #import <Foundation/Foundation.h>
 
+#import <CoreGraphics/CoreGraphics.h>
+#ifdef GEODE_IS_MACOS
+#include <ImageIO/CGImageDestination.h>
+#else 
+#import <UIKit/UIKit.h>
+#endif
+
 static std::vector<struct dyld_image_info const*> getAllImages() {
     std::vector<struct dyld_image_info const*> images;
     struct task_dyld_info dyldInfo;
@@ -86,4 +95,5 @@
     else return fmt::format("{:#x}", addr - base);
 }
 
+
 #endif
diff --git a/src/platform/utils.cpp b/src/platform/utils.cpp
@@ -1,6 +1,14 @@
 #include "utils.hpp"
 
+#if defined(GEODE_IS_MACOS)
+#include <OpenGL/gl.h>
+#elif defined(GEODE_IS_IOS)
+#include <OpenGLES/ES2/gl.h>
+#endif
 #include <unordered_map>
+#include <cocos2d.h>
+
+using namespace cocos2d;
 
 std::string formatAddressIntoOffset(uintptr_t addr, bool module) {
     static std::unordered_map<uintptr_t, std::pair<std::string, std::string>> formatted;
@@ -16,4 +24,92 @@ std::string formatAddressIntoOffset(uintptr_t addr, bool module) {
         if(module) return pair.first;
         else return pair.second;
     }
+}
+
+std::vector<uint8_t> renderToBytes(CCNode* node, int& width, int& height) {
+    // Get scale from cocos2d units to opengl units
+    GLint viewport[4];
+    glGetIntegerv(GL_VIEWPORT, viewport);
+    auto winSize = CCDirector::get()->getWinSize();
+
+    width = node->getContentSize().width * (viewport[2] / winSize.width);
+    height = node->getContentSize().height * (viewport[3] / winSize.height);
+
+    // Create Texture
+    GLuint texture;
+    glGenTextures(1, &texture);
+    glBindTexture(GL_TEXTURE_2D, texture);
+    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+    // Create Framebuffer Object
+    GLuint fbo;
+    glGenFramebuffers(1, &fbo);
+    glBindFramebuffer(GL_FRAMEBUFFER, fbo);
+    glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
+
+    // Unbind texture
+    glBindTexture(GL_TEXTURE_2D, 0);
+
+    // Clear any data
+    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
+
+    // Flip Y when projecting
+    kmGLMatrixMode(KM_GL_PROJECTION);
+    kmGLPushMatrix();
+    kmGLLoadIdentity();
+
+    kmMat4 ortho;
+    kmMat4OrthographicProjection(&ortho,
+        0.0f, winSize.width,
+        winSize.height, 0.0f,
+        -1.0f, 1.0f
+    );
+    kmGLMultMatrix(&ortho);
+
+    // Transform matrix so the node is drawn at 0,0
+    kmGLMatrixMode(KM_GL_MODELVIEW);
+    kmGLPushMatrix();
+    kmGLLoadIdentity();
+
+    auto anchor = node->isIgnoreAnchorPointForPosition() ? ccp(0, 0) : node->getAnchorPointInPoints();
+    kmGLTranslatef(
+        anchor.x - node->getPositionX(),
+        anchor.y - node->getPositionY() + (winSize.height - node->getContentSize().height),
+        0
+    );
+
+    // Visit
+    node->visit();              
+
+    // Undo matrix transformations
+    kmGLPopMatrix();
+    kmGLMatrixMode(KM_GL_PROJECTION);
+    kmGLPopMatrix();
+    kmGLMatrixMode(KM_GL_MODELVIEW);
+
+    // Read from Framebuffer
+    std::vector<unsigned char> pixels(width * height * 4); // RGBA8
+    glReadPixels(
+        0, 0, width, height,
+        GL_RGBA, GL_UNSIGNED_BYTE,
+        pixels.data()
+    );
+
+    // Unbind Framebuffer
+    glBindFramebuffer(GL_FRAMEBUFFER, 0);
+
+    // Delete
+    glDeleteFramebuffers(1, &fbo);
+    glDeleteTextures(1, &texture);
+
+    return pixels;
+}
+
+void saveRenderToFile(std::vector<uint8_t> const& data, int width, int height, char const* filename) {
+    auto img = new CCImage();
+    img->initWithImageData((void*)data.data(), data.size(), CCImage::kFmtRawData, width, height, 8);
+    img->saveToFile(filename, false);
 }
diff --git a/src/platform/utils.hpp b/src/platform/utils.hpp

Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`{`
`2`		`- "geode": "4.8.0",`
`3`		`- "version": "v1.10.0",`
	`2`	`+ "geode": "4.9.0",`
	`3`	`+ "version": "v1.11.0",`
`4`	`4`	`"gd": {`
`5`	`5`	`"win": "2.2074",`
`6`	`6`	`"android": "*",`
Original file line number	Diff line number	Diff line change
`@@ -289,6 +289,10 @@ void DevTools::toggle() {`
`289`	`289`	`this->show(!m_visible);`
`290`	`290`	`}`
`291`	`291`
	`292`	`+bool DevTools::isVisible() {`
	`293`	`+ return m_visible;`
	`294`	`+}`
	`295`	`+`
`292`	`296`	`void DevTools::sceneChanged() {`
`293`	`297`	`m_selectedNode = nullptr;`
`294`	`298`	`}`