namespace EE

Overview

namespace EE {

// namespaces

namespace EE::Audio;
namespace EE::Graphics;
namespace EE::Math;
    namespace EE::Math::easing;
namespace EE::Network;
    namespace EE::Network::SSL;
namespace EE::Scene;
    namespace EE::Scene::Actions;
namespace EE::System;
namespace EE::UI;
    namespace EE::UI::Abstract;
    namespace EE::UI::CSS;
        namespace EE::UI::CSS::detail;
    namespace EE::UI::Doc;
    namespace EE::UI::LayoutInvalidation;
    namespace EE::UI::Models;
    namespace EE::UI::Private;
    namespace EE::UI::Tools;
namespace EE::Window;

// typedefs

typedef float Float;
typedef signed char Int8;
typedef unsigned char Uint8;
typedef signed short Int16;
typedef unsigned short Uint16;
typedef signed int Int32;
typedef unsigned int Uint32;
typedef signed long long Int64;
typedef unsigned long long Uint64;
typedef Int32 IntPtr;
typedef Uint32 UintPtr;
typedef ankerl::unordered_dense::map<Key, Value, Hash, KeyEqual> UnorderedMap;
typedef ankerl::unordered_dense::set<Key> UnorderedSet;
typedef ankerl::unordered_dense::map<Key, Value, ankerl::unordered_dense::hash<Key>, std::equal_to<Key>, EE::SmallVector<std::pair<Key, Value>, MinInlineCapacity>> SmallUnorderedMap;
typedef ankerl::unordered_dense::set<Key, ankerl::unordered_dense::hash<Key>, std::equal_to<Key>, EE::SmallVector<Key, MinInlineCapacity>> SmallUnorderedSet;
typedef std::unordered_map<void*, AllocatedPointer> AllocatedPointerMap;
typedef AllocatedPointerMap::iterator AllocatedPointerMapIt;
typedef Utf<8> Utf8;
typedef Utf<16> Utf16;
typedef Utf<32> Utf32;
typedef long long ios_size;

// structs

template <typename T>
struct FormatArg;

template <>
struct FormatArg<std::string>;

template <>
struct FormatArg<std::string_view>;

template <typename... Ts>
struct Overloaded;

struct TextHints;

// classes

class AllocatedPointer;

template <typename T, typename Calculator, typename... Dependencies>
class ComputedValue;

template <std::size_t Capacity, typename KeyT = std::uint64_t, typename ValueT = std::array<char, 64>>
class DynamicLRU;

template <std::size_t Capacity, typename KeyT = std::uint64_t, typename ValueT = std::array<char, 64>>
class LRUCache;

class MemoryManager;
class NonCopyable;

template <typename T>
class ObservableValue;

template <typename T>
class ObservableVector;

template <std::size_t InlineSize = 64>
class SmallFunction;

template <typename T, size_t MinInlineCapacity = 16>
class SmallVector;

template <std::size_t Capacity, typename KeyT = std::uint64_t, typename ValueT = std::array<char, 64>>
class StaticLRU;

class String;

template <>
class Utf<32>;

template <>
class Utf<16>;

template <unsigned int N>
class Utf;

template <>
class Utf<8>;

class Version;

// global variables

EE_API bool PrintDebugInLog;

// global functions

template <typename T>
T eemax(T a, T b);

template <typename T>
T eemin(T a, T b);

template <typename T>
T eeabs(T n);

template <typename T>
T eeclamp(T val, T min, T max);

template <typename T>
void eeclamp(T* val, T min, T max);

template <typename Calculator, typename... Dependencies>
auto makeComputedValue(Calculator&& calculator, Dependencies&... dependencies);

template <typename Dependency, typename Calculator>
auto computedValue(Dependency& dependency, Calculator&& calculator);

template <typename Dependency1, typename Dependency2, typename Calculator>
auto computedValue(Dependency1& dependency1, Dependency2& dependency2, Calculator&& calculator);

template <typename Dependency1, typename Dependency2, typename Dependency3, typename Calculator>
auto computedValue(Dependency1& dependency1, Dependency2& dependency2, Dependency3& dependency3, Calculator&& calculator);

template <typename Dependency1, typename Dependency2, typename Dependency3, typename Dependency4, typename Calculator>
auto computedValue(Dependency1& dependency1, Dependency2& dependency2, Dependency3& dependency3, Dependency4& dependency4, Calculator&& calculator);

void EE_API eePRINT(const char* format, ...);
void EE_API eePRINTL(const char* format, ...);
void EE_API eePRINTC(unsigned int cond, const char* format, ...);

template <typename... Ts>
Overloaded(Ts...);

} // namespace EE

Detailed Documentation

Global Functions

template <typename Calculator, typename... Dependencies>
auto makeComputedValue(Calculator&& calculator, Dependencies&... dependencies)

Creates a ComputedValue while deducing its result, calculator, and dependency types.

template <typename Dependency, typename Calculator>
auto computedValue(Dependency& dependency, Calculator&& calculator)

Convenience form of makeComputedValue() for one dependency.

template <typename Dependency1, typename Dependency2, typename Calculator>
auto computedValue(Dependency1& dependency1, Dependency2& dependency2, Calculator&& calculator)

Convenience form of makeComputedValue() for two dependencies.

template <typename Dependency1, typename Dependency2, typename Dependency3, typename Calculator>
auto computedValue(Dependency1& dependency1, Dependency2& dependency2, Dependency3& dependency3, Calculator&& calculator)

Convenience form of makeComputedValue() for three dependencies.

template <typename Dependency1, typename Dependency2, typename Dependency3, typename Dependency4, typename Calculator>
auto computedValue(Dependency1& dependency1, Dependency2& dependency2, Dependency3& dependency3, Dependency4& dependency4, Calculator&& calculator)

Convenience form of makeComputedValue() for four dependencies.