geode/loader/include/Geode/utils/cocos.hpp
2022-11-22 17:24:03 +02:00

634 lines
18 KiB
C++

#pragma once
#include "Ref.hpp"
#include "casts.hpp"
#include <Geode/DefaultInclude.hpp>
#include <cocos2d.h>
#include <functional>
#include <type_traits>
namespace geode::cocos {
/**
* Get child at index. Checks bounds. A negative
* index will get the child starting from the end
* @returns Child at index cast to the given type,
* or nullptr if index exceeds bounds
*/
template <class T = cocos2d::CCNode>
static T* getChild(cocos2d::CCNode* x, int i) {
// start from end for negative index
if (i < 0) i = x->getChildrenCount() + i;
// check if backwards index is out of bounds
if (i < 0) return nullptr;
// check if forwards index is out of bounds
if (static_cast<int>(x->getChildrenCount()) <= i) return nullptr;
return static_cast<T*>(x->getChildren()->objectAtIndex(i));
}
/**
* Get nth child that is a given type. Checks bounds.
* @returns Child at index cast to the given type,
* or nullptr if index exceeds bounds
*/
template <class Type = cocos2d::CCNode>
static Type* getChildOfType(cocos2d::CCNode* node, size_t index) {
size_t indexCounter = 0;
for (size_t i = 0; i < node->getChildrenCount(); ++i) {
auto obj = cast::typeinfo_cast<Type*>(node->getChildren()->objectAtIndex(i));
if (obj != nullptr) {
if (indexCounter == index) {
return obj;
}
++indexCounter;
}
}
return nullptr;
}
/**
* Return a node, or create a default one if it's
* nullptr. Syntactic sugar function
*/
template <class T, class... Args>
static T* nodeOrDefault(T* node, Args... args) {
return node ? node : T::create(args...);
}
template <class T = cocos2d::CCNode>
struct SafeCreate final {
T* result;
SafeCreate<T>& with(T* node) {
result = node;
return *this;
}
template <class... Args>
SafeCreate<T>& make(Args... args) {
result = T::create(args...);
return *this;
}
// convenience for CCSprite
template <class... Args>
SafeCreate<T>& makeWithFrame(Args... args) {
result = T::createWithSpriteFrameName(args...);
return *this;
}
template <class... Args>
SafeCreate<T>& makeUsing(T* (*func)(Args...), Args... args) {
result = func(args...);
return *this;
}
template <class O = T, class... Args>
T* orMakeUsing(O* (*func)(Args...), Args... args) {
if (result) return result;
return func(args...);
}
template <class O = T, class... Args>
T* orMake(Args... args) {
if (result) return result;
return O::create(args...);
}
template <class O = T, class... Args>
T* orMakeWithFrame(Args... args) {
if (result) return result;
return O::createWithSpriteFrameName(args...);
}
};
/**
* Get bounds for a set of nodes. Based on content
* size
* @param nodes Nodes to calculate coverage of
* @returns Rectangle fitting all nodes. Origin
* will be <= 0 and size will be >= 0
*/
GEODE_DLL cocos2d::CCRect calculateNodeCoverage(std::vector<cocos2d::CCNode*> const& nodes);
/**
* Get bounds for a set of nodes. Based on content
* size
* @param nodes Nodes to calculate coverage of
* @returns Rectangle fitting all nodes. Origin
* will be <= 0 and size will be >= 0
*/
GEODE_DLL cocos2d::CCRect calculateNodeCoverage(cocos2d::CCArray* nodes);
/**
* Get bounds for a set of nodes. Based on content
* size
* @param parent Parent whose children to calculate
* coverage of
* @returns Rectangle fitting all the parent's children.
* Origin will be <= 0 and size will be >= 0
*/
GEODE_DLL cocos2d::CCRect calculateChildCoverage(cocos2d::CCNode* parent);
/**
* Create a CCScene from a layer and switch to it with the default fade
* transition
* @param layer Layer to create a scene from
* @returns Created scene (not the fade transition)
*/
GEODE_DLL cocos2d::CCScene* switchToScene(cocos2d::CCLayer* layer);
using CreateLayerFunc = cocos2d::CCLayer*(*)();
/**
* 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.
* Leave nullptr to enable default behaviour
*/
GEODE_DLL void reloadTextures(CreateLayerFunc returnTo = nullptr);
/**
* Rescale node to fit inside given size
* @param node Node to rescale
* @param size Size to fit inside
* @param def Default size
* @param min Minimum size
*/
GEODE_DLL void limitNodeSize(
cocos2d::CCNode* node, cocos2d::CCSize const& size, float def, float min
);
/**
* Checks if a node is visible (recursively
* checks parent visibility)
* @param node Node to check if visible
* @returns True if node is visibile. Does
* not take into account if node is off-screen
*/
GEODE_DLL bool nodeIsVisible(cocos2d::CCNode* node);
/**
* Gets a node by tag by traversing
* children recursively
*
* @param node Parent node
* @param tag Target tag
* @return Child node with specified tag, or
* null if there is none
*/
GEODE_DLL cocos2d::CCNode* getChildByTagRecursive(cocos2d::CCNode* node, int tag);
/**
* 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
* there is none
*/
template <class Type = cocos2d::CCNode>
Type* findFirstChildRecursive(cocos2d::CCNode* node, std::function<bool(Type*)> predicate) {
if (cast::safe_cast<Type*>(node) && predicate(static_cast<Type*>(node)))
return static_cast<Type*>(node);
auto children = node->getChildren();
if (!children) return nullptr;
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;
}
return nullptr;
}
/**
* Checks if a given file exists in CCFileUtils
* search paths.
* @param filename File to check
* @returns True if file exists
* @example if (fileExistsInSearchPaths("mySprite.png"_spr)) {
* CCSprite::create("mySprite.png"_spr);
* } else {
* CCSprite::create("fallback.png");
* }
*/
GEODE_DLL bool fileExistsInSearchPaths(char const* filename);
template <typename T>
struct CCArrayIterator {
public:
CCArrayIterator(T* p) : m_ptr(p) {}
T* m_ptr;
auto& operator*() {
return *m_ptr;
}
auto& operator*() const {
return *m_ptr;
}
auto operator->() {
return m_ptr;
}
auto operator->() const {
return m_ptr;
}
auto& operator++() {
++m_ptr;
return *this;
}
auto& operator--() {
--m_ptr;
return *this;
}
auto& operator+=(size_t val) {
m_ptr += val;
return *this;
}
auto& operator-=(size_t val) {
m_ptr -= val;
return *this;
}
auto operator+(size_t val) const {
return CCArrayIterator<T>(m_ptr + val);
}
auto operator-(size_t val) const {
return CCArrayIterator<T>(m_ptr - val);
}
auto operator-(CCArrayIterator<T> const& other) const {
return m_ptr - other.m_ptr;
}
bool operator<(CCArrayIterator<T> const& other) const {
return m_ptr < other.m_ptr;
}
bool operator>(CCArrayIterator<T> const& other) const {
return m_ptr > other.m_ptr;
}
bool operator<=(CCArrayIterator<T> const& other) const {
return m_ptr <= other.m_ptr;
}
bool operator>=(CCArrayIterator<T> const& other) const {
return m_ptr >= other.m_ptr;
}
bool operator==(CCArrayIterator<T> const& other) const {
return m_ptr == other.m_ptr;
}
bool operator!=(CCArrayIterator<T> const& other) const {
return m_ptr != other.m_ptr;
}
};
}
namespace std {
template <typename T>
struct iterator_traits<geode::cocos::CCArrayIterator<T>> {
using difference_type = ptrdiff_t;
using value_type = T;
using pointer = T*;
using reference = T&;
using iterator_category =
std::random_access_iterator_tag; // its random access but im too lazy to implement it
};
}
namespace geode::cocos {
struct GEODE_DLL CCArrayInserter {
public:
CCArrayInserter(cocos2d::CCArray* p) : m_array(p) {}
cocos2d::CCArray* m_array;
auto& operator=(cocos2d::CCObject* value) {
m_array->addObject(value);
return *this;
}
auto& operator*() {
return *this;
}
auto& operator++() {
return *this;
}
};
template <typename _Type>
class CCArrayExt {
protected:
Ref<cocos2d::CCArray> m_arr;
using T = std::remove_pointer_t<_Type>;
public:
CCArrayExt() : m_arr(cocos2d::CCArray::create()) {}
CCArrayExt(cocos2d::CCArray* arr) : m_arr(arr) {}
CCArrayExt(CCArrayExt const& a) : m_arr(a.m_arr) {}
CCArrayExt(CCArrayExt&& a) : m_arr(a.m_arr) {
a.m_arr = nullptr;
}
~CCArrayExt() {}
auto begin() {
if (!m_arr) {
return CCArrayIterator<T*>(nullptr);
}
return CCArrayIterator<T*>(reinterpret_cast<T**>(m_arr->data->arr));
}
auto end() {
if (!m_arr) {
return CCArrayIterator<T*>(nullptr);
}
return CCArrayIterator<T*>(reinterpret_cast<T**>(m_arr->data->arr) + m_arr->count());
}
size_t size() const {
return m_arr ? m_arr->count() : 0;
}
T operator[](size_t index) {
return static_cast<T*>(m_arr->objectAtIndex(index));
}
void push_back(T* item) {
m_arr->addObject(item);
}
T* pop_back() {
T ret = m_arr->lastObject();
m_arr->removeLastObject();
return ret;
}
cocos2d::CCArray* inner() {
return m_arr;
}
};
template <typename K, typename T>
struct CCDictIterator {
public:
CCDictIterator(cocos2d::CCDictElement* p) : m_ptr(p) {}
cocos2d::CCDictElement* m_ptr;
std::pair<K, T> operator*() {
if constexpr (std::is_same<K, std::string>::value) {
return { m_ptr->getStrKey(), static_cast<T>(m_ptr->getObject()) };
}
else {
return { m_ptr->getIntKey(), static_cast<T>(m_ptr->getObject()) };
}
}
auto& operator++() {
m_ptr = static_cast<decltype(m_ptr)>(m_ptr->hh.next);
return *this;
}
friend bool operator==(CCDictIterator<K, T> const& a, CCDictIterator<K, T> const& b) {
return a.m_ptr == b.m_ptr;
};
friend bool operator!=(CCDictIterator<K, T> const& a, CCDictIterator<K, T> const& b) {
return a.m_ptr != b.m_ptr;
};
bool operator!=(int b) {
return m_ptr != nullptr;
}
};
template <typename K, typename T>
struct CCDictEntry {
K m_key;
cocos2d::CCDictionary* m_dict;
CCDictEntry(K key, cocos2d::CCDictionary* dict) : m_key(key), m_dict(dict) {}
T operator->() {
return static_cast<T>(m_dict->objectForKey(m_key));
}
operator T() {
return static_cast<T>(m_dict->objectForKey(m_key));
}
CCDictEntry& operator=(T f) {
m_dict->setObject(f, m_key);
return *this;
}
};
template <typename K, typename T>
struct CCDictionaryExt {
protected:
cocos2d::CCDictionary* m_dict;
public:
CCDictionaryExt() : m_dict(cocos2d::CCDictionary::create()) {
m_dict->retain();
}
CCDictionaryExt(cocos2d::CCDictionary* dict) : m_dict(dict) {
m_dict->retain();
}
CCDictionaryExt(CCDictionaryExt const& d) : m_dict(d.m_dict) {
m_dict->retain();
}
CCDictionaryExt(CCDictionaryExt&& d) : m_dict(d.m_dict) {
d.m_dict = nullptr;
}
~CCDictionaryExt() {
if (m_dict) m_dict->release();
}
CCDictionaryExt const& operator=(cocos2d::CCDictionary* d) {
m_dict->release();
m_dict = d;
m_dict->retain();
}
auto begin() {
return CCDictIterator<K, T*>(m_dict->m_pElements);
}
// do not use this
auto end() {
return nullptr;
}
size_t size() {
return m_dict->count();
}
auto operator[](K key) {
auto ret = static_cast<T*>(m_dict->objectForKey(key));
if (!ret) m_dict->setObject(cocos2d::CCNode::create(), key);
return CCDictEntry<K, T*>(key, m_dict);
}
size_t count(K key) {
return m_dict->allKeys(key)->count();
}
};
// namespace for storing implementation stuff for
// inline member functions
namespace {
// class that holds the lambda (probably should've just used
// std::function but hey, this one's heap-free!)
template <class F, class Ret, class... Args>
struct LambdaHolder {
bool m_assigned = false;
// lambdas don't implement operator= so we
// gotta do this wacky union stuff
union {
F m_lambda;
};
LambdaHolder() {}
~LambdaHolder() {
if (m_assigned) {
m_lambda.~F();
}
}
LambdaHolder(F&& func) {
this->assign(std::forward<F>(func));
}
Ret operator()(Args... args) {
if (m_assigned) {
return m_lambda(std::forward<Args>(args)...);
}
else {
return Ret();
}
}
void assign(F&& func) {
if (m_assigned) {
m_lambda.~F();
}
new (&m_lambda) F(func);
m_assigned = true;
}
};
// Extract parameters and return type from a lambda
template <class Func>
struct ExtractLambda : public ExtractLambda<decltype(&Func::operator())> {};
template <class C, class R, class... Args>
struct ExtractLambda<R (C::*)(Args...) const> {
using Ret = R;
using Params = std::tuple<Args...>;
};
// Class for storing the member function
template <class Base, class Func, class Args>
struct InlineMemberFunction;
template <class Base, class Func, class... Args>
struct InlineMemberFunction<Base, Func, std::tuple<Args...>> : public Base {
using Ret = typename ExtractLambda<Func>::Ret;
using Selector = Ret (Base::*)(Args...);
using Holder = LambdaHolder<Func, Ret, Args...>;
static inline Holder s_selector {};
Ret selector(Args... args) {
return s_selector(std::forward<Args>(args)...);
}
static Selector get(Func&& function) {
s_selector.assign(std::move(function));
return static_cast<Selector>(&InlineMemberFunction::selector);
}
};
}
/**
* Wrap a lambda into a member function pointer. Useful for creating
* callbacks that have to be members of a class without having to deal
* with all of the boilerplate associated with defining a new class
* member function.
*
* Do note that due to implementation problems, captures may have
* unexpected side-effects. In practice, lambda member functions with
* captures do not work properly in loops. If you assign the same
* member lambda to multiple different targets, they will share the
* same captured values.
*/
template <class Base, class Func>
[[deprecated(
"Due to too many implementation problems, "
"makeMemberFunction will be removed in the future."
)]] static auto
makeMemberFunction(Func&& function) {
return InlineMemberFunction<Base, Func, typename ExtractLambda<Func>::Params>::get(
std::move(function)
);
}
/**
* Create a SEL_MenuHandler out of a lambda with optional captures. Useful
* for adding callbacks to CCMenuItemSpriteExtras without needing to add
* the callback as a member to a class. Use the GEODE_MENU_SELECTOR class
* for even more concise code.
*
* Do note that due to implementation problems, captures may have
* unexpected side-effects. In practice, **you should not expect to be able
* to pass any more information than you can pass to a normal menu selector
* through captures**. If you assign the same member lambda to multiple
* different targets, they will share the same captured values.
*/
template <class Func>
[[deprecated(
"Due to too many implementation problems, "
"makeMenuSelector will be removed in the future."
)]] static cocos2d::SEL_MenuHandler
makeMenuSelector(Func&& selector) {
return reinterpret_cast<cocos2d::SEL_MenuHandler>(
makeMemberFunction<cocos2d::CCObject, Func>(std::move(selector))
);
}
#define GEODE_MENU_SELECTOR(senderArg, ...) \
makeMenuSelector([this](senderArg) { \
__VA_ARGS__; \
})
}