sead namespace

Namespaces

namespace anonymous_namespace{seadCoreInfo.cpp}

namespace anonymous_namespace{seadDateTime.cpp}

namespace anonymous_namespace{seadPath.cpp}

namespace BitUtil

namespace DateUtil

namespace detail

namespace hostio

namespace literals inline

namespace numbers

namespace PrimitiveRendererUtil

namespace RuntimeTypeInfo

namespace StringUtil

namespace system

Classes

class AccelerometerAddon

class AnyDelegate

template<typename A1>

class AnyDelegate1

template<typename T>

class AnyDelegate1Const

template<typename A1, typename R>

class AnyDelegate1R

template<typename A1, typename A2>

class AnyDelegate2

template<typename A1, typename A2, typename R>

class AnyDelegate2R

template<typename R>

class AnyDelegateR

class ArchiveFileDevice

class ArchiveRes

class Arena

class AssertConfig

template<class T>

struct Atomic

template<class T>

struct Atomic<T*>

Specialization for pointer types.

template<class T>

struct AtomicBase

struct AtomicDirectInitTag

class Base64

template<typename T>

struct BaseMtx22

template<typename T>

struct BaseMtx33

template<typename T>

struct BaseMtx34

template<typename T>

struct BaseMtx44

template<typename T>

struct BaseQuat

template<typename T>

struct BaseVec2

template<typename T>

struct BaseVec3

template<typename T>

struct BaseVec4

template<typename T>

class BitFlag

class BitFlagUtil

template<typename T>

struct BoundBox2

template<typename T>

struct BoundBox3

template<typename T>

class Buffer

template<typename T>

class BufferedSafeStringBase

class BufferingPrintFormatter

class BufferingPrintOutput

class BufferMultiByteNullTerminatedTextWriteStreamSrc

class BufferMultiByteTextWriteStream

class BufferMultiByteTextWriteStreamSrc

class BufferReadStream

class BufferReadStreamSrc

class BufferWriteStream

class BufferWriteStreamSrc

class CafeContentFileDevice

class CafeFSAFileDevice

class CalculateTask

class CalendarSpan

A CalendarSpan represents a duration in terms of days, hours, minutes and seconds.

class CalendarTime

class Camera

class Color4f

class Color4u8

template<typename T>

class ConditionalScopedLock

class ControlDevice

class Controller

class ControllerAddon

class ControllerBase

class ControllerDefine

class ControllerMgr

class ControllerWrapper

class ControllerWrapperBase

class CoreInfo

class CriticalSection

class DateSpan

class DateTime

class DateTimeUtc

class DebugFontMgrJis1Nvn

class DebugFontMgrNvn

class Decompressor

template<typename T>

class Delegate

template<typename T, typename A1>

class Delegate1

template<typename A1>

class Delegate1Func

template<typename T, typename A1, typename R>

class Delegate1R

template<typename A1, typename R>

class Delegate1RFunc

template<typename T, typename A1, typename A2>

class Delegate2

template<typename A1, typename A2>

class Delegate2Func

template<typename T, typename A1, typename A2, typename R>

class Delegate2R

template<typename A1, typename A2, typename R>

class Delegate2RFunc

template<typename T, typename PTMF, typename Base>

class DelegateBase

Base class for delegate implementations.

template<typename FunctionPointer, typename Base>

class DelegateBase<void, FunctionPointer, Base>

template<typename T>

class DelegateEvent

Manages signal and slots for an event.

class DelegateFunc

template<typename T, typename R>

class DelegateR

template<typename R>

class DelegateRFunc

class DelegateThread

class DirectCamera

struct DirectoryEntry

class DirectoryHandle

class DirectProjection

class DirectResource

template<typename T>

class DirectResourceFactory

class DirectResourceFactoryBase

class DrawContext

class DrawLockContext

class Endian

class EnumUtil

class EnvUtil

class Event

class ExpHeap

class FileDevice

class FileDeviceMgr

class FileHandle

class FindContainHeapCache

template<typename T, s32 N>

class FixedObjArray

template<typename T, s32 N>

class FixedObjList

template<typename T, s32 N>

class FixedPtrArray

template<typename T, s32 N>

class FixedRingBuffer

template<s32 L>

class FixedSafeString

template<typename T, s32 L>

class FixedSafeStringBase

class FixedSizeJQ

template<s32 N>

class FixedStringBuilder

template<typename Key, typename Value, int N>

class FixedTreeMap

class FontBase

template<s32 L>

class FormatFixedSafeString

class FrameBuffer

class FrameHeap

class Framework

class FreeList

class FrustumProjection

class GameConfig

class GameFramework

class GameFrameworkNx

class GlobalRandom

class Graphics

class GraphicsNvn

class HandleBase

class HashCRC16

class HashCRC32

class Heap

class HeapArray

class HeapMgr

struct HeapPolicies

struct HeapPolicy

template<typename T>

class HeapSafeStringBase

class HostIOMgr

class IDelegate

Interface of a delegate for a member function with no argument.

template<typename A1>

class IDelegate1

template<typename A1, typename R>

class IDelegate1R

template<typename A1, typename A2>

class IDelegate2

template<typename A1, typename A2, typename R>

class IDelegate2R

template<typename R>

class IDelegateR

class IDisposer

class INamable

class InfLoopChecker

struct InitializeTag

template<typename Key, typename Node>

class IntrusiveTreeMap

class Job

template<typename T>

class Job0

class JobQueue

class JobQueueLock

template<typename Lambda>

class LambdaDelegate

template<typename Lambda, typename A1>

class LambdaDelegate1

template<typename Lambda, typename A1, typename R>

class LambdaDelegate1R

template<typename Lambda, typename A1, typename A2>

class LambdaDelegate2

template<typename Lambda, typename A1, typename A2, typename R>

class LambdaDelegate2R

template<typename Lambda, typename R>

class LambdaDelegateR

class ListImpl

class ListNode

class LogicalFrameBuffer

template<s32 N>

class LongBitFlag

class LookAtCamera

class MainFileDevice

class MainThread

template<typename T>

class MathCalcCommon

template<typename T>

class Matrix22

template<typename T>

class Matrix22CalcCommon

template<typename T>

class Matrix33

template<typename T>

class Matrix33CalcCommon

template<typename T>

class Matrix34

template<typename T>

class Matrix34CalcCommon

template<typename T>

class Matrix44

template<typename T>

class Matrix44CalcCommon

class MemBlock

class MemUtil

class MessageQueue

class MethodTreeMgr

class MethodTreeNode

template<s32 N>

class MultiProcessMeterBar

class Mutex

class NinAocFileDevice

class NinContentFileDevice

class NinFileDeviceBase

class NinHostIOFileDevice

class NinJoyNpadDevice

class NinSaveFileDevice

class NinSDFileDevice

template<typename T>

class ObjArray

template<typename T>

class ObjList

template<typename T>

class OffsetList

template<typename Value>

class OrderedSet

template<typename Value>

struct OrderedSetItemImpl

class OrthoCamera

class OrthoProjection

class ParallelSZSDecompressor

class Path

class PatternRumbleAddon

class PerfJobQueue

class PerspectiveProjection

template<typename T>

class Policies

class PrimitiveDrawer

class PrimitiveRenderer

class PrimitiveRendererBase

class PrimitiveRendererCafe

class PrintFormatter

class PrintOutput

class ProcessMeter

class ProcessMeterBarBase

class Projection

template<typename T>

class PtrArray

class PtrArrayImpl

class PtrUtil

template<typename T>

struct Quat

template<typename T>

class QuatCalcCommon

class Random

A fast non-cryptographically secure pseudorandom number generator based on Xorshift128.

template<typename T>

class Ray

class ReadStream

class ReadWriteLock

class Resource

class ResourceFactory

class ResourceMgr

template<typename T>

class RingBuffer

template<typename T, s32 N>

class SafeArray

A lightweight std::array like wrapper for a C style array.

template<typename T>

class SafeStringBase

class ScopedCurrentHeapSetter

template<typename T>

class ScopedLock

template<typename Function>

class ScopeGuard

class Semaphore

class SharcArchiveRes

template<typename Enum, typename Storage>

struct SizedEnum

class SpinLock

template<s32 Capacity>

class StackTrace

class StackTraceBase

template<typename T, bool AutoDestruct = false>

class StorageFor

class Stream

class StreamFormat

class StreamPrintFormatter

class StreamPrintOutput

class StreamSrc

template<typename T>

class StringBuilderBase

class StringCutOffPrintFormatter

class StringCutOffPrintOutput

class StringPrintFormatter

class StringPrintOutput

template<s32 MaxKeyLength, typename Value>

class StrTreeMap

class SZSDecompressor

class Task

class TaskBase

class TaskClassID

struct TaskConstructArg

class TaskMgr

class TaskParameter

class TaskUserID

class Texture

class TextureCafeGX2

class TextWriter

class Thread

class ThreadLocalStorage

class ThreadMgr

class ThreadUtil

class TickSpan

A TickSpan represents a number of ticks.

class TickTime

A TickTime represents an instant in time.

template<typename T>

class TList

template<typename T>

class TListNode

template<typename Key, typename Value>

class TreeMap

template<typename Key>

class TreeMapImpl

template<typename Key>

struct TreeMapKeyImpl

template<typename Key>

class TreeMapNode

class TreeNode

template<typename T>

class TTreeNode

template<typename Enum, typename Storage = std::underlying_type_t<Enum>>

class TypedBitFlag

template<s32 N, typename Enum, typename Storage = std::underlying_type_t<Enum>>

class TypedLongBitFlag

class UniformBlockBuffer

template<typename T, s32 N>

class UnsafeArray

template<typename T>

struct Vector2

template<typename T>

class Vector2CalcCommon

template<typename T>

struct Vector3

template<typename T>

class Vector3CalcCommon

template<typename T>

struct Vector4

template<typename T>

class Vector4CalcCommon

class Viewport

template<s32 L>

class WFixedSafeString

template<s32 L>

class WFormatFixedSafeString

class Worker

class WorkerMgr

class WriteStream

struct ZeroInitializeTag

Typedefs

using HandleBuffer = SafeArray<u8, 32>

using TaskFactory = TaskBase*(*)(const TaskConstructArg&)

using MemBlockList = OffsetList<MemBlock>

using BoundBox2f = BoundBox2<f32>

using BoundBox3f = BoundBox3<f32>

using Mathi = MathCalcCommon<s32>

using Mathu = MathCalcCommon<u32>

using Mathf = MathCalcCommon<f32>

using MathSizeT = MathCalcCommon<size_t>

using Matrix22f = Matrix22<f32>

using Matrix33f = Matrix33<f32>

using Matrix34f = Matrix34<f32>

using Matrix44f = Matrix44<f32>

using Matrixf = Matrix34<f32>

using Quatf = Quat<f32>

using Vector2i = Vector2<s32>

using Vector2u = Vector2<u32>

using Vector2f = Vector2<f32>

using Vector3i = Vector3<s32>

using Vector3u = Vector3<u32>

using Vector3f = Vector3<f32>

using Vector4i = Vector4<s32>

using Vector4u = Vector4<u32>

using Vector4f = Vector4<f32>

using BitFlag8 = BitFlag<u8>

using BitFlag16 = BitFlag<u16>

using BitFlag32 = BitFlag<u32>

using BitFlag64 = BitFlag<u64>

using SafeString = SafeStringBase<char>

using WSafeString = SafeStringBase<char16>

using BufferedSafeString = BufferedSafeStringBase<char>

using WBufferedSafeString = BufferedSafeStringBase<char16>

using HeapSafeString = HeapSafeStringBase<char>

using WHeapSafeString = HeapSafeStringBase<char16>

using StringBuilder = StringBuilderBase<char>

using WStringBuilder = StringBuilderBase<char16>

using ThreadList = TList<Thread*>

using ThreadListNode = TListNode<Thread*>

Functions

void AllocFailAssert(Heap* heap, size_t size, u32 alignment)

auto AllocBuffer(size_t size, Heap* heap, s32 alignment) -> u8*

template<class T, std::size_t N>

auto toArray(T(&a)[N]) -> sead::SafeArray<std::remove_cv_t<T>, N> constexpr

template<class T, std::size_t N>

auto toArray(T( && a)[N]) -> sead::SafeArray<std::remove_cv_t<T>, N> constexpr

template<typename T>

auto log2(T n) -> T constexpr

template<typename T, typename T2>

auto lerp(T a, T b, T2 t) -> T

template<typename T>

auto operator==(const Matrix34<T>& lhs, const Matrix34<T>& rhs) -> bool

template<typename T>

auto operator!=(const Matrix34<T>& lhs, const Matrix34<T>& rhs) -> bool

SEAD_ENUM(CoreId, cMain, cSub1, cSub2, cSub3, cSub4, cSub5, cSub6, cSub7, cSub8, cSub9, cSub10, cSub11, cSub12, cSub13, cSub14, cSub15, cSub16, cSub17, cSub18, cSub19, cSub20, cSub21, cSub22, cSub23, cSub24, cSub25, cSub26, cSub27, cSub28, cSub29, cSub30, cSub31, cSub32, cUndef) class CoreIdMask

template<typename T>

auto stdIterator(T& container) -> auto

template<typename Lambda>

static auto makeLambdaDelegate(Lambda&& l) -> auto

template<typename Lambda>

static auto makeLambdaDelegateR(Lambda&& l) -> auto

template<typename A1, typename Lambda>

static auto makeLambdaDelegate1(Lambda&& l) -> auto

template<typename A1, typename Lambda>

static auto makeLambdaDelegate1R(Lambda&& l) -> auto

template<typename A1, typename A2, typename Lambda>

static auto makeLambdaDelegate2(Lambda&& l) -> auto

template<typename A1, typename A2, typename Lambda>

static auto makeLambdaDelegate2R(Lambda&& l) -> auto

auto flush(PrintFormatter& formatter) -> PrintFormatter&

template<typename DerivedType, typename Type>

auto IsDerivedFrom(const Type* obj) -> bool

Tests if the object is a DerivedType or any type that derives from (i.e. inherits) DerivedType.

template<typename DerivedType, typename Type>

auto DynamicCast(Type* obj) -> DerivedType*

template<typename T>

auto replaceStringImpl_(T* dst, s32* length, s32 dst_size, const T* src, s32 src_size, const SafeStringBase<T>& old_str, const SafeStringBase<T>& new_str, bool* is_buffer_overflow) -> s32

auto operator<(const SafeString& lhs, const SafeString& rhs) -> bool

auto operator>(const SafeString& lhs, const SafeString& rhs) -> bool

auto operator<=(const SafeString& lhs, const SafeString& rhs) -> bool

auto operator>=(const SafeString& lhs, const SafeString& rhs) -> bool

auto operator""_str(const char* str, std::size_t) -> SafeString

auto operator""_str(const char16* str, std::size_t) -> WSafeString

template<typename T>

auto calcStrLength_(const T* str) -> s32

template<typename T>

auto makeScopedLock(T& lock) -> ScopedLock<T>

template<typename T>

auto makeScopedLock(T& lock, bool do_lock) -> ConditionalScopedLock<T>

template<typename Function>

auto makeScopeGuard(Function&& function) -> ScopeGuard<Function>

To work around the lack of CTAD in compilers with incomplete C++17 support.

auto operator-(DateTime lhs, DateTime rhs) -> DateSpan

auto operator-(DateTime time, DateSpan span) -> DateTime

auto operator+(DateTime time, DateSpan span) -> DateTime

auto operator-(DateTimeUtc lhs, DateTimeUtc rhs) -> DateSpan

auto operator-(DateTimeUtc time, DateSpan span) -> DateTimeUtc

auto operator+(DateTimeUtc time, DateSpan span) -> DateTimeUtc

auto operator==(const Color4f& lhs, const Color4f& rhs) -> bool

SEAD_Color4u8_OPERATORS(+, +)

SEAD_Color4u8_OPERATORS(-, -)

auto SEAD_Color4u8_OPERATORS(/, /) ;SEAD_Color4u8_OPERATORS(|=,| -> SEAD_Color4u8_OPERATORS*

auto Color4u8(const Color4u8& rhs) { return apply_([&](auto m -> SEAD_Color4u8_OPERATORS&

auto operator==(const Color4u8& lhs, const Color4u8& rhs) -> bool

auto operator*(const Color4u8& lhs, f32 x) -> Color4u8

auto operator/(const Color4u8& lhs, f32 x) -> Color4u8

template<typename T>

static auto getUndefined2() -> BoundBox2<T>

template<typename T>

static auto getUndefined3() -> BoundBox3<T>

static auto makeWorkerName(Heap* heap, const WorkerMgr::InitializeArg& arg, u32 core) -> SafeString*

void ParseFailed_(] char** text_ptr, ] int v)

auto replaceStringImpl_<char>(char* buffer, s32* length, s32 buffer_size, const char* target_buf, s32 target_len, const SafeStringBase<char>& old_str, const SafeStringBase<char>& new_str, bool* is_buffer_overflow) -> template s32

auto replaceStringImpl_<char16>(char16* buffer, s32* length, s32 buffer_size, const char16* target_buf, s32 target_len, const SafeStringBase<char16>& old_str, const SafeStringBase<char16>& new_str, bool* is_buffer_overflow) -> template s32

template<typename T>

auto appendImpl_(T* buffer_, s32* length_, const s32 buffer_size_, T c, s32 num) -> s32

static auto checkStackMagic(uintptr_t addr) -> bool

Variables

u32 cStackCanaryMagic constexpr

Typedef documentation

Function documentation

Variable documentation