simplify api, remove dependency

Author: nytelytee

CMakeLists.txt

@@ -12,12 +12,18 @@ project(WaveTrailDrawFix VERSION 1.1.0)
 
 add_library(${PROJECT_NAME} SHARED
   src/hooks/HardStreak.cpp
-  src/nodes/ColorDrawNode.cpp
   src/utilities.cpp
   src/main.cpp
+  src/api.cpp
 )
+if (CMAKE_BUILD_TYPE STREQUAL "Debug" AND WIN32)
+  target_sources(${PROJECT_NAME} PRIVATE src/debug-windows.cpp)
+endif()
+
 include_directories(${PROJECT_NAME} PUBLIC include)
 
+add_compile_definitions(NDEBUG _NDEBUG)
+
 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()

changelog.md

@@ -1,3 +1,6 @@
+# v1.1.3
+- simplify mod scope (to prevent issues with shaders)
+
 # v1.1.2
 - macOS & iOS support (thank you, hiimjasmine00)
 

include/constants.hpp

@@ -4,50 +4,8 @@
 #include <Geode/Geode.hpp>
 using namespace geode::prelude;
 
-const std::map<std::string, GLenum> blendEnumMap = {
-  {"GL_ZERO", GL_ZERO},
-  {"GL_ONE", GL_ONE},
-  {"GL_SRC_COLOR", GL_SRC_COLOR},
-  {"GL_ONE_MINUS_SRC_COLOR", GL_ONE_MINUS_SRC_COLOR},
-  {"GL_DST_COLOR", GL_DST_COLOR},
-  {"GL_ONE_MINUS_DST_COLOR", GL_ONE_MINUS_DST_COLOR},
-  {"GL_SRC_ALPHA", GL_SRC_ALPHA},
-  {"GL_ONE_MINUS_SRC_ALPHA", GL_ONE_MINUS_SRC_ALPHA},
-  {"GL_DST_ALPHA", GL_DST_ALPHA},
-  {"GL_ONE_MINUS_DST_ALPHA", GL_ONE_MINUS_DST_ALPHA},
-  //{"GL_CONSTANT_COLOR", GL_CONSTANT_COLOR},
-  //{"GL_ONE_MINUS_CONSTANT_COLOR", GL_ONE_MINUS_CONSTANT_COLOR},
-  //{"GL_CONSTANT_ALPHA", GL_CONSTANT_ALPHA},
-  //{"GL_ONE_MINUS_CONSTANT_ALPHA", GL_ONE_MINUS_CONSTANT_ALPHA},
-  {"GL_SRC_ALPHA_SATURATE", GL_SRC_ALPHA_SATURATE},
-  //{"GL_SRC1_COLOR", GL_SRC1_COLOR},
-  //{"GL_ONE_MINUS_SRC1_COLOR", GL_ONE_MINUS_SRC1_COLOR},
-  //{"GL_SRC1_ALPHA", GL_SRC1_ALPHA},
-  //{"GL_ONE_MINUS_SRC1_ALPHA", GL_ONE_MINUS_SRC1_ALPHA},
-};
-
-const std::map<std::string, _ccBlendFunc> blendFuncMap = {
-  {"additive", {GL_SRC_ALPHA, GL_ONE}},
-  {"normal", {GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA}},
-};
-
-const std::map<std::string, GLenum> blendEqMap = {
-  {"GL_FUNC_ADD", GL_FUNC_ADD},
-  {"GL_FUNC_SUBTRACT", GL_FUNC_SUBTRACT},
-  {"GL_FUNC_REVERSE_SUBTRACT", GL_FUNC_REVERSE_SUBTRACT},
-  {"GL_MIN", 0x8007},
-  {"GL_MAX", 0x8008},
-
-  {"add", GL_FUNC_ADD},
-  {"subtract", GL_FUNC_SUBTRACT},
-  {"reverse-subtract", GL_FUNC_REVERSE_SUBTRACT},
-  {"min", 0x8007},
-  {"max", 0x8008},
-};
-
 const float epsilon = 10e-6f;
 
-
 using SetConfigurationEvent = geode::DispatchEvent<matjson::Value>;
 using SetConfigurationEventResult = geode::DispatchEvent<matjson::Value, std::optional<std::string>*>;
 using GetConfigurationEvent = geode::DispatchEvent<matjson::Value*>;
@@ -60,4 +18,3 @@ using GetSpecificConfigurationEvent = geode::DispatchEvent<HardStreak*, matjson:
 using UpdateConfigurationFilter = geode::DispatchFilter<HardStreak*, matjson::Value>;
 using UpdateConfigurationFilterResult = geode::DispatchFilter<HardStreak*, matjson::Value, std::optional<std::string>*>;
 using GetSpecificConfigurationFilter = geode::DispatchFilter<HardStreak*, matjson::Value*>;
-

include/globals.hpp

@@ -2,4 +2,4 @@
 
 #include <utilities.hpp>
 
-extern std::vector<utilities::Unit> configuration;
+extern std::vector<utilities::Part> configuration;

include/hooks/HardStreak.hpp

@@ -7,9 +7,7 @@ using namespace geode::prelude;
 
 struct HookedHardStreak : Modify<HookedHardStreak, HardStreak> {
   struct Fields {
-    std::vector<utilities::Unit> m_configuration;
-    // if this is true, the configuration is invalid, and the trail will not get drawn
-    bool m_broken = false;
+    std::vector<utilities::Part> m_configuration;
   };
 
 	static void onModify(auto& self);
@@ -19,13 +17,11 @@ struct HookedHardStreak : Modify<HookedHardStreak, HardStreak> {
 
   void clearAllChildren();
 
-  void setConfiguration(std::vector<utilities::Unit>&);
+  void setConfiguration(std::vector<utilities::Part>&);
 
-  $override
-  void stopStroke();
+  void drawTriangle(CCPoint const&, CCPoint const&, CCPoint const&, ccColor4B color);
 
   $override 
 	void updateStroke(float);
 
 };
-

include/nodes/ColorDrawNode.hpp

@@ -24,30 +24,29 @@ namespace utilities {
   // people who actually know how to generate proper offset polylines: please tell me what i am missing
   void fixPoints(std::vector<CCPoint>& trailPath, float offset, std::vector<CCPoint>& points, std::vector<bool>& labels, std::vector<CCPoint>& otherPoints);
 
-  struct Part {
-    std::string type;
-    matjson::Value data;
-    float weight;
+  struct Subpart {
+    std::optional<ccColor3B> color;
+    float weight, opacity;
+    bool solidOnly, nonSolidOnly;
   };
 
-  struct Unit {
+  struct Part {
     float start, end, startOffset, endOffset;
     std::optional<float> pulseOverride, sizeOverride;
-    std::vector<Part> parts;
+    std::vector<Subpart> subparts;
   };
 
 }
 
 
 template <>
-struct matjson::Serialize<utilities::Part> {
-  static Result<utilities::Part> fromJson(const matjson::Value& value);
-  static matjson::Value toJson(const utilities::Part& part);
+struct matjson::Serialize<utilities::Subpart> {
+  static Result<utilities::Subpart> fromJson(const matjson::Value& value);
+  static matjson::Value toJson(const utilities::Subpart& subpart);
 };
 
 template <>
-struct matjson::Serialize<utilities::Unit> {
-  static Result<utilities::Unit> fromJson(const matjson::Value& value);
-  static matjson::Value toJson(const utilities::Unit& unit);
+struct matjson::Serialize<utilities::Part> {
+  static Result<utilities::Part> fromJson(const matjson::Value& value);
+  static matjson::Value toJson(const utilities::Part& part);
 };
-

include/utilities.hpp

@@ -1,14 +1,13 @@
 {
-  "geode": "4.7.0",
+  "geode": "4.8.0",
   "gd": {"android": "2.2074", "win": "2.2074", "mac": "2.2074", "ios": "2.2074"},
-  "version": "v1.1.2",
+  "version": "v1.1.3",
   "id": "nytelyte.wave_trail_draw_fix",
   "name": "Wave Trail Draw Fix",
   "developer": "NyteLyte",
   "description": "Fix the wave trail drawing algorithm.",
   "repository": "https://github.com/nytelytee/geode-wave-trail-draw-fix",
   "resources": {"files": ["resources/examples/with.png", "resources/examples/without.png", "resources/examples/with-trailfix.png"]},
   "tags": ["offline", "bugfix", "enhancement"],
-  "incompatibilities": [{"id": "sabe.trailfix", "version": "*", "importance": "conflicting"}],
-  "dependencies": [{"id": "nytelyte.wave_trail_drag_fix", "version": ">=v1.0.0", "importance": "suggested"}]
+  "incompatibilities": [{"id": "sabe.trailfix", "version": "*", "importance": "conflicting"}]
 }

mod.json

@@ -0,0 +1,60 @@
+#include <constants.hpp>
+#include <utilities.hpp>
+#include <globals.hpp>
+#include <hooks/HardStreak.hpp>
+
+using namespace geode::prelude;
+
+// there is no api header yet, there may be one in the future
+// interact with these events directly at your own risk, they can be changed at any time
+
+$execute {
+
+  // set the global configuration, silently ignore config parsing errors
+  new EventListener(+[](matjson::Value config) {
+      Result<std::vector<utilities::Part>> newConfigResult = config.as<std::vector<utilities::Part>>();
+      if (newConfigResult.isOk()) configuration = *newConfigResult.ok();
+      return ListenerResult::Stop;
+  }, SetConfigurationFilter("set-configuration"_spr));
+
+  // set the global configuration, put config parsing errors into second argument
+  new EventListener(+[](matjson::Value config, std::optional<std::string>* error) {
+      Result<std::vector<utilities::Part>> newConfigResult = config.as<std::vector<utilities::Part>>();
+      if (newConfigResult.isOk()) configuration = *newConfigResult.ok();
+      *error = newConfigResult.err();
+      return ListenerResult::Stop;
+  }, SetConfigurationFilterResult("set-configuration"_spr));
+
+  // get the global configuration
+  new EventListener(+[](matjson::Value* config) {
+      *config = configuration;
+      return ListenerResult::Stop;
+  }, GetConfigurationFilter("get-configuration"_spr));
+
+  // get the configuration of a specific HardStreak
+  new EventListener(+[](HardStreak* streak, matjson::Value* config) {
+      *config = static_cast<HookedHardStreak*>(streak)->m_fields->m_configuration;
+      return ListenerResult::Stop;
+  }, GetSpecificConfigurationFilter("get-configuration"_spr));
+
+  // these are named differently from set-configuration, as they actually update a streak's configuration explicitly
+  // HardStreaks store their configurations after they're set, so subsequent updates to the global configuration will
+  // not affect already existing HardStreaks, to explicitly change those configurations, you call these events
+  
+  // update the configuration of a specific HardStreak, silently ignore config parsing errors
+  new EventListener(+[](HardStreak* streak, matjson::Value config) {
+      Result<std::vector<utilities::Part>> newConfigResult = config.as<std::vector<utilities::Part>>();
+      if (newConfigResult.isOk()) static_cast<HookedHardStreak*>(streak)->setConfiguration(*newConfigResult);
+      return ListenerResult::Stop;
+  }, UpdateConfigurationFilter("update-configuration"_spr));
+
+  // update the configuration of a specific HardStreak, put config parsing errors into second argument
+  new EventListener(+[](HardStreak* streak, matjson::Value config, std::optional<std::string>* error) {
+      Result<std::vector<utilities::Part>> newConfigResult = config.as<std::vector<utilities::Part>>();
+      if (newConfigResult.isOk()) static_cast<HookedHardStreak*>(streak)->setConfiguration(*newConfigResult);
+      *error = newConfigResult.err();
+      return ListenerResult::Stop;
+  }, UpdateConfigurationFilterResult("update-configuration"_spr));
+
+};
+

src/api.cpp

@@ -0,0 +1,38 @@
+#include <Geode/Geode.hpp>
+using namespace geode::prelude;
+
+inline Result<> withProtectedMemory(void* address, size_t size, auto&& callback) {
+  DWORD oldProtect;
+
+  if (VirtualProtect(address, size, PAGE_READWRITE, &oldProtect)) {
+    callback(address);
+    VirtualProtect(address, size, oldProtect, &oldProtect);
+  } else
+    return Err(fmt::format("Failed to set memory protection: {}", GetLastError()));
+
+  return Ok();
+}
+
+void inlHook(uintptr_t target, uintptr_t detour) {
+  auto array = std::to_array<uint8_t>({
+    0xff, 0x25, 0x00, 0x00, 0x00, 0x00,             // jmp [rip+0]
+    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // address
+  });
+
+  std::memcpy(array.data() + 6, &detour, sizeof(uintptr_t));
+
+  auto res = withProtectedMemory(
+    reinterpret_cast<void*>(target),
+    array.size(),
+    [&](void* mem){std::memcpy(mem, array.data(), array.size());}
+  );
+
+  if (!res) log::error("{}", res.unwrapErr());
+
+}
+$execute {
+  inlHook(reinterpret_cast<uintptr_t>(&malloc), reinterpret_cast<uintptr_t>(&_malloc_base));
+  inlHook(reinterpret_cast<uintptr_t>(&calloc), reinterpret_cast<uintptr_t>(&_calloc_base));
+  inlHook(reinterpret_cast<uintptr_t>(&realloc), reinterpret_cast<uintptr_t>(&_realloc_base));
+  inlHook(reinterpret_cast<uintptr_t>(&free), reinterpret_cast<uintptr_t>(&_free_base));
+}