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

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

@ -69,45 +69,120 @@ namespace cocos2d::extension {}
#define GEODE_EXPAND(x) x
#define GEODE_INVOKE(macro, ...) GEODE_EXPAND(macro(__VA_ARGS__))
#define GEODE_FILL_CONSTRUCTOR(Class_, Offset_) \
Class_(std::monostate, size_t fill) : \
Class_({}, std::memset(reinterpret_cast<std::byte*>(this) + Offset_, 0, fill - Offset_)) { \
} \
#define GEODE_FILL_CONSTRUCTOR(Class_, Offset_) \
Class_(std::monostate, size_t fill) : \
Class_({}, std::memset(reinterpret_cast<std::byte*>(this) + Offset_, 0, fill - Offset_)) {} \
Class_(std::monostate, void*)
#define GEODE_MONOSTATE_CONSTRUCTOR_BEGIN(Class_) \
GEODE_MACOS(GEODE_FILL_CONSTRUCTOR(Class_, 0) {}) \
GEODE_IOS(GEODE_FILL_CONSTRUCTOR(Class_, 0) {})
#define GEODE_MONOSTATE_CONSTRUCTOR_BEGIN(Class_) \
GEODE_MACOS(GEODE_FILL_CONSTRUCTOR(Class_, 0){}) \
GEODE_IOS(GEODE_FILL_CONSTRUCTOR(Class_, 0){})
#define GEODE_MONOSTATE_CONSTRUCTOR_COCOS(Class_, Base_) \
GEODE_MACOS(Class_(std::monostate, size_t fill) : Base_({}, fill) {}) \
GEODE_IOS(Class_(std::monostate, size_t fill) : Base_({}, fill) {})
#define GEODE_MONOSTATE_CONSTRUCTOR_COCOS(Class_, Base_) \
GEODE_MACOS(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_) \
GEODE_WINDOWS(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) {})
#define GEODE_MONOSTATE_CONSTRUCTOR_GD(Class_, Base_) \
GEODE_WINDOWS(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){})
#define GEODE_MONOSTATE_CONSTRUCTOR_CUTOFF(Class_, Base_) \
GEODE_WINDOWS(GEODE_FILL_CONSTRUCTOR(Class_, sizeof(Base_)) : Base_() {}) \
GEODE_MACOS(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_) \
GEODE_WINDOWS(GEODE_FILL_CONSTRUCTOR(Class_, sizeof(Base_)) : Base_(){}) \
GEODE_MACOS(Class_(std::monostate, size_t fill) : Base_({}, fill){}) \
GEODE_IOS(Class_(std::monostate, size_t fill) : Base_({}, fill){})
#define GEODE_NUMBER_OF_ARGS(...) \
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_N( \
_1, _2, _3, _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, ... \
) \
#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, \
_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
#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, \
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
#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) \
// macro(GEODE_CONCAT(begin, 0)), \
// macro(GEODE_CONCAT(begin, 1)), \

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

@ -1,5 +1,6 @@
#pragma once
#include "../utils/casts.hpp"
#include "Mod.hpp"
#include <Geode/DefaultInclude.hpp>
@ -25,9 +26,9 @@ namespace geode {
template <typename C, typename T>
struct to_member;
template <typename C, typename R, typename ...Args>
template <typename C, typename R, typename... Args>
struct to_member<C, R(Args...)> {
using value = R(C::*)(Args...);
using value = R (C::*)(Args...);
};
template <typename T>
@ -43,10 +44,9 @@ namespace geode {
return fn(e);
}
};
template <typename T>
concept is_filter =
std::is_base_of_v<EventFilter<typename T::Event>, T> &&
concept is_filter = std::is_base_of_v<EventFilter<typename T::Event>, T> &&
requires(T a) {
a.handle(std::declval<typename T::Callback>(), std::declval<typename T::Event*>());
};
@ -55,14 +55,14 @@ namespace geode {
class EventListener : public EventListenerProtocol {
public:
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;
ListenerResult passThrough(Event* e) override {
if (m_callback) {
if (auto myev = typeinfo_cast<typename T::Event*>(e)) {
return m_filter.handle(m_callback, myev);
}
// 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 ListenerResult::Propagate;
}
@ -70,15 +70,19 @@ namespace geode {
EventListener(T filter = T()) {
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();
}
EventListener(Callback* fnptr, T filter = T()) : m_callback(fnptr), m_filter(filter) {
this->enable();
}
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();
}
@ -86,11 +90,13 @@ namespace geode {
std::cout << "this: " << this << "\n";
m_callback = fn;
}
template <typename C>
void bind(C* cls, MemberFn<C> fn) {
std::cout << "this: " << this << "\n";
m_callback = std::bind(fn, cls, std::placeholders::_1);
}
protected:
std::function<Callback> m_callback = nullptr;
T m_filter;

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

@ -1,9 +1,10 @@
#pragma once
#include "Event.hpp"
#include <optional>
#include "Mod.hpp"
#include <optional>
namespace geode {
enum class ModEventType {
Loaded,
@ -18,25 +19,25 @@ namespace geode {
protected:
ModEventType m_type;
Mod* m_mod;
public:
ModStateEvent(Mod* mod, ModEventType type);
ModEventType getType() const;
Mod* getMod() const;
};
class GEODE_DLL ModStateFilter : public EventFilter<ModStateEvent> {
public:
using Callback = void(ModStateEvent*);
protected:
class GEODE_DLL ModStateFilter : public EventFilter<ModStateEvent> {
public:
using Callback = void(ModStateEvent*);
protected:
ModEventType m_type;
Mod* m_mod;
public:
public:
ListenerResult handle(std::function<Callback> fn, ModStateEvent* event);
ModStateFilter(Mod* mod, ModEventType type);
};
ModStateFilter(Mod* mod, ModEventType type);
};
}
#define $on_mod(type) \

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

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

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

@ -1,7 +1,7 @@
#pragma once
#include "casts.hpp"
#include "../external/json/json.hpp"
#include "casts.hpp"
#include "general.hpp"
#include "../DefaultInclude.hpp"
#include <cocos2d.h>
@ -140,11 +140,11 @@ namespace geode {
}
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) {
return { -size.width, -size.height };
return {-size.width, -size.height};
}
static bool operator==(cocos2d::CCPoint const& p1, cocos2d::CCPoint const& p2) {
@ -284,6 +284,7 @@ namespace geode {
bool operator==(T* other) const {
return m_obj == other;
}
bool operator==(Ref<T> const& other) const {
return m_obj == other.m_obj;
}
@ -291,6 +292,7 @@ namespace geode {
bool operator!=(T* other) const {
return m_obj != other;
}
bool operator!=(Ref<T> const& other) const {
return m_obj != other.m_obj;
}
@ -299,6 +301,7 @@ namespace geode {
bool operator<(Ref<T> const& other) const {
return m_obj < other.m_obj;
}
bool operator>(Ref<T> const& other) const {
return m_obj > other.m_obj;
}
@ -436,13 +439,13 @@ namespace geode::cocos {
*/
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
* @param returnTo A function that returns a new layer. After loading is
* finished, the game switches to the given layer instead of MenuLayer.
* @param returnTo A function that returns a new layer. After loading is
* finished, the game switches to the given layer instead of MenuLayer.
* Leave nullptr to enable default behaviour
*/
GEODE_DLL void reloadTextures(CreateLayerFunc returnTo = nullptr);
@ -454,9 +457,7 @@ namespace geode::cocos {
* @param def Default size
* @param min Minimum size
*/
GEODE_DLL void limitNodeSize(
cocos2d::CCNode* node, cocos2d::CCSize const& size, float def, float min
);
GEODE_DLL void limitNodeSize(cocos2d::CCNode* node, cocos2d::CCSize const& size, float def, float min);
/**
* Checks if a node is visible (recursively
@ -479,12 +480,12 @@ namespace geode::cocos {
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
*
*
* @param node Parent node
* @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
*/
template <class Type = cocos2d::CCNode>
@ -498,8 +499,7 @@ namespace geode::cocos {
for (int i = 0; i < children->count(); ++i) {
auto newParent = static_cast<cocos2d::CCNode*>(children->objectAtIndex(i));
auto child = findFirstChildRecursive(newParent, predicate);
if (child)
return child;
if (child) return child;
}
return nullptr;
@ -603,13 +603,18 @@ namespace geode::cocos {
}
inline cocos2d::ccColor4B invert4B(cocos2d::ccColor4B const& color) {
return { static_cast<GLubyte>(255 - color.r), static_cast<GLubyte>(255 - color.g),
static_cast<GLubyte>(255 - color.b), color.a };
return {
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) {
return { static_cast<GLubyte>(255 - color.r), static_cast<GLubyte>(255 - color.g),
static_cast<GLubyte>(255 - color.b) };
return {
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) {
@ -625,34 +630,38 @@ namespace geode::cocos {
}
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) {
return { color.r, color.g, color.b, alpha };
return {color.r, color.g, color.b, alpha};
}
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) {
if (hexValue <= 0xf)
return cocos2d::ccColor3B { static_cast<GLubyte>(hexValue * 17),
static_cast<GLubyte>(hexValue * 17),
static_cast<GLubyte>(hexValue * 17) };
return cocos2d::ccColor3B{
static_cast<GLubyte>(hexValue * 17),
static_cast<GLubyte>(hexValue * 17),
static_cast<GLubyte>(hexValue * 17)};
if (hexValue <= 0xff)
return cocos2d::ccColor3B { static_cast<GLubyte>(hexValue),
static_cast<GLubyte>(hexValue),
static_cast<GLubyte>(hexValue) };
return cocos2d::ccColor3B{
static_cast<GLubyte>(hexValue),
static_cast<GLubyte>(hexValue),
static_cast<GLubyte>(hexValue)};
if (hexValue <= 0xfff)
return cocos2d::ccColor3B { static_cast<GLubyte>((hexValue >> 8 & 0xf) * 17),
static_cast<GLubyte>((hexValue >> 4 & 0xf) * 17),
static_cast<GLubyte>((hexValue >> 0 & 0xf) * 17) };
return cocos2d::ccColor3B{
static_cast<GLubyte>((hexValue >> 8 & 0xf) * 17),
static_cast<GLubyte>((hexValue >> 4 & 0xf) * 17),
static_cast<GLubyte>((hexValue >> 0 & 0xf) * 17)};
else
return cocos2d::ccColor3B { static_cast<GLubyte>(hexValue >> 16 & 0xff),
static_cast<GLubyte>(hexValue >> 8 & 0xff),
static_cast<GLubyte>(hexValue >> 0 & 0xff) };
return cocos2d::ccColor3B{
static_cast<GLubyte>(hexValue >> 16 & 0xff),
static_cast<GLubyte>(hexValue >> 8 & 0xff),
static_cast<GLubyte>(hexValue >> 0 & 0xff)};
}
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>>>
static cocos2d::CCArray* vectorToCCArray(
std::vector<T> const& vec, std::function<C(T)> convFunc
) {
static cocos2d::CCArray* vectorToCCArray(std::vector<T> const& vec, std::function<C(T)> convFunc) {
auto res = cocos2d::CCArray::createWithCapacity(vec.size());
for (auto const& item : vec)
res->addObject(convFunc(item));
@ -681,8 +688,7 @@ namespace geode::cocos {
template <typename T, typename = std::enable_if_t<std::is_pointer_v<T>>>
std::vector<T> ccArrayToVector(cocos2d::CCArray* arr) {
return std::vector<T>(
reinterpret_cast<T*>(arr->data->arr),
reinterpret_cast<T*>(arr->data->arr) + arr->data->num
reinterpret_cast<T*>(arr->data->arr), reinterpret_cast<T*>(arr->data->arr) + arr->data->num
);
}
@ -699,9 +705,7 @@ namespace geode::cocos {
template <
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>>>
static cocos2d::CCDictionary* mapToCCDict(
std::map<K, V> const& map, std::function<C(K)> convFunc
) {
static cocos2d::CCDictionary* mapToCCDict(std::map<K, V> const& map, std::function<C(K)> convFunc) {
auto res = cocos2d::CCDictionary::create();
for (auto const& [key, value] : map)
res->setObject(value, convFunc(key));
@ -726,7 +730,7 @@ namespace geode::cocos {
// std specializations
namespace std {
// enables using Ref as the key in unordered_map etc.
template<class T>
template <class T>
struct hash<geode::Ref<T>> {
size_t operator()(geode::Ref<T> const& ref) const {
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());
}
size_t size() const {
return m_arr ? m_arr->count() : 0;
}
@ -830,10 +835,10 @@ namespace geode::cocos {
std::pair<K, T> operator*() {
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 {
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 Holder = LambdaHolder<Func, Ret, Args...>;
static inline Holder s_selector {};
static inline Holder s_selector{};
Ret selector(Args... args) {
return s_selector(std::forward<Args>(args)...);

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

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

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

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

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

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

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

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

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

@ -19,7 +19,4 @@ ListenerResult ModStateFilter::handle(std::function<Callback> fn, ModStateEvent*
return ListenerResult::Propagate;
}
ModStateFilter::ModStateFilter(
Mod* mod,
ModEventType type
) : m_mod(mod), m_type(type) {}
ModStateFilter::ModStateFilter(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 <Geode/loader/IPC.hpp>
#include <Geode/loader/Loader.hpp>
#include <Geode/loader/Log.hpp>
#include <Geode/loader/Mod.hpp>
#include <Geode/loader/SettingEvent.hpp>
#include <Geode/loader/Setting.hpp>
#include <Geode/loader/IPC.hpp>
#include <Geode/loader/SettingEvent.hpp>
#include <InternalLoader.hpp>
#include <InternalMod.hpp>
#include <array>
@ -102,27 +102,25 @@ BOOL WINAPI DllMain(HINSTANCE lib, DWORD reason, LPVOID) {
#define $_ GEODE_CONCAT(unnamedVar_, __LINE__)
static auto $_ = listenForSettingChanges<BoolSetting>(
"show-platform-console",
[](BoolSetting* setting) {
static auto $_ =
listenForSettingChanges<BoolSetting>("show-platform-console", [](BoolSetting* setting) {
if (setting->getValue()) {
Loader::get()->openPlatformConsole();
}
else {
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!";
});
static auto $_ = listenForIPC("loader-info", +[](IPCEvent* event) -> nlohmann::json {
static auto $_ = listenForIPC("loader-info", [](IPCEvent* event) -> nlohmann::json {
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;
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>();
if (!dontIncludeLoader) {
res.push_back(includeRunTimeInfo ?
Loader::get()->getInternalMod()->getRuntimeInfo() :
Loader::get()->getInternalMod()->getModInfo().toJSON()
res.push_back(
includeRunTimeInfo ? Loader::get()->getInternalMod()->getRuntimeInfo() :
Loader::get()->getInternalMod()->getModInfo().toJSON()
);
}
for (auto& mod : Loader::get()->getAllMods()) {
res.push_back(
includeRunTimeInfo ?
mod->getRuntimeInfo() :
mod->getModInfo().toJSON()
);
res.push_back(includeRunTimeInfo ? mod->getRuntimeInfo() : mod->getModInfo().toJSON());
}
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/Log.hpp>
#include <InternalLoader.hpp>
#include <InternalMod.hpp>
#include <iostream>
#ifdef GEODE_IS_MACOS
#include <CoreFoundation/CoreFoundation.h>
#include <CoreFoundation/CoreFoundation.h>
void InternalLoader::platformMessageBox(char const* title, std::string const& info) {
CFStringRef cfTitle = CFStringCreateWithCString(NULL, title, kCFStringEncodingUTF8);
@ -29,46 +29,37 @@ void InternalLoader::closePlatformConsole() {
m_platformConsoleOpen = false;
}
CFDataRef msgPortCallback(
CFMessagePortRef port,
SInt32 messageID,
CFDataRef data,
void* info
) {
if(!CFDataGetLength(data))
return NULL;
CFDataRef msgPortCallback(CFMessagePortRef port, SInt32 messageID, CFDataRef data, void* info) {
if (!CFDataGetLength(data)) return NULL;
std::string cdata(
reinterpret_cast<char const*>(CFDataGetBytePtr(data)),
CFDataGetLength(data)
);
std::string cdata(reinterpret_cast<char const*>(CFDataGetBytePtr(data)), CFDataGetLength(data));
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() {
std::thread([]() {
CFStringRef portName = CFStringCreateWithCString(NULL, IPC_PORT_NAME, kCFStringEncodingUTF8);
CFMessagePortRef localPort = CFMessagePortCreateLocal(
NULL,
portName,
msgPortCallback,
NULL,
NULL
);
CFMessagePortRef localPort =
CFMessagePortCreateLocal(NULL, portName, msgPortCallback, NULL, NULL);
if (localPort == NULL) {
log::warn("Unable to create port, quitting IPC");
return;
}
CFRunLoopSourceRef runLoopSource = CFMessagePortCreateRunLoopSource(NULL, localPort, 0);
CFRunLoopAddSource(
CFRunLoopGetCurrent(),
runLoopSource,
kCFRunLoopCommonModes
);
if (runLoopSource == NULL) {
log::warn("Unable to create loop source, quitting IPC");
return;
}
CFRunLoopAddSource(CFRunLoopGetCurrent(), runLoopSource, kCFRunLoopCommonModes);
CFRunLoopRun();
CFRelease(localPort);
}).detach();
log::log(Severity::Warning, InternalMod::get(), "IPC is not supported on this platform");
log::debug("IPC set up");
}
#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/Log.hpp>
#include <iostream>
#include <InternalLoader.hpp>
#include <InternalMod.hpp>
#include <iostream>
USE_GEODE_NAMESPACE();
@ -77,10 +77,10 @@ void InternalLoader::setupIPC() {
nullptr
);
if (pipe == INVALID_HANDLE_VALUE) {
// todo: Rn this quits IPC, but we might wanna change that later
// to just continue trying. however, I'm assuming that if
// CreateNamedPipeA fails, then it will probably fail again if
// you try right after, so changing the break; to continue; might
// todo: Rn this quits IPC, but we might wanna change that later
// to just continue trying. however, I'm assuming that if
// CreateNamedPipeA fails, then it will probably fail again if
// you try right after, so changing the break; to continue; might
// just result in the console getting filled with error messages
log::warn("Unable to create pipe, quitting IPC");
break;
@ -89,14 +89,15 @@ void InternalLoader::setupIPC() {
if (ConnectNamedPipe(pipe, nullptr)) {
// log::debug("Got connection, creating thread");
std::thread(&ipcPipeThread, pipe).detach();
} else {
}
else {
// log::debug("No connection, cleaning pipe");
CloseHandle(pipe);
}
}
}).detach();
log::log(Severity::Debug, InternalMod::get(), "IPC set up");
log::debug("IPC set up");
}
#endif

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

@ -205,14 +205,12 @@ JsonMaybeValue<Json> JsonMaybeValue<Json>::at(size_t i) {
return *this;
}
return JsonMaybeValue<Json>(
self().m_checker, self().m_json.at(i), self().m_hierarchy + "." + std::to_string(i),
self().m_hasValue
self().m_checker, self().m_json.at(i), self().m_hierarchy + "." + std::to_string(i), self().m_hasValue
);
}
template <class Json>
typename JsonMaybeValue<Json>::template Iterator<JsonMaybeValue<Json>> JsonMaybeValue<
Json>::iterate() {
typename JsonMaybeValue<Json>::template Iterator<JsonMaybeValue<Json>> JsonMaybeValue<Json>::iterate() {
this->as<value_t::array>();
Iterator<JsonMaybeValue<Json>> iter;
if (this->isError()) return iter;
@ -226,8 +224,8 @@ typename JsonMaybeValue<Json>::template Iterator<JsonMaybeValue<Json>> JsonMaybe
}
template <class Json>
typename JsonMaybeValue<Json>::template Iterator<std::pair<std::string, JsonMaybeValue<Json>>>
JsonMaybeValue<Json>::items() {
typename JsonMaybeValue<Json>::template Iterator<std::pair<std::string, JsonMaybeValue<Json>>> JsonMaybeValue<
Json>::items() {
this->as<value_t::object>();
Iterator<std::pair<std::string, JsonMaybeValue<Json>>> iter;
if (this->isError()) return iter;
@ -235,9 +233,7 @@ JsonMaybeValue<Json>::items() {
for (auto& [k, v] : self().m_json.items()) {
iter.m_values.emplace_back(
k,
JsonMaybeValue<Json>(
self().m_checker, v, self().m_hierarchy + "." + k, self().m_hasValue
)
JsonMaybeValue<Json>(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, 9)), macro(GEODE_CONCAT(begin, a)), \
macro(GEODE_CONCAT(begin, b)), macro(GEODE_CONCAT(begin, c)), \
macro(GEODE_CONCAT(begin, d)), macro(GEODE_CONCAT(begin, e)), \
macro(GEODE_CONCAT(begin, f))
macro(GEODE_CONCAT(begin, d)), macro(GEODE_CONCAT(begin, e)), macro(GEODE_CONCAT(begin, f))
#define GEODE_ADDRESSER_NEST2(macro, begin) \
GEODE_ADDRESSER_NEST1(macro, GEODE_CONCAT(begin, 0)), \
@ -53,13 +52,13 @@ namespace {
using table_table_t = intptr_t[0x100];
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 {
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();
void cocos2d::to_json(nlohmann::json& json, ccColor3B const& color) {
json = nlohmann::json {
{ "r", color.r },
{ "g", color.g },
{ "b", color.b },
json = nlohmann::json{
{"r", color.r},
{"g", color.g},
{"b", color.b},
};
}
@ -20,9 +20,7 @@ void cocos2d::from_json(nlohmann::json const& json, ccColor3B& color) {
json.at(2).get_to(color.b);
}
else {
throw nlohmann::json::type_error::create(
0, "Expected color array to have 3 items", json
);
throw nlohmann::json::type_error::create(0, "Expected color array to have 3 items", json);
}
}
// 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) {
json = nlohmann::json {
{ "r", color.r },
{ "g", color.g },
{ "b", color.b },
{ "a", color.a },
json = nlohmann::json{
{"r", color.r},
{"g", color.g},
{"b", color.b},
{"a", color.a},
};
}
@ -75,9 +73,7 @@ void cocos2d::from_json(nlohmann::json const& json, ccColor4B& color) {
json.at(3).get_to(color.a);
}
else {
throw nlohmann::json::type_error::create(
0, "Expected color array to have 4 items", json
);
throw nlohmann::json::type_error::create(0, "Expected color array to have 4 items", json);
}
}
// object
@ -245,7 +241,7 @@ CCRect geode::cocos::calculateNodeCoverage(std::vector<CCNode*> const& nodes) {
for (auto child : nodes) {
auto pos = child->getPosition() - child->getScaledContentSize() * child->getAnchorPoint();
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) {
coverage.origin.x = pos.x;
}
@ -267,7 +263,7 @@ CCRect geode::cocos::calculateNodeCoverage(CCArray* nodes) {
for (auto child : CCArrayExt<CCNode>(nodes)) {
auto pos = child->getPosition() - child->getScaledContentSize() * child->getAnchorPoint();
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) {
coverage.origin.x = pos.x;
}
@ -288,9 +284,7 @@ CCRect geode::cocos::calculateChildCoverage(CCNode* parent) {
return calculateNodeCoverage(parent->getChildren());
}
void geode::cocos::limitNodeSize(
cocos2d::CCNode* spr, cocos2d::CCSize const& size, float def, float min
) {
void geode::cocos::limitNodeSize(cocos2d::CCNode* spr, cocos2d::CCSize const& size, float def, float min) {
spr->setScale(1.f);
auto [cwidth, cheight] = spr->getContentSize();

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

@ -164,12 +164,14 @@ public:
// Read file and add to entries
unz_file_pos pos;
if (unzGetFilePos(m_zip, &pos) == UNZ_OK) {
m_entries.insert({ fileName,
ZipEntry {
.m_pos = pos,
.m_compressedSize = fileInfo.compressed_size,
.m_uncompressedSize = fileInfo.uncompressed_size,
} });
m_entries.insert({
fileName,
ZipEntry {
.m_pos = pos,
.m_compressedSize = fileInfo.compressed_size,
.m_uncompressedSize = fileInfo.uncompressed_size,
},
});
}
// Read next file, or break on error
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);
}
std::string& utils::string::replaceIP(
std::string& str, std::string const& orig, std::string const& repl
) {
std::string& utils::string::replaceIP(std::string& str, std::string const& orig, std::string const& repl) {
std::string::size_type n = 0;
while ((n = str.find(orig, n)) != std::string::npos) {
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) {
str.erase(
std::find_if(
str.rbegin(), str.rend(),
str.rbegin(),
str.rend(),
[](auto 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) {
str.erase(
std::find_if(
str.rbegin(), str.rend(),
str.rbegin(),
str.rend(),
[](auto 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)));
}
static std::unordered_map<std::string, SentAsyncWebRequestHandle> RUNNING_REQUESTS {};
static std::unordered_map<std::string, SentAsyncWebRequestHandle> RUNNING_REQUESTS{};
static std::mutex RUNNING_REQUESTS_MUTEX;
SentAsyncWebRequest::SentAsyncWebRequest(AsyncWebRequest const& req, std::string const& id) :
@ -190,10 +190,11 @@ SentAsyncWebRequest::SentAsyncWebRequest(AsyncWebRequest const& req, std::string
struct ProgressData {
SentAsyncWebRequest* self;
std::ofstream* file;
} data { this, file.get() };
} data{this, file.get()};
curl_easy_setopt(
curl, CURLOPT_PROGRESSFUNCTION,
curl,
CURLOPT_PROGRESSFUNCTION,
+[](void* ptr, double total, double now, double, double) -> int {
auto data = static_cast<ProgressData*>(ptr);
while (data->self->m_paused) {}
@ -350,7 +351,7 @@ SentAsyncWebRequestHandle AsyncWebRequest::send() {
else {
auto id = m_joinID.value_or("__anon_request_" + std::to_string(COUNTER++));
ret = std::make_shared<SentAsyncWebRequest>(*this, id);
RUNNING_REQUESTS.insert({ id, ret });
RUNNING_REQUESTS.insert({id, ret});
}
// resume all running requests