7cc5c4f330d47060/geode
1
0
Fork 0
mirror of https://github.com/geode-sdk/geode.git synced 2024-11-22 23:48:08 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Merge branch 'main' of https://github.com/geode-sdk/geode into main

Browse source
This commit is contained in:
HJfod 2022-12-07 12:37:10 +02:00
commit 996acf15aa
21 changed files with 297 additions and 244 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

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

@ -69,45 +69,120 @@ namespace cocos2d::extension {}
#define GEODE_EXPAND(x) x #define GEODE_EXPAND(x) x
#define GEODE_INVOKE(macro, ...) GEODE_EXPAND(macro(__VA_ARGS__)) #define GEODE_INVOKE(macro, ...) GEODE_EXPAND(macro(__VA_ARGS__))
#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_) \
GEODE_MACOS(GEODE_FILL_CONSTRUCTOR(Class_, 0) {}) \ GEODE_MACOS(GEODE_FILL_CONSTRUCTOR(Class_, 0){}) \
GEODE_IOS(GEODE_FILL_CONSTRUCTOR(Class_, 0) {}) GEODE_IOS(GEODE_FILL_CONSTRUCTOR(Class_, 0){})
#define GEODE_MONOSTATE_CONSTRUCTOR_COCOS(Class_, Base_) \ #define GEODE_MONOSTATE_CONSTRUCTOR_COCOS(Class_, Base_) \
GEODE_MACOS(Class_(std::monostate, size_t fill) : Base_({}, fill) {}) \ GEODE_MACOS(Class_(std::monostate, size_t fill) : Base_({}, fill){}) \
GEODE_IOS(Class_(std::monostate, size_t fill) : Base_({}, fill) {}) GEODE_IOS(Class_(std::monostate, size_t fill) : Base_({}, fill){})
#define GEODE_MONOSTATE_CONSTRUCTOR_GD(Class_, Base_) \ #define GEODE_MONOSTATE_CONSTRUCTOR_GD(Class_, Base_) \
GEODE_WINDOWS(Class_(std::monostate, size_t fill) : Base_({}, fill) {}) \ GEODE_WINDOWS(Class_(std::monostate, size_t fill) : Base_({}, fill){}) \
GEODE_MACOS(Class_(std::monostate, size_t fill) : Base_({}, fill) {}) \ GEODE_MACOS(Class_(std::monostate, size_t fill) : Base_({}, fill){}) \
GEODE_IOS(Class_(std::monostate, size_t fill) : Base_({}, fill) {}) GEODE_IOS(Class_(std::monostate, size_t fill) : Base_({}, fill){})
#define GEODE_MONOSTATE_CONSTRUCTOR_CUTOFF(Class_, Base_) \ #define GEODE_MONOSTATE_CONSTRUCTOR_CUTOFF(Class_, Base_) \
GEODE_WINDOWS(GEODE_FILL_CONSTRUCTOR(Class_, sizeof(Base_)) : Base_() {}) \ GEODE_WINDOWS(GEODE_FILL_CONSTRUCTOR(Class_, sizeof(Base_)) : Base_(){}) \
GEODE_MACOS(Class_(std::monostate, size_t fill) : Base_({}, fill) {}) \ GEODE_MACOS(Class_(std::monostate, size_t fill) : Base_({}, fill){}) \
GEODE_IOS(Class_(std::monostate, size_t fill) : Base_({}, fill) {}) GEODE_IOS(Class_(std::monostate, size_t fill) : Base_({}, fill){})
#define GEODE_NUMBER_OF_ARGS(...) \ #define GEODE_NUMBER_OF_ARGS(...) \
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() \
63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, \ 63, 62, 61, 60, 59, 58, 57, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, \
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)), \

30
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>
@ -25,9 +26,9 @@ namespace geode {
template <typename C, typename T> template <typename C, typename T>
struct to_member; struct to_member;
template <typename C, typename R, typename ...Args> template <typename C, typename R, typename... Args>
struct to_member<C, R(Args...)> { struct to_member<C, R(Args...)> {
using value = R(C::*)(Args...); using value = R (C::*)(Args...);
}; };
template <typename T> template <typename T>
@ -43,10 +44,9 @@ namespace geode {
return fn(e); return fn(e);
} }
}; };
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,14 +55,14 @@ 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 (m_callback) { // it is so silly to use dynamic cast in an interbinary context
if (auto myev = typeinfo_cast<typename T::Event*>(e)) { 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;
} }
@ -70,15 +70,19 @@ 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();
} }
@ -86,11 +90,13 @@ namespace geode {
std::cout << "this: " << this << "\n"; std::cout << "this: " << this << "\n";
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) {
std::cout << "this: " << this << "\n"; std::cout << "this: " << this << "\n";
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 = nullptr; std::function<Callback> m_callback = nullptr;
T m_filter; T m_filter;

23
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,
@ -18,25 +19,25 @@ namespace geode {
protected: protected:
ModEventType m_type; ModEventType m_type;
Mod* m_mod; Mod* m_mod;
public: public:
ModStateEvent(Mod* mod, ModEventType type); ModStateEvent(Mod* mod, ModEventType type);
ModEventType getType() const; ModEventType getType() const;
Mod* getMod() const; Mod* getMod() const;
}; };
class GEODE_DLL ModStateFilter : public EventFilter<ModStateEvent> { class GEODE_DLL ModStateFilter : public EventFilter<ModStateEvent> {
public: public:
using Callback = void(ModStateEvent*); using Callback = void(ModStateEvent*);
protected: protected:
ModEventType m_type; ModEventType m_type;
Mod* m_mod; Mod* m_mod;
public: public:
ListenerResult handle(std::function<Callback> fn, ModStateEvent* event); ListenerResult handle(std::function<Callback> fn, ModStateEvent* event);
ModStateFilter(Mod* mod, ModEventType type); ModStateFilter(Mod* mod, ModEventType type);
}; };
} }
#define $on_mod(type) \ #define $on_mod(type) \

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;

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

@ -1,7 +1,7 @@
#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 "../DefaultInclude.hpp" #include "../DefaultInclude.hpp"
#include <cocos2d.h> #include <cocos2d.h>
@ -140,11 +140,11 @@ namespace geode {
} }
static cocos2d::CCSize operator-(cocos2d::CCSize const& size, float f) { static cocos2d::CCSize operator-(cocos2d::CCSize const& size, float f) {
return { size.width - f, size.height - f }; return {size.width - f, size.height - f};
} }
static cocos2d::CCSize operator-(cocos2d::CCSize const& size) { static cocos2d::CCSize operator-(cocos2d::CCSize const& size) {
return { -size.width, -size.height }; return {-size.width, -size.height};
} }
static bool operator==(cocos2d::CCPoint const& p1, cocos2d::CCPoint const& p2) { static bool operator==(cocos2d::CCPoint const& p1, cocos2d::CCPoint const& p2) {
@ -284,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;
} }
@ -291,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;
} }
@ -299,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;
} }
@ -436,13 +439,13 @@ 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
* screen is finished * screen is finished
* @param returnTo A function that returns a new layer. After loading is * @param returnTo A function that returns a new layer. After loading is
* finished, the game switches to the given layer instead of MenuLayer. * finished, the game switches to the given layer instead of MenuLayer.
* Leave nullptr to enable default behaviour * Leave nullptr to enable default behaviour
*/ */
GEODE_DLL void reloadTextures(CreateLayerFunc returnTo = nullptr); GEODE_DLL void reloadTextures(CreateLayerFunc returnTo = nullptr);
@ -454,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
@ -479,12 +480,12 @@ namespace geode::cocos {
GEODE_DLL cocos2d::CCNode* getChildByTagRecursive(cocos2d::CCNode* node, int tag); GEODE_DLL cocos2d::CCNode* getChildByTagRecursive(cocos2d::CCNode* node, int tag);
/** /**
* Get first node that conforms to the predicate * Get first node that conforms to the predicate
* by traversing children recursively * by traversing children recursively
* *
* @param node Parent node * @param node Parent node
* @param predicate Predicate used to evaluate nodes * @param predicate Predicate used to evaluate nodes
* @return Child node if one is found, or null if * @return Child node if one is found, or null if
* there is none * there is none
*/ */
template <class Type = cocos2d::CCNode> template <class Type = cocos2d::CCNode>
@ -498,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;
@ -603,13 +603,18 @@ 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.b) }; static_cast<GLubyte>(255 - color.r),
static_cast<GLubyte>(255 - color.g),
static_cast<GLubyte>(255 - color.b)};
} }
inline cocos2d::ccColor3B lighten3B(cocos2d::ccColor3B const& color, int amount) { inline cocos2d::ccColor3B lighten3B(cocos2d::ccColor3B const& color, int amount) {
@ -625,34 +630,38 @@ namespace geode::cocos {
} }
inline cocos2d::ccColor3B to3B(cocos2d::ccColor4B const& color) { inline cocos2d::ccColor3B to3B(cocos2d::ccColor4B const& color) {
return { color.r, color.g, color.b }; return {color.r, color.g, color.b};
} }
inline cocos2d::ccColor4B to4B(cocos2d::ccColor3B const& color, GLubyte alpha = 255) { inline cocos2d::ccColor4B to4B(cocos2d::ccColor3B const& color, GLubyte alpha = 255) {
return { color.r, color.g, color.b, alpha }; return {color.r, color.g, color.b, alpha};
} }
inline cocos2d::ccColor4F to4F(cocos2d::ccColor4B const& color) { inline cocos2d::ccColor4F to4F(cocos2d::ccColor4B const& color) {
return { color.r / 255.f, color.g / 255.f, color.b / 255.f, color.a / 255.f }; return {color.r / 255.f, color.g / 255.f, color.b / 255.f, color.a / 255.f};
} }
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 >> 4 & 0xf) * 17), static_cast<GLubyte>((hexValue >> 8 & 0xf) * 17),
static_cast<GLubyte>((hexValue >> 0 & 0xf) * 17) }; static_cast<GLubyte>((hexValue >> 4 & 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 >> 8 & 0xff), static_cast<GLubyte>(hexValue >> 16 & 0xff),
static_cast<GLubyte>(hexValue >> 0 & 0xff) }; static_cast<GLubyte>(hexValue >> 8 & 0xff),
static_cast<GLubyte>(hexValue >> 0 & 0xff)};
} }
GEODE_DLL Result<cocos2d::ccColor3B> cc3bFromHexString(std::string const& hexValue); GEODE_DLL Result<cocos2d::ccColor3B> cc3bFromHexString(std::string const& hexValue);
@ -669,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));
@ -681,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
); );
} }
@ -699,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));
@ -726,7 +730,7 @@ namespace geode::cocos {
// std specializations // std specializations
namespace std { namespace std {
// enables using Ref as the key in unordered_map etc. // enables using Ref as the key in unordered_map etc.
template<class T> template <class T>
struct hash<geode::Ref<T>> { struct hash<geode::Ref<T>> {
size_t operator()(geode::Ref<T> const& ref) const { size_t operator()(geode::Ref<T> const& ref) const {
return std::hash<T*>()(ref.data()); return std::hash<T*>()(ref.data());
@ -798,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;
} }
@ -830,10 +835,10 @@ namespace geode::cocos {
std::pair<K, T> operator*() { std::pair<K, T> operator*() {
if constexpr (std::is_same<K, std::string>::value) { if constexpr (std::is_same<K, std::string>::value) {
return { m_ptr->getStrKey(), static_cast<T>(m_ptr->getObject()) }; return {m_ptr->getStrKey(), static_cast<T>(m_ptr->getObject())};
} }
else { else {
return { m_ptr->getIntKey(), static_cast<T>(m_ptr->getObject()) }; return {m_ptr->getIntKey(), static_cast<T>(m_ptr->getObject())};
} }
} }
@ -998,7 +1003,7 @@ namespace geode::cocos {
using Selector = Ret (Base::*)(Args...); using Selector = Ret (Base::*)(Args...);
using Holder = LambdaHolder<Func, Ret, Args...>; using Holder = LambdaHolder<Func, Ret, Args...>;
static inline Holder s_selector {}; static inline Holder s_selector{};
Ret selector(Args... args) { Ret selector(Args... args) {
return s_selector(std::forward<Args>(args)...); return s_selector(std::forward<Args>(args)...);

7
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>
@ -10,7 +10,7 @@
namespace geode::utils::web { namespace geode::utils::web {
GEODE_DLL void openLinkInBrowser(std::string const& url); GEODE_DLL void openLinkInBrowser(std::string const& url);
using FileProgressCallback = std::function<bool(double, double)>; using FileProgressCallback = std::function<bool(double, double)>;
/** /**
@ -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

2
loader/src/loader/Event.cpp
View file

@ -15,7 +15,7 @@ void EventListenerProtocol::disable() {
} }
EventListenerProtocol::~EventListenerProtocol() { EventListenerProtocol::~EventListenerProtocol() {
this->disable(); this->disable();
} }
Event::~Event() {} Event::~Event() {}

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

@ -125,7 +125,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) {}

30
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;

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

@ -1,12 +1,12 @@
#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
#include <CoreFoundation/CoreFoundation.h> #include <CoreFoundation/CoreFoundation.h>
void InternalLoader::platformMessageBox(char const* title, std::string const& info) { void InternalLoader::platformMessageBox(char const* title, std::string const& info) {
CFStringRef cfTitle = CFStringCreateWithCString(NULL, title, kCFStringEncodingUTF8); CFStringRef cfTitle = CFStringCreateWithCString(NULL, title, kCFStringEncodingUTF8);
@ -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

17
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();
@ -77,10 +77,10 @@ void InternalLoader::setupIPC() {
nullptr nullptr
); );
if (pipe == INVALID_HANDLE_VALUE) { if (pipe == INVALID_HANDLE_VALUE) {
// todo: Rn this quits IPC, but we might wanna change that later // todo: Rn this quits IPC, but we might wanna change that later
// to just continue trying. however, I'm assuming that if // to just continue trying. however, I'm assuming that if
// CreateNamedPipeA fails, then it will probably fail again if // CreateNamedPipeA fails, then it will probably fail again if
// you try right after, so changing the break; to continue; might // you try right after, so changing the break; to continue; might
// just result in the console getting filled with error messages // just result in the console getting filled with error messages
log::warn("Unable to create pipe, quitting IPC"); log::warn("Unable to create pipe, quitting IPC");
break; break;
@ -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
)
); );
} }

7
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)), \
@ -53,13 +52,13 @@ namespace {
using table_table_t = intptr_t[0x100]; using table_table_t = intptr_t[0x100];
struct GEODE_HIDDEN ThunkTable { struct GEODE_HIDDEN ThunkTable {
static inline thunk0_table_t table = { GEODE_ADDRESSER_THUNK0_SET() }; static inline thunk0_table_t table = {GEODE_ADDRESSER_THUNK0_SET()};
}; };
class GEODE_HIDDEN TableTable { class GEODE_HIDDEN TableTable {
friend class geode::addresser::Addresser; friend class geode::addresser::Addresser;
static inline table_table_t table = { GEODE_ADDRESSER_TABLE_SET() }; static inline table_table_t table = {GEODE_ADDRESSER_TABLE_SET()};
}; };
} }

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

@ -4,10 +4,10 @@
USE_GEODE_NAMESPACE(); USE_GEODE_NAMESPACE();
void cocos2d::to_json(nlohmann::json& json, ccColor3B const& color) { void cocos2d::to_json(nlohmann::json& json, ccColor3B const& color) {
json = nlohmann::json { json = nlohmann::json{
{ "r", color.r }, {"r", color.r},
{ "g", color.g }, {"g", color.g},
{ "b", color.b }, {"b", color.b},
}; };
} }
@ -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
@ -57,11 +55,11 @@ void cocos2d::from_json(nlohmann::json const& json, ccColor3B& color) {
} }
void cocos2d::to_json(nlohmann::json& json, ccColor4B const& color) { void cocos2d::to_json(nlohmann::json& json, ccColor4B const& color) {
json = nlohmann::json { json = nlohmann::json{
{ "r", color.r }, {"r", color.r},
{ "g", color.g }, {"g", color.g},
{ "b", color.b }, {"b", color.b},
{ "a", color.a }, {"a", color.a},
}; };
} }
@ -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
@ -245,7 +241,7 @@ CCRect geode::cocos::calculateNodeCoverage(std::vector<CCNode*> const& nodes) {
for (auto child : nodes) { for (auto child : nodes) {
auto pos = child->getPosition() - child->getScaledContentSize() * child->getAnchorPoint(); auto pos = child->getPosition() - child->getScaledContentSize() * child->getAnchorPoint();
auto csize = child->getPosition() + auto csize = child->getPosition() +
child->getScaledContentSize() * (CCPoint { 1.f, 1.f } - child->getAnchorPoint()); child->getScaledContentSize() * (CCPoint{1.f, 1.f} - child->getAnchorPoint());
if (pos.x < coverage.origin.x) { if (pos.x < coverage.origin.x) {
coverage.origin.x = pos.x; coverage.origin.x = pos.x;
} }
@ -267,7 +263,7 @@ CCRect geode::cocos::calculateNodeCoverage(CCArray* nodes) {
for (auto child : CCArrayExt<CCNode>(nodes)) { for (auto child : CCArrayExt<CCNode>(nodes)) {
auto pos = child->getPosition() - child->getScaledContentSize() * child->getAnchorPoint(); auto pos = child->getPosition() - child->getScaledContentSize() * child->getAnchorPoint();
auto csize = child->getPosition() + auto csize = child->getPosition() +
child->getScaledContentSize() * (CCPoint { 1.f, 1.f } - child->getAnchorPoint()); child->getScaledContentSize() * (CCPoint{1.f, 1.f} - child->getAnchorPoint());
if (pos.x < coverage.origin.x) { if (pos.x < coverage.origin.x) {
coverage.origin.x = pos.x; coverage.origin.x = pos.x;
} }
@ -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();

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

@ -164,12 +164,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({
ZipEntry { fileName,
.m_pos = pos, ZipEntry {
.m_compressedSize = fileInfo.compressed_size, .m_pos = pos,
.m_uncompressedSize = fileInfo.uncompressed_size, .m_compressedSize = fileInfo.compressed_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);
} }

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

@ -125,7 +125,7 @@ Result<std::string> web::fetch(std::string const& url) {
return Err("Error getting info: " + std::string(curl_easy_strerror(res))); return Err("Error getting info: " + std::string(curl_easy_strerror(res)));
} }
static std::unordered_map<std::string, SentAsyncWebRequestHandle> RUNNING_REQUESTS {}; static std::unordered_map<std::string, SentAsyncWebRequestHandle> RUNNING_REQUESTS{};
static std::mutex RUNNING_REQUESTS_MUTEX; static std::mutex RUNNING_REQUESTS_MUTEX;
SentAsyncWebRequest::SentAsyncWebRequest(AsyncWebRequest const& req, std::string const& id) : SentAsyncWebRequest::SentAsyncWebRequest(AsyncWebRequest const& req, std::string const& id) :
@ -190,10 +190,11 @@ SentAsyncWebRequest::SentAsyncWebRequest(AsyncWebRequest const& req, std::string
struct ProgressData { struct ProgressData {
SentAsyncWebRequest* self; SentAsyncWebRequest* self;
std::ofstream* file; std::ofstream* file;
} 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) {}
@ -350,7 +351,7 @@ SentAsyncWebRequestHandle AsyncWebRequest::send() {
else { else {
auto id = m_joinID.value_or("__anon_request_" + std::to_string(COUNTER++)); auto id = m_joinID.value_or("__anon_request_" + std::to_string(COUNTER++));
ret = std::make_shared<SentAsyncWebRequest>(*this, id); ret = std::make_shared<SentAsyncWebRequest>(*this, id);
RUNNING_REQUESTS.insert({ id, ret }); RUNNING_REQUESTS.insert({id, ret});
} }
// resume all running requests // resume all running requests