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

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

@ -71,8 +71,7 @@ namespace cocos2d::extension {}
#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::memset(reinterpret_cast<std::byte*>(this) + Offset_, 0, fill - Offset_)) {} \
Class_(std::monostate, void*)
#define GEODE_MONOSTATE_CONSTRUCTOR_BEGIN(Class_) \
@ -97,10 +96,71 @@ namespace cocos2d::extension {}
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, ... \
_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() \
@ -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, \
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)), \

21
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>
@ -45,8 +46,7 @@ namespace geode {
};
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,11 +55,13 @@ 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 (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 ListenerResult::Propagate;
@ -68,25 +70,31 @@ 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();
}
void bind(std::function<Callback> fn) {
m_callback = fn;
}
template <typename C>
void bind(C* cls, MemberFn<C> fn) {
m_callback = std::bind(fn, cls, std::placeholders::_1);
}
protected:
std::function<Callback> m_callback;
T m_filter;
@ -96,6 +104,7 @@ namespace geode {
static std::unordered_set<EventListenerProtocol*> s_listeners;
Mod* m_sender;
friend EventListenerProtocol;
public:
void postFrom(Mod* sender);

15
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,
@ -45,13 +46,17 @@ void GEODE_CONCAT(geodeExecFunction, __LINE__)(ModStateEvent*); \
namespace { \
struct GEODE_CONCAT(ExecFuncUnique, __LINE__) {}; \
} \
static inline auto GEODE_CONCAT(Exec, __LINE__) = (geode::Loader::get()->scheduleOnModLoad(\
geode::Mod::get(), []() { \
static inline auto GEODE_CONCAT(Exec, __LINE__) = \
(geode::Loader::get()->scheduleOnModLoad( \
geode::Mod::get(), \
[]() { \
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) \
); \
} \
), 0); \
), \
0); \
template <class> \
void GEODE_CONCAT(geodeExecFunction, __LINE__)(ModStateEvent*)

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;

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

@ -1,8 +1,9 @@
#pragma once
#include "casts.hpp"
#include "../external/json/json.hpp"
#include "casts.hpp"
#include "general.hpp"
#include <Geode/DefaultInclude.hpp>
#include <cocos2d.h>
#include <functional>
@ -283,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;
}
@ -290,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;
}
@ -298,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;
}
@ -435,7 +439,7 @@ 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
@ -453,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
@ -497,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;
@ -602,12 +603,17 @@ 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),
return {
static_cast<GLubyte>(255 - color.r),
static_cast<GLubyte>(255 - color.g),
static_cast<GLubyte>(255 - color.b)};
}
@ -637,19 +643,23 @@ namespace geode::cocos {
constexpr cocos2d::ccColor3B cc3x(int hexValue) {
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)};
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)};
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 >> 0 & 0xf) * 17)};
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 >> 0 & 0xff)};
}
@ -668,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));
@ -680,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
);
}
@ -698,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));
@ -797,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;
}

5
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>
@ -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

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

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

28
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() :
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;

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/Log.hpp>
#include <InternalLoader.hpp>
#include <InternalMod.hpp>
#include <iostream>
#ifdef GEODE_IS_MACOS
@ -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

9
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();
@ -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)
);
}

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, 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)), \

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);
}
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
@ -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
@ -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();

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

@ -151,12 +151,14 @@ public:
// Read file and add to entries
unz_file_pos pos;
if (unzGetFilePos(m_zip, &pos) == UNZ_OK) {
m_entries.insert({ fileName,
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);
}

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

@ -193,7 +193,8 @@ SentAsyncWebRequest::SentAsyncWebRequest(AsyncWebRequest const& req, std::string
} 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) {}