7cc5c4f330d47060/geode
1
0
Fork 0
mirror of https://github.com/geode-sdk/geode.git synced 2024-11-30 03:15:38 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge pull request #94 from altalk23/altalk

Browse source 
fix events and cleanup
This commit is contained in:
alk 2022-12-07 13:34:48 +03:00 committed by GitHub
commit 6e2784d3ef
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
21 changed files with 318 additions and 257 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
.clang-format
View file

@ -3,6 +3,7 @@ IndentWidth: 4
AlignAfterOpenBracket: BlockIndent AlignAfterOpenBracket: BlockIndent
AlignEscapedNewlines: Left AlignEscapedNewlines: Left
AlignConsecutiveAssignments: false
AlignOperands: DontAlign AlignOperands: DontAlign
AlignTrailingComments: false AlignTrailingComments: false
@ -22,7 +23,7 @@ AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: true AlwaysBreakBeforeMultilineStrings: true
AlwaysBreakTemplateDeclarations: Yes AlwaysBreakTemplateDeclarations: Yes
BinPackArguments: true BinPackArguments: false
BinPackParameters: true BinPackParameters: true
BraceWrapping: BraceWrapping:
@ -49,7 +50,7 @@ BraceWrapping:
BreakBeforeBinaryOperators: None BreakBeforeBinaryOperators: None
BreakBeforeBraces: Custom BreakBeforeBraces: Custom
BreakBeforeConceptDeclarations: true BreakBeforeConceptDeclarations: true
BreakBeforeTernaryOperators: true BreakBeforeTernaryOperators: false
BreakConstructorInitializers: AfterColon BreakConstructorInitializers: AfterColon
BreakInheritanceList: AfterColon BreakInheritanceList: AfterColon
BreakStringLiterals: true BreakStringLiterals: true
@ -57,7 +58,7 @@ ColumnLimit: 100
CompactNamespaces: false CompactNamespaces: false
ConstructorInitializerIndentWidth: 4 ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4 ContinuationIndentWidth: 4
Cpp11BracedListStyle: false Cpp11BracedListStyle: true
DeriveLineEnding: false DeriveLineEnding: false
UseCRLF: false UseCRLF: false
@ -103,7 +104,7 @@ PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000 PenaltyBreakString: 1000
PenaltyBreakOpenParenthesis: 0 PenaltyBreakOpenParenthesis: 0
PenaltyBreakTemplateDeclaration: 10 PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000 PenaltyExcessCharacter: 10
PenaltyReturnTypeOnItsOwnLine: 1000000 PenaltyReturnTypeOnItsOwnLine: 1000000
PenaltyIndentedWhitespace: 0 PenaltyIndentedWhitespace: 0
@ -122,7 +123,7 @@ SpaceAfterTemplateKeyword: true
SpaceAroundPointerQualifiers: Default SpaceAroundPointerQualifiers: Default
SpaceBeforeAssignmentOperators: true SpaceBeforeAssignmentOperators: true
SpaceBeforeCaseColon: false SpaceBeforeCaseColon: false
SpaceBeforeCpp11BracedList: true SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements SpaceBeforeParens: ControlStatements

87
loader/include/Geode/DefaultInclude.hpp
View file

@ -71,8 +71,7 @@ namespace cocos2d::extension {}
#define GEODE_FILL_CONSTRUCTOR(Class_, Offset_) \ #define GEODE_FILL_CONSTRUCTOR(Class_, Offset_) \
Class_(std::monostate, size_t fill) : \ Class_(std::monostate, size_t fill) : \
Class_({}, std::memset(reinterpret_cast<std::byte*>(this) + Offset_, 0, fill - Offset_)) { \ Class_({}, std::memset(reinterpret_cast<std::byte*>(this) + Offset_, 0, fill - Offset_)) {} \
} \
Class_(std::monostate, void*) Class_(std::monostate, void*)
#define GEODE_MONOSTATE_CONSTRUCTOR_BEGIN(Class_) \ #define GEODE_MONOSTATE_CONSTRUCTOR_BEGIN(Class_) \
@ -97,10 +96,71 @@ namespace cocos2d::extension {}
GEODE_EXPAND(GEODE_NUMBER_OF_ARGS_(__VA_ARGS__, GEODE_NUMBER_SEQUENCE(), )) GEODE_EXPAND(GEODE_NUMBER_OF_ARGS_(__VA_ARGS__, GEODE_NUMBER_SEQUENCE(), ))
#define GEODE_NUMBER_OF_ARGS_(...) GEODE_EXPAND(GEODE_NUMBER_OF_ARGS_N(__VA_ARGS__)) #define GEODE_NUMBER_OF_ARGS_(...) GEODE_EXPAND(GEODE_NUMBER_OF_ARGS_N(__VA_ARGS__))
#define GEODE_NUMBER_OF_ARGS_N( \ #define GEODE_NUMBER_OF_ARGS_N( \
_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, _11, _12, _13, _14, _15, _16, _17, _18, _19, _20, \ _1, \
_21, _22, _23, _24, _25, _26, _27, _28, _29, _30, _31, _32, _33, _34, _35, _36, _37, _38, _39, \ _2, \
_40, _41, _42, _43, _44, _45, _46, _47, _48, _49, _50, _51, _52, _53, _54, _55, _56, _57, _58, \ _3, \
_59, _60, _61, _62, _63, N, ... \ _4, \
_5, \
_6, \
_7, \
_8, \
_9, \
_10, \
_11, \
_12, \
_13, \
_14, \
_15, \
_16, \
_17, \
_18, \
_19, \
_20, \
_21, \
_22, \
_23, \
_24, \
_25, \
_26, \
_27, \
_28, \
_29, \
_30, \
_31, \
_32, \
_33, \
_34, \
_35, \
_36, \
_37, \
_38, \
_39, \
_40, \
_41, \
_42, \
_43, \
_44, \
_45, \
_46, \
_47, \
_48, \
_49, \
_50, \
_51, \
_52, \
_53, \
_54, \
_55, \
_56, \
_57, \
_58, \
_59, \
_60, \
_61, \
_62, \
_63, \
N, \
... \
) \ ) \
N N
#define GEODE_NUMBER_SEQUENCE() \ #define GEODE_NUMBER_SEQUENCE() \
@ -108,6 +168,21 @@ namespace cocos2d::extension {}
40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, \ 40, 39, 38, 37, 36, 35, 34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, \
18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 18, 17, 16, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0
#define $execute \
template <class> \
void GEODE_CONCAT(geodeExecFunction, __LINE__)(); \
namespace { \
struct GEODE_CONCAT(ExecFuncUnique, __LINE__) {}; \
} \
static inline auto GEODE_CONCAT(Exec, __LINE__) = \
(Loader::get()->scheduleOnModLoad( \
getMod(), \
&GEODE_CONCAT(geodeExecFunction, __LINE__) < GEODE_CONCAT(ExecFuncUnique, __LINE__) > \
), \
0); \
template <class> \
void GEODE_CONCAT(geodeExecFunction, __LINE__)()
// #define GEODE_NEST1(macro, begin) \ // #define GEODE_NEST1(macro, begin) \
// macro(GEODE_CONCAT(begin, 0)), \ // macro(GEODE_CONCAT(begin, 0)), \
// macro(GEODE_CONCAT(begin, 1)), \ // macro(GEODE_CONCAT(begin, 1)), \

21
loader/include/Geode/loader/Event.hpp
View file

@ -1,5 +1,6 @@
#pragma once #pragma once
#include "../utils/casts.hpp"
#include "Mod.hpp" #include "Mod.hpp"
#include <Geode/DefaultInclude.hpp> #include <Geode/DefaultInclude.hpp>
@ -45,8 +46,7 @@ namespace geode {
}; };
template <typename T> template <typename T>
concept is_filter = concept is_filter = std::is_base_of_v<EventFilter<typename T::Event>, T> &&
std::is_base_of_v<EventFilter<typename T::Event>, T> &&
requires(T a) { requires(T a) {
a.handle(std::declval<typename T::Callback>(), std::declval<typename T::Event*>()); a.handle(std::declval<typename T::Callback>(), std::declval<typename T::Event*>());
}; };
@ -55,11 +55,13 @@ namespace geode {
class EventListener : public EventListenerProtocol { class EventListener : public EventListenerProtocol {
public: public:
using Callback = typename T::Callback; using Callback = typename T::Callback;
template <typename C> requires std::is_class_v<C> template <typename C>
requires std::is_class_v<C>
using MemberFn = typename to_member<C, Callback>::value; using MemberFn = typename to_member<C, Callback>::value;
ListenerResult passThrough(Event* e) override { ListenerResult passThrough(Event* e) override {
if (auto myev = dynamic_cast<typename T::Event*>(e)) { // it is so silly to use dynamic cast in an interbinary context
if (auto myev = cast::typeinfo_cast<typename T::Event*>(e)) {
return m_filter.handle(m_callback, myev); return m_filter.handle(m_callback, myev);
} }
return ListenerResult::Propagate; return ListenerResult::Propagate;
@ -68,25 +70,31 @@ namespace geode {
EventListener(T filter = T()) { EventListener(T filter = T()) {
this->enable(); this->enable();
} }
EventListener(std::function<Callback> fn, T filter = T()) : m_callback(fn), m_filter(filter) {
EventListener(std::function<Callback> fn, T filter = T()) :
m_callback(fn), m_filter(filter) {
this->enable(); this->enable();
} }
EventListener(Callback* fnptr, T filter = T()) : m_callback(fnptr), m_filter(filter) { EventListener(Callback* fnptr, T filter = T()) : m_callback(fnptr), m_filter(filter) {
this->enable(); this->enable();
} }
template <class C> template <class C>
EventListener(C* cls, MemberFn<C> fn, T filter = T()) : EventListener(std::bind(fn, cls, std::placeholders::_1), filter) { EventListener(C* cls, MemberFn<C> fn, T filter = T()) :
EventListener(std::bind(fn, cls, std::placeholders::_1), filter) {
this->enable(); this->enable();
} }
void bind(std::function<Callback> fn) { void bind(std::function<Callback> fn) {
m_callback = fn; m_callback = fn;
} }
template <typename C> template <typename C>
void bind(C* cls, MemberFn<C> fn) { void bind(C* cls, MemberFn<C> fn) {
m_callback = std::bind(fn, cls, std::placeholders::_1); m_callback = std::bind(fn, cls, std::placeholders::_1);
} }
protected: protected:
std::function<Callback> m_callback; std::function<Callback> m_callback;
T m_filter; T m_filter;
@ -96,6 +104,7 @@ namespace geode {
static std::unordered_set<EventListenerProtocol*> s_listeners; static std::unordered_set<EventListenerProtocol*> s_listeners;
Mod* m_sender; Mod* m_sender;
friend EventListenerProtocol; friend EventListenerProtocol;
public: public:
void postFrom(Mod* sender); void postFrom(Mod* sender);

15
loader/include/Geode/loader/ModEvent.hpp
View file

@ -1,9 +1,10 @@
#pragma once #pragma once
#include "Event.hpp" #include "Event.hpp"
#include <optional>
#include "Mod.hpp" #include "Mod.hpp"
#include <optional>
namespace geode { namespace geode {
enum class ModEventType { enum class ModEventType {
Loaded, Loaded,
@ -45,13 +46,17 @@ void GEODE_CONCAT(geodeExecFunction, __LINE__)(ModStateEvent*); \
namespace { \ namespace { \
struct GEODE_CONCAT(ExecFuncUnique, __LINE__) {}; \ struct GEODE_CONCAT(ExecFuncUnique, __LINE__) {}; \
} \ } \
static inline auto GEODE_CONCAT(Exec, __LINE__) = (geode::Loader::get()->scheduleOnModLoad(\ static inline auto GEODE_CONCAT(Exec, __LINE__) = \
geode::Mod::get(), []() { \ (geode::Loader::get()->scheduleOnModLoad( \
geode::Mod::get(), \
[]() { \
static auto _ = geode::EventListener( \ static auto _ = geode::EventListener( \
&GEODE_CONCAT(geodeExecFunction, __LINE__)<GEODE_CONCAT(ExecFuncUnique, __LINE__)>,\ &GEODE_CONCAT(geodeExecFunction, __LINE__) < \
GEODE_CONCAT(ExecFuncUnique, __LINE__) >, \
geode::ModStateFilter(geode::Mod::get(), geode::ModEventType::type) \ geode::ModStateFilter(geode::Mod::get(), geode::ModEventType::type) \
); \ ); \
} \ } \
), 0); \ ), \
0); \
template <class> \ template <class> \
void GEODE_CONCAT(geodeExecFunction, __LINE__)(ModStateEvent*) void GEODE_CONCAT(geodeExecFunction, __LINE__)(ModStateEvent*)

18
loader/include/Geode/modify/InternalMacros.hpp
View file

@ -55,21 +55,3 @@
* Useful for callbacks * Useful for callbacks
*/ */
#define $cls std::remove_pointer<decltype(this)>::type #define $cls std::remove_pointer<decltype(this)>::type
#define GEODE_ONLY_FIELD(type, field_, default_) private: field<type> field_ = default_; public:
#define GEODE_INTERNAL_FIELD(type, field, name) inline type& name() { return this->*field; }
//#define GEODE_EXTERNAL_FIELD(type, field, name) static inline type& name##From(void* self) { return reinterpret_cast<decltype(this)>(self)->*field; }
#define GEODE_FIELD(type, field, name, default_) GEODE_ONLY_FIELD(type, field, default_) GEODE_INTERNAL_FIELD(type, field, name) //GEODE_EXTERNAL_FIELD(type, field, name)
#define $execute \
template<class> \
void GEODE_CONCAT(geodeExecFunction, __LINE__)(); \
namespace { \
struct GEODE_CONCAT(ExecFuncUnique, __LINE__) {}; \
} \
static inline auto GEODE_CONCAT(Exec, __LINE__) = (Loader::get()->scheduleOnModLoad(\
nullptr, &GEODE_CONCAT(geodeExecFunction, __LINE__)<GEODE_CONCAT(ExecFuncUnique, __LINE__)> \
), 0); \
template<class> \
void GEODE_CONCAT(geodeExecFunction, __LINE__)()

13
loader/include/Geode/utils/JsonValidation.hpp
View file

@ -1,7 +1,7 @@
#pragma once #pragma once
#include "../loader/Log.hpp"
#include "../external/json/json.hpp" #include "../external/json/json.hpp"
#include "../loader/Log.hpp"
#include <set> #include <set>
#include <variant> #include <variant>
@ -15,9 +15,7 @@ namespace geode {
template <typename T> template <typename T>
struct is_iterable< struct is_iterable<
T, T, std::void_t<decltype(std::begin(std::declval<T>())), decltype(std::end(std::declval<T>()))>> :
std::void_t<
decltype(std::begin(std::declval<T>())), decltype(std::end(std::declval<T>()))>> :
std::true_type {}; std::true_type {};
template <typename T> template <typename T>
@ -79,7 +77,7 @@ namespace geode {
} }
template <class T> template <class T>
using JsonValueValidator = bool (*)(T const&); using JsonValueValidator = std::function<bool(T const&)>;
template <class Json> template <class Json>
struct JsonMaybeObject; struct JsonMaybeObject;
@ -175,6 +173,11 @@ namespace geode {
return *this; return *this;
} }
template <class T>
JsonMaybeValue<Json>& validate(bool (*validator)(T const&)) {
return this->validate(std::function(validator));
}
template <class T> template <class T>
JsonMaybeValue<Json>& inferType() { JsonMaybeValue<Json>& inferType() {
if (this->isError() || !m_inferType) return *this; if (this->isError() || !m_inferType) return *this;

50
loader/include/Geode/utils/cocos.hpp
View file

@ -1,8 +1,9 @@
#pragma once #pragma once
#include "casts.hpp"
#include "../external/json/json.hpp" #include "../external/json/json.hpp"
#include "casts.hpp"
#include "general.hpp" #include "general.hpp"
#include <Geode/DefaultInclude.hpp> #include <Geode/DefaultInclude.hpp>
#include <cocos2d.h> #include <cocos2d.h>
#include <functional> #include <functional>
@ -283,6 +284,7 @@ namespace geode {
bool operator==(T* other) const { bool operator==(T* other) const {
return m_obj == other; return m_obj == other;
} }
bool operator==(Ref<T> const& other) const { bool operator==(Ref<T> const& other) const {
return m_obj == other.m_obj; return m_obj == other.m_obj;
} }
@ -290,6 +292,7 @@ namespace geode {
bool operator!=(T* other) const { bool operator!=(T* other) const {
return m_obj != other; return m_obj != other;
} }
bool operator!=(Ref<T> const& other) const { bool operator!=(Ref<T> const& other) const {
return m_obj != other.m_obj; return m_obj != other.m_obj;
} }
@ -298,6 +301,7 @@ namespace geode {
bool operator<(Ref<T> const& other) const { bool operator<(Ref<T> const& other) const {
return m_obj < other.m_obj; return m_obj < other.m_obj;
} }
bool operator>(Ref<T> const& other) const { bool operator>(Ref<T> const& other) const {
return m_obj > other.m_obj; return m_obj > other.m_obj;
} }
@ -435,7 +439,7 @@ namespace geode::cocos {
*/ */
GEODE_DLL cocos2d::CCScene* switchToScene(cocos2d::CCLayer* layer); GEODE_DLL cocos2d::CCScene* switchToScene(cocos2d::CCLayer* layer);
using CreateLayerFunc = cocos2d::CCLayer*(*)(); using CreateLayerFunc = std::function<cocos2d::CCLayer*()>;
/** /**
* Reload textures, overwriting the scene to return to after the loading * Reload textures, overwriting the scene to return to after the loading
@ -453,9 +457,7 @@ namespace geode::cocos {
* @param def Default size * @param def Default size
* @param min Minimum size * @param min Minimum size
*/ */
GEODE_DLL void limitNodeSize( GEODE_DLL void limitNodeSize(cocos2d::CCNode* node, cocos2d::CCSize const& size, float def, float min);
cocos2d::CCNode* node, cocos2d::CCSize const& size, float def, float min
);
/** /**
* Checks if a node is visible (recursively * Checks if a node is visible (recursively
@ -497,8 +499,7 @@ namespace geode::cocos {
for (int i = 0; i < children->count(); ++i) { for (int i = 0; i < children->count(); ++i) {
auto newParent = static_cast<cocos2d::CCNode*>(children->objectAtIndex(i)); auto newParent = static_cast<cocos2d::CCNode*>(children->objectAtIndex(i));
auto child = findFirstChildRecursive(newParent, predicate); auto child = findFirstChildRecursive(newParent, predicate);
if (child) if (child) return child;
return child;
} }
return nullptr; return nullptr;
@ -602,12 +603,17 @@ namespace geode::cocos {
} }
inline cocos2d::ccColor4B invert4B(cocos2d::ccColor4B const& color) { inline cocos2d::ccColor4B invert4B(cocos2d::ccColor4B const& color) {
return { static_cast<GLubyte>(255 - color.r), static_cast<GLubyte>(255 - color.g), return {
static_cast<GLubyte>(255 - color.b), color.a }; static_cast<GLubyte>(255 - color.r),
static_cast<GLubyte>(255 - color.g),
static_cast<GLubyte>(255 - color.b),
color.a};
} }
inline cocos2d::ccColor3B invert3B(cocos2d::ccColor3B const& color) { inline cocos2d::ccColor3B invert3B(cocos2d::ccColor3B const& color) {
return { static_cast<GLubyte>(255 - color.r), static_cast<GLubyte>(255 - color.g), return {
static_cast<GLubyte>(255 - color.r),
static_cast<GLubyte>(255 - color.g),
static_cast<GLubyte>(255 - color.b)}; static_cast<GLubyte>(255 - color.b)};
} }
@ -637,19 +643,23 @@ namespace geode::cocos {
constexpr cocos2d::ccColor3B cc3x(int hexValue) { constexpr cocos2d::ccColor3B cc3x(int hexValue) {
if (hexValue <= 0xf) if (hexValue <= 0xf)
return cocos2d::ccColor3B { static_cast<GLubyte>(hexValue * 17), return cocos2d::ccColor3B{
static_cast<GLubyte>(hexValue * 17),
static_cast<GLubyte>(hexValue * 17), static_cast<GLubyte>(hexValue * 17),
static_cast<GLubyte>(hexValue * 17)}; static_cast<GLubyte>(hexValue * 17)};
if (hexValue <= 0xff) if (hexValue <= 0xff)
return cocos2d::ccColor3B { static_cast<GLubyte>(hexValue), return cocos2d::ccColor3B{
static_cast<GLubyte>(hexValue),
static_cast<GLubyte>(hexValue), static_cast<GLubyte>(hexValue),
static_cast<GLubyte>(hexValue)}; static_cast<GLubyte>(hexValue)};
if (hexValue <= 0xfff) if (hexValue <= 0xfff)
return cocos2d::ccColor3B { static_cast<GLubyte>((hexValue >> 8 & 0xf) * 17), return cocos2d::ccColor3B{
static_cast<GLubyte>((hexValue >> 8 & 0xf) * 17),
static_cast<GLubyte>((hexValue >> 4 & 0xf) * 17), static_cast<GLubyte>((hexValue >> 4 & 0xf) * 17),
static_cast<GLubyte>((hexValue >> 0 & 0xf) * 17)}; static_cast<GLubyte>((hexValue >> 0 & 0xf) * 17)};
else else
return cocos2d::ccColor3B { static_cast<GLubyte>(hexValue >> 16 & 0xff), return cocos2d::ccColor3B{
static_cast<GLubyte>(hexValue >> 16 & 0xff),
static_cast<GLubyte>(hexValue >> 8 & 0xff), static_cast<GLubyte>(hexValue >> 8 & 0xff),
static_cast<GLubyte>(hexValue >> 0 & 0xff)}; static_cast<GLubyte>(hexValue >> 0 & 0xff)};
} }
@ -668,9 +678,7 @@ namespace geode::cocos {
} }
template <typename T, typename C, typename = std::enable_if_t<std::is_pointer_v<C>>> template <typename T, typename C, typename = std::enable_if_t<std::is_pointer_v<C>>>
static cocos2d::CCArray* vectorToCCArray( static cocos2d::CCArray* vectorToCCArray(std::vector<T> const& vec, std::function<C(T)> convFunc) {
std::vector<T> const& vec, std::function<C(T)> convFunc
) {
auto res = cocos2d::CCArray::createWithCapacity(vec.size()); auto res = cocos2d::CCArray::createWithCapacity(vec.size());
for (auto const& item : vec) for (auto const& item : vec)
res->addObject(convFunc(item)); res->addObject(convFunc(item));
@ -680,8 +688,7 @@ namespace geode::cocos {
template <typename T, typename = std::enable_if_t<std::is_pointer_v<T>>> template <typename T, typename = std::enable_if_t<std::is_pointer_v<T>>>
std::vector<T> ccArrayToVector(cocos2d::CCArray* arr) { std::vector<T> ccArrayToVector(cocos2d::CCArray* arr) {
return std::vector<T>( return std::vector<T>(
reinterpret_cast<T*>(arr->data->arr), reinterpret_cast<T*>(arr->data->arr), reinterpret_cast<T*>(arr->data->arr) + arr->data->num
reinterpret_cast<T*>(arr->data->arr) + arr->data->num
); );
} }
@ -698,9 +705,7 @@ namespace geode::cocos {
template < template <
typename K, typename V, typename C, typename K, typename V, typename C,
typename = std::enable_if_t<std::is_same_v<C, std::string> || std::is_same_v<C, intptr_t>>> typename = std::enable_if_t<std::is_same_v<C, std::string> || std::is_same_v<C, intptr_t>>>
static cocos2d::CCDictionary* mapToCCDict( static cocos2d::CCDictionary* mapToCCDict(std::map<K, V> const& map, std::function<C(K)> convFunc) {
std::map<K, V> const& map, std::function<C(K)> convFunc
) {
auto res = cocos2d::CCDictionary::create(); auto res = cocos2d::CCDictionary::create();
for (auto const& [key, value] : map) for (auto const& [key, value] : map)
res->setObject(value, convFunc(key)); res->setObject(value, convFunc(key));
@ -797,6 +802,7 @@ namespace geode::cocos {
} }
return CCArrayIterator<T*>(reinterpret_cast<T**>(m_arr->data->arr) + m_arr->count()); return CCArrayIterator<T*>(reinterpret_cast<T**>(m_arr->data->arr) + m_arr->count());
} }
size_t size() const { size_t size() const {
return m_arr ? m_arr->count() : 0; return m_arr ? m_arr->count() : 0;
} }

5
loader/include/Geode/utils/web.hpp
View file

@ -1,8 +1,8 @@
#pragma once #pragma once
#include "../DefaultInclude.hpp" #include "../DefaultInclude.hpp"
#include "Result.hpp"
#include "../external/json/json.hpp" #include "../external/json/json.hpp"
#include "Result.hpp"
#include "general.hpp" #include "general.hpp"
#include <fs/filesystem.hpp> #include <fs/filesystem.hpp>
@ -38,8 +38,7 @@ namespace geode::utils::web {
* @returns Returned data as JSON, or error on error * @returns Returned data as JSON, or error on error
*/ */
GEODE_DLL Result<> fetchFile( GEODE_DLL Result<> fetchFile(
std::string const& url, ghc::filesystem::path const& into, std::string const& url, ghc::filesystem::path const& into, FileProgressCallback prog = nullptr
FileProgressCallback prog = nullptr
); );
/** /**

21
loader/src/cocos2d-ext/zip/zip.cpp
View file

@ -2,7 +2,8 @@
Version 1.1, February 14h, 2010 Version 1.1, February 14h, 2010
part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html ) part of the MiniZip project - ( http://www.winimage.com/zLibDll/minizip.html )
Copyright (C) 1998-2010 Gilles Vollant (minizip) ( http://www.winimage.com/zLibDll/minizip.html ) Copyright (C) 1998-2010 Gilles Vollant (minizip) (
http://www.winimage.com/zLibDll/minizip.html )
Modifications for Zip64 support Modifications for Zip64 support
Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com ) Copyright (C) 2009-2010 Mathias Svensson ( http://result42.com )
@ -12,15 +13,17 @@
Changes Changes
Oct-2009 - Mathias Svensson - Remove old C style function prototypes Oct-2009 - Mathias Svensson - Remove old C style function prototypes
Oct-2009 - Mathias Svensson - Added Zip64 Support when creating new file archives Oct-2009 - Mathias Svensson - Added Zip64 Support when creating new file archives
Oct-2009 - Mathias Svensson - Did some code cleanup and refactoring to get better overview of some functions. Oct-2009 - Mathias Svensson - Did some code cleanup and refactoring to get better overview of
Oct-2009 - Mathias Svensson - Added zipRemoveExtraInfoBlock to strip extra field data from its ZIP64 data some functions. Oct-2009 - Mathias Svensson - Added zipRemoveExtraInfoBlock to strip extra field
It is used when recreting zip archive with RAW when deleting items from a zip. data from its ZIP64 data It is used when recreting zip archive with RAW when deleting items from
ZIP64 data is automatically added to items that needs it, and existing ZIP64 data need to be removed. a zip. ZIP64 data is automatically added to items that needs it, and existing ZIP64 data need to
Oct-2009 - Mathias Svensson - Added support for BZIP2 as compression mode (bzip2 lib is required) be removed. Oct-2009 - Mathias Svensson - Added support for BZIP2 as compression mode (bzip2 lib
Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer is required) Jan-2010 - back to unzip and minizip 1.0 name scheme, with compatibility layer
*/ */
// clang-format off
#ifndef NOCRYPT #ifndef NOCRYPT
#define NOCRYPT #define NOCRYPT
#endif #endif
@ -1071,7 +1074,7 @@ extern int ZEXPORT zipOpenNewFileInZip4_64 (zipFile file, const char* filename,
int err = ZIP_OK; int err = ZIP_OK;
# ifdef NOCRYPT # ifdef NOCRYPT
(crcForCrypting); (void)(crcForCrypting);
if (password != NULL) if (password != NULL)
return ZIP_PARAMERROR; return ZIP_PARAMERROR;
# endif # endif
@ -2006,3 +2009,5 @@ extern int ZEXPORT zipRemoveExtraInfoBlock (char* pData, int* dataLen, short sHe
} }
} // end of namespace cocos2d } // end of namespace cocos2d
// clang-format on

3
loader/src/loader/Mod.cpp
View file

@ -122,7 +122,8 @@ Result<> Mod::loadData() {
} }
else { else {
log::log( log::log(
Severity::Warning, this, Severity::Warning,
this,
"Encountered unknown setting \"{}\" while loading " "Encountered unknown setting \"{}\" while loading "
"settings", "settings",
key key

5
loader/src/loader/ModEvent.cpp
View file

@ -19,7 +19,4 @@ ListenerResult ModStateFilter::handle(std::function<Callback> fn, ModStateEvent*
return ListenerResult::Propagate; return ListenerResult::Propagate;
} }
ModStateFilter::ModStateFilter( ModStateFilter::ModStateFilter(Mod* mod, ModEventType type) : m_mod(mod), m_type(type) {}
Mod* mod,
ModEventType type
) : m_mod(mod), m_type(type) {}

28
loader/src/main.cpp
View file

@ -1,11 +1,11 @@
#include "../core/Core.hpp" #include "../core/Core.hpp"
#include <Geode/loader/IPC.hpp>
#include <Geode/loader/Loader.hpp> #include <Geode/loader/Loader.hpp>
#include <Geode/loader/Log.hpp> #include <Geode/loader/Log.hpp>
#include <Geode/loader/Mod.hpp> #include <Geode/loader/Mod.hpp>
#include <Geode/loader/SettingEvent.hpp>
#include <Geode/loader/Setting.hpp> #include <Geode/loader/Setting.hpp>
#include <Geode/loader/IPC.hpp> #include <Geode/loader/SettingEvent.hpp>
#include <InternalLoader.hpp> #include <InternalLoader.hpp>
#include <InternalMod.hpp> #include <InternalMod.hpp>
#include <array> #include <array>
@ -102,27 +102,25 @@ BOOL WINAPI DllMain(HINSTANCE lib, DWORD reason, LPVOID) {
#define $_ GEODE_CONCAT(unnamedVar_, __LINE__) #define $_ GEODE_CONCAT(unnamedVar_, __LINE__)
static auto $_ = listenForSettingChanges<BoolSetting>( static auto $_ =
"show-platform-console", listenForSettingChanges<BoolSetting>("show-platform-console", [](BoolSetting* setting) {
[](BoolSetting* setting) {
if (setting->getValue()) { if (setting->getValue()) {
Loader::get()->openPlatformConsole(); Loader::get()->openPlatformConsole();
} }
else { else {
Loader::get()->closePlatfromConsole(); Loader::get()->closePlatfromConsole();
} }
} });
);
static auto $_ = listenForIPC("ipc-test", +[](IPCEvent* event) -> nlohmann::json { static auto $_ = listenForIPC("ipc-test", [](IPCEvent* event) -> nlohmann::json {
return "Hello from Geode!"; return "Hello from Geode!";
}); });
static auto $_ = listenForIPC("loader-info", +[](IPCEvent* event) -> nlohmann::json { static auto $_ = listenForIPC("loader-info", [](IPCEvent* event) -> nlohmann::json {
return Loader::get()->getInternalMod()->getModInfo(); return Loader::get()->getInternalMod()->getModInfo();
}); });
static auto $_ = listenForIPC("list-mods", +[](IPCEvent* event) -> nlohmann::json { static auto $_ = listenForIPC("list-mods", [](IPCEvent* event) -> nlohmann::json {
std::vector<nlohmann::json> res; std::vector<nlohmann::json> res;
auto args = event->getMessageData(); auto args = event->getMessageData();
@ -133,18 +131,14 @@ static auto $_ = listenForIPC("list-mods", +[](IPCEvent* event) -> nlohmann::jso
auto dontIncludeLoader = root.has("dont-include-loader").template get<bool>(); auto dontIncludeLoader = root.has("dont-include-loader").template get<bool>();
if (!dontIncludeLoader) { if (!dontIncludeLoader) {
res.push_back(includeRunTimeInfo ? res.push_back(
Loader::get()->getInternalMod()->getRuntimeInfo() : includeRunTimeInfo ? Loader::get()->getInternalMod()->getRuntimeInfo() :
Loader::get()->getInternalMod()->getModInfo().toJSON() Loader::get()->getInternalMod()->getModInfo().toJSON()
); );
} }
for (auto& mod : Loader::get()->getAllMods()) { for (auto& mod : Loader::get()->getAllMods()) {
res.push_back( res.push_back(includeRunTimeInfo ? mod->getRuntimeInfo() : mod->getModInfo().toJSON());
includeRunTimeInfo ?
mod->getRuntimeInfo() :
mod->getModInfo().toJSON()
);
} }
return res; return res;

51
loader/src/platform/mac/InternalLoader.cpp
View file

@ -1,8 +1,8 @@
#include <InternalLoader.hpp>
#include <Geode/loader/Log.hpp>
#include <iostream>
#include <InternalMod.hpp>
#include <Geode/loader/IPC.hpp> #include <Geode/loader/IPC.hpp>
#include <Geode/loader/Log.hpp>
#include <InternalLoader.hpp>
#include <InternalMod.hpp>
#include <iostream>
#ifdef GEODE_IS_MACOS #ifdef GEODE_IS_MACOS
@ -29,46 +29,37 @@ void InternalLoader::closePlatformConsole() {
m_platformConsoleOpen = false; m_platformConsoleOpen = false;
} }
CFDataRef msgPortCallback( CFDataRef msgPortCallback(CFMessagePortRef port, SInt32 messageID, CFDataRef data, void* info) {
CFMessagePortRef port, if (!CFDataGetLength(data)) return NULL;
SInt32 messageID,
CFDataRef data,
void* info
) {
if(!CFDataGetLength(data))
return NULL;
std::string cdata( std::string cdata(reinterpret_cast<char const*>(CFDataGetBytePtr(data)), CFDataGetLength(data));
reinterpret_cast<char const*>(CFDataGetBytePtr(data)),
CFDataGetLength(data)
);
std::string reply = InternalLoader::processRawIPC(port, cdata); std::string reply = InternalLoader::processRawIPC(port, cdata);
return CFDataCreate(NULL, (const UInt8*)reply.data(), reply.size()); return CFDataCreate(NULL, (UInt8 const*)reply.data(), reply.size());
} }
void InternalLoader::setupIPC() { void InternalLoader::setupIPC() {
std::thread([]() { std::thread([]() {
CFStringRef portName = CFStringCreateWithCString(NULL, IPC_PORT_NAME, kCFStringEncodingUTF8); CFStringRef portName = CFStringCreateWithCString(NULL, IPC_PORT_NAME, kCFStringEncodingUTF8);
CFMessagePortRef localPort = CFMessagePortCreateLocal( CFMessagePortRef localPort =
NULL, CFMessagePortCreateLocal(NULL, portName, msgPortCallback, NULL, NULL);
portName, if (localPort == NULL) {
msgPortCallback, log::warn("Unable to create port, quitting IPC");
NULL, return;
NULL }
);
CFRunLoopSourceRef runLoopSource = CFMessagePortCreateRunLoopSource(NULL, localPort, 0); CFRunLoopSourceRef runLoopSource = CFMessagePortCreateRunLoopSource(NULL, localPort, 0);
CFRunLoopAddSource( if (runLoopSource == NULL) {
CFRunLoopGetCurrent(), log::warn("Unable to create loop source, quitting IPC");
runLoopSource, return;
kCFRunLoopCommonModes }
);
CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, kCFRunLoopCommonModes);
CFRunLoopRun(); CFRunLoopRun();
CFRelease(localPort); CFRelease(localPort);
}).detach(); }).detach();
log::log(Severity::Warning, InternalMod::get(), "IPC is not supported on this platform"); log::debug("IPC set up");
} }
#endif #endif

9
loader/src/platform/windows/InternalLoader.cpp
View file

@ -1,8 +1,8 @@
#include <InternalLoader.hpp>
#include <Geode/loader/IPC.hpp> #include <Geode/loader/IPC.hpp>
#include <Geode/loader/Log.hpp> #include <Geode/loader/Log.hpp>
#include <iostream> #include <InternalLoader.hpp>
#include <InternalMod.hpp> #include <InternalMod.hpp>
#include <iostream>
USE_GEODE_NAMESPACE(); USE_GEODE_NAMESPACE();
@ -89,14 +89,15 @@ void InternalLoader::setupIPC() {
if (ConnectNamedPipe(pipe, nullptr)) { if (ConnectNamedPipe(pipe, nullptr)) {
// log::debug("Got connection, creating thread"); // log::debug("Got connection, creating thread");
std::thread(&ipcPipeThread, pipe).detach(); std::thread(&ipcPipeThread, pipe).detach();
} else { }
else {
// log::debug("No connection, cleaning pipe"); // log::debug("No connection, cleaning pipe");
CloseHandle(pipe); CloseHandle(pipe);
} }
} }
}).detach(); }).detach();
log::log(Severity::Debug, InternalMod::get(), "IPC set up"); log::debug("IPC set up");
} }
#endif #endif

14
loader/src/utils/JsonValidation.cpp
View file

@ -205,14 +205,12 @@ JsonMaybeValue<Json> JsonMaybeValue<Json>::at(size_t i) {
return *this; return *this;
} }
return JsonMaybeValue<Json>( return JsonMaybeValue<Json>(
self().m_checker, self().m_json.at(i), self().m_hierarchy + "." + std::to_string(i), self().m_checker, self().m_json.at(i), self().m_hierarchy + "." + std::to_string(i), self().m_hasValue
self().m_hasValue
); );
} }
template <class Json> template <class Json>
typename JsonMaybeValue<Json>::template Iterator<JsonMaybeValue<Json>> JsonMaybeValue< typename JsonMaybeValue<Json>::template Iterator<JsonMaybeValue<Json>> JsonMaybeValue<Json>::iterate() {
Json>::iterate() {
this->as<value_t::array>(); this->as<value_t::array>();
Iterator<JsonMaybeValue<Json>> iter; Iterator<JsonMaybeValue<Json>> iter;
if (this->isError()) return iter; if (this->isError()) return iter;
@ -226,8 +224,8 @@ typename JsonMaybeValue<Json>::template Iterator<JsonMaybeValue<Json>> JsonMaybe
} }
template <class Json> template <class Json>
typename JsonMaybeValue<Json>::template Iterator<std::pair<std::string, JsonMaybeValue<Json>>> typename JsonMaybeValue<Json>::template Iterator<std::pair<std::string, JsonMaybeValue<Json>>> JsonMaybeValue<
JsonMaybeValue<Json>::items() { Json>::items() {
this->as<value_t::object>(); this->as<value_t::object>();
Iterator<std::pair<std::string, JsonMaybeValue<Json>>> iter; Iterator<std::pair<std::string, JsonMaybeValue<Json>>> iter;
if (this->isError()) return iter; if (this->isError()) return iter;
@ -235,9 +233,7 @@ JsonMaybeValue<Json>::items() {
for (auto& [k, v] : self().m_json.items()) { for (auto& [k, v] : self().m_json.items()) {
iter.m_values.emplace_back( iter.m_values.emplace_back(
k, k,
JsonMaybeValue<Json>( JsonMaybeValue<Json>(self().m_checker, v, self().m_hierarchy + "." + k, self().m_hasValue)
self().m_checker, v, self().m_hierarchy + "." + k, self().m_hasValue
)
); );
} }

3
loader/src/utils/addresser.cpp
View file

@ -14,8 +14,7 @@
macro(GEODE_CONCAT(begin, 7)), macro(GEODE_CONCAT(begin, 8)), \ macro(GEODE_CONCAT(begin, 7)), macro(GEODE_CONCAT(begin, 8)), \
macro(GEODE_CONCAT(begin, 9)), macro(GEODE_CONCAT(begin, a)), \ macro(GEODE_CONCAT(begin, 9)), macro(GEODE_CONCAT(begin, a)), \
macro(GEODE_CONCAT(begin, b)), macro(GEODE_CONCAT(begin, c)), \ macro(GEODE_CONCAT(begin, b)), macro(GEODE_CONCAT(begin, c)), \
macro(GEODE_CONCAT(begin, d)), macro(GEODE_CONCAT(begin, e)), \ macro(GEODE_CONCAT(begin, d)), macro(GEODE_CONCAT(begin, e)), macro(GEODE_CONCAT(begin, f))
macro(GEODE_CONCAT(begin, f))
#define GEODE_ADDRESSER_NEST2(macro, begin) \ #define GEODE_ADDRESSER_NEST2(macro, begin) \
GEODE_ADDRESSER_NEST1(macro, GEODE_CONCAT(begin, 0)), \ GEODE_ADDRESSER_NEST1(macro, GEODE_CONCAT(begin, 0)), \

12
loader/src/utils/cocos.cpp
View file

@ -20,9 +20,7 @@ void cocos2d::from_json(nlohmann::json const& json, ccColor3B& color) {
json.at(2).get_to(color.b); json.at(2).get_to(color.b);
} }
else { else {
throw nlohmann::json::type_error::create( throw nlohmann::json::type_error::create(0, "Expected color array to have 3 items", json);
0, "Expected color array to have 3 items", json
);
} }
} }
// object // object
@ -75,9 +73,7 @@ void cocos2d::from_json(nlohmann::json const& json, ccColor4B& color) {
json.at(3).get_to(color.a); json.at(3).get_to(color.a);
} }
else { else {
throw nlohmann::json::type_error::create( throw nlohmann::json::type_error::create(0, "Expected color array to have 4 items", json);
0, "Expected color array to have 4 items", json
);
} }
} }
// object // object
@ -288,9 +284,7 @@ CCRect geode::cocos::calculateChildCoverage(CCNode* parent) {
return calculateNodeCoverage(parent->getChildren()); return calculateNodeCoverage(parent->getChildren());
} }
void geode::cocos::limitNodeSize( void geode::cocos::limitNodeSize(cocos2d::CCNode* spr, cocos2d::CCSize const& size, float def, float min) {
cocos2d::CCNode* spr, cocos2d::CCSize const& size, float def, float min
) {
spr->setScale(1.f); spr->setScale(1.f);
auto [cwidth, cheight] = spr->getContentSize(); auto [cwidth, cheight] = spr->getContentSize();

6
loader/src/utils/file.cpp
View file

@ -151,12 +151,14 @@ public:
// Read file and add to entries // Read file and add to entries
unz_file_pos pos; unz_file_pos pos;
if (unzGetFilePos(m_zip, &pos) == UNZ_OK) { if (unzGetFilePos(m_zip, &pos) == UNZ_OK) {
m_entries.insert({ fileName, m_entries.insert({
fileName,
ZipEntry { ZipEntry {
.m_pos = pos, .m_pos = pos,
.m_compressedSize = fileInfo.compressed_size, .m_compressedSize = fileInfo.compressed_size,
.m_uncompressedSize = fileInfo.uncompressed_size, .m_uncompressedSize = fileInfo.uncompressed_size,
} }); },
});
} }
// Read next file, or break on error // Read next file, or break on error
if (unzGoToNextFile64(m_zip, &fileInfo, fileName, sizeof(fileName) - 1) != UNZ_OK) { if (unzGoToNextFile64(m_zip, &fileInfo, fileName, sizeof(fileName) - 1) != UNZ_OK) {

10
loader/src/utils/string.cpp
View file

@ -91,9 +91,7 @@ std::wstring utils::string::toUpper(std::wstring const& str) {
return utils::string::toUpperIP(ret); return utils::string::toUpperIP(ret);
} }
std::string& utils::string::replaceIP( std::string& utils::string::replaceIP(std::string& str, std::string const& orig, std::string const& repl) {
std::string& str, std::string const& orig, std::string const& repl
) {
std::string::size_type n = 0; std::string::size_type n = 0;
while ((n = str.find(orig, n)) != std::string::npos) { while ((n = str.find(orig, n)) != std::string::npos) {
str.replace(n, orig.size(), repl); str.replace(n, orig.size(), repl);
@ -248,7 +246,8 @@ std::wstring& utils::string::trimLeftIP(std::wstring& str) {
std::string& utils::string::trimRightIP(std::string& str) { std::string& utils::string::trimRightIP(std::string& str) {
str.erase( str.erase(
std::find_if( std::find_if(
str.rbegin(), str.rend(), str.rbegin(),
str.rend(),
[](auto ch) { [](auto ch) {
return !std::isspace(ch); return !std::isspace(ch);
} }
@ -261,7 +260,8 @@ std::string& utils::string::trimRightIP(std::string& str) {
std::wstring& utils::string::trimRightIP(std::wstring& str) { std::wstring& utils::string::trimRightIP(std::wstring& str) {
str.erase( str.erase(
std::find_if( std::find_if(
str.rbegin(), str.rend(), str.rbegin(),
str.rend(),
[](auto ch) { [](auto ch) {
return !std::isspace(ch); return !std::isspace(ch);
} }

3
loader/src/utils/web.cpp
View file

@ -193,7 +193,8 @@ SentAsyncWebRequest::SentAsyncWebRequest(AsyncWebRequest const& req, std::string
} data{this, file.get()}; } data{this, file.get()};
curl_easy_setopt( curl_easy_setopt(
curl, CURLOPT_PROGRESSFUNCTION, curl,
CURLOPT_PROGRESSFUNCTION,
+[](void* ptr, double total, double now, double, double) -> int { +[](void* ptr, double total, double now, double, double) -> int {
auto data = static_cast<ProgressData*>(ptr); auto data = static_cast<ProgressData*>(ptr);
while (data->self->m_paused) {} while (data->self->m_paused) {}