al namespace

Namespaces

namespace anonymous_namespace{ChildStep.cpp}

namespace anonymous_namespace{EffectObjFollowCamera.cpp}

namespace anonymous_namespace{EffectObjFollowCameraLimit.cpp}

namespace anonymous_namespace{KeyMoveMapParts.cpp}

namespace anonymous_namespace{RailMoveMapParts.cpp}

namespace anonymous_namespace{RotateMapParts.cpp}

namespace anonymous_namespace{SwitchOpenMapParts.cpp}

namespace anonymous_namespace{VisibleSwitchMapParts.cpp}

namespace EffectObjFunction

Classes

class AccountHolder

class ActionAnimCtrl

struct ActionAnimCtrlInfo

struct ActionAnimDataInfo

class ActionBgmCtrl

class ActionEffectCtrl

struct ActionEffectCtrlInfo

class ActionFlagCtrl

struct ActionFlagCtrlInfo

class ActionPadAndCameraCtrl

class ActionScreenEffectCtrl

struct ActionScreenEffectCtrlInfo

class ActionSeCtrl

class ActorActionKeeper

class ActorBackAroundCameraSubTarget

class ActorCameraSubTarget

class ActorCameraTarget

class ActorDitherAnimator

class ActorExecuteInfo

class ActorFactory

struct ActorInitInfo

class ActorInitResourceData

class ActorItemKeeper

class ActorMatrixCameraTarget

class ActorOcclusionKeeper

class ActorParamHolder

struct ActorParamMove

class ActorPoseKeeperBase

class ActorPoseKeeperTFGSV

class ActorPoseKeeperTFSV

class ActorPoseKeeperTFUSV

class ActorPoseKeeperTQGMSV

class ActorPoseKeeperTQGSV

class ActorPoseKeeperTQSV

class ActorPoseKeeperTRGMSV

class ActorPoseKeeperTRMSV

class ActorPoseKeeperTRSV

class ActorPrePassLightKeeper

class ActorResource

class ActorResourceHolder

struct ActorSceneInfo

class ActorScoreKeeper

class ActorSensorController

class ActorSensorControllerList

class ActorStateBase

class AllDeadWatcher

class AnimInfoTable

class AnimPlayerBase

struct AnimPlayerInitInfo

class AnimPlayerMat

class AnimPlayerSimple

class AnimPlayerSkl

class AnimPlayerVis

struct AnimResInfo

class AnimScaleController

struct AnimScaleParam

class ApplicationMessageReceiver

class ArchiveEntry

class ArchiveHolder

struct AreaGroupInfo

class AreaInitInfo

class AreaObj

class AreaObjDirector

class AreaObjFactory

class AreaObjFilterBase

class AreaObjFindCallBack

class AreaObjGroup

class AreaObjMtxConnecter

class AreaObjMtxConnecterHolder

class AreaShape

class AreaShapeCube

class AreaShapeCubeBase

class AreaShapeCubeCenter

class AreaShapeCubeTop

class AreaShapeCylinder

class AreaShapeCylinderBase

class AreaShapeCylinderCenter

class AreaShapeCylinderTop

class AreaShapeFactory

class AreaShapeInfinite

class AreaShapeOval

class AreaShapeSphere

struct ArrowHitInfo

class AsyncFunctorThread

class AudioDirector

struct AudioDirectorInitInfo

template<typename T>

class AudioInfoListWithParts

class AudioKeeper

class AudioSystem

struct AudioSystemInfo

class BackHideDitherAnimator

class BackHideParts

class BalloonMessage

struct BalloonMessageInitParam

class BezierCurve

class BgmBeatCounter

class BgmChangeableParams

class BgmDataBase

class BgmDirector

struct BgmDirectorInitInfo

class BgmKeeper

struct BgmUserInfo

class BreakMapPartsBase

class BreakModel

class ByamlArrayIter

class ByamlContainerHeader

class ByamlData

class ByamlHashIter

class ByamlHashPair

class ByamlHeader

class ByamlIter

class ByamlStringTableIter

class ByamlWriter

class ByamlWriterArray

class ByamlWriterBigData

class ByamlWriterBigDataList

class ByamlWriterBool

class ByamlWriterContainer

class ByamlWriterData

class ByamlWriterDouble

class ByamlWriterFloat

class ByamlWriterHash

class ByamlWriterHashPair

class ByamlWriterInt

class ByamlWriterInt64

class ByamlWriterNull

class ByamlWriterString

class ByamlWriterStringTable

class ByamlWriterUInt

class ByamlWriterUInt64

class CameraAngleCtrlInfo

class CameraAngleSwingInfo

class CameraAngleVerticalRequester

class CameraArrowCollider

class CameraDirector

struct CameraFlagCtrl

class CameraInputHolder

class CameraLimitRailKeeper

struct CameraObjectRequestInfo

class CameraOffsetCtrl

class CameraOffsetCtrlPreset

class CameraParamMoveLimit

class CameraPoser

class CameraPoserActorRailParallel

class CameraPoserAnim

class CameraPoserFactory

class CameraPoserFix

class CameraPoserFixActor

class CameraPoserFixFishing

class CameraPoserFixLook

class CameraPoserFixPoint

class CameraPoserFixTalk

struct CameraPoserFlag

struct CameraPoserSceneInfo

class CameraPoserSubjective

class CameraPoseUpdater

class CameraRailHolder

class CameraRequestParamHolder

class CameraResourceHolder

class CameraShaker

struct CameraStartInfo

class CameraStartParamArea

class CameraStopJudge

class CameraSubTargetBase

class CameraSubTargetTurnParam

class CameraSwitchRequester

class CameraSwitchRequestInfo

class CameraTargetAreaLimitter

class CameraTargetBase

class CameraTargetHolder

class CameraTicket

class CameraTicketHolder

class CameraTicketId

class CameraVerticalAbsorber

class CameraViewFlag

class CameraViewInfo

class CameraWatchPoint

class ChildStep

class ChromakeyDrawer

class ClippingActorHolder

class ClippingActorInfo

class ClippingActorInfoList

class ClippingDirector

class ClippingFarAreaObserver

class ClippingGroupHolder

class ClippingInfoGroup

class ClippingJudge

class ClockMapParts

class Collider

class CollisionDirector

class CollisionObj

class CollisionParts

class CollisionPartsFilterActor

class CollisionPartsFilterBase

class CollisionPartsFilterSpecialPurpose

struct ConveyerKey

class ConveyerKeyKeeper

class ConveyerMapParts

class ConveyerStep

class DemoDirector

class DepthShadowMapCtrl

class DepthShadowModel

template<class T>

class DeriveActorGroup

struct DiskHitInfo

class DitherAnimator

struct DrawSystemInfo

class DynamicDrawActor

class EffectKeeper

class EffectObj

class EffectObjCameraEmit

class EffectObjFollowCamera

class EffectObjFollowCameraLimit

class EffectObjInterval

class EffectSystem

class EffectSystemInfo

class EnemyStateBlowDown

struct EnemyStateBlowDownParam

class EventFlowNodeFactory

class EventFlowRequestInfo

class ExecuteAsyncExecutor

class ExecuteAsyncExecutorDraw

class ExecuteAsyncExecutorUpdate

class ExecuteDirector

struct ExecuteOrder

class ExecuteRequestInfo

class ExecuteRequestKeeper

class ExecuteRequestTable

struct ExecuteSystemInitInfo

struct ExecuteTable

class ExecuteTableHolderDraw

class ExecuteTableHolderUpdate

class ExecutorListBase

template<typename T>

class Factory

class FallMapParts

class FarDistanceDitherAnimator

class FileEntryBase

class FileLoader

class FileLoaderThread

class FireSurfaceFinder

struct FireSurfaceProperties

class FixMapParts

class FloaterMapParts

class FlowMapCtrl

class FlowMapParts

class FunctorBase

template<class T, class F>

class FunctorV0M

class GameDataHolderBase

class GameFrameworkNx

class GamePadSystem

struct GameSystemInfo

class GateMapParts

class GpuMemAllocator

class GpuPerf

class Graph

struct GraphicsInitArg

class GraphicsQualityController

class GraphicsSystemInfo

class GravityHolder

class GridMeshXZ

class GyroCameraCtrl

class HioNode

struct HitInfo

struct HitReactionInfo

class HitReactionKeeper

class HitSensor

class HitSensorDirector

class HitSensorKeeper

template<class T>

class HostStateBase

class HtmlViewer

class IAudioResourceLoader

class IAudioSystemPause

class ICameraInput

class ICollisionPartsKeeper

class IEventFlowEventReceiver

class InitializeThread

class InitResourceDataAction

class InitResourceDataActionAnim

class InitResourceDataAnim

class InOutParam

class IntervalTrigger

class ISceneObj

class ItemDirectorBase

class IUseAreaObj

class IUseAudioKeeper

class IUseCamera

class IUseCollision

class IUseEffectKeeper

class IUseExecutor

class IUseFinalize

class IUseFluidSurface

class IUseGridMesh

class IUseHioNode

class IUseLayout

class IUseLayoutAction

class IUseMessageSystem

class IUseName

class IUseNerve

class IUsePadDataReader

class IUsePadDataWriter

class IUsePartsGraphics

class IUseRail

class IUseSceneCreator

class IUseSceneObjHolder

class IUseStageSwitch

class JointControllerBase

class JointLocalAxisRotator

class JointRippleGenerator

class JointSpringController

class JointSpringControllerHolder

class JoyPadAccelPoseAnalyzer

struct KCHitInfo

class KCollisionServer

struct KCPrismData

struct KCPrismHeader

class KeyMoveFollowTarget

class KeyMoveMapParts

class KeyMoveMapPartsGenerator

class KeyPose

class KeyPoseKeeper

class KeyRepeatCtrl

class LayoutActionKeeper

class LayoutActor

class LayoutActorGroup

class LayoutExecuteInfo

class LayoutInitInfo

class LayoutKeeper

class LayoutKit

class LayoutPaneGroup

class LayoutPartsActorKeeper

class LayoutSceneInfo

class LinearCurve

class LiveActor

struct LiveActorFlag

class LiveActorGroup

class LiveActorKit

struct MatchStr

template<typename T>

struct Matrix43

class MemorySystem

class MessageHolder

class MessageSystem

class MessageTagDataHolder

class ModelCtrl

class ModelDisplayListController

struct ModelDrawBufferCounter

class ModelDrawBufferUpdater

class ModelDrawerBase

class ModelDrawParts

class ModelGroup

class ModelKeeper

class ModelLodAllCtrl

class ModelLodCtrl

class ModelMaterialCategory

class ModelOcclusionCullingDirector

class ModelOcclusionQuery

class MtxPtrHolder

template<typename T>

struct NameToCreator

class NatureDirector

class Nerve

class NerveAction

class NerveActionCtrl

class NerveExecutor

class NerveKeeper

class NerveStateBase

class NerveStateCtrl

struct NfpCharacterId

class NfpDirector

struct NfpFormatVersion

struct NfpInfo

class OneMeshFixMapParts

struct OrthoProjectionInfo

class PadDataArcReader

struct PadDataPack

class PadRumbleDirector

struct PadRumbleParam

class ParabolicPath

template<typename T>

class Parameter

class ParameterArray

class ParameterBase

class ParameterIo

class ParameterList

class ParameterObj

class PartsEffectGroup

class PartsModel

class PauseCameraCtrl

class PlacementId

class PlacementInfo

class PlayerHolder

class PostProcessingFilter

struct PrintParams

class Projection

class Rail

class RailKeeper

class RailMoveMapParts

class RailMoveMovement

class RailPart

class RailRider

struct ReplaceTimeInfo

class ReplayController

class Resource

class ResourceSystem

class RippleCtrl

class RollingCubeMapParts

class RollingCubePose

class RollingCubePoseKeeper

class RollParts

class RotateMapParts

class SaveDataDirector

class Scene

class SceneCameraCtrl

class SceneCameraInfo

class SceneCameraViewCtrl

class SceneCreator

class SceneEventFlowMsg

struct SceneInitInfo

class SceneMsg

class SceneMsgCtrl

class SceneObjHolder

class SceneStopCtrl

class ScreenCaptureExecutor

class ScreenCoverCtrl

class ScreenPointDirector

class ScreenPointKeeper

class SeBarrierArea

struct SeDirectorInitInfo

class SeesawMapParts

class SeKeeper

class SensorHitGroup

class SePlayArea

class Sequence

struct SeUserInfo

class ShaderHolder

class ShadowDirector

class ShadowKeeper

class ShadowMaskCtrl

class SilhouetteModel

class SimpleAudioUser

class SimpleCameraInput

class SimpleCameraPoserFactory

class SimpleCircleShadowXZ

class SimpleLayoutAppear

class SimpleLayoutAppearWait

class SimpleLayoutAppearWaitEnd

class SimpleLayoutText

class SimpleLayoutTextHolder

struct SimpleLayoutTextHolderEntry

class SimpleLayoutTextWrapper

class SimplePopupMessageLayout

struct SklAnimRetargettingInfo

class SkyDirector

class SlideMapParts

class SnapShotCameraCtrl

class SoundItemEntry

class SoundItemHolder

class SpecialCameraHolder

struct SphereHitInfo

class SphereInterpolator

class SpherePoseInterpolator

class SpinInputAnalyzer

class StageInfo

class StageResourceKeeper

class StageResourceList

class StageSwitchAccesser

struct StageSwitchAccesserList

class StageSwitchDirector

class StageSwitchFunctorListener

struct StageSwitchInfo

class StageSwitchKeeper

class StageSwitchListener

class StageSwitchWatcher

class StageSwitchWatcherHolder

class StageSyncCounter

template<s32 L>

class StringTmp

struct SubActorInfo

class SubActorKeeper

class SubActorLodExecutor

class SubActorLodMapParts

struct SubActorSync

class SubCameraRenderer

class SupportFreezeSyncGroup

class SupportFreezeSyncGroupHolder

class SurfMapParts

class SwingMapParts

class SwingMovement

class SwitchAreaDirector

class SwitchAreaTargetInfo

class SwitchDitherMapParts

class SwitchKeepOnAreaGroup

class SwitchOnAreaGroup

class SwitchOpenMapParts

class SystemKit

class TalkMessageVoicePlayer

class TrafficArea

class Triangle

class ValidatorBase

class ViewCtrlArea

class ViewIdHolder

class ViewInfoCtrl

class ViewRenderer

class VisibleSwitchMapParts

class WaterSurfaceFinder

struct WaterSurfaceProperties

class WheelMapParts

class WheelMovement

class WindowConfirm

class WipeCloseAppearWaitEnd

class WipeHolder

class WipeSimple

class WobbleMapParts

template<s32 L>

class WStringTmp

Enums

enum class CollisionLocation: u8 { None = 0, Face = 1, Edge1 = 2, Edge2 = 3, Edge3 = 4, Corner1 = 5, Corner2 = 6, Corner3 = 7 }

enum class FloaterMoveType: s32 { Wait, Back, Sink }

enum class Axis: s32 { InvertZ = -3, InvertY = -2, InvertX = -1, None = 0, X = 1, Y = 2, Z = 3 }

enum EaseType: s32 { EaseType_EaseIn = 1, EaseType_EaseOut, EaseType_EaseInOut, EaseType_SquareIn, EaseType_SquareOut }

enum class MoveType: s32 { Loop, Turn, Stop, Restart }

enum class ShadowMaskDrawCategory: s32 { }

enum ByamlDataType: const u8 { TYPE_INVALID = 0, TYPE_STRING = 0xA0, TYPE_BINARY = 0xA1, TYPE_ARRAY = 0xC0, TYPE_HASH = 0xC1, TYPE_STRING_TABLE = 0xC2, TYPE_BOOL = 0xD0, TYPE_INT = 0xD1, TYPE_FLOAT = 0xD2, TYPE_UINT = 0xD3, TYPE_LONG = 0xD4, TYPE_ULONG = 0xD5, TYPE_DOUBLE = 0xD6, TYPE_NULL = 0xFF }

enum class FileState: s32 { None, IsLoadRequested, IsSendMessageDone, IsLoadDone }

enum class HitSensorType: u32 { Eye = 0, Player = 1, PlayerAttack = 2, PlayerFoot = 3, PlayerDecoration = 4, PlayerEye = 5, Npc = 6, Ride = 7, Enemy = 8, EnemyBody = 9, EnemyAttack = 10, EnemySimple = 11, MapObj = 12, MapObjSimple = 13, Bindable = 14, CollisionParts = 15, PlayerFireBall = 16, HoldObj = 17, LookAt = 18, BindableGoal = 19, BindableAllPlayer = 20, BindableBubbleOutScreen = 21, BindableKoura = 22, BindableRouteDokan = 23, BindableBubblePadInput = 24 }

Typedefs

using AreaCreatorFunction = AreaObj*(*)(const char*areaName)

using AreaShapeCreatorFunction = AreaShape*(*)()

using CameraPoserCreatorFunction = CameraPoser*(*)(const char*cameraPoserName)

using EventFlowNodeCreatorFunction = EventFlowNode*(*)(const char*eventFlowNodeName)

using Matrix43f = Matrix43<f32>

using ActorCreatorFunction = LiveActor*(*)(const char*actorName)

using PoseKeeperCreatorFunction = void(*)(LiveActor*)

using JudgeFuncPtr = bool(*)(const SensorMsg*message, HitSensor*other, HitSensor*self)

using SensorSortCmpFunc = bool(*)(HitSensor*a, HitSensor*b)

Functions

auto tryFindAreaObj(const IUseAreaObj* areaUser, const char* name, const sead::Vector3f& position) -> AreaObj*

auto tryFindAreaObjWithFilter(const IUseAreaObj* areaUser, const char* name, const sead::Vector3f& position, AreaObjFilterBase* filter) -> AreaObj*

auto tryFindAreaObjAll(const IUseAreaObj* areaUser, const char* name, const sead::Vector3f& position, AreaObjFindCallBack* callBack) -> bool

auto tryFindAreaObjGroup(const IUseAreaObj* areaUser, const char* name) -> AreaObjGroup*

auto isInAreaObj(const AreaObjGroup* group, const sead::Vector3f& position) -> bool

auto tryGetAreaObj(const AreaObjGroup* group, const sead::Vector3f& position) -> AreaObj*

auto isInAreaPos(const AreaObj* areaObj, const sead::Vector3f& position) -> bool

auto isInAreaObj(const IUseAreaObj* areaUser, const char* name, const sead::Vector3f& position) -> bool

auto isExistAreaObj(const IUseAreaObj* areaUser, const char* name) -> bool

auto isInDeathArea(const IUseAreaObj* areaUser, const sead::Vector3f& position) -> bool

auto isInWaterArea(const IUseAreaObj* areaUser, const sead::Vector3f& position) -> bool

auto isInPlayerControlOffArea(const IUseAreaObj* areaUser, const sead::Vector3f& position) -> bool

auto calcAreaObjNum(const IUseAreaObj* areaUser, const char* name) -> s32

auto calcWaterSinkDepth(const IUseAreaObj* areaUser, const sead::Vector3f& position) -> f32

auto tryGetAreaObjArg(s32* outArg, const AreaObj* areaObj, const char* key) -> bool

auto tryGetAreaObjArg(f32* outArg, const AreaObj* areaObj, const char* key) -> bool

auto tryGetAreaObjArg(bool* outArg, const AreaObj* areaObj, const char* key) -> bool

auto tryGetAreaObjStringArg(const char** outArg, const AreaObj* areaObj, const char* key) -> bool

auto getAreaObjBaseMtx(const AreaObj* areaObj) -> const sead::Matrix34f&

auto getAreaObjScale(const AreaObj* areaObj) -> const sead::Vector3f&

void getAreaObjDirFront(sead::Vector3f* outFrontDir, const AreaObj* areaObj)

void getAreaObjDirUp(sead::Vector3f* outUpDir, const AreaObj* areaObj)

void getAreaObjDirSide(sead::Vector3f* outSideDir, const AreaObj* areaObj)

void calcNearestAreaObjEdgePos(sead::Vector3f* outNearestEdgePos, const AreaObj* areaObj, const sead::Vector3f& position)

void calcNearestAreaObjEdgePosTopY(sead::Vector3f* outNearestEdgePosTopY, const AreaObj* areaObj, const sead::Vector3f& position)

auto calcNearestAreaObjEdgeRateTopY(const AreaObj* areaObj, const sead::Vector3f& position) -> f32

void calcAreaObjCenterPos(sead::Vector3f* outCenterPosition, const AreaObj* areaObj)

auto checkAreaObjCollisionByArrow(sead::Vector3f* outHitPosition, sead::Vector3f* outNormal, const AreaObj* areaObj, const sead::Vector3f& position1, const sead::Vector3f& position2) -> bool

auto calcFindAreaSurface(const IUseAreaObj* areaUser, const char* name, sead::Vector3f* outHitPosition, sead::Vector3f* outNormal, const sead::Vector3f& position1, const sead::Vector3f& position2) -> bool

auto calcFindAreaSurface(const IUseAreaObj* areaUser, const char* name, sead::Vector3f* outHitPosition, sead::Vector3f* outNormal, const sead::Vector3f& position, const sead::Vector3f& direction, f32 distance) -> bool

template<typename T>

auto createAreaShapeFunction() -> AreaShape*

template<typename T>

auto createAreaObjFunction(const char* areaObjName) -> AreaObj*

auto isAnyPosInVolume(AreaObj* areaObj, sead::Vector3f* targetPos, s32 targetPosCount) -> bool

auto isAllPosInVolume(AreaObj* areaObj, sead::Vector3f* targetPos, s32 targetPosCount) -> bool

auto calcHashCode(const char* str) -> s32

auto calcHashCodeLower(const char* str) -> s32

auto calcHashCodeFmt(const char* format, std::va_list argv) -> s32

auto calcHashCodeFmt(const char* format, ...) -> s32

auto getBaseName(const char* name) -> const char*

auto createStringIfInStack(const char* str) -> const char*

auto createConcatString(const char* start, const char* end) -> const char*

void createFileNameBySuffix(sead::BufferedSafeString* out, const char* name, const char* suffix)

auto outputValueWithComma(char* out, u32 size, u64 value, bool usePadding, bool padToThousands) -> u32

void extractString(char* out, const char* str, u32 len, u32 unused)

auto searchSubString(const char* str, const char* substr) -> const char*

auto searchSubString(const char* str, const char* substr, s32 substrLen) -> const char*

void removeExtensionString(char* out, u32 len, const char* str)

void removeStringFromEnd(char* out, u32 len, const char* end, const char* str)

void translateCharacters(char* string, const char* charmap, const char* newCharmap)

auto isEqualString(const char16* str1, const char16* str2) -> bool

auto isEqualSubString(const char* str, const char* subStr) -> bool

auto isEqualSubString(const sead::SafeString& str, const sead::SafeString& subStr) -> bool

auto isStartWithString(const char* str, const char* start) -> bool

auto isEndWithString(const char* str, const char* end) -> bool

auto compareStringIgnoreCase(const char* str1, const char* str2) -> s32

void copyString(char* out, const char* str, u32 len)

void copyStringW(char16* out, const char16* str, u32 len)

__attribute__((noinline)) bool isEqualString(const char *str1

auto isEqualString(const sead::SafeString& safestr1, const sead::SafeString& safestr2) -> bool

auto isEqualStringCase(const char* str1, const char* str2) -> bool

auto isEqualStringCase(const sead::SafeString& str1, const sead::SafeString& str2) -> bool

auto getSubStringUnmatched(const char**, const char*, const MatchStr&, void(*)(const char*, const char*, void*), void*) -> const char*

auto getSubStringUnmatched(const char*, const MatchStr&) -> const char*

void extractBaseNameW(sead::WBufferedSafeString*, const sead::WSafeString&)

void tryReplaceString(sead::BufferedSafeString*, const char*, const char*)

void tryReplaceString(sead::BufferedSafeString*, const char*, const char*, const char*)

void tryReplaceStringNoRecursive(sead::BufferedSafeString*, const char*, const char*, const char*)

auto isMatchString(const char*, const MatchStr&) -> bool

void makeUrlEncodeString(char*, u32, const char*)

void makeUrlDecodeString(char*, u32, const char*)

auto isInStack(const void*) -> bool

auto isEqualString(const char* str1, const char* str2) -> bool

auto getBgmDirector(const IUseAudioKeeper*) -> BgmDirector*

auto tryGetBgmDirector(const IUseAudioKeeper*) -> BgmDirector*

auto getBgmSituationDirector(const IUseAudioKeeper*) -> BgmSituationDirector*

auto getBgm3DParamsController(const IUseAudioKeeper*) -> Bgm3DParamsController*

auto getActiveBgmLine(const IUseAudioKeeper*) -> BgmLine*

auto getPlayingBgmLine(const IUseAudioKeeper*, const char*) -> BgmLine*

auto getCurPlayingBgmPlayName(const IUseAudioKeeper*) -> const char*

auto getCurPlayingBgmResourceName(const IUseAudioKeeper*) -> const char*

auto getBgmPlayNameInCurPosition(const IUseAudioKeeper*, bool) -> const char*

auto getBgmResourceNameInCurPosition(const IUseAudioKeeper*, bool) -> const char*

auto getActiveBgmCurSamplePosition(const IUseAudioKeeper*) -> s64

auto getBgmLoopEndSamplePosition(const IUseAudioKeeper*, const char*) -> s64

void startBgm(const IUseAudioKeeper*, const char*, s32, s32)

void startBgm(const IUseAudioKeeper*, const BgmPlayingRequest&, bool, bool)

void startBgmWithSuffix(const IUseAudioKeeper*, const char*, const char*, s32, s32)

void startAndStopBgmInCurPosition(const IUseAudioKeeper*, bool)

void startBgmSituation(const IUseAudioKeeper*, const char*, bool)

void prepareBgm(const IUseAudioKeeper*, const BgmPlayingRequest&)

void prepareBgmWithAreaCheck(const IUseAudioKeeper*)

void stopBgm(const IUseAudioKeeper*, const char*, s32)

void stopBgm(const IUseAudioKeeper*, const BgmPlayingRequest&)

void pauseBgm(const IUseAudioKeeper*, const char*, s32)

void resumeBgm(const IUseAudioKeeper*, const char*, s32)

auto isPlayingBgm(const IUseAudioKeeper*) -> bool

auto isPlayingBgm(const IUseAudioKeeper*, const char*) -> bool

auto isRunningBgm(const IUseAudioKeeper*, const char*) -> bool

auto isPlayingResourceCategoryBgm(const IUseAudioKeeper*, const char*) -> bool

void stopActiveBgm(const IUseAudioKeeper*, s32)

void pauseActiveBgm(const IUseAudioKeeper*, s32)

void resumeActiveBgm(const IUseAudioKeeper*, s32)

auto isPlayingActiveBgm(const IUseAudioKeeper*, const char*) -> bool

auto isPauseActiveBgm(const IUseAudioKeeper*) -> bool

void stopAllBgm(const IUseAudioKeeper*, s32)

void tryStopAllBgm(const IUseAudioKeeper*, s32)

void setTriggerEventForStopAllBgm(const IUseAudioKeeper*, const FunctorBase&)

void tryPauseBgmIfDifferBgmArea(const LiveActor*, const sead::Vector3f&, s32)

void tryPauseBgmIfLowPriority(const IUseAudioKeeper*, const char*, s32)

void startBgmSituation(const IUseAudioKeeper*, const char*, bool, bool)

void startBgmSituation(const IUseAudioKeeper*, sead::PtrArray<IBgmParamsChanger>*, const char*, bool, bool)

void forceStartBgmSituation(const IUseAudioKeeper*, const char*, bool, bool)

void endBgmSituation(const IUseAudioKeeper*, const char*, bool)

void endBgmSituation(const IUseAudioKeeper*, sead::PtrArray<IBgmParamsChanger>*, const char*, bool)

void forceEndBgmSituation(const IUseAudioKeeper*, const char*, bool)

void startBgm3D(const IUseAudioKeeper*)

void endBgm3D(const IUseAudioKeeper*)

void changeBgm3DParams(const IUseAudioKeeper*, f32, f32, f32, f32, bool)

void activateBgm3DController(const IUseAudioKeeper*)

void deactivateBgm3DController(const IUseAudioKeeper*)

auto isActivateBgm3DController(const IUseAudioKeeper*) -> bool

auto getActiveBgmSituationNum(const IUseAudioKeeper*) -> s32

auto getActiveBgmSituationName(const IUseAudioKeeper*, s32) -> const char*

auto getDeactiveBgmSituationNum(const IUseAudioKeeper*) -> s32

auto getDeactiveBgmSituationName(const IUseAudioKeeper*, s32) -> const char*

void takeBgmSituationSnapShot(const IUseAudioKeeper*)

void applyBgmSituationSnapShot(const IUseAudioKeeper*)

void applyNoAppliedSituationRecord(const IUseAudioKeeper*)

auto isStartedBgmSituation(const IUseAudioKeeper*, const char*) -> bool

void endAllBgmSituation(const IUseAudioKeeper*)

void clearBgmDataForStepOverScene(const IUseAudioKeeper*)

void clearBgmPlayPointRecord(const IUseAudioKeeper*)

void startBgmSyncedCurBgmBeat(const IUseAudioKeeper*, const BgmPlayingRequest&, s32)

void stopBgmSyncedCurBgmBeat(const IUseAudioKeeper*, const BgmPlayingRequest&, s32)

void disableBgmLineChange(const IUseAudioKeeper*)

void enableBgmLineChange(const IUseAudioKeeper*)

auto isDisableBgmLineChange(const IUseAudioKeeper*) -> bool

void disableBgmSituationChange(const IUseAudioKeeper*)

void enableBgmSituationChange(const IUseAudioKeeper*, bool)

auto isDisableBgmSituationChange(const IUseAudioKeeper*) -> bool

auto tryAllocBgmMultiPlayingController(const IUseAudioKeeper*) -> BgmMultiPlayingController*

void tryReleaseBgmMultiPlayingController(const IUseAudioKeeper*, BgmMultiPlayingController*)

auto getBgmLineNum(const IUseAudioKeeper*, bool) -> s32

auto getBgmLineAccessor(const IUseAudioKeeper*, s32, bool) -> BgmLine*

auto getgBgmLineIndex(const IUseAudioKeeper*, const char*, bool) -> s32

void replaceBgmPlayInfoResourceName(const IUseAudioKeeper*, const char*, const char*)

auto isEnableRhythmAnim(const IUseAudioKeeper*, const char*) -> bool

auto isTriggerBeat(const IUseAudioKeeper*) -> bool

auto isTriggerBackBeat(const IUseAudioKeeper*) -> bool

auto isTriggerMeasureTop(const IUseAudioKeeper*) -> bool

auto getBpm(const IUseAudioKeeper*) -> f32

auto getBeatRate(const IUseAudioKeeper*) -> f32

auto getCurBeat(const IUseAudioKeeper*) -> f32

auto getCurBeatOnMeasure(const IUseAudioKeeper*) -> f32

auto getLoopStartBeat(const IUseAudioKeeper*) -> f32

auto getLoopEndBeat(const IUseAudioKeeper*) -> f32

auto getFramePerMeasure(const IUseAudioKeeper*) -> f32

auto getBeatPerMeasure(const IUseAudioKeeper*) -> s32

auto isChangeActiveBgmResourceName(const IUseAudioKeeper*) -> bool

auto tryRegistTargetBgmResourceName(const IUseAudioKeeper*, const char*) -> bool

void muteOnRunningLineTrack(IUseAudioKeeper*, u32, bool)

void muteOffRunningLineTrack(IUseAudioKeeper*, u32, bool)

__attribute__((always_inline)) void getStageName(StringTmp< 128 > *stageName

auto format("%s", archiveName) -> safeArchiveName

if(safeArchiveName. endsWith"Map")

auto getCameraDirector(const IUseCamera* user) -> CameraDirector*

auto getSceneCameraInfo(const IUseCamera* user) -> SceneCameraInfo*

auto getViewNumMax(const IUseCamera* user) -> s32

auto getViewNumMax(const SceneCameraInfo* info) -> s32

auto isValidView(const IUseCamera* user, s32 viewIdx) -> bool

auto isValidView(const SceneCameraInfo* info, s32 viewIdx) -> bool

auto getViewName(const IUseCamera* user, s32 viewIdx) -> const char*

auto getViewName(const SceneCameraInfo* info, s32 viewIdx) -> const char*

auto getViewMtx(const IUseCamera* user, s32 viewIdx) -> const sead::Matrix34f&

auto getViewMtx(const SceneCameraInfo* info, s32 viewIdx) -> const sead::Matrix34f&

auto getViewMtxPtr(const IUseCamera* user, s32 viewIdx) -> const sead::Matrix34f*

auto getViewMtxPtr(const SceneCameraInfo* info, s32 viewIdx) -> const sead::Matrix34f*

auto getProjectionMtx(const IUseCamera* user, s32 viewIdx) -> const sead::Matrix44f&

auto getProjectionMtx(const SceneCameraInfo* info, s32 viewIdx) -> const sead::Matrix44f&

auto getLookAtCamera(const IUseCamera* user, s32 viewIdx) -> const sead::LookAtCamera&

auto getLookAtCamera(const SceneCameraInfo* info, s32 viewIdx) -> const sead::LookAtCamera&

auto getProjectionSead(const IUseCamera* user, s32 viewIdx) -> const sead::Projection&

auto getProjectionSead(const SceneCameraInfo* info, s32 viewIdx) -> const sead::Projection&

auto getProjection(const IUseCamera* user, s32 viewIdx) -> const Projection&

auto getProjection(const SceneCameraInfo* info, s32 viewIdx) -> const Projection&

auto getCameraPos(const IUseCamera* user, s32 viewIdx) -> const sead::Vector3f&

auto getCameraPos(const SceneCameraInfo* info, s32 viewIdx) -> const sead::Vector3f&

auto getCameraAt(const IUseCamera* user, s32 viewIdx) -> const sead::Vector3f&

auto getCameraAt(const SceneCameraInfo* info, s32 viewIdx) -> const sead::Vector3f&

auto getCameraUp(const IUseCamera* user, s32 viewIdx) -> const sead::Vector3f&

auto getCameraUp(const SceneCameraInfo* info, s32 viewIdx) -> const sead::Vector3f&

auto getFovyDegree(const IUseCamera* user, s32 viewIdx) -> f32

auto getFovyDegree(const SceneCameraInfo* info, s32 viewIdx) -> f32

auto getFovy(const IUseCamera* user, s32 viewIdx) -> f32

auto getFovy(const SceneCameraInfo* info, s32 viewIdx) -> f32

auto getNear(const IUseCamera* user, s32 viewIdx) -> f32

auto getNear(const SceneCameraInfo* info, s32 viewIdx) -> f32

auto getFar(const IUseCamera* user, s32 viewIdx) -> f32

auto getFar(const SceneCameraInfo* info, s32 viewIdx) -> f32

auto calcCameraDistance(const IUseCamera* user, s32 viewIdx) -> f32

auto calcFovxDegree(const IUseCamera* user, s32 viewIdx) -> f32

auto calcCurrentFovyRate(const IUseCamera* user, s32 viewIdx) -> f32

auto getProjectionMtxPtr(const IUseCamera* user, s32 viewIdx) -> const sead::Matrix44f*

auto getProjectionMtxPtr(const SceneCameraInfo* info, s32 viewIdx) -> const sead::Matrix44f*

void calcCameraFront(sead::Vector3f*, const IUseCamera* user, s32 viewIdx)

void setNearClipDistance(const IUseCamera* user, f32 distance, s32 updaterIdx)

void setFarClipDistance(const IUseCamera* user, f32 distance, s32 updaterIdx)

void setCurrentCameraPose(CameraPoseInfo* poseInfo, const IUseCamera* user)

void calcCameraDir(sead::Vector3f* dir, const IUseCamera* user, s32 viewIdx)

void calcCameraLookDir(sead::Vector3f* lookDir, const IUseCamera* user, s32 viewIdx)

void calcCameraSideDir(sead::Vector3f* sideDir, const IUseCamera* user, s32 viewIdx)

void calcCameraUpDir(sead::Vector3f* upDir, const IUseCamera* user, s32 viewIdx)

auto tryCalcCameraDir(sead::Vector3f* dir, const SceneCameraInfo* info, s32 viewIdx) -> bool

auto tryCalcCameraDirH(sead::Vector3f* dirH, const SceneCameraInfo* info, const sead::Vector3f& upDir, s32 viewIdx) -> bool

auto tryCalcCameraLookDirH(sead::Vector3f* lookDirH, const SceneCameraInfo* info, const sead::Vector3f& upDir, s32 viewIdx) -> bool

void startCamera(const IUseCamera* user, CameraTicket* ticket, s32 unk = -1)

void startCameraSub(const IUseCamera* user, CameraTicket* ticket, s32 unk = -1)

void startAnimCamera(const IUseCamera* user, CameraTicket* ticket, const char* animName, s32 unk = 0)

void startAnimCameraAnim(CameraTicket* ticket, const char*, s32, s32, s32)

void startAnimCameraWithStartStepAndEndStepAndPlayStep(const IUseCamera* user, CameraTicket* ticket, const char* animName, s32, s32, s32, s32)

void endCamera(const IUseCamera* user, CameraTicket* ticket, s32, bool)

void endCameraWithNextCameraPose(const IUseCamera* user, CameraTicket* ticket, const CameraPoseInfo* poseInfo, s32)

void endCameraSub(const IUseCamera* user, CameraTicket* ticket, s32)

auto isActiveCamera(const CameraTicket* ticket) -> bool

auto initObjectCamera(const IUseCamera* user, const PlacementInfo& placementInfo, const char*, const char*) -> CameraTicket*

auto initObjectCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*, const char*) -> CameraTicket*

auto initObjectCameraNoPlacementInfo(const IUseCamera* user, const char*, const char*) -> CameraTicket*

auto initFixCamera(const IUseCamera* user, const char*, const sead::Vector3f&, const sead::Vector3f& lookAtPos) -> CameraTicket*

auto initFixDoorwayCamera(const IUseCamera* user, const char*, const sead::Vector3f&, const sead::Vector3f& lookAtPos) -> CameraTicket*

auto initFixActorCamera(const LiveActor* actor, const ActorInitInfo& actorInitInfo, const char*, const sead::Vector3f&, f32, f32, f32, bool) -> CameraTicket*

auto initFixLookCamera(LiveActor* actor, const ActorInitInfo& actorInitInfo, const char*) -> CameraTicket*

auto initFixTalkCamera(const LiveActor* actor, const ActorInitInfo& actorInitInfo, const char*, const sead::Vector3f&, f32, f32, f32, bool) -> CameraTicket*

auto initFixFishingCamera(const LiveActor* actor, const ActorInitInfo& actorInitInfo, const char*, const sead::Vector3f&, const sead::Vector3f&, f32, f32, f32, bool) -> CameraTicket*

auto initFixPointCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*, bool) -> CameraTicket*

auto initLookDownCamera(const LiveActor* actor, const ActorInitInfo& actorInitInfo, const char*) -> CameraTicket*

auto initProgramableCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*, const sead::Vector3f*, const sead::Vector3f*, const sead::Vector3f*) -> CameraTicket*

auto initProgramableCamera(const IUseCamera* user, const char*, const sead::Vector3f*, const sead::Vector3f*, const sead::Vector3f*) -> CameraTicket*

auto initProgramableCameraWithCollider(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*, const sead::Vector3f*, const sead::Vector3f*, const sead::Vector3f*) -> CameraTicket*

auto initProgramableAngleCamera(const IUseCamera* user, const PlacementInfo& placementInfo, const char*, const sead::Vector3f*, const f32*, const f32*, const f32*) -> CameraTicket*

auto initProgramableCameraKeepColliderPreCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*, const sead::Vector3f*, const sead::Vector3f*, const sead::Vector3f*) -> CameraTicket*

auto initShooterCameraSingle(const IUseCamera* user, const char*) -> CameraTicket*

auto initTowerCameraWithSave(const IUseCamera* user, const sead::Vector3f*, const ActorInitInfo& actorInitInfo, const char*) -> CameraTicket*

auto initTowerCamera(const IUseCamera* user, const sead::Vector3f*, const ActorInitInfo& actorInitInfo, const char*) -> CameraTicket*

auto initBossBattleCamera(const IUseCamera* user, const sead::Vector3f*, const ActorInitInfo& actorInitInfo, const char*) -> CameraTicket*

void initProgramableCameraAngleSwing(CameraTicket* ticket)

auto initFollowCameraSimple(const IUseCamera* user, const char*) -> CameraTicket*

auto initFollowCameraSimple(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*) -> CameraTicket*

auto initDemoObjectCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*, const char*) -> CameraTicket*

auto initDemoProgramableCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*, const sead::Vector3f*, const sead::Vector3f*, const sead::Vector3f*) -> CameraTicket*

auto initDemoProgramableCameraKeepColliderPreCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*, const sead::Vector3f*, const sead::Vector3f*, const sead::Vector3f*) -> CameraTicket*

auto initDemoAnimCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const Resource*, const sead::Matrix34f*, const char*) -> CameraTicket*

auto initAnimCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const Resource*, const sead::Matrix34f*, const char*) -> CameraTicket*

auto initDemoAnimCamera(const LiveActor* actor, const ActorInitInfo& actorInitInfo, const char*) -> CameraTicket*

void loadActorCameraParam(CameraTicket* ticket, const LiveActor* actor, const char*, const char*)

void loadActorCameraParamInitFile(CameraTicket* ticket, const LiveActor* actor, const char*)

void setFixActorCameraTarget(CameraTicket* ticket, const LiveActor* actor)

void setFixActorCameraAngleH(CameraTicket* ticket, f32 angleH)

void setTowerCameraDistance(CameraTicket* ticket, f32 distance)

void setTowerCameraStartAngleV(CameraTicket* ticket, f32 startAngleV)

void setTowerCameraUserMarginAngleH(CameraTicket* ticket, f32 angleH)

void resetTowerCameraUserMarginAngleH(CameraTicket* ticket)

void resetTowerCameraInputRotate(CameraTicket* ticket, f32, s32)

auto initSubjectiveCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*) -> CameraTicket*

auto initSubjectiveCameraNoSave(const IUseCamera* user, const char*) -> CameraTicket*

auto getSubjectiveCameraOffsetUp(const CameraTicket* ticket) -> f32

auto getSubjectiveCameraOffsetFront() -> f32

void setSubjectiveCameraStartAngleH(const CameraTicket* ticket, f32 angleH)

void validateSubjectiveCameraResetAngleH(CameraTicket* ticket)

void requestSubjectiveCameraZoomIn(CameraTicket* ticket)

auto initParallelCamera(const IUseCamera* user, const char*) -> CameraTicket*

auto initParallelCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*) -> CameraTicket*

void setParallelCameraLookAtOffset(const CameraTicket* ticket, const sead::Vector3f& offset)

void setParallelCameraDistance(const CameraTicket* ticket, f32 distance)

void setParallelCameraAngleH(const CameraTicket* ticket, f32 angleH)

void setParallelCameraAngleV(const CameraTicket* ticket, f32 angleV)

auto initQuickTurnCamera(const IUseCamera* user, const char*) -> CameraTicket*

void setQuickTurnCameraFollow(CameraTicket* ticket)

void setQuickTurnCameraRotateFast(CameraTicket* ticket)

auto initRaceCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*) -> CameraTicket*

void setRaceCameraFrontDirPtr(const CameraTicket* ticket, const sead::Vector3f* frontDirPtr)

void setRaceCameraDistance(const CameraTicket* ticket, f32 distance)

void setRaceCameraOffsetY(const CameraTicket* ticket, f32 offsetY)

void setRaceCameraAngleDegreeV(const CameraTicket* ticket, f32 angleV)

auto initCartCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*) -> CameraTicket*

void stopCartCamera(const CameraTicket* ticket)

void restartCartCamera(const CameraTicket* ticket)

auto initActorRailParallelCamera(const LiveActor* actor, const ActorInitInfo& actorInitInfo, const char*) -> CameraTicket*

auto initKinopioBrigadeCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*) -> CameraTicket*

auto initAnimCamera(const LiveActor* actor, const ActorInitInfo& actorInitInfo, const char*) -> CameraTicket*

void validateAnimCameraAngleSwing(CameraTicket* ticket)

void invalidateAnimCameraAngleSwing(CameraTicket* ticket)

void setAnimCameraBaseMtxPtr(CameraTicket* ticket, const sead::Matrix34f* baseMtxPtr)

auto initEntranceCamera(const IUseCamera* user, const PlacementInfo& placementInfo, const char*) -> CameraTicket*

auto initEntranceCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*) -> CameraTicket*

auto initEntranceCameraNoSave(const IUseCamera* user, const PlacementInfo& placementInfo, const char*) -> CameraTicket*

void setEntranceCameraParam(CameraTicket* ticket, f32, const sead::Vector3f&, const sead::Vector3f&)

void setEntranceCameraLookAt(CameraTicket* ticket, const sead::Vector3f& lookAt)

void invalidateEndEntranceCamera(LiveActor* actor)

void invalidateEndEntranceCameraWithName(IUseCamera* user, const char* name)

void validateEndEntranceCamera(IUseCamera* user)

auto isPlayingEntranceCamera(const IUseCamera* user, s32 updaterIdx) -> bool

void setCameraInterpoleStep(CameraTicket* ticket, s32 step)

void setCameraFovyDegree(CameraTicket* ticket, f32 fovy)

auto createSimpleCameraInput(s32 port) -> SimpleCameraInput*

void setCameraInput(IUseCamera* user, const ICameraInput* cameraInput)

void setViewCameraInput(IUseCamera* user, const ICameraInput* cameraInput, s32 inputIdx)

auto isExistCameraInputAtDisableTiming(const IUseCamera* user, s32 inputIdx) -> bool

auto createActorCameraTarget(const LiveActor* actor, f32) -> ActorCameraTarget*

auto createActorCameraTarget(const LiveActor* actor, const sead::Vector3f*) -> ActorCameraTarget*

auto createActorJointCameraTarget(const LiveActor* actor, const char* jointName) -> ActorMatrixCameraTarget*

auto createActorMatrixCameraTarget(const LiveActor* actor, const sead::Matrix34f* matrix) -> ActorMatrixCameraTarget*

auto isActiveCameraTarget(const CameraTargetBase* target) -> bool

void setCameraTarget(IUseCamera* user, CameraTargetBase* target)

void resetCameraTarget(IUseCamera* user, CameraTargetBase* target)

auto createActorCameraSubTarget(const LiveActor* actor, const sead::Vector3f*) -> ActorCameraSubTarget*

auto createActorBackAroundCameraSubTarget(const LiveActor* actor, const sead::Vector3f*) -> ActorBackAroundCameraSubTarget*

auto createTransCameraSubTarget(const char*, const sead::Vector3f*) -> TransCameraSubTarget*

void initCameraSubTargetTurnParam(CameraSubTargetBase* target, const CameraSubTargetTurnParam* turnParam)

auto isActiveCameraSubTarget(const CameraSubTargetBase* target) -> bool

void setCameraSubTarget(IUseCamera* user, CameraSubTargetBase* target)

void resetCameraSubTarget(IUseCamera* user, CameraSubTargetBase* target)

void setCameraPlacementSubTarget(IUseCamera* user, CameraSubTargetBase* target)

void resetCameraPlacementSubTarget(IUseCamera* user, CameraSubTargetBase* target)

auto getCameraDistanceRocketFlowerCurve() -> const CameraDistanceCurve*

void setViewCameraTarget(IUseCamera* user, CameraTargetBase* target, s32)

void startCameraShakeByAction(const LiveActor* actor, const char*, const char*, s32, s32)

void startCameraShakeByHitReaction(const IUseCamera* user, const char*, const char*, const char*, s32, s32)

void requestCameraLoopShakeWeak(const IUseCamera* user)

auto isActiveCameraInterpole(const IUseCamera* user, s32) -> bool

auto isActiveCameraInterpole(const SceneCameraInfo* info, s32) -> bool

void startCameraInterpole(const IUseCamera* user, s32, s32)

void requestCancelCameraInterpole(const IUseCamera* user, s32)

auto tryCalcCameraPoseWithoutInterpole(sead::LookAtCamera* camera, const IUseCamera* user, s32) -> bool

void invalidateCameraPoserVerticalAbsorber(CameraTicket* ticket)

void requestStopCameraVerticalAbsorb(IUseCamera* user)

void validateSnapShotCameraZoomFovy(CameraTicket* ticket)

void validateSnapShotCameraRoll(CameraTicket* ticket)

auto isSnapShotOrientationRotate90(const IUseCamera* user) -> bool

auto isSnapShotOrientationRotate270(const IUseCamera* user) -> bool

auto isValidCameraGyro(const IUseCamera* user) -> bool

auto isInvalidChangeSubjectiveCamera(const IUseCamera* user) -> bool

auto isCurrentCameraZooming(const IUseCamera* user, s32) -> bool

void onCameraRideObj(const LiveActor* actor)

void offCameraRideObj(const LiveActor* actor)

auto isExistAnimCameraData(const CameraTicket* ticket, const char*) -> bool

auto isEndAnimCamera(const CameraTicket* ticket) -> bool

auto isAnimCameraPlaying(const CameraTicket* ticket) -> bool

auto isAnimCameraAnimPlaying(const CameraTicket* ticket, const char*) -> bool

auto getAnimCameraStepMax(const CameraTicket* ticket) -> s32

auto getAnimCameraStep(const CameraTicket* ticket) -> s32

auto calcAnimCameraAnimStepMax(const CameraTicket* ticket, const char*) -> s32

void setAnimCameraRotateBaseUp(const CameraTicket* ticket)

template<typename T>

auto createCameraPoserFunction(const char* cameraPoserName) -> CameraPoser*

auto isWallPolygon(const sead::Vector3f&, const sead::Vector3f&) -> bool

auto isFloorPolygon(const sead::Vector3f&, const sead::Vector3f&) -> bool

auto isCeilingPolygon(const sead::Vector3f&, const sead::Vector3f&) -> bool

auto isFloorCode(const Triangle&, const char*) -> bool

auto createMtxConnector(const LiveActor* actor) -> MtxConnector*

auto tryCreateMtxConnector(const LiveActor* actor, const ActorInitInfo& info) -> MtxConnector*

void attachMtxConnectorToCollision(MtxConnector* mtxConnector, const LiveActor* actor, bool)

void attachMtxConnectorToCollision(MtxConnector* mtxConnector, const LiveActor* actor, const sead::Vector3f&, const sead::Vector3f&)

auto attachMtxConnectorToCollision(MtxConnector* mtxConnector, const LiveActor* actor, f32, f32) -> CollisionParts*

void connectPoseQT(LiveActor* actor, const MtxConnector* mtxConnector, const sead::Quatf& quat, const sead::Vector3f& trans)

void connectPoseQT(LiveActor* actor, const MtxConnector* mtxConnector)

void attachMtxConnectorToJoint(MtxConnector* mtxConnector, const LiveActor* actor, const char* jointName)

void attachMtxConnectorToJoint(MtxConnector* mtxConnector, const LiveActor* actor, const char* jointName, const sead::Vector3f& quatInitVec, const sead::Vector3f& trans)

void disconnectMtxConnector(MtxConnector* mtxConnector)

auto isMtxConnectorConnecting(const MtxConnector* mtxConnector) -> bool

auto getController(s32 port) -> sead::ControllerBase*

auto isPadTrigger(s32 port, s32 button) -> bool

auto isPadTriggerA(s32 port) -> bool

auto isPadTriggerB(s32 port) -> bool

auto isPadTriggerX(s32 port) -> bool

auto isPadTriggerY(s32 port) -> bool

auto isPadTriggerZL(s32 port) -> bool

auto isPadTriggerZR(s32 port) -> bool

auto isPadTriggerL(s32 port) -> bool

auto isPadTriggerR(s32 port) -> bool

auto isPadTrigger1(s32 port) -> bool

auto isPadTrigger2(s32 port) -> bool

auto isPadTriggerUp(s32 port) -> bool

auto isPadTriggerDown(s32 port) -> bool

auto isPadTriggerLeft(s32 port) -> bool

auto isPadTriggerRight(s32 port) -> bool

auto isPadTriggerLeftUp(s32 port) -> bool

auto isPadTriggerLeftDown(s32 port) -> bool

auto isPadTriggerRightUp(s32 port) -> bool

auto isPadTriggerRightDown(s32 port) -> bool

auto isPadTriggerHome(s32 port) -> bool

auto isPadTriggerStart(s32 port) -> bool

auto isPadTriggerSelect(s32 port) -> bool

auto isPadTriggerPlus(s32 port) -> bool

auto isPadTriggerMinus(s32 port) -> bool

auto isPadTriggerTouch() -> bool

auto isPadTriggerUpLeftStick(s32 port) -> bool

auto isPadTriggerDownLeftStick(s32 port) -> bool

auto isPadTriggerLeftLeftStick(s32 port) -> bool

auto isPadTriggerRightLeftStick(s32 port) -> bool

auto isPadTriggerUpRightStick(s32 port) -> bool

auto isPadTriggerDownRightStick(s32 port) -> bool

auto isPadTriggerLeftRightStick(s32 port) -> bool

auto isPadTriggerRightRightStick(s32 port) -> bool

auto isPadTriggerAnyABXY(s32 port) -> bool

auto isPadTriggerAny(s32 port) -> bool

auto isPadTriggerLeftStick(s32 port) -> bool

auto isPadTriggerRightStick(s32 port) -> bool

auto isPadTriggerPressLeftStick(s32 port) -> bool

auto isPadTriggerPressRightStick(s32 port) -> bool

auto isPadRepeat(s32 port, s32 button) -> bool

auto isPadRepeatA(s32 port) -> bool

auto isPadRepeatB(s32 port) -> bool

auto isPadRepeatX(s32 port) -> bool

auto isPadRepeatY(s32 port) -> bool

auto isPadRepeatZL(s32 port) -> bool

auto isPadRepeatZR(s32 port) -> bool

auto isPadRepeatL(s32 port) -> bool

auto isPadRepeatR(s32 port) -> bool

auto isPadRepeat1(s32 port) -> bool

auto isPadRepeat2(s32 port) -> bool

auto isPadRepeatUp(s32 port) -> bool

auto isPadRepeatDown(s32 port) -> bool

auto isPadRepeatLeft(s32 port) -> bool

auto isPadRepeatRight(s32 port) -> bool

auto isPadRepeatHome(s32 port) -> bool

auto isPadRepeatStart(s32 port) -> bool

auto isPadRepeatSelect(s32 port) -> bool

auto isPadRepeatPlus(s32 port) -> bool

auto isPadRepeatMinus(s32 port) -> bool

auto isPadRepeatTouch() -> bool

auto isPadRepeatUpLeftStick(s32 port) -> bool

auto isPadRepeatDownLeftStick(s32 port) -> bool

auto isPadRepeatLeftLeftStick(s32 port) -> bool

auto isPadRepeatRightLeftStick(s32 port) -> bool

auto isPadRepeatUpRightStick(s32 port) -> bool

auto isPadRepeatDownRightStick(s32 port) -> bool

auto isPadRepeatLeftRightStick(s32 port) -> bool

auto isPadRepeatRightRightStick(s32 port) -> bool

auto isPadHoldPressLeftStick(s32 port) -> bool

auto isPadHoldPressRightStick(s32 port) -> bool

auto isPadHold(s32 port, s32 button) -> bool

auto isPadHoldA(s32 port) -> bool

auto isPadHoldB(s32 port) -> bool

auto isPadHoldX(s32 port) -> bool

auto isPadHoldY(s32 port) -> bool

auto isPadHoldZL(s32 port) -> bool

auto isPadHoldZR(s32 port) -> bool

auto isPadHoldL(s32 port) -> bool

auto isPadHoldR(s32 port) -> bool

auto isPadHold1(s32 port) -> bool

auto isPadHold2(s32 port) -> bool

auto isPadHoldUp(s32 port) -> bool

auto isPadHoldDown(s32 port) -> bool

auto isPadHoldLeft(s32 port) -> bool

auto isPadHoldRight(s32 port) -> bool

auto isPadHoldLeftUp(s32 port) -> bool

auto isPadHoldLeftDown(s32 port) -> bool

auto isPadHoldRightUp(s32 port) -> bool

auto isPadHoldRightDown(s32 port) -> bool

auto isPadHoldHome(s32 port) -> bool

auto isPadHoldStart(s32 port) -> bool

auto isPadHoldSelect(s32 port) -> bool

auto isPadHoldPlus(s32 port) -> bool

auto isPadHoldMinus(s32 port) -> bool

auto isPadHoldAny(s32 port) -> bool

auto isPadHoldAnyWithoutStick(s32 port) -> bool

auto isPadHoldTouch() -> bool

auto isPadHoldUpLeftStick(s32 port) -> bool

auto isPadHoldDownLeftStick(s32 port) -> bool

auto isPadHoldLeftLeftStick(s32 port) -> bool

auto isPadHoldRightLeftStick(s32 port) -> bool

auto isPadHoldUpRightStick(s32 port) -> bool

auto isPadHoldDownRightStick(s32 port) -> bool

auto isPadHoldLeftRightStick(s32 port) -> bool

auto isPadHoldRightRightStick(s32 port) -> bool

auto isPadHoldLeftStick(s32 port) -> bool

auto isPadHoldRightStick(s32 port) -> bool

auto isPadRelease(s32 port, s32 button) -> bool

auto isPadReleaseA(s32 port) -> bool

auto isPadReleaseB(s32 port) -> bool

auto isPadReleaseX(s32 port) -> bool

auto isPadReleaseY(s32 port) -> bool

auto isPadReleaseZL(s32 port) -> bool

auto isPadReleaseZR(s32 port) -> bool

auto isPadReleaseL(s32 port) -> bool

auto isPadReleaseR(s32 port) -> bool

auto isPadRelease1(s32 port) -> bool

auto isPadRelease2(s32 port) -> bool

auto isPadReleaseUp(s32 port) -> bool

auto isPadReleaseDown(s32 port) -> bool

auto isPadReleaseLeft(s32 port) -> bool

auto isPadReleaseRight(s32 port) -> bool

auto isPadReleaseHome(s32 port) -> bool

auto isPadReleaseStart(s32 port) -> bool

auto isPadReleaseSelect(s32 port) -> bool

auto isPadReleasePlus(s32 port) -> bool

auto isPadReleaseMinus(s32 port) -> bool

auto isPadReleaseTouch() -> bool

auto isPadReleaseUpLeftStick(s32 port) -> bool

auto isPadReleaseDownLeftStick(s32 port) -> bool

auto isPadReleaseLeftLeftStick(s32 port) -> bool

auto isPadReleaseRightLeftStick(s32 port) -> bool

auto isPadReleaseUpRightStick(s32 port) -> bool

auto isPadReleaseDownRightStick(s32 port) -> bool

auto isPadReleaseLeftRightStick(s32 port) -> bool

auto isPadReleaseRightRightStick(s32 port) -> bool

auto getLeftStick(s32 port) -> const sead::Vector2f&

auto getRightStick(s32 port) -> const sead::Vector2f&

void getPadCrossDir(sead::Vector2f* vec, s32 port)

void getPadCrossDirSideways(sead::Vector2f* vec, s32 port)

void calcTouchScreenPos(sead::Vector2f* vec)

void calcTouchLayoutPos(sead::Vector2f*)

auto isTouchPosInRect(const sead::Vector2f& rect_pos, const sead::Vector2f& size) -> bool

void setPadRepeat(s32 a1, s32 a2, s32 a3, s32 port)

auto getPlayerControllerPort(s32 playerNo) -> s32

auto getTouchPanelPort() -> s32

auto getMainControllerPort() -> s32

auto getMainJoyPadDoublePort() -> s32

auto getMainJoyPadSingleRightPort() -> s32

auto getMainJoyPadSingleLeftPort() -> s32

auto isPadTypeJoySingle(s32 port = -1) -> bool

auto isPadTriggerUiCursorUp(s32 port = -1) -> bool

auto isPadTriggerUiCursorDown(s32 port = -1) -> bool

auto isPadTriggerUiCursorLeft(s32 port = -1) -> bool

auto isPadTriggerUiCursorRight(s32 port = -1) -> bool

auto isPadRepeatUiCursorUp(s32 port = -1) -> bool

auto isPadRepeatUiCursorDown(s32 port = -1) -> bool

auto isPadRepeatUiCursorLeft(s32 port = -1) -> bool

auto isPadRepeatUiCursorRight(s32 port = -1) -> bool

auto isPadHoldUiCursorUp(s32 port = -1) -> bool

auto isPadHoldUiCursorDown(s32 port = -1) -> bool

auto isPadHoldUiCursorLeft(s32 port = -1) -> bool

auto isPadHoldUiCursorRight(s32 port = -1) -> bool

auto isPadReleaseUiCursorUp(s32 port = -1) -> bool

auto isPadReleaseUiCursorDown(s32 port = -1) -> bool

auto isPadReleaseUiCursorLeft(s32 port = -1) -> bool

auto isPadReleaseUiCursorRight(s32 port = -1) -> bool

auto isTouchPosInCircle(const sead::Vector2f&, f32) -> bool

auto isTouchPosInCircleByWorldPos(const sead::Vector2f&, const IUseCamera*, f32, f32) -> bool

auto isPadTouchRect(f32, f32, f32, f32) -> bool

auto isSameNpadId(u32, s32) -> bool

void createReplayController(u32 port)

void unregistReplayController(u32 port)

auto getReplayController(u32 port) -> ReplayController*

void setPadDataReader(IUsePadDataReader* reader, u32 port)

void createAndSetPadDataArcReader(const char* path, const char* stageName, u32 port)

void startPadReplay(u32 port)

void pausePadReplay(u32 port)

void endPadReplay(u32 port)

void setPadDataWriter(IUsePadDataWriter* writer, u32 port)

void startPadRecording(u32 port)

void endPadRecording(u32 port)

auto isPadReplaying(u32 port) -> bool

auto getPadReplayRemainFrame(u32 port) -> s32

auto isPadRecording(u32 port) -> bool

void invalidatePadReplay(u32 port)

void validatePadReplay(u32 port)

auto isValidReplayController(u32 port) -> bool

auto isReadPadReplayData(u32 port) -> bool

auto createPadRumbleKeeper(const LiveActor*, s32) -> PadRumbleKeeper*

void getComputerName(sead::BufferedSafeString* computerName)

auto tryGetComputerName(sead::BufferedSafeString* computerName) -> bool

void getUserName(sead::BufferedSafeString* userName)

void makeUniqueTemporaryFilename(sead::BufferedSafeString* out, const char* fileName)

void expandEnvironmentString(sead::BufferedSafeString* out, const sead::SafeString& envStr)

auto makeTmpExpandEnvironmentString(const sead::SafeString& envStr) -> sead::FixedSafeString<128>

auto makeTmpFileFullPath(const char* fileName) -> StringTmp<128>

auto getALCommon() -> const char*

void FUN_710086f65c(sead::BufferedSafeString* out, const sead::SafeString& envStr)

auto registDemoRequesterToAddDemoInfo(const LiveActor* actor, const ActorInitInfo& initInfo, s32 index) -> AddDemoInfo*

void registActorToDemoInfo(LiveActor* actor, const ActorInitInfo& initInfo)

void addDemoActorFromAddDemoInfo(const LiveActor* actor, const AddDemoInfo* info)

void addDemoActorFromDemoActorHolder(const LiveActor* actor, const DemoActorHolder* holder)

void addDemoActorFromDemoActorHolder(const Scene* scene, const DemoActorHolder* holder)

void setDemoInfoDemoName(const LiveActor* actor, const char* name)

void killForceBeforeDemo(LiveActor* actor)

void prepareSkip(LiveActor* actor, s32)

void invalidateLODWithSubActor(LiveActor*)

auto isActiveDemo(const Scene*) -> bool

auto getDepthClearValue() -> f32

void setDepthFuncNearDraw(sead::GraphicsContext* context)

void setDepthFuncFarDraw(sead::GraphicsContext* context)

auto getAlphaTestEnable(nn::g3d::MaterialObj* material) -> bool

void emitEffectCurrentPos(IUseEffectKeeper*, const char*)

void emitEffect(IUseEffectKeeper*, const char*, const sead::Vector3f*)

auto tryEmitEffect(IUseEffectKeeper*, const char*, const sead::Vector3f*) -> bool

void deleteEffect(IUseEffectKeeper*, const char*)

auto tryDeleteEffect(IUseEffectKeeper*, const char*) -> bool

void deleteEffectAll(IUseEffectKeeper*)

void tryKillEmitterAndParticleAll(IUseEffectKeeper*)

void onCalcAndDrawEffect(IUseEffectKeeper*)

void offCalcAndDrawEffect(IUseEffectKeeper*)

void forceSetStopCalcAndDraw(IUseEffectKeeper*, bool)

auto isEffectEmitting(const IUseEffectKeeper*, const char*) -> bool

void setEffectEmitRatio(IUseEffectKeeper*, const char*, f32)

void setEffectAllScale(IUseEffectKeeper*, const char*, const sead::Vector3f&)

void setEffectEmitterVolumeScale(IUseEffectKeeper*, const char*, const sead::Vector3f&)

void setEffectParticleScale(IUseEffectKeeper*, const char*, f32)

void setEffectParticleScale(IUseEffectKeeper*, const char*, const sead::Vector3f&)

void setEffectParticleAlpha(IUseEffectKeeper*, const char*, f32)

void setEffectParticleColor(IUseEffectKeeper*, const char*, const sead::Color4f&)

void setParticleLifeScale(IUseEffectKeeper*, const char*, f32)

void setEffectParticleDirectionalVel(IUseEffectKeeper*, const char*, f32)

void setEffectFollowPosPtr(IUseEffectKeeper*, const char*, const sead::Vector3f*)

void setEffectFollowMtxPtr(IUseEffectKeeper*, const char*, const sead::Matrix34f*)

void setEffectNamedMtxPtr(IUseEffectKeeper*, const char*, const sead::Matrix34f*)

auto trySetEffectNamedMtxPtr(IUseEffectKeeper*, const char*, const sead::Matrix34f*) -> bool

auto tryUpdateEffectMaterialCode(IUseEffectKeeper*, const char*) -> bool

void resetEffectMaterialCode(IUseEffectKeeper*)

void updateEffectMaterialWater(IUseEffectKeeper*, bool)

void updateEffectMaterialWet(IUseEffectKeeper*, bool)

void updateEffectMaterialPuddle(IUseEffectKeeper*, bool)

template<typename T>

auto createEventFlowNode(const char* eventFlowNodeName) -> EventFlowNode*

auto isNodeName(const EventFlowNode*, const char*) -> bool

auto getScareMessage(const EventFlowNode*) -> const char16*

void startEventCamera(EventFlowNode*, const char*, s32)

void startEventAnimCamera(EventFlowNode*, const char*, const char*, s32)

void endEventCamera(EventFlowNode*, const char*, s32, bool)

auto tryEndEventCameraIfPlaying(EventFlowNode*, const char*, s32, bool) -> bool

auto isEndInterpoleEventCamera(const EventFlowNode*, const char*) -> bool

auto isPlayingEventAnimCamera(const EventFlowNode*, const char*) -> bool

void requestDemoAction(EventFlowNode*, const char*, bool)

void requestPlayerDemoAction(EventFlowNode*, const char*)

auto isEndDemoAction(const EventFlowNode*) -> bool

void setDemoTalkAction(EventFlowNode*, const char*)

void resetDemoTalkAction(EventFlowNode*)

void requestDemoCamera(EventFlowNode*, const char*)

auto isEndRequestDemoCamera(const EventFlowNode*) -> bool

auto isHideDemoPlayer(const EventFlowNode*) -> bool

void requestHideDemoPlayer(EventFlowNode*)

void requestShowDemoPlayer(EventFlowNode*)

void calcPlayerWatchTrans(sead::Vector3f*, const EventFlowNode*)

void requestCommandCloseTalkMessageLayout(EventFlowNode*)

auto isActive(const EventFlowExecutor*) -> bool

auto isScare(const IUseEventFlowData*) -> bool

auto tryGetScareEnemyPos(sead::Vector3f*, const IUseEventFlowData*) -> bool

void invalidateUiCollisionCheck(EventFlowExecutor*)

void onExistLookAtJointCtrl(EventFlowExecutor*)

void setTalkSubActorName(EventFlowExecutor*, const char*)

void resetTalkSubActorName(EventFlowExecutor*)

void startEventAction(LiveActor*, const IUseEventFlowData*, const char*)

void makeEventActionName(sead::BufferedSafeStringBase<char>*, const IUseEventFlowData*, const char*)

void startEventActionAtRandomFrame(LiveActor*, const IUseEventFlowData*, const char*)

auto tryStartEventActionIfNotPlaying(LiveActor*, const IUseEventFlowData*, const char*) -> bool

auto isPlayingEventAction(const LiveActor*, const IUseEventFlowData*, const char*) -> bool

auto isExistEventAction(const LiveActor*, const IUseEventFlowData*, const char*) -> bool

auto isOneTimeEventAction(const LiveActor*, const IUseEventFlowData*, const char*) -> bool

auto getEventActionFrameMax(const LiveActor*, const IUseEventFlowData*, const char*) -> f32

auto getParamMoveSpeed(const IUseEventFlowData*) -> f32

auto getParamTurnSpeedDegree(const IUseEventFlowData*) -> f32

auto getRecordActorFront(const IUseEventFlowData*) -> const sead::Vector3f&

void recordActorFront(IUseEventFlowData*, const sead::Vector3f&)

auto checkInsideTerritoryPos(const IUseEventFlowData*, const LiveActor*, const sead::Vector3f&, f32) -> bool

auto checkInsideEmotionTerritoryPos(const IUseEventFlowData*, const LiveActor*, const sead::Vector3f&) -> bool

auto checkInsideEmotionLowPriorityTerritoryPos(const IUseEventFlowData*, const LiveActor*, const sead::Vector3f&) -> bool

auto checkInsideTalkTerritoryPos(const IUseEventFlowData*, const LiveActor*, const sead::Vector3f&) -> bool

void calcBalloonOffset(sead::Vector3f*, const IUseEventFlowData*, const LiveActor*)

void setBalloonLocalOffset(EventFlowExecutor*, const sead::Vector3f&)

auto getBalloonCollisionCheckOffsetRadius(const IUseEventFlowData*) -> f32

auto isDisableOpenBalloonByOrderGroup(const LiveActor*, const IUseEventFlowData*) -> bool

auto isEnableForceOpenBalloonByOrderGroup(const LiveActor*, const IUseEventFlowData*) -> bool

auto isWaitAtPointMovement(const EventFlowExecutor*) -> bool

auto isStopMovement(const IUseEventFlowData*) -> bool

auto isRequestEventDemoAction(const EventFlowExecutor*) -> bool

auto isPlayingEventDemoAction(const EventFlowExecutor*) -> bool

auto getEventDemoActionName(const EventFlowExecutor*) -> const char*

auto isExistEventDemoTalkAction(const EventFlowExecutor*) -> bool

auto getEventDemoTalkActionName(const EventFlowExecutor*) -> const char*

auto isResetEventDemoPlayerDynamics(const EventFlowExecutor*) -> bool

void startEventDemoAction(EventFlowExecutor*)

void endEventDemoAction(EventFlowExecutor*)

auto isRequestEventDemoCamera(const EventFlowExecutor*) -> bool

auto getEventDemoCameraAnimName(const EventFlowExecutor*) -> const char*

void clearEventDemoCameraRequest(EventFlowExecutor*)

auto isHideDemoPlayer(const EventFlowExecutor*) -> bool

auto isExistEventEntry(const EventFlowExecutor*, const char*) -> bool

auto isCurrentEventEntry(const EventFlowExecutor*, const char*) -> bool

auto isEventName(const EventFlowEventData*, const char*, ...) -> bool

auto getEventName(const EventFlowEventData*) -> const char*

auto getEventDataParamString(const EventFlowEventData*, const char*) -> bool

auto isEventDataParamBool(const EventFlowEventData*, const char*) -> bool

void registerExecutorUser(IUseExecutor* user, ExecuteDirector* director, const char* listName)

void registerExecutorActorUpdate(LiveActor* actor, ExecuteDirector* director, const char* listName)

void registerExecutorActorDraw(LiveActor* actor, ExecuteDirector* director, const char* listName)

void registerExecutorLayoutUpdate(LayoutActor* layout, ExecuteDirector* director, const char* listName)

void registerExecutorLayoutDraw(LayoutActor* layout, ExecuteDirector* director, const char* listName)

void registerExecutorFunctor(const char* listName, ExecuteDirector* director, const FunctorBase& functor)

void registerExecutorFunctorDraw(const char* listName, ExecuteDirector* director, const FunctorBase& functor)

auto getFileLoader() -> FileLoader*

auto isExistFile(const sead::SafeString& fileName) -> bool

auto isExistDirectory(const sead::SafeString& fileName) -> bool

auto isExistArchive(const sead::SafeString& fileName) -> bool

auto isExistArchive(const sead::SafeString& fileName, const char* ext) -> bool

auto getFileSize(const sead::SafeString& fileName) -> u32

auto calcFileAlignment(const sead::SafeString& fileName) -> u32

auto calcBufferSizeAlignment(const sead::SafeString& fileName) -> u32

auto loadFile(const sead::SafeString& fileName, s32 size) -> u8*

auto tryLoadFileToBuffer(const sead::SafeString& fileName, u8* buffer, u32 bufferSize, s32 size) -> bool

auto loadArchive(const sead::SafeString& fileName) -> sead::ArchiveRes*

auto loadArchiveWithExt(const sead::SafeString& fileName, const char* ext) -> sead::ArchiveRes*

auto tryRequestLoadArchive(const sead::SafeString& fileName, sead::Heap* heap) -> bool

void loadSoundItem(u32 soundEntryId, u32 unknown, IAudioResourceLoader* resLoader)

auto tryRequestLoadSoundItem(u32 soundEntryId) -> bool

auto tryRequestPreLoadFile(const Resource* res, s32 id, sead::Heap* heap, IAudioResourceLoader* resLoader) -> bool

auto tryRequestPreLoadFile(const Resource* res, const sead::SafeString& fileName, sead::Heap* heap, IAudioResourceLoader* resLoader) -> bool

void waitLoadDoneAllFile()

void clearFileLoaderEntry()

void makeLocalizedArchivePath(sead::BufferedSafeString* outPath, const sead::SafeString& fileName)

void makeLocalizedArchivePathByCountryCode(sead::BufferedSafeString* outPath, const sead::SafeString& fileName)

void setFileLoaderThreadPriority(s32 priority)

auto isExistItemKeeper(const LiveActor* actor) -> bool

auto addItem(LiveActor* actor, const ActorInitInfo&, const char*, const char*, const char*, s32, bool) -> ActorItemInfo*

auto addItem(LiveActor* actor, const ActorInitInfo&, const char*, bool) -> ActorItemInfo*

void setAppearItemFactor(const LiveActor* actor, const char*, const HitSensor* sensor)

void setAppearItemOffset(const LiveActor* actor, const sead::Vector3f& offset)

void setAppearItemAttackerSensor(const LiveActor* actor, const HitSensor* sensor)

auto appearItem(const LiveActor* actor) -> bool

auto appearItem(const LiveActor* actor, const sead::Vector3f&, const sead::Quatf&, const HitSensor* sensor) -> bool

auto appearItem(const LiveActor* actor, const sead::Vector3f&, const sead::Vector3f&, const HitSensor* sensor) -> bool

auto appearItemTiming(const LiveActor* actor, const char*) -> bool

auto appearItemTiming(const LiveActor* actor, const char*, const sead::Vector3f&, const sead::Quatf&, const HitSensor* sensor) -> bool

auto appearItemTiming(const LiveActor* actor, const char*, const sead::Vector3f&, const sead::Vector3f&, const HitSensor* sensor) -> bool

void acquireItem(const LiveActor* actor, HitSensor* sensor, const char*)

auto getItemType(const LiveActor* actor, const char*) -> s32

void initJointControllerKeeper(const LiveActor*, s32)

void isExistJointControllerKeeper(const LiveActor*)

void registerJointController(const LiveActor*, JointControllerBase*)

void registerJointController(const LiveActor*, JointControllerBase*, const char*)

void initJointLocalRotator(const LiveActor*, sead::Vector3f*, const char*)

void initJointLocalXRotator(const LiveActor*, const f32*, const char*)

void initJointLocalYRotator(const LiveActor*, const f32*, const char*)

void initJointLocalZRotator(const LiveActor*, const f32*, const char*)

auto initJointLocalAxisRotator(const LiveActor*, const sead::Vector3f&, const f32*, const char*, bool) -> JointLocalAxisRotator*

void initJointLocalMinusXRotator(const LiveActor*, const f32*, const char*)

void initJointLocalMinusYRotator(const LiveActor*, const f32*, const char*)

void initJointLocalMinusZRotator(const LiveActor*, const f32*, const char*)

void initJointGlobalXRotator(const LiveActor*, f32*, const char*)

void initJointGlobalAxisRotator(const LiveActor*, const sead::Vector3f&, f32*, const char*)

void initJointGlobalYRotator(const LiveActor*, f32*, const char*)

void initJointGlobalZRotator(const LiveActor*, f32*, const char*)

void initJointGlobalMinusXRotator(const LiveActor*, f32*, const char*)

void initJointGlobalMinusYRotator(const LiveActor*, f32*, const char*)

void initJointGlobalMinusZRotator(const LiveActor*, f32*, const char*)

void initJointLocalTransControllerX(const LiveActor*, const f32*, const char*)

void initJointLocalTransControllerY(const LiveActor*, const f32*, const char*)

void initJointLocalTransControllerZ(const LiveActor*, const f32*, const char*)

void initJointLocalTransController(const LiveActor*, const sead::Vector3f*, const char*)

void initJointLocalScaleControllerX(const LiveActor*, const f32*, const char*)

void initJointLocalScaleControllerY(const LiveActor*, const f32*, const char*)

void initJointLocalScaleControllerZ(const LiveActor*, const f32*, const char*)

void initJointLocalScaleController(const LiveActor*, const sead::Vector3f*, const char*)

void initJointLocalMtxController(const LiveActor*, const sead::Matrix34f*, const char*)

void initJointGlobalMtxController(const LiveActor*, const sead::Matrix34f*, const char*)

void initJointGlobalQuatController(const LiveActor*, const sead::Quatf*, const char*)

void initJointGlobalQuatTransController(const LiveActor*, const sead::Quatf*, const sead::Vector3f*, const char*)

void initJointPostQuatController(const LiveActor*, const sead::Quatf*, const char*)

void initJointLocalDirController(const LiveActor*, const JointDirectionInfo*, const char*)

void initJointAimController(const LiveActor*, const JointAimInfo*, const char*)

void initJointTranslateShaker(const LiveActor*, s32)

void appendJointTranslateShakerX(JointTranslateShaker*, const char*)

void appendJointTranslateShakerY(JointTranslateShaker*, const char*)

void appendJointTranslateShakerZ(JointTranslateShaker*, const char*)

void initJointMasher(const LiveActor*, const bool*, s32)

void appendMashJoint(JointMasher*, const char*, f32)

void initJointRumbler(const LiveActor*, const char*, f32, f32, u32, s32)

void initJointLocalQuatRotator(const LiveActor*, const char*, const sead::Quatf*)

void initJointLookAtController(const LiveActor*, s32)

void appendJointLookAtController(JointLookAtController*, const LiveActor*, const char*, f32, const sead::Vector2f&, const sead::Vector2f&, const sead::Vector3f&, const sead::Vector3f&)

void appendJointLookAtControllerNoJudge(JointLookAtController*, const LiveActor*, const char*, f32, const sead::Vector2f&, const sead::Vector2f&, const sead::Vector3f&, const sead::Vector3f&)

void appendJointLookAtControllerNoJudgeNoOverLimitYaw(JointLookAtController*, const LiveActor*, const char*, f32, const sead::Vector2f&, const sead::Vector2f&, const sead::Vector3f&, const sead::Vector3f&)

void initJointGroundSmoothController(const LiveActor*, const char*)

void initJointPosToPosController(const LiveActor*, const char*, const sead::Vector3f*, const sead::Vector3f*, f32*, const sead::Vector3f&)

auto initJointSpringController(const LiveActor*, const char*) -> JointSpringController*

void initJointConstrainedSpringController(const LiveActor*, const char*)

void initJointSpringTransController(const LiveActor*, const char*)

void initJointSimpleIK(const LiveActor*, const char*)

auto createKeyPoseKeeper(const ActorInitInfo& info) -> KeyPoseKeeper*

auto createKeyPoseKeeper(const PlacementInfo& info) -> KeyPoseKeeper*

void resetKeyPose(KeyPoseKeeper* keyPoseKeeper)

void nextKeyPose(KeyPoseKeeper* keyPoseKeeper)

void restartKeyPose(KeyPoseKeeper* keyPoseKeeper, sead::Vector3f* pos, sead::Quatf* orientation)

void reverseKeyPose(KeyPoseKeeper* keyPoseKeeper)

auto getCurrentKeyTrans(const KeyPoseKeeper* keyPoseKeeper) -> const sead::Vector3f&

auto getNextKeyTrans(const KeyPoseKeeper* keyPoseKeeper) -> const sead::Vector3f&

auto getCurrentKeyQuat(const KeyPoseKeeper* keyPoseKeeper) -> const sead::Quatf&

auto getNextKeyQuat(const KeyPoseKeeper* keyPoseKeeper) -> const sead::Quatf&

auto getCurrentKeyPlacementInfo(const KeyPoseKeeper* keyPoseKeeper) -> const PlacementInfo&

auto getNextKeyPlacementInfo(const KeyPoseKeeper* keyPoseKeeper) -> const PlacementInfo&

auto getKeyPoseCount(const KeyPoseKeeper* keyPoseKeeper) -> s32

void getKeyPoseTrans(sead::Vector3f* out, const KeyPoseKeeper* keyPoseKeeper, s32 idx)

void getKeyPoseQuat(sead::Quatf* out, const KeyPoseKeeper* keyPoseKeeper, s32 idx)

void calcLerpKeyTrans(sead::Vector3f* out, const KeyPoseKeeper* keyPoseKeeper, f32 rate)

void calcSlerpKeyQuat(sead::Quatf* out, const KeyPoseKeeper* keyPoseKeeper, f32 rate)

auto isMoveSignKey(const KeyPoseKeeper* keyPoseKeeper) -> bool

auto isLastKey(const KeyPoseKeeper* keyPoseKeeper) -> bool

auto isFirstKey(const KeyPoseKeeper* keyPoseKeeper) -> bool

auto isGoingToEnd(const KeyPoseKeeper* keyPoseKeeper) -> bool

auto isStop(const KeyPoseKeeper* keyPoseKeeper) -> bool

auto isRestart(const KeyPoseKeeper* keyPoseKeeper) -> bool

auto calcDistanceNextKeyTrans(const KeyPoseKeeper* keyPoseKeeper) -> f32

auto calcTimeToNextKeyMove(const KeyPoseKeeper* keyPoseKeeper, f32 speed) -> s32

void calcDirToNextKey(sead::Vector3f* out, const KeyPoseKeeper* keyPoseKeeper)

auto calcKeyMoveSpeed(const KeyPoseKeeper* keyPoseKeeper) -> f32

auto calcKeyMoveSpeedByTime(const KeyPoseKeeper* keyPoseKeeper) -> f32

auto calcKeyMoveWaitTime(const KeyPoseKeeper* keyPoseKeeper) -> s32

auto calcKeyMoveMoveTime(const KeyPoseKeeper* keyPoseKeeper) -> s32

void calcKeyMoveClippingInfo(sead::Vector3f*, f32*, const KeyPoseKeeper*, f32)

void setKeyMoveClippingInfo(LiveActor*, sead::Vector3f*, const KeyPoseKeeper*)

auto getLayoutPaneGroup(const IUseLayoutAction* layout, const char* paneName) -> LayoutPaneGroup*

void startAction(IUseLayoutAction* layout, const char* actionName, const char* paneName)

auto startActionAtRandomFrame(IUseLayoutAction* layout, const char* actionName, const char* paneName) -> s32

void startFreezeAction(IUseLayoutAction* layout, const char* actionName, f32 frame, const char* paneName)

void startFreezeActionEnd(IUseLayoutAction* layout, const char* actionName, const char* paneName)

auto getActionFrameMax(const IUseLayoutAction* layout, const char* actionName, const char* paneName) -> f32

void startFreezeGaugeAction(IUseLayoutAction* layout, f32 value, f32 minFrame, f32 maxFrame, const char* actionName, const char* paneName)

auto tryStartAction(IUseLayoutAction* layout, const char* actionName, const char* paneName) -> bool

auto isExistAction(const IUseLayoutAction* layout, const char* actionName, const char* paneName) -> bool

auto isActionEnd(const IUseLayoutAction* layout, const char* paneName) -> bool

auto isExistAction(const IUseLayoutAction* layout, const char* paneName) -> bool

auto isActionOneTime(const IUseLayoutAction* layout, const char* actionName, const char* paneName) -> bool

auto getActionFrame(const IUseLayoutAction* layout, const char* paneName) -> f32

void setActionFrame(IUseLayoutAction* layout, f32 frame, const char* paneName)

auto getActionFrameRate(const IUseLayoutAction* layout, const char* paneName) -> f32

void setActionFrameRate(IUseLayoutAction* layout, f32 frameRate, const char* paneName)

auto getActionName(const IUseLayoutAction* layout, const char* paneName) -> const char*

auto isActionPlaying(const IUseLayoutAction* layout, const char* actionName, const char* paneName) -> bool

auto isAnyActionPlaying(const IUseLayoutAction* layout, const char* paneName) -> bool

void setNerveAtActionEnd(LayoutActor* layout, const Nerve* nerve)

void startTextPaneAnim(LayoutActor*, const char16*, const MessageTagDataHolder*, const ReplaceTagProcessorBase*)

void startTextPaneAnimWithAudioUser(LayoutActor*, const char16*, const MessageTagDataHolder*, const ReplaceTagProcessorBase*, const IUseAudioKeeper*)

void startAndSetTextPaneAnimStage(LayoutActor*, const char*, const char*, const MessageTagDataHolder*, const ReplaceTagProcessorBase*)

void startAndSetTextPaneAnimSystem(LayoutActor*, const char*, const char*, const MessageTagDataHolder*, const ReplaceTagProcessorBase*)

void endTextPaneAnim(LayoutActor*)

void skipTextPaneAnim(LayoutActor*)

void flushTextPaneAnim(LayoutActor*)

void changeNextPage(LayoutActor*, const MessageTagDataHolder*, const ReplaceTagProcessorBase*)

auto tryChangeNextPage(LayoutActor*, const MessageTagDataHolder*, const ReplaceTagProcessorBase*) -> bool

auto isExistNextPage(const LayoutActor*) -> bool

auto isEndTextPaneAnim(const LayoutActor*, bool) -> bool

auto getCurrentMessagePaneAnim(const LayoutActor*) -> const char16*

auto calcCurrentMessageTextNum(const LayoutActor*) -> s32

auto calcShowTextTime(s32) -> s32

auto tryStartTextAnim(LayoutActor*, const char16*) -> bool

auto tryStartTextTagVoice(LayoutActor*, const char16*, const IUseAudioKeeper*, const char*, sead::FixedSafeString<64>*) -> bool

void startHitReaction(const LayoutActor*, const char*, const char*)

auto killLayoutIfActive(LayoutActor*) -> bool

auto appearLayoutIfDead(LayoutActor*) -> bool

auto isActive(const LayoutActor*) -> bool

auto isDead(const LayoutActor*) -> bool

void calcTrans(sead::Vector3f*, const IUseLayout*)

auto getLocalTrans(const IUseLayout*) -> sead::Vector2f

auto getLocalTransPtr(const IUseLayout*) -> sead::Vector2f*

void calcScale(sead::Vector3f*, const IUseLayout*)

auto getLocalScale(const IUseLayout*) -> f32

void setLocalTrans(IUseLayout*, const sead::Vector3f&)

void setLocalTrans(IUseLayout*, const sead::Vector2f&)

void setLocalScale(IUseLayout*, f32)

void setLocalScale(IUseLayout*, const sead::Vector2f&)

void setLocalAlpha(IUseLayout*, f32)

void calcPaneTrans(sead::Vector3f*, const IUseLayout*, const char*)

void calcPaneMtx(sead::Matrix34f*, const IUseLayout*, const char*)

void calcPaneTrans(sead::Vector2f*, const IUseLayout*, const char*)

void calcPaneScale(sead::Vector3f*, const IUseLayout*, const char*)

void calcPaneSize(sead::Vector3f*, const IUseLayout*, const char*)

auto getPaneMtx(const IUseLayout*, const char*) -> const Matrix43f&

auto getPaneMtxRaw(const IUseLayout*, const char*) -> const Matrix43f*

auto getGlobalAlpha(const IUseLayout*, const char*) -> f32

void setPaneLocalTrans(IUseLayout*, const char*, const sead::Vector2f&)

void setPaneLocalTrans(IUseLayout*, const char*, const sead::Vector3f&)

void setPaneLocalRotate(IUseLayout*, const char*, const sead::Vector3f&)

void setPaneLocalScale(IUseLayout*, const char*, const sead::Vector2f&)

void setPaneLocalSize(IUseLayout*, const char*, const sead::Vector2f&)

void setPaneLocalAlpha(IUseLayout*, const char*, f32)

auto getPaneLocalTrans(const IUseLayout*, const char*) -> sead::Vector3f

void getPaneLocalSize(sead::Vector2f*, const IUseLayout*, const char*)

auto getPaneLocalRotate(const IUseLayout*, const char*) -> const sead::Vector3f&

auto getPaneLocalScale(const IUseLayout*, const char*) -> const sead::Vector3f&

auto getTextBoxDrawRectSize(const IUseLayout*, const char*) -> const sead::Vector3f&

void showPane(IUseLayout*, const char*)

void hidePane(IUseLayout*, const char*)

void showPaneNoRecursive(IUseLayout*, const char*)

void hidePaneNoRecursive(IUseLayout*, const char*)

auto isHidePane(const IUseLayout*, const char*) -> bool

void showPaneRoot(IUseLayout*)

void hidePaneRoot(IUseLayout*)

void showPaneRootNoRecursive(IUseLayout*)

void hidePaneRootNoRecursive(IUseLayout*)

auto isHidePaneRoot(const IUseLayout*) -> bool

auto isExistPane(const IUseLayout*, const char*) -> bool

auto isContainPointPane(const IUseLayout*, const char*, const sead::Vector2f&) -> bool

void findHitPaneFromLayoutPos(const IUseLayout*, const sead::Vector2f&)

auto isExistHitPaneFromLayoutPos(const IUseLayout*, const sead::Vector2f&) -> bool

void findHitPaneFromScreenPos(const IUseLayout*, const sead::Vector2f&)

auto isExistHitPaneFromScreenPos(const IUseLayout*, const sead::Vector2f&) -> bool

auto isTouchPosInPane(const IUseLayout*, const char*) -> bool

void setCursorPanePos(IUseLayout*, const IUseLayout*)

void setPaneVtxColor(const IUseLayout*, const char*, const sead::Color4u8&)

auto isTriggerTouchPane(const IUseLayout*, const char*) -> bool

auto isHoldTouchPane(const IUseLayout*, const char*) -> bool

auto isReleaseTouchPane(const IUseLayout*, const char*) -> bool

auto getPaneChildNum(const IUseLayout*, const char*) -> s32

auto getPaneChildName(const IUseLayout*, const char*, s32) -> const char*

void setPaneStringLength(IUseLayout*, const char*, const char16*, u16, u16)

void setPaneString(IUseLayout*, const char*, const char16*, u16)

void setPaneCounterDigit1(IUseLayout*, const char*, s32, u16)

void setPaneCounterDigit2(IUseLayout*, const char*, s32, u16)

void setPaneCounterDigit3(IUseLayout*, const char*, s32, u16)

void setPaneCounterDigit4(IUseLayout*, const char*, s32, u16)

void setPaneCounterDigit5(IUseLayout*, const char*, s32, u16)

void setPaneCounterDigit6(IUseLayout*, const char*, s32, u16)

void setPaneNumberDigit1(IUseLayout*, const char*, s32, u16)

void setPaneNumberDigit2(IUseLayout*, const char*, s32, u16)

void setPaneNumberDigit3(IUseLayout*, const char*, s32, u16)

void setPaneNumberDigit4(IUseLayout*, const char*, s32, u16)

void setPaneNumberDigit5(IUseLayout*, const char*, s32, u16)

void setPaneStringFormat(IUseLayout*, const char*, const char*, ...)

void setTextPositionCenterH(IUseLayout*, const char*)

void initPaneMessage(IUseLayout*, const char*, const MessageHolder*, const char*, u32)

void setPaneSystemMessage(LayoutActor*, const char*, const char*, const char*)

void setPaneStageMessage(LayoutActor*, const char*, const char*, const char*)

auto getPaneStringBuffer(const IUseLayout*, const char*) -> const char16*

auto getPaneStringBufferLength(const IUseLayout*, const char*) -> s32

void setTextBoxPaneFont(const LayoutActor*, const char*, const char*)

void adjustPaneSizeToTextSizeAll(const LayoutActor*)

void requestCaptureRecursive(const LayoutActor*)

void setRubyScale(const LayoutActor*, f32)

auto createTextureInfo() -> nn::ui2d::TextureInfo*

auto createTextureInfo(const agl::TextureData&) -> nn::ui2d::TextureInfo*

auto createTextureInfo(const IUseLayout*, const char*) -> nn::ui2d::TextureInfo*

void getPaneTextureInfo(nn::ui2d::TextureInfo*, const IUseLayout*, const char*)

auto createTextureInfo(const char*, const char*, const char*) -> nn::ui2d::TextureInfo*

void updateTextureInfo(nn::ui2d::TextureInfo*, const agl::TextureData&)

void setPaneTexture(IUseLayout*, const char*, const nn::ui2d::TextureInfo*)

void registerLayoutPartsActor(LayoutActor*, LayoutActor*)

void updateLayoutPaneRecursive(LayoutActor*)

auto getLayoutPaneGroupNum(LayoutActor*) -> s32

auto getLayoutPaneGroup(LayoutActor*, s32) -> LayoutPaneGroup*

void initLayoutActor(LayoutActor*, const LayoutInitInfo&, const char*, const char*)

void initLayoutActorLocalized(LayoutActor*, const LayoutInitInfo&, const char*, const char*)

void initLayoutActorUseOtherMessage(LayoutActor*, const LayoutInitInfo&, const char*, const char*, const char*)

void initLayoutTextPaneAnimator(LayoutActor*, const char*)

void initLayoutTextPaneAnimatorWithShadow(LayoutActor*, const char*)

void initLayoutPartsActor(LayoutActor*, LayoutActor*, const LayoutInitInfo&, const char*, const char*)

void initLayoutPartsActorLocalized(LayoutActor*, LayoutActor*, const LayoutInitInfo&, const char*, const char*)

void initLayoutInitInfo(LayoutInitInfo*, const LayoutKit*, SceneObjHolder*, const AudioDirector*, const LayoutSystem*, const MessageSystem*, const GamePadSystem*)

void setRenderBuffer(LayoutKit*, const agl::RenderBuffer*)

void executeUpdate(LayoutKit*)

void executeUpdateList(LayoutKit*, const char*, const char*)

void executeUpdateEffect(LayoutKit*)

void executeDraw(const LayoutKit*, const char*)

void executeDrawEffect(const LayoutKit*)

void startAction(LiveActor* actor, const char* actionName)

auto startActionAtRandomFrame(LiveActor* actor, const char* actionName) -> s32

auto tryStartAction(LiveActor* actor, const char* actionName) -> bool

auto tryStartActionIfNotPlaying(LiveActor* actor, const char* actionName) -> bool

auto isActionPlaying(const LiveActor* actor, const char* actionName) -> bool

auto tryStartActionIfActionEnd(LiveActor* actor, const char* actionName) -> bool

auto isActionEnd(const LiveActor* actor) -> bool

auto isExistAction(const LiveActor* actor) -> bool

auto isExistAction(const LiveActor* actor, const char* actionName) -> bool

auto isActionOneTime(const LiveActor* actor) -> bool

auto isActionOneTime(const LiveActor* actor, const char* actionName) -> bool

auto getActionName(const LiveActor* actor) -> const char*

auto getActionFrame(const LiveActor* actor) -> f32

auto getActionFrameMax(const LiveActor* actor) -> f32

auto getActionFrameMax(const LiveActor* actor, const char* actionName) -> f32

auto getActionFrameRate(const LiveActor* actor) -> f32

void setActionFrame(LiveActor* actor, f32 frame)

void setActionFrameRate(LiveActor* actor, f32 rate)

void stopAction(LiveActor* actor)

void restartAction(LiveActor* actor)

void copyAction(LiveActor* actor, const LiveActor* sourceActor)

void startNerveAction(LiveActor* actor, const char* actionName)

void setNerveAtActionEnd(LiveActor* actor, const Nerve* nerve)

void resetNerveActionForInit(LiveActor* actor)

void startHitReaction(const LiveActor* actor, const char* name)

void startHitReactionHitEffect(const LiveActor* actor, const char* name, const HitSensor* other, const HitSensor* self)

void startHitReactionHitEffect(const LiveActor* actor, const char* name, const sead::Vector3f& pos)

void startHitReactionHitEffect(const LiveActor* actor, const char* name, const sead::Matrix34f* mtx)

void startHitReactionBlowHit(const LiveActor* actor, const HitSensor* other, const HitSensor* self)

void startHitReactionBlowHit(const LiveActor* actor, const sead::Vector3f& pos)

void startHitReactionBlowHit(const LiveActor* actor)

void startHitReactionBlowHitDirect(const LiveActor* actor, const HitSensor* other, const HitSensor* self)

void startHitReactionBlowHitDirect(const LiveActor* actor, const sead::Vector3f& pos)

void startHitReactionBlowHitDirect(const LiveActor* actor)

void startSklAnim(LiveActor* actor, const char* animName)

void startSklAnimInterpole(LiveActor* actor, const char* animName0, const char* animName1)

auto tryStartSklAnimIfExist(LiveActor* actor, const char* animName) -> bool

auto isSklAnimExist(const LiveActor* actor, const char* animName) -> bool

auto tryStartSklAnimIfNotPlaying(LiveActor* actor, const char* animName) -> bool

auto isSklAnimPlaying(const LiveActor* actor, const char* animName, s32 index) -> bool

void startSklAnimBlend(LiveActor* actor, const char* animName0, const char* animName1, const char* animName2, const char* animName3, const char* animName4, const char* animName5)

void startSklAnimBlendInterpole(LiveActor* actor, const char* animName0, const char* animName1, const char* animName2, const char* animName3, const char* animName4, const char* animName5, const char* animName6)

void clearSklAnimInterpole(LiveActor* actor)

auto isSklAnimExist(const LiveActor* actor) -> bool

auto isSklAnimEnd(const LiveActor* actor, s32 index) -> bool

auto isSklAnimOneTime(const LiveActor* actor, const char* animName) -> bool

auto isSklAnimOneTime(const LiveActor* actor, s32 index) -> bool

auto isSklAnimPlaying(const LiveActor* actor, s32 index) -> bool

auto getPlayingSklAnimName(const LiveActor* actor, s32 index) -> const char*

auto getSklAnimFrame(const LiveActor* actor, s32 index) -> f32

auto getSklAnimFrameRate(const LiveActor* actor, s32 index) -> f32

auto getSklAnimFrameMax(const LiveActor* actor, s32 index) -> f32

auto getSklAnimFrameMax(const LiveActor* actor, const char* animName) -> f32

void setSklAnimFrame(LiveActor* actor, f32 frame, s32 index)

void setSklAnimFrameRate(LiveActor* actor, f32 frameRate, s32 index)

void setSklAnimFrameAndStop(LiveActor* actor, f32 frame, s32 index)

auto getSklAnimBlendNum(const LiveActor* actor) -> s32

auto getSklAnimBlendWeight(const LiveActor* actor, s32 index) -> f32

void setSklAnimBlendWeight(LiveActor* actor, f32 weight, s32 index)

void setSklAnimBlendWeightDouble(LiveActor* actor, f32 weight)

void setSklAnimBlendWeightDouble(LiveActor* actor, f32 weight0, f32 weight1)

void setSklAnimBlendWeightTriple(LiveActor* actor, f32 weight0, f32 weight1, f32 weight2)

void setSklAnimBlendWeightQuad(LiveActor* actor, f32 weight0, f32 weight1, f32 weight2, f32 weight3)

void setSklAnimBlendWeightFivefold(LiveActor* actor, f32 weight0, f32 weight1, f32 weight2, f32 weight3, f32 weight4)

void setSklAnimBlendWeightSixfold(LiveActor* actor, f32 weight0, f32 weight1, f32 weight2, f32 weight3, f32 weight4, f32 weight5)

void setSklAnimBlendFrameAll(LiveActor* actor, f32 frame, bool isSync)

void setSklAnimBlendFrameRateAll(LiveActor* actor, f32 frameRate, bool isSync)

void startMtpAnim(LiveActor* actor, const char* animName)

void startMtpAnimAndSetFrameAndStop(LiveActor* actor, const char* animName, f32 frame)

void setMtpAnimFrameRate(LiveActor* actor, f32 frameRate)

void setMtpAnimFrame(LiveActor* actor, f32 frame)

auto tryStartMtpAnimIfExist(LiveActor* actor, const char* animName) -> bool

auto isMtpAnimExist(const LiveActor* actor, const char* animName) -> bool

auto tryStartMtpAnimIfNotPlaying(LiveActor* actor, const char* animName) -> bool

auto isMtpAnimPlaying(const LiveActor* actor, const char* animName) -> bool

void clearMtpAnim(LiveActor* actor)

auto isMtpAnimExist(const LiveActor* actor) -> bool

auto isMtpAnimEnd(const LiveActor* actor) -> bool

auto isMtpAnimOneTime(const LiveActor* actor, const char* animName) -> bool

auto isMtpAnimOneTime(const LiveActor* actor) -> bool

auto getPlayingMtpAnimName(const LiveActor* actor) -> const char*

auto isMtpAnimPlaying(const LiveActor* actor) -> bool

auto getMtpAnimFrame(const LiveActor* actor) -> f32

auto getMtpAnimFrameRate(const LiveActor* actor) -> f32

auto getMtpAnimFrameMax(const LiveActor* actor) -> f32

auto getMtpAnimFrameMax(const LiveActor* actor, const char* animName) -> f32

void setMtpAnimFrameAndStop(LiveActor* actor, f32 frame)

void setMtpAnimFrameAndStopEnd(LiveActor* actor)

void startMclAnim(LiveActor* actor, const char* animName)

auto isMclAnimExist(const LiveActor* actor) -> bool

auto isMclAnimExist(const LiveActor* actor, const char* animName) -> bool

auto tryStartMclAnimIfExist(LiveActor* actor, const char* animName) -> bool

auto tryStartMclAnimIfNotPlaying(LiveActor* actor, const char* animName) -> bool

auto isMclAnimPlaying(const LiveActor* actor, const char* animName) -> bool

void clearMclAnim(LiveActor* actor)

auto isMclAnimEnd(const LiveActor* actor) -> bool

auto isMclAnimOneTime(const LiveActor* actor, const char* animName) -> bool

auto isMclAnimOneTime(const LiveActor* actor) -> bool

auto getPlayingMclAnimName(const LiveActor* actor) -> const char*

auto isMclAnimPlaying(const LiveActor* actor) -> bool

auto getMclAnimFrame(const LiveActor* actor) -> f32

auto getMclAnimFrameRate(const LiveActor* actor) -> f32

auto getMclAnimFrameMax(const LiveActor* actor) -> f32

auto getMclAnimFrameMax(const LiveActor* actor, const char* animName) -> f32

void setMclAnimFrame(LiveActor* actor, f32 frame)

void setMclAnimFrameRate(LiveActor* actor, f32 frameRate)

void startMclAnimAndSetFrameAndStop(LiveActor* actor, const char* animName, f32 frame)

void setMclAnimFrameAndStop(LiveActor* actor, f32 frame)

void setMclAnimNormalFrameAndStop(LiveActor* actor, f32 frame)

void setMclAnimFrameAndStopEnd(LiveActor* actor)

void startMtsAnim(LiveActor* actor, const char* animName)

void startMtsAnimAndSetFrameAndStop(LiveActor* actor, const char* animName, f32 frame)

void setMtsAnimFrame(LiveActor* actor, f32 frame)

void setMtsAnimFrameRate(LiveActor* actor, f32 frameRate)

auto tryStartMtsAnimIfExist(LiveActor* actor, const char* animName) -> bool

auto isMtsAnimExist(const LiveActor* actor, const char* animName) -> bool

auto tryStartMtsAnimIfNotPlaying(LiveActor* actor, const char* animName) -> bool

auto isMtsAnimPlaying(const LiveActor* actor, const char* animName) -> bool

void clearMtsAnim(LiveActor* actor)

auto isMtsAnimExist(const LiveActor* actor) -> bool

auto isMtsAnimEnd(const LiveActor* actor) -> bool

auto isMtsAnimOneTime(const LiveActor* actor, const char* animName) -> bool

auto isMtsAnimOneTime(const LiveActor* actor) -> bool

auto getPlayingMtsAnimName(const LiveActor* actor) -> const char*

auto isMtsAnimPlaying(const LiveActor* actor) -> bool

auto getMtsAnimFrame(const LiveActor* actor) -> f32

auto getMtsAnimFrameRate(const LiveActor* actor) -> f32

auto getMtsAnimFrameMax(const LiveActor* actor) -> f32

auto getMtsAnimFrameMax(const LiveActor* actor, const char* animName) -> f32

void setMtsAnimFrameAndStop(LiveActor* actor, f32 frame)

void setMtsAnimFrameAndStopEnd(LiveActor* actor)

void createMatAnimSlotForMcl(LiveActor* actor)

void createMatAnimSlotForMtp(LiveActor* actor)

void createMatAnimSlotForMts(LiveActor* actor)

void startMatAnim(LiveActor* actor, const char* animName)

void startMatAnimAndSetFrameAndStop(LiveActor* actor, const char* animName, f32 frame)

void setMatAnimFrame(LiveActor* actor, f32 frame)

void setMatAnimFrameRate(LiveActor* actor, f32 frameRate)

auto tryStartMatAnimIfExist(LiveActor* actor, const char* animName) -> bool

auto isMatAnimExist(const LiveActor* actor, const char* animName) -> bool

auto tryStartMatAnimIfNotPlaying(LiveActor* actor, const char* animName) -> bool

auto isMatAnimPlaying(const LiveActor* actor, const char* animName) -> bool

void clearMatAnim(LiveActor* actor)

auto isMatAnimExist(const LiveActor* actor) -> bool

auto isMatAnimEnd(const LiveActor* actor) -> bool

auto isMatAnimOneTime(const LiveActor* actor, const char* animName) -> bool

auto isMatAnimOneTime(const LiveActor* actor) -> bool

auto getPlayingMatAnimName(const LiveActor* actor) -> const char*

auto isMatAnimPlaying(const LiveActor* actor) -> bool

auto getMatAnimFrame(const LiveActor* actor) -> f32

auto getMatAnimFrameRate(const LiveActor* actor) -> f32

auto getMatAnimFrameMax(const LiveActor* actor) -> f32

auto getMatAnimFrameMax(const LiveActor* actor, const char* animName) -> f32

void setMatAnimFrameAndStop(LiveActor* actor, f32 frame)

void setMatAnimFrameAndStopEnd(LiveActor* actor)

void startVisAnim(LiveActor* actor, const char* animName)

auto tryStartVisAnimIfExist(LiveActor* actor, const char* animName) -> bool

auto isVisAnimExist(const LiveActor* actor, const char* animName) -> bool

auto tryStartVisAnimIfNotPlaying(LiveActor* actor, const char* animName) -> bool

auto isVisAnimPlaying(const LiveActor* actor, const char* animName) -> bool

void clearVisAnim(LiveActor* actor)

auto isVisAnimExist(const LiveActor* actor) -> bool

auto isVisAnimEnd(const LiveActor* actor) -> bool

auto isVisAnimOneTime(const LiveActor* actor, const char* animName) -> bool

auto isVisAnimOneTime(const LiveActor* actor) -> bool

auto getPlayingVisAnimName(const LiveActor* actor) -> const char*

auto isVisAnimPlaying(const LiveActor* actor) -> bool

auto getVisAnimFrame(const LiveActor* actor) -> f32

auto getVisAnimFrameRate(const LiveActor* actor) -> f32

auto getVisAnimFrameMax(const LiveActor* actor) -> f32

auto getVisAnimFrameMax(const LiveActor* actor, const char* animName) -> f32

void setVisAnimFrame(LiveActor* actor, f32 frame)

void setVisAnimFrameRate(LiveActor* actor, f32 frameRate)

void setVisAnimFrameAndStop(LiveActor* actor, f32 frame)

void setVisAnimFrameAndStopEnd(LiveActor* actor)

void startVisAnimAndSetFrameAndStop(LiveActor* actor, const char* animName, f32 frame)

void startVisAnimForAction(LiveActor* actor, const char* animName)

auto tryStartVisAnimIfExistForAction(LiveActor* actor, const char* animName) -> bool

auto tryStartVisAnimIfNotPlayingForAction(LiveActor* actor, const char* animName) -> bool

auto isVisAnimPlayingForAction(const LiveActor* actor, const char* animName) -> bool

void clearVisAnimForAction(LiveActor* actor)

auto isVisAnimEndForAction(const LiveActor* actor) -> bool

auto isVisAnimOneTimeForAction(const LiveActor* actor, const char* animName) -> bool

auto isVisAnimOneTimeForAction(const LiveActor* actor) -> bool

auto getPlayingVisAnimNameForAction(const LiveActor* actor) -> const char*

auto isVisAnimPlayingForAction(const LiveActor* actor) -> bool

auto getVisAnimFrameForAction(const LiveActor* actor) -> f32

auto getVisAnimFrameRateForAction(const LiveActor* actor) -> f32

auto getVisAnimFrameMaxForAction(const LiveActor* actor) -> f32

void setVisAnimFrameForAction(LiveActor* actor, f32 frame)

void setVisAnimFrameRateForAction(LiveActor* actor, f32 frameRate)

void setVisAnimFrameAndStopForAction(LiveActor* actor, f32 frame)

void setVisAnimFrameAndStopEndForAction(LiveActor* actor)

void startVisAnimAndSetFrameAndStopForAction(LiveActor* actor, const char* animName, f32 frame)

void setAllAnimFrame(LiveActor* actor, f32 frame)

void setAllAnimFrameRate(LiveActor* actor, f32 frameRate)

void startPartialSklAnim(LiveActor* actor, const char* animName, s32 partCount, s32 value, const SklAnimRetargettingInfo* info)

void startPartialSklAnimWithInterpolate(LiveActor* actor, const char* animName, s32 partCount, s32 value, s32 interpol, const SklAnimRetargettingInfo* info)

void clearPartialSklAnim(LiveActor* actor, s32 index)

void clearPartialSklAnimWithInterpolate(LiveActor* actor, s32 partIndex, s32 interpol)

auto isPartialSklAnimEnd(const LiveActor* actor, s32 index) -> bool

auto isPartialSklAnimOneTime(const LiveActor* actor, s32 index) -> bool

auto isPartialSklAnimAttached(const LiveActor* actor, s32 index) -> bool

auto isPartialSklAnimPlaying(const LiveActor* actor, const char* partsName, s32 index) -> bool

auto getPlayingPartialSklAnimName(const LiveActor* actor, s32 index) -> const char*

auto getPartialSklAnimFrame(const LiveActor* actor, s32 index) -> f32

void setPartialSklAnimFrame(LiveActor* actor, s32 index, f32 frame)

auto getPartialSklAnimFrameRate(const LiveActor* actor, s32 index) -> f32

void setPartialSklAnimFrameRate(LiveActor* actor, s32 index, f32 frameRate)

void setBaseMtxAndCalcAnim(LiveActor* actor, const sead::Matrix34f& matrix, const sead::Vector3f& vector)

auto getSkl(const LiveActor* actor) -> AnimPlayerSkl*

auto getMtp(const LiveActor* actor) -> AnimPlayerMat*

auto getMcl(const LiveActor* actor) -> AnimPlayerMat*

auto getMts(const LiveActor* actor) -> AnimPlayerMat*

auto getMat(const LiveActor* actor) -> AnimPlayerMat*

auto getVis(const LiveActor* actor) -> AnimPlayerVis*

auto getVisForAction(const LiveActor* actor) -> AnimPlayerVis*

void updateModelDraw(const LiveActor* actor)

void updateActorSystem(LiveActor* actor)

void setSklBlendWeight(const LiveActor* actor, u32 index, f32 weight)

void createMat(const LiveActor* actor, s32 programType)

void setAllAnimFrameRate(LiveActor* f32)

void validateSklAnimRetargetting(const LiveActor*)

void invalidateSklAnimRetargetting(const LiveActor*)

void copySklAnim(LiveActor*, const LiveActor*)

void setSklAnimBlendWeightSixfold(LiveActor*, f32, f32, f32, f32, f32)

auto isExistSklAnimRetargetting(const LiveActor*) -> bool

auto isSklAnimRetargettingValid(const LiveActor*) -> bool

void startMatAnim(LiveActor, const char*)

void startMatAnimAndSetFrameAndStop(LiveActor, const char*, f32)

auto getVisAnimFrameMaxForAction(const LiveActor*, const char*) -> f32

auto isVisAnimExistForAction(const LiveActor*, const char*) -> bool

auto isVisAnimExistForAction(const LiveActor*) -> bool

void initAndBindSklAnimRetargetting(LiveActor*, const char*, const sead::Vector3f&)

auto createSklAnimRetargetting(const LiveActor*, const char*, const sead::Vector3f&) -> SklAnimRetargettingInfo*

void bindSklAnimRetargetting(const LiveActor*, const SklAnimRetargettingInfo*)

auto createSklAnimRetargetting(const LiveActor*, const LiveActor*, const sead::Vector3f&) -> SklAnimRetargettingInfo*

void unbindSklAnimRetargetting(const LiveActor*)

void initPartialSklAnim(LiveActor*, s32, s32, s32)

void addPartialSklAnimPartsList(LiveActor*, const char*, const char*, s32)

void addPartialSklAnimPartsListRecursive(LiveActor*, const char*, s32)

auto getPartialSklAnimSlotNum(LiveActor*) -> s32

auto calcJoitsAmountFromJoint(LiveActor*, const char*) -> s32

auto isPartialAnimPlaying(const LiveActor*, s32) -> bool

auto tryFindAreaObjPlayerOne(const PlayerHolder* holder, const char* name) -> AreaObj*

auto tryFindAreaObjPlayerAll(const PlayerHolder* holder, const char* name) -> AreaObj*

auto createAreaObj(const ActorInitInfo& actorInitInfo, const char* name) -> AreaObj*

void initAreaInitInfo(AreaInitInfo* areaInitInfo, const ActorInitInfo& actorInitInfo)

auto createLinkArea(const ActorInitInfo& initInfo, const char* name, const char* areaName) -> AreaObj*

void initAreaInitInfo(AreaInitInfo* areaInitInfo, const PlacementInfo& placementInfo, const ActorInitInfo& actorInitInfo)

auto tryCreateLinkArea(const ActorInitInfo& initInfo, const char* name, const char* areaName) -> AreaObj*

__attribute__((always_inline)) AreaObjGroup *createLinkAreaGroup(const ActorInitInfo &initInfo

if() return nullptr

auto createBuffer(linkChildNum) -> areaGroup

for()

auto createLinkAreaGroup(LiveActor* actor, const ActorInitInfo& initInfo, const char* name, const char* groupName, const char* areaName) -> AreaObjGroup*

auto tryFindAreaObj(const LiveActor* actor, const char* name) -> AreaObj*

auto isInAreaObj(const LiveActor* actor, const char* name) -> bool

auto isInDeathArea(const LiveActor* actor) -> bool

auto isInWaterArea(const LiveActor* actor) -> bool

auto isInPlayerControlOffArea(const LiveActor* actor) -> bool

auto calcWaterSinkDepth(const LiveActor* actor) -> f32

void registerAreaHostMtx(const IUseAreaObj* areaObj, const sead::Matrix34f* mtx, const ActorInitInfo& initInfo)

void registerAreaHostMtx(const IUseAreaObj* areaObj, const sead::Matrix34f* mtx, const ActorInitInfo& initInfo, const ValidatorBase& validator)

void registerAreaHostMtx(const LiveActor* actor, const ActorInitInfo& initInfo)

void registerAreaHostMtx(const LiveActor* actor, const ActorInitInfo& initInfo, const ValidatorBase& validator)

void registerAreaSyncHostMtx(const IUseAreaObj* areaObj, const sead::Matrix34f* mtx, const ActorInitInfo& initInfo)

void registerAreaSyncHostMtx(const IUseAreaObj* areaObj, const sead::Matrix34f* mtx, const ActorInitInfo& initInfo, const ValidatorBase& validator)

void registerAreaSyncHostMtx(const LiveActor* actor, const ActorInitInfo& initInfo)

void registerAreaSyncHostMtx(const LiveActor* actor, const ActorInitInfo& initInfo, const ValidatorBase& validator)

auto tryReviseVelocityInsideAreaObj(sead::Vector3f* nearestEdgePos, LiveActor* actor, AreaObjGroup* areaGroup, const AreaObj* areaObj) -> bool

auto tryCreateSwitchKeepOnAreaGroup(LiveActor* actor, const ActorInitInfo& initInfo) -> SwitchKeepOnAreaGroup*

auto tryCreateSwitchOnAreaGroup(LiveActor* actor, const ActorInitInfo& initInfo) -> SwitchOnAreaGroup*

auto tryGetAreaObjPlayerAll(const LiveActor* actor, const AreaObjGroup* areaGroup) -> AreaObj*

auto isInAreaObjPlayerAll(const LiveActor* actor, const AreaObj* areaObj) -> bool

auto isInAreaObjPlayerAll(const LiveActor* actor, const AreaObjGroup* areaGroup) -> bool

auto isInAreaObjPlayerAnyOne(const LiveActor* actor, const AreaObj* areaObj) -> bool

auto isInAreaObjPlayerAnyOne(const LiveActor* actor, const AreaObjGroup* areaGroup) -> bool

auto createLinkAreaGroup(const ActorInitInfo& initInfo, const char* name, const char* groupName, const char* areaName) -> AreaObjGroup*

auto isInAreaObjPlayerOne(const PlayerHolder* holder, const char* name) -> bool

auto isInAreaObjPlayerAll(const PlayerHolder* holder, const char* name) -> bool

auto isInAreaObjPlayerOneIgnoreAreaTarget(const PlayerHolder* holder, const char* name) -> bool

auto isClipped(const LiveActor* actor) -> bool

auto isInvalidClipping(const LiveActor* actor) -> bool

void initActorClipping(LiveActor* actor, const ActorInitInfo& initInfo)

void initGroupClipping(LiveActor* actor, const ActorInitInfo& initInfo)

auto getClippingRadius(const LiveActor* actor) -> f32

void setClippingInfo(LiveActor* actor, f32, const sead::Vector3f*)

void setClippingObb(LiveActor* actor, const sead::BoundBox3f& boundingBox)

auto getClippingObb(LiveActor* actor) -> const sead::BoundBox3f&

auto getClippingCenterPos(const LiveActor* actor) -> const sead::Vector3f&

void setClippingNearDistance(LiveActor* actor, f32 near)

void expandClippingRadiusByShadowLength(LiveActor* actor, sead::Vector3f*, f32 radius)

auto tryExpandClippingToGround(LiveActor* actor, sead::Vector3f*, f32) -> bool

auto tryExpandClippingByShadowMaskLength(LiveActor* actor, sead::Vector3f*) -> bool

auto tryExpandClippingByDepthShadowLength(LiveActor* actor, sead::Vector3f*) -> bool

auto tryExpandClippingByExpandObject(LiveActor*, const ActorInitInfo& initInfo) -> bool

void invalidateClipping(LiveActor* actor)

void validateClipping(LiveActor* actor)

void onDrawClipping(LiveActor* actor)

void offDrawClipping(LiveActor* actor)

void onGroupClipping(LiveActor* actor)

void offGroupClipping(LiveActor* actor)

auto isInClippingFrustum(const LiveActor* actor, const sead::Vector3f&, f32, f32, s32) -> bool

auto isInClippingFrustum(const ClippingDirector* director, const sead::Vector3f&, f32, f32, s32) -> bool

auto isInClippingFrustumAllView(const LiveActor* actor, const sead::Vector3f& pos, f32, f32) -> bool

auto getActorCollider(const LiveActor*) -> Collider*

auto isExistActorCollider(const LiveActor*) -> bool

void getActorCollisionPartsSensor(const LiveActor*)

auto isExistCollisionParts(const LiveActor*) -> bool

auto isEqualCollisionParts(const LiveActor*, const CollisionParts*) -> bool

void validateCollisionParts(LiveActor*)

void invalidateCollisionParts(LiveActor*)

void validateCollisionPartsBySystem(LiveActor*)

void invalidateCollisionPartsBySystem(LiveActor*)

void isValidCollisionParts(const LiveActor*)

void setCollisionPartsSpecialPurposeName(LiveActor*, const char*)

void resetAllCollisionMtx(LiveActor*)

void syncCollisionMtx(LiveActor*, const sead::Matrix34f*)

void syncCollisionMtx(LiveActor*, CollisionParts*, const sead::Matrix34f*)

void setSyncCollisionMtxPtr(LiveActor*, const sead::Matrix34f*)

auto isOnGround(const LiveActor*, u32) -> bool

auto isOnGroundFace(const LiveActor*) -> bool

auto isCollidedGroundEdgeOrCorner(const LiveActor*) -> bool

auto isOnGroundNoVelocity(const LiveActor*, u32) -> bool

auto isOnGroundDegree(const LiveActor*, f32, u32) -> bool

auto isOnGroundFaceDegree(const LiveActor*, f32) -> bool

auto isOnGroundNoVelocityDegree(const LiveActor*, f32, u32) -> bool

auto getOnGroundNormal(const LiveActor*, u32) -> const sead::Vector3f&

void setColliderRadius(LiveActor*, f32)

void setColliderOffsetY(LiveActor*, f32)

auto getColliderRadius(const LiveActor*) -> f32

auto getColliderOffsetY(const LiveActor*) -> f32

void getColliderFixReaction(const LiveActor*)

void calcColliderPos(sead::Vector3f*, const LiveActor*)

void validateColliderRobustCheck(LiveActor*)

void invalidateColliderRobustCheck(LiveActor*)

void setColliderReactMovePower(LiveActor*, bool)

void calcColliderFloorRotatePower(sead::Quatf*, LiveActor*)

void calcJumpInertia(sead::Vector3f*, LiveActor*, const sead::Vector3f&, f32)

auto isCollidedGround(const LiveActor*) -> bool

void calcJumpInertiaWall(sead::Vector3f*, LiveActor*, f32)

auto isCollidedWall(const LiveActor*) -> bool

void scaleVelocityInertiaWallHit(LiveActor*, f32, f32, f32)

auto getCollidedWallNormal(const LiveActor*) -> const sead::Vector3f&

void calcCollidedNormalSum(const LiveActor*, sead::Vector3f*)

void calcGroundNormalOrUpDir(sead::Vector3f*, const LiveActor*)

auto getCollidedGroundNormal(const LiveActor*) -> const sead::Vector3f&

void calcGroundNormalOrGravityDir(sead::Vector3f*, const LiveActor*)

void setColliderFilterTriangle(LiveActor*, const TriangleFilterBase*)

void setColliderFilterCollisionParts(LiveActor*, const CollisionPartsFilterBase*)

void createAndSetColliderFilterExistActor(LiveActor*)

void createAndSetColliderFilterExistActor(LiveActor*, LiveActor*)

void createAndSetColliderFilterSubActor(LiveActor*)

void createAndSetColliderSpecialPurpose(LiveActor*, const char*)

void createAndSetColliderSpecialPurposeForCollisionActor(LiveActor*, const char*)

void createAndSetColliderIgnoreOptionalPurpose(LiveActor*, const char*)

void createAndSetColliderSpecialAndIgnoreOptionalPurpose(LiveActor*, const char*, const char*)

void createActorCollisionController(LiveActor*)

void setColliderRadius(ActorCollisionController*, f32)

void setColliderRadiusScale(ActorCollisionController*, f32)

void setColliderOffsetY(ActorCollisionController*, f32)

void resetActorCollisionController(ActorCollisionController*, s32)

void updateActorCollisionController(ActorCollisionController*)

auto getCollidedFloorMaterialCodeName(const LiveActor*) -> const char*

auto getCollidedFloorMaterialCodeName(const Collider*) -> const char*

auto getCollidedWallMaterialCodeName(const LiveActor*) -> const char*

auto getCollidedCeilingMaterialCodeName(const LiveActor*) -> const char*

auto isCollidedFloorCode(const LiveActor*, const char*) -> bool

auto isCollidedCollisionCode(const LiveActor*, const char*, const char*) -> bool

auto isCollidedWallCode(const LiveActor*, const char*) -> bool

auto isCollidedCameraCode(const LiveActor*, const char*) -> bool

auto isCollidedMaterialCode(const LiveActor*, const char*) -> bool

auto isCollidedGroundFloorCode(const LiveActor*, const char*) -> bool

auto isCollidedGroundCollisionCode(const LiveActor*, const char*, const char*) -> bool

auto isCollided(const LiveActor*) -> bool

auto isCollidedCeiling(const LiveActor*) -> bool

auto isCollidedWallFace(const LiveActor*) -> bool

auto isCollidedVelocity(const LiveActor*) -> bool

auto isCollidedWallVelocity(const LiveActor*) -> bool

auto isCollidedCeilingVelocity(const LiveActor*) -> bool

auto getCollidedCeilingNormal(const LiveActor*) -> const sead::Vector3f&

auto getCollidedGroundPos(const LiveActor*) -> const sead::Vector3f&

auto getCollidedWallPos(const LiveActor*) -> const sead::Vector3f&

auto getCollidedCeilingPos(const LiveActor*) -> const sead::Vector3f&

void calcSpeedCollideWall(const LiveActor*)

void calcSpeedCollideGround(const LiveActor*)

void calcSpeedCollideCeiling(const LiveActor*)

void getCollidedGroundCollisionParts(const LiveActor*)

auto tryGetCollidedGroundCollisionParts(const LiveActor*) -> bool

void getCollidedWallCollisionParts(const LiveActor*)

auto tryGetCollidedWallCollisionParts(const LiveActor*) -> bool

void getCollidedCeilingCollisionParts(const LiveActor*)

auto tryGetCollidedCeilingCollisionParts(const LiveActor*) -> bool

void getCollidedGroundSensor(const LiveActor*)

auto tryGetCollidedGroundSensor(const LiveActor*) -> HitSensor*

auto getCollidedWallSensor(const LiveActor*) -> HitSensor*

auto tryGetCollidedWallSensor(const LiveActor*) -> HitSensor*

auto getCollidedCeilingSensor(const LiveActor*) -> HitSensor*

auto tryGetCollidedCeilingSensor(const LiveActor*) -> HitSensor*

auto tryGetCollidedSensor(const LiveActor*) -> HitSensor*

auto tryGetCollidedPos(sead::Vector3f*, const LiveActor*) -> bool

void setForceCollisionScaleOne(const LiveActor*)

void followRotateFrontAxisUpGround(LiveActor*)

void followRotateFrontAxisUp(LiveActor*, const CollisionParts*)

auto isAlive(const LiveActor* actor) -> bool

auto isDead(const LiveActor* actor) -> bool

auto isNoCollide(const LiveActor* actor) -> bool

void onCalcAnim(LiveActor* actor)

void offCalcAnim(LiveActor* actor)

void validateShadow(LiveActor* actor)

void invalidateShadow(LiveActor* actor)

void onCollide(LiveActor* actor)

void offCollide(LiveActor* actor)

void validateMaterialCode(LiveActor* actor)

void invalidateMaterialCode(LiveActor* actor)

void validatePuddleMaterial(LiveActor* actor)

void invalidatePuddleMaterial(LiveActor* actor)

auto isAreaTarget(const LiveActor* actor) -> bool

void onAreaTarget(LiveActor* actor)

void offAreaTarget(LiveActor* actor)

auto isUpdateMovementEffectAudioCollisionSensor(const LiveActor* actor) -> bool

void onUpdateMovementEffectAudioCollisionSensor(LiveActor* actor)

void offUpdateMovementEffectAudioCollisionSensor(LiveActor* actor)

void initActorSceneInfo(LiveActor* actor, const ActorInitInfo& info)

void initExecutorUpdate(LiveActor* actor, const ActorInitInfo& info, const char*)

void initExecutorDraw(LiveActor* actor, const ActorInitInfo& info, const char*)

void initExecutorPlayer(LiveActor* actor, const ActorInitInfo& info)

void initExecutorPlayerPreMovement(LiveActor* actor, const ActorInitInfo& info)

void initExecutorPlayerMovement(LiveActor* actor, const ActorInitInfo& info)

void initExecutorPlayerModel(LiveActor* actor, const ActorInitInfo& info)

void initExecutorPlayerDecoration(LiveActor* actor, const ActorInitInfo& info)

void initExecutorEnemy(LiveActor* actor, const ActorInitInfo& info)

void initExecutorEnemyMovement(LiveActor* actor, const ActorInitInfo& info)

void initExecutorEnemyDecoration(LiveActor* actor, const ActorInitInfo& info)

void initExecutorEnemyDecorationMovement(LiveActor* actor, const ActorInitInfo& info)

void initExecutorMapObj(LiveActor* actor, const ActorInitInfo& info)

void initExecutorMapObjMovement(LiveActor* actor, const ActorInitInfo& info)

void initExecutorMapObjDecoration(LiveActor* actor, const ActorInitInfo& info)

void initExecutorNpcDecoration(LiveActor* actor, const ActorInitInfo& info)

void initExecutorShadowVolume(LiveActor* actor, const ActorInitInfo& info)

void initExecutorShadowVolumeFillStencil(LiveActor* actor, const ActorInitInfo& info)

void initExecutorCollisionMapObjDecorationMovement(LiveActor* actor, const ActorInitInfo& info)

void initExecutorWatchObj(LiveActor* actor, const ActorInitInfo& info)

void initExecutorDebugMovement(LiveActor* actor, const ActorInitInfo& info)

void initExecutorModelUpdate(LiveActor* actor, const ActorInitInfo& info)

void initExecutorDrcAssistMovement(LiveActor* actor, const ActorInitInfo& info)

void initActorPoseTRSV(LiveActor* actor)

void initActorPoseTRMSV(LiveActor* actor)

void initActorPoseTRGMSV(LiveActor* actor)

void initActorPoseTFSV(LiveActor* actor)

void initActorPoseTFUSV(LiveActor* actor)

void initActorPoseTFGSV(LiveActor* actor)

void initActorPoseTQSV(LiveActor* actor)

void initActorPoseTQGSV(LiveActor* actor)

void initActorPoseTQGMSV(LiveActor* actor)

void initActorSRT(LiveActor* actor, const ActorInitInfo& info)

void initActorModelKeeper(LiveActor*, const ActorInitInfo&, const ActorResource*, s32)

void initActorModelKeeper(LiveActor*, const ActorInitInfo&, const char*, s32, const char*)

void initActorModelKeeperByHost(LiveActor*, const LiveActor*)

void initActorModelForceCubeMap(LiveActor*, const ActorInitInfo&)

void initActorActionKeeper(LiveActor*, const ActorInitInfo&, const char*, const char*)

void initActorActionKeeper(LiveActor*, const ActorResource*, const char*, const char*)

void initActorEffectKeeper(LiveActor*, const ActorInitInfo&, const char*)

void initActorSeKeeper(LiveActor*, const ActorInitInfo&, const char*, const sead::Vector3f*, const sead::Matrix34f*)

void initActorSeKeeper(LiveActor*, const ActorInitInfo&, const char*)

void initActorSeKeeperWithout3D(LiveActor*, const ActorInitInfo&, const char*)

void initActorBgmKeeper(LiveActor*, const ActorInitInfo&, const char*)

auto isInitializedBgmKeeper(LiveActor*) -> bool

void initHitReactionKeeper(LiveActor*, const char*)

void initHitReactionKeeper(LiveActor*, const Resource*, const char*)

void initActorParamHolder(LiveActor*, const char*)

void initActorParamHolder(LiveActor*, const Resource*, const char*)

void initDepthShadowMapCtrl(LiveActor*, const Resource*, const ActorInitInfo&, const char*)

void initDepthShadowMapCtrlWithoutIter(LiveActor*, s32, bool)

void addDepthShadowMapInfo(const LiveActor*, const char*, s32, s32, s32, f32, bool, const sead::Vector3f&, bool, const sead::Vector3f&, const sead::Vector3f&, bool, const char*, s32, bool, f32, f32, f32, bool, bool, f32, s32, bool)

void declareUseDepthShadowMap(const LiveActor*, s32)

void createDepthShadowMap(const LiveActor*, const char*, s32, s32, s32)

void initShadowMaskCtrl(LiveActor*, const ActorInitInfo&, const ByamlIter&, const char*)

void initShadowMaskCtrlWithoutInitFile(LiveActor*, const ActorInitInfo&, s32)

void createShadowMaskSphere(LiveActor*, const char*, const char*, const char*)

void createShadowMaskCube(LiveActor*, const char*, const char*, const char*, const sead::Color4f&, const sead::Vector3f&, f32, f32, f32, const sead::Vector3f&, f32)

void createShadowMaskCylinder(LiveActor*, const char*, const char*, const char*, const sead::Color4f&, const sead::Vector3f&, f32, f32, f32, f32, f32)

void createShadowMaskCastOvalCylinder(LiveActor*, const char*, const char*, const char*, const sead::Color4f&, const sead::Vector3f&, const sead::Vector3f&, f32, f32, f32, f32)

void initActorCollision(LiveActor*, const sead::SafeString&, HitSensor*, const sead::Matrix34f*)

void initActorCollisionWithResource(LiveActor*, const Resource*, const sead::SafeString&, HitSensor*, const sead::Matrix34f*, const char*)

void initActorCollisionWithArchiveName(LiveActor*, const sead::SafeString&, const sead::SafeString&, HitSensor*, const sead::Matrix34f*)

void initActorCollisionWithFilePtr(LiveActor*, void*, const void*, HitSensor*, const sead::Matrix34f*, const char*, const char*, s32)

void initStageSwitch(LiveActor*, const ActorInitInfo&)

void initActorItemKeeper(LiveActor*, const ActorInitInfo&, const ByamlIter&)

auto initActorPrePassLightKeeper(LiveActor*, const Resource*, const ActorInitInfo&, const char*) -> bool

void initActorOcclusionKeeper(LiveActor*, const Resource*, const ActorInitInfo&, const char*)

void initSubActorKeeper(LiveActor*, const ActorInitInfo&, const char*, s32)

void initSubActorKeeperNoFile(LiveActor*, const ActorInitInfo&, s32)

void registerSubActor(LiveActor*, LiveActor*)

void registerSubActorSyncClipping(LiveActor*, LiveActor*)

void registerSubActorSyncClippingAndHide(LiveActor*, LiveActor*)

void registerSubActorSyncAll(LiveActor*, LiveActor*)

void setSubActorOffSyncClipping(LiveActor*)

void initScreenPointKeeper(LiveActor*, const Resource*, const ActorInitInfo&, const char*)

void initScreenPointKeeperNoYaml(LiveActor*, s32)

void initActorMaterialCategory(LiveActor*, const ActorInitInfo&, const char*)

void initActor(LiveActor* actor, const ActorInitInfo& initInfo)

if(poseId ! = -1)

if(!tryGetActorInitFileIter&,, "", suffix) return

if(!initPose.tryGetStringByKey&, "" Pose) return

if(! initActorPoseKeeperpose, actor) return

if(isEqualString(pose, "TFUSV") && tryGetByamlKeyBoolOrFalse(initPose, "IsFrontUp"))

if(!tryGetByamlScale&,, "" Scale) return

setScale(actor, scale)

if(isExistModel(actor))

auto init(initLod) -> modelLodCtrl

initActorModelKeeper(actor, initInfo, actorResource, blendAnimMax)

if(displayRootJointName ! = nullptr)

if(isCreateUniqShader)

if(partialAnimGroupNum>= 1) initPartialSklAnim(actor

if(isFixedModel)

if(isIgnoreUpdateOnDrawClipping) setIgnoreUpdateDrawClipping(actor

auto setModelLodCtrl(modelLodCtrl) -> modelKeeper

if(modelLodCtrl)

auto getModelCtrl() -> modelKeeper

if(isCalcViewCore1)

if(isCalcViewCore2)

if(initExecutor.tryGetIterByKey&, ""Updater && iter. isTypeArray())

if(initExecutor.tryGetIterByKey&, "" Drawer)

if(numSensors<= 0) return

auto initHitSensor(numSensors) -> actor

if(name = =nullptr) name

if(initCollision.tryGetStringByKey&, "" Sensor) sensor

if(joint ! = nullptr) jointMtx

initActorCollisionWithResource(actor, modelRes, name, sensor, jointMtx, suffix)

auto initCollider(radius, offset. y, planeNum) -> actor

if(!initEffect.tryGetStringByKey&, "" Name) return

initActorEffectKeeper(actor, initInfo, name)

if(tryGetActorInitFileIter&,, "", suffix)

if(seName ! = nullptr) initActorSeKeeper(actor

if(initSound. isExistKey"BgmUserName") initActorBgmKeeper(actor

if(!initClipping.tryGetIterByKey&, "" GroupClipping) return

initGroupClipping(actor, initInfo)

initActorClipping(actor, initInfo)

if(invalidate)

if(initClipping.tryGetFloatByKey&, "" Radius)

auto if(actor-> getModelKeeper()) -> else

if(tryGetByamlBox3f&,, "" Obb) setClippingObb(actor

initActorGroupClipping(actor, initInfo, initClipping)

initDepthShadowMapCtrl(actor, modelRes, initInfo, suffix)

initShadowMaskCtrl(actor, initInfo, initShadowMask, "InitShadowMask")

if(usingDepthShadow)

if(initFlag.tryGetIterByKey&, "" MaterialCode)

initActorItemKeeper(actor, initInfo, initItem)

auto initScoreKeeper() -> actor

auto getActorScoreKeeper() -> actor

initActorActionKeeper(actor, actorResource, archiveName, suffix)

if(!actor-> getModelKeeper()) return

if(! tryStartActionactor, archiveName)

if(! modelKeeper) return

if(ditherAnimator)

void initActorImpl(LiveActor* actor, const ActorInitInfo& initInfo, const sead::SafeString& folderName, const sead::SafeString& fileName, const char* suffix)

void initActorSuffix(LiveActor* actor, const ActorInitInfo& initInfo, const char* suffix)

void initActorChangeModel(LiveActor* actor, const ActorInitInfo& initInfo)

auto getModelName(const ActorInitInfo& initInfo) -> const char*

void initActorChangeModelSuffix(LiveActor* actor, const ActorInitInfo& initInfo, const char* suffix)

void initActorWithArchiveName(LiveActor* actor, const ActorInitInfo& initInfo, const sead::SafeString& archiveName, const char* suffix)

void initChildActorWithArchiveNameWithPlacementInfo(LiveActor* actor, const ActorInitInfo& initInfo, const sead::SafeString& archiveName, const char* suffix)

void initChildActorWithArchiveNameNoPlacementInfo(LiveActor* actor, const ActorInitInfo& initInfo, const sead::SafeString& archiveName, const char* suffix)

auto createChildLinkSimpleActor(const char* actorName, const char* linkName, const ActorInitInfo& initInfo, bool alive) -> LiveActor*

auto createChildLinkMapPartsActor(const char* actorName, const char* linkName, const ActorInitInfo& initInfo, s32 linkIndex, bool alive) -> LiveActor*

void initMapPartsActor(LiveActor* actor, const ActorInitInfo& initInfo, const char* suffix)

void initLinksActor(LiveActor* actor, const ActorInitInfo& initInfo, const char* suffix, s32 linkIndex)

auto createLinksPlayerActorInfo(LiveActor* actor, const ActorInitInfo& initInfo) -> ActorInitInfo*

auto getLinksActorClassName(const ActorInitInfo& initInfo, const char* linkName, s32 linkIndex) -> const char*

auto getLinksActorDisplayName(const ActorInitInfo& initInfo, const char* linkName, s32 linkIndex) -> const char*

auto getLinksActorObjectName(const ActorInitInfo& initInfo, const char* linkName, s32 linkIndex) -> const char*

void initCreateActorWithPlacementInfo(LiveActor* actor, const ActorInitInfo& initInfo)

void initCreateActorWithPlacementInfo(LiveActor* actor, const ActorInitInfo& initInfo, const PlacementInfo& placementInfo)

void initCreateActorNoPlacementInfo(LiveActor* actor, const ActorInitInfo& initInfo)

void initCreateActorNoPlacementInfoNoViewId(LiveActor* actor, const ActorInitInfo& initInfo)

if(creationFunction = =nullptr) return nullptr

auto init(childInitInfo) -> actor

auto createPlacementActorFromFactory(const ActorInitInfo& initInfo, const PlacementInfo* placementInfo) -> LiveActor*

auto createLinksActorFromFactory(const ActorInitInfo& initInfo, const char* linkName, s32 linkNum) -> LiveActor*

auto createLinksActorGroupFromFactory(const ActorInitInfo& initInfo, const char* linkName, const char* groupName) -> LiveActorGroup*

auto tryCreateLinksActorGroupFromFactory(const ActorInitInfo& initInfo, const char* linkName, const char* groupName) -> LiveActorGroup*

auto tryCreateLinksActorFromFactorySingle(const ActorInitInfo& initInfo, const char* linkName) -> LiveActor*

void createAndRegisterLinksActorFromFactory(LiveActorGroup* group, const ActorInitInfo& initInfo, const char* linkName)

void makeMapPartsModelName(sead::BufferedSafeString* modelName, sead::BufferedSafeString* path, const PlacementInfo& placementInfo)

void makeMapPartsModelName(sead::BufferedSafeString* modelName, sead::BufferedSafeString* path, const ActorInitInfo& initInfo)

auto tryGetMapPartsSuffix(const ActorInitInfo& initInfo, const char* suffix) -> const char*

void initMapPartsActorWithArchiveName(LiveActor* actor, const ActorInitInfo& initInfo, const char* fileName, const char* suffix)

void initNerve(LiveActor* actor, const Nerve* nerve, s32 maxStates)

void initNerveAction(LiveActor* actor, const char* actionName, alNerveFunction::NerveActionCollector* collector, s32 maxStates)

auto trySyncStageSwitchAppear(LiveActor* actor) -> bool

auto trySyncStageSwitchKill(LiveActor* actor) -> bool

auto trySyncStageSwitchAppearAndKill(LiveActor* actor) -> bool

auto tryListenStageSwitchAppear(LiveActor* actor) -> bool

auto tryListenStageSwitchKill(LiveActor* actor) -> bool

void syncSensorScaleY(LiveActor* actor)

void syncSensorAndColliderScaleY(LiveActor* actor)

void setMaterialCode(LiveActor* actor, const char* materialCode)

void initMaterialCode(LiveActor* actor, const ActorInitInfo& initInfo)

auto tryAddDisplayRotate(LiveActor* actor, const ActorInitInfo& initInfo) -> bool

auto tryAddDisplayOffset(LiveActor* actor, const ActorInitInfo& initInfo) -> bool

auto tryAddDisplayScale(LiveActor* actor, const ActorInitInfo& initInfo) -> bool

auto getPlacementInfo(const ActorInitInfo& initInfo) -> const PlacementInfo&

auto getLayoutInitInfo(const ActorInitInfo& initInfo) -> const LayoutInitInfo&

auto getAudioDirector(const ActorInitInfo& initInfo) -> AudioDirector*

auto getCollisionDirectorFromInfo(const ActorInitInfo& initInfo) -> CollisionDirector*

auto getSceneCameraInfoFromInfo(const ActorInitInfo& initInfo) -> const SceneCameraInfo*

auto getGraphicsSystemInfo(const ActorInitInfo& initInfo) -> GraphicsSystemInfo*

auto getDrawContext(const ActorInitInfo& initInfo) -> agl::DrawContext*

void getActorRecourseDataF32(f32* val, LiveActor* actor, const char* fileName, const char* entryName)

void getActorRecourseDataString(const char** val, LiveActor* actor, const char* fileName, const char* entryName)

void getActorRecourseDataV3f(sead::Vector3f* val, LiveActor* actor, const char* fileName, const char* entryName)

void getActorRecourseDataBox3f(sead::BoundBox3f* box, LiveActor* actor, const char* fileName, const char* entryName)

auto createPartsEffectGroup(LiveActor* actor, const ActorInitInfo& initInfo, s32 maxEffects) -> PartsEffectGroup*

void updateMaterialCodeGround(LiveActor* actor, const char*)

void updateMaterialCodeAll(LiveActor* actor)

void updateMaterialCodeArea(LiveActor* actor)

void updateMaterialCodeWet(LiveActor* actor, bool)

void updateMaterialCodeWater(LiveActor* actor)

void updateMaterialCodeWater(LiveActor* actor, bool)

void updateMaterialCodePuddle(LiveActor* actor)

void updateMaterialCodePuddle(LiveActor* actor, bool)

void resetMaterialCode(LiveActor* actor)

void showModel(LiveActor* actor)

void showModelIfHide(LiveActor* actor)

auto isHideModel(const LiveActor* actor) -> bool

void hideModel(LiveActor* actor)

void hideModelIfShow(LiveActor* actor)

auto isExistModel(const LiveActor* actor) -> bool

void switchShowHideModelIfNearCamera(LiveActor* actor, f32)

auto blinkModel(LiveActor* actor, s32, s32, s32) -> bool

void calcViewModelSystem(LiveActor* actor)

void calcViewModel(LiveActor* actor)

void showSilhouetteModel(LiveActor* actor)

void hideSilhouetteModel(LiveActor* actor)

auto isSilhouetteModelHidden(const LiveActor* actor) -> bool

void showSilhouetteModelIfHide(LiveActor* actor)

void hideSilhouetteModelIfShow(LiveActor* actor)

void setModelAlphaMask(LiveActor* actor, f32)

auto getModelAlphaMask(const LiveActor* actor) -> f32

auto isModelAlphaMask(const LiveActor* actor) -> bool

void updateModelAlphaMaskCameraDistance(LiveActor* actor, f32, f32, f32, f32)

auto isExistZPrePass(const LiveActor* actor) -> bool

auto isEnableZPrePass(const LiveActor* actor) -> bool

void validateZPrePass(LiveActor* actor)

void invalidateZPrePass(LiveActor* actor)

void invalidateOcclusionQuery(LiveActor* actor)

void validateOcclusionQuery(LiveActor* actor)

auto isValidOcclusionQuery(const LiveActor* actor) -> bool

void setFixedModelFlag(LiveActor* actor)

void tryInitFixedModelGpuBuffer(LiveActor* actor)

void setIgnoreUpdateDrawClipping(LiveActor* actor, bool value)

void setNeedSetBaseMtxAndCalcAnimFlag(LiveActor* actor, bool value)

auto isViewDependentModel(const LiveActor* actor) -> bool

auto isNeedUpdateModel(const LiveActor* actor) -> bool

void setEnvTextureMirror(LiveActor* actor, s32)

void setEnvTextureProc3D(LiveActor* actor, s32)

void forceApplyCubeMap(LiveActor* actor, const char* cubeMapName)

void setMaterialProgrammable(LiveActor* actor)

auto isIncludePrepassCullingShape(LiveActor* actor) -> bool

auto isExistJoint(const LiveActor* actor, const char*) -> bool

auto getJointIndex(const LiveActor* actor, const char*) -> s32

auto getJointMtxPtr(const LiveActor* actor, const char*) -> sead::Matrix34f*

auto getJointMtxPtrByIndex(const LiveActor* actor, s32) -> sead::Matrix34f*

void getJointLocalTrans(sead::Vector3f*, const LiveActor* actor, const char*)

void calcJointPos(sead::Vector3f*, const LiveActor* actor, const char*)

void calcJointOffsetPos(sead::Vector3f*, const LiveActor* actor, const char*, const sead::Vector3f&)

void calcJointPosByIndex(sead::Vector3f*, const LiveActor* actor, s32)

void calcJointSideDir(sead::Vector3f*, const LiveActor* actor, const char*)

void calcJointUpDir(sead::Vector3f*, const LiveActor* actor, const char*)

void calcJointFrontDir(sead::Vector3f*, const LiveActor* actor, const char*)

void calcJointScale(sead::Vector3f*, const LiveActor* actor, const char*)

void calcJointQuat(sead::Quatf*, const LiveActor* actor, const char*)

void multVecJointMtx(sead::Vector3f*, const sead::Vector3f&, const LiveActor* actor, const char*)

void multVecJointInvMtx(sead::Vector3f*, const sead::Vector3f&, const LiveActor* actor, const char*)

void multMtxJointInvMtx(sead::Matrix34f*, const sead::Matrix34f&, const LiveActor* actor, const char*)

void setJointVisibility(LiveActor* actor, const char*, bool)

auto isJointVisibility(const LiveActor* actor, const char*) -> bool

auto isFaceJointXDirDegreeYZ(const LiveActor* actor, const char*, const sead::Vector3f&, f32, f32) -> bool

auto isFaceJointYDirDegreeZX(const LiveActor* actor, const char*, const sead::Vector3f&, f32, f32) -> bool

auto isFaceJointZDirDegreeXY(const LiveActor* actor, const char*, const sead::Vector3f&, f32, f32) -> bool

void calcJointAngleXDirToTargetOnYDir(const LiveActor* actor, const char*, const sead::Vector3f&)

void calcJointAngleXDirToTargetOnZDir(const LiveActor* actor, const char*, const sead::Vector3f&)

void calcJointAngleYDirToTargetOnXDir(const LiveActor* actor, const char*, const sead::Vector3f&)

void calcJointAngleYDirToTargetOnZDir(const LiveActor* actor, const char*, const sead::Vector3f&)

void calcJointAngleZDirToTargetOnXDir(const LiveActor* actor, const char*, const sead::Vector3f&)

void calcJointAngleZDirToTargetOnYDir(const LiveActor* actor, const char*, const sead::Vector3f&)

auto getMaterialName(const LiveActor* actor, s32) -> const char*

auto getMaterialCount(const LiveActor* actor) -> s32

auto isExistMaterial(const LiveActor* actor, const char*) -> bool

void getMaterialObj(const LiveActor* actor, s32)

void getMaterialObj(const LiveActor* actor, const char*)

auto getMaterialIndex(const LiveActor* actor, const char*) -> s32

auto isExistMaterialTexture(const LiveActor* actor, const char*, const char*) -> bool

void getMaterialCategory(const LiveActor* actor, s32)

void tryGetMaterialCategory(const LiveActor* actor, s32)

auto isOnlyMaterialCategoryObject(const LiveActor* actor) -> bool

void showMaterial(LiveActor* actor, const char*)

void hideMaterial(LiveActor* actor, const char*)

void showMaterial(LiveActor* actor, s32)

void hideMaterial(LiveActor* actor, s32)

void showMaterialAll(LiveActor* actor)

void tryShowMaterial(LiveActor* actor, s32)

void tryHideMaterial(LiveActor* actor, s32)

void tryShowMaterialAll(LiveActor* actor)

void setModelMaterialParameterF32(const LiveActor* actor, s32, const char*, f32)

void setModelMaterialParameterF32(const LiveActor* actor, const char*, const char*, f32)

void setModelMaterialParameterV2F(const LiveActor* actor, s32, const char*, const sead::Vector2f&)

void setModelMaterialParameterV2F(const LiveActor* actor, const char*, const char*, const sead::Vector2f&)

void setModelMaterialParameterV3F(const LiveActor* actor, s32, const char*, const sead::Vector3f&)

void setModelMaterialParameterV3F(const LiveActor* actor, const char*, const char*, const sead::Vector3f&)

void setModelMaterialParameterV4F(const LiveActor* actor, s32, const char*, const sead::Vector4f&)

void setModelMaterialParameterV4F(const LiveActor* actor, const char*, const char*, const sead::Vector4f&)

void setModelMaterialParameterRgb(const LiveActor* actor, s32, const char*, const sead::Vector3f&)

void setModelMaterialParameterRgb(const LiveActor* actor, const char*, const char*, const sead::Vector3f&)

void setModelMaterialParameterRgb(const LiveActor* actor, s32, const char*, const sead::Color4f&)

void setModelMaterialParameterRgb(const LiveActor* actor, const char*, const char*, const sead::Color4f&)

void setModelMaterialParameterRgba(const LiveActor* actor, s32, const char*, const sead::Color4f&)

void setModelMaterialParameterRgba(const LiveActor* actor, const char*, const char*, const sead::Color4f&)

void setModelMaterialParameterAlpha(const LiveActor* actor, s32, const char*, f32)

void setModelMaterialParameterAlpha(const LiveActor* actor, const char*, const char*, f32)

void setModelMaterialParameterTextureTrans(const LiveActor* actor, const char*, s32, const sead::Vector2f&)

void getModelMaterialParameterDisplacementScale(const LiveActor* actor, const char*, s32)

void setModelMaterialParameterDisplacementScale(const LiveActor* actor, const char*, s32, f32)

void getModelUniformBlock(const LiveActor* actor, const char*)

void findModelUniformBlock(const LiveActor* actor, const char*)

void swapModelUniformBlock(agl::UniformBlock*)

void flushModelUniformBlock(agl::UniformBlock*)

void getModelDrawCategoryFromShaderAssign(bool*, bool*, bool*, bool*, const LiveActor* actor)

void trySetOcclusionQueryBox(LiveActor* actor, f32)

void trySetOcclusionQueryBox(LiveActor* actor, const sead::BoundBox3f&)

void trySetOcclusionQueryCenter(LiveActor* actor, const sead::Vector3f*)

auto getModelName(const LiveActor* actor) -> const char*

auto isModelName(const LiveActor* actor, const char*) -> bool

auto calcModelBoundingSphereRadius(const LiveActor* actor) -> f32

void getBoundingSphereCenterAndRadius(sead::Vector3f*, f32*, const LiveActor* actor)

void calcModelBoundingBox(sead::BoundBox3f*, const LiveActor* actor)

void calcModelBoundingBoxMtx(sead::Matrix34f*, const LiveActor* actor)

void submitViewModel(const LiveActor* actor, const sead::Matrix34f&)

void replaceMaterialTextureRef(LiveActor* actor, nn::g3d::TextureRef*, const char*, const char*)

void replaceMaterialResTexture(LiveActor* actor, nn::gfx::ResTexture*, const char*, const char*)

void replaceMaterialResTexture(LiveActor*, const char*, const char*, nn::gfx::DescriptorSlot, const nn::gfx::TextureView*)

void replaceMaterialLayoutTexture(LiveActor* actor, const LayoutTextureRenderObj*, const char*, const char*)

void recreateModelDisplayList(const LiveActor* actor)

void calcPolygonNum(const LiveActor* actor, s32)

void calcPolygonNumCurrentLod(const LiveActor* actor)

void calcPolygonNumCurrentLodWithoutVisAnim(const LiveActor* actor)

void getLodLevel(const LiveActor* actor)

void getMaterialLodLevel(const LiveActor* actor)

void getLodLevelNoClamp(const LiveActor* actor)

auto getLodModelCount(const LiveActor* actor) -> s32

void forceLodLevel(LiveActor* actor, s32)

void unforceLodLevel(LiveActor* actor)

auto isExistLodModel(const LiveActor* actor) -> bool

auto isEnableMaterialLod(const LiveActor* actor) -> bool

void validateLodModel(LiveActor* actor)

void invalidateLodModel(LiveActor* actor)

auto isValidateLodModel(const LiveActor* actor) -> bool

auto isExistDitherAnimator(const LiveActor* actor) -> bool

auto isValidNearDitherAnim(const LiveActor* actor) -> bool

void stopDitherAnimAutoCtrl(LiveActor* actor)

void restartDitherAnimAutoCtrl(LiveActor* actor)

void validateDitherAnim(LiveActor* actor)

void invalidateDitherAnim(LiveActor* actor)

void validateFarDitherIfInvalidateClipping(LiveActor* actor)

void setDitherAnimSphereRadius(LiveActor* actor, f32)

void setDitherAnimBoundingBox(LiveActor* actor, const sead::Vector3f&)

void setDitherAnimMaxAlpha(LiveActor* actor, f32)

void setDitherAnimClippingJudgeLocalOffset(LiveActor* actor, const sead::Vector3f&)

void setDitherAnimClippingJudgeParam(LiveActor* actor, const char*)

void resetDitherAnimClippingJudgeParam(LiveActor* actor)

void getDitherAnimMinNearDitherAlpha(const LiveActor* actor)

auto getDitherAnimNearClipStartDistance(const LiveActor* actor) -> f32

auto getDitherAnimNearClipEndDistance(const LiveActor* actor) -> f32

void calcDitherAnimJudgeDistance(const LiveActor* actor)

void createUniqueShader(LiveActor* actor)

auto isJudgedToClipFrustum(const ClippingDirector*, const sead::Vector3f&, f32, f32) -> bool

auto isJudgedToClipFrustum(const LiveActor* actor, const sead::Vector3f&, f32, f32) -> bool

auto isJudgedToClipFrustum(const LiveActor* actor, f32, f32) -> bool

auto isJudgedToClipFrustumWithoutFar(const ClippingDirector*, const sead::Vector3f&, f32, f32) -> bool

auto isJudgedToClipFrustumWithoutFar(const LiveActor* actor, const sead::Vector3f&, f32, f32) -> bool

auto isJudgedToClipFrustumWithoutFar(const LiveActor* actor, f32, f32) -> bool

auto modDegree(f32 deg) -> f32

void resetPosition(LiveActor* actor)

void resetPosition(LiveActor* actor, const sead::Vector3f& trans)

void resetRotatePosition(LiveActor* actor, const sead::Vector3f& rot, const sead::Vector3f& trans)

void resetQuatPosition(LiveActor* actor, const sead::Quatf& quat, const sead::Vector3f& trans)

void resetMtxPosition(LiveActor* actor, const sead::Matrix34f& mtx)

void resetActorPosition(LiveActor* actor, const LiveActor* target)

auto trySetPosOnGround(LiveActor* actor) -> bool

auto getVelocity(const LiveActor* actor) -> const sead::Vector3f&

auto getVelocityPtr(LiveActor* actor) -> sead::Vector3f*

void separateVelocityHV(sead::Vector3f* horizontal, sead::Vector3f* vertical, const LiveActor* actor)

void separateVelocityDirHV(sead::Vector3f* horizontal, sead::Vector3f* vertical, const LiveActor* actor, const sead::Vector3f& dir)

void separateVelocityParallelVertical(sead::Vector3f* parallel, sead::Vector3f* vertical, const LiveActor* actor, const sead::Vector3f& dir)

void setVelocity(LiveActor* actor, const sead::Vector3f& vel)

void setVelocity(LiveActor* actor, f32 x, f32 y, f32 z)

void setVelocityX(LiveActor* actor, f32 x)

void setVelocityY(LiveActor* actor, f32 y)

void setVelocityZ(LiveActor* actor, f32 z)

void setVelocityZero(LiveActor* actor)

void setVelocityZeroX(LiveActor* actor)

void setVelocityZeroY(LiveActor* actor)

void setVelocityZeroZ(LiveActor* actor)

void setVelocityZeroH(LiveActor* actor)

void setVelocityZeroH(LiveActor* actor, const sead::Vector3f& gravity)

void setVelocityZeroV(LiveActor* actor)

void setVelocityZeroV(LiveActor* actor, const sead::Vector3f& gravity)

void setVelocityJump(LiveActor* actor, f32 speed)

void setVelocityToFront(LiveActor* actor, f32 speed)

void setVelocityToUp(LiveActor* actor, f32 speed)

void setVelocityToSide(LiveActor* actor, f32 speed)

void setVelocityToDirection(LiveActor* actor, const sead::Vector3f& dir, f32 speed)

void setVelocityToGravity(LiveActor* actor, f32 speed)

void setVelocitySeparateHV(LiveActor* actor, const sead::Vector3f& h, const sead::Vector3f& v, f32 speedH, f32 speedV)

void setVelocitySeparateHV(LiveActor* actor, const sead::Vector3f& h, f32 speedH, f32 speedV)

void calcVelocitySeparateHV(sead::Vector3f* velocity, const LiveActor* actor, const sead::Vector3f& h, f32 speedH, f32 speedV)

void setVelocitySeparateUp(LiveActor* actor, const sead::Vector3f& h, f32 speedH, f32 speedV)

void setVelocityOnlyDir(LiveActor* actor, const sead::Vector3f& dir, f32 speed)

void setVelocityOnlyV(LiveActor* actor, f32 speed)

void setVelocityOnlyGravity(LiveActor* actor, f32 speed)

void addVelocity(LiveActor* actor, const sead::Vector3f& vel)

void addVelocity(LiveActor* actor, f32 x, f32 y, f32 z)

void addVelocityX(LiveActor* actor, f32 x)

void addVelocityY(LiveActor* actor, f32 y)

void addVelocityZ(LiveActor* actor, f32 z)

void addVelocityDump(LiveActor* actor, const sead::Vector3f& dir, f32 force)

void addVelocityJump(LiveActor* actor, f32 force)

void addVelocityInline(LiveActor* actor, const sead::Vector3f& vel, f32 force)

void addVelocityToFront(LiveActor* actor, f32 force)

void addVelocityToUp(LiveActor* actor, f32 force)

void addVelocityToSide(LiveActor* actor, f32 force)

void addVelocityToDown(LiveActor* actor, f32 force)

void addVelocityToDirection(LiveActor* actor, const sead::Vector3f& dir, f32 force)

void addVelocityToGravity(LiveActor* actor, f32 force)

void addVelocityToGravityLimit(LiveActor* actor, f32 force, f32 limit)

void addVelocityToGravityFittedGround(LiveActor* actor, f32 force, u32 maxAirTime)

void addVelocityToGravityNaturalOrFittedGround(LiveActor* actor, f32 force)

void calcGravityDir(sead::Vector3f* gravity, const LiveActor* actor)

void addVelocityToTarget(LiveActor* actor, const sead::Vector3f& target, f32 force)

void addVelocityToTarget(LiveActor* actor, const sead::Vector3f& target, f32 minForce, f32 maxForce, f32 minDistance, f32 maxDistance)

void addVelocityToTargetH(LiveActor* actor, const sead::Vector3f& target, f32 force)

void addVelocityToTargetHV(LiveActor* actor, const sead::Vector3f& target, f32 forceH, f32 forceV)

void addVelocityDampToTarget(LiveActor* actor, const sead::Vector3f& target, f32 forceDamp)

void addVelocityDampToTarget(LiveActor* actor, const sead::Vector3f& target, f32 force, f32 damp)

auto addVelocityToPlayer(LiveActor* actor, f32 force, const sead::Vector3f& offset) -> bool

auto addVelocityToPlayerHV(LiveActor* actor, f32 forceH, f32 forceV, const sead::Vector3f& offset) -> bool

void addVelocityFromTarget(LiveActor* actor, const sead::Vector3f& target, f32 force)

void addVelocityFromTargetHV(LiveActor* actor, const sead::Vector3f& target, f32 forceH, f32 forceV)

auto addVelocityFromPlayer(LiveActor* actor, f32 force, const sead::Vector3f& offset) -> bool

auto addVelocityFromPlayerHV(LiveActor* actor, f32 forceH, f32 forceV, const sead::Vector3f& offset) -> bool

void addVelocityClockwiseToDirection(LiveActor* actor, const sead::Vector3f& dir, f32 force)

auto calcVelocityClockwiseToDirection(LiveActor* actor, sead::Vector3f* dirVelocity, const sead::Vector3f& dir) -> bool

void addVelocityClockwiseToTarget(LiveActor* actor, const sead::Vector3f& target, f32 force)

void addVelocityJumpGroundInertia(LiveActor* actor, const sead::Vector3f& velocity, f32 force)

void tryAddVelocityLimit(LiveActor* actor, const sead::Vector3f& velocity, f32 limit)

void subVelocityExceptDirectionLimit(LiveActor* actor, const sead::Vector3f& direction, f32 subVel, f32 limit)

void scaleVelocity(LiveActor* actor, f32 factor)

void scaleVelocityLimit(LiveActor* actor, f32 factor, f32 limit)

void scaleVelocityX(LiveActor* actor, f32 factorX)

void scaleVelocityY(LiveActor* actor, f32 factorY)

void scaleVelocityZ(LiveActor* actor, f32 factorZ)

void scaleVelocityHV(LiveActor* actor, f32 factorH, f32 factorV)

void scaleVelocityDirection(LiveActor* actor, const sead::Vector3f& direction, f32 factor)

void scaleVelocityExceptDirection(LiveActor* actor, const sead::Vector3f& direction, f32 factor)

void scaleVelocityParallelVertical(LiveActor* actor, const sead::Vector3f& direction, f32 parallel, f32 vertical)

void limitVelocity(LiveActor* actor, f32 limit)

auto calcSpeed(const LiveActor* actor) -> f32

void limitVelocityX(LiveActor* actor, f32 limitX)

void limitVelocityY(LiveActor* actor, f32 limitY)

void limitVelocityZ(LiveActor* actor, f32 limitZ)

void limitVelocityH(LiveActor* actor, f32 limitH)

void limitVelocityHV(LiveActor* actor, f32 limitH, f32 limitV)

void limitVelocityUpGravityH(LiveActor* actor, f32 limitDown, f32 limitUp, f32 limitH)

void limitVelocityDir(LiveActor* actor, const sead::Vector3f& dir, f32 limit)

void limitVelocityDirSign(LiveActor* actor, const sead::Vector3f& dir, f32 limit)

void limitVelocityDirV(LiveActor* actor, const sead::Vector3f& dir, f32 limit)

void limitVelocityDirVRate(LiveActor* actor, const sead::Vector3f& dir, f32 limit, f32 rate)

void limitVelocityParallelVertical(LiveActor* actor, const sead::Vector3f& dir, f32 parallel, f32 vertical)

void limitVelocitySeparateHV(LiveActor* actor, const sead::Vector3f& dir, f32 horizontal, f32 vertical)

auto reboundVelocityPart(LiveActor* actor, f32 rebound, f32 threshold) -> u32

auto reboundVelocityPart(LiveActor* actor, f32 ground, f32 wall, f32 ceiling, f32 threshold) -> u32

auto reboundVelocityFromEachCollision(LiveActor* actor, f32 ground, f32 wall, f32 ceiling, f32 threshold) -> bool

auto reboundVelocityFromCollision(LiveActor* actor, f32 reboundStrength, f32 reboundMin, f32 friction) -> bool

auto reboundVelocityFromTriangles(LiveActor* actor, f32 reboundStrength, f32 reboundMin) -> bool

auto reboundVelocityFromActor(LiveActor* actor, const LiveActor* target, f32 reboundStrength) -> bool

if(dot<=0. 0f) return false

addVelocity(actor, direction*dot*-reboundStrength+1.0f)

auto reboundVelocityFromActor(LiveActor* actor, const LiveActor* target, const sead::Vector3f& targetVelocity, f32 reboundStrength) -> bool

auto reboundVelocityFromSensor(LiveActor* actor, const HitSensor* sensor, f32 reboundStrength) -> bool

auto reboundVelocityFromSensor(LiveActor* actor, const HitSensor* sensor, const sead::Vector3f& targetVelocity, f32 reboundStrength) -> bool

auto calcDirToActor(sead::Vector3f* dir, const LiveActor* actor, const LiveActor* target) -> bool

auto reboundVelocityBetweenActor(LiveActor* actor, LiveActor* target, const sead::Vector3f& direction, f32 reboundStrength) -> bool

auto reboundVelocityBetweenActor(LiveActor* actor, LiveActor* target, f32 reboundStrength) -> bool

auto reboundVelocityBetweenSensor(HitSensor* sensorA, HitSensor* sensorB, f32 reboundStrength) -> bool

void calcVelocityKeepLengthBetweenActor(sead::Vector3f* vel, const LiveActor* actor, const LiveActor* target, f32 targetLength, f32 force)

void addVelocityKeepLengthBetweenActor(LiveActor* actor, LiveActor* target, f32 targetLength, f32 force)

void addVelocityDumpKeepLengthBetweenActor(LiveActor* actor, LiveActor* target, f32 targetLength, f32 lenForce, f32 dumpForce)

void calcVelocityBlowAttack(sead::Vector3f* velocity, const LiveActor* actor, const sead::Vector3f& trans, f32 speedH, f32 speedV)

void addVelocityBlowAttack(LiveActor* actor, const sead::Vector3f& trans, f32 speedH, f32 speedV)

void addVelocityBlowAttack(LiveActor* actor, const HitSensor* sensor, f32 speedH, f32 speedV)

void setVelocityBlowAttack(LiveActor* actor, const sead::Vector3f& trans, f32 speedH, f32 speedV)

void setVelocityBlowAttack(LiveActor* actor, const HitSensor* sensor, f32 speedH, f32 speedV)

void setVelocityBlowAttackAndTurnToTarget(LiveActor* actor, const sead::Vector3f& target, f32 speedH, f32 speedV)

auto isVelocityFast(const LiveActor* actor, f32 threshold) -> bool

auto isVelocityFastH(const LiveActor* actor, f32 threshold) -> bool

auto isVelocitySlow(const LiveActor* actor, f32 threshold) -> bool

auto isVelocitySlowH(const LiveActor* actor, f32 threshold) -> bool

auto calcSpeedH(const LiveActor* actor) -> f32

auto calcSpeedV(const LiveActor* actor) -> f32

auto calcSpeedDirection(const LiveActor* actor, const sead::Vector3f& dir) -> f32

auto calcSpeedExceptDir(const LiveActor* actor, const sead::Vector3f& dir) -> f32

auto isNear(const LiveActor* actor, const LiveActor* target, f32 threshold) -> bool

auto isNear(const LiveActor* actor, const sead::Vector3f& trans, f32 threshold) -> bool

auto isNearXZ(const LiveActor* actor, const sead::Vector3f& trans, f32 threshold) -> bool

auto isNearH(const LiveActor* actor, const sead::Vector3f& trans, f32 threshold) -> bool

auto calcDistanceH(const LiveActor* actor, const sead::Vector3f& trans) -> f32

auto isNearV(const LiveActor* actor, const sead::Vector3f& trans, f32 threshold) -> bool

auto calcDistanceV(const LiveActor* actor, const sead::Vector3f& trans) -> f32

auto isNearHV(const LiveActor* actor, const sead::Vector3f& trans, f32 threshH, f32 threshV) -> bool

auto isNearHV(const LiveActor* actor, const sead::Vector3f& trans, f32 threshH, f32 minV, f32 maxV) -> bool

auto calcHeight(const LiveActor* actor, const sead::Vector3f& trans) -> f32

auto isFar(const LiveActor* actor, const LiveActor* target, f32 threshold) -> bool

auto isFar(const LiveActor* actor, const sead::Vector3f& trans, f32 threshold) -> bool

auto calcDistance(const LiveActor* actor, const LiveActor* target) -> f32

auto calcDistance(const LiveActor* actor, const sead::Vector3f& trans) -> f32

auto calcDistanceV(const LiveActor* actor, const LiveActor* target) -> f32

auto calcDistanceH(const LiveActor* actor, const LiveActor* target) -> f32

auto calcDistanceH(const LiveActor* actor, const sead::Vector3f& trans1, const sead::Vector3f& trans2) -> f32

auto calcHeight(const LiveActor* actor, const LiveActor* target) -> f32

auto calcDistanceFront(const LiveActor* actor, const sead::Vector3f& trans) -> f32

auto calcDistanceFront(const LiveActor* actor, const LiveActor* target) -> f32

void addRotateAndRepeatX(LiveActor* actor, f32 deg)

void addRotateAndRepeatY(LiveActor* actor, f32 deg)

void addRotateAndRepeatZ(LiveActor* actor, f32 deg)

void addRandomRotateY(LiveActor* actor)

void calcQuatSide(sead::Vector3f* side, const LiveActor* actor)

void calcQuatUp(sead::Vector3f* up, const LiveActor* actor)

void calcQuatFront(sead::Vector3f* front, const LiveActor* actor)

void calcQuatLocalAxis(sead::Vector3f* local, const LiveActor* actor, s32 axis)

void calcTransOffsetFront(sead::Vector3f* offset, const LiveActor* actor, f32 len)

void calcTransOffsetUp(sead::Vector3f* offset, const LiveActor* actor, f32 len)

void calcTransOffsetSide(sead::Vector3f* offset, const LiveActor* actor, f32 len)

void setTransOffsetLocalDir(LiveActor* actor, const sead::Quatf& quat, const sead::Vector3f& globalOffset, f32 localOffset, s32 axis)

void addTransOffsetLocal(LiveActor* actor, const sead::Vector3f& localOffset)

void addTransOffsetLocalDir(LiveActor* actor, f32 localOffset, s32 axis)

void rotateQuatXDirDegree(LiveActor* actor, f32 deg)

void rotateQuatXDirDegree(LiveActor* actor, const sead::Quatf& quat, f32 deg)

void rotateQuatYDirDegree(LiveActor* actor, f32 deg)

void rotateQuatYDirDegree(LiveActor* actor, const sead::Quatf& quat, f32 deg)

void rotateQuatZDirDegree(LiveActor* actor, f32 deg)

void rotateQuatZDirDegree(LiveActor* actor, const sead::Quatf& quat, f32 deg)

void rotateQuatLocalDirDegree(LiveActor* actor, s32 axis, f32 deg)

void rotateQuatLocalDirDegree(LiveActor* actor, const sead::Quatf& quat, s32 axis, f32 deg)

void rotateQuatYDirRandomDegree(LiveActor* actor)

void rotateQuatYDirRandomDegree(LiveActor* actor, const sead::Quatf& quat)

auto turnQuatFrontToDirDegreeH(LiveActor* actor, const sead::Vector3f& dir, f32 deg) -> bool

auto turnQuatFrontToPosDegreeH(LiveActor* actor, const sead::Vector3f& pos, f32 deg) -> bool

auto turnQuatFrontFromPosDegreeH(LiveActor* actor, const sead::Vector3f& pos, f32 deg) -> bool

void turnFront(LiveActor* actor, f32 deg)

void turnFront(LiveActor* actor, const sead::Vector3f& up, f32 deg)

void turnFrontToPos(LiveActor* actor, const sead::Vector3f& pos, f32 deg)

void turnFrontToDir(LiveActor* actor, const sead::Vector3f& dir, f32 deg)

auto turnFrontToDirGetIsFinished(LiveActor* actor, const sead::Vector3f& dir, f32 deg) -> bool

auto turnDirectionDegree(const LiveActor* actor, sead::Vector3f* vec, const sead::Vector3f& dir, f32 deg) -> bool

void turnFrontToTarget(LiveActor* actor, const LiveActor* target, f32 deg)

void turnFrontFromTarget(LiveActor* actor, const LiveActor* target, f32 deg)

auto turnFrontToPlayer(LiveActor* actor, f32 deg) -> bool

auto turnFrontFromPlayer(LiveActor* actor, f32 deg) -> bool

auto turnDirection(const LiveActor* actor, sead::Vector3f* vec, const sead::Vector3f& dir, f32 cos) -> bool

auto turnDirectionToTarget(const LiveActor* actor, sead::Vector3f* vec, const sead::Vector3f& target, f32 cos) -> bool

auto turnDirectionToTargetDegree(const LiveActor* actor, sead::Vector3f* vec, const sead::Vector3f& target, f32 deg) -> bool

auto turnDirectionFromTargetDegree(const LiveActor* actor, sead::Vector3f* vec, const sead::Vector3f& target, f32 deg) -> bool

void turnDirectionAlongGround(const LiveActor* actor, sead::Vector3f* dir)

void turnDirectionAlongGround(LiveActor* actor)

auto turnToDirectionAxis(LiveActor* actor, const sead::Vector3f& horizontal, const sead::Vector3f& vertical, f32 deg) -> bool

auto turnFrontSpherical(const LiveActor* actor, sead::Vector3f* vec, const sead::Vector3f& targetFront, f32 cos) -> bool

auto turnFrontSphericalToTarget(const LiveActor* actor, sead::Vector3f* vec, const sead::Vector3f& target, f32 cos) -> bool

auto turnFrontSphericalToTargetDegree(const LiveActor* actor, sead::Vector3f* vec, const sead::Vector3f& target, f32 deg) -> bool

auto turnToDirection(LiveActor* actor, const sead::Vector3f& dir, f32 deg) -> bool

void turnLocalDirToDirection(LiveActor* actor, const sead::Vector3f& localDir, const sead::Vector3f& targetDir, f32 deg)

auto turnToTarget(LiveActor* actor, const sead::Vector3f& target, f32 deg) -> bool

auto turnToTarget(LiveActor* actor, const LiveActor* target, f32 deg) -> bool

void faceToDirection(LiveActor* actor, const sead::Vector3f& dir)

void faceToDirectionSupportUp(LiveActor* actor, const sead::Vector3f& dir)

void faceToTarget(LiveActor* actor, const sead::Vector3f& target)

void faceToTarget(LiveActor* actor, const LiveActor* target)

void faceToSensor(LiveActor* actor, const HitSensor* sensor)

void faceToVelocity(LiveActor* actor)

void calcDirClockwiseToDir(sead::Vector3f* out, const LiveActor* actor, const sead::Vector3f& dir)

void calcDirClockwiseToPos(sead::Vector3f* out, const LiveActor* actor, const sead::Vector3f& target)

void calcDirToActorH(sead::Vector3f* out, const LiveActor* actor, const LiveActor* target)

void calcDirToActorH(sead::Vector3f* out, const LiveActor* actor, const sead::Vector3f& target)

auto calcAngleToTargetH(const LiveActor* actor, const sead::Vector3f& target) -> f32

auto calcAngleToTargetV(const LiveActor* actor, const sead::Vector3f& target) -> f32

auto isFaceToTargetDegree(const LiveActor* actor, const sead::Vector3f& target, const sead::Vector3f& face, f32 threshDeg) -> bool

auto isFaceToTargetDegree(const LiveActor* actor, const sead::Vector3f& target, f32 threshDeg) -> bool

auto isFaceToTargetDegreeHV(const LiveActor* actor, const sead::Vector3f& target, const sead::Vector3f& face, f32 degH, f32 degV) -> bool

auto isFaceToTargetDegreeH(const LiveActor* actor, const sead::Vector3f& target, const sead::Vector3f& face, f32 degH) -> bool

auto isInSightCone(const LiveActor* actor, const sead::Vector3f& target, const sead::Vector3f& face, f32 maxDist, f32 threshDeg) -> bool

auto isInSightConeTarget(const LiveActor* actor, const LiveActor* target, f32 maxDist, f32 threshDeg) -> bool

auto isInSightConePlayer(const LiveActor* actor, f32 maxDist, f32 threshDeg) -> bool

auto isInSightFan(const LiveActor* actor, const sead::Vector3f& target, const sead::Vector3f& face, f32 maxDist, f32 angleH, f32 angleV) -> bool

auto isInSightFanTarget(const LiveActor* actor, const LiveActor* target, f32 maxDist, f32 angleH, f32 angleV) -> bool

auto isInSightBox(const LiveActor* actor, const sead::Vector3f& pos, const sead::BoundBox3f& box) -> bool

void walkAndTurnToDirection(LiveActor* actor, const sead::Vector3f& dir, f32 forceFront, f32 forceGravity, f32 decay, f32 deg, bool turnAlongGround)

void walkAndTurnToDirection(LiveActor* actor, sead::Vector3f* front, const sead::Vector3f& dir, f32 forceFront, f32 forceGravity, f32 decay, f32 deg, bool turnAlongGround)

void walkAndTurnPoseToDirection(LiveActor* actor, const sead::Vector3f& dir, const ActorParamMove& param, bool turnAlongGround)

void walkAndTurnToTarget(LiveActor* actor, const sead::Vector3f& target, f32 forceFront, f32 forceGravity, f32 decay, f32 deg, bool turnAlongGround)

void flyAndTurnToDirection(LiveActor* actor, sead::Vector3f* front, const sead::Vector3f& dir, f32 forceFront, f32 forceGravity, f32 decay, f32 deg)

void flyAndTurnToDirection(LiveActor* actor, const sead::Vector3f& dir, f32 forceFront, f32 forceGravity, f32 decay, f32 deg)

void flyAndTurnToTarget(LiveActor* actor, const sead::Vector3f& target, f32 forceFront, f32 forceGravity, f32 decay, f32 deg)

auto walkAndTurnToDirectionFittedGroundGravity(LiveActor* actor, sead::Vector3f* front, const sead::Vector3f& dir, f32 forceFront, f32 forceGravity, f32 decay, f32 deg, bool turnAlongGround) -> bool

auto walkAndTurnToDirectionFittedGroundGravity(LiveActor* actor, const sead::Vector3f& dir, f32 forceFront, f32 forceGravity, f32 decay, f32 deg, bool turnAlongGround) -> bool

auto walkAndTurnToTargetFittedGroundGravity(LiveActor* actor, const sead::Vector3f& target, f32 forceFront, f32 forceGravity, f32 decay, f32 deg, bool turnAlongGround) -> bool

auto tryKillByDeathArea(LiveActor* actor) -> bool

void rotateAndKeepColliderPosRate(LiveActor* actor, const sead::Vector3f& up, const sead::Vector3f& front, f32 rate)

void calcSpringMovement(LiveActor* actor, const sead::Vector3f& pos, f32 springPos, f32 sinStrength, const sead::Vector3f& offset, f32 constStrength, f32 sinAmpl)

auto addVelocityClockwiseToPlayer(LiveActor* actor, f32 force) -> bool

auto calcDirClockwiseToPlayer(sead::Vector3f* dir, const LiveActor* actor) -> bool

auto flyAndTurnToPlayer(LiveActor* actor, const ActorParamMove& param) -> bool

auto escapeFromPlayer(LiveActor* actor, f32 forceFront, f32 forceGravity, f32 decay, f32 deg) -> bool

auto escapeFromPlayer(LiveActor* actor, sead::Vector3f* front, f32 forceFront, f32 forceGravity, f32 decay, f32 deg) -> bool

auto walkAndTurnToPlayer(LiveActor* actor, f32 forceFront, f32 forceGravity, f32 decay, f32 deg, bool turnAlongGround) -> bool

auto isPlayerInSightFan(const LiveActor* actor, f32 maxDist, f32 angleH, f32 angleV) -> bool

auto nextMove(Triangle* triangle, const LiveActor* actor, const sead::Vector3f& velocity, f32 gravity, f32 searchDist) -> bool

auto isFallOrDamageCodeNextMove(const LiveActor* actor, const sead::Vector3f& velocity, f32 gravity, f32 searchDist) -> bool

auto isFallNextMove(const LiveActor* actor, const sead::Vector3f& velocity, f32 gravity, f32 searchDist) -> bool

auto findActorParamF32(const LiveActor* actor, const char* paramName) -> f32*

auto findActorParamS32(const LiveActor* actor, const char* paramName) -> s32*

static void rotationAndTranslationFromMatrix(sead::Vector3f* trans, sead::Vector3f* rot, const sead::Matrix34f* mtx)

void initActorPoseT(LiveActor* actor, const sead::Vector3f& trans)

void setTrans(LiveActor* actor, const sead::Vector3f& trans)

void initActorPoseTR(LiveActor* actor, const sead::Vector3f& trans, const sead::Vector3f& rotate)

void setRotate(LiveActor* actor, const sead::Vector3f& rotate)

void makeMtxSRT(sead::Matrix34f* mtx, const LiveActor* actor)

void makeMtxRT(sead::Matrix34f* mtx, const LiveActor* actor)

void makeMtxR(sead::Matrix34f* mtx, const LiveActor* actor)

void calcAnimFrontGravityPos(LiveActor* actor, const sead::Vector3f& front)

auto getGravity(const LiveActor* actor) -> const sead::Vector3f&

auto getTrans(const LiveActor* actor) -> const sead::Vector3f&

auto getScale(const LiveActor* actor) -> const sead::Vector3f&

void copyPose(LiveActor* actor, const LiveActor* target)

void updatePoseTrans(LiveActor* actor, const sead::Vector3f& trans)

void updatePoseRotate(LiveActor* actor, const sead::Vector3f& rotate)

void updatePoseQuat(LiveActor* actor, const sead::Quatf& quat)

void updatePoseMtx(LiveActor* actor, const sead::Matrix34f* mtx)

void calcSideDir(sead::Vector3f* side, const LiveActor* actor)

void calcLeftDir(sead::Vector3f* left, const LiveActor* actor)

void calcRightDir(sead::Vector3f* right, const LiveActor* actor)

void calcUpDir(sead::Vector3f* up, const LiveActor* actor)

void calcDownDir(sead::Vector3f* down, const LiveActor* actor)

void calcFrontDir(sead::Vector3f* front, const LiveActor* actor)

void calcBackDir(sead::Vector3f* back, const LiveActor* actor)

void calcPoseDir(sead::Vector3f* side, sead::Vector3f* up, sead::Vector3f* front, const LiveActor* actor)

void calcQuat(sead::Quatf* quat, const LiveActor* actor)

auto calcDistanceSignLocalXDir(const LiveActor* actor, const sead::Vector3f& pos) -> f32

auto calcDistanceSignLocalYDir(const LiveActor* actor, const sead::Vector3f& pos) -> f32

auto calcDistanceSignLocalZDir(const LiveActor* actor, const sead::Vector3f& pos) -> f32

auto calcDistanceLocalXDir(const LiveActor* actor, const sead::Vector3f& pos) -> f32

auto calcDistanceLocalYDir(const LiveActor* actor, const sead::Vector3f& pos) -> f32

auto calcDistanceLocalZDir(const LiveActor* actor, const sead::Vector3f& pos) -> f32

auto getTransPtr(LiveActor* actor) -> sead::Vector3f*

void setTrans(LiveActor* actor, f32 x, f32 y, f32 z)

void setTransX(LiveActor* actor, f32 x)

void setTransY(LiveActor* actor, f32 y)

void setTransZ(LiveActor* actor, f32 z)

auto getRotate(const LiveActor* actor) -> const sead::Vector3f&

auto getRotatePtr(LiveActor* actor) -> sead::Vector3f*

void setRotate(LiveActor* actor, f32 x, f32 y, f32 z)

void setRotateX(LiveActor* actor, f32 x)

void setRotateY(LiveActor* actor, f32 y)

void setRotateZ(LiveActor* actor, f32 z)

auto getScalePtr(LiveActor* actor) -> sead::Vector3f*

auto tryGetScalePtr(LiveActor* actor) -> sead::Vector3f*

auto getScaleX(const LiveActor* actor) -> f32

auto getScaleY(const LiveActor* actor) -> f32

auto getScaleZ(const LiveActor* actor) -> f32

void setScale(LiveActor* actor, const sead::Vector3f& scale)

void setScale(LiveActor* actor, f32 x, f32 y, f32 z)

void setScaleAll(LiveActor* actor, f32 scale)

void setScaleX(LiveActor* actor, f32 x)

void setScaleY(LiveActor* actor, f32 y)

void setScaleZ(LiveActor* actor, f32 z)

auto isFrontTarget(const LiveActor* actor, const sead::Vector3f& pos) -> bool

auto isFrontDir(const LiveActor* actor, const sead::Vector3f& dir) -> bool

auto isBackTarget(const LiveActor* actor, const sead::Vector3f& pos) -> bool

auto isBackDir(const LiveActor* actor, const sead::Vector3f& dir) -> bool

auto isLeftTarget(const LiveActor* actor, const sead::Vector3f& pos) -> bool

auto isLeftDir(const LiveActor* actor, const sead::Vector3f& dir) -> bool

auto isRightTarget(const LiveActor* actor, const sead::Vector3f& pos) -> bool

auto isRightDir(const LiveActor* actor, const sead::Vector3f& dir) -> bool

auto isUpTarget(const LiveActor* actor, const sead::Vector3f& pos) -> bool

auto isUpDir(const LiveActor* actor, const sead::Vector3f& dir) -> bool

auto isDownTarget(const LiveActor* actor, const sead::Vector3f& pos) -> bool

auto isDownDir(const LiveActor* actor, const sead::Vector3f& dir) -> bool

auto getQuat(const LiveActor* actor) -> const sead::Quatf&

auto getQuatPtr(LiveActor* actor) -> sead::Quatf*

auto tryGetQuatPtr(LiveActor* actor) -> sead::Quatf*

void setQuat(LiveActor* actor, const sead::Quatf& quat)

auto getGravityPtr(const LiveActor* actor) -> sead::Vector3f*

void setGravity(const LiveActor* actor, const sead::Vector3f& gravity)

auto getFront(const LiveActor* actor) -> const sead::Vector3f&

auto getFrontPtr(LiveActor* actor) -> sead::Vector3f*

void setFront(LiveActor* actor, const sead::Vector3f& front)

auto getUp(const LiveActor* actor) -> const sead::Vector3f&

auto getUpPtr(LiveActor* actor) -> sead::Vector3f*

void setUp(LiveActor* actor, const sead::Vector3f& up)

void multVecPoseNoTrans(sead::Vector3f* posOut, const LiveActor* actor, const sead::Vector3f& posIn)

void multVecPose(sead::Vector3f* posOut, const LiveActor* actor, const sead::Vector3f& posIn)

void multVecPoseAndScale(sead::Vector3f* posOut, const LiveActor* actor, const sead::Vector3f& posIn)

void multVecInvPose(sead::Vector3f* posOut, const LiveActor* actor, const sead::Vector3f& posIn)

void multMtxInvPose(sead::Matrix34f* mtxOut, const LiveActor* actor, const sead::Matrix34f& mtxIn)

void calcTransLocalOffset(sead::Vector3f* transOut, const LiveActor* actor, const sead::Vector3f& transIn)

void multVecInvQuat(sead::Vector3f* posOut, const LiveActor* actor, const sead::Vector3f& posIn)

auto isExistModelResource(const LiveActor*) -> bool

auto isExistAnimResource(const LiveActor*) -> bool

void tryGetAnimResource(const LiveActor*)

auto isExistModelResourceYaml(const LiveActor*, const char*, const char*) -> bool

void getModelResource(const LiveActor*)

auto isExistAnimResourceYaml(const LiveActor*, const char*, const char*) -> bool

void getAnimResource(const LiveActor*)

auto isExistModelOrAnimResourceYaml(const LiveActor*, const char*, const char*) -> bool

auto getModelResourceYaml(const LiveActor*, const char*, const char*) -> u8*

auto getAnimResourceYaml(const LiveActor*, const char*, const char*) -> u8*

auto getModelOrAnimResourceYaml(const LiveActor*, const char*, const char*) -> u8*

auto getMapPartsResourceYaml(const ActorInitInfo&, const char*) -> u8*

auto tryGetMapPartsResourceYaml(const ActorInitInfo&, const char*) -> u8*

void tryMakeInitFileName(sead::BufferedSafeString*, const Resource*, const char*, const char*, const char*)

void tryGetSuffixIter(ByamlIter*, const Resource*, const char*, const char*)

void tryGetInitFileIterAndName(ByamlIter*, sead::BufferedSafeString*, const Resource*, const char*, const char*, const char*)

void tryGetActorInitFileIterAndName(ByamlIter*, sead::BufferedSafeString*, const Resource*, const char*, const char*)

auto tryGetActorInitFileIter(ByamlIter*, const Resource*, const char*, const char*) -> bool

auto tryGetActorInitFileIterAndName(ByamlIter*, sead::BufferedSafeString*, const LiveActor*, const char*, const char*) -> bool

auto tryGetActorInitFileIter(ByamlIter*, const LiveActor*, const char*, const char*) -> bool

auto tryGetActorInitFileName(sead::BufferedSafeString*, const Resource*, const char*, const char*) -> bool

auto tryGetActorInitFileName(sead::BufferedSafeString*, const ActorResource*, const char*, const char*) -> bool

auto tryGetActorInitFileName(sead::BufferedSafeString*, const LiveActor*, const char*, const char*) -> bool

auto tryGetActorInitFileSuffixName(sead::BufferedSafeString*, const Resource*, const char*, const char*) -> bool

auto tryGetActorInitFileSuffixName(sead::BufferedSafeString*, const LiveActor*, const char*, const char*) -> bool

auto tryGetActorInitFileSuffixName(const LiveActor*, const char*, const char*) -> const char*

auto tryGetActorInitFileSuffixName(const Resource*, const char*, const char*) -> const char*

void initParameterIoAsActorInfo(ParameterIo*, const LiveActor*, const char*, const char*)

void initParameterIoAndLoad(ParameterIo*, const LiveActor*, const char*, const char*)

void stopScene(const LiveActor* actor, s32 stopFrames, s32 delayFrames)

auto isStopScene(const LiveActor* actor) -> bool

void stopScene(SceneStopCtrl* ctrl, s32 stopFrames, s32 delayFrames)

auto isStopScene(SceneStopCtrl* ctrl) -> bool

void requestCaptureScreenCover(const LiveActor* actor, s32 coverFrames)

auto requestStartDemo(const LiveActor* actor, const char* name) -> bool

void requestEndDemo(const LiveActor* actor, const char* name)

void addDemoActor(LiveActor* actor)

auto addHitSensor(LiveActor*, const ActorInitInfo&, const char*, u32, f32, u16, const sead::Vector3f&) -> HitSensor*

auto addHitSensorPlayer(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&) -> HitSensor*

auto addHitSensorPlayerAttack(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&) -> HitSensor*

auto addHitSensorPlayerEye(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&) -> HitSensor*

auto addHitSensorEnemy(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&) -> HitSensor*

auto addHitSensorEnemyBody(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&) -> HitSensor*

auto addHitSensorEnemyAttack(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&) -> HitSensor*

auto addHitSensorMapObj(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&) -> HitSensor*

auto addHitSensorBindable(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&) -> HitSensor*

auto addHitSensorBindableGoal(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&) -> HitSensor*

auto addHitSensorBindableAllPlayer(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&) -> HitSensor*

auto addHitSensorBindableBubbleOutScreen(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&) -> HitSensor*

auto addHitSensorBindableKoura(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&) -> HitSensor*

auto addHitSensorBindableRouteDokan(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&) -> HitSensor*

auto addHitSensorBindableBubblePadInput(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&) -> HitSensor*

auto addHitSensorCollisionParts(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&) -> HitSensor*

auto addHitSensorEye(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&) -> HitSensor*

void setHitSensorSort(LiveActor*, const char*, const SensorSortCmpFuncBase*)

void setHitSensorPosPtr(LiveActor*, const char*, const sead::Vector3f*)

auto getHitSensor(const LiveActor*, const char*) -> HitSensor*

void setHitSensorMtxPtr(LiveActor*, const char*, const sead::Matrix34f*)

void setHitSensorJointMtx(LiveActor*, const char*, const char*)

void setSensorRadius(LiveActor*, const char*, f32)

void setSensorRadius(LiveActor*, f32)

auto getSensorRadius(const LiveActor*, const char*) -> f32

auto getSensorRadius(const LiveActor*) -> f32

auto getSensorPos(const LiveActor*, const char*) -> const sead::Vector3f&

auto getSensorPos(const LiveActor*) -> const sead::Vector3f&

void setSensorFollowPosOffset(LiveActor*, const char*, const sead::Vector3f&)

void setSensorFollowPosOffset(LiveActor*, const sead::Vector3f&)

auto getSensorFollowPosOffset(const LiveActor*, const char*) -> const sead::Vector3f&

auto getSensorFollowPosOffset(const LiveActor*) -> const sead::Vector3f&

auto createActorSensorController(LiveActor*, const char*) -> ActorSensorController*

void setSensorRadius(ActorSensorController*, f32)

void setSensorScale(ActorSensorController*, f32)

void setSensorFollowPosOffset(ActorSensorController*, const sead::Vector3f&)

auto getOriginalSensorRadius(const ActorSensorController*) -> f32

auto getOriginalSensorFollowPosOffset(const ActorSensorController*) -> const sead::Vector3f&

void resetActorSensorController(ActorSensorController*)

void calcPosBetweenSensors(sead::Vector3f*, const HitSensor*, const HitSensor*, f32)

auto calcDistance(const HitSensor*, const HitSensor*) -> f32

auto getSensorPos(const HitSensor*) -> const sead::Vector3f&

auto calcDistanceV(const sead::Vector3f&, const HitSensor*, const HitSensor*) -> f32

auto calcDistanceH(const sead::Vector3f&, const HitSensor*, const HitSensor*) -> f32

auto calcDirBetweenSensors(sead::Vector3f*, const HitSensor*, const HitSensor*) -> bool

auto calcDirBetweenSensorsH(sead::Vector3f*, const HitSensor*, const HitSensor*) -> bool

auto calcDirBetweenSensorsNormal(sead::Vector3f*, const HitSensor*, const HitSensor*, sead::Vector3f) -> bool

void calcVecBetweenSensors(sead::Vector3f*, const HitSensor*, const HitSensor*)

void calcVecBetweenSensorsH(sead::Vector3f*, const HitSensor*, const HitSensor*)

void calcVecBetweenSensorsNormal(sead::Vector3f*, const HitSensor*, const HitSensor*, sead::Vector3f)

auto calcStrikeArrowCollideWallAndCeilingBetweenAttackSensor(const LiveActor*, const HitSensor*, const HitSensor*, const sead::Vector3f&, f32) -> s32

auto getSensorHost(const HitSensor*) -> LiveActor*

auto isFaceBetweenSensors(const sead::Vector3f&, const HitSensor*, const HitSensor*) -> bool

auto isFaceBetweenSensorsH(const sead::Vector3f&, const HitSensor*, const HitSensor*) -> bool

auto isEnableLookAtTargetSensor(const HitSensor*, const sead::Vector3f&, f32) -> bool

auto isSensorValid(const HitSensor*) -> bool

auto isHitBoxSensor(const HitSensor*, const sead::Vector3f&, const sead::BoundBox3f&) -> bool

auto getSensorRadius(const HitSensor*) -> f32

auto isHitBoxSensor(const HitSensor*, const sead::Matrix34f&, const sead::BoundBox3f&) -> bool

auto isHitCylinderSensor(const HitSensor*, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

auto isHitCylinderSensor(const HitSensor*, const HitSensor*, const sead::Vector3f&, f32) -> bool

auto isHitCylinderSensor(sead::Vector3f*, sead::Vector3f*, const HitSensor*, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

auto isHitCylinderSensor(sead::Vector3f*, sead::Vector3f*, const HitSensor*, const HitSensor*, const sead::Vector3f&, f32) -> bool

auto isHitCylinderSensorHeight(const HitSensor*, const HitSensor*, const sead::Vector3f&, f32, f32) -> bool

auto isHitCircleSensor(sead::Vector3f*, sead::Vector3f*, const HitSensor*, const sead::Vector3f&, const sead::Vector3f&, f32, f32) -> bool

auto isHitCircleSensor(sead::Vector3f*, sead::Vector3f*, const HitSensor*, const HitSensor*, const sead::Vector3f&, f32, f32) -> bool

auto isHitCircleSensor(const HitSensor*, const sead::Vector3f&, const sead::Vector3f&, f32, f32) -> bool

auto isHitCircleSensor(const HitSensor*, const HitSensor*, const sead::Vector3f&, f32, f32) -> bool

auto isHitPlaneSensor(const HitSensor*, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

auto isHitPlaneSensor(const HitSensor*, const HitSensor*, const sead::Vector3f&, f32) -> bool

auto getActorTrans(const HitSensor*) -> const sead::Vector3f&

auto getActorVelocity(const HitSensor*) -> const sead::Vector3f&

auto getActorGravity(const HitSensor*) -> const sead::Vector3f&

auto isSensorName(const HitSensor*, const char*) -> bool

auto isSensorHostName(const HitSensor*, const char*) -> bool

auto isSensorHost(const HitSensor*, const LiveActor*) -> bool

void validateHitSensors(LiveActor*)

void invalidateHitSensors(LiveActor*)

auto isSensorValid(const LiveActor*, const char*) -> bool

void validateHitSensor(LiveActor*, const char*)

void invalidateHitSensor(LiveActor*, const char*)

void validateHitSensorBindableAll(LiveActor*)

auto isSensorBindableAll(const HitSensor*) -> bool

void validateHitSensorEnemyAll(LiveActor*)

auto isSensorEnemy(const HitSensor*) -> bool

void validateHitSensorEnemyAttackAll(LiveActor*)

auto isSensorEnemyAttack(const HitSensor*) -> bool

void validateHitSensorEnemyBodyAll(LiveActor*)

auto isSensorEnemyBody(const HitSensor*) -> bool

void validateHitSensorEyeAll(LiveActor*)

auto isSensorEye(const HitSensor*) -> bool

void validateHitSensorMapObjAll(LiveActor*)

auto isSensorMapObj(const HitSensor*) -> bool

void validateHitSensorNpcAll(LiveActor*)

auto isSensorNpc(const HitSensor*) -> bool

void validateHitSensorPlayerAll(LiveActor*)

auto isSensorPlayerAll(const HitSensor*) -> bool

void validateHitSensorRideAll(LiveActor*)

auto isSensorRide(const HitSensor*) -> bool

void invalidateHitSensorEyeAll(LiveActor*)

void invalidateHitSensorPlayerAll(LiveActor*)

void invalidateHitSensorPlayerAttackAll(LiveActor*)

auto isSensorPlayerAttack(const HitSensor*) -> bool

auto sendMsgPlayerAttackTrample(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerTrampleReflect(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerReflectOrTrample(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerHipDrop(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerObjHipDrop(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerObjHipDropReflect(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerObjHipDropHighJump(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerHipDropKnockDown(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerStatueDrop(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerObjStatueDrop(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerObjStatueDropReflect(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerObjStatueDropReflectNoCondition(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerStatueTouch(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerUpperPunch(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerObjUpperPunch(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerRollingAttack(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerRollingReflect(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerObjRollingAttack(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerObjRollingAttackFailure(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerInvincibleAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerFireBallAttack(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerRouteDokanFireBallAttack(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerTailAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerTouch(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerKick(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerCatch(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerSlidingAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerBoomerangAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerBoomerangAttackCollide(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerBoomerangReflect(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerBoomerangBreak(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerBodyAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerBodyLanding(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerBodyAttackReflect(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerClimbAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerSpinAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerGiantAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerCooperationHipDrop(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerClimbSlidingAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerClimbRollingAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerGiantHipDrop(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPlayerDisregard(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerItemGet(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerPutOnEquipment(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerReleaseEquipment(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerReleaseEquipmentGoal(HitSensor* receiver, HitSensor* sender, u32) -> bool

auto sendMsgPlayerFloorTouch(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerDamageTouch(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerCarryFront(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerCarryFrontWallKeep(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerCarryUp(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerCarryKeepDemo(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerCarryWarp(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerLeave(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerRelease(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerReleaseBySwing(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerReleaseDamage(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerReleaseDead(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerReleaseDemo(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerToss(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerInvincibleTouch(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgEnemyAttack(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgEnemyAttackBoomerang(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgEnemyAttackFire(HitSensor* receiver, HitSensor* sender, const char*) -> bool

auto sendMsgEnemyAttackNeedle(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgEnemyFloorTouch(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgEnemyItemGet(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgEnemyRouteDokanAttack(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgEnemyRouteDokanFire(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgEnemyTouch(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgEnemyUpperPunch(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgEnemyTrample(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgMapObjTrample(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPressureDeath(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgNpcTouch(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgExplosion(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgExplosionCollide(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgPush(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPushStrong(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPushVeryStrong(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgHit(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgHitStrong(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgHitVeryStrong(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgKnockDown(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgMapPush(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgVanish(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgChangeAlpha(LiveActor* receiver, f32 alpha) -> bool

auto sendMsgShowModel(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgHideModel(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgRestart(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgNeedleBallAttack(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPunpunFloorTouch(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgInvalidateFootPrint(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgKickKouraAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgKickKouraAttackCollide(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgKickKouraGetItem(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgKickKouraReflect(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgKickKouraCollideNoReflect(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgKickKouraBreak(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgKickKouraBlow(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgKickStoneAttack(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgKickStoneAttackCollide(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgKickStoneAttackHold(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgKickStoneAttackReflect(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgKickStoneTrample(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgKillerAttack(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgLiftGeyser(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgWarpStart(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgWarpEnd(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgHoldCancel(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgHoleIn(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgJumpInhibit(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgGoalKill(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgGoal(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgBindStart(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgBindInit(HitSensor* receiver, HitSensor* sender, u32) -> bool

auto sendMsgBindEnd(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgBindCancel(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgBindCancelByDemo(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgBindDamage(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgBindSteal(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgBindGiant(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgBallAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgBallRouteDokanAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgBallAttackHold(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgBallAttackDRCHold(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgBallAttackCollide(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgBallTrample(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgBallTrampleCollide(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgBallItemGet(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgFireBalCollide(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgFireBallFloorTouch(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgDokanBazookaAttack(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgRideAllPlayerItemGet(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgHideModel(LiveActor* receiver) -> bool

auto sendMsgShowModel(LiveActor* receiver) -> bool

auto sendMsgRestart(LiveActor* receiver) -> bool

auto sendMsgCollisionImpulse(HitSensor* receiver, HitSensor* sender, sead::Vector3f*, const sead::Vector3f&, f32, const sead::Vector3f&, f32) -> bool

auto sendMsgSwitchOn(LiveActor* receiver) -> bool

auto sendMsgSwitchOnInit(LiveActor* receiver) -> bool

auto sendMsgSwitchOffInit(LiveActor* receiver) -> bool

auto sendMsgSwitchKillOn(LiveActor* receiver) -> bool

auto sendMsgSwitchKillOnInit(LiveActor* receiver) -> bool

auto sendMsgSwitchKillOffInit(LiveActor* receiver) -> bool

auto sendMsgPlayerFloorTouchToColliderGround(LiveActor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerUpperPunchToColliderCeiling(LiveActor* receiver, HitSensor* sender) -> bool

auto sendMsgEnemyFloorTouchToColliderGround(LiveActor* receiver, HitSensor* sender) -> bool

auto sendMsgEnemyUpperPunchToColliderCeiling(LiveActor* receiver, HitSensor* sender) -> bool

auto sendMsgAskSafetyPoint(HitSensor* receiver, HitSensor* sender, sead::Vector3f**) -> bool

auto sendMsgAskSafetyPointToColliderGround(LiveActor* receiver, HitSensor* sender, sead::Vector3f**) -> bool

auto sendMsgTouchAssist(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgTouchAssistTrig(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgTouchStroke(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgScreenPointInvalidCollisionParts(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgBlockUpperPunch(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgBlockLowerPunch(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgBlockItemGet(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgKillerItemGet(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerKouraAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter) -> bool

auto sendMsgLightFlash(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgForceAbyss(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgIsNerveSupportFreeze(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgOnSyncSupportFreeze(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgOffSyncSupportFreeze(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgSwordAttackHighLeft(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgSwordAttackLowLeft(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgSwordAttackHighRight(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgSwordAttackLowRight(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgSwordAttackJumpUnder(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgSwordBeamAttack(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgSwordBeamReflectAttack(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgShieldGuard(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgEnemyAttackKnockDown(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgAskMultiPlayerEnemy(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgItemGettable(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgKikkiThrow(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgIsKikkiThrowTarget(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerCloudGet(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgAutoJump(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerTouchShadow(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerPullOutShadow(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerAttackShadow(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerAttackShadowStrong(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgPlayerAttackChangePos(HitSensor* receiver, HitSensor* sender, sead::Vector3f* pos) -> bool

auto sendMsgAtmosOnlineLight(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgLightBurn(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgMoonLightBurn(HitSensor* receiver, HitSensor* sender) -> bool

auto sendMsgString(HitSensor* receiver, HitSensor* sender, const char* str) -> bool

auto sendMsgStringV4fPtr(HitSensor* receiver, HitSensor* sender, const char* str, sead::Vector4f* vec) -> bool

auto sendMsgStringV4fSensorPtr(HitSensor* receiver, HitSensor* sender, const char* str, sead::Vector4f* vec) -> bool

auto sendMsgStringVoidPtr(HitSensor* receiver, HitSensor* sender, const char* str, void* ptr) -> bool

auto isMsgPushAll(const SensorMsg* msg) -> bool

auto isMsgPush(const SensorMsg* msg) -> bool

auto isMsgPushStrong(const SensorMsg* msg) -> bool

auto isMsgPushVeryStrong(const SensorMsg* msg) -> bool

auto isMsgHoldReleaseAll(const SensorMsg* msg) -> bool

auto isMsgHoldCancel(const SensorMsg* msg) -> bool

auto isMsgPlayerRelease(const SensorMsg* msg) -> bool

auto isMsgPlayerReleaseBySwing(const SensorMsg* msg) -> bool

auto isMsgPlayerReleaseDead(const SensorMsg* msg) -> bool

auto isMsgPlayerReleaseDamage(const SensorMsg* msg) -> bool

auto isMsgPlayerReleaseDemo(const SensorMsg* msg) -> bool

auto isMsgItemGetDirectAll(const SensorMsg* msg) -> bool

auto isMsgPlayerItemGet(const SensorMsg* msg) -> bool

auto isMsgRideAllPlayerItemGet(const SensorMsg* msg) -> bool

auto isMsgPlayerTailAttack(const SensorMsg* msg) -> bool

auto isMsgItemGetByObjAll(const SensorMsg* msg) -> bool

auto isMsgBallItemGet(const SensorMsg* msg) -> bool

auto isMsgKickKouraItemGet(const SensorMsg* msg) -> bool

auto isMsgKillerItemGet(const SensorMsg* msg) -> bool

auto isMsgItemGetAll(const SensorMsg* msg) -> bool

auto isMsgFloorTouch(const SensorMsg* msg) -> bool

auto isMsgPlayerFloorTouch(const SensorMsg* msg) -> bool

auto isMsgEnemyFloorTouch(const SensorMsg* msg) -> bool

auto isMsgUpperPunch(const SensorMsg* msg) -> bool

auto isMsgPlayerUpperPunch(const SensorMsg* msg) -> bool

auto isMsgEnemyUpperPunch(const SensorMsg* msg) -> bool

auto isMsgPlayerTrample(const SensorMsg* msg) -> bool

auto isMsgPlayerTrampleReflect(const SensorMsg* msg) -> bool

auto isMsgPlayerHipDropAll(const SensorMsg* msg) -> bool

auto isMsgPlayerStatueDrop(const SensorMsg* msg) -> bool

auto isMsgPlayerObjHipDropAll(const SensorMsg* msg) -> bool

auto isMsgPlayerObjStatueDrop(const SensorMsg* msg) -> bool

auto isMsgPlayerObjHipDropReflectAll(const SensorMsg* msg) -> bool

auto isMsgPlayerObjStatueDropReflect(const SensorMsg* msg) -> bool

auto isMsgPlayerObjHipDropHighJump(const SensorMsg* msg) -> bool

auto isMsgPlayerHipDropKnockDown(const SensorMsg* msg) -> bool

auto isMsgPlayerObjStatueDropReflectNoCondition(const SensorMsg* msg) -> bool

auto isMsgPlayerStatueTouch(const SensorMsg* msg) -> bool

auto isMsgPlayerObjUpperPunch(const SensorMsg* msg) -> bool

auto isMsgPlayerRollingAttack(const SensorMsg* msg) -> bool

auto isMsgPlayerRollingReflect(const SensorMsg* msg) -> bool

auto isMsgPlayerObjRollingAttack(const SensorMsg* msg) -> bool

auto isMsgPlayerObjRollingAttackFailure(const SensorMsg* msg) -> bool

auto isMsgPlayerInvincibleAttack(const SensorMsg* msg) -> bool

auto isMsgPlayerFireBallAttack(const SensorMsg* msg) -> bool

auto isMsgPlayerRouteDokanFireBallAttack(const SensorMsg* msg) -> bool

auto isMsgPlayerKick(const SensorMsg* msg) -> bool

auto isMsgPlayerCatch(const SensorMsg* msg) -> bool

auto isMsgPlayerSlidingAttack(const SensorMsg* msg) -> bool

auto isMsgPlayerBoomerangAttack(const SensorMsg* msg) -> bool

auto isMsgPlayerBoomerangAttackCollide(const SensorMsg* msg) -> bool

auto isMsgPlayerBoomerangReflect(const SensorMsg* msg) -> bool

auto isMsgPlayerBoomerangBreak(const SensorMsg* msg) -> bool

auto isMsgPlayerBodyAttack(const SensorMsg* msg) -> bool

auto isMsgPlayerBodyLanding(const SensorMsg* msg) -> bool

auto isMsgPlayerBodyAttackReflect(const SensorMsg* msg) -> bool

auto isMsgPlayerClimbAttack(const SensorMsg* msg) -> bool

auto isMsgPlayerSpinAttack(const SensorMsg* msg) -> bool

auto isMsgPlayerGiantAttack(const SensorMsg* msg) -> bool

auto isMsgPlayerCooperationHipDrop(const SensorMsg* msg) -> bool

auto isMsgPlayerClimbSlidingAttack(const SensorMsg* msg) -> bool

auto isMsgPlayerClimbRollingAttack(const SensorMsg* msg) -> bool

auto isMsgPlayerGiantHipDrop(const SensorMsg* msg) -> bool

auto isMsgPlayerDisregard(const SensorMsg* msg) -> bool

auto isMsgPlayerDash(const SensorMsg* msg) -> bool

auto isMsgPlayerDamageTouch(const SensorMsg* msg) -> bool

auto isMsgPlayerFloorTouchBind(const SensorMsg* msg) -> bool

auto isMsgPlayerTouch(const SensorMsg* msg) -> bool

auto isMsgPlayerInvincibleTouch(const SensorMsg* msg) -> bool

auto isMsgPlayerGiantTouch(const SensorMsg* msg) -> bool

auto isMsgPlayerObjTouch(const SensorMsg* msg) -> bool

auto isMsgPlayerPutOnEquipment(const SensorMsg* msg) -> bool

auto isMsgPlayerReleaseEquipment(const SensorMsg* msg) -> bool

auto isMsgPlayerReleaseEquipmentGoal(const SensorMsg* msg) -> bool

auto isMsgPlayerCarryFront(const SensorMsg* msg) -> bool

auto isMsgPlayerCarryFrontWallKeep(const SensorMsg* msg) -> bool

auto isMsgPlayerCarryUp(const SensorMsg* msg) -> bool

auto isMsgPlayerCarryKeepDemo(const SensorMsg* msg) -> bool

auto isMsgPlayerCarryWarp(const SensorMsg* msg) -> bool

auto isMsgPlayerLeave(const SensorMsg* msg) -> bool

auto isMsgPlayerToss(const SensorMsg* msg) -> bool

auto isMsgEnemyAttack(const SensorMsg* msg) -> bool

auto isMsgEnemyAttackFire(const SensorMsg* msg) -> bool

auto isMsgEnemyAttackKnockDown(const SensorMsg* msg) -> bool

auto isMsgEnemyAttackBoomerang(const SensorMsg* msg) -> bool

auto isMsgEnemyAttackNeedle(const SensorMsg* msg) -> bool

auto isMsgEnemyItemGet(const SensorMsg* msg) -> bool

auto isMsgEnemyRouteDokanAttack(const SensorMsg* msg) -> bool

auto isMsgEnemyRouteDokanFire(const SensorMsg* msg) -> bool

auto isMsgExplosion(const SensorMsg* msg) -> bool

auto isMsgExplosionCollide(const SensorMsg* msg) -> bool

auto isMsgBindStart(const SensorMsg* msg) -> bool

auto isMsgBindInit(const SensorMsg* msg) -> bool

auto isMsgBindEnd(const SensorMsg* msg) -> bool

auto isMsgBindCancel(const SensorMsg* msg) -> bool

auto isMsgBindCancelByDemo(const SensorMsg* msg) -> bool

auto isMsgBindDamage(const SensorMsg* msg) -> bool

auto isMsgBindSteal(const SensorMsg* msg) -> bool

auto isMsgBindGiant(const SensorMsg* msg) -> bool

auto isMsgPressureDeath(const SensorMsg* msg) -> bool

auto isMsgNpcTouch(const SensorMsg* msg) -> bool

auto isMsgHit(const SensorMsg* msg) -> bool

auto isMsgHitStrong(const SensorMsg* msg) -> bool

auto isMsgHitVeryStrong(const SensorMsg* msg) -> bool

auto isMsgKnockDown(const SensorMsg* msg) -> bool

auto isMsgMapPush(const SensorMsg* msg) -> bool

auto isMsgVanish(const SensorMsg* msg) -> bool

auto isMsgChangeAlpha(const SensorMsg* msg) -> bool

auto isMsgShowModel(const SensorMsg* msg) -> bool

auto isMsgHideModel(const SensorMsg* msg) -> bool

auto isMsgRestart(const SensorMsg* msg) -> bool

auto isMsgEnemyTouch(const SensorMsg* msg) -> bool

auto isMsgEnemyTrample(const SensorMsg* msg) -> bool

auto isMsgMapObjTrample(const SensorMsg* msg) -> bool

auto isMsgNeedleBallAttack(const SensorMsg* msg) -> bool

auto isMsgPunpunFloorTouch(const SensorMsg* msg) -> bool

auto isMsgInvalidateFootPrint(const SensorMsg* msg) -> bool

auto isMsgKickKouraAttack(const SensorMsg* msg) -> bool

auto isMsgKickKouraAttackCollide(const SensorMsg* msg) -> bool

auto isMsgKickKouraReflect(const SensorMsg* msg) -> bool

auto isMsgKickKouraCollideNoReflect(const SensorMsg* msg) -> bool

auto isMsgKickKouraBreak(const SensorMsg* msg) -> bool

auto isMsgKickKouraBlow(const SensorMsg* msg) -> bool

auto isMsgKickStoneAttack(const SensorMsg* msg) -> bool

auto isMsgKickStoneAttackCollide(const SensorMsg* msg) -> bool

auto isMsgKickStoneAttackHold(const SensorMsg* msg) -> bool

auto isMsgKickStoneAttackReflect(const SensorMsg* msg) -> bool

auto isMsgKickStoneTrample(const SensorMsg* msg) -> bool

auto isMsgKillerAttack(const SensorMsg* msg) -> bool

auto isMsgLiftGeyser(const SensorMsg* msg) -> bool

auto isMsgWarpStart(const SensorMsg* msg) -> bool

auto isMsgWarpEnd(const SensorMsg* msg) -> bool

auto isMsgHoleIn(const SensorMsg* msg) -> bool

auto isMsgJumpInhibit(const SensorMsg* msg) -> bool

auto isMsgGoalKill(const SensorMsg* msg) -> bool

auto isMsgGoal(const SensorMsg* msg) -> bool

auto isMsgBallAttack(const SensorMsg* msg) -> bool

auto isMsgBallRouteDokanAttack(const SensorMsg* msg) -> bool

auto isMsgBallAttackHold(const SensorMsg* msg) -> bool

auto isMsgBallAttackDRCHold(const SensorMsg* msg) -> bool

auto isMsgBallAttackCollide(const SensorMsg* msg) -> bool

auto isMsgBallTrample(const SensorMsg* msg) -> bool

auto isMsgBallTrampleCollide(const SensorMsg* msg) -> bool

auto isMsgFireBallCollide(const SensorMsg* msg) -> bool

auto isMsgFireBallFloorTouch(const SensorMsg* msg) -> bool

auto isMsgDokanBazookaAttack(const SensorMsg* msg) -> bool

auto isMsgSwitchOn(const SensorMsg* msg) -> bool

auto isMsgSwitchOnInit(const SensorMsg* msg) -> bool

auto isMsgSwitchOffInit(const SensorMsg* msg) -> bool

auto isMsgSwitchKillOn(const SensorMsg* msg) -> bool

auto isMsgSwitchKillOnInit(const SensorMsg* msg) -> bool

auto isMsgSwitchKillOffInit(const SensorMsg* msg) -> bool

auto isMsgAskSafetyPoint(const SensorMsg* msg) -> bool

auto trySetAskSafetyPointFollowPos(const SensorMsg* msg, sead::Vector3f*) -> bool

auto isMsgTouchAssist(const SensorMsg* msg) -> bool

auto isMsgTouchAssistNoPat(const SensorMsg* msg) -> bool

auto isMsgTouchAssistTrig(const SensorMsg* msg) -> bool

auto isMsgTouchAssistTrigOff(const SensorMsg* msg) -> bool

auto isMsgTouchAssistTrigNoPat(const SensorMsg* msg) -> bool

auto isMsgTouchAssistBurn(const SensorMsg* msg) -> bool

auto isMsgTouchAssistAll(const SensorMsg* msg) -> bool

auto isMsgTouchCarryItem(const SensorMsg* msg) -> bool

auto isMsgTouchReleaseItem(const SensorMsg* msg) -> bool

auto isMsgTouchStroke(const SensorMsg* msg) -> bool

auto isMsgIsNerveSupportFreeze(const SensorMsg* msg) -> bool

auto isMsgOnSyncSupportFreeze(const SensorMsg* msg) -> bool

auto isMsgOffSyncSupportFreeze(const SensorMsg* msg) -> bool

auto isMsgScreenPointInvalidCollisionParts(const SensorMsg* msg) -> bool

auto isMsgBlockUpperPunch(const SensorMsg* msg) -> bool

auto isMsgBlockLowerPunch(const SensorMsg* msg) -> bool

auto isMsgBlockItemGet(const SensorMsg* msg) -> bool

auto isMsgPlayerKouraAttack(const SensorMsg* msg) -> bool

auto isMsgLightFlash(const SensorMsg* msg) -> bool

auto isMsgForceAbyss(const SensorMsg* msg) -> bool

auto isMsgSwordAttackHigh(const SensorMsg* msg) -> bool

auto isMsgSwordAttackHighLeft(const SensorMsg* msg) -> bool

auto isMsgSwordAttackHighRight(const SensorMsg* msg) -> bool

auto isMsgSwordAttackLow(const SensorMsg* msg) -> bool

auto isMsgSwordAttackLowLeft(const SensorMsg* msg) -> bool

auto isMsgSwordAttackLowRight(const SensorMsg* msg) -> bool

auto isMsgSwordBeamAttack(const SensorMsg* msg) -> bool

auto isMsgSwordBeamReflectAttack(const SensorMsg* msg) -> bool

auto isMsgSwordAttackJumpUnder(const SensorMsg* msg) -> bool

auto isMsgShieldGuard(const SensorMsg* msg) -> bool

auto isMsgAskMultiPlayerEnemy(const SensorMsg* msg) -> bool

auto isMsgItemGettable(const SensorMsg* msg) -> bool

auto isMsgKikkiThrow(const SensorMsg* msg) -> bool

auto isMsgIsKikkiThrowTarget(const SensorMsg* msg) -> bool

auto isMsgPlayerCloudGet(const SensorMsg* msg) -> bool

auto isMsgAutoJump(const SensorMsg* msg) -> bool

auto isMsgPlayerTouchShadow(const SensorMsg* msg) -> bool

auto isMsgPlayerPullOutShadow(const SensorMsg* msg) -> bool

auto isMsgPlayerAttackShadow(const SensorMsg* msg) -> bool

auto isMsgPlayerAttackShadowStrong(const SensorMsg* msg) -> bool

auto isMsgPlayerAttackChangePos(const SensorMsg* msg) -> bool

auto isMsgAtmosOnlineLight(const SensorMsg* msg) -> bool

auto isMsgLightBurn(const SensorMsg* msg) -> bool

auto isMsgMoonLightBurn(const SensorMsg* msg) -> bool

auto isMsgString(const SensorMsg* msg) -> bool

auto isMsgStringV4fPtr(const SensorMsg* msg) -> bool

auto isMsgStringV4fSensorPtr(const SensorMsg* msg) -> bool

auto isMsgStringVoidPtr(const SensorMsg* msg) -> bool

auto isMsgPlayerTrampleForCrossoverSensor(const SensorMsg* msg, const HitSensor*, const HitSensor*) -> bool

auto isMsgPlayerTrampleReflectForCrossoverSensor(const SensorMsg* msg, const HitSensor*, const HitSensor*) -> bool

auto isMsgPlayerUpperPunchForCrossoverSensor(const SensorMsg* msg, const HitSensor*, const HitSensor*, f32) -> bool

auto isMsgKickStoneTrampleForCrossoverSensor(const SensorMsg* msg, const HitSensor*, const HitSensor*) -> bool

auto sendMsgEnemyAttackForCrossoverSensor(HitSensor*, HitSensor*) -> bool

auto sendMsgEnemyAttackForCrossoverCylinderSensor(HitSensor*, HitSensor*, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

auto isSensorPlayer(const HitSensor*) -> bool

auto isSensorPlayerFoot(const HitSensor*) -> bool

auto isSensorPlayerDecoration(const HitSensor*) -> bool

auto isSensorPlayerEye(const HitSensor*) -> bool

auto isSensorPlayerOrPlayerWeapon(const HitSensor*) -> bool

auto isSensorCollision(const HitSensor*) -> bool

auto isSensorPlayerFireBall(const HitSensor*) -> bool

auto isSensorHoldObj(const HitSensor*) -> bool

auto isSensorLookAt(const HitSensor*) -> bool

auto isSensorBindableGoal(const HitSensor*) -> bool

auto isSensorBindableAllPlayer(const HitSensor*) -> bool

auto isSensorBindableBubbleOutScreen(const HitSensor*) -> bool

auto isSensorBindableKoura(const HitSensor*) -> bool

auto isSensorBindableRouteDokan(const HitSensor*) -> bool

auto isSensorBindableBubblePadInput(const HitSensor*) -> bool

auto isSensorBindable(const HitSensor*) -> bool

auto isSensorSimple(const HitSensor*) -> bool

void updateHitSensorsAll(LiveActor*)

auto isMySensor(const HitSensor*, const LiveActor*) -> bool

auto isSensorHitAnyPlane(const HitSensor*, const HitSensor*, const sead::Vector3f&) -> bool

auto isSensorHitRingShape(const HitSensor*, const HitSensor*, f32) -> bool

auto tryGetEnemyAttackFireMaterialCode(const char**, const SensorMsg*) -> bool

auto sendMsgPushAndKillVelocityToTarget(LiveActor*, HitSensor*, HitSensor*) -> bool

auto sendMsgPushAndKillVelocityToTargetH(LiveActor*, HitSensor*, HitSensor*) -> bool

auto pushAndAddVelocity(LiveActor*, const HitSensor*, const HitSensor*, f32) -> bool

auto pushAndAddVelocityH(LiveActor*, const HitSensor*, const HitSensor*, f32) -> bool

auto pushAndAddVelocityV(LiveActor*, const HitSensor*, const HitSensor*, f32) -> bool

auto tryReceiveMsgPushAndAddVelocity(LiveActor*, const SensorMsg*, const HitSensor*, const HitSensor*, f32) -> bool

auto tryReceiveMsgPushAndAddVelocityH(LiveActor*, const SensorMsg*, const HitSensor*, const HitSensor*, f32) -> bool

auto tryReceiveMsgPushAndCalcPushTrans(sead::Vector3f*, const SensorMsg*, const LiveActor*, const HitSensor*, const HitSensor*, f32) -> bool

auto sendMsgCollidePush(HitSensor*, HitSensor*, const sead::Vector3f&) -> bool

auto tryReceiveMsgCollidePush(sead::Vector3f*, const SensorMsg*) -> bool

auto getChangeAlphaValue(const SensorMsg*) -> f32

auto getBindInitType(const SensorMsg*) -> u32

auto getMsgString(const SensorMsg*) -> const char*

auto getMsgStringV4fPtr(const SensorMsg*, sead::Vector4f**) -> const char*

auto getMsgStringV4fSensorPtr(const SensorMsg*, sead::Vector4f, HitSensor**) -> const char*

auto getMsgStringVoidPtr(const SensorMsg*, void**) -> const char*

auto getPlayerReleaseEquipmentGoalType(const SensorMsg*) -> u32

template<typename T>

auto createActorFunction(const char* actorName) -> LiveActor*

auto getSubActorInfo(const LiveActor* actor, s32 index) -> SubActorInfo*

auto getSubActorInfo(const LiveActor* actor, const LiveActor* subActor) -> SubActorInfo*

auto isExistSubActorKeeper(const LiveActor* actor) -> bool

auto getSubActor(const LiveActor* actor, const char* subActorName) -> LiveActor*

auto tryGetSubActor(const LiveActor* actor, const char* subActorName) -> LiveActor*

auto getSubActor(const LiveActor* actor, s32 index) -> LiveActor*

auto getSubActorNum(const LiveActor* actor) -> s32

void offSyncClippingSubActor(LiveActor* actor, const LiveActor* subActor)

void offSyncClippingSubActor(LiveActor* actor, const char* subActorName)

void offSyncClippingSubActorAll(LiveActor* actor)

void onSyncClippingSubActor(LiveActor* actor, const LiveActor* subActor)

void onSyncClippingSubActor(LiveActor* actor, const char* subActorName)

void onSyncClippingSubActorAll(LiveActor* actor)

void offSyncAppearSubActor(LiveActor* actor, const LiveActor* subActor)

void offSyncAppearSubActor(LiveActor* actor, const char* subActorName)

void offSyncAppearSubActorAll(LiveActor* actor)

void onSyncAppearSubActor(LiveActor* actor, const LiveActor* subActor)

void onSyncAppearSubActor(LiveActor* actor, const char* subActorName)

void onSyncAppearSubActorAll(LiveActor* actor)

void offSyncHideSubActor(LiveActor* actor, const LiveActor* subActor)

void offSyncHideSubActor(LiveActor* actor, const char* subActorName)

void offSyncHideSubActorAll(LiveActor* actor)

void onSyncHideSubActor(LiveActor* actor, const LiveActor* subActor)

void onSyncHideSubActor(LiveActor* actor, const char* subActorName)

void onSyncHideSubActorAll(LiveActor* actor)

auto isSyncHideSubActor(const LiveActor* actor, const LiveActor* subActor) -> bool

void offSyncAlphaMaskSubActor(LiveActor* actor, const LiveActor* subActor)

void offSyncAlphaMaskSubActor(LiveActor* actor, const char* subActorName)

void offSyncAlphaMaskSubActorAll(LiveActor* actor)

void onSyncAlphaMaskSubActor(LiveActor* actor, const LiveActor* subActor)

void onSyncAlphaMaskSubActor(LiveActor* actor, const char* subActorName)

void onSyncAlphaMaskSubActorAll(LiveActor* actor)

auto isSyncAlphaMaskSubActor(const LiveActor* actor, const LiveActor* subActor) -> bool

void startActionSubActor(const LiveActor* actor, const char* subActorName, const char* action)

auto isActionEndSubActor(const LiveActor* actor, const char* subActorName) -> bool

auto isActionPlayingSubActor(const LiveActor* actor, const char* subActorName, const char* action) -> bool

auto isActionOneTimeSubActor(const LiveActor* actor, const char* subActorName) -> bool

auto isActionOneTimeSubActor(const LiveActor* actor, const char* subActorName, const char* action) -> bool

auto tryStartActionSubActorAll(const LiveActor* actor, const char* action) -> bool

void makeActorDeadSubActorAll(const LiveActor* actor)

void tryValidateCollisionPartsSubActorAll(LiveActor* actor)

void tryInvalidateCollisionPartsSubActorAll(LiveActor* actor)

static void syncStageSwitchMakeActorDead(LiveActor* actor)

auto calcChildStepCount(const ActorInitInfo& info) -> s32

void tryInitSubActorKeeperChildStep(LiveActor* actor, const ActorInitInfo& info)

void createChildStep(const ActorInitInfo& info, LiveActor* parent, bool isSyncClipping)

void registerConveyerSteps(DeriveActorGroup<ConveyerStep>* conveyerStepGroup, const ActorInitInfo& info)

auto isGreaterThanOrEqualToZero(f32 val) -> bool

void calcWorldPosFromGridIndex(sead::Vector3f* out, const sead::Matrix34f& matrix, const sead::Vector3i& in)

void calcGridIndexFromWorldPos(sead::Vector3i* out, const sead::Matrix34f& matrix, const sead::Vector3f& in)

auto calcGridIndexNext(const sead::Vector3f&, s32) -> sead::Vector3f

auto calcDegreeDirIndexSignedX(s32 index) -> f32

auto calcDegreeDirIndexSignedY(s32 index) -> f32

auto calcDegreeDirIndexSignedZ(s32 index) -> f32

auto calcDirIndexNearXY(const sead::Vector3i&, const sead::Vector3i&) -> f32

auto signDirIndexX(s32) -> f32

auto signDirIndexY(s32) -> f32

auto signDirIndexZ(s32) -> f32

void calcGridMinMaxFromOBB(sead::Vector3i*, sead::Vector3i*, const sead::Matrix34f&, const sead::Matrix34f&, const sead::BoundBox3f&)

void expandGridFromOBB(sead::Vector3i*, sead::Vector3i*, const sead::Matrix34f&, const sead::Matrix34f&, const sead::BoundBox3f&)

auto calcAngleRadian(const sead::Vector3f& a, const sead::Vector3f& b) -> f32

auto calcAngleDegree(const sead::Vector3f& a, const sead::Vector3f& b) -> f32

auto calcAngleDegree(const sead::Vector2f& a, const sead::Vector2f& b) -> f32

auto isNearZero(const sead::Vector2f& vec, f32 tolerance) -> bool

auto tryCalcAngleDegree(f32* out, const sead::Vector3f& a, const sead::Vector3f& b) -> bool

auto isNearZero(const sead::Vector3f& vec, f32 tolerance) -> bool

auto calcAngleOnPlaneRadian(const sead::Vector3f& a, const sead::Vector3f& b, const sead::Vector3f& vertical) -> f32

void verticalizeVec(sead::Vector3f* out, const sead::Vector3f& vertical, const sead::Vector3f& vec)

auto calcAngleOnPlaneDegree(const sead::Vector3f& a, const sead::Vector3f& b, const sead::Vector3f& vertical) -> f32

auto calcAngleOnPlaneDegreeOrZero(const sead::Vector3f& a, const sead::Vector3f& b, const sead::Vector3f& vertical) -> f32

auto isParallelDirection(const sead::Vector3f& a, const sead::Vector3f& b, f32 tolerance) -> bool

auto calcAngleSignOnPlane(const sead::Vector3f& a, const sead::Vector3f& b, const sead::Vector3f& vertical) -> s32

auto isNearAngleRadian(const sead::Vector2f& a, const sead::Vector2f& b, f32 tolerance) -> bool

void normalize(sead::Vector2f* out, const sead::Vector2f& vec)

auto isNearAngleRadian(const sead::Vector3f& a, const sead::Vector3f& b, f32 tolerance) -> bool

void normalize(sead::Vector3f* out, const sead::Vector3f& vec)

auto isNearAngleDegree(const sead::Vector2f& a, const sead::Vector2f& b, f32 tolerance) -> bool

auto isNearAngleDegree(const sead::Vector3f& a, const sead::Vector3f& b, f32 tolerance) -> bool

auto tryNormalizeOrZero(sead::Vector3f* vec) -> bool

auto tryNormalizeOrZero(sead::Vector3f* out, const sead::Vector3f& vec) -> bool

auto isNearAngleDegreeHV(const sead::Vector3f& a, const sead::Vector3f& b, const sead::Vector3f& c, f32 d, f32 e) -> bool

auto isNear(f32 value, f32 target, f32 tolerance) -> bool

auto isNear(const sead::Vector2f& value, const sead::Vector2f& target, f32 tolerance) -> bool

auto isNear(const sead::Vector3f& value, const sead::Vector3f& target, f32 tolerance) -> bool

auto isNear(const sead::Color4f& value, const sead::Color4f& target, f32 tolerance) -> bool

auto isNearZero(f32 value, f32 tolerance) -> bool

auto isNearZero(const sead::Matrix34f& value, f32 tolerance) -> bool

auto isNearZeroOrGreater(f32 value, f32 tolerance) -> bool

auto isNearZeroOrLess(f32 value, f32 tolerance) -> bool

auto isExistNearZeroVal(const sead::Vector3f& vec, f32 tolerance) -> bool

auto isNormalize(const sead::Vector3f& vec, f32 tolerance) -> bool

auto isParallelDirection(const sead::Vector2f& a, const sead::Vector2f& b, f32 tolerance) -> bool

auto isNearDirection(const sead::Vector2f& a, const sead::Vector2f& b, f32 tolerance) -> bool

auto isInRange(s32 x, s32 a, s32 b) -> bool

auto isInRange(f32 x, f32 a, f32 b) -> bool

void normalize(sead::Vector2f* vec)

void normalize(sead::Vector3f* vec)

void normalize(sead::Matrix33f* mtx)

void normalize(sead::Matrix34f* mtx)

auto tryNormalizeOrZero(sead::Vector2f* vec) -> bool

auto tryNormalizeOrZero(sead::Vector2f* out, const sead::Vector2f& vec) -> bool

auto tryNormalizeOrDirZ(sead::Vector3f* vec) -> bool

auto tryNormalizeOrDirZ(sead::Vector3f* out, const sead::Vector3f& vec) -> bool

auto getMaxAbsElementIndex(const sead::Vector3f& vec) -> u32

void setLength(sead::Vector3f* vec, f32 length)

void setProjectionLength(sead::Vector3f* out, const sead::Vector3f& vec, f32 length)

auto limitLength(sead::Vector2f* out, const sead::Vector2f& vec, f32 limit) -> bool

auto limitLength(sead::Vector3f* out, const sead::Vector3f& vec, f32 limit) -> bool

auto normalizeAbs(f32 x, f32 min, f32 max) -> f32

auto normalize(f32 x, f32 min, f32 max) -> f32

auto normalize(s32 x, s32 min, s32 max) -> f32

auto sign(f32 x) -> f32

auto sign(s32 x) -> s32

auto cubeRoot(f32 x) -> f32

void clampV3f(sead::Vector3f* out, const sead::Vector3f& min, const sead::Vector3f& max)

void clampV2f(sead::Vector2f* out, const sead::Vector2f& min, const sead::Vector2f& max)

auto easeIn(f32 t) -> f32

auto easeOut(f32 t) -> f32

auto easeInOut(f32 t) -> f32

auto squareIn(f32 t) -> f32

auto squareOut(f32 t) -> f32

auto powerIn(f32 t, f32 exp) -> f32

auto powerOut(f32 t, f32 exp) -> f32

auto logarithmIn(f32 t, f32 base) -> f32

auto logarithmOut(f32 t, f32 base) -> f32

auto exponentIn(f32 t, f32 exp) -> f32

auto exponentOut(f32 t, f32 exp) -> f32

auto hermiteRate(f32 t, f32 m0, f32 m1) -> f32

auto calcFourthOrderRate(f32 t, f32 scale) -> f32

auto calcTriangleWave01(f32 t, f32 period) -> f32

auto calcTriangleWave(f32 t, f32 min, f32 max, f32 period) -> f32

auto lerpValue(f32 a, f32 b, f32 t) -> f32

auto calcRate01(f32 t, f32 min, f32 max) -> f32

auto easeByType(f32 t, s32 easeType) -> f32

auto hermite(f32 y0, f32 m0, f32 y1, f32 m1, f32 t) -> f32

auto hermite(f32 y0, f32 m0, f32 y1, f32 m1, f32 t, f32 width) -> f32

auto reverseBit8(u8 x) -> u8

auto reverseBit16(u16 x) -> u16

auto reverseBit32(u32 x) -> u32

auto calcVanDerCorput(u32 x) -> f32

void calcHammersleyPoint(sead::Vector2f* outPoint, u32 i, u32 num)

auto getRandom() -> f32

auto getRandom(f32 factor) -> f32

auto getRandom(f32 min, f32 max) -> f32

auto getRandom(s32 factor) -> s32

auto getRandom(s32 min, s32 max) -> s32

auto getRandomDegree() -> f32

auto getRandomRadian() -> f32

void getRandomVector(sead::Vector3f* vec, f32 factor)

void getRandomDir(sead::Vector3f* vec)

auto modf(f32 a, f32 b) -> f32

auto modi(s32 a, s32 b) -> s32

auto calcSpeedMax(f32 accel, f32 friction) -> f32

auto calcAccel(f32 speed, f32 friction) -> f32

auto calcFriction(f32 accel, f32 speed) -> f32

auto round(f32 v) -> f32

void roundOffVec(sead::Vector3f* outVec, const sead::Vector3f& vec)

void roundOffVec(sead::Vector3f* vec)

void roundOffVec(sead::Vector2f* outVec, const sead::Vector2f& vec)

void roundOffVec(sead::Vector2f* vec)

auto snapToGrid(f32 val, f32 gridSize, f32 offset) -> f32

void snapVecToGrid(sead::Vector3f* outVec, const sead::Vector3f& vec, f32 gridSize, const sead::Vector3f& offset)

void snapVecToGrid(sead::Vector3f* outVec, const sead::Vector3f& vec, const sead::Vector3f& gridSize, const sead::Vector3f& offset)

void limitVectorOppositeDir(sead::Vector3f* outVec, const sead::Vector3f& inVec, const sead::Vector3f& dir, f32 scale)

void scaleVectorDirection(sead::Vector3f* outVec, const sead::Vector3f& inVec, const sead::Vector3f& dir, f32 scale)

void scaleVectorExceptDirection(sead::Vector3f* outVec, const sead::Vector3f& inVec, const sead::Vector3f& dir, f32 scale)

auto calcDir(sead::Vector3f* outVec, const sead::Vector3f& vecA, const sead::Vector3f& vecB) -> bool

auto calcDirH(sead::Vector3f* outVec, const sead::Vector3f& vecA, const sead::Vector3f& vecB) -> bool

auto calcDirOnPlane(sead::Vector3f* outVec, const sead::Vector3f& vecA, const sead::Vector3f& vecB, const sead::Vector3f& plane) -> bool

auto mapRangeLogarithmic(f32 x, f32 min, f32 max, f32 start, f32 end, f32 exponent) -> f32

void calcDirFromLongitudeLatitude(sead::Vector3f* outVec, f32 longitude, f32 latitude)

void calcLongitudeLatitudeFromDir(f32* longitude, f32* latitude, const sead::Vector3f& dir)

auto getMaxAbsElementIndex(const sead::Vector3i& vec) -> u32

auto getMaxAbsElementValue(const sead::Vector3f& vec) -> f32

auto getMaxAbsElementValue(const sead::Vector3i& vec) -> s32

auto getMinAbsElementIndex(const sead::Vector3f& vec) -> u32

auto getMinAbsElementIndex(const sead::Vector3i& vec) -> u32

auto getMinAbsElementValue(const sead::Vector3f& vec) -> f32

auto getMinAbsElementValue(const sead::Vector3i& vec) -> s32

void makeQuatFromTwoAxis(sead::Quatf* outQuat, const sead::Vector3f& vectorA, const sead::Vector3f& vectorB, s32 axisA, s32 axisB)

void makeQuatFrontUp(sead::Quatf* outQuat, const sead::Vector3f& front, const sead::Vector3f& up)

void makeQuatFrontSide(sead::Quatf* outQuat, const sead::Vector3f& front, const sead::Vector3f& side)

void makeQuatFrontNoSupport(sead::Quatf* outQuat, const sead::Vector3f& front)

void makeQuatUpFront(sead::Quatf* outQuat, const sead::Vector3f& up, const sead::Vector3f& front)

void makeQuatUpSide(sead::Quatf* outQuat, const sead::Vector3f& up, const sead::Vector3f& side)

void makeQuatUpNoSupport(sead::Quatf* outQuat, const sead::Vector3f& up)

void makeQuatSideUp(sead::Quatf* outQuat, const sead::Vector3f& side, const sead::Vector3f& up)

void makeQuatSideFront(sead::Quatf* outQuat, const sead::Vector3f& side, const sead::Vector3f& front)

void makeQuatSideNoSupport(sead::Quatf* outQuat, const sead::Vector3f& side)

void rotateQuatRadian(sead::Quatf* outQuat, const sead::Quatf& quat, const sead::Vector3f& vec, f32 angle)

void makeQuatXDegree(sead::Quatf* outQuat, f32 angle)

void makeQuatYDegree(sead::Quatf* outQuat, f32 angle)

void makeQuatZDegree(sead::Quatf* outQuat, f32 angle)

void rotateQuatXDirDegree(sead::Quatf* outQuat, const sead::Quatf& quat, f32 angle)

void rotateQuatYDirDegree(sead::Quatf* outQuat, const sead::Quatf& quat, f32 angle)

void rotateQuatZDirDegree(sead::Quatf* outQuat, const sead::Quatf& quat, f32 angle)

void rotateQuatLocalDirDegree(sead::Quatf* outQuat, const sead::Quatf& quat, s32 axis, f32 angle)

void rotateQuatMoment(sead::Quatf* outQuat, const sead::Quatf& quat, const sead::Vector3f& vec)

void rotateQuatMomentDegree(sead::Quatf* outQuat, const sead::Quatf& quat, const sead::Vector3f& vec)

void rotateQuatRollBall(sead::Quatf* outQuat, const sead::Quatf& quat, const sead::Vector3f& vecA, const sead::Vector3f& vecB, f32 scale)

void calcMomentRollBall(sead::Vector3f* outVec, const sead::Vector3f& vecA, const sead::Vector3f& vecB, f32 scale)

void calcCirclePointPicking(sead::Vector2f* outPoint, f32 x, f32 y)

void pickUniformPointsOnCircleHammersley(sead::Vector2f* outPoint, u32 x, u32 y)

void calcDiskPointPicking(sead::Vector2f* outPoint, f32 radius, f32 angle)

void pickUniformPointsOnDiskHammersley(sead::Vector2f* outPoint, u32 x, u32 y)

void pickUniformPointOnDisk(sead::Vector2f* outPoint)

void calcSpherePointPicking(sead::Vector3f* outPoint, f32 x, f32 y)

void pickUniformPointOnSphere(sead::Vector3f* outPoint)

void calcParabolicFunctionParam(f32* gravity, f32* initialVelY, f32 maxHeight, f32 verticalDistance)

template<typename T>

auto clamp(T value, T min, T max) -> T

auto tryCalcAngleOnPlaneDegree(f32* angle, const sead::Vector3f& a, const sead::Vector3f& b, const sead::Vector3f& vertical) -> bool

auto isNearAngleRadianHV(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32, f32) -> bool

auto isInAngleOnPlaneDegreeHV(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32, f32, f32, f32) -> bool

auto isNormalize(const sead::Matrix34f& mtx) -> bool

auto isReverseDirection(const sead::Vector3f& a, const sead::Vector3f& b, f32 tolerance = 0.01f) -> bool

auto isNearDirection(const sead::Vector3f& a, const sead::Vector3f& b, f32 tolerance = 0.01f) -> bool

void normalizeComplement(sead::Matrix34f* mtx)

auto lerpValue(f32, f32, f32, f32, f32) -> f32

auto lerpDegree(f32, f32, f32) -> f32

auto lerpRadian(f32, f32, f32) -> f32

void lerpVec(sead::Vector2f*, const sead::Vector2f&, const sead::Vector2f&, f32)

void lerpVec(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32)

void lerpVecHV(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

void separateVectorHV(sead::Vector3f*, sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&)

void lerpColor(sead::Color4f*, const sead::Color4f&, const sead::Color4f&, f32)

auto lerpLogValueEaseIn(f32, f32, f32, f32) -> f32

auto lerpLogValueEaseOut(f32, f32, f32, f32) -> f32

void lerpLogVecEaseIn(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

void lerpLogVecEaseOut(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

auto lerpExponentValueEaseIn(f32, f32, f32, f32) -> f32

auto lerpExponentValueEaseOut(f32, f32, f32, f32) -> f32

void lerpExponentVecEaseIn(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

void lerpExponentVecEaseOut(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

auto clampLeapMinAbs(f32, f32, f32, f32) -> f32

void hermiteVec(sead::Vector3f* out, const sead::Vector3f& p0, const sead::Vector3f& v0, const sead::Vector3f& p1, const sead::Vector3f& v1, f32 t)

auto converge(s32, s32, s32) -> s32

auto converge(f32, f32, f32) -> f32

auto convergeDegree(f32, f32, f32) -> f32

auto convergeRadian(f32, f32, f32) -> f32

void convergeVec(sead::Vector2f*, const sead::Vector2f&, const sead::Vector2f&, f32)

void convergeVec(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32)

auto diffNearAngleDegree(f32, f32) -> f32

auto isInRangeAngleDegree(f32, f32, f32) -> bool

auto calcEyesAnimAngleInRange(f32*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32, f32, f32, f32) -> bool

auto isSameSign(f32, f32) -> bool

auto findMaxFromArray(const s32*, s32) -> s32

void separateMinMax(sead::Vector3f*, sead::Vector3f*, const sead::Vector3f&)

auto findMinFromArray(const s32*, s32) -> s32

void getRandomDirH(sead::Vector3f*, const sead::Vector3f&)

void rotateVectorDegree(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32)

void getRandomOnCircle(sead::Vector2f*, f32)

void getRandomInCircle(sead::Vector2f*, f32)

void getRandomInCircleMinMaxRadius(sead::Vector2f*, f32, f32)

void getRandomInCircle(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32)

void getRandomOnSphere(sead::Vector3f*, f32)

void getRandomInSphere(sead::Vector3f*, f32)

auto calcRandomDirInCone(sead::Vector3f*, const sead::Vector3f&, f32) -> bool

void getRandomInSphereMinMaxRadius(sead::Vector3f*, f32, f32)

void initRandomSeed(u32)

void initRandomSeedByTick()

void initRandomSeedByString(const char*)

auto isHalfProbability() -> bool

auto isPercentProbability(f32) -> bool

void getRandomContext(u32*, u32*, u32*, u32*)

void setRandomContext(u32, u32, u32, u32)

void makeRandomDirXZ(sead::Vector3f*)

auto calcBoxMullerRandomGauss() -> f32

void makeBoxMullerRandomGauss(sead::Vector2f*, f32, f32)

auto separateScalarAndDirection(f32*, sead::Vector2f*, const sead::Vector2f&) -> bool

auto separateScalarAndDirection(f32*, sead::Vector3f*, const sead::Vector3f&) -> bool

void limitVectorSeparateHV(sead::Vector3f*, const sead::Vector3f&, f32, f32)

void parallelizeVec(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&)

void calcVectorSeparateHV(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

void limitVectorParallelVertical(sead::Vector3f*, const sead::Vector3f&, f32, f32)

void separateVectorParallelVertical(sead::Vector3f*, sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&)

auto addVectorLimit(sead::Vector3f*, const sead::Vector3f&, f32) -> bool

void alongVectorNormalH(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

auto calcDistanceVecToPlane(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&) -> f32

void limitPlanePos(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

auto limitCylinderInPos(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

auto limitCylinderInDir(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&) -> bool

auto limitCylinderInPos(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

auto limitCylinderInDir(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&) -> bool

void snapVecToDirAxisY(sead::Vector3f*, const sead::Vector3f&, s32)

auto calcNearVecFromAxis2(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&) -> Axis

auto calcNearVecFromAxis3(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&) -> Axis

void calcDirVerticalAny(sead::Vector3f*, const sead::Vector3f&)

void calcDirSlide(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&)

auto calcNearVecFromAxis3(sead::Vector3f*, const sead::Vector3f&, const sead::Quatf&) -> Axis

void calcQuatLocalAxisAll(const sead::Quatf&, sead::Vector3f*, sead::Vector3f*, sead::Vector3f*)

void addRandomVector(sead::Vector3f*, const sead::Vector3f&, f32)

void turnRandomVector(sead::Vector3f*, const sead::Vector3f&, f32)

void makeAxisFrontUp(sead::Vector3f*, sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&)

void makeAxisFrontSide(sead::Vector3f*, sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&)

void makeAxisUpFront(sead::Vector3f*, sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&)

void makeAxisUpSide(sead::Vector3f*, sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&)

void makeQuatFromToQuat(sead::Quatf*, const sead::Quatf&, const sead::Quatf&)

void makeQuatRotationRate(sead::Quatf*, const sead::Vector3f&, const sead::Vector3f&, f32)

auto makeQuatRotationLimit(sead::Quatf*, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

void makeQuatAxisRotation(sead::Quatf*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32)

void makeQuatRotateDegree(sead::Quatf*, const sead::Vector3f&, f32)

void slerpQuat(sead::Quatf*, const sead::Quatf&, const sead::Quatf&, f32)

void calcQuatSide(sead::Vector3f* out, const sead::Quatf& quat)

void calcQuatUp(sead::Vector3f* out, const sead::Quatf& quat)

void calcQuatGravity(sead::Vector3f* out, const sead::Quatf& quat)

void calcQuatFront(sead::Vector3f* out, const sead::Quatf& quat)

auto calcQuatUpY(const sead::Quatf&) -> f32

auto calcQuatFrontY(const sead::Quatf&) -> f32

void calcQuatLocalAxis(sead::Vector3f*, const sead::Quatf&, s32)

void calcQuatLocalSignAxis(sead::Vector3f*, const sead::Quatf&, s32)

void calcQuatRotateDegree(sead::Vector3f*, const sead::Quatf&)

void calcQuatRotateRadian(sead::Vector3f*, const sead::Quatf&)

void calcQuatRotateAxisAndDegree(sead::Vector3f*, f32*, const sead::Quatf&)

void calcQuatRotateAxisAndDegree(sead::Vector3f*, f32*, const sead::Quatf&, const sead::Quatf&)

auto turnQuat(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

auto turnQuatXDirRadian(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32) -> bool

auto turnQuatYDirRadian(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32) -> bool

auto turnQuatZDirRadian(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32) -> bool

void turnQuatXDirRate(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

void turnQuatYDirRate(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

void turnQuatZDirRate(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

void tiltQuatDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, const sead::Vector3f&, f32)

void tiltQuatXDirDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

void tiltQuatYDirDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

void tiltQuatZDirDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

auto turnQuatWithAxisDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

auto turnQuatXDirWithYDirDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32) -> bool

auto turnQuatXDirWithZDirDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32) -> bool

auto turnQuatYDirWithZDirDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32) -> bool

auto turnQuatYDirWithXDirDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32) -> bool

auto turnQuatZDirWithXDirDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32) -> bool

auto turnQuatZDirWithYDirDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32) -> bool

auto turnQuatZDirToTargetWithAxis(sead::Quatf*, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

auto turnQuatFrontToDirDegreeH(sead::Quatf*, const sead::Vector3f&, f32) -> bool

void rotateQuatAndTransDegree(sead::Quatf*, sead::Vector3f*, const sead::Quatf&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32)

auto turnVecToVecDegree(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

void turnVecToVecRate(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32)

auto turnVecToVecCos(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32, const sead::Vector3f&, f32) -> bool

auto turnVecToVecCosOnPlane(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

auto turnVecToVecCosOnPlane(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

void rotateVectorCenterDegree(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32)

void rotateVectorDegreeX(sead::Vector3f*, f32)

void rotateVectorDegreeY(sead::Vector3f*, f32)

void rotateVectorDegreeZ(sead::Vector3f*, f32)

void rotateVectorQuat(sead::Vector3f*, const sead::Quatf&)

auto calcAreaTriangle(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&) -> f32

void createBoundingBox(const sead::Vector3f*, u32, sead::Vector3f*, sead::Vector3f*)

void updateBoundingBox(sead::Vector3f, sead::Vector3f*, sead::Vector3f*)

auto calcDistanceToFarthestBoundingBoxVertex(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&) -> f32

void calcSphereMargeSpheres(sead::Vector3f*, f32*, const sead::Vector3f&, f32, const sead::Vector3f&, f32)

auto calcCrossLinePoint(sead::Vector2f*, const sead::Vector2f&, const sead::Vector2f&, const sead::Vector2f&, const sead::Vector2f&) -> bool

auto calcSquaredDistanceSegmentToSegment(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, sead::Vector3f*, sead::Vector3f*) -> f32

auto calcSquaredDistancePointToSegment(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&) -> f32

auto calcDistancePointToSegment(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&) -> f32

void calcPerpendicFootToLineInside(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

void calcClosestSegmentPoint(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

auto calcCylinderRadiusDot(const sead::Vector3f&, const sead::Vector3f&, f32) -> f32

auto checkHitSemilinePlane(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&) -> bool

auto checkHitSegmentPlane(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, bool) -> bool

auto checkHitLinePlane(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&) -> bool

auto checkHitSegmentSphere(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32, sead::Vector3f*, sead::Vector3f*) -> bool

auto checkHitSegmentSphereNearDepth(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32, sead::Vector3f*, sead::Vector3f*) -> bool

auto checkInCylinder(const sead::Vector3f&, const sead::Vector3f&, f32, const sead::Vector3f&, f32) -> bool

auto checkHitSegmentCylinder(const sead::Vector3f&, f32, const sead::Vector3f&, f32, const sead::Vector3f&, const sead::Vector3f&, sead::Vector3f*, sead::Vector3f*) -> bool

auto checkHitHalfLineSphere(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

auto checkHitSegmentBox(const sead::Vector3f&, const sead::Vector3f&, const sead::BoundBox3f&, sead::Vector3f*) -> bool

auto checkHitPointCone(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32, f32) -> bool

auto checkHitSphereCone(const sead::Vector3f&, f32, const sead::Vector3f&, const sead::Vector3f&, f32, f32) -> bool

auto checkHitSphereSpotLight(const sead::Vector3f&, f32, const sead::Vector3f&, const sead::Vector3f&, f32, f32) -> bool

auto calcBoundingSphereSpotLight(sead::Vector3f*, f32*, const sead::Vector3f&, const sead::Vector3f&, f32, f32) -> bool

void calcBoundingSphereBox3f(sead::Vector3f*, f32*, const sead::BoundBox3f&)

void calcArrowAabb(sead::BoundBox3f*, const sead::Vector3f&, const sead::Vector3f&)

auto isNearCollideSphereAabb(const sead::Vector3f&, f32, const sead::BoundBox3f&) -> bool

void calcBoxFacePoint(sead::Vector3f[4], const sead::BoundBox3f&, Axis)

void calcBoxFacePoint(sead::Vector3f[4], const sead::BoundBox3f&, Axis, const sead::Matrix34f&)

void calcBoxFacePoint(sead::Vector3f[4], const sead::BoundBox3f&, Axis, const sead::Quatf&, const sead::Vector3f&)

void calcFittingBoxPoseEqualAxisAll(sead::Quatf*, const sead::Quatf&, const sead::Quatf&)

void calcFittingBoxPoseEqualAxisNone(sead::Quatf*, const sead::Quatf&, const sead::Quatf&)

void calcFittingBoxPoseEqualAxisTwo(sead::Quatf*, const sead::Quatf&, const sead::Quatf&, s32)

void calcFittingBoxPose(sead::Quatf*, const sead::BoundBox3f&, const sead::Quatf&, const sead::Quatf&)

auto calcSquaredDistanceToObb(const sead::Vector3f&, const sead::Matrix34f&, const sead::Vector3f&) -> f32

auto calcDistanceToObb(const sead::Vector3f&, const sead::Matrix34f&, const sead::Vector3f&) -> f32

auto calcSquaredDistanceToObb(const sead::Vector3f&, const sead::Matrix34f&, const sead::Vector3f&, const sead::BoundBox3f&) -> f32

auto calcDistanceToObb(const sead::Vector3f&, const sead::Matrix34f&, const sead::Vector3f&, const sead::BoundBox3f&) -> f32

auto calcSquaredDistanceToObb(const sead::Vector3f&, const sead::Matrix34f&) -> f32

auto calcDistanceToObb(const sead::Vector3f&, const sead::Matrix34f&) -> f32

void calcObbCorners(sead::Vector3f*, const sead::Matrix34f&, const sead::BoundBox3f&)

auto calcTriangleInteriorAngleDegree(f32*, f32*, f32*, f32, f32, f32) -> bool

auto calcBetweenTwoLinkMtx(sead::Matrix34f*, sead::Matrix34f*, sead::Matrix34f*, const sead::Vector3f&, const sead::Vector3f&, f32, f32) -> bool

auto calcBetweenTwoLinkPos(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32, f32, const sead::Vector3f&) -> bool

auto calcReflectionVector(sead::Vector3f*, const sead::Vector3f&, f32, f32) -> bool

void calcReverseVector(sead::Vector3f*, const sead::Vector3f&, f32)

auto calcConvergeVibrationValue(f32, f32, f32, f32, f32) -> f32

auto calcSphericalPolarCoordPY(sead::Vector2f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&) -> bool

void calcBezierPoint(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32)

auto calcSpringDumperForce(f32, f32, f32, f32) -> f32

auto convertSpringEnergyToSpeed(f32, f32, f32) -> f32

auto axisIndexToString(s32) -> const char*

void visitCellsOverlapped(const sead::Vector3f&, const sead::Vector3f&, f32, const VisitCellCallBack&)

auto calcMultValueToDestination(u32, f32, f32) -> f32

auto getHaltonSequence(u32, u32) -> f32

auto calcFractal(f32, f32, u32, f32, f32, f32, bool) -> f32

auto calcMultiFractal(f32, f32, f32, u32, f32, f32, f32, bool) -> f32

auto calcNormalDistribution(f32, f32, f32) -> f32

auto calcVecViewInput(sead::Vector3f*, const sead::Vector2f&, const sead::Vector3f&, const sead::Matrix34f*) -> bool

auto calcDirViewInput(sead::Vector3f*, const sead::Vector2f&, const sead::Vector3f&, const sead::Matrix34f*) -> bool

auto calcVecViewInput2D(sead::Vector3f*, const sead::Vector2f&, const sead::Vector3f&, const sead::Matrix34f*) -> bool

auto calcDirViewInput2D(sead::Vector3f*, const sead::Vector2f&, const sead::Vector3f&, const sead::Matrix34f*) -> bool

void calcBendPosAndFront(sead::Vector3f*, sead::Vector3f*, sead::Vector3f&, f32, const sead::Vector3f&, const sead::Vector3f&, f32)

void pickUniformPointsOnCircleHammersley(sead::Vector2f* outPoint, f32 x, f32 y)

void makeBayerMatrix(s32*, s32)

auto f32ToF16(f32) -> u16

auto f16ToF32(u16) -> f32

void makeMtxRotateTrans(sead::Matrix34f* outMtx, const sead::Vector3f& rotate, const sead::Vector3f& trans)

void makeMtxFromTwoAxis(sead::Matrix34f* outMtx, const sead::Vector3f& vectorA, const sead::Vector3f& vectorB, s32 axisA, s32 axisB)

void makeMtxFrontUp(sead::Matrix34f* outMtx, const sead::Vector3f& front, const sead::Vector3f& up)

void makeMtxFrontSide(sead::Matrix34f* outMtx, const sead::Vector3f& front, const sead::Vector3f& side)

void makeMtxUpFront(sead::Matrix34f* outMtx, const sead::Vector3f& up, const sead::Vector3f& front)

void makeMtxUpSide(sead::Matrix34f* outMtx, const sead::Vector3f& up, const sead::Vector3f& side)

void makeMtxSideUp(sead::Matrix34f* outMtx, const sead::Vector3f& side, const sead::Vector3f& up)

void makeMtxSideFront(sead::Matrix34f* outMtx, const sead::Vector3f& side, const sead::Vector3f& front)

void makeMtxFrontNoSupport(sead::Matrix34f* outMtx, const sead::Vector3f& front)

void makeMtxFrontNoSupportPos(sead::Matrix34f* outMtx, const sead::Vector3f& front, const sead::Vector3f& pos)

void makeMtxUpNoSupport(sead::Matrix34f* outMtx, const sead::Vector3f& up)

void makeMtxUpNoSupportPos(sead::Matrix34f* outMtx, const sead::Vector3f& up, const sead::Vector3f& pos)

void makeMtxFrontUpPos(sead::Matrix34f* outMtx, const sead::Vector3f& front, const sead::Vector3f& up, const sead::Vector3f& pos)

void makeMtxFrontSidePos(sead::Matrix34f* outMtx, const sead::Vector3f& front, const sead::Vector3f& side, const sead::Vector3f& pos)

void makeMtxUpFrontPos(sead::Matrix34f* outMtx, const sead::Vector3f& up, const sead::Vector3f& front, const sead::Vector3f& pos)

void makeMtxUpSidePos(sead::Matrix34f* outMtx, const sead::Vector3f& up, const sead::Vector3f& side, const sead::Vector3f& pos)

void makeMtxSideUpPos(sead::Matrix34f* outMtx, const sead::Vector3f& side, const sead::Vector3f& up, const sead::Vector3f& pos)

void makeMtxSideFrontPos(sead::Matrix34f* outMtx, const sead::Vector3f& side, const sead::Vector3f& front, const sead::Vector3f& pos)

void makeMtxFollowTarget(sead::Matrix34f* outMtx, const sead::Matrix34f& baseMtx, const sead::Vector3f& trans, const sead::Vector3f& rotate)

void rotateMtxXDirDegree(sead::Matrix34f* outMtx, const sead::Matrix34f& baseMtx, f32 angle)

void rotateMtxYDirDegree(sead::Matrix34f* outMtx, const sead::Matrix34f& baseMtx, f32 angle)

void rotateMtxZDirDegree(sead::Matrix34f* outMtx, const sead::Matrix34f& baseMtx, f32 angle)

void calcMtxScale(sead::Vector3f* outMtx, const sead::Matrix34f& mtx)

void calcMtxScale(sead::Vector3f* outMtx, const Matrix43f& mtx)

void normalizeMtxScale(sead::Matrix34f* outMtx, const sead::Matrix34f& mtx)

auto tryNormalizeMtxScaleOrIdentity(sead::Matrix34f* outMtx, const sead::Matrix34f& mtx) -> bool

void preScaleMtx(sead::Matrix34f* outMtx, const sead::Vector3f& scale)

void makeMtxSideNoSupport(sead::Matrix34f* outMtx, const sead::Vector3f& side)

void makeMtxSideNoSupportPos(sead::Matrix34f* outMtx, const sead::Vector3f& side, const sead::Vector3f& pos)

void makeMtxQuatPos(sead::Matrix34f* outMtx, const sead::Quatf& quat, const sead::Vector3f& pos)

void makeMtxQuatScalePos(sead::Matrix34f* outMtx, const sead::Quatf& quat, const sead::Vector3f& scale, const sead::Vector3f& pos)

void makeMtxQuatScalePos(sead::Matrix44f* outMtx, const sead::Quatf& quat, const sead::Vector3f& scale, const sead::Vector3f& pos)

void makeMtxProj(sead::Matrix44f*, const sead::Vector2f&, const sead::Vector3f&, const sead::Vector3f&)

void makeMtxProjFromQuatPoseUp(sead::Matrix44f*, const sead::Quatf&, const sead::Vector2f&, const sead::Vector3f&)

void makeMtxProjFromQuatPoseFront(sead::Matrix44f*, const sead::Quatf&, const sead::Vector2f&, const sead::Vector3f&)

void makeMtxProjFromQuatPoseSide(sead::Matrix44f*, const sead::Quatf&, const sead::Vector2f&, const sead::Vector3f&)

void makeMtxProjFromUp(sead::Matrix44f*, const sead::Vector2f&, const sead::Vector3f&)

void rotateMtxCenterPosXDirDegree(sead::Matrix34f*, const sead::Matrix34f&, const sead::Vector3f&, f32)

void rotateMtxCenterPosAxisDegree(sead::Matrix34f*, const sead::Matrix34f&, const sead::Vector3f&, const sead::Vector3f&, f32)

void rotateMtxCenterPosYDirDegree(sead::Matrix34f*, const sead::Matrix34f&, const sead::Vector3f&, f32)

void rotateMtxCenterPosZDirDegree(sead::Matrix34f*, const sead::Matrix34f&, const sead::Vector3f&, f32)

void rotateMtxCenterPosQuat(sead::Matrix34f*, const sead::Matrix34f&, const sead::Vector3f&, const sead::Quatf&)

auto turnMtxXDirDegree(sead::Matrix34f*, const sead::Matrix34f&, const sead::Vector3f&, f32) -> bool

auto turnMtxYDirDegree(sead::Matrix34f*, const sead::Matrix34f&, const sead::Vector3f&, f32) -> bool

auto turnMtxZDirDegree(sead::Matrix34f*, const sead::Matrix34f&, const sead::Vector3f&, f32) -> bool

void calcCameraPosFromViewMtx(sead::Vector3f*, const sead::Matrix34f&)

void calcMtxMul(sead::Vector3f*, const sead::Matrix34f&, const sead::Vector3f&)

void calcMtxMul(sead::Vector3f*, const Matrix43f&, const sead::Vector3f&)

void calcMtxLocalTrans(sead::Vector3f*, const sead::Matrix34f&, const sead::Vector3f&)

void calcTransLocalOffsetByMtx(sead::Vector3f*, const sead::Matrix34f&, const sead::Vector3f&)

void addTransMtxLocalOffset(sead::Matrix34f*, const sead::Matrix34f&, const sead::Vector3f&)

void blendMtx(sead::Matrix34f*, const sead::Matrix34f&, const sead::Matrix34f&, f32)

void blendMtxRotate(sead::Matrix34f*, const sead::Matrix34f&, const sead::Matrix34f&, f32)

void blendMtxTrans(sead::Matrix34f*, const sead::Matrix34f&, const sead::Matrix34f&, f32)

auto calcMtxLocalDirAngleOnPlaneToTarget(const sead::Matrix34f*, const sead::Vector3f&, s32, s32) -> f32

auto calcMtxLocalDirAngleOnPlaneToDir(const sead::Matrix34f*, const sead::Vector3f&, s32, s32) -> f32

auto calcRotAxisOrZero(sead::Vector3f*, const sead::Matrix34f&) -> bool

void calcMxtInvertOrtho(sead::Matrix34f*, const sead::Matrix34f&)

void calcNearFarByInvProjection(f32*, f32*, const sead::Matrix44f&)

void calcMovedInertiaTensor(sead::Matrix33f*, const sead::Matrix33f&, const sead::Vector3f&, f32)

void calcInertiaTensorByMovedTensorAndCenter(sead::Matrix33f*, const sead::Matrix33f&, const sead::Vector3f&, f32)

void calcInertiaTensorSphere(sead::Matrix33f*, f32, f32)

void calcInertiaTensorBox(sead::Matrix33f*, const sead::Vector3f&, f32)

void makeMtx34f(sead::Matrix34f*, const nn::util::neon::MatrixColumnMajor4x3fType&)

void makeMtx44f(sead::Matrix44f*, const nn::util::neon::MatrixColumnMajor4x4fType&)

auto getStationedHeap() -> sead::Heap*

auto getSequenceHeap() -> sead::Heap*

auto getSceneResourceHeap() -> sead::Heap*

auto getSceneHeap() -> sead::Heap*

auto getCourseSelectResourceHeap() -> sead::Heap*

auto getCourseSelectHeap() -> sead::Heap*

auto getWorldResourceHeap() -> sead::Heap*

auto tryFindNamedHeap(const char* heapName) -> sead::Heap*

auto findNamedHeap(const char* heapName) -> sead::Heap*

void addNamedHeap(sead::Heap* heap, const char* heapName)

void removeNamedHeap(const char* heapName)

void createSequenceHeap()

void freeAllSequenceHeap()

auto printAllSequenceHeap() -> bool

void createSceneHeap(const char* stageName, bool backwards)

void createSceneResourceHeap(const char* stageName)

auto isCreatedSceneResourceHeap() -> bool

void destroySceneHeap(bool removeCategory)

void createCourseSelectHeap()

void destroyCourseSelectHeap()

void createWorldResourceHeap(bool useCategory)

void destroyWorldResourceHeap(bool removeCategory)

void loadPlayerResource(const char* categoryName)

void freePlayerResource(const char* categoryName)

void setAudioResourceDirectorToMemorySystem(AudioResourceDirector* audioResourceDirector)

auto getLanguage() -> const char*

auto getLayoutMessageArcName() -> const char*

auto isMessageTagMark(char16) -> bool

auto isMessageTagEndMark(char16) -> bool

auto isMessageTagPageBreak(const IUseMessageSystem*, const char16*) -> bool

auto isMessageTagPageBreak(const IUseMessageSystem*, const MessageTag&) -> bool

auto isMessageTagPageBreak(const MessageProjectEx*, const MessageTag&) -> bool

auto getMessageTagGroupName(const MessageProjectEx*, s32) -> const char*

auto getMessageTagGroupName(const IUseMessageSystem*, s32) -> const char*

auto getMessageTagName(const MessageProjectEx*, s32, s32) -> const char*

auto getMessageTagName(const IUseMessageSystem*, s32, s32) -> const char*

auto isExistMessageTag(const char16*) -> bool

auto calcMessageSizeWithoutNullCharacter(const char16*, const char16*) -> s32

auto isExistMessageTagTextPaneAnim(const IUseMessageSystem*, const char16*) -> bool

auto tryGetMessageTagTextAnim(sead::BufferedSafeString*, const IUseMessageSystem*, const char16*) -> bool

auto isMessageTagVoice(const IUseMessageSystem*, const char16*) -> bool

void getMessageTagVoiceName(sead::BufferedSafeString*, const IUseMessageSystem*, const char16*)

auto tryGetMessageTagVoiceNameInPage(sead::BufferedSafeString*, const IUseMessageSystem*, const char16*) -> bool

auto isMessageTagPictFont(const IUseMessageSystem*, s32) -> bool

auto isMessageTagDeviceFont(const IUseMessageSystem*, s32) -> bool

auto isExistMessageTagPadSwitch(const IUseMessageSystem*, const char16*, s32) -> bool

auto isMessageTagPadStyle(const IUseMessageSystem*, s32, s32) -> bool

auto isMessageTagPadPair(const IUseMessageSystem*, s32, s32) -> bool

auto isMessageTagPadStyle2P(const IUseMessageSystem*, s32, s32) -> bool

auto isMessageTagAlignLeft(const IUseMessageSystem*, s32, s32) -> bool

auto isMessageTagAlignCenter(const IUseMessageSystem*, s32, s32) -> bool

void replaceMessageTagString(sead::WBufferedSafeString*, const IUseMessageSystem*, const char16*, const char16*)

void replaceMessageTagTimeDirectRaceTime(sead::WBufferedSafeString*, const IUseMessageSystem*, ReplaceTimeInfo&)

auto getSystemMessageString(const IUseMessageSystem*, const char*, const char*) -> const char16*

void replaceMessageTagTimeDirectDate(sead::WBufferedSafeString*, const IUseMessageSystem*, ReplaceTimeInfo&)

void replaceMessageTagTimeDirectDateDetail(sead::WBufferedSafeString*, const IUseMessageSystem*, ReplaceTimeInfo&)

void replaceMessageTagScore(sead::WBufferedSafeString*, const IUseMessageSystem*, const char16*, s32, const char*)

void replaceMessageTagCoinNum(sead::WBufferedSafeString*, const IUseMessageSystem*, const char16*, s32, const char*)

void replaceMessageTagAmiiboName(sead::WBufferedSafeString*, const IUseMessageSystem*, const char16*, const char*, const char*)

void replaceMessageTagUserName(sead::WBufferedSafeString*, const IUseMessageSystem*, const char16*, const char16*, const char*)

void replaceMessageTagNamedString(sead::WBufferedSafeString*, const IUseMessageSystem*, const char16*, const char16*, const char*)

void replaceMessageTagTime(sead::WBufferedSafeString*, const IUseMessageSystem*, const char16*, ReplaceTimeInfo&, const char*)

void createReplaceTimeInfoForRaceTime(ReplaceTimeInfo*, s32, s32, s32)

void createReplaceTimeInfoForDateTime(ReplaceTimeInfo*, u64)

void replacePaneDateTime(LayoutActor*, const char*, u64)

auto initMessageTagDataHolder(s32) -> MessageTagDataHolder*

void registerMessageTagDataScore(MessageTagDataHolder*, const char*, const s32*)

void registerMessageTagDataCoinNum(MessageTagDataHolder*, const char*, const s32*)

void registerMessageTagDataUserName(MessageTagDataHolder*, const char*, const char16**)

void registerMessageTagDataAmiiboName(MessageTagDataHolder*, const char*, const char**)

void registerMessageTagDataString(MessageTagDataHolder*, const char*, const char16**)

void replaceMessageTagData(sead::WBufferedSafeString*, const IUseMessageSystem*, const MessageTagDataHolder*, const char16*)

auto calcMessageSizeWithoutTag(const char16*, const char16*) -> s32

auto isExistLayoutMessage(const IUseMessageSystem*, const char*) -> bool

auto isExistSystemMessage(const IUseMessageSystem*, const char*) -> bool

auto isExistStageMessage(const IUseMessageSystem*, const char*) -> bool

auto isExistLabelInLayoutMessage(const IUseMessageSystem*, const char*, const char*) -> bool

auto isExistLabelInSystemMessage(const IUseMessageSystem*, const char*, const char*) -> bool

auto isExistLabelInStageMessage(const IUseMessageSystem*, const char*, const char*) -> bool

auto calcSystemMessageCharacterNum(const IUseMessageSystem*, const char*, const char*) -> s32

auto calcSystemMessageCharacterNumWithoutTag(const IUseMessageSystem*, const char*, const char*) -> s32

auto getLayoutMessageString(const IUseMessageSystem*, const char*, const char*) -> const char16*

auto getStageMessageString(const IUseMessageSystem*, const char*, const char*) -> const char16*

auto tryGetStageMessageString(const char16**, const IUseMessageSystem*, const char*, const char*) -> bool

auto getLayoutMessageString(const IUseMessageSystem*, const char*, s32) -> const char16*

auto getSystemMessageString(const IUseMessageSystem*, const char*, s32) -> const char16*

auto getSystemMessageLabelNum(const IUseMessageSystem*, const char*) -> s32

auto getLayoutMessageLabelNum(const IUseMessageSystem*, const char*) -> s32

auto getMessageTagParamName(const IUseMessageSystem*, const MessageTag&, s32) -> const char*

auto getMessageTagParamNum(const IUseMessageSystem*, const MessageTag&) -> s32

void getMessageTagParamString(sead::WBufferedSafeString*, const IUseMessageSystem*, const MessageTag&, s32)

void getSystemMessageLabelString(sead::BufferedSafeString*, const IUseMessageSystem*, const char*, s32)

void getLayoutMessageLabelString(sead::BufferedSafeString*, const IUseMessageSystem*, const char*, s32)

void getMessageLine(char16*, u32, const char16*, u32)

auto countMessageLine(const char16*) -> s32

auto copyMessageExpandTag(char16*, s32, const IUseMessageSystem*, const char16*) -> bool

auto copyMessageWithoutTag(char16*, s32, const char16*) -> bool

auto copyMessageWithoutRubyTag(char16*, s32, const IUseMessageSystem*, const char16*) -> bool

void copyMessageWithoutTagExpandRuby(char16*, s32, const IUseMessageSystem*, const char16*)

auto copyMessageWithTag(char16*, s32, const char16*) -> s32

auto copyMessageWithTagOnlyCurrentPage(const IUseMessageSystem*, char16*, s32, const char16*, s32) -> s32

auto getMessageWithPage(const IUseMessageSystem*, const char16*, s32) -> const char16*

void copyMessageOnlyRuby(char16*, s32, const IUseMessageSystem*, const char16*)

auto countMessagePage(const IUseMessageSystem*, const char16*, s32) -> s32

auto getNextMessagePage(const IUseMessageSystem*, const char16*) -> const char16*

auto getPictureFont(const LayoutSystem*) -> void*

auto isGreaterEqualMaxLodLevelNoClamp(const ModelKeeper* modelKeeper) -> bool

auto isLessMaxLodLevelNoClamp(const ModelKeeper* modelKeeper) -> bool

void setModelProjMtx0(const ModelKeeper*, const sead::Matrix44f&)

auto tryCreateRailMoveMovement(LiveActor* host, const ActorInitInfo& info) -> RailMoveMovement*

void registerFluidSurfaceObj(IUseFluidSurface*, const LiveActor*)

auto isExistFluidSurface(const LiveActor*) -> bool

void setWaterRippleFieldScale(const LiveActor*, f32)

auto isInWaterPos(const LiveActor*, const sead::Vector3f&) -> bool

auto isInWater(const LiveActor*) -> bool

auto isInWaterNoIgnore(const LiveActor*, const sead::Vector3f&) -> bool

auto isInSodaWater(const LiveActor*, const sead::Vector3f&) -> bool

auto isInIceWaterPos(const LiveActor*, const sead::Vector3f&) -> bool

auto isInIceWater(const LiveActor*) -> bool

auto isInFirePos(const LiveActor*, const sead::Vector3f&) -> bool

auto isInFire(const LiveActor*) -> bool

auto isInCloudPos(const LiveActor*, const sead::Vector3f&) -> bool

auto isInCloud(const LiveActor*) -> bool

auto tryAddRippleMiddle(const LiveActor*) -> bool

auto tryAddRippleLarge(const LiveActor*) -> bool

auto isWaterAreaIgnore(const AreaObj*) -> bool

auto getFireMaterialCode(const LiveActor*) -> const char*

auto calcFindWaterSurface(sead::Vector3f*, sead::Vector3f*, const LiveActor*, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

auto calcFindWaterSurfaceFlat(sead::Vector3f*, sead::Vector3f*, const LiveActor*, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

auto calcFindWaterSurfaceDisplacement(sead::Vector3f*, sead::Vector3f*, const LiveActor*, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

auto calcFindWaterSurfaceOverGround(sead::Vector3f*, sead::Vector3f*, const LiveActor*, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

auto calcFindFireSurface(sead::Vector3f*, sead::Vector3f*, const LiveActor*, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

auto calcFindCloudSurface(sead::Vector3f*, sead::Vector3f*, const LiveActor*, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

auto tryAddRipple(const NatureDirector*, const sead::Vector3f&, f32, f32) -> bool

auto tryAddRippleTiny(const LiveActor*) -> bool

auto tryAddRippleSmall(const LiveActor*, const sead::Vector3f&) -> bool

auto tryAddRippleTiny(const LiveActor*, const sead::Vector3f&) -> bool

auto tryAddRippleSmall(const LiveActor*) -> bool

auto tryAddRippleMiddle(const LiveActor*, const sead::Vector3f&) -> bool

auto tryAddRippleLarge(const LiveActor*, const sead::Vector3f&) -> bool

auto tryAddRippleWithRange(const LiveActor*, const sead::Vector3f&, f32, f32, f32, f32) -> bool

auto tryAddRipple(const LiveActor*, const sead::Vector3f&, f32, f32) -> bool

auto tryAddRippleRandomBlur(const LiveActor*, const sead::Vector3f&, f32, f32, f32) -> bool

auto tryAddQuadRipple(const LiveActor*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32) -> bool

auto tryAddQuadRipple(const LiveActor*, const sead::BoundBox3f&, const sead::Vector3f&, const sead::Quatf&, f32, f32) -> bool

auto tryAddQuadRippleByBoxRotateY(const LiveActor*, const sead::BoundBox3f&, const sead::Vector3f&, f32, f32, f32) -> bool

void approachWaterSurfaceSpringDumper(LiveActor*, const WaterSurfaceFinder*, f32, f32, f32, f32, f32)

void approachFireSurfaceSpringDumper(LiveActor*, const FireSurfaceFinder*, f32, f32, f32, f32, f32)

void approachWaterSurfaceRate(LiveActor*, const WaterSurfaceFinder*, f32, f32, f32)

void approachFireSurfaceRate(LiveActor*, const FireSurfaceFinder*, f32, f32, f32)

void keepWaterSurfaceHeight(LiveActor*, const WaterSurfaceFinder*, f32)

void syncWaterSurfaceTrans(LiveActor*, const WaterSurfaceFinder*)

void syncFireSurfaceTrans(LiveActor*, const FireSurfaceFinder*)

void syncWaterSurfaceTransH(LiveActor*, const WaterSurfaceFinder*)

void blendWaterSurfaceTransH(LiveActor*, const WaterSurfaceFinder*, f32)

void syncWaterSurfaceUp(LiveActor*, const WaterSurfaceFinder*, f32)

void syncFireSurfaceUp(LiveActor*, const FireSurfaceFinder*, f32)

void calcMatrixFromActorPoseAndWaterSurfaceH(sead::Matrix34f*, const WaterSurfaceFinder*, const LiveActor*)

void setNerve(IUseNerve* user, const Nerve* nerve)

void setNerveAtStep(IUseNerve* user, const Nerve* nerve, s32 step)

auto isStep(const IUseNerve* user, s32 step) -> bool

void setNerveAtGreaterEqualStep(IUseNerve* user, const Nerve* nerve, s32 step)

auto isNerve(const IUseNerve* user, const Nerve* nerve) -> bool

auto getNerveStep(const IUseNerve* user) -> s32

auto getCurrentNerve(const IUseNerve* user) -> const Nerve*

auto isFirstStep(const IUseNerve* user) -> bool

auto isGreaterStep(const IUseNerve* user, s32 step) -> bool

auto isGreaterEqualStep(const IUseNerve* user, s32 step) -> bool

auto isLessStep(const IUseNerve* user, s32 step) -> bool

auto isLessEqualStep(const IUseNerve* user, s32 step) -> bool

auto isInRangeStep(const IUseNerve* user, s32 startStep, s32 endStep) -> bool

auto isIntervalStep(const IUseNerve* user, s32 interval, s32 offset) -> bool

auto isIntervalOnOffStep(const IUseNerve* user, s32 interval, s32 offset) -> bool

auto isNewNerve(const IUseNerve* user) -> bool

auto calcNerveInterval(const IUseNerve* user, s32 interval, s32 offset) -> s32

auto calcNerveRate(const IUseNerve* user, s32 max) -> f32

auto calcNerveRate(const IUseNerve* user, s32 min, s32 max) -> f32

auto calcNerveEaseInRate(const IUseNerve* user, s32 max) -> f32

auto calcNerveEaseInRate(const IUseNerve* user, s32 min, s32 max) -> f32

auto calcNerveEaseOutRate(const IUseNerve* user, s32 max) -> f32

auto calcNerveEaseOutRate(const IUseNerve* user, s32 min, s32 max) -> f32

auto calcNerveEaseInOutRate(const IUseNerve* user, s32 max) -> f32

auto calcNerveEaseInOutRate(const IUseNerve* user, s32 min, s32 max) -> f32

auto calcNerveSquareInRate(const IUseNerve* user, s32 max) -> f32

auto calcNerveSquareInRate(const IUseNerve* user, s32 min, s32 max) -> f32

auto calcNerveSquareOutRate(const IUseNerve* user, s32 max) -> f32

auto calcNerveSquareOutRate(const IUseNerve* user, s32 min, s32 max) -> f32

auto calcNerveEaseByTypeRate(const IUseNerve* user, s32 max, s32 type) -> f32

auto calcNerveEaseByTypeRate(const IUseNerve* user, s32 min, s32 max, s32 type) -> f32

auto calcNervePowerInRate(const IUseNerve* user, s32 max, f32 power) -> f32

auto calcNervePowerInRate(const IUseNerve* user, s32 min, s32 max, f32 power) -> f32

auto calcNervePowerOutRate(const IUseNerve* user, s32 max, f32 power) -> f32

auto calcNervePowerOutRate(const IUseNerve* user, s32 min, s32 max, f32 power) -> f32

auto calcNerveJumpRate(const IUseNerve* user, s32 inMax, s32 upDuration, s32 release) -> f32

auto calcNerveEaseInValue(const IUseNerve* user, s32 min, s32 max, f32 start, f32 end) -> f32

auto calcNerveStartEndRate(const IUseNerve* user, s32 inMax, s32 upDuration, s32 release) -> f32

auto calcNerveEaseInOutValue(const IUseNerve* user, s32 min, s32 max, f32 start, f32 end) -> f32

auto calcNerveValue(const IUseNerve* user, s32 max, f32 start, f32 end) -> f32

auto calcNerveValue(const IUseNerve* user, s32 min, s32 max, f32 start, f32 end) -> f32

auto calcNerveEaseInValue(const IUseNerve* user, s32 max, f32 start, f32 end) -> f32

auto calcNerveEaseOutValue(const IUseNerve* user, s32 max, f32 start, f32 end) -> f32

auto calcNerveEaseOutValue(const IUseNerve* user, s32 min, s32 max, f32 start, f32 end) -> f32

auto calcNerveEaseInOutValue(const IUseNerve* user, s32 max, f32 start, f32 end) -> f32

auto calcNerveSquareInValue(const IUseNerve* user, s32 max, f32 start, f32 end) -> f32

auto calcNerveSquareInValue(const IUseNerve* user, s32 min, s32 max, f32 start, f32 end) -> f32

auto calcNerveSquareOutValue(const IUseNerve* user, s32 max, f32 start, f32 end) -> f32

auto calcNerveSquareOutValue(const IUseNerve* user, s32 min, s32 max, f32 start, f32 end) -> f32

auto calcNerveEaseByTypeValue(const IUseNerve* user, s32 max, f32 start, f32 end, s32 type) -> f32

auto calcNerveEaseByTypeValue(const IUseNerve* user, s32 min, s32 max, f32 start, f32 end, s32 type) -> f32

auto calcNerveCosCycle(const IUseNerve* user, s32 max) -> f32

auto calcNerveSinCycle(const IUseNerve* user, s32 max) -> f32

auto calcNerveRepeatRate(const IUseNerve* user, s32 max) -> f32

auto calcNerveRepeatDegree(const IUseNerve* user, s32 max) -> f32

auto calcNerveJumpValue(const IUseNerve* user, s32 inMax, s32 upDuration, s32 release, f32 factor) -> f32

auto calcNerveStartEndValue(const IUseNerve* user, s32 inMax, s32 upDuration, s32 release, f32 start, f32 end) -> f32

void initNerveState(IUseNerve* user, NerveStateBase* state, const Nerve* nerve, const char* name)

void addNerveState(IUseNerve* user, NerveStateBase* state, const Nerve* nerve, const char* name)

auto updateNerveState(IUseNerve* user) -> bool

auto updateNerveStateAndNextNerve(IUseNerve* user, const Nerve* nerve) -> bool

auto isStateEnd(const IUseNerve* user) -> bool

auto isAnyNfcTagDetected(const NfpInfo& nfpInfo) -> bool

auto isNormalNfc(const NfpInfo& nfpInfo) -> bool

auto isAmiibo(const NfpInfo& nfpInfo) -> bool

auto isEqualUniqueNfcId(const NfpInfo& nfpInfoA, const NfpInfo& nfpInfoB) -> bool

auto isEqualUniqueNfcId(const nn::nfp::TagInfo& tagInfoA, const nn::nfp::TagInfo& tagInfoB) -> bool

auto isEqualCharacterId(const NfpInfo& nfpInfo, NfpCharacterId characterId) -> bool

auto isEqualCharacterId(const nn::nfp::ModelInfo& modelInfo, const NfpCharacterId& characterId) -> bool

auto isEqualCharacterIdBase(const NfpInfo& nfpInfo, NfpCharacterId characterId) -> bool

auto isEqualNumberingId(const NfpInfo& nfpInfo, s32 numberingId) -> bool

auto isEqualNumberingId(const nn::nfp::ModelInfo& modelInfo, s32 numberingId) -> bool

auto tryGetCharacterId(NfpCharacterId* characterId, const NfpInfo& nfpInfo) -> bool

auto tryGetNumberingId(s32* numberingId, const NfpInfo& nfpInfo) -> bool

auto isCharacterIdBaseMario(const NfpInfo& nfpInfo) -> bool

auto isCharacterIdBaseDrMario(const NfpInfo& nfpInfo) -> bool

auto isCharacterIdBasePeach(const NfpInfo& nfpInfo) -> bool

auto isCharacterIdBaseKoopa(const NfpInfo& nfpInfo) -> bool

auto isCharacterIdBaseYoshi(const NfpInfo& nfpInfo) -> bool

auto isCharacterIdBaseKinopio(const NfpInfo& nfpInfo) -> bool

auto isNeedFormat(const NfpInfo& nfpInfo) -> bool

auto isNeedRestore(const NfpInfo& nfpInfo) -> bool

auto isNeedRegister(const NfpInfo& nfpInfo) -> bool

auto isNeedRegisterNickName(const NfpInfo& nfpInfo) -> bool

auto isValidRegisterInfo(const NfpInfo& nfpInfo) -> bool

void getAmiiboOwnerName(sead::BufferedSafeStringBase<char16>* ownerName, const NfpInfo& nfpInfo)

void getAmiiboNickName(sead::BufferedSafeStringBase<char16>* nickName, const NfpInfo& nfpInfo)

auto isInvalidFormatVersion(const NfpInfo& nfpInfo) -> bool

auto isEqualCharacterIdBase(const nn::nfp::ModelInfo& modelInfo, const NfpCharacterId& characterId) -> bool

auto isEqualUniqueNfcId(const nn::nfp::TagInfo& tagInfoA, const NfpInfo& nfpInfoB) -> bool

auto isEqualUniqueNfcId(const nn::nfp::TagId& tagIdA, const nn::nfp::TagId& tagIdB) -> bool

auto isNfpTriggerTouch(NfpDirector*, s32) -> bool

auto tryGetTriggerTouchNfpInfo(NfpDirector*, s32) -> bool

auto isNfpError(NfpDirector*, s32) -> bool

auto isNfpErrorDisableNfcDevice(const nn::Result&) -> bool

auto isNfpErrorBreakTagDisableRestore(const nn::Result&) -> bool

auto isNfpErrorBreakTagEnableRestore(const nn::Result&) -> bool

void showNfpErrorApplet(const nn::Result&)

auto createCollisionObj(const LiveActor* parent, const ActorInitInfo& info, const char* collisionFileName, HitSensor* hitSensor, const char* joinMtxName, const char* suffix) -> CollisionObj*

auto createCollisionObjMtx(const LiveActor* parent, const ActorInitInfo& info, const char* collisionFileName, HitSensor* hitSensor, const sead::Matrix34f* joinMtx, const char* suffix) -> CollisionObj*

auto createPartsModel(LiveActor*, const ActorInitInfo&, const char*, const char*, const sead::Matrix34f*) -> PartsModel*

auto createPartsModelFile(LiveActor*, const ActorInitInfo&, const char*, const char*, const char*) -> PartsModel*

auto createPartsModelFileSuffix(LiveActor*, const ActorInitInfo&, const char*, const char*, const char*, const char*) -> PartsModel*

auto createSimplePartsModel(LiveActor*, const ActorInitInfo&, const char*, const char*, const char*) -> PartsModel*

auto createSimplePartsModelSuffix(LiveActor*, const ActorInitInfo&, const char*, const char*, const char*, const char*) -> PartsModel*

auto createPartsModelSuffix(LiveActor*, const ActorInitInfo&, const char*, const char*, const char*, const sead::Matrix34f*) -> PartsModel*

auto createPartsModelJoint(LiveActor*, const ActorInitInfo&, const char*, const char*, const char*) -> PartsModel*

auto createPartsModelSuffixJoint(LiveActor*, const ActorInitInfo&, const char*, const char*, const char*, const char*) -> PartsModel*

void appearBreakModelRandomRotateY(LiveActor*)

auto updateSyncHostVisible(bool*, LiveActor*, const LiveActor*, bool) -> bool

auto isTraceModelRandomRotate(const LiveActor* actor) -> bool

auto createBreakModel(const LiveActor*, const ActorInitInfo&, const char*, const char*, const char*, const sead::Matrix34f*, const char*) -> BreakModel*

auto createHostSyncTowerCamera(LiveActor*, const ActorInitInfo&) -> HostSyncTowerCamera*

void activateHostSyncTowerCamera(HostSyncTowerCamera*)

void deactivateHostSyncTowerCamera(HostSyncTowerCamera*)

void updateHostSyncTowerCamera(HostSyncTowerCamera*)

auto tryCreateLinksKeyMoveCameraObj(const ActorInitInfo&, const char*) -> KeyMoveCameraObj*

auto tryCreateLinksKeyMoveCameraObjWithInterpole(const ActorInitInfo&, const char*) -> KeyMoveCameraObj*

auto isValidInfo(const PlacementInfo& placementInfo) -> bool

auto isPlaced(const ActorInitInfo& initInfo) -> bool

void getObjectName(const char** name, const ActorInitInfo& initInfo)

void getObjectName(const char** name, const PlacementInfo& placementInfo)

auto tryGetObjectName(const char** name, const ActorInitInfo& initInfo) -> bool

auto tryGetObjectName(const char** name, const PlacementInfo& placementInfo) -> bool

auto isObjectName(const ActorInitInfo& initInfo, const char* name) -> bool

auto isObjectName(const PlacementInfo& placementInfo, const char* name) -> bool

auto isObjectNameSubStr(const ActorInitInfo& initInfo, const char* name) -> bool

auto isObjectNameSubStr(const PlacementInfo& placementInfo, const char* name) -> bool

void getClassName(const char** name, const ActorInitInfo& initInfo)

void getClassName(const char** name, const PlacementInfo& placementInfo)

auto tryGetClassName(const char** name, const ActorInitInfo& initInfo) -> bool

auto tryGetClassName(const char** name, const PlacementInfo& placementInfo) -> bool

auto isClassName(const ActorInitInfo& initInfo, const char* name) -> bool

auto isClassName(const PlacementInfo& placementInfo, const char* name) -> bool

void getDisplayName(const char** name, const ActorInitInfo& initInfo)

void getDisplayName(const char** name, const PlacementInfo& placementInfo)

auto tryGetDisplayName(const char** name, const ActorInitInfo& initInfo) -> bool

auto tryGetDisplayName(const char** name, const PlacementInfo& placementInfo) -> bool

void getPlacementTargetFile(const char** targetFile, const PlacementInfo& placementInfo)

void getTrans(sead::Vector3f* trans, const ActorInitInfo& initInfo)

void getTrans(sead::Vector3f* trans, const PlacementInfo& placementInfo)

void multZoneMtx(sead::Vector3f* trans, const PlacementInfo& placementInfo)

auto tryGetTrans(sead::Vector3f* trans, const ActorInitInfo& initInfo) -> bool

auto tryGetTrans(sead::Vector3f* trans, const PlacementInfo& placementInfo) -> bool

void getRotate(sead::Vector3f* rotate, const PlacementInfo& placementInfo)

auto tryGetRotate(sead::Vector3f* rotate, const ActorInitInfo& initInfo) -> bool

template<typename T>

void getRotation(sead::Vector3f* v, const sead::Matrix34f& n)

auto tryGetRotate(sead::Vector3f* rotate, const PlacementInfo& placementInfo) -> bool

auto tryGetZoneMatrixTR(sead::Matrix34f* matrix, const PlacementInfo& placementInfo) -> bool

void getQuat(sead::Quatf* quat, const ActorInitInfo& initInfo)

void getQuat(sead::Quatf* quat, const PlacementInfo& placementInfo)

auto tryGetQuat(sead::Quatf* quat, const ActorInitInfo& initInfo) -> bool

auto tryGetQuat(sead::Quatf* quat, const PlacementInfo& placementInfo) -> bool

void getScale(sead::Vector3f* scale, const PlacementInfo& placementInfo)

void getScale(f32* x, f32* y, f32* z, const PlacementInfo& placementInfo)

auto tryGetScale(sead::Vector3f* scale, const ActorInitInfo& initInfo) -> bool

auto tryGetScale(sead::Vector3f* scale, const PlacementInfo& placementInfo) -> bool

void getSide(sead::Vector3f* side, const ActorInitInfo& initInfo)

void getSide(sead::Vector3f* side, const PlacementInfo& placementInfo)

auto tryGetSide(sead::Vector3f* side, const ActorInitInfo& initInfo) -> bool

auto tryGetSide(sead::Vector3f* side, const PlacementInfo& placementInfo) -> bool

void getUp(sead::Vector3f* up, const ActorInitInfo& initInfo)

void getUp(sead::Vector3f* up, const PlacementInfo& placementInfo)

auto tryGetUp(sead::Vector3f* up, const ActorInitInfo& initInfo) -> bool

auto tryGetUp(sead::Vector3f* up, const PlacementInfo& placementInfo) -> bool

void getFront(sead::Vector3f* front, const ActorInitInfo& initInfo)

void getFront(sead::Vector3f* front, const PlacementInfo& placementInfo)

auto tryGetFront(sead::Vector3f* front, const ActorInitInfo& initInfo) -> bool

auto tryGetFront(sead::Vector3f* front, const PlacementInfo& placementInfo) -> bool

auto tryGetLocalAxis(sead::Vector3f* dir, const ActorInitInfo& initInfo, s32 axis) -> bool

auto tryGetLocalAxis(sead::Vector3f* dir, const PlacementInfo& placementInfo, s32 axis) -> bool

auto tryGetLocalSignAxis(sead::Vector3f* dir, const ActorInitInfo& initInfo, s32 axis) -> bool

auto tryGetLocalSignAxis(sead::Vector3f* dir, const PlacementInfo& placementInfo, s32 axis) -> bool

auto tryGetMatrixTR(sead::Matrix34f* matrix, const ActorInitInfo& initInfo) -> bool

auto tryGetMatrixTR(sead::Matrix34f* matrix, const PlacementInfo& placementInfo) -> bool

auto tryGetMatrixTRS(sead::Matrix34f* matrix, const ActorInitInfo& initInfo) -> bool

auto tryGetMatrixTRS(sead::Matrix34f* matrix, const PlacementInfo& placementInfo) -> bool

auto tryGetInvertMatrixTR(sead::Matrix34f* matrix, const ActorInitInfo& initInfo) -> bool

auto tryGetInvertMatrixTR(sead::Matrix34f* matrix, const PlacementInfo& placementInfo) -> bool

void calcMatrixMultParent(sead::Matrix34f* matrix, const ActorInitInfo& initInfo1, const ActorInitInfo& initInfo2)

void calcMatrixMultParent(sead::Matrix34f* matrix, const PlacementInfo& placementInfo1, const PlacementInfo& placementInfo2)

void getArg(s32* arg, const ActorInitInfo& initInfo, const char* key)

void getArg(s32* arg, const PlacementInfo& placementInfo, const char* key)

auto tryGetArg(s32* arg, const ActorInitInfo& initInfo, const char* key) -> bool

auto tryGetArg(s32* arg, const PlacementInfo& placementInfo, const char* key) -> bool

void getArg(f32* arg, const ActorInitInfo& initInfo, const char* key)

void getArg(f32* arg, const PlacementInfo& placementInfo, const char* key)

auto tryGetArg(f32* arg, const ActorInitInfo& initInfo, const char* key) -> bool

auto tryGetArg(f32* arg, const PlacementInfo& placementInfo, const char* key) -> bool

void getArg(bool* arg, const ActorInitInfo& initInfo, const char* key)

void getArg(bool* arg, const PlacementInfo& placementInfo, const char* key)

auto tryGetArg(bool* arg, const ActorInitInfo& initInfo, const char* key) -> bool

auto tryGetArg(bool* arg, const PlacementInfo& placementInfo, const char* key) -> bool

auto getArgS32(const ActorInitInfo& actorInitInfo, const char* key) -> s32

auto getArgF32(const ActorInitInfo& actorInitInfo, const char* key) -> f32

void getArgV3f(sead::Vector3f* arg, const ActorInitInfo& actorInitInfo, const char* key)

void getArgV3f(sead::Vector3f* arg, const PlacementInfo& placementInfo, const char* key)

auto tryGetArgV3f(sead::Vector3f* arg, const ActorInitInfo& actorInitInfo, const char* key) -> bool

auto tryGetArgV3f(sead::Vector3f* arg, const PlacementInfo& placementInfo, const char* key) -> bool

auto isArgBool(const ActorInitInfo& initInfo, const char* key) -> bool

auto isArgBool(const PlacementInfo& placementInfo, const char* key) -> bool

auto isArgString(const ActorInitInfo& initInfo, const char* key, const char* arg) -> bool

auto isArgString(const PlacementInfo& placementInfo, const char* key, const char* arg) -> bool

void getStringArg(const char** arg, const ActorInitInfo& initInfo, const char* key)

void getStringArg(const char** arg, const PlacementInfo& placementInfo, const char* key)

void getStringArg(const char** arg, const AreaInitInfo& initInfo, const char* key)

auto getStringArg(const ActorInitInfo& initInfo, const char* key) -> const char*

auto getStringArg(const PlacementInfo& placementInfo, const char* key) -> const char*

auto getStringArg(const AreaInitInfo& initInfo, const char* key) -> const char*

auto tryGetStringArg(const char** arg, const ActorInitInfo& initInfo, const char* key) -> bool

auto tryGetStringArg(const char** arg, const PlacementInfo& initInfo, const char* key) -> bool

auto tryGetStringArg(const char** arg, const AreaInitInfo& initInfo, const char* key) -> bool

auto tryGetArgV2f(sead::Vector2f* arg, const ActorInitInfo& initInfo, const char* key) -> bool

auto tryGetArgV2f(sead::Vector2f* arg, const PlacementInfo& initInfo, const char* key) -> bool

auto tryGetArgColor(sead::Color4f* arg, const ActorInitInfo& initInfo, const char* key) -> bool

auto tryGetArgColor(sead::Color4f* arg, const PlacementInfo& initInfo, const char* key) -> bool

void getLayerConfigName(const char** name, const ActorInitInfo& initInfo)

void getLayerConfigName(const char** name, const PlacementInfo& initInfo)

auto tryGetZoneNameIfExist(const char** name, const PlacementInfo& placementInfo) -> bool

void getPlacementId(PlacementId* placementId, const PlacementInfo& placementInfo)

auto tryGetBoolArgOrFalse(const ActorInitInfo& initInfo, const char* key) -> bool

auto getCountPlacementInfo(const PlacementInfo& placementInfo) -> s32

void getPlacementInfoByKey(PlacementInfo* outPlacementInfo, const PlacementInfo& placementInfo, const char* key)

auto tryGetPlacementInfoByKey(PlacementInfo* outPlacementInfo, const PlacementInfo& placementInfo, const char* key) -> bool

void getPlacementInfoByIndex(PlacementInfo* outPlacementInfo, const PlacementInfo& placementInfo, s32 index)

auto tryGetPlacementInfoByIndex(PlacementInfo* outPlacementInfo, const PlacementInfo& placementInfo, s32 index) -> bool

void getPlacementInfoAndKeyNameByIndex(PlacementInfo* outPlacementInfo, const char** outKey, const PlacementInfo& placementInfo, s32 index)

auto tryGetPlacementInfoAndKeyNameByIndex(PlacementInfo* outPlacementInfo, const char** outKey, const PlacementInfo& placementInfo, s32 index) -> bool

auto createPlacementId(const ActorInitInfo& initInfo) -> PlacementId*

auto createPlacementId(const PlacementInfo& placementInfo) -> PlacementId*

auto tryGetPlacementId(PlacementId* placementId, const ActorInitInfo& initInfo) -> bool

auto tryGetPlacementId(PlacementId* placementId, const PlacementInfo& placementInfo) -> bool

void getPlacementId(PlacementId* placementId, const ActorInitInfo& initInfo)

auto isEqualPlacementId(const PlacementId& placementId, const PlacementId& otherPlacementId) -> bool

auto isEqualPlacementId(const PlacementInfo& placementInfo, const PlacementInfo& otherPlacementInfo) -> bool

auto isExistRail(const ActorInitInfo& initInfo, const char* linkName) -> bool

auto tryGetRailIter(PlacementInfo* railPlacementInfo, const PlacementInfo& placementInfo, const char* linkName) -> bool

auto tryGetLinksInfo(PlacementInfo* railPlacementInfo, const PlacementInfo& placementInfo, const char* linkName) -> bool

auto tryGetMoveParameterRailIter(PlacementInfo* railPlacementInfo, const PlacementInfo& placementInfo) -> bool

auto tryGetRailPointPos(sead::Vector3f* railPoint, const PlacementInfo& placementInfo) -> bool

void getRailPointHandlePrev(sead::Vector3f* railPoint, const PlacementInfo& placementInfo)

auto tryGetRailPointHandlePrev(sead::Vector3f* railPoint, const PlacementInfo& placementInfo) -> bool

void getRailPointHandleNext(sead::Vector3f* railPoint, const PlacementInfo& placementInfo)

auto tryGetRailPointHandleNext(sead::Vector3f* railPoint, const PlacementInfo& placementInfo) -> bool

auto isExistGraphRider(const ActorInitInfo& initInfo) -> bool

auto calcLinkChildNum(const ActorInitInfo& initInfo, const char* linkName) -> s32

auto calcLinkChildNum(const PlacementInfo& placementInfo, const char* linkName) -> s32

auto isExistLinkChild(const ActorInitInfo& initInfo, const char* linkName, s32 index) -> bool

auto isExistLinkChild(const PlacementInfo& placementInfo, const char* linkName, s32 index) -> bool

auto isExistLinkChild(const AreaInitInfo& initInfo, const char* linkName, s32 index) -> bool

auto calcLinkNestNum(const ActorInitInfo& initInfo, const char* linkName) -> s32

auto calcLinkNestNum(const PlacementInfo& placementInfo, const char* linkName) -> s32

void getLinksInfo(PlacementInfo* linkPlacementInfo, const PlacementInfo& placementInfo, const char* linkName)

void getLinksInfoByIndex(PlacementInfo* linkPlacementInfo, const PlacementInfo& placementInfo, const char* linkName, s32 index)

void getLinksInfo(PlacementInfo* linkPlacementInfo, const ActorInitInfo& initInfo, const char* linkName)

void getLinksInfoByIndex(PlacementInfo* linkPlacementInfo, const ActorInitInfo& initInfo, const char* linkName, s32 index)

auto tryGetLinksInfo(PlacementInfo* linkPlacementInfo, const ActorInitInfo& initInfo, const char* linkName) -> bool

void getLinksMatrix(sead::Matrix34f* matrix, const ActorInitInfo& initInfo, const char* linkName)

void getLinksMatrixByIndex(sead::Matrix34f* matrix, const ActorInitInfo& initInfo, const char* linkName, s32 index)

void getLinkTR(sead::Vector3f* trans, sead::Vector3f* rotate, const PlacementInfo& placementInfo, const char* linkName)

void getLinkTR(sead::Vector3f* trans, sead::Vector3f* rotate, const ActorInitInfo& initInfo, const char* linkName)

void getLinkTR(sead::Vector3f* trans, sead::Vector3f* rotate, const AreaInitInfo& initInfo, const char* linkName)

void getLinksQT(sead::Quatf* quat, sead::Vector3f* trans, const ActorInitInfo& initInfo, const char* linkName)

void getLinksQT(sead::Quatf* quat, sead::Vector3f* trans, const PlacementInfo& placementInfo, const char* linkName)

auto tryGetLinksQT(sead::Quatf* quat, sead::Vector3f* trans, const ActorInitInfo& initInfo, const char* linkName) -> bool

auto tryGetLinksQTS(sead::Quatf* quat, sead::Vector3f* trans, sead::Vector3f* scale, const ActorInitInfo& initInfo, const char* linkName) -> bool

auto tryGetLinksMatrixTR(sead::Matrix34f* matrix, const ActorInitInfo& initInfo, const char* linkName) -> bool

auto tryGetLinksMatrixTR(sead::Matrix34f* matrix, const AreaInitInfo& initInfo, const char* linkName) -> bool

auto tryGetLinksMatrixTRS(sead::Matrix34f* matrix, const ActorInitInfo& initInfo, const char* linkName) -> bool

auto tryGetLinksTrans(sead::Vector3f* trans, const ActorInitInfo& initInfo, const char* linkName) -> bool

auto tryGetLinksTrans(sead::Vector3f* trans, const PlacementInfo& placementInfo, const char* linkName) -> bool

auto tryGetLinksQuat(sead::Quatf* quat, const ActorInitInfo& initInfo, const char* linkName) -> bool

auto tryGetLinksTR(sead::Vector3f* trans, sead::Vector3f* rotate, const ActorInitInfo& initInfo, const char* linkName) -> bool

void getChildTrans(sead::Vector3f* trans, const PlacementInfo& placementInfo, const char* linkName)

void getChildTrans(sead::Vector3f* trans, const ActorInitInfo& initInfo, const char* linkName)

void getChildTrans(sead::Vector3f* trans, const AreaInitInfo& initInfo, const char* linkName)

void getChildLinkT(sead::Vector3f* trans, const ActorInitInfo& initInfo, const char* linkName, s32 index)

void getChildLinkTR(sead::Vector3f* trans, sead::Vector3f* rotate, const ActorInitInfo& initInfo, const char* linkName, s32 index)

auto calcMatchNameLinkCount(const PlacementInfo& placementInfo, const char* linkName) -> s32

auto calcLinkCountClassName(const PlacementInfo& placementInfo, const char* linkName) -> s32

auto tryGetZoneMatrixTR(sead::Matrix34f* matrix, const ActorInitInfo& initInfo) -> bool

auto tryGetDisplayOffset(sead::Vector3f* offset, const ActorInitInfo& initInfo) -> bool

auto tryGetDisplayOffset(sead::Vector3f* offset, const PlacementInfo& placementInfo) -> bool

auto tryGetChildDisplayOffset(sead::Vector3f* offset, const ActorInitInfo& initInfo, const char* linkName) -> bool

auto tryGetDisplayRotate(sead::Vector3f* rotate, const ActorInitInfo& initInfo) -> bool

auto tryGetDisplayScale(sead::Vector3f* scale, const ActorInitInfo& initInfo) -> bool

auto makeStringPlacementId(const PlacementId* placementId) -> StringTmp<128>

void startAppear(LayoutActor* layout)

auto createBalloonMessage(const LiveActor* hostActor, const ActorInitInfo& info, const BalloonMessageInitParam& initParam) -> BalloonMessage*

auto createBalloonMessageNoAutoUpdate(const LiveActor* hostActor, const ActorInitInfo& info, const BalloonMessageInitParam& initParam) -> BalloonMessage*

auto createBalloonMessage(const LiveActor* hostActor, const ActorInitInfo& info) -> BalloonMessage*

auto createBalloonMessage(const LiveActor* hostActor, const ActorInitInfo& info, const char* message) -> BalloonMessage*

auto createSimpleLayoutText(const ActorInitInfo& info, const char* name, const char* paneName, const char* archiveName) -> SimpleLayoutText*

void addPlayerAccelStick(LiveActor*, sead::Vector3f*, f32, s32, const sead::Matrix34f*)

void addPlayerAccelStickGravity(LiveActor*, sead::Vector3f*, f32, const sead::Vector3f&, s32, const sead::Matrix34f*)

void addPlayerAccelInputGravity(LiveActor*, sead::Vector3f*, const sead::Vector2f&, f32, const sead::Vector3f&, const sead::Matrix34f*)

auto tryCalcTouchWorldPosPlane(const IUseCamera*, sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&) -> bool

auto tryCalcTouchWorldPosPlaneXZ(const IUseCamera*, sead::Vector3f*, f32) -> bool

auto getPlayerNumMax(const PlayerHolder* holder) -> s32

auto getAlivePlayerNum(const PlayerHolder* holder) -> s32

auto getPlayerActor(const PlayerHolder* holder, s32 index) -> LiveActor*

auto getPlayerPos(const PlayerHolder* holder, s32 index) -> const sead::Vector3f&

auto tryGetPlayerActor(const PlayerHolder* holder, s32 index) -> LiveActor*

auto isPlayerDead(const PlayerHolder* holder, s32 index) -> bool

auto isPlayerAreaTarget(const PlayerHolder* holder, s32 index) -> bool

auto tryFindAlivePlayerActorFirst(const PlayerHolder* holder) -> LiveActor*

auto findAlivePlayerActorFirst(const PlayerHolder* holder) -> LiveActor*

auto getPlayerNumMax(const LiveActor*) -> s32

auto getAlivePlayerNum(const LiveActor*) -> s32

auto getPlayerActor(const LiveActor*, s32) -> LiveActor*

auto getPlayerPos(const LiveActor*, s32) -> const sead::Vector3f&

auto tryGetPlayerActor(const LiveActor*, s32) -> LiveActor*

auto isPlayerDead(const LiveActor*, s32) -> bool

auto isPlayerAreaTarget(const LiveActor*, s32) -> bool

auto tryFindAlivePlayerActorFirst(const LiveActor*) -> LiveActor*

auto findAlivePlayerActorFirst(const LiveActor*) -> LiveActor*

auto getPlayerPadRumbleKeeper(const LiveActor*, s32) -> PadRumbleKeeper*

auto getPlayerPort(const PlayerHolder*, s32) -> s32

auto getPlayerPort(const LiveActor*, s32) -> s32

auto findAlivePlayerActorFromPort(const PlayerHolder*, s32) -> LiveActor*

auto tryFindAlivePlayerActorFromPort(const PlayerHolder*, s32) -> LiveActor*

auto findAlivePlayerActorFromPort(const LiveActor*, s32) -> LiveActor*

auto tryFindAlivePlayerActorFromPort(const LiveActor*, s32) -> LiveActor*

auto findNearestPlayerId(const LiveActor*, f32) -> s32

auto findNearestPlayerActor(const LiveActor*) -> LiveActor*

auto tryFindNearestPlayerActor(const LiveActor*) -> LiveActor*

auto findNearestPlayerPos(const LiveActor*) -> const sead::Vector3f&

auto tryFindNearestPlayerPos(sead::Vector3f*, const LiveActor*) -> bool

auto tryFindNearestPlayerDisatanceFromTarget(f32*, const LiveActor*, const sead::Vector3f&) -> bool

auto isNearPlayer(const LiveActor*, f32) -> bool

auto isNearPlayerH(const LiveActor*, f32) -> bool

auto isNearPlayerHCondition(const LiveActor*, f32, bool(*)(const LiveActor*)) -> bool

auto getFarPlayerPosMaxX(const LiveActor*) -> const sead::Vector3f&

auto getFarPlayerPosMinX(const LiveActor*) -> const sead::Vector3f&

auto calcPlayerListOrderByDistance(const LiveActor*, const LiveActor**, u32) -> u32

auto calcAlivePlayerActor(const LiveActor*, const LiveActor**, u32) -> u32

auto tryFindNearestPlayerActorCondition(const LiveActor*, bool(*)(const LiveActor*)) -> LiveActor*

auto tryFindNearestPlayerPosCondition(sead::Vector3f*, const LiveActor*, bool(*)(const LiveActor*)) -> bool

auto isResetablePlayerPos(const LiveActor*, const sead::Vector3f&, f32, f32) -> bool

auto isResetablePlayerPos(const LiveActor*, f32) -> bool

void faceToPlayer(LiveActor*)

auto createRailKeeper(const PlacementInfo& info, const char* linkName) -> RailKeeper*

auto tryCreateRailKeeper(const PlacementInfo& info, const char* linkName) -> RailKeeper*

auto createRailKeeperIndex(const PlacementInfo& info, s32 linkIndex, const char* linkName) -> RailKeeper*

void setRailPosToStart(IUseRail* railHolder)

void setRailPosToEnd(IUseRail* railHolder)

void setRailPosToNearestPos(IUseRail* railHolder, const sead::Vector3f&)

void setRailPosToCoord(IUseRail* railHolder, f32)

void setRailPosToRailPoint(IUseRail* railHolder, s32)

void setSyncRailToStart(LiveActor* actor)

void syncRailTrans(LiveActor* actor)

void setSyncRailToEnd(LiveActor* actor)

void setSyncRailToNearestPos(LiveActor* actor, const sead::Vector3f&)

void setSyncRailToNearestRailControlPoint(LiveActor* actor)

void setSyncRailToNearestPos(LiveActor* actor)

void setSyncRailToCoord(LiveActor* actor, f32 coord)

void setSyncRailToRailPoint(LiveActor* actor, s32)

auto moveRail(IUseRail* railHolder, f32) -> bool

auto isRailReachedGoal(const IUseRail* railHolder) -> bool

auto moveRailLoop(IUseRail* railHolder, f32) -> bool

auto getRailCoord(const IUseRail* railHolder) -> f32

auto isRailGoingToEnd(const IUseRail* railHolder) -> bool

auto getRailTotalLength(const IUseRail* railHolder) -> f32

auto moveRailTurn(IUseRail* railHolder, f32, f32) -> bool

void reverseRail(IUseRail* railHolder)

auto isRailReachedNearGoal(const IUseRail* railHolder, f32) -> bool

auto turnToRailDir(LiveActor* actor, f32) -> bool

void calcRailMoveDir(sead::Vector3f*, const IUseRail* railHolder)

auto turnToRailDirImmediately(LiveActor* actor) -> bool

auto getRailPos(const IUseRail* railHolder) -> const sead::Vector3f&

auto moveSyncRail(LiveActor* actor, f32) -> bool

auto moveSyncRailLoop(LiveActor* actor, f32 speed) -> bool

auto moveSyncRailTurn(LiveActor* actor, f32 speed) -> bool

auto calcNearestRailCoord(const IUseRail* railHolder, const sead::Vector3f&) -> f32

auto calcNearestRailPos(sead::Vector3f*, const IUseRail* railHolder, const sead::Vector3f&) -> f32

void calcNearestRailDir(sead::Vector3f*, const IUseRail* railHolder, const sead::Vector3f&)

void calcNearestRailPosAndDir(sead::Vector3f*, sead::Vector3f*, const IUseRail* railHolder, const sead::Vector3f&)

void calcRailPosDir(sead::Vector3f*, sead::Vector3f*, const IUseRail* railHolder, f32)

void calcRailPointPos(sead::Vector3f*, const IUseRail* railHolder, s32)

auto calcNearestRailPointNo(const IUseRail* railHolder, const sead::Vector3f&) -> s32

auto calcNearestRailPointNo(const IUseRail* railHolder) -> s32

auto calcCoordNearestRailPointNo(const IUseRail* railHolder) -> s32

auto getRailPartIndex(const IUseRail* railHolder) -> s32

auto calcRailPartRate(const IUseRail* railHolder) -> f32

auto isLoopRail(const IUseRail* railHolder) -> bool

auto getRailPointNum(const IUseRail* railHolder) -> s32

auto calcNearestRailPointPosCoord(const IUseRail* railHolder, const sead::Vector3f&) -> f32

auto calcRailCoordByPoint(const IUseRail* railHolder, s32) -> f32

void calcRailUp(sead::Vector3f*, const IUseRail* railHolder)

auto getRailPointInfo(const IUseRail* railHolder, s32) -> PlacementInfo*

auto getRailPointNo(const IUseRail* railHolder) -> s32

auto getNextRailPointNo(const IUseRail* railHolder) -> s32

auto calcRailToGoalLength(const IUseRail* railHolder) -> f32

auto calcRailTotalRate(const IUseRail* railHolder) -> f32

auto calcRailToNextRailPointLength(const IUseRail* railHolder) -> f32

auto calcRailToPreviousRailPointLength(const IUseRail* railHolder) -> f32

auto getRailNum(const IUseRail* railHolder) -> s32

auto getRailDir(const IUseRail* railHolder) -> const sead::Vector3f&

auto isRailReachedEnd(const IUseRail* railHolder) -> bool

auto getRailPartLength(const IUseRail* railHolder, s32) -> f32

auto tryGetCurrentRailPointArg(f32*, const IUseRail* railHolder, const char*) -> bool

auto tryGetNextRailPointArg(f32*, const IUseRail* railHolder, const char*) -> bool

auto tryGetCurrentRailPointArg(s32*, const IUseRail* railHolder, const char*) -> bool

auto tryGetNextRailPointArg(s32*, const IUseRail* railHolder, const char*) -> bool

auto tryGetCurrentRailPointArg(bool*, const IUseRail* railHolder, const char*) -> bool

auto tryGetNextRailPointArg(bool*, const IUseRail* railHolder, const char*) -> bool

auto tryGetCurrentRailPointArg(const char**, const IUseRail* railHolder, const char*) -> bool

auto tryGetNextRailPointArg(const char**, const IUseRail* railHolder, const char*) -> bool

auto isExistRail(const IUseRail* railHolder) -> bool

auto isRailReachedStart(const IUseRail* railHolder) -> bool

auto isRailReachedNearGoal(const IUseRail* railHolder, f32, f32) -> bool

auto isRailReachedEdge(const IUseRail* railHolder) -> bool

auto isRailReachedNearRailPoint(const IUseRail* railHolder, f32) -> bool

auto isRailIncludeBezierPart(const IUseRail* railHolder) -> bool

auto isRailBezierPart(const IUseRail* railHolder, s32) -> bool

auto isRailPlusDir(const IUseRail* railHolder, const sead::Vector3f&) -> bool

auto isRailPlusPoseSide(const LiveActor* actor) -> bool

auto isRailPlusPoseUp(const LiveActor* actor) -> bool

auto isRailPlusPoseFront(const LiveActor* actor) -> bool

void calcRailPosAtCoord(sead::Vector3f*, const IUseRail* railHolder, f32)

void calcRailDirAtCoord(sead::Vector3f*, const IUseRail* railHolder, f32)

void calcRailPosFront(sead::Vector3f*, const IUseRail* railHolder, f32)

void calcRailDirFront(sead::Vector3f*, const IUseRail* railHolder, f32)

void calcRailPointPose(sead::Quatf*, const IUseRail* railHolder, s32)

auto calcRailPointNum(const IUseRail* railHolder, f32, f32) -> s32

auto calcForwardRailPointNo(const IUseRail* railHolder, s32) -> s32

auto calcPreviousRailPointNo(const IUseRail* railHolder, s32) -> s32

void calcRailClippingInfo(sead::Vector3f*, f32*, const IUseRail* railHolder, f32, f32)

void setRailClippingInfo(sead::Vector3f*, LiveActor* actor, f32, f32)

void calcAndSyncMoveFitRailDir(IUseRail* railHolder, sead::Vector3f*, f32, const sead::Vector3f&, const sead::Vector3f&, bool)

void calcAndSyncMoveFitRailDir(LiveActor* actor, sead::Vector3f*, f32, bool)

auto createRailModelGroup(const IUseRail* railHolder, const ActorInitInfo&, const char*, const char*) -> LiveActorGroup*

auto calcRailDivideNum(const IUseRail* railHolder, f32, bool) -> s32

auto calcRailDivideForcePointNum(const IUseRail* railHolder, f32) -> s32

auto calcRailDivideEquallyNum(const IUseRail* railHolder, f32) -> s32

void placementRailDivide(const IUseRail* railHolder, f32, bool, const RailPlacementCallBack&)

void placementRailDivideForcePoint(const IUseRail* railHolder, f32, const RailPlacementCallBack&)

void placementRailDivideEqually(const IUseRail* railHolder, f32, const RailPlacementCallBack&)

void addResourceCategory(const sead::SafeString&, s32, sead::Heap*)

auto isEmptyCategoryResource(const sead::SafeString&) -> bool

void createCategoryResourceAll(const sead::SafeString&)

void removeResourceCategory(const sead::SafeString&)

auto getResourceName(const Resource*) -> const char*

auto getResourcePath(const Resource*) -> const char*

auto isExistResGraphicsFile(const Resource*) -> bool

auto findResource(const sead::SafeString&) -> Resource*

auto findOrCreateResource(const sead::SafeString& path, const char* ext) -> Resource*

auto findOrCreateResourceCategory(const sead::SafeString& path, const sead::SafeString& category, const char* ext) -> Resource*

auto findOrCreateResourceEventData(const char*, const char*) -> Resource*

auto findOrCreateResourceSystemData(const char*, const char*) -> Resource*

auto findOrCreateActorResource(ActorResourceHolder*, const char*, const char*) -> ActorResource*

void findOrCreateActorResourceWithAnimResource(ActorResourceHolder*, const char*, const char*, const char*, bool)

auto isExistResourceYaml(const Resource*, const char*, const char*) -> bool

auto isExistResourceYaml(const ActorResource*, const char*, const char*) -> bool

void findResourceYaml(const Resource*, const char*, const char*)

void findResourceYaml(const ActorResource*, const char*, const char*)

auto tryFindStageParameterFileDesign(const sead::SafeString&, const sead::SafeString&, s32) -> bool

void loadCategoryArchiveAll(const sead::SafeString&)

void setCurrentCategoryName(const char*)

void resetCurrentCategoryName()

void setCurrentCategoryNameDefault()

auto getBymlFromObjectResource(const sead::SafeString&, const sead::SafeString&) -> u8*

auto tryGetBymlFromObjectResource(const sead::SafeString&, const sead::SafeString&) -> u8*

auto getBymlFromLayoutResource(const sead::SafeString&, const sead::SafeString&) -> u8*

auto tryGetBymlFromLayoutResource(const sead::SafeString&, const sead::SafeString&) -> u8*

auto tryGetBymlFromArcName(const sead::SafeString&, const sead::SafeString&) -> u8*

auto getBymlFromArcName(const sead::SafeString&, const sead::SafeString&) -> u8*

auto getByml(const Resource*, const sead::SafeString&) -> u8*

auto tryGetByml(const Resource*, const sead::SafeString&) -> u8*

auto setAudioPlayerToResourceSystem(SeadAudioPlayer*, SeadAudioPlayer*) -> bool

auto createSceneObj(const IUseSceneObjHolder* objHolder, s32 type) -> ISceneObj*

void setSceneObj(const IUseSceneObjHolder* user, ISceneObj* obj, s32 sceneObjId)

auto getSceneObj(const IUseSceneObjHolder* user, s32 sceneObjId) -> ISceneObj*

auto tryGetSceneObj(const IUseSceneObjHolder* user, s32 sceneObjId) -> ISceneObj*

auto isExistSceneObj(const IUseSceneObjHolder* user, s32 sceneObjId) -> bool

void deleteSceneObj(const IUseSceneObjHolder* user, s32 sceneObjId)

auto tryDeleteSceneObj(const IUseSceneObjHolder* user, s32 sceneObjId) -> bool

template<typename T>

auto getSceneObj(const IUseSceneObjHolder* user) -> T*

template<typename T>

auto tryGetSceneObj(const IUseSceneObjHolder* user) -> T*

auto getStageInfoMapNum(const Scene* scene) -> s32

auto getStageInfoDesignNum(const Scene* scene) -> s32

auto getStageInfoSoundNum(const Scene* scene) -> s32

auto getStageInfoMap(const Scene* scene, s32 index) -> StageInfo*

auto getStageInfoDesign(const Scene* scene, s32 index) -> StageInfo*

auto getStageInfoSound(const Scene* scene, s32 index) -> StageInfo*

auto getStageResourceMap(const Scene* scene, s32 index) -> Resource*

auto tryGetStageResourceDesign(const Scene* scene, s32 index) -> Resource*

auto tryGetStageResourceSound(const Scene* scene, s32 index) -> Resource*

auto getSceneFrameBufferMain(const Scene* scene) -> agl::RenderBuffer*

auto getSceneDrawContext(const Scene* scene) -> agl::DrawContext*

auto getSceneFrameBufferConsole(const Scene* scene) -> agl::RenderBuffer*

auto getSceneFrameBufferHandheld(const Scene* scene) -> agl::RenderBuffer*

auto getSceneFrameBufferMainAspect(const Scene* scene) -> f32

auto isChangedGraphicsQualityMode(const Scene* scene) -> bool

auto getSceneAreaObjDirector(const Scene* scene) -> AreaObjDirector*

auto getSceneExecuteDirector(const Scene* scene) -> ExecuteDirector*

auto getScenePlayerHolder(const Scene* scene) -> PlayerHolder*

auto getSceneItemDirector(const Scene* scene) -> ItemDirectorBase*

void initActorInitInfo(ActorInitInfo* actorInitInfo, const Scene* scene, const PlacementInfo* placementInfo, const LayoutInitInfo* layoutInfo, const ActorFactory* actorFactory, SceneMsgCtrl* sceneMsgCtrl, GameDataHolderBase* gameDataHolderBase)

void initLayoutInitInfo(LayoutInitInfo* layoutInfo, const Scene* scene, const SceneInitInfo& sceneInfo)

void initPlacementAreaObj(Scene* scene, const ActorInitInfo& actorInfo)

void initPlacementGravityObj(Scene* scene)

auto tryGetPlacementInfoAndCount(PlacementInfo* outPlacementInfo, s32* outCount, const StageInfo* stageInfo, const char* key) -> bool

void initPlacementObjectMap(Scene* scene, const ActorInitInfo& actorInfo, const char* name)

void initPlacementByStageInfo(const StageInfo* stageInfo, const char* key, const ActorInitInfo& actorInfo)

void initPlacementObjectDesign(Scene* scene, const ActorInitInfo& actorInfo, const char* name)

void initPlacementObjectSound(Scene* scene, const ActorInitInfo& actorInfo, const char* name)

auto tryInitPlacementSingleObject(Scene* scene, const ActorInitInfo& actorInfo, s32 resourceType, const char* key) -> LiveActor*

auto tryInitPlacementSingleObject(Scene* scene, const ActorInitInfo& actorInfo, s32 resourceType, const char* key, const char* name) -> LiveActor*

auto tryInitPlacementActorGroup(LiveActorGroup* liveActorGroup, Scene* scene, const ActorInitInfo& actorInfo, s32 resourceType, const char* key, const char* name) -> bool

void initPlacementByStageInfoSingle(const StageInfo* stageInfo, const char* key, const ActorInitInfo& actorInfo)

auto tryGetPlacementInfo(PlacementInfo* outPlacementInfo, const StageInfo* stageInfo, const char* key) -> bool

void getPlacementInfo(PlacementInfo* outPlacementInfo, const StageInfo* stageInfo, const char* key)

void getPlacementInfoAndCount(PlacementInfo* outPlacementInfo, s32* outCount, const StageInfo* stageInfo, const char* key)

void initAreaObjDirector(Scene* scene, const AreaObjFactory* factory)

void initDemoDirector(Scene* scene, DemoDirector* demoDirector)

void initHitSensorDirector(Scene* scene)

void initGravityHolder(Scene* scene)

void initItemDirector(Scene* scene, ItemDirectorBase* itemDirector)

void initNatureDirector(Scene* scene)

void initSwitchAreaDirector(Scene* scene, s32 maxSwitchOnArea, s32 maxSwitchKeepOnArea)

void registerSwitchOnAreaGroup(Scene* scene, SwitchOnAreaGroup* switchOnAreaGroup)

void registerSwitchKeepOnAreaGroup(Scene* scene, SwitchKeepOnAreaGroup* switchKeepOnAreaGroup)

void initGraphicsSystemInfo(Scene* scene, const char* name, s32 index)

void initCameraDirectorImpl(Scene* scene, const CameraPoserFactory* cameraPoserFactory)

void initCameraDirector(Scene* scene, const char* name, s32 index, const CameraPoserFactory* cameraPoserFactory)

void initCameraDirectorWithoutStageResource(Scene* scene, const CameraPoserFactory* cameraPoserFactory)

void initCameraDirectorFix(Scene* scene, const sead::Vector3f& pos, const sead::Vector3f& lookAtPos, const CameraPoserFactory* cameraPoserFactory)

void initSceneCameraFovyDegree(Scene* scene, f32 fovy)

void initSnapShotCameraAudioKeeper(Scene* scene, IUseAudioKeeper* audioKeeper)

void setCameraAspect(Scene* scene, f32 aspectA, f32 aspectB)

void resetSceneInitEntranceCamera(Scene* scene)

void stopCameraByDeathPlayer(Scene* scene)

void restartCameraByDeathPlayer(Scene* scene)

void startInvalidCameraStopJudgeByDemo(Scene* scene)

void endInvalidCameraStopJudgeByDemo(Scene* scene)

void startCameraSnapShotMode(Scene* scene, bool useInterpole)

void endCameraSnapShotMode(Scene* scene)

auto isCameraReverseInputH(const Scene* scene) -> bool

void onCameraReverseInputH(Scene* scene)

void offCameraReverseInputH(Scene* scene)

auto isCameraReverseInputV(const Scene* scene) -> bool

void onCameraReverseInputV(Scene* scene)

void offCameraReverseInputV(Scene* scene)

auto getCameraStickSensitivityLevel(const Scene* scene) -> s32

void setCameraStickSensitivityLevel(Scene* scene, s32 sensitivityLevel)

auto isValidCameraGyro(const Scene* scene) -> bool

void validateCameraGyro(Scene* scene)

void invalidateCameraGyro(Scene* scene)

auto getCameraGyroSensitivityLevel(const Scene* scene) -> s32

void setCameraGyroSensitivityLevel(Scene* scene, s32 sensitivityLevel)

auto initAndCreatePauseCameraCtrl(Scene* scene, f32 value) -> PauseCameraCtrl*

void startCameraPause(PauseCameraCtrl* pauseCameraCtrl)

void endCameraPause(PauseCameraCtrl* pauseCameraCtrl)

auto initAudioDirectorImpl(Scene* scene, const SceneInitInfo& sceneInfo, AudioDirectorInitInfo& audioDirectorInfo) -> AudioDirector*

void initAudioDirector2D(Scene* scene, const SceneInitInfo& sceneInfo, AudioDirectorInitInfo& audioDirectorInfo)

void initAudioDirector3D(Scene* scene, const SceneInitInfo& sceneInfo, AudioDirectorInitInfo& audioDirectorInfo)

void initAudioDirector3D(Scene* scene, const SceneInitInfo& sceneInfo, AudioDirectorInitInfo& audioDirectorInfo, const sead::LookAtCamera* lookAtCamera, const Projection* projection, AreaObjDirector* areaObjDirector)

void initSceneAudioKeeper(Scene* scene, const SceneInitInfo& sceneInfo, const char* name)

void setIsSafeFinalizingInParallelThread(Scene* scene, bool isSafe)

void updateKit(Scene* scene)

void updateKitTable(Scene* scene, const char* name)

void updateKitList(Scene* scene, const char* listName, const char* name)

void updateKitList(Scene* scene, const char* name)

void updateLayoutKit(Scene* scene)

void updateEffect(Scene* scene)

void updateEffectSystem(Scene* scene)

void updateEffectPlayer(Scene* scene)

void updateEffectDemo(Scene* scene)

void updateEffectDemoWithPause(Scene* scene)

void updateEffectLayout(Scene* scene)

void updateGraphicsPrev(Scene* scene)

void updateKitListPrev(Scene* scene)

void updateKitListPost(Scene* scene)

void updateKitListPostDemoWithPauseNormalEffect(Scene* scene)

void updateKitListPostOnNerveEnd(Scene* scene)

void drawKit(const Scene* scene, const char* name)

void drawKitList(const Scene* scene, const char* listName, const char* name)

void drawLayoutKit(const Scene* scene, const char* name)

void drawEffectDeferred(const Scene* scene, s32 index)

void startForwardPlayerScreenFader(const Scene* scene, s32 a, s32 b, f32 c)

void endForwardPlayerScreenFader(const Scene* scene, s32 a)

auto isStopScene(const Scene* scene) -> bool

void startCheckViewCtrlByCameraPos(Scene* scene)

void startCheckViewCtrlByLookAtPos(Scene* scene)

void startCheckViewCtrlByPlayerPos(Scene* scene)

auto isExistScreenCoverCtrl(const Scene* scene) -> bool

auto isRequestCaptureScreenCover(const Scene* scene) -> bool

void resetRequestCaptureScreenCover(const Scene* scene)

auto isOffDrawScreenCover(const Scene* scene) -> bool

void resetCaptureScreenCover(const Scene* scene)

void validatePostProcessingFilter(const Scene* scene)

void invalidatePostProcessingFilter(const Scene* scene)

void incrementPostProcessingFilterPreset(const Scene* scene)

void decrementPostProcessingFilterPreset(const Scene* scene)

auto getPostProcessingFilterPresetId(const Scene* scene) -> s32

auto getActiveDemoName(const Scene* scene) -> const char*

auto getDemoActorList(const Scene* scene) -> LiveActor**

auto getDemoActorNum(const Scene* scene) -> s32

void updateDemoActor(const Scene* scene)

void updateDemoActorForPauseEffect(const Scene* scene)

void stopAllSe(const Scene* scene, u32 index)

void initPadRumble(const Scene* scene, const SceneInitInfo& sceneInfo)

void stopPadRumble(const Scene* scene)

void pausePadRumble(const Scene* scene)

void endPausePadRumble(const Scene* scene)

void validatePadRumble(Scene* scene)

void invalidatePadRumble(Scene* scene)

void setPadRumblePowerLevel(Scene* scene, s32 powerLevel)

auto getPreLoadFileListArc() -> const Resource*

auto tryRequestPreLoadFile(const Scene* scene, const SceneInitInfo& sceneInfo, s32 index, sead::Heap* heap) -> bool

void initCameraDirector(Scene* scene, const CameraPoserFactory* cameraPoserFactory)

auto getDisplayWidth() -> u32

auto getDisplayHeight() -> u32

auto getLayoutDisplayWidth() -> u32

auto getLayoutDisplayHeight() -> u32

auto getVirtualDisplayWidth() -> u32

auto getVirtualDisplayHeight() -> u32

auto getSubDisplayWidth() -> u32

auto getSubDisplayHeight() -> u32

auto isInScreen(const sead::Vector2f&, f32) -> bool

auto calcWorldPosFromScreen(sead::Vector3f* output, const sead::Vector2f&, const sead::Matrix34f&, f32) -> bool

void calcWorldPosFromScreenPos(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, f32)

void calcWorldPosFromScreenPos(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, const sead::Vector3f&)

void calcWorldPosFromScreenPos(sead::Vector3f* output, const SceneCameraInfo*, const sead::Vector2f&, f32, s32)

void calcWorldPosFromScreenPos(sead::Vector3f* output, const SceneCameraInfo*, const sead::Vector2f&, const sead::Vector3f&, s32)

void calcWorldPosFromScreenPosSub(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, f32)

void calcWorldPosFromScreenPosSub(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, const sead::Vector3f&)

void calcWorldPosFromLayoutPos(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, f32)

void calcWorldPosFromLayoutPos(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, const sead::Vector3f&)

void calcWorldPosFromLayoutPos(sead::Vector3f* output, const SceneCameraInfo*, const sead::Vector2f&, s32, s32)

void calcWorldPosFromLayoutPos(sead::Vector3f* output, const SceneCameraInfo*, const sead::Vector2f&, const sead::Vector3f&, s32)

void calcWorldPosFromLayoutPosSub(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, f32)

void calcWorldPosFromLayoutPosSub(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, const sead::Vector3f&)

void calcScreenPosFromWorldPos(sead::Vector2f* output, const IUseCamera*, const sead::Vector3f&)

void calcScreenPosFromWorldPosSub(sead::Vector2f* output, const IUseCamera*, const sead::Vector3f&)

void calcScreenPosFromLayoutPos(sead::Vector2f* output, const sead::Vector2f&)

auto calcScreenRadiusFromWorldRadius(const sead::Vector3f&, const IUseCamera*, f32) -> f32

auto calcScreenRadiusFromWorldRadiusSub(const sead::Vector3f&, const IUseCamera*, f32) -> f32

void calcLayoutPosFromScreenPos(sead::Vector2f* output, const sead::Vector2f&)

void calcLayoutPosFromWorldPos(sead::Vector2f* output, const IUseCamera*, const sead::Vector3f&)

void calcLayoutPosFromWorldPos(sead::Vector3f* output, const IUseCamera*, const sead::Vector3f&)

void calcLayoutPosFromWorldPos(sead::Vector2f* output, const SceneCameraInfo*, const sead::Vector3f&, s32)

void calcLayoutPosFromWorldPos(sead::Vector3f* output, const SceneCameraInfo*, const sead::Vector3f&, s32)

void calcLayoutPosFromWorldPosSub(sead::Vector2f* output, const IUseCamera*, const sead::Vector3f&)

void calcLayoutPosFromWorldPosWithClampOutRange(sead::Vector3f* output, const IUseCamera*, const sead::Vector3f&, f32, s32)

void calcLayoutPosFromWorldPosWithClampOutRange(sead::Vector3f* output, const SceneCameraInfo*, const sead::Vector3f&, f32, s32)

void calcLayoutPosFromWorldPosWithClampByScreen(sead::Vector3f* output, const IUseCamera*, const sead::Vector3f&)

auto calcLayoutRadiusFromWorldRadius(const sead::Vector3f&, const IUseCamera*, f32) -> f32

auto calcCameraPosToWorldPosDirFromScreenPos(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, f32) -> bool

auto calcCameraPosToWorldPosDirFromScreenPos(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, const sead::Vector3f&) -> bool

auto calcCameraPosToWorldPosDirFromScreenPos(sead::Vector3f* output, const SceneCameraInfo*, const sead::Vector2f&, f32, s32) -> bool

auto calcCameraPosToWorldPosDirFromScreenPos(sead::Vector3f* output, const SceneCameraInfo*, const sead::Vector2f&, const sead::Vector3f&, s32) -> bool

void calcCameraPosToWorldPosDirFromScreenPosSub(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, f32)

void calcCameraPosToWorldPosDirFromScreenPosSub(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, const sead::Vector3f&)

void calcLineCameraToWorldPosFromScreenPos(sead::Vector3f* output1, sead::Vector3f* output2, const IUseCamera*, const sead::Vector2f&)

void calcLineCameraToWorldPosFromScreenPos(sead::Vector3f* output1, sead::Vector3f* output2, const IUseCamera*, const sead::Vector2f&, f32, f32)

void calcLineCameraToWorldPosFromScreenPos(sead::Vector3f* output1, sead::Vector3f* output2, const SceneCameraInfo*, const sead::Vector2f&, s32)

void calcLineCameraToWorldPosFromScreenPos(sead::Vector3f* output1, sead::Vector3f* output2, const SceneCameraInfo*, const sead::Vector2f&, f32, f32, s32)

void calcLineCameraToWorldPosFromScreenPosSub(sead::Vector3f* output1, sead::Vector3f* output2, const IUseCamera*, const sead::Vector2f&)

void calcLineCameraToWorldPosFromScreenPosSub(sead::Vector3f* output1, sead::Vector3f* output2, const IUseCamera*, const sead::Vector2f&, f32, f32)

void startSe(const IUseAudioKeeper*, const sead::SafeString&)

auto verifySeKeeperNull(const IUseAudioKeeper*, const sead::SafeString&) -> bool

auto tryStartSe(const IUseAudioKeeper*, const sead::SafeString&) -> bool

void holdSe(const IUseAudioKeeper*, const sead::SafeString&)

auto tryHoldSe(const IUseAudioKeeper*, const sead::SafeString&) -> bool

void startSeWithParam(const IUseAudioKeeper*, const sead::SafeString&, f32, const char*)

auto tryStartSeWithParam(const IUseAudioKeeper*, const sead::SafeString&, f32, const char*) -> bool

void holdSeWithParam(const IUseAudioKeeper*, const sead::SafeString&, f32, const char*)

auto tryHoldSeWithParam(const IUseAudioKeeper*, const sead::SafeString&, f32, const char*) -> bool

void startSeWithMeInfo(const IUseAudioKeeper*, const sead::SafeString&, const MeInfo*)

void holdSeWithMeInfo(const IUseAudioKeeper*, const sead::SafeString&, const MeInfo*)

void startSeWithManualControl(const IUseAudioKeeper*, const sead::SafeString&, const SePlayParamList*, const char*, const sead::Vector3f*)

auto tryStartSeWithManualControl(const IUseAudioKeeper*, const sead::SafeString&, const SePlayParamList*, const char*, const sead::Vector3f*) -> bool

void holdSeWithManualControl(const IUseAudioKeeper*, const sead::SafeString&, const SePlayParamList*, const char*, const sead::Vector3f*)

auto tryHoldSeWithManualControl(const IUseAudioKeeper*, const sead::SafeString&, const SePlayParamList*, const char*, const sead::Vector3f*) -> bool

void stopSe(const IUseAudioKeeper*, const sead::SafeString&, s32, const char*)

void stopSeWithoutFreezed(const IUseAudioKeeper*, const sead::SafeString&, s32, const char*)

auto tryStopSe(const IUseAudioKeeper*, const sead::SafeString&, s32, const char*) -> bool

void tryStopAllSeFromUser(const IUseAudioKeeper*, s32, const char*)

void stopAllSeFromUser(const IUseAudioKeeper*, s32, const char*)

auto isPlayingAnySe(const IUseAudioKeeper*, const char*) -> bool

auto checkIsPlayingSe(const IUseAudioKeeper*, const sead::SafeString&, const char*) -> bool

void setLifeTimeForHoldCall(const IUseAudioKeeper*, const char*, s32, const char*)

void setSeSourceVolume(const IUseAudioKeeper*, f32)

void setSeKeeperPlayNamePrefix(const IUseAudioKeeper*, const char*)

void resetSeKeeperPlayNamePrefix(const IUseAudioKeeper*)

auto isExistSeKeeper(const IUseAudioKeeper*) -> bool

void forceActivateSeKeeper(IUseAudioKeeper*)

void validateSeKeeper(IUseAudioKeeper*)

void invalidateSeKeeper(IUseAudioKeeper*)

void setSeEmitterPoseMtxPtr(const IUseAudioKeeper*, const sead::Matrix34f*, const char*)

void setSeEmitterPosePosPtr(const IUseAudioKeeper*, const sead::Vector3f*, const char*)

void tryUpdateSeMaterialCode(IUseAudioKeeper*, const char*)

void updateSeMaterialWater(IUseAudioKeeper*, bool)

void updateSeMaterialWet(IUseAudioKeeper*, bool)

void updateSeMaterialBeyondWall(IUseAudioKeeper*, bool)

void updateSeMaterialPuddle(IUseAudioKeeper*, bool)

void resetSeMaterialName(const IUseAudioKeeper*)

void setSeModifier(const IUseAudioKeeper*, ISeModifier*)

void setSeUserSyncParamPtr(const IUseAudioKeeper*, const f32*, const char*)

void setSeUserSyncParamPtrInt(const IUseAudioKeeper*, const s32*, const char*)

void setSeOutputFromController(SePlayParamList*, s32, bool)

void setSeOutputTvDrcRemoteAll(SePlayParamList*)

auto isExistShadow(LiveActor* actor) -> bool

auto isExistShadowMaskCtrl(LiveActor* actor) -> bool

auto isExistShadowMask(LiveActor* actor, const char* maskName) -> bool

auto isExistDepthShadow(LiveActor* actor) -> bool

auto isExistDepthShadowMapCtrl(LiveActor* actor) -> bool

auto isExistAnyShadowCtrl(LiveActor* actor) -> bool

auto isHideShadowMask(const LiveActor* actor) -> bool

void hideShadow(LiveActor* actor)

void showShadow(LiveActor* actor)

void showShadowMask(LiveActor* actor)

void showShadowMask(LiveActor* actor, ShadowMaskBase* mask)

void showShadowMask(LiveActor* actor, const char* maskName)

void showShadowMask(LiveActor* actor, ShadowMaskDrawCategory drawCategory)

void hideShadowMask(LiveActor* actor)

void hideShadowMask(LiveActor* actor, ShadowMaskBase* mask)

void hideShadowMask(LiveActor* actor, const char* maskName)

void hideShadowMask(LiveActor* actor, ShadowMaskDrawCategory drawCategory)

auto isHideShadowMask(LiveActor* actor, const char* maskName) -> bool

void showDepthShadowMap(LiveActor* actor, s32 mapIdx)

void showDepthShadowMap(const LiveActor* actor, DepthShadowMapInfo* map)

void showDepthShadowMap(LiveActor* actor, const char* mapName)

void hideDepthShadowMap(LiveActor* actor, s32 mapIdx)

void hideDepthShadowMap(const LiveActor* actor, DepthShadowMapInfo* map)

void hideDepthShadowMap(LiveActor* actor, const char* mapName)

auto isHideDepthShadowMap(LiveActor* actor, const char* mapName) -> bool

auto isHideDepthShadowMap(LiveActor* actor, s32 mapIdx) -> bool

auto getDepthShadowMapNum(LiveActor* actor) -> s32

void validateShadowMask(LiveActor* actor)

void validateShadowMask(LiveActor* actor, ShadowMaskBase* mask)

void validateShadowMask(LiveActor* actor, const char* maskName)

void invalidateShadowMask(LiveActor* actor)

void invalidateShadowMask(LiveActor* actor, ShadowMaskBase* mask)

void invalidateShadowMask(LiveActor* actor, const char* maskName)

void validateDepthShadowMap(LiveActor* actor)

void validateDepthShadowMap(LiveActor* actor, DepthShadowMapInfo* map)

void validateDepthShadowMap(LiveActor* actor, const char* mapName)

void invalidateDepthShadowMap(LiveActor* actor)

void invalidateDepthShadowMap(LiveActor* actor, DepthShadowMapInfo* map)

void invalidateDepthShadowMap(LiveActor* actor, const char* mapName)

void invalidateShadowMask(LiveActor* actor, ShadowMaskDrawCategory drawCategory)

void invalidateShadowMaskIntensityAll(LiveActor* actor)

void setShadowMaskFixed(LiveActor* actor, bool isFixed)

void setShadowMaskDropDir(LiveActor* actor, const sead::Vector3f& dropDir)

void setShadowMaskDropDir(LiveActor* actor, const sead::Vector3f& dropDir, const char* maskName)

void setShadowMaskDropDirActorDown(LiveActor* actor)

void setShadowMaskSize(LiveActor* actor, const char* maskName, const sead::Vector3f& size)

void setShadowMaskSize(LiveActor* actor, const char* maskName, f32 sizeX, f32 sizeY, f32 sizeZ)

void setShadowTextureOffset(LiveActor* actor, const char* maskName, f32 offsetX, f32 offsetY)

void onShadowTextureScroll(LiveActor* actor, const char* maskName)

void offShadowTextureScroll(LiveActor* actor, const char* maskName)

void calcShadowMaskSize(sead::Vector3f* size, LiveActor* actor, const char* maskName)

auto getShadowMaskDropLength(const LiveActor* actor, const char* maskName) -> f32

void setShadowMaskDropLength(LiveActor* actor, f32 dropLength)

void setShadowMaskDropLength(LiveActor* actor, f32 dropLength, const char* maskName)

void setShadowMaskDropLengthScaleWithDrawCategory(LiveActor* actor, f32 dropLengthScale, ShadowMaskDrawCategory drawCategory)

void setShadowMaskDropLengthWithDrawCategory(LiveActor* actor, f32 dropLength, ShadowMaskDrawCategory drawCategory)

void setShadowMaskDropLengthEvenWithTarget(ShadowMaskBase* targetMask, const char* maskName, const sead::Vector3f&)

void setShadowMaskDropLengthEvenWithTarget(ShadowMaskBase* targetMask, const ShadowMaskBase* mask, const sead::Vector3f&)

void setShadowMaskDropLengthEvenWithDrawCategory(LiveActor*, ShadowMaskDrawCategory drawCategory, const LiveActor*, const char* maskName)

void setShadowMaskDropLengthEvenPlaneNormal(const LiveActor* actor, const sead::Vector3f&)

auto getDepthShadowMapWidth(const LiveActor* actor, const char* mapName) -> s32

auto getDepthShadowMapHeight(const LiveActor* actor, const char* mapName) -> s32

void setDepthShadowMapSize(const LiveActor* actor, s32 width, s32 height, const char* mapName)

auto getDepthShadowMapLength(const LiveActor* actor, const char* mapName) -> f32

void setDepthShadowMapLength(const LiveActor* actor, f32 length, const char* mapName)

void setDepthShadowMapLengthFromActorTransFlag(const LiveActor* actor, bool isSetShadowLength, const char* mapName)

void setDepthShadowMapBoundingBox(const LiveActor* actor, const sead::Vector3f& boundMin, const sead::Vector3f& boundMax, const char* mapName)

void setDepthShadowMapMaskTypeNone(const LiveActor* actor, const char* mapName)

void setDepthShadowMapMaskTypeSelf(const LiveActor* actor, const char* mapName)

void setEnableDepthShadowMapBottomGradation(const LiveActor* actor, const char* mapName, bool isEnableBottomGradation)

auto isEnableDepthShadowMapBottomGradation(const LiveActor* actor, const char* mapName) -> bool

void setDepthShadowMapBottomGradationLength(const LiveActor* actor, const char* mapName, f32 length)

auto getDepthShadowMapBottomGradationLength(const LiveActor* actor, const char* mapName) -> f32

auto isAppendSubActorDepthShadowMap(const LiveActor* actor) -> bool

auto getShadowMaskDropLengthMax(const LiveActor* actor) -> f32

void setShadowMaskColor(const LiveActor* actor, const char* maskName, const sead::Color4f& color)

auto getShadowMaskColor(const LiveActor* actor, const char* maskName) -> const sead::Color4f&

void setShadowMaskIntensity(const LiveActor* actor, const char* maskName, f32 intensity)

auto getShadowMaskIntensity(const LiveActor* actor, const char* maskName) -> f32

auto getShadowMaskTextureFixedScale(const LiveActor* actor, const char* maskName) -> f32

void setShadowMaskTextureFixedScale(const LiveActor* actor, const char* maskName, f32 scale)

auto getShadowMaskOffset(const LiveActor* actor, const char* maskName) -> const sead::Vector3f&

void setShadowMaskOffset(const LiveActor* actor, const sead::Vector3f& offset, const char* maskName)

auto isExistOcclusionLightPosPtr(const LiveActor* actor, const char* occSphereName) -> bool

void setOcclusionLightPosPtr(const LiveActor* actor, const char* occSphereName, const sead::Vector3f* lightPosPtr)

void setOcclusionAddOffset(const LiveActor* actor, const char* occSphereName, const sead::Vector3f& offset)

void enableOcclusion(const LiveActor* actor, const char* occSphereName)

void disableOcclusion(const LiveActor* actor, const char* occSphereName)

auto isEnableOcclusion(const LiveActor* actor, const char* occSphereName) -> bool

void calcSphereDoBoundingInfo(sead::Vector3f*, sead::Vector3f*, f32*, f32*, const LiveActor* actor, const char* occSphereName, f32)

void calcOcclusionSpherePos(sead::Vector3f* pos, const LiveActor* actor, const char* occSphereName)

void changeOcclusionGroup(const LiveActor* actor, const char* occSphereName, const char* groupName)

auto getOcclusionSphere(const LiveActor* actor, const char* occSphereName) -> OccSphere*

void setOcclusionIgnoreHostHide(const LiveActor* actor, bool isIgnoreHostHide)

auto findIsInShade(const LiveActor* actor, const sead::Vector3f& pos) -> bool

void requestDepthShadowMapLightDir(const LiveActor* actor, const sead::Vector3f& lightDir, const char* mapName)

void resetRequestDepthShadowMapLightDir(const LiveActor* actor, const char* mapName)

auto isRequestDepthShadowMapLightDir(const LiveActor* actor, const char* mapName) -> bool

void onDepthShadowModel(LiveActor* actor)

void offDepthShadowModel(LiveActor* actor)

void updateDepthShadowMapCtrlShapeVisible(LiveActor* actor)

void makeStageDataArchivePath(sead::BufferedSafeString* archivePath, const char* stageName, const char* resourceType)

void initStageSwitch(IUseStageSwitch* user, StageSwitchDirector* stageSwitchDirector, const PlacementInfo& placementInfo)

static auto getStageSwitchAccesser(const IUseStageSwitch* user, const char* linkName) -> StageSwitchAccesser*

auto isValidStageSwitch(const IUseStageSwitch* user, const char* linkName) -> bool

auto isOnStageSwitch(const IUseStageSwitch* user, const char* linkName) -> bool

void onStageSwitch(IUseStageSwitch* user, const char* linkName)

void offStageSwitch(IUseStageSwitch* user, const char* linkName)

auto tryOnStageSwitch(IUseStageSwitch* user, const char* linkName) -> bool

auto tryOffStageSwitch(IUseStageSwitch* user, const char* linkName) -> bool

auto isSameStageSwitch(const IUseStageSwitch* user, const IUseStageSwitch* otherUser, const char* linkName) -> bool

auto isValidSwitchAppear(const IUseStageSwitch* user) -> bool

auto isOnSwitchAppear(const IUseStageSwitch* user) -> bool

auto isValidSwitchKill(const IUseStageSwitch* user) -> bool

auto isValidSwitchDeadOn(const IUseStageSwitch* user) -> bool

void onSwitchDeadOn(IUseStageSwitch* user)

void offSwitchDeadOn(IUseStageSwitch* user)

auto tryOnSwitchDeadOn(IUseStageSwitch* user) -> bool

auto tryOffSwitchDeadOn(IUseStageSwitch* user) -> bool

auto isValidSwitchStart(const IUseStageSwitch* user) -> bool

auto isOnSwitchStart(const IUseStageSwitch* user) -> bool

auto listenStageSwitchOn(IUseStageSwitch* user, const char* eventName, const FunctorBase& action) -> bool

auto listenStageSwitchOff(IUseStageSwitch* user, const char* eventName, const FunctorBase& action) -> bool

auto listenStageSwitchOnOff(IUseStageSwitch* user, const char* eventName, const FunctorBase& actionOn, const FunctorBase& actionOff) -> bool

auto listenStageSwitchOnAppear(IUseStageSwitch* user, const FunctorBase& action) -> bool

auto listenStageSwitchOnOffAppear(IUseStageSwitch* user, const FunctorBase& actionOn, const FunctorBase& actionOff) -> bool

auto listenStageSwitchOnKill(IUseStageSwitch* user, const FunctorBase& action) -> bool

auto listenStageSwitchOnOffKill(IUseStageSwitch* user, const FunctorBase& actionOn, const FunctorBase& actionOff) -> bool

auto trySyncStageSwitchOnOffAppear(IUseStageSwitch* user, const FunctorBase& actionOn, const FunctorBase& actionOff) -> bool

auto trySyncStageSwitchOnOffKill(IUseStageSwitch* user, const FunctorBase& actionOn, const FunctorBase& actionOff) -> bool

auto trySyncStageSwitchOnOffAppearAndKill(IUseStageSwitch* user, const FunctorBase& actionOn, const FunctorBase& actionOff) -> bool

auto listenStageSwitchOnStart(IUseStageSwitch* user, const FunctorBase& action) -> bool

auto listenStageSwitchOnOffStart(IUseStageSwitch* user, const FunctorBase& actionOn, const FunctorBase& actionOff) -> bool

auto listenStageSwitchOnStop(IUseStageSwitch* user, const FunctorBase& action) -> bool

auto trySyncStageSwitchOnOff(IUseStageSwitch* user, const FunctorBase& actionOn, const FunctorBase& actionOff) -> bool

auto tryGetByamlU8(u8* pOut, const ByamlIter& rIter, const char* pKey) -> bool

auto tryGetByamlU16(u16* pOut, const ByamlIter& rIter, const char* pKey) -> bool

auto tryGetByamlS16(s16* pOut, const ByamlIter& rIter, const char* pKey) -> bool

auto tryGetByamlS32(s32* pOut, const ByamlIter& rIter, const char* pKey) -> bool

auto tryGetByamlU32(u32* pOut, const ByamlIter& rIter, const char* pKey) -> bool

auto tryGetByamlS64(s64* pOut, const ByamlIter& rIter, const char* pKey) -> bool

auto tryGetByamlU64(u64* pOut, const ByamlIter& rIter, const char* pKey) -> bool

auto tryGetByamlF32(f32* pOut, const ByamlIter& rIter, const char* pKey) -> bool

auto tryGetByamlV2f(sead::Vector2f* pOut, const ByamlIter& rIter) -> bool

auto tryGetByamlV3f(sead::Vector3f* pOut, const ByamlIter& rIter) -> bool

auto tryGetByamlV4f(sead::Vector4f* pOut, const ByamlIter& rIter) -> bool

auto tryGetByamlScale(sead::Vector3f* pOut, const ByamlIter& rIter) -> bool

auto tryGetByamlV2s32(sead::Vector2i* pOut, const ByamlIter& rIter) -> bool

auto tryGetByamlV3s32(sead::Vector3i* pOut, const ByamlIter& rIter) -> bool

auto tryGetByamlBox3f(sead::BoundBox3f* pOut, const ByamlIter& rIter) -> bool

auto tryGetByamlV3f(sead::Vector3f* pOut, const ByamlIter& sIter, const char* key) -> bool

auto tryGetByamlV2f(sead::Vector2f* pOut, const ByamlIter& sIter, const char* key) -> bool

auto tryGetByamlV4f(sead::Vector4f* pOut, const ByamlIter& sIter, const char* key) -> bool

auto tryGetByamlScale(sead::Vector3f* pOut, const ByamlIter& sIter, const char* key) -> bool

auto tryGetByamlV2s32(sead::Vector2i* pOut, const ByamlIter& sIter, const char* key) -> bool

auto tryGetByamlV3s32(sead::Vector3i* pOut, const ByamlIter& sIter, const char* key) -> bool

auto tryGetByamlBox3f(sead::BoundBox3f* pOut, const ByamlIter& sIter, const char* key) -> bool

auto tryGetByamlString(const char** pOut, const ByamlIter& rIter, const char* key) -> bool

auto tryGetByamlColor(sead::Color4f* pOut, const ByamlIter& rIter) -> bool

auto tryGetByamlColor(sead::Color4f* pOut, const ByamlIter& sIter, const char* key) -> bool

auto tryGetByamlBool(bool* pOut, const ByamlIter& rIter, const char* key) -> bool

auto tryGetByamlKeyStringOrNULL(const ByamlIter& rIter, const char* key) -> const char*

auto tryGetByamlKeyIntOrZero(const ByamlIter& rIter, const char* key) -> s32

auto tryGetByamlKeyU32OrZero(const ByamlIter& rIter, const char* key) -> u32

auto tryGetByamlKeyFloatOrZero(const ByamlIter& rIter, const char* key) -> f32

auto tryGetByamlKeyBoolOrFalse(const ByamlIter& rIter, const char* key) -> bool

auto tryGetByamlIterByKey(ByamlIter* pOut, const ByamlIter& rIter, const char* key) -> bool

auto tryGetByamlKeyAndIntByIndex(const char** key, s32* pOut, const ByamlIter& rIter, s32 index) -> bool

auto getByamlKeyString(const ByamlIter& rIter, const char* key) -> const char*

auto getByamlKeyInt(const ByamlIter& rIter, const char* key) -> s32

auto getByamlKeyFloat(const ByamlIter& rIter, const char* key) -> f32

auto getByamlKeyBool(const ByamlIter& rIter, const char* key) -> bool

void getByamlIterByKey(ByamlIter* pOut, const ByamlIter& rIter, const char* pKey)

void getByamlIterByIndex(ByamlIter* pOut, const ByamlIter& rIter, s32 index)

auto isTypeBoolByIndex(const ByamlIter& rIter, s32 index) -> bool

auto isTypeBoolByKey(const ByamlIter& rIter, const char* pKey) -> bool

auto isTypeIntByIndex(const ByamlIter& rIter, s32 index) -> bool

auto isTypeIntByKey(const ByamlIter& rIter, const char* pKey) -> bool

auto isTypeFloatByIndex(const ByamlIter& rIter, s32 index) -> bool

auto isTypeFloatByKey(const ByamlIter& rIter, const char* pKey) -> bool

auto isTypeStringByIndex(const ByamlIter& rIter, s32 index) -> bool

auto isTypeStringByKey(const ByamlIter& rIter, const char* pKey) -> bool

auto isTypeArrayByIndex(const ByamlIter& rIter, s32 index) -> bool

auto isTypeArrayByKey(const ByamlIter& rIter, const char* pKey) -> bool

auto isTypeHashByIndex(const ByamlIter& rIter, s32 index) -> bool

auto isTypeHashByKey(const ByamlIter& rIter, const char* pKey) -> bool

auto getByamlIterDataNum(const ByamlIter& rIter) -> s32

void printByamlIter(const u8* data)

void printByamlIter(const ByamlIter& iter)

void printByamlIter_(const ByamlIter& iter, PrintParams* param)

template<ByamlDataType T>

auto isTypeByIndex(const ByamlIter& rIter, s32 index) -> bool

template<ByamlDataType T>

auto isTypeByKey(const ByamlIter& rIter, const char* key) -> bool

SEAD_ENUM(YamlParamType, Invalid, Bool, F32, S32, U32, V2f, V2s32, V3f, V4f, Q4f, C4f, StringRef, String32, String64, String128, String256, String512, String1024, String2048, String4096)

auto add(const char* string, sead::TList<const char*>& list) -> char*

auto getFileList(sead::FixedSafeString<256> out[], s32 outSize, const char* path, bool isPathValidconst sead::DirectoryEntry &, const char *, const char* suffix) -> u32

static auto isDirectoryValid(const sead::DirectoryEntry& entry, const char* suffix) -> bool

static auto isFileValid(const sead::DirectoryEntry& entry, const char* suffix) -> bool

auto createRollingCubePoseKeeper(const LiveActor* actor, const ActorInitInfo& initInfo) -> RollingCubePoseKeeper*

auto createRollingCubePoseKeeper(const sead::BoundBox3f& cubeSize, const ActorInitInfo& initInfo) -> RollingCubePoseKeeper*

auto nextRollingCubeKey(RollingCubePoseKeeper* keeper) -> bool

void setStartRollingCubeKey(RollingCubePoseKeeper* keeper)

void setRollingCubeKeyIndex(RollingCubePoseKeeper* keeper, s32 index)

auto isMoveTypeLoopRollingCube(const RollingCubePoseKeeper* keeper) -> bool

void fittingToCurrentKeyBoundingBox(sead::Quatf* outQuat, sead::Vector3f* outTrans, const RollingCubePoseKeeper* keeper)

void calcCurrentKeyQT(sead::Quatf* outQuat, sead::Vector3f* outTrans, const RollingCubePoseKeeper* keeper, const sead::Quatf& quat, const sead::Vector3f& trans, f32 rate)

void getCurrentKeyQT(sead::Quatf* outQuat, sead::Vector3f* outTrans, const RollingCubePoseKeeper* keeper)

auto getCurrentKeyRotateDegree(const RollingCubePoseKeeper* keeper) -> f32

auto getCurrentKeySlideVec(const RollingCubePoseKeeper* keeper) -> const sead::Vector3f&

auto getCurrentKeyIndex(const RollingCubePoseKeeper* keeper) -> s32

auto getCurrentKeyPlacementInfo(const RollingCubePoseKeeper* keeper) -> const PlacementInfo&

auto isMovementCurrentKeyRotate(const RollingCubePoseKeeper* keeper) -> bool

auto isMovementCurrentKeySlide(const RollingCubePoseKeeper* keeper) -> bool

auto calcDistanceCurrentKeyRotateCenterToBoxCenter(const RollingCubePoseKeeper* keeper) -> f32

void calcMtxLandEffect(sead::Matrix34f* effectMtx, const RollingCubePoseKeeper* keeper, const sead::Quatf& quat, const sead::Vector3f& trans)

void calcRollingCubeClippingInfo(sead::Vector3f* clippingTrans, f32* clippingRadius, const RollingCubePoseKeeper* keeper, f32 offset)

void executeUpdate(LiveActorKit*, const char*)

void executeUpdateTable(LiveActorKit*, const char*)

void executeUpdateList(LiveActorKit*, const char*, const char*)

void executeDraw(const LiveActorKit*, const char*)

void executeDrawList(const LiveActorKit*, const char*, const char*)

auto isActiveDraw(const LiveActorKit*, const char*) -> bool

void executeUpdateDrawBuffer(const LiveActorKit*)

void waitUpdateDrawBuffer(const LiveActorKit*)

void executeUpdateCalcView(const LiveActorKit*)

void waitUpdateCalcView(const LiveActorKit*)

void incrementDrawBufferCounter(const LiveActorKit*)

void registSupportFreezeSyncGroup(LiveActor* actor, const ActorInitInfo& info)

Variables

static NameToCreator<AreaShapeCreatorFunction> sAreaShapeEntries

const char* str2

const char* archiveName

const CameraShaker::ShakeInfo WeakShakeLoop

const CameraShaker::ShakeInfo ShakeInfos

const char* name

const char const char* groupName

const char const char const char* areaName

AreaObjGroup* areaGroup

const PlacementInfo& actorPlacementInfo

const NameToCreator<PoseKeeperCreatorFunction> gActorPoseTable

LiveActor* actor

s32 poseId

return false

const ActorInitInfo& initInfo

const ActorInitInfo Resource* modelRes

const ActorInitInfo Resource const char* suffix

const char* pose

sead::Vector3f scale

const sead::Vector3f& prevScale

scale x

scale y

scale z

sead::BoundBox3f modelBoundingBox

s32 lodModelCount

ModelLodCtrl* modelLodCtrl

const ActorInitInfo Resource ActorResource* actorResource

s32 blendAnimMax

const char* displayRootJointName

bool isCreateUniqShader

s32 partialAnimSlotNum

s32 partialAnimGroupNum

s32 partialAnimPartsListBufferSize

bool isFixedModel

bool isIgnoreUpdateOnDrawClipping

true

ModelKeeper* modelKeeper

MaterialCategoryKeeper* materialCategoryKeeper

GraphicsQualityInfo* graphicsQualityInfo

ModelOcclusionQuery* modelOcclusionQuery

bool isCalcViewCore1

bool isCalcViewCore2

const char* updaterCategoryName

const char* drawerCategoryName

ByamlIter iter

s32 numSensors

sead::FixedSafeString<256> unused

const char* sensorName

HitSensor* sensor

const char* joint

sead::Matrix34f* jointMtx

f32 radius

u32 planeNum

sead::Vector3f offset

const char* seName

const char* bgmName

else return

const ActorInitInfo const ByamlIter& initClipping

ByamlIter groupClipping

bool invalidate

sead::BoundBox3f obb

f32 nearClipDistance

tryGetArg& usingDepthShadow

ByamlIter initShadowMask

ByamlIter tmp

DitherAnimator* ditherAnimator

const PlacementInfo* placementInfo

const char* objectName

const char* className

ActorCreatorFunction creationFunction

const char* displayName

const LiveActor* target

const LiveActor const sead::Vector3f& targetVelocity

const LiveActor const sead::Vector3f f32 reboundStrength

calcDirToActor& direction

f32 dot

static sead::FixedSafeString<256> sDeviceName

Enum documentation

enum class al::CollisionLocation: u8

#include <l/Library/Collision/CollisionPartsTriangle.h>

enum class al::FloaterMoveType: s32

#include <l/Library/MapObj/FloaterMapParts.h>

enum class al::Axis: s32

#include <l/Library/Math/Axis.h>

enum al::EaseType: s32

#include <l/Library/Math/MathUtil.h>

enum class al::MoveType: s32

#include <l/Library/Movement/MoveType.h>

enum class al::ShadowMaskDrawCategory: s32

#include <l/Library/Shadow/ActorShadowUtil.h>

enum al::ByamlDataType: const u8

#include <l/Library/Yaml/ByamlData.h>

enum class al::FileState: s32

#include <l/Project/FileEntryBase.h>

enum class al::HitSensorType: u32

#include <l/Project/HitSensor/HitSensor.h>

Typedef documentation

using al::AreaCreatorFunction = AreaObj*(*)(const char*areaName)

#include <l/Library/Area/AreaObjFactory.h>

using al::AreaShapeCreatorFunction = AreaShape*(*)()

#include <l/Library/Area/AreaShape.h>

using al::CameraPoserCreatorFunction = CameraPoser*(*)(const char*cameraPoserName)

#include <l/Library/Camera/CameraPoserFactory.h>

using al::EventFlowNodeCreatorFunction = EventFlowNode*(*)(const char*eventFlowNodeName)

#include <l/Library/Event/EventFlowNodeFactory.h>

typedef Matrix43<f32> al::Matrix43f

#include <l/Library/Layout/LayoutActorUtil.h>

using al::ActorCreatorFunction = LiveActor*(*)(const char*actorName)

#include <l/Library/LiveActor/ActorFactory.h>

using al::PoseKeeperCreatorFunction = void(*)(LiveActor*)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

using al::JudgeFuncPtr = bool(*)(const SensorMsg*message, HitSensor*other, HitSensor*self)

#include <l/Library/MapObj/BreakMapPartsBase.h>

using al::SensorSortCmpFunc = bool(*)(HitSensor*a, HitSensor*b)

#include <l/Project/HitSensor/HitSensor.h>

Function documentation

AreaObj* al::tryFindAreaObj(const IUseAreaObj* areaUser, const char* name, const sead::Vector3f& position)

#include <l/Library/Area/AreaObjUtil.h>

AreaObj* al::tryFindAreaObjWithFilter(const IUseAreaObj* areaUser, const char* name, const sead::Vector3f& position, AreaObjFilterBase* filter)

#include <l/Library/Area/AreaObjUtil.h>

bool al::tryFindAreaObjAll(const IUseAreaObj* areaUser, const char* name, const sead::Vector3f& position, AreaObjFindCallBack* callBack)

#include <l/Library/Area/AreaObjUtil.h>

AreaObjGroup* al::tryFindAreaObjGroup(const IUseAreaObj* areaUser, const char* name)

#include <l/Library/Area/AreaObjUtil.h>

bool al::isInAreaObj(const AreaObjGroup* group, const sead::Vector3f& position)

#include <l/Library/Area/AreaObjUtil.h>

AreaObj* al::tryGetAreaObj(const AreaObjGroup* group, const sead::Vector3f& position)

#include <l/Library/Area/AreaObjUtil.h>

bool al::isInAreaPos(const AreaObj* areaObj, const sead::Vector3f& position)

#include <l/Library/Area/AreaObjUtil.h>

bool al::isInAreaObj(const IUseAreaObj* areaUser, const char* name, const sead::Vector3f& position)

#include <l/Library/Area/AreaObjUtil.h>

bool al::isExistAreaObj(const IUseAreaObj* areaUser, const char* name)

#include <l/Library/Area/AreaObjUtil.h>

bool al::isInDeathArea(const IUseAreaObj* areaUser, const sead::Vector3f& position)

#include <l/Library/Area/AreaObjUtil.h>

bool al::isInWaterArea(const IUseAreaObj* areaUser, const sead::Vector3f& position)

#include <l/Library/Area/AreaObjUtil.h>

bool al::isInPlayerControlOffArea(const IUseAreaObj* areaUser, const sead::Vector3f& position)

#include <l/Library/Area/AreaObjUtil.h>

s32 al::calcAreaObjNum(const IUseAreaObj* areaUser, const char* name)

#include <l/Library/Area/AreaObjUtil.h>

f32 al::calcWaterSinkDepth(const IUseAreaObj* areaUser, const sead::Vector3f& position)

#include <l/Library/Area/AreaObjUtil.h>

bool al::tryGetAreaObjArg(s32* outArg, const AreaObj* areaObj, const char* key)

#include <l/Library/Area/AreaObjUtil.h>

bool al::tryGetAreaObjArg(f32* outArg, const AreaObj* areaObj, const char* key)

#include <l/Library/Area/AreaObjUtil.h>

bool al::tryGetAreaObjArg(bool* outArg, const AreaObj* areaObj, const char* key)

#include <l/Library/Area/AreaObjUtil.h>

bool al::tryGetAreaObjStringArg(const char** outArg, const AreaObj* areaObj, const char* key)

#include <l/Library/Area/AreaObjUtil.h>

const sead::Matrix34f& al::getAreaObjBaseMtx(const AreaObj* areaObj)

#include <l/Library/Area/AreaObjUtil.h>

const sead::Vector3f& al::getAreaObjScale(const AreaObj* areaObj)

#include <l/Library/Area/AreaObjUtil.h>

void al::getAreaObjDirFront(sead::Vector3f* outFrontDir, const AreaObj* areaObj)

#include <l/Library/Area/AreaObjUtil.h>

void al::getAreaObjDirUp(sead::Vector3f* outUpDir, const AreaObj* areaObj)

#include <l/Library/Area/AreaObjUtil.h>

void al::getAreaObjDirSide(sead::Vector3f* outSideDir, const AreaObj* areaObj)

#include <l/Library/Area/AreaObjUtil.h>

void al::calcNearestAreaObjEdgePos(sead::Vector3f* outNearestEdgePos, const AreaObj* areaObj, const sead::Vector3f& position)

#include <l/Library/Area/AreaObjUtil.h>

void al::calcNearestAreaObjEdgePosTopY(sead::Vector3f* outNearestEdgePosTopY, const AreaObj* areaObj, const sead::Vector3f& position)

#include <l/Library/Area/AreaObjUtil.h>

f32 al::calcNearestAreaObjEdgeRateTopY(const AreaObj* areaObj, const sead::Vector3f& position)

#include <l/Library/Area/AreaObjUtil.h>

void al::calcAreaObjCenterPos(sead::Vector3f* outCenterPosition, const AreaObj* areaObj)

#include <l/Library/Area/AreaObjUtil.h>

bool al::checkAreaObjCollisionByArrow(sead::Vector3f* outHitPosition, sead::Vector3f* outNormal, const AreaObj* areaObj, const sead::Vector3f& position1, const sead::Vector3f& position2)

#include <l/Library/Area/AreaObjUtil.h>

bool al::calcFindAreaSurface(const IUseAreaObj* areaUser, const char* name, sead::Vector3f* outHitPosition, sead::Vector3f* outNormal, const sead::Vector3f& position1, const sead::Vector3f& position2)

#include <l/Library/Area/AreaObjUtil.h>

bool al::calcFindAreaSurface(const IUseAreaObj* areaUser, const char* name, sead::Vector3f* outHitPosition, sead::Vector3f* outNormal, const sead::Vector3f& position, const sead::Vector3f& direction, f32 distance)

#include <l/Library/Area/AreaObjUtil.h>

#include <l/Library/Area/AreaShape.cpp>

template<typename T>

AreaShape* al::createAreaShapeFunction()

#include <l/Library/Area/CreateAreaObjFunction.h>

template<typename T>

AreaObj* al::createAreaObjFunction(const char* areaObjName)

bool al::isAnyPosInVolume(AreaObj* areaObj, sead::Vector3f* targetPos, s32 targetPosCount)

#include <l/Library/Area/SwitchKeepOnAreaGroup.cpp>

bool al::isAllPosInVolume(AreaObj* areaObj, sead::Vector3f* targetPos, s32 targetPosCount)

#include <l/Library/Area/SwitchKeepOnAreaGroup.cpp>

s32 al::calcHashCode(const char* str)

#include <l/Library/Base/HashCodeUtil.h>

s32 al::calcHashCodeLower(const char* str)

#include <l/Library/Base/HashCodeUtil.h>

s32 al::calcHashCodeFmt(const char* format, std::va_list argv)

#include <l/Library/Base/HashCodeUtil.h>

s32 al::calcHashCodeFmt(const char* format, ...)

#include <l/Library/Base/HashCodeUtil.h>

const char* al::getBaseName(const char* name)

#include <l/Library/Base/HashCodeUtil.h>

const char* al::createStringIfInStack(const char* str)

#include <l/Library/Base/StringUtil.h>

const char* al::createConcatString(const char* start, const char* end)

#include <l/Library/Base/StringUtil.h>

void al::createFileNameBySuffix(sead::BufferedSafeString* out, const char* name, const char* suffix)

#include <l/Library/Base/StringUtil.h>

u32 al::outputValueWithComma(char* out, u32 size, u64 value, bool usePadding, bool padToThousands)

#include <l/Library/Base/StringUtil.h>

void al::extractString(char* out, const char* str, u32 len, u32 unused)

#include <l/Library/Base/StringUtil.h>

const char* al::searchSubString(const char* str, const char* substr)

#include <l/Library/Base/StringUtil.h>

const char* al::searchSubString(const char* str, const char* substr, s32 substrLen)

#include <l/Library/Base/StringUtil.h>

void al::removeExtensionString(char* out, u32 len, const char* str)

#include <l/Library/Base/StringUtil.h>

void al::removeStringFromEnd(char* out, u32 len, const char* end, const char* str)

#include <l/Library/Base/StringUtil.h>

void al::translateCharacters(char* string, const char* charmap, const char* newCharmap)

#include <l/Library/Base/StringUtil.h>

bool al::isEqualString(const char16* str1, const char16* str2)

#include <l/Library/Base/StringUtil.h>

bool al::isEqualSubString(const char* str, const char* subStr)

#include <l/Library/Base/StringUtil.h>

bool al::isEqualSubString(const sead::SafeString& str, const sead::SafeString& subStr)

#include <l/Library/Base/StringUtil.h>

bool al::isStartWithString(const char* str, const char* start)

#include <l/Library/Base/StringUtil.h>

bool al::isEndWithString(const char* str, const char* end)

#include <l/Library/Base/StringUtil.h>

s32 al::compareStringIgnoreCase(const char* str1, const char* str2)

#include <l/Library/Base/StringUtil.h>

void al::copyString(char* out, const char* str, u32 len)

#include <l/Library/Base/StringUtil.h>

void al::copyStringW(char16* out, const char16* str, u32 len)

#include <l/Library/Base/StringUtil.h>

al::__attribute__((noinline)) bool isEqualString(const char *str1

#include <l/Library/Base/StringUtil.cpp>

bool al::isEqualString(const sead::SafeString& safestr1, const sead::SafeString& safestr2)

#include <l/Library/Base/StringUtil.h>

bool al::isEqualStringCase(const char* str1, const char* str2)

#include <l/Library/Base/StringUtil.h>

bool al::isEqualStringCase(const sead::SafeString& str1, const sead::SafeString& str2)

#include <l/Library/Base/StringUtil.h>

const char* al::getSubStringUnmatched(const char**, const char*, const MatchStr&, void(*)(const char*, const char*, void*), void*)

#include <l/Library/Base/StringUtil.h>

const char* al::getSubStringUnmatched(const char*, const MatchStr&)

#include <l/Library/Base/StringUtil.h>

void al::extractBaseNameW(sead::WBufferedSafeString*, const sead::WSafeString&)

#include <l/Library/Base/StringUtil.h>

void al::tryReplaceString(sead::BufferedSafeString*, const char*, const char*)

#include <l/Library/Base/StringUtil.h>

void al::tryReplaceString(sead::BufferedSafeString*, const char*, const char*, const char*)

#include <l/Library/Base/StringUtil.h>

void al::tryReplaceStringNoRecursive(sead::BufferedSafeString*, const char*, const char*, const char*)

#include <l/Library/Base/StringUtil.h>

bool al::isMatchString(const char*, const MatchStr&)

#include <l/Library/Base/StringUtil.h>

void al::makeUrlEncodeString(char*, u32, const char*)

#include <l/Library/Base/StringUtil.h>

void al::makeUrlDecodeString(char*, u32, const char*)

#include <l/Library/Base/StringUtil.h>

bool al::isInStack(const void*)

#include <l/Library/Base/StringUtil.h>

bool al::isEqualString(const char* str1, const char* str2)

#include <l/Library/Base/StringUtil.h>

BgmDirector* al::getBgmDirector(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

BgmDirector* al::tryGetBgmDirector(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

BgmSituationDirector* al::getBgmSituationDirector(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

Bgm3DParamsController* al::getBgm3DParamsController(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

BgmLine* al::getActiveBgmLine(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

BgmLine* al::getPlayingBgmLine(const IUseAudioKeeper*, const char*)

#include <l/Library/Bgm/BgmLineFunction.h>

const char* al::getCurPlayingBgmPlayName(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

const char* al::getCurPlayingBgmResourceName(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

const char* al::getBgmPlayNameInCurPosition(const IUseAudioKeeper*, bool)

#include <l/Library/Bgm/BgmLineFunction.h>

const char* al::getBgmResourceNameInCurPosition(const IUseAudioKeeper*, bool)

#include <l/Library/Bgm/BgmLineFunction.h>

s64 al::getActiveBgmCurSamplePosition(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

s64 al::getBgmLoopEndSamplePosition(const IUseAudioKeeper*, const char*)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::startBgm(const IUseAudioKeeper*, const char*, s32, s32)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::startBgm(const IUseAudioKeeper*, const BgmPlayingRequest&, bool, bool)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::startBgmWithSuffix(const IUseAudioKeeper*, const char*, const char*, s32, s32)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::startAndStopBgmInCurPosition(const IUseAudioKeeper*, bool)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::startBgmSituation(const IUseAudioKeeper*, const char*, bool)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::prepareBgm(const IUseAudioKeeper*, const BgmPlayingRequest&)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::prepareBgmWithAreaCheck(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::stopBgm(const IUseAudioKeeper*, const char*, s32)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::stopBgm(const IUseAudioKeeper*, const BgmPlayingRequest&)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::pauseBgm(const IUseAudioKeeper*, const char*, s32)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::resumeBgm(const IUseAudioKeeper*, const char*, s32)

#include <l/Library/Bgm/BgmLineFunction.h>

bool al::isPlayingBgm(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

bool al::isPlayingBgm(const IUseAudioKeeper*, const char*)

#include <l/Library/Bgm/BgmLineFunction.h>

bool al::isRunningBgm(const IUseAudioKeeper*, const char*)

#include <l/Library/Bgm/BgmLineFunction.h>

bool al::isPlayingResourceCategoryBgm(const IUseAudioKeeper*, const char*)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::stopActiveBgm(const IUseAudioKeeper*, s32)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::pauseActiveBgm(const IUseAudioKeeper*, s32)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::resumeActiveBgm(const IUseAudioKeeper*, s32)

#include <l/Library/Bgm/BgmLineFunction.h>

bool al::isPlayingActiveBgm(const IUseAudioKeeper*, const char*)

#include <l/Library/Bgm/BgmLineFunction.h>

bool al::isPauseActiveBgm(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::stopAllBgm(const IUseAudioKeeper*, s32)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::tryStopAllBgm(const IUseAudioKeeper*, s32)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::setTriggerEventForStopAllBgm(const IUseAudioKeeper*, const FunctorBase&)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::tryPauseBgmIfDifferBgmArea(const LiveActor*, const sead::Vector3f&, s32)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::tryPauseBgmIfLowPriority(const IUseAudioKeeper*, const char*, s32)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::startBgmSituation(const IUseAudioKeeper*, const char*, bool, bool)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::startBgmSituation(const IUseAudioKeeper*, sead::PtrArray<IBgmParamsChanger>*, const char*, bool, bool)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::forceStartBgmSituation(const IUseAudioKeeper*, const char*, bool, bool)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::endBgmSituation(const IUseAudioKeeper*, const char*, bool)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::endBgmSituation(const IUseAudioKeeper*, sead::PtrArray<IBgmParamsChanger>*, const char*, bool)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::forceEndBgmSituation(const IUseAudioKeeper*, const char*, bool)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::startBgm3D(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::endBgm3D(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::changeBgm3DParams(const IUseAudioKeeper*, f32, f32, f32, f32, bool)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::activateBgm3DController(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::deactivateBgm3DController(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

bool al::isActivateBgm3DController(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

s32 al::getActiveBgmSituationNum(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

const char* al::getActiveBgmSituationName(const IUseAudioKeeper*, s32)

#include <l/Library/Bgm/BgmLineFunction.h>

s32 al::getDeactiveBgmSituationNum(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

const char* al::getDeactiveBgmSituationName(const IUseAudioKeeper*, s32)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::takeBgmSituationSnapShot(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::applyBgmSituationSnapShot(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::applyNoAppliedSituationRecord(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

bool al::isStartedBgmSituation(const IUseAudioKeeper*, const char*)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::endAllBgmSituation(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::clearBgmDataForStepOverScene(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::clearBgmPlayPointRecord(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::startBgmSyncedCurBgmBeat(const IUseAudioKeeper*, const BgmPlayingRequest&, s32)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::stopBgmSyncedCurBgmBeat(const IUseAudioKeeper*, const BgmPlayingRequest&, s32)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::disableBgmLineChange(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::enableBgmLineChange(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

bool al::isDisableBgmLineChange(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::disableBgmSituationChange(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::enableBgmSituationChange(const IUseAudioKeeper*, bool)

#include <l/Library/Bgm/BgmLineFunction.h>

bool al::isDisableBgmSituationChange(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

BgmMultiPlayingController* al::tryAllocBgmMultiPlayingController(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::tryReleaseBgmMultiPlayingController(const IUseAudioKeeper*, BgmMultiPlayingController*)

#include <l/Library/Bgm/BgmLineFunction.h>

s32 al::getBgmLineNum(const IUseAudioKeeper*, bool)

#include <l/Library/Bgm/BgmLineFunction.h>

BgmLine* al::getBgmLineAccessor(const IUseAudioKeeper*, s32, bool)

#include <l/Library/Bgm/BgmLineFunction.h>

s32 al::getgBgmLineIndex(const IUseAudioKeeper*, const char*, bool)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::replaceBgmPlayInfoResourceName(const IUseAudioKeeper*, const char*, const char*)

#include <l/Library/Bgm/BgmLineFunction.h>

bool al::isEnableRhythmAnim(const IUseAudioKeeper*, const char*)

#include <l/Library/Bgm/BgmLineFunction.h>

bool al::isTriggerBeat(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

bool al::isTriggerBackBeat(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

bool al::isTriggerMeasureTop(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

f32 al::getBpm(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

f32 al::getBeatRate(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

f32 al::getCurBeat(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

f32 al::getCurBeatOnMeasure(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

f32 al::getLoopStartBeat(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

f32 al::getLoopEndBeat(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

f32 al::getFramePerMeasure(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

s32 al::getBeatPerMeasure(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

bool al::isChangeActiveBgmResourceName(const IUseAudioKeeper*)

#include <l/Library/Bgm/BgmLineFunction.h>

bool al::tryRegistTargetBgmResourceName(const IUseAudioKeeper*, const char*)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::muteOnRunningLineTrack(IUseAudioKeeper*, u32, bool)

#include <l/Library/Bgm/BgmLineFunction.h>

void al::muteOffRunningLineTrack(IUseAudioKeeper*, u32, bool)

#include <l/Library/Bgm/BgmLineFunction.h>

al::__attribute__((always_inline)) void getStageName(StringTmp< 128 > *stageName

#include <l/Library/Camera/CameraResourceHolder.cpp>

safeArchiveName al::format("%s", archiveName)

#include <l/Library/Camera/CameraResourceHolder.cpp>

al::if(safeArchiveName. endsWith"Map")

#include <l/Library/Camera/CameraResourceHolder.cpp>

CameraDirector* al::getCameraDirector(const IUseCamera* user)

#include <l/Library/Camera/CameraUtil.cpp>

SceneCameraInfo* al::getSceneCameraInfo(const IUseCamera* user)

#include <l/Library/Camera/CameraUtil.h>

s32 al::getViewNumMax(const IUseCamera* user)

#include <l/Library/Camera/CameraUtil.h>

s32 al::getViewNumMax(const SceneCameraInfo* info)

#include <l/Library/Camera/CameraUtil.h>

bool al::isValidView(const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

bool al::isValidView(const SceneCameraInfo* info, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const char* al::getViewName(const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const char* al::getViewName(const SceneCameraInfo* info, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const sead::Matrix34f& al::getViewMtx(const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const sead::Matrix34f& al::getViewMtx(const SceneCameraInfo* info, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const sead::Matrix34f* al::getViewMtxPtr(const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const sead::Matrix34f* al::getViewMtxPtr(const SceneCameraInfo* info, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const sead::Matrix44f& al::getProjectionMtx(const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const sead::Matrix44f& al::getProjectionMtx(const SceneCameraInfo* info, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const sead::LookAtCamera& al::getLookAtCamera(const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const sead::LookAtCamera& al::getLookAtCamera(const SceneCameraInfo* info, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const sead::Projection& al::getProjectionSead(const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const sead::Projection& al::getProjectionSead(const SceneCameraInfo* info, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const Projection& al::getProjection(const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const Projection& al::getProjection(const SceneCameraInfo* info, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const sead::Vector3f& al::getCameraPos(const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const sead::Vector3f& al::getCameraPos(const SceneCameraInfo* info, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const sead::Vector3f& al::getCameraAt(const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const sead::Vector3f& al::getCameraAt(const SceneCameraInfo* info, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const sead::Vector3f& al::getCameraUp(const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const sead::Vector3f& al::getCameraUp(const SceneCameraInfo* info, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

f32 al::getFovyDegree(const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

f32 al::getFovyDegree(const SceneCameraInfo* info, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

f32 al::getFovy(const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

f32 al::getFovy(const SceneCameraInfo* info, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

f32 al::getNear(const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

f32 al::getNear(const SceneCameraInfo* info, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

f32 al::getFar(const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

f32 al::getFar(const SceneCameraInfo* info, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

f32 al::calcCameraDistance(const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

f32 al::calcFovxDegree(const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

f32 al::calcCurrentFovyRate(const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const sead::Matrix44f* al::getProjectionMtxPtr(const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

const sead::Matrix44f* al::getProjectionMtxPtr(const SceneCameraInfo* info, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

void al::calcCameraFront(sead::Vector3f*, const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

void al::setNearClipDistance(const IUseCamera* user, f32 distance, s32 updaterIdx)

#include <l/Library/Camera/CameraUtil.h>

void al::setFarClipDistance(const IUseCamera* user, f32 distance, s32 updaterIdx)

#include <l/Library/Camera/CameraUtil.h>

void al::setCurrentCameraPose(CameraPoseInfo* poseInfo, const IUseCamera* user)

#include <l/Library/Camera/CameraUtil.h>

void al::calcCameraDir(sead::Vector3f* dir, const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

void al::calcCameraLookDir(sead::Vector3f* lookDir, const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

void al::calcCameraSideDir(sead::Vector3f* sideDir, const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

void al::calcCameraUpDir(sead::Vector3f* upDir, const IUseCamera* user, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

bool al::tryCalcCameraDir(sead::Vector3f* dir, const SceneCameraInfo* info, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

bool al::tryCalcCameraDirH(sead::Vector3f* dirH, const SceneCameraInfo* info, const sead::Vector3f& upDir, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

bool al::tryCalcCameraLookDirH(sead::Vector3f* lookDirH, const SceneCameraInfo* info, const sead::Vector3f& upDir, s32 viewIdx)

#include <l/Library/Camera/CameraUtil.h>

void al::startCamera(const IUseCamera* user, CameraTicket* ticket, s32 unk = -1)

#include <l/Library/Camera/CameraUtil.h>

void al::startCameraSub(const IUseCamera* user, CameraTicket* ticket, s32 unk = -1)

#include <l/Library/Camera/CameraUtil.h>

void al::startAnimCamera(const IUseCamera* user, CameraTicket* ticket, const char* animName, s32 unk = 0)

#include <l/Library/Camera/CameraUtil.h>

void al::startAnimCameraAnim(CameraTicket* ticket, const char*, s32, s32, s32)

#include <l/Library/Camera/CameraUtil.h>

void al::startAnimCameraWithStartStepAndEndStepAndPlayStep(const IUseCamera* user, CameraTicket* ticket, const char* animName, s32, s32, s32, s32)

#include <l/Library/Camera/CameraUtil.h>

void al::endCamera(const IUseCamera* user, CameraTicket* ticket, s32, bool)

#include <l/Library/Camera/CameraUtil.h>

void al::endCameraWithNextCameraPose(const IUseCamera* user, CameraTicket* ticket, const CameraPoseInfo* poseInfo, s32)

#include <l/Library/Camera/CameraUtil.h>

void al::endCameraSub(const IUseCamera* user, CameraTicket* ticket, s32)

#include <l/Library/Camera/CameraUtil.h>

bool al::isActiveCamera(const CameraTicket* ticket)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initObjectCamera(const IUseCamera* user, const PlacementInfo& placementInfo, const char*, const char*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initObjectCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*, const char*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initObjectCameraNoPlacementInfo(const IUseCamera* user, const char*, const char*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initFixCamera(const IUseCamera* user, const char*, const sead::Vector3f&, const sead::Vector3f& lookAtPos)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initFixDoorwayCamera(const IUseCamera* user, const char*, const sead::Vector3f&, const sead::Vector3f& lookAtPos)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initFixActorCamera(const LiveActor* actor, const ActorInitInfo& actorInitInfo, const char*, const sead::Vector3f&, f32, f32, f32, bool)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initFixLookCamera(LiveActor* actor, const ActorInitInfo& actorInitInfo, const char*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initFixTalkCamera(const LiveActor* actor, const ActorInitInfo& actorInitInfo, const char*, const sead::Vector3f&, f32, f32, f32, bool)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initFixFishingCamera(const LiveActor* actor, const ActorInitInfo& actorInitInfo, const char*, const sead::Vector3f&, const sead::Vector3f&, f32, f32, f32, bool)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initFixPointCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*, bool)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initLookDownCamera(const LiveActor* actor, const ActorInitInfo& actorInitInfo, const char*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initProgramableCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*, const sead::Vector3f*, const sead::Vector3f*, const sead::Vector3f*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initProgramableCamera(const IUseCamera* user, const char*, const sead::Vector3f*, const sead::Vector3f*, const sead::Vector3f*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initProgramableCameraWithCollider(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*, const sead::Vector3f*, const sead::Vector3f*, const sead::Vector3f*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initProgramableAngleCamera(const IUseCamera* user, const PlacementInfo& placementInfo, const char*, const sead::Vector3f*, const f32*, const f32*, const f32*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initProgramableCameraKeepColliderPreCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*, const sead::Vector3f*, const sead::Vector3f*, const sead::Vector3f*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initShooterCameraSingle(const IUseCamera* user, const char*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initTowerCameraWithSave(const IUseCamera* user, const sead::Vector3f*, const ActorInitInfo& actorInitInfo, const char*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initTowerCamera(const IUseCamera* user, const sead::Vector3f*, const ActorInitInfo& actorInitInfo, const char*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initBossBattleCamera(const IUseCamera* user, const sead::Vector3f*, const ActorInitInfo& actorInitInfo, const char*)

#include <l/Library/Camera/CameraUtil.h>

void al::initProgramableCameraAngleSwing(CameraTicket* ticket)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initFollowCameraSimple(const IUseCamera* user, const char*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initFollowCameraSimple(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initDemoObjectCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*, const char*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initDemoProgramableCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*, const sead::Vector3f*, const sead::Vector3f*, const sead::Vector3f*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initDemoProgramableCameraKeepColliderPreCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*, const sead::Vector3f*, const sead::Vector3f*, const sead::Vector3f*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initDemoAnimCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const Resource*, const sead::Matrix34f*, const char*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initAnimCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const Resource*, const sead::Matrix34f*, const char*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initDemoAnimCamera(const LiveActor* actor, const ActorInitInfo& actorInitInfo, const char*)

#include <l/Library/Camera/CameraUtil.h>

void al::loadActorCameraParam(CameraTicket* ticket, const LiveActor* actor, const char*, const char*)

#include <l/Library/Camera/CameraUtil.h>

void al::loadActorCameraParamInitFile(CameraTicket* ticket, const LiveActor* actor, const char*)

#include <l/Library/Camera/CameraUtil.h>

void al::setFixActorCameraTarget(CameraTicket* ticket, const LiveActor* actor)

#include <l/Library/Camera/CameraUtil.h>

void al::setFixActorCameraAngleH(CameraTicket* ticket, f32 angleH)

#include <l/Library/Camera/CameraUtil.h>

void al::setTowerCameraDistance(CameraTicket* ticket, f32 distance)

#include <l/Library/Camera/CameraUtil.h>

void al::setTowerCameraStartAngleV(CameraTicket* ticket, f32 startAngleV)

#include <l/Library/Camera/CameraUtil.h>

void al::setTowerCameraUserMarginAngleH(CameraTicket* ticket, f32 angleH)

#include <l/Library/Camera/CameraUtil.h>

void al::resetTowerCameraUserMarginAngleH(CameraTicket* ticket)

#include <l/Library/Camera/CameraUtil.h>

void al::resetTowerCameraInputRotate(CameraTicket* ticket, f32, s32)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initSubjectiveCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initSubjectiveCameraNoSave(const IUseCamera* user, const char*)

#include <l/Library/Camera/CameraUtil.h>

f32 al::getSubjectiveCameraOffsetUp(const CameraTicket* ticket)

#include <l/Library/Camera/CameraUtil.h>

f32 al::getSubjectiveCameraOffsetFront()

#include <l/Library/Camera/CameraUtil.h>

void al::setSubjectiveCameraStartAngleH(const CameraTicket* ticket, f32 angleH)

#include <l/Library/Camera/CameraUtil.h>

void al::validateSubjectiveCameraResetAngleH(CameraTicket* ticket)

#include <l/Library/Camera/CameraUtil.h>

void al::requestSubjectiveCameraZoomIn(CameraTicket* ticket)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initParallelCamera(const IUseCamera* user, const char*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initParallelCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*)

#include <l/Library/Camera/CameraUtil.h>

void al::setParallelCameraLookAtOffset(const CameraTicket* ticket, const sead::Vector3f& offset)

#include <l/Library/Camera/CameraUtil.h>

void al::setParallelCameraDistance(const CameraTicket* ticket, f32 distance)

#include <l/Library/Camera/CameraUtil.h>

void al::setParallelCameraAngleH(const CameraTicket* ticket, f32 angleH)

#include <l/Library/Camera/CameraUtil.h>

void al::setParallelCameraAngleV(const CameraTicket* ticket, f32 angleV)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initQuickTurnCamera(const IUseCamera* user, const char*)

#include <l/Library/Camera/CameraUtil.h>

void al::setQuickTurnCameraFollow(CameraTicket* ticket)

#include <l/Library/Camera/CameraUtil.h>

void al::setQuickTurnCameraRotateFast(CameraTicket* ticket)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initRaceCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*)

#include <l/Library/Camera/CameraUtil.h>

void al::setRaceCameraFrontDirPtr(const CameraTicket* ticket, const sead::Vector3f* frontDirPtr)

#include <l/Library/Camera/CameraUtil.h>

void al::setRaceCameraDistance(const CameraTicket* ticket, f32 distance)

#include <l/Library/Camera/CameraUtil.h>

void al::setRaceCameraOffsetY(const CameraTicket* ticket, f32 offsetY)

#include <l/Library/Camera/CameraUtil.h>

void al::setRaceCameraAngleDegreeV(const CameraTicket* ticket, f32 angleV)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initCartCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*)

#include <l/Library/Camera/CameraUtil.h>

void al::stopCartCamera(const CameraTicket* ticket)

#include <l/Library/Camera/CameraUtil.h>

void al::restartCartCamera(const CameraTicket* ticket)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initActorRailParallelCamera(const LiveActor* actor, const ActorInitInfo& actorInitInfo, const char*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initKinopioBrigadeCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initAnimCamera(const LiveActor* actor, const ActorInitInfo& actorInitInfo, const char*)

#include <l/Library/Camera/CameraUtil.h>

void al::validateAnimCameraAngleSwing(CameraTicket* ticket)

#include <l/Library/Camera/CameraUtil.h>

void al::invalidateAnimCameraAngleSwing(CameraTicket* ticket)

#include <l/Library/Camera/CameraUtil.h>

void al::setAnimCameraBaseMtxPtr(CameraTicket* ticket, const sead::Matrix34f* baseMtxPtr)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initEntranceCamera(const IUseCamera* user, const PlacementInfo& placementInfo, const char*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initEntranceCamera(const IUseCamera* user, const ActorInitInfo& actorInitInfo, const char*)

#include <l/Library/Camera/CameraUtil.h>

CameraTicket* al::initEntranceCameraNoSave(const IUseCamera* user, const PlacementInfo& placementInfo, const char*)

#include <l/Library/Camera/CameraUtil.h>

void al::setEntranceCameraParam(CameraTicket* ticket, f32, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Camera/CameraUtil.h>

void al::setEntranceCameraLookAt(CameraTicket* ticket, const sead::Vector3f& lookAt)

#include <l/Library/Camera/CameraUtil.h>

void al::invalidateEndEntranceCamera(LiveActor* actor)

#include <l/Library/Camera/CameraUtil.h>

void al::invalidateEndEntranceCameraWithName(IUseCamera* user, const char* name)

#include <l/Library/Camera/CameraUtil.h>

void al::validateEndEntranceCamera(IUseCamera* user)

#include <l/Library/Camera/CameraUtil.h>

bool al::isPlayingEntranceCamera(const IUseCamera* user, s32 updaterIdx)

#include <l/Library/Camera/CameraUtil.h>

void al::setCameraInterpoleStep(CameraTicket* ticket, s32 step)

#include <l/Library/Camera/CameraUtil.h>

void al::setCameraFovyDegree(CameraTicket* ticket, f32 fovy)

#include <l/Library/Camera/CameraUtil.h>

SimpleCameraInput* al::createSimpleCameraInput(s32 port)

#include <l/Library/Camera/CameraUtil.h>

void al::setCameraInput(IUseCamera* user, const ICameraInput* cameraInput)

#include <l/Library/Camera/CameraUtil.h>

void al::setViewCameraInput(IUseCamera* user, const ICameraInput* cameraInput, s32 inputIdx)

#include <l/Library/Camera/CameraUtil.h>

bool al::isExistCameraInputAtDisableTiming(const IUseCamera* user, s32 inputIdx)

#include <l/Library/Camera/CameraUtil.h>

ActorCameraTarget* al::createActorCameraTarget(const LiveActor* actor, f32)

#include <l/Library/Camera/CameraUtil.h>

ActorCameraTarget* al::createActorCameraTarget(const LiveActor* actor, const sead::Vector3f*)

#include <l/Library/Camera/CameraUtil.h>

ActorMatrixCameraTarget* al::createActorJointCameraTarget(const LiveActor* actor, const char* jointName)

#include <l/Library/Camera/CameraUtil.h>

ActorMatrixCameraTarget* al::createActorMatrixCameraTarget(const LiveActor* actor, const sead::Matrix34f* matrix)

#include <l/Library/Camera/CameraUtil.h>

bool al::isActiveCameraTarget(const CameraTargetBase* target)

#include <l/Library/Camera/CameraUtil.h>

void al::setCameraTarget(IUseCamera* user, CameraTargetBase* target)

#include <l/Library/Camera/CameraUtil.h>

void al::resetCameraTarget(IUseCamera* user, CameraTargetBase* target)

#include <l/Library/Camera/CameraUtil.h>

ActorCameraSubTarget* al::createActorCameraSubTarget(const LiveActor* actor, const sead::Vector3f*)

#include <l/Library/Camera/CameraUtil.h>

ActorBackAroundCameraSubTarget* al::createActorBackAroundCameraSubTarget(const LiveActor* actor, const sead::Vector3f*)

#include <l/Library/Camera/CameraUtil.h>

TransCameraSubTarget* al::createTransCameraSubTarget(const char*, const sead::Vector3f*)

#include <l/Library/Camera/CameraUtil.h>

void al::initCameraSubTargetTurnParam(CameraSubTargetBase* target, const CameraSubTargetTurnParam* turnParam)

#include <l/Library/Camera/CameraUtil.h>

bool al::isActiveCameraSubTarget(const CameraSubTargetBase* target)

#include <l/Library/Camera/CameraUtil.h>

void al::setCameraSubTarget(IUseCamera* user, CameraSubTargetBase* target)

#include <l/Library/Camera/CameraUtil.h>

void al::resetCameraSubTarget(IUseCamera* user, CameraSubTargetBase* target)

#include <l/Library/Camera/CameraUtil.h>

void al::setCameraPlacementSubTarget(IUseCamera* user, CameraSubTargetBase* target)

#include <l/Library/Camera/CameraUtil.h>

void al::resetCameraPlacementSubTarget(IUseCamera* user, CameraSubTargetBase* target)

#include <l/Library/Camera/CameraUtil.h>

const CameraDistanceCurve* al::getCameraDistanceRocketFlowerCurve()

#include <l/Library/Camera/CameraUtil.h>

void al::setViewCameraTarget(IUseCamera* user, CameraTargetBase* target, s32)

#include <l/Library/Camera/CameraUtil.h>

void al::startCameraShakeByAction(const LiveActor* actor, const char*, const char*, s32, s32)

#include <l/Library/Camera/CameraUtil.h>

void al::startCameraShakeByHitReaction(const IUseCamera* user, const char*, const char*, const char*, s32, s32)

#include <l/Library/Camera/CameraUtil.h>

void al::requestCameraLoopShakeWeak(const IUseCamera* user)

#include <l/Library/Camera/CameraUtil.h>

bool al::isActiveCameraInterpole(const IUseCamera* user, s32)

#include <l/Library/Camera/CameraUtil.h>

bool al::isActiveCameraInterpole(const SceneCameraInfo* info, s32)

#include <l/Library/Camera/CameraUtil.h>

void al::startCameraInterpole(const IUseCamera* user, s32, s32)

#include <l/Library/Camera/CameraUtil.h>

void al::requestCancelCameraInterpole(const IUseCamera* user, s32)

#include <l/Library/Camera/CameraUtil.h>

bool al::tryCalcCameraPoseWithoutInterpole(sead::LookAtCamera* camera, const IUseCamera* user, s32)

#include <l/Library/Camera/CameraUtil.h>

void al::invalidateCameraPoserVerticalAbsorber(CameraTicket* ticket)

#include <l/Library/Camera/CameraUtil.h>

void al::requestStopCameraVerticalAbsorb(IUseCamera* user)

#include <l/Library/Camera/CameraUtil.h>

void al::validateSnapShotCameraZoomFovy(CameraTicket* ticket)

#include <l/Library/Camera/CameraUtil.h>

void al::validateSnapShotCameraRoll(CameraTicket* ticket)

#include <l/Library/Camera/CameraUtil.h>

bool al::isSnapShotOrientationRotate90(const IUseCamera* user)

#include <l/Library/Camera/CameraUtil.h>

bool al::isSnapShotOrientationRotate270(const IUseCamera* user)

#include <l/Library/Camera/CameraUtil.h>

bool al::isValidCameraGyro(const IUseCamera* user)

#include <l/Library/Camera/CameraUtil.h>

bool al::isInvalidChangeSubjectiveCamera(const IUseCamera* user)

#include <l/Library/Camera/CameraUtil.h>

bool al::isCurrentCameraZooming(const IUseCamera* user, s32)

#include <l/Library/Camera/CameraUtil.h>

void al::onCameraRideObj(const LiveActor* actor)

#include <l/Library/Camera/CameraUtil.h>

void al::offCameraRideObj(const LiveActor* actor)

#include <l/Library/Camera/CameraUtil.h>

bool al::isExistAnimCameraData(const CameraTicket* ticket, const char*)

#include <l/Library/Camera/CameraUtil.h>

bool al::isEndAnimCamera(const CameraTicket* ticket)

#include <l/Library/Camera/CameraUtil.h>

bool al::isAnimCameraPlaying(const CameraTicket* ticket)

#include <l/Library/Camera/CameraUtil.h>

bool al::isAnimCameraAnimPlaying(const CameraTicket* ticket, const char*)

#include <l/Library/Camera/CameraUtil.h>

s32 al::getAnimCameraStepMax(const CameraTicket* ticket)

#include <l/Library/Camera/CameraUtil.h>

s32 al::getAnimCameraStep(const CameraTicket* ticket)

#include <l/Library/Camera/CameraUtil.h>

s32 al::calcAnimCameraAnimStepMax(const CameraTicket* ticket, const char*)

#include <l/Library/Camera/CameraUtil.h>

void al::setAnimCameraRotateBaseUp(const CameraTicket* ticket)

#include <l/Library/Camera/CameraUtil.h>

#include <l/Library/Camera/CreateCameraPoserFunction.h>

template<typename T>

CameraPoser* al::createCameraPoserFunction(const char* cameraPoserName)

bool al::isWallPolygon(const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Collision/Collider.h>

bool al::isFloorPolygon(const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Collision/Collider.h>

bool al::isCeilingPolygon(const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Collision/Collider.h>

bool al::isFloorCode(const Triangle&, const char*)

#include <l/Library/Collision/CollisionPartsKeeperUtil.h>

MtxConnector* al::createMtxConnector(const LiveActor* actor)

#include <l/Library/Collision/PartsConnector.h>

MtxConnector* al::tryCreateMtxConnector(const LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/Collision/PartsConnector.h>

void al::attachMtxConnectorToCollision(MtxConnector* mtxConnector, const LiveActor* actor, bool)

#include <l/Library/Collision/PartsConnector.h>

void al::attachMtxConnectorToCollision(MtxConnector* mtxConnector, const LiveActor* actor, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Collision/PartsConnector.h>

CollisionParts* al::attachMtxConnectorToCollision(MtxConnector* mtxConnector, const LiveActor* actor, f32, f32)

#include <l/Library/Collision/PartsConnector.h>

void al::connectPoseQT(LiveActor* actor, const MtxConnector* mtxConnector, const sead::Quatf& quat, const sead::Vector3f& trans)

#include <l/Library/Collision/PartsConnector.h>

void al::connectPoseQT(LiveActor* actor, const MtxConnector* mtxConnector)

#include <l/Library/Collision/PartsConnector.h>

void al::attachMtxConnectorToJoint(MtxConnector* mtxConnector, const LiveActor* actor, const char* jointName)

#include <l/Library/Collision/PartsConnector.h>

void al::attachMtxConnectorToJoint(MtxConnector* mtxConnector, const LiveActor* actor, const char* jointName, const sead::Vector3f& quatInitVec, const sead::Vector3f& trans)

#include <l/Library/Collision/PartsConnector.h>

void al::disconnectMtxConnector(MtxConnector* mtxConnector)

#include <l/Library/Collision/PartsConnector.h>

bool al::isMtxConnectorConnecting(const MtxConnector* mtxConnector)

#include <l/Library/Collision/PartsConnector.h>

sead::ControllerBase* al::getController(s32 port)

#include <l/Library/Controller/InputFunction.cpp>

bool al::isPadTrigger(s32 port, s32 button)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerA(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerB(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerX(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerY(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerZL(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerZR(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerL(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerR(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTrigger1(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTrigger2(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerUp(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerDown(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerLeft(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerRight(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerLeftUp(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerLeftDown(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerRightUp(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerRightDown(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerHome(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerStart(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerSelect(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerPlus(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerMinus(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerTouch()

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerUpLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerDownLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerLeftLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerRightLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerUpRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerDownRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerLeftRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerRightRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerAnyABXY(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerAny(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerPressLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerPressRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeat(s32 port, s32 button)

#include <l/Library/Controller/InputFunction.cpp>

bool al::isPadRepeatA(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatB(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatX(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatY(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatZL(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatZR(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatL(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatR(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeat1(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeat2(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatUp(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatDown(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatLeft(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatRight(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatHome(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatStart(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatSelect(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatPlus(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatMinus(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatTouch()

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatUpLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatDownLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatLeftLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatRightLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatUpRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatDownRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatLeftRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatRightRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldPressLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldPressRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHold(s32 port, s32 button)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldA(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldB(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldX(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldY(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldZL(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldZR(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldL(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldR(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHold1(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHold2(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldUp(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldDown(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldLeft(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldRight(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldLeftUp(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldLeftDown(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldRightUp(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldRightDown(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldHome(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldStart(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldSelect(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldPlus(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldMinus(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldAny(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldAnyWithoutStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldTouch()

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldUpLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldDownLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldLeftLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldRightLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldUpRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldDownRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldLeftRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldRightRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRelease(s32 port, s32 button)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseA(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseB(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseX(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseY(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseZL(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseZR(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseL(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseR(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRelease1(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRelease2(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseUp(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseDown(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseLeft(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseRight(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseHome(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseStart(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseSelect(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleasePlus(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseMinus(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseTouch()

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseUpLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseDownLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseLeftLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseRightLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseUpRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseDownRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseLeftRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseRightRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

const sead::Vector2f& al::getLeftStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

const sead::Vector2f& al::getRightStick(s32 port)

#include <l/Library/Controller/InputFunction.h>

void al::getPadCrossDir(sead::Vector2f* vec, s32 port)

#include <l/Library/Controller/InputFunction.h>

void al::getPadCrossDirSideways(sead::Vector2f* vec, s32 port)

#include <l/Library/Controller/InputFunction.h>

void al::calcTouchScreenPos(sead::Vector2f* vec)

#include <l/Library/Controller/InputFunction.h>

void al::calcTouchLayoutPos(sead::Vector2f*)

#include <l/Library/Controller/InputFunction.h>

bool al::isTouchPosInRect(const sead::Vector2f& rect_pos, const sead::Vector2f& size)

#include <l/Library/Controller/InputFunction.h>

void al::setPadRepeat(s32 a1, s32 a2, s32 a3, s32 port)

#include <l/Library/Controller/InputFunction.h>

s32 al::getPlayerControllerPort(s32 playerNo)

#include <l/Library/Controller/InputFunction.h>

s32 al::getTouchPanelPort()

#include <l/Library/Controller/InputFunction.h>

s32 al::getMainControllerPort()

#include <l/Library/Controller/InputFunction.h>

s32 al::getMainJoyPadDoublePort()

#include <l/Library/Controller/InputFunction.h>

s32 al::getMainJoyPadSingleRightPort()

#include <l/Library/Controller/InputFunction.h>

s32 al::getMainJoyPadSingleLeftPort()

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTypeJoySingle(s32 port = -1)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerUiCursorUp(s32 port = -1)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerUiCursorDown(s32 port = -1)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerUiCursorLeft(s32 port = -1)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTriggerUiCursorRight(s32 port = -1)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatUiCursorUp(s32 port = -1)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatUiCursorDown(s32 port = -1)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatUiCursorLeft(s32 port = -1)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadRepeatUiCursorRight(s32 port = -1)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldUiCursorUp(s32 port = -1)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldUiCursorDown(s32 port = -1)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldUiCursorLeft(s32 port = -1)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadHoldUiCursorRight(s32 port = -1)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseUiCursorUp(s32 port = -1)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseUiCursorDown(s32 port = -1)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseUiCursorLeft(s32 port = -1)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadReleaseUiCursorRight(s32 port = -1)

#include <l/Library/Controller/InputFunction.h>

bool al::isTouchPosInCircle(const sead::Vector2f&, f32)

#include <l/Library/Controller/InputFunction.h>

bool al::isTouchPosInCircleByWorldPos(const sead::Vector2f&, const IUseCamera*, f32, f32)

#include <l/Library/Controller/InputFunction.h>

bool al::isPadTouchRect(f32, f32, f32, f32)

#include <l/Library/Controller/InputFunction.h>

bool al::isSameNpadId(u32, s32)

#include <l/Library/Controller/InputFunction.h>

void al::createReplayController(u32 port)

#include <l/Library/Controller/PadReplayFunction.h>

void al::unregistReplayController(u32 port)

#include <l/Library/Controller/PadReplayFunction.h>

ReplayController* al::getReplayController(u32 port)

#include <l/Library/Controller/PadReplayFunction.h>

void al::setPadDataReader(IUsePadDataReader* reader, u32 port)

#include <l/Library/Controller/PadReplayFunction.h>

void al::createAndSetPadDataArcReader(const char* path, const char* stageName, u32 port)

#include <l/Library/Controller/PadReplayFunction.h>

void al::startPadReplay(u32 port)

#include <l/Library/Controller/PadReplayFunction.h>

void al::pausePadReplay(u32 port)

#include <l/Library/Controller/PadReplayFunction.h>

void al::endPadReplay(u32 port)

#include <l/Library/Controller/PadReplayFunction.h>

void al::setPadDataWriter(IUsePadDataWriter* writer, u32 port)

#include <l/Library/Controller/PadReplayFunction.h>

void al::startPadRecording(u32 port)

#include <l/Library/Controller/PadReplayFunction.h>

void al::endPadRecording(u32 port)

#include <l/Library/Controller/PadReplayFunction.h>

bool al::isPadReplaying(u32 port)

#include <l/Library/Controller/PadReplayFunction.h>

s32 al::getPadReplayRemainFrame(u32 port)

#include <l/Library/Controller/PadReplayFunction.h>

bool al::isPadRecording(u32 port)

#include <l/Library/Controller/PadReplayFunction.h>

void al::invalidatePadReplay(u32 port)

#include <l/Library/Controller/PadReplayFunction.h>

void al::validatePadReplay(u32 port)

#include <l/Library/Controller/PadReplayFunction.h>

bool al::isValidReplayController(u32 port)

#include <l/Library/Controller/PadReplayFunction.h>

bool al::isReadPadReplayData(u32 port)

#include <l/Library/Controller/PadReplayFunction.h>

PadRumbleKeeper* al::createPadRumbleKeeper(const LiveActor*, s32)

#include <l/Library/Controller/PadRumbleDirector.h>

void al::getComputerName(sead::BufferedSafeString* computerName)

#include <l/Library/Debug/Host.h>

bool al::tryGetComputerName(sead::BufferedSafeString* computerName)

#include <l/Library/Debug/Host.h>

void al::getUserName(sead::BufferedSafeString* userName)

#include <l/Library/Debug/Host.h>

void al::makeUniqueTemporaryFilename(sead::BufferedSafeString* out, const char* fileName)

#include <l/Library/Debug/Host.h>

void al::expandEnvironmentString(sead::BufferedSafeString* out, const sead::SafeString& envStr)

#include <l/Library/Debug/Host.h>

sead::FixedSafeString<128> al::makeTmpExpandEnvironmentString(const sead::SafeString& envStr)

#include <l/Library/Debug/Host.h>

StringTmp<128> al::makeTmpFileFullPath(const char* fileName)

#include <l/Library/Debug/Host.h>

const char* al::getALCommon()

#include <l/Library/Debug/Host.h>

void al::FUN_710086f65c(sead::BufferedSafeString* out, const sead::SafeString& envStr)

#include <l/Library/Debug/Host.h>

AddDemoInfo* al::registDemoRequesterToAddDemoInfo(const LiveActor* actor, const ActorInitInfo& initInfo, s32 index)

#include <l/Library/Demo/DemoFunction.h>

void al::registActorToDemoInfo(LiveActor* actor, const ActorInitInfo& initInfo)

#include <l/Library/Demo/DemoFunction.h>

void al::addDemoActorFromAddDemoInfo(const LiveActor* actor, const AddDemoInfo* info)

#include <l/Library/Demo/DemoFunction.h>

void al::addDemoActorFromDemoActorHolder(const LiveActor* actor, const DemoActorHolder* holder)

#include <l/Library/Demo/DemoFunction.h>

void al::addDemoActorFromDemoActorHolder(const Scene* scene, const DemoActorHolder* holder)

#include <l/Library/Demo/DemoFunction.h>

void al::setDemoInfoDemoName(const LiveActor* actor, const char* name)

#include <l/Library/Demo/DemoFunction.h>

void al::killForceBeforeDemo(LiveActor* actor)

#include <l/Library/Demo/DemoFunction.h>

void al::prepareSkip(LiveActor* actor, s32)

#include <l/Library/Demo/DemoFunction.h>

void al::invalidateLODWithSubActor(LiveActor*)

#include <l/Library/Demo/DemoFunction.h>

bool al::isActiveDemo(const Scene*)

#include <l/Library/Scene/SceneUtil.h>

f32 al::getDepthClearValue()

#include <l/Library/Draw/GraphicsFunction.h>

void al::setDepthFuncNearDraw(sead::GraphicsContext* context)

#include <l/Library/Draw/GraphicsFunction.h>

void al::setDepthFuncFarDraw(sead::GraphicsContext* context)

#include <l/Library/Draw/GraphicsFunction.h>

bool al::getAlphaTestEnable(nn::g3d::MaterialObj* material)

#include <l/Library/Draw/GraphicsFunction.h>

void al::emitEffectCurrentPos(IUseEffectKeeper*, const char*)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::emitEffect(IUseEffectKeeper*, const char*, const sead::Vector3f*)

#include <l/Library/Effect/EffectSystemInfo.h>

bool al::tryEmitEffect(IUseEffectKeeper*, const char*, const sead::Vector3f*)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::deleteEffect(IUseEffectKeeper*, const char*)

#include <l/Library/Effect/EffectSystemInfo.h>

bool al::tryDeleteEffect(IUseEffectKeeper*, const char*)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::deleteEffectAll(IUseEffectKeeper*)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::tryKillEmitterAndParticleAll(IUseEffectKeeper*)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::onCalcAndDrawEffect(IUseEffectKeeper*)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::offCalcAndDrawEffect(IUseEffectKeeper*)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::forceSetStopCalcAndDraw(IUseEffectKeeper*, bool)

#include <l/Library/Effect/EffectSystemInfo.h>

bool al::isEffectEmitting(const IUseEffectKeeper*, const char*)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::setEffectEmitRatio(IUseEffectKeeper*, const char*, f32)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::setEffectAllScale(IUseEffectKeeper*, const char*, const sead::Vector3f&)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::setEffectEmitterVolumeScale(IUseEffectKeeper*, const char*, const sead::Vector3f&)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::setEffectParticleScale(IUseEffectKeeper*, const char*, f32)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::setEffectParticleScale(IUseEffectKeeper*, const char*, const sead::Vector3f&)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::setEffectParticleAlpha(IUseEffectKeeper*, const char*, f32)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::setEffectParticleColor(IUseEffectKeeper*, const char*, const sead::Color4f&)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::setParticleLifeScale(IUseEffectKeeper*, const char*, f32)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::setEffectParticleDirectionalVel(IUseEffectKeeper*, const char*, f32)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::setEffectFollowPosPtr(IUseEffectKeeper*, const char*, const sead::Vector3f*)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::setEffectFollowMtxPtr(IUseEffectKeeper*, const char*, const sead::Matrix34f*)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::setEffectNamedMtxPtr(IUseEffectKeeper*, const char*, const sead::Matrix34f*)

#include <l/Library/Effect/EffectSystemInfo.h>

bool al::trySetEffectNamedMtxPtr(IUseEffectKeeper*, const char*, const sead::Matrix34f*)

#include <l/Library/Effect/EffectSystemInfo.h>

bool al::tryUpdateEffectMaterialCode(IUseEffectKeeper*, const char*)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::resetEffectMaterialCode(IUseEffectKeeper*)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::updateEffectMaterialWater(IUseEffectKeeper*, bool)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::updateEffectMaterialWet(IUseEffectKeeper*, bool)

#include <l/Library/Effect/EffectSystemInfo.h>

void al::updateEffectMaterialPuddle(IUseEffectKeeper*, bool)

#include <l/Library/Effect/EffectSystemInfo.h>

#include <l/Library/Event/CreateEventFlowNode.h>

template<typename T>

EventFlowNode* al::createEventFlowNode(const char* eventFlowNodeName)

bool al::isNodeName(const EventFlowNode*, const char*)

#include <l/Library/Event/EventFlowUtil.h>

const char16* al::getScareMessage(const EventFlowNode*)

#include <l/Library/Event/EventFlowUtil.h>

void al::startEventCamera(EventFlowNode*, const char*, s32)

#include <l/Library/Event/EventFlowUtil.h>

void al::startEventAnimCamera(EventFlowNode*, const char*, const char*, s32)

#include <l/Library/Event/EventFlowUtil.h>

void al::endEventCamera(EventFlowNode*, const char*, s32, bool)

#include <l/Library/Event/EventFlowUtil.h>

bool al::tryEndEventCameraIfPlaying(EventFlowNode*, const char*, s32, bool)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isEndInterpoleEventCamera(const EventFlowNode*, const char*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isPlayingEventAnimCamera(const EventFlowNode*, const char*)

#include <l/Library/Event/EventFlowUtil.h>

void al::requestDemoAction(EventFlowNode*, const char*, bool)

#include <l/Library/Event/EventFlowUtil.h>

void al::requestPlayerDemoAction(EventFlowNode*, const char*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isEndDemoAction(const EventFlowNode*)

#include <l/Library/Event/EventFlowUtil.h>

void al::setDemoTalkAction(EventFlowNode*, const char*)

#include <l/Library/Event/EventFlowUtil.h>

void al::resetDemoTalkAction(EventFlowNode*)

#include <l/Library/Event/EventFlowUtil.h>

void al::requestDemoCamera(EventFlowNode*, const char*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isEndRequestDemoCamera(const EventFlowNode*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isHideDemoPlayer(const EventFlowNode*)

#include <l/Library/Event/EventFlowUtil.h>

void al::requestHideDemoPlayer(EventFlowNode*)

#include <l/Library/Event/EventFlowUtil.h>

void al::requestShowDemoPlayer(EventFlowNode*)

#include <l/Library/Event/EventFlowUtil.h>

void al::calcPlayerWatchTrans(sead::Vector3f*, const EventFlowNode*)

#include <l/Library/Event/EventFlowUtil.h>

void al::requestCommandCloseTalkMessageLayout(EventFlowNode*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isActive(const EventFlowExecutor*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isScare(const IUseEventFlowData*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::tryGetScareEnemyPos(sead::Vector3f*, const IUseEventFlowData*)

#include <l/Library/Event/EventFlowUtil.h>

void al::invalidateUiCollisionCheck(EventFlowExecutor*)

#include <l/Library/Event/EventFlowUtil.h>

void al::onExistLookAtJointCtrl(EventFlowExecutor*)

#include <l/Library/Event/EventFlowUtil.h>

void al::setTalkSubActorName(EventFlowExecutor*, const char*)

#include <l/Library/Event/EventFlowUtil.h>

void al::resetTalkSubActorName(EventFlowExecutor*)

#include <l/Library/Event/EventFlowUtil.h>

void al::startEventAction(LiveActor*, const IUseEventFlowData*, const char*)

#include <l/Library/Event/EventFlowUtil.h>

void al::makeEventActionName(sead::BufferedSafeStringBase<char>*, const IUseEventFlowData*, const char*)

#include <l/Library/Event/EventFlowUtil.h>

void al::startEventActionAtRandomFrame(LiveActor*, const IUseEventFlowData*, const char*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::tryStartEventActionIfNotPlaying(LiveActor*, const IUseEventFlowData*, const char*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isPlayingEventAction(const LiveActor*, const IUseEventFlowData*, const char*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isExistEventAction(const LiveActor*, const IUseEventFlowData*, const char*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isOneTimeEventAction(const LiveActor*, const IUseEventFlowData*, const char*)

#include <l/Library/Event/EventFlowUtil.h>

f32 al::getEventActionFrameMax(const LiveActor*, const IUseEventFlowData*, const char*)

#include <l/Library/Event/EventFlowUtil.h>

f32 al::getParamMoveSpeed(const IUseEventFlowData*)

#include <l/Library/Event/EventFlowUtil.h>

f32 al::getParamTurnSpeedDegree(const IUseEventFlowData*)

#include <l/Library/Event/EventFlowUtil.h>

const sead::Vector3f& al::getRecordActorFront(const IUseEventFlowData*)

#include <l/Library/Event/EventFlowUtil.h>

void al::recordActorFront(IUseEventFlowData*, const sead::Vector3f&)

#include <l/Library/Event/EventFlowUtil.h>

bool al::checkInsideTerritoryPos(const IUseEventFlowData*, const LiveActor*, const sead::Vector3f&, f32)

#include <l/Library/Event/EventFlowUtil.h>

bool al::checkInsideEmotionTerritoryPos(const IUseEventFlowData*, const LiveActor*, const sead::Vector3f&)

#include <l/Library/Event/EventFlowUtil.h>

bool al::checkInsideEmotionLowPriorityTerritoryPos(const IUseEventFlowData*, const LiveActor*, const sead::Vector3f&)

#include <l/Library/Event/EventFlowUtil.h>

bool al::checkInsideTalkTerritoryPos(const IUseEventFlowData*, const LiveActor*, const sead::Vector3f&)

#include <l/Library/Event/EventFlowUtil.h>

void al::calcBalloonOffset(sead::Vector3f*, const IUseEventFlowData*, const LiveActor*)

#include <l/Library/Event/EventFlowUtil.h>

void al::setBalloonLocalOffset(EventFlowExecutor*, const sead::Vector3f&)

#include <l/Library/Event/EventFlowUtil.h>

f32 al::getBalloonCollisionCheckOffsetRadius(const IUseEventFlowData*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isDisableOpenBalloonByOrderGroup(const LiveActor*, const IUseEventFlowData*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isEnableForceOpenBalloonByOrderGroup(const LiveActor*, const IUseEventFlowData*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isWaitAtPointMovement(const EventFlowExecutor*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isStopMovement(const IUseEventFlowData*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isRequestEventDemoAction(const EventFlowExecutor*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isPlayingEventDemoAction(const EventFlowExecutor*)

#include <l/Library/Event/EventFlowUtil.h>

const char* al::getEventDemoActionName(const EventFlowExecutor*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isExistEventDemoTalkAction(const EventFlowExecutor*)

#include <l/Library/Event/EventFlowUtil.h>

const char* al::getEventDemoTalkActionName(const EventFlowExecutor*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isResetEventDemoPlayerDynamics(const EventFlowExecutor*)

#include <l/Library/Event/EventFlowUtil.h>

void al::startEventDemoAction(EventFlowExecutor*)

#include <l/Library/Event/EventFlowUtil.h>

void al::endEventDemoAction(EventFlowExecutor*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isRequestEventDemoCamera(const EventFlowExecutor*)

#include <l/Library/Event/EventFlowUtil.h>

const char* al::getEventDemoCameraAnimName(const EventFlowExecutor*)

#include <l/Library/Event/EventFlowUtil.h>

void al::clearEventDemoCameraRequest(EventFlowExecutor*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isHideDemoPlayer(const EventFlowExecutor*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isExistEventEntry(const EventFlowExecutor*, const char*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isCurrentEventEntry(const EventFlowExecutor*, const char*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isEventName(const EventFlowEventData*, const char*, ...)

#include <l/Library/Event/EventFlowUtil.h>

const char* al::getEventName(const EventFlowEventData*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::getEventDataParamString(const EventFlowEventData*, const char*)

#include <l/Library/Event/EventFlowUtil.h>

bool al::isEventDataParamBool(const EventFlowEventData*, const char*)

#include <l/Library/Event/EventFlowUtil.h>

void al::registerExecutorUser(IUseExecutor* user, ExecuteDirector* director, const char* listName)

#include <l/Library/Execute/ExecuteUtil.h>

void al::registerExecutorActorUpdate(LiveActor* actor, ExecuteDirector* director, const char* listName)

#include <l/Library/Execute/ExecuteUtil.h>

void al::registerExecutorActorDraw(LiveActor* actor, ExecuteDirector* director, const char* listName)

#include <l/Library/Execute/ExecuteUtil.h>

void al::registerExecutorLayoutUpdate(LayoutActor* layout, ExecuteDirector* director, const char* listName)

#include <l/Library/Execute/ExecuteUtil.h>

void al::registerExecutorLayoutDraw(LayoutActor* layout, ExecuteDirector* director, const char* listName)

#include <l/Library/Execute/ExecuteUtil.h>

void al::registerExecutorFunctor(const char* listName, ExecuteDirector* director, const FunctorBase& functor)

#include <l/Library/Execute/ExecuteUtil.h>

void al::registerExecutorFunctorDraw(const char* listName, ExecuteDirector* director, const FunctorBase& functor)

#include <l/Library/Execute/ExecuteUtil.h>

FileLoader* al::getFileLoader()

#include <l/Library/File/FileUtil.cpp>

bool al::isExistFile(const sead::SafeString& fileName)

#include <l/Library/File/FileUtil.h>

bool al::isExistDirectory(const sead::SafeString& fileName)

#include <l/Library/File/FileUtil.h>

bool al::isExistArchive(const sead::SafeString& fileName)

#include <l/Library/File/FileUtil.h>

bool al::isExistArchive(const sead::SafeString& fileName, const char* ext)

#include <l/Library/File/FileUtil.h>

u32 al::getFileSize(const sead::SafeString& fileName)

#include <l/Library/File/FileUtil.h>

u32 al::calcFileAlignment(const sead::SafeString& fileName)

#include <l/Library/File/FileUtil.h>

u32 al::calcBufferSizeAlignment(const sead::SafeString& fileName)

#include <l/Library/File/FileUtil.h>

u8* al::loadFile(const sead::SafeString& fileName, s32 size)

#include <l/Library/File/FileUtil.h>

bool al::tryLoadFileToBuffer(const sead::SafeString& fileName, u8* buffer, u32 bufferSize, s32 size)

#include <l/Library/File/FileUtil.h>

sead::ArchiveRes* al::loadArchive(const sead::SafeString& fileName)

#include <l/Library/File/FileUtil.h>

sead::ArchiveRes* al::loadArchiveWithExt(const sead::SafeString& fileName, const char* ext)

#include <l/Library/File/FileUtil.h>

bool al::tryRequestLoadArchive(const sead::SafeString& fileName, sead::Heap* heap)

#include <l/Library/File/FileUtil.h>

void al::loadSoundItem(u32 soundEntryId, u32 unknown, IAudioResourceLoader* resLoader)

#include <l/Library/File/FileUtil.h>

bool al::tryRequestLoadSoundItem(u32 soundEntryId)

#include <l/Library/File/FileUtil.h>

bool al::tryRequestPreLoadFile(const Resource* res, s32 id, sead::Heap* heap, IAudioResourceLoader* resLoader)

#include <l/Library/File/FileUtil.h>

bool al::tryRequestPreLoadFile(const Resource* res, const sead::SafeString& fileName, sead::Heap* heap, IAudioResourceLoader* resLoader)

#include <l/Library/File/FileUtil.h>

void al::waitLoadDoneAllFile()

#include <l/Library/File/FileUtil.h>

void al::clearFileLoaderEntry()

#include <l/Library/File/FileUtil.h>

void al::makeLocalizedArchivePath(sead::BufferedSafeString* outPath, const sead::SafeString& fileName)

#include <l/Library/File/FileUtil.h>

void al::makeLocalizedArchivePathByCountryCode(sead::BufferedSafeString* outPath, const sead::SafeString& fileName)

#include <l/Library/File/FileUtil.h>

void al::setFileLoaderThreadPriority(s32 priority)

#include <l/Library/File/FileUtil.h>

bool al::isExistItemKeeper(const LiveActor* actor)

#include <l/Library/Item/ItemUtil.h>

ActorItemInfo* al::addItem(LiveActor* actor, const ActorInitInfo&, const char*, const char*, const char*, s32, bool)

#include <l/Library/Item/ItemUtil.h>

ActorItemInfo* al::addItem(LiveActor* actor, const ActorInitInfo&, const char*, bool)

#include <l/Library/Item/ItemUtil.h>

void al::setAppearItemFactor(const LiveActor* actor, const char*, const HitSensor* sensor)

#include <l/Library/Item/ItemUtil.h>

void al::setAppearItemOffset(const LiveActor* actor, const sead::Vector3f& offset)

#include <l/Library/Item/ItemUtil.h>

void al::setAppearItemAttackerSensor(const LiveActor* actor, const HitSensor* sensor)

#include <l/Library/Item/ItemUtil.h>

bool al::appearItem(const LiveActor* actor)

#include <l/Library/Item/ItemUtil.h>

bool al::appearItem(const LiveActor* actor, const sead::Vector3f&, const sead::Quatf&, const HitSensor* sensor)

#include <l/Library/Item/ItemUtil.h>

bool al::appearItem(const LiveActor* actor, const sead::Vector3f&, const sead::Vector3f&, const HitSensor* sensor)

#include <l/Library/Item/ItemUtil.h>

bool al::appearItemTiming(const LiveActor* actor, const char*)

#include <l/Library/Item/ItemUtil.h>

bool al::appearItemTiming(const LiveActor* actor, const char*, const sead::Vector3f&, const sead::Quatf&, const HitSensor* sensor)

#include <l/Library/Item/ItemUtil.h>

bool al::appearItemTiming(const LiveActor* actor, const char*, const sead::Vector3f&, const sead::Vector3f&, const HitSensor* sensor)

#include <l/Library/Item/ItemUtil.h>

void al::acquireItem(const LiveActor* actor, HitSensor* sensor, const char*)

#include <l/Library/Item/ItemUtil.h>

s32 al::getItemType(const LiveActor* actor, const char*)

#include <l/Library/Item/ItemUtil.h>

void al::initJointControllerKeeper(const LiveActor*, s32)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::isExistJointControllerKeeper(const LiveActor*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::registerJointController(const LiveActor*, JointControllerBase*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::registerJointController(const LiveActor*, JointControllerBase*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointLocalRotator(const LiveActor*, sead::Vector3f*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointLocalXRotator(const LiveActor*, const f32*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointLocalYRotator(const LiveActor*, const f32*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointLocalZRotator(const LiveActor*, const f32*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

JointLocalAxisRotator* al::initJointLocalAxisRotator(const LiveActor*, const sead::Vector3f&, const f32*, const char*, bool)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointLocalMinusXRotator(const LiveActor*, const f32*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointLocalMinusYRotator(const LiveActor*, const f32*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointLocalMinusZRotator(const LiveActor*, const f32*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointGlobalXRotator(const LiveActor*, f32*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointGlobalAxisRotator(const LiveActor*, const sead::Vector3f&, f32*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointGlobalYRotator(const LiveActor*, f32*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointGlobalZRotator(const LiveActor*, f32*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointGlobalMinusXRotator(const LiveActor*, f32*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointGlobalMinusYRotator(const LiveActor*, f32*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointGlobalMinusZRotator(const LiveActor*, f32*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointLocalTransControllerX(const LiveActor*, const f32*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointLocalTransControllerY(const LiveActor*, const f32*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointLocalTransControllerZ(const LiveActor*, const f32*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointLocalTransController(const LiveActor*, const sead::Vector3f*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointLocalScaleControllerX(const LiveActor*, const f32*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointLocalScaleControllerY(const LiveActor*, const f32*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointLocalScaleControllerZ(const LiveActor*, const f32*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointLocalScaleController(const LiveActor*, const sead::Vector3f*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointLocalMtxController(const LiveActor*, const sead::Matrix34f*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointGlobalMtxController(const LiveActor*, const sead::Matrix34f*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointGlobalQuatController(const LiveActor*, const sead::Quatf*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointGlobalQuatTransController(const LiveActor*, const sead::Quatf*, const sead::Vector3f*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointPostQuatController(const LiveActor*, const sead::Quatf*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointLocalDirController(const LiveActor*, const JointDirectionInfo*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointAimController(const LiveActor*, const JointAimInfo*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointTranslateShaker(const LiveActor*, s32)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::appendJointTranslateShakerX(JointTranslateShaker*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::appendJointTranslateShakerY(JointTranslateShaker*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::appendJointTranslateShakerZ(JointTranslateShaker*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointMasher(const LiveActor*, const bool*, s32)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::appendMashJoint(JointMasher*, const char*, f32)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointRumbler(const LiveActor*, const char*, f32, f32, u32, s32)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointLocalQuatRotator(const LiveActor*, const char*, const sead::Quatf*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointLookAtController(const LiveActor*, s32)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::appendJointLookAtController(JointLookAtController*, const LiveActor*, const char*, f32, const sead::Vector2f&, const sead::Vector2f&, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::appendJointLookAtControllerNoJudge(JointLookAtController*, const LiveActor*, const char*, f32, const sead::Vector2f&, const sead::Vector2f&, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::appendJointLookAtControllerNoJudgeNoOverLimitYaw(JointLookAtController*, const LiveActor*, const char*, f32, const sead::Vector2f&, const sead::Vector2f&, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointGroundSmoothController(const LiveActor*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointPosToPosController(const LiveActor*, const char*, const sead::Vector3f*, const sead::Vector3f*, f32*, const sead::Vector3f&)

#include <l/Library/Joint/JointControllerKeeper.h>

JointSpringController* al::initJointSpringController(const LiveActor*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointConstrainedSpringController(const LiveActor*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointSpringTransController(const LiveActor*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

void al::initJointSimpleIK(const LiveActor*, const char*)

#include <l/Library/Joint/JointControllerKeeper.h>

KeyPoseKeeper* al::createKeyPoseKeeper(const ActorInitInfo& info)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

KeyPoseKeeper* al::createKeyPoseKeeper(const PlacementInfo& info)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

void al::resetKeyPose(KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

void al::nextKeyPose(KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

void al::restartKeyPose(KeyPoseKeeper* keyPoseKeeper, sead::Vector3f* pos, sead::Quatf* orientation)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

void al::reverseKeyPose(KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

const sead::Vector3f& al::getCurrentKeyTrans(const KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

const sead::Vector3f& al::getNextKeyTrans(const KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

const sead::Quatf& al::getCurrentKeyQuat(const KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

const sead::Quatf& al::getNextKeyQuat(const KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

const PlacementInfo& al::getCurrentKeyPlacementInfo(const KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

const PlacementInfo& al::getNextKeyPlacementInfo(const KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

s32 al::getKeyPoseCount(const KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

void al::getKeyPoseTrans(sead::Vector3f* out, const KeyPoseKeeper* keyPoseKeeper, s32 idx)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

void al::getKeyPoseQuat(sead::Quatf* out, const KeyPoseKeeper* keyPoseKeeper, s32 idx)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

void al::calcLerpKeyTrans(sead::Vector3f* out, const KeyPoseKeeper* keyPoseKeeper, f32 rate)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

void al::calcSlerpKeyQuat(sead::Quatf* out, const KeyPoseKeeper* keyPoseKeeper, f32 rate)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

bool al::isMoveSignKey(const KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

bool al::isLastKey(const KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

bool al::isFirstKey(const KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

bool al::isGoingToEnd(const KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

bool al::isStop(const KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

bool al::isRestart(const KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

f32 al::calcDistanceNextKeyTrans(const KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

s32 al::calcTimeToNextKeyMove(const KeyPoseKeeper* keyPoseKeeper, f32 speed)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

void al::calcDirToNextKey(sead::Vector3f* out, const KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

f32 al::calcKeyMoveSpeed(const KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

f32 al::calcKeyMoveSpeedByTime(const KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

s32 al::calcKeyMoveWaitTime(const KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

s32 al::calcKeyMoveMoveTime(const KeyPoseKeeper* keyPoseKeeper)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

void al::calcKeyMoveClippingInfo(sead::Vector3f*, f32*, const KeyPoseKeeper*, f32)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

void al::setKeyMoveClippingInfo(LiveActor*, sead::Vector3f*, const KeyPoseKeeper*)

#include <l/Library/KeyPose/KeyPoseKeeperUtil.h>

LayoutPaneGroup* al::getLayoutPaneGroup(const IUseLayoutAction* layout, const char* paneName)

#include <l/Library/Layout/LayoutActionFunction.cpp>

void al::startAction(IUseLayoutAction* layout, const char* actionName, const char* paneName)

#include <l/Library/Layout/LayoutActionFunction.h>

s32 al::startActionAtRandomFrame(IUseLayoutAction* layout, const char* actionName, const char* paneName)

#include <l/Library/Layout/LayoutActionFunction.h>

void al::startFreezeAction(IUseLayoutAction* layout, const char* actionName, f32 frame, const char* paneName)

#include <l/Library/Layout/LayoutActionFunction.h>

void al::startFreezeActionEnd(IUseLayoutAction* layout, const char* actionName, const char* paneName)

#include <l/Library/Layout/LayoutActionFunction.h>

f32 al::getActionFrameMax(const IUseLayoutAction* layout, const char* actionName, const char* paneName)

#include <l/Library/Layout/LayoutActionFunction.h>

void al::startFreezeGaugeAction(IUseLayoutAction* layout, f32 value, f32 minFrame, f32 maxFrame, const char* actionName, const char* paneName)

#include <l/Library/Layout/LayoutActionFunction.h>

bool al::tryStartAction(IUseLayoutAction* layout, const char* actionName, const char* paneName)

#include <l/Library/Layout/LayoutActionFunction.h>

bool al::isExistAction(const IUseLayoutAction* layout, const char* actionName, const char* paneName)

#include <l/Library/Layout/LayoutActionFunction.h>

bool al::isActionEnd(const IUseLayoutAction* layout, const char* paneName)

#include <l/Library/Layout/LayoutActionFunction.h>

bool al::isExistAction(const IUseLayoutAction* layout, const char* paneName)

#include <l/Library/Layout/LayoutActionFunction.h>

bool al::isActionOneTime(const IUseLayoutAction* layout, const char* actionName, const char* paneName)

#include <l/Library/Layout/LayoutActionFunction.h>

f32 al::getActionFrame(const IUseLayoutAction* layout, const char* paneName)

#include <l/Library/Layout/LayoutActionFunction.h>

void al::setActionFrame(IUseLayoutAction* layout, f32 frame, const char* paneName)

#include <l/Library/Layout/LayoutActionFunction.h>

f32 al::getActionFrameRate(const IUseLayoutAction* layout, const char* paneName)

#include <l/Library/Layout/LayoutActionFunction.h>

void al::setActionFrameRate(IUseLayoutAction* layout, f32 frameRate, const char* paneName)

#include <l/Library/Layout/LayoutActionFunction.h>

const char* al::getActionName(const IUseLayoutAction* layout, const char* paneName)

#include <l/Library/Layout/LayoutActionFunction.h>

bool al::isActionPlaying(const IUseLayoutAction* layout, const char* actionName, const char* paneName)

#include <l/Library/Layout/LayoutActionFunction.h>

bool al::isAnyActionPlaying(const IUseLayoutAction* layout, const char* paneName)

#include <l/Library/Layout/LayoutActionFunction.h>

void al::setNerveAtActionEnd(LayoutActor* layout, const Nerve* nerve)

#include <l/Library/Layout/LayoutActionFunction.h>

void al::startTextPaneAnim(LayoutActor*, const char16*, const MessageTagDataHolder*, const ReplaceTagProcessorBase*)

#include <l/Library/Layout/LayoutActionFunction.h>

void al::startTextPaneAnimWithAudioUser(LayoutActor*, const char16*, const MessageTagDataHolder*, const ReplaceTagProcessorBase*, const IUseAudioKeeper*)

#include <l/Library/Layout/LayoutActionFunction.h>

void al::startAndSetTextPaneAnimStage(LayoutActor*, const char*, const char*, const MessageTagDataHolder*, const ReplaceTagProcessorBase*)

#include <l/Library/Layout/LayoutActionFunction.h>

void al::startAndSetTextPaneAnimSystem(LayoutActor*, const char*, const char*, const MessageTagDataHolder*, const ReplaceTagProcessorBase*)

#include <l/Library/Layout/LayoutActionFunction.h>

void al::endTextPaneAnim(LayoutActor*)

#include <l/Library/Layout/LayoutActionFunction.h>

void al::skipTextPaneAnim(LayoutActor*)

#include <l/Library/Layout/LayoutActionFunction.h>

void al::flushTextPaneAnim(LayoutActor*)

#include <l/Library/Layout/LayoutActionFunction.h>

void al::changeNextPage(LayoutActor*, const MessageTagDataHolder*, const ReplaceTagProcessorBase*)

#include <l/Library/Layout/LayoutActionFunction.h>

bool al::tryChangeNextPage(LayoutActor*, const MessageTagDataHolder*, const ReplaceTagProcessorBase*)

#include <l/Library/Layout/LayoutActionFunction.h>

bool al::isExistNextPage(const LayoutActor*)

#include <l/Library/Layout/LayoutActionFunction.h>

bool al::isEndTextPaneAnim(const LayoutActor*, bool)

#include <l/Library/Layout/LayoutActionFunction.h>

const char16* al::getCurrentMessagePaneAnim(const LayoutActor*)

#include <l/Library/Layout/LayoutActionFunction.h>

s32 al::calcCurrentMessageTextNum(const LayoutActor*)

#include <l/Library/Layout/LayoutActionFunction.h>

s32 al::calcShowTextTime(s32)

#include <l/Library/Layout/LayoutActionFunction.h>

bool al::tryStartTextAnim(LayoutActor*, const char16*)

#include <l/Library/Layout/LayoutActionFunction.h>

bool al::tryStartTextTagVoice(LayoutActor*, const char16*, const IUseAudioKeeper*, const char*, sead::FixedSafeString<64>*)

#include <l/Library/Layout/LayoutActionFunction.h>

void al::startHitReaction(const LayoutActor*, const char*, const char*)

#include <l/Library/Layout/LayoutActionFunction.h>

bool al::killLayoutIfActive(LayoutActor*)

#include <l/Library/Layout/LayoutActorUtil.h>

bool al::appearLayoutIfDead(LayoutActor*)

#include <l/Library/Layout/LayoutActorUtil.h>

bool al::isActive(const LayoutActor*)

#include <l/Library/Layout/LayoutActorUtil.h>

bool al::isDead(const LayoutActor*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::calcTrans(sead::Vector3f*, const IUseLayout*)

#include <l/Library/Layout/LayoutActorUtil.h>

sead::Vector2f al::getLocalTrans(const IUseLayout*)

#include <l/Library/Layout/LayoutActorUtil.h>

sead::Vector2f* al::getLocalTransPtr(const IUseLayout*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::calcScale(sead::Vector3f*, const IUseLayout*)

#include <l/Library/Layout/LayoutActorUtil.h>

f32 al::getLocalScale(const IUseLayout*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setLocalTrans(IUseLayout*, const sead::Vector3f&)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setLocalTrans(IUseLayout*, const sead::Vector2f&)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setLocalScale(IUseLayout*, f32)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setLocalScale(IUseLayout*, const sead::Vector2f&)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setLocalAlpha(IUseLayout*, f32)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::calcPaneTrans(sead::Vector3f*, const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::calcPaneMtx(sead::Matrix34f*, const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::calcPaneTrans(sead::Vector2f*, const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::calcPaneScale(sead::Vector3f*, const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::calcPaneSize(sead::Vector3f*, const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

const Matrix43f& al::getPaneMtx(const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

const Matrix43f* al::getPaneMtxRaw(const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

f32 al::getGlobalAlpha(const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneLocalTrans(IUseLayout*, const char*, const sead::Vector2f&)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneLocalTrans(IUseLayout*, const char*, const sead::Vector3f&)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneLocalRotate(IUseLayout*, const char*, const sead::Vector3f&)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneLocalScale(IUseLayout*, const char*, const sead::Vector2f&)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneLocalSize(IUseLayout*, const char*, const sead::Vector2f&)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneLocalAlpha(IUseLayout*, const char*, f32)

#include <l/Library/Layout/LayoutActorUtil.h>

sead::Vector3f al::getPaneLocalTrans(const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::getPaneLocalSize(sead::Vector2f*, const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

const sead::Vector3f& al::getPaneLocalRotate(const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

const sead::Vector3f& al::getPaneLocalScale(const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

const sead::Vector3f& al::getTextBoxDrawRectSize(const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::showPane(IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::hidePane(IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::showPaneNoRecursive(IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::hidePaneNoRecursive(IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

bool al::isHidePane(const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::showPaneRoot(IUseLayout*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::hidePaneRoot(IUseLayout*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::showPaneRootNoRecursive(IUseLayout*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::hidePaneRootNoRecursive(IUseLayout*)

#include <l/Library/Layout/LayoutActorUtil.h>

bool al::isHidePaneRoot(const IUseLayout*)

#include <l/Library/Layout/LayoutActorUtil.h>

bool al::isExistPane(const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

bool al::isContainPointPane(const IUseLayout*, const char*, const sead::Vector2f&)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::findHitPaneFromLayoutPos(const IUseLayout*, const sead::Vector2f&)

#include <l/Library/Layout/LayoutActorUtil.h>

bool al::isExistHitPaneFromLayoutPos(const IUseLayout*, const sead::Vector2f&)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::findHitPaneFromScreenPos(const IUseLayout*, const sead::Vector2f&)

#include <l/Library/Layout/LayoutActorUtil.h>

bool al::isExistHitPaneFromScreenPos(const IUseLayout*, const sead::Vector2f&)

#include <l/Library/Layout/LayoutActorUtil.h>

bool al::isTouchPosInPane(const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setCursorPanePos(IUseLayout*, const IUseLayout*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneVtxColor(const IUseLayout*, const char*, const sead::Color4u8&)

#include <l/Library/Layout/LayoutActorUtil.h>

bool al::isTriggerTouchPane(const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

bool al::isHoldTouchPane(const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

bool al::isReleaseTouchPane(const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

s32 al::getPaneChildNum(const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

const char* al::getPaneChildName(const IUseLayout*, const char*, s32)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneStringLength(IUseLayout*, const char*, const char16*, u16, u16)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneString(IUseLayout*, const char*, const char16*, u16)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneCounterDigit1(IUseLayout*, const char*, s32, u16)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneCounterDigit2(IUseLayout*, const char*, s32, u16)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneCounterDigit3(IUseLayout*, const char*, s32, u16)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneCounterDigit4(IUseLayout*, const char*, s32, u16)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneCounterDigit5(IUseLayout*, const char*, s32, u16)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneCounterDigit6(IUseLayout*, const char*, s32, u16)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneNumberDigit1(IUseLayout*, const char*, s32, u16)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneNumberDigit2(IUseLayout*, const char*, s32, u16)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneNumberDigit3(IUseLayout*, const char*, s32, u16)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneNumberDigit4(IUseLayout*, const char*, s32, u16)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneNumberDigit5(IUseLayout*, const char*, s32, u16)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneStringFormat(IUseLayout*, const char*, const char*, ...)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setTextPositionCenterH(IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::initPaneMessage(IUseLayout*, const char*, const MessageHolder*, const char*, u32)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneSystemMessage(LayoutActor*, const char*, const char*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneStageMessage(LayoutActor*, const char*, const char*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

const char16* al::getPaneStringBuffer(const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

s32 al::getPaneStringBufferLength(const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setTextBoxPaneFont(const LayoutActor*, const char*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::adjustPaneSizeToTextSizeAll(const LayoutActor*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::requestCaptureRecursive(const LayoutActor*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setRubyScale(const LayoutActor*, f32)

#include <l/Library/Layout/LayoutActorUtil.h>

nn::ui2d::TextureInfo* al::createTextureInfo()

#include <l/Library/Layout/LayoutActorUtil.h>

nn::ui2d::TextureInfo* al::createTextureInfo(const agl::TextureData&)

#include <l/Library/Layout/LayoutActorUtil.h>

nn::ui2d::TextureInfo* al::createTextureInfo(const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::getPaneTextureInfo(nn::ui2d::TextureInfo*, const IUseLayout*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

nn::ui2d::TextureInfo* al::createTextureInfo(const char*, const char*, const char*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::updateTextureInfo(nn::ui2d::TextureInfo*, const agl::TextureData&)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::setPaneTexture(IUseLayout*, const char*, const nn::ui2d::TextureInfo*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::registerLayoutPartsActor(LayoutActor*, LayoutActor*)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::updateLayoutPaneRecursive(LayoutActor*)

#include <l/Library/Layout/LayoutActorUtil.h>

s32 al::getLayoutPaneGroupNum(LayoutActor*)

#include <l/Library/Layout/LayoutActorUtil.h>

LayoutPaneGroup* al::getLayoutPaneGroup(LayoutActor*, s32)

#include <l/Library/Layout/LayoutActorUtil.h>

void al::initLayoutActor(LayoutActor*, const LayoutInitInfo&, const char*, const char*)

#include <l/Library/Layout/LayoutInitInfo.h>

void al::initLayoutActorLocalized(LayoutActor*, const LayoutInitInfo&, const char*, const char*)

#include <l/Library/Layout/LayoutInitInfo.h>

void al::initLayoutActorUseOtherMessage(LayoutActor*, const LayoutInitInfo&, const char*, const char*, const char*)

#include <l/Library/Layout/LayoutInitInfo.h>

void al::initLayoutTextPaneAnimator(LayoutActor*, const char*)

#include <l/Library/Layout/LayoutInitInfo.h>

void al::initLayoutTextPaneAnimatorWithShadow(LayoutActor*, const char*)

#include <l/Library/Layout/LayoutInitInfo.h>

void al::initLayoutPartsActor(LayoutActor*, LayoutActor*, const LayoutInitInfo&, const char*, const char*)

#include <l/Library/Layout/LayoutInitInfo.h>

void al::initLayoutPartsActorLocalized(LayoutActor*, LayoutActor*, const LayoutInitInfo&, const char*, const char*)

#include <l/Library/Layout/LayoutInitInfo.h>

void al::initLayoutInitInfo(LayoutInitInfo*, const LayoutKit*, SceneObjHolder*, const AudioDirector*, const LayoutSystem*, const MessageSystem*, const GamePadSystem*)

#include <l/Library/Layout/LayoutUtil.h>

void al::setRenderBuffer(LayoutKit*, const agl::RenderBuffer*)

#include <l/Library/Layout/LayoutUtil.h>

void al::executeUpdate(LayoutKit*)

#include <l/Library/Layout/LayoutUtil.h>

void al::executeUpdateList(LayoutKit*, const char*, const char*)

#include <l/Library/Layout/LayoutUtil.h>

void al::executeUpdateEffect(LayoutKit*)

#include <l/Library/Layout/LayoutUtil.h>

void al::executeDraw(const LayoutKit*, const char*)

#include <l/Library/Layout/LayoutUtil.h>

void al::executeDrawEffect(const LayoutKit*)

#include <l/Library/Layout/LayoutUtil.h>

void al::startAction(LiveActor* actor, const char* actionName)

#include <l/Library/LiveActor/ActorActionFunction.h>

s32 al::startActionAtRandomFrame(LiveActor* actor, const char* actionName)

#include <l/Library/LiveActor/ActorActionFunction.h>

bool al::tryStartAction(LiveActor* actor, const char* actionName)

#include <l/Library/LiveActor/ActorActionFunction.h>

bool al::tryStartActionIfNotPlaying(LiveActor* actor, const char* actionName)

#include <l/Library/LiveActor/ActorActionFunction.h>

bool al::isActionPlaying(const LiveActor* actor, const char* actionName)

#include <l/Library/LiveActor/ActorActionFunction.h>

bool al::tryStartActionIfActionEnd(LiveActor* actor, const char* actionName)

#include <l/Library/LiveActor/ActorActionFunction.h>

bool al::isActionEnd(const LiveActor* actor)

#include <l/Library/LiveActor/ActorActionFunction.h>

bool al::isExistAction(const LiveActor* actor)

#include <l/Library/LiveActor/ActorActionFunction.h>

bool al::isExistAction(const LiveActor* actor, const char* actionName)

#include <l/Library/LiveActor/ActorActionFunction.h>

bool al::isActionOneTime(const LiveActor* actor)

#include <l/Library/LiveActor/ActorActionFunction.h>

bool al::isActionOneTime(const LiveActor* actor, const char* actionName)

#include <l/Library/LiveActor/ActorActionFunction.h>

const char* al::getActionName(const LiveActor* actor)

#include <l/Library/LiveActor/ActorActionFunction.h>

f32 al::getActionFrame(const LiveActor* actor)

#include <l/Library/LiveActor/ActorActionFunction.h>

f32 al::getActionFrameMax(const LiveActor* actor)

#include <l/Library/LiveActor/ActorActionFunction.h>

f32 al::getActionFrameMax(const LiveActor* actor, const char* actionName)

#include <l/Library/LiveActor/ActorActionFunction.h>

f32 al::getActionFrameRate(const LiveActor* actor)

#include <l/Library/LiveActor/ActorActionFunction.h>

void al::setActionFrame(LiveActor* actor, f32 frame)

#include <l/Library/LiveActor/ActorActionFunction.h>

void al::setActionFrameRate(LiveActor* actor, f32 rate)

#include <l/Library/LiveActor/ActorActionFunction.h>

void al::stopAction(LiveActor* actor)

#include <l/Library/LiveActor/ActorActionFunction.h>

void al::restartAction(LiveActor* actor)

#include <l/Library/LiveActor/ActorActionFunction.h>

void al::copyAction(LiveActor* actor, const LiveActor* sourceActor)

#include <l/Library/LiveActor/ActorActionFunction.h>

void al::startNerveAction(LiveActor* actor, const char* actionName)

#include <l/Library/LiveActor/ActorActionFunction.h>

void al::setNerveAtActionEnd(LiveActor* actor, const Nerve* nerve)

#include <l/Library/LiveActor/ActorActionFunction.h>

void al::resetNerveActionForInit(LiveActor* actor)

#include <l/Library/LiveActor/ActorActionFunction.h>

void al::startHitReaction(const LiveActor* actor, const char* name)

#include <l/Library/LiveActor/ActorActionFunction.h>

void al::startHitReactionHitEffect(const LiveActor* actor, const char* name, const HitSensor* other, const HitSensor* self)

#include <l/Library/LiveActor/ActorActionFunction.h>

void al::startHitReactionHitEffect(const LiveActor* actor, const char* name, const sead::Vector3f& pos)

#include <l/Library/LiveActor/ActorActionFunction.h>

void al::startHitReactionHitEffect(const LiveActor* actor, const char* name, const sead::Matrix34f* mtx)

#include <l/Library/LiveActor/ActorActionFunction.h>

void al::startHitReactionBlowHit(const LiveActor* actor, const HitSensor* other, const HitSensor* self)

#include <l/Library/LiveActor/ActorActionFunction.h>

void al::startHitReactionBlowHit(const LiveActor* actor, const sead::Vector3f& pos)

#include <l/Library/LiveActor/ActorActionFunction.h>

void al::startHitReactionBlowHit(const LiveActor* actor)

#include <l/Library/LiveActor/ActorActionFunction.h>

void al::startHitReactionBlowHitDirect(const LiveActor* actor, const HitSensor* other, const HitSensor* self)

#include <l/Library/LiveActor/ActorActionFunction.h>

void al::startHitReactionBlowHitDirect(const LiveActor* actor, const sead::Vector3f& pos)

#include <l/Library/LiveActor/ActorActionFunction.h>

void al::startHitReactionBlowHitDirect(const LiveActor* actor)

#include <l/Library/LiveActor/ActorActionFunction.h>

void al::startSklAnim(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::startSklAnimInterpole(LiveActor* actor, const char* animName0, const char* animName1)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::tryStartSklAnimIfExist(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isSklAnimExist(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::tryStartSklAnimIfNotPlaying(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isSklAnimPlaying(const LiveActor* actor, const char* animName, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::startSklAnimBlend(LiveActor* actor, const char* animName0, const char* animName1, const char* animName2, const char* animName3, const char* animName4, const char* animName5)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::startSklAnimBlendInterpole(LiveActor* actor, const char* animName0, const char* animName1, const char* animName2, const char* animName3, const char* animName4, const char* animName5, const char* animName6)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::clearSklAnimInterpole(LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isSklAnimExist(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isSklAnimEnd(const LiveActor* actor, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isSklAnimOneTime(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isSklAnimOneTime(const LiveActor* actor, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isSklAnimPlaying(const LiveActor* actor, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.h>

const char* al::getPlayingSklAnimName(const LiveActor* actor, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getSklAnimFrame(const LiveActor* actor, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getSklAnimFrameRate(const LiveActor* actor, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getSklAnimFrameMax(const LiveActor* actor, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getSklAnimFrameMax(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setSklAnimFrame(LiveActor* actor, f32 frame, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setSklAnimFrameRate(LiveActor* actor, f32 frameRate, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setSklAnimFrameAndStop(LiveActor* actor, f32 frame, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.h>

s32 al::getSklAnimBlendNum(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getSklAnimBlendWeight(const LiveActor* actor, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setSklAnimBlendWeight(LiveActor* actor, f32 weight, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setSklAnimBlendWeightDouble(LiveActor* actor, f32 weight)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setSklAnimBlendWeightDouble(LiveActor* actor, f32 weight0, f32 weight1)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setSklAnimBlendWeightTriple(LiveActor* actor, f32 weight0, f32 weight1, f32 weight2)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setSklAnimBlendWeightQuad(LiveActor* actor, f32 weight0, f32 weight1, f32 weight2, f32 weight3)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setSklAnimBlendWeightFivefold(LiveActor* actor, f32 weight0, f32 weight1, f32 weight2, f32 weight3, f32 weight4)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setSklAnimBlendWeightSixfold(LiveActor* actor, f32 weight0, f32 weight1, f32 weight2, f32 weight3, f32 weight4, f32 weight5)

#include <l/Library/LiveActor/ActorAnimFunction.cpp>

void al::setSklAnimBlendFrameAll(LiveActor* actor, f32 frame, bool isSync)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setSklAnimBlendFrameRateAll(LiveActor* actor, f32 frameRate, bool isSync)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::startMtpAnim(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::startMtpAnimAndSetFrameAndStop(LiveActor* actor, const char* animName, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setMtpAnimFrameRate(LiveActor* actor, f32 frameRate)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setMtpAnimFrame(LiveActor* actor, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::tryStartMtpAnimIfExist(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMtpAnimExist(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::tryStartMtpAnimIfNotPlaying(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMtpAnimPlaying(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::clearMtpAnim(LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMtpAnimExist(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMtpAnimEnd(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMtpAnimOneTime(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMtpAnimOneTime(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

const char* al::getPlayingMtpAnimName(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMtpAnimPlaying(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getMtpAnimFrame(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getMtpAnimFrameRate(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getMtpAnimFrameMax(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getMtpAnimFrameMax(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setMtpAnimFrameAndStop(LiveActor* actor, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setMtpAnimFrameAndStopEnd(LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::startMclAnim(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMclAnimExist(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMclAnimExist(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::tryStartMclAnimIfExist(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::tryStartMclAnimIfNotPlaying(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMclAnimPlaying(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::clearMclAnim(LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMclAnimEnd(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMclAnimOneTime(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMclAnimOneTime(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

const char* al::getPlayingMclAnimName(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMclAnimPlaying(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getMclAnimFrame(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getMclAnimFrameRate(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getMclAnimFrameMax(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getMclAnimFrameMax(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setMclAnimFrame(LiveActor* actor, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setMclAnimFrameRate(LiveActor* actor, f32 frameRate)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::startMclAnimAndSetFrameAndStop(LiveActor* actor, const char* animName, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setMclAnimFrameAndStop(LiveActor* actor, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setMclAnimNormalFrameAndStop(LiveActor* actor, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setMclAnimFrameAndStopEnd(LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::startMtsAnim(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::startMtsAnimAndSetFrameAndStop(LiveActor* actor, const char* animName, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setMtsAnimFrame(LiveActor* actor, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setMtsAnimFrameRate(LiveActor* actor, f32 frameRate)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::tryStartMtsAnimIfExist(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMtsAnimExist(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::tryStartMtsAnimIfNotPlaying(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMtsAnimPlaying(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::clearMtsAnim(LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMtsAnimExist(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMtsAnimEnd(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMtsAnimOneTime(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMtsAnimOneTime(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

const char* al::getPlayingMtsAnimName(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMtsAnimPlaying(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getMtsAnimFrame(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getMtsAnimFrameRate(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getMtsAnimFrameMax(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getMtsAnimFrameMax(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setMtsAnimFrameAndStop(LiveActor* actor, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setMtsAnimFrameAndStopEnd(LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::createMatAnimSlotForMcl(LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::createMatAnimSlotForMtp(LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::createMatAnimSlotForMts(LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::startMatAnim(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.cpp>

void al::startMatAnimAndSetFrameAndStop(LiveActor* actor, const char* animName, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.cpp>

void al::setMatAnimFrame(LiveActor* actor, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setMatAnimFrameRate(LiveActor* actor, f32 frameRate)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::tryStartMatAnimIfExist(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMatAnimExist(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::tryStartMatAnimIfNotPlaying(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMatAnimPlaying(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::clearMatAnim(LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMatAnimExist(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMatAnimEnd(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMatAnimOneTime(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMatAnimOneTime(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

const char* al::getPlayingMatAnimName(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isMatAnimPlaying(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getMatAnimFrame(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getMatAnimFrameRate(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getMatAnimFrameMax(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getMatAnimFrameMax(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setMatAnimFrameAndStop(LiveActor* actor, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setMatAnimFrameAndStopEnd(LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::startVisAnim(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::tryStartVisAnimIfExist(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isVisAnimExist(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::tryStartVisAnimIfNotPlaying(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isVisAnimPlaying(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::clearVisAnim(LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isVisAnimExist(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isVisAnimEnd(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isVisAnimOneTime(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isVisAnimOneTime(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

const char* al::getPlayingVisAnimName(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isVisAnimPlaying(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getVisAnimFrame(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getVisAnimFrameRate(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getVisAnimFrameMax(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getVisAnimFrameMax(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setVisAnimFrame(LiveActor* actor, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setVisAnimFrameRate(LiveActor* actor, f32 frameRate)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setVisAnimFrameAndStop(LiveActor* actor, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setVisAnimFrameAndStopEnd(LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::startVisAnimAndSetFrameAndStop(LiveActor* actor, const char* animName, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::startVisAnimForAction(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::tryStartVisAnimIfExistForAction(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::tryStartVisAnimIfNotPlayingForAction(LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isVisAnimPlayingForAction(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::clearVisAnimForAction(LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isVisAnimEndForAction(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isVisAnimOneTimeForAction(const LiveActor* actor, const char* animName)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isVisAnimOneTimeForAction(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

const char* al::getPlayingVisAnimNameForAction(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isVisAnimPlayingForAction(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getVisAnimFrameForAction(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getVisAnimFrameRateForAction(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getVisAnimFrameMaxForAction(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setVisAnimFrameForAction(LiveActor* actor, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setVisAnimFrameRateForAction(LiveActor* actor, f32 frameRate)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setVisAnimFrameAndStopForAction(LiveActor* actor, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setVisAnimFrameAndStopEndForAction(LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::startVisAnimAndSetFrameAndStopForAction(LiveActor* actor, const char* animName, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setAllAnimFrame(LiveActor* actor, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setAllAnimFrameRate(LiveActor* actor, f32 frameRate)

#include <l/Library/LiveActor/ActorAnimFunction.cpp>

void al::startPartialSklAnim(LiveActor* actor, const char* animName, s32 partCount, s32 value, const SklAnimRetargettingInfo* info)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::startPartialSklAnimWithInterpolate(LiveActor* actor, const char* animName, s32 partCount, s32 value, s32 interpol, const SklAnimRetargettingInfo* info)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::clearPartialSklAnim(LiveActor* actor, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::clearPartialSklAnimWithInterpolate(LiveActor* actor, s32 partIndex, s32 interpol)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isPartialSklAnimEnd(const LiveActor* actor, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isPartialSklAnimOneTime(const LiveActor* actor, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isPartialSklAnimAttached(const LiveActor* actor, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isPartialSklAnimPlaying(const LiveActor* actor, const char* partsName, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.cpp>

const char* al::getPlayingPartialSklAnimName(const LiveActor* actor, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getPartialSklAnimFrame(const LiveActor* actor, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setPartialSklAnimFrame(LiveActor* actor, s32 index, f32 frame)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getPartialSklAnimFrameRate(const LiveActor* actor, s32 index)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setPartialSklAnimFrameRate(LiveActor* actor, s32 index, f32 frameRate)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setBaseMtxAndCalcAnim(LiveActor* actor, const sead::Matrix34f& matrix, const sead::Vector3f& vector)

#include <l/Library/LiveActor/ActorAnimFunction.h>

AnimPlayerSkl* al::getSkl(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

AnimPlayerMat* al::getMtp(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

AnimPlayerMat* al::getMcl(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

AnimPlayerMat* al::getMts(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

AnimPlayerMat* al::getMat(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

AnimPlayerVis* al::getVis(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

AnimPlayerVis* al::getVisForAction(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::updateModelDraw(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::updateActorSystem(LiveActor* actor)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setSklBlendWeight(const LiveActor* actor, u32 index, f32 weight)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::createMat(const LiveActor* actor, s32 programType)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setAllAnimFrameRate(LiveActor* f32)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::validateSklAnimRetargetting(const LiveActor*)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::invalidateSklAnimRetargetting(const LiveActor*)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::copySklAnim(LiveActor*, const LiveActor*)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::setSklAnimBlendWeightSixfold(LiveActor*, f32, f32, f32, f32, f32)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isExistSklAnimRetargetting(const LiveActor*)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isSklAnimRetargettingValid(const LiveActor*)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::startMatAnim(LiveActor, const char*)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::startMatAnimAndSetFrameAndStop(LiveActor, const char*, f32)

#include <l/Library/LiveActor/ActorAnimFunction.h>

f32 al::getVisAnimFrameMaxForAction(const LiveActor*, const char*)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isVisAnimExistForAction(const LiveActor*, const char*)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isVisAnimExistForAction(const LiveActor*)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::initAndBindSklAnimRetargetting(LiveActor*, const char*, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorAnimFunction.h>

SklAnimRetargettingInfo* al::createSklAnimRetargetting(const LiveActor*, const char*, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::bindSklAnimRetargetting(const LiveActor*, const SklAnimRetargettingInfo*)

#include <l/Library/LiveActor/ActorAnimFunction.h>

SklAnimRetargettingInfo* al::createSklAnimRetargetting(const LiveActor*, const LiveActor*, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::unbindSklAnimRetargetting(const LiveActor*)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::initPartialSklAnim(LiveActor*, s32, s32, s32)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::addPartialSklAnimPartsList(LiveActor*, const char*, const char*, s32)

#include <l/Library/LiveActor/ActorAnimFunction.h>

void al::addPartialSklAnimPartsListRecursive(LiveActor*, const char*, s32)

#include <l/Library/LiveActor/ActorAnimFunction.h>

s32 al::getPartialSklAnimSlotNum(LiveActor*)

#include <l/Library/LiveActor/ActorAnimFunction.h>

s32 al::calcJoitsAmountFromJoint(LiveActor*, const char*)

#include <l/Library/LiveActor/ActorAnimFunction.h>

bool al::isPartialAnimPlaying(const LiveActor*, s32)

#include <l/Library/LiveActor/ActorAnimFunction.h>

AreaObj* al::tryFindAreaObjPlayerOne(const PlayerHolder* holder, const char* name)

#include <l/Library/LiveActor/ActorAreaFunction.h>

AreaObj* al::tryFindAreaObjPlayerAll(const PlayerHolder* holder, const char* name)

#include <l/Library/LiveActor/ActorAreaFunction.h>

AreaObj* al::createAreaObj(const ActorInitInfo& actorInitInfo, const char* name)

#include <l/Library/LiveActor/ActorAreaFunction.h>

void al::initAreaInitInfo(AreaInitInfo* areaInitInfo, const ActorInitInfo& actorInitInfo)

#include <l/Library/LiveActor/ActorAreaFunction.h>

AreaObj* al::createLinkArea(const ActorInitInfo& initInfo, const char* name, const char* areaName)

#include <l/Library/LiveActor/ActorAreaFunction.h>

void al::initAreaInitInfo(AreaInitInfo* areaInitInfo, const PlacementInfo& placementInfo, const ActorInitInfo& actorInitInfo)

#include <l/Library/LiveActor/ActorAreaFunction.h>

AreaObj* al::tryCreateLinkArea(const ActorInitInfo& initInfo, const char* name, const char* areaName)

#include <l/Library/LiveActor/ActorAreaFunction.h>

al::__attribute__((always_inline)) AreaObjGroup *createLinkAreaGroup(const ActorInitInfo &initInfo

#include <l/Library/LiveActor/ActorAreaFunction.cpp>

al::if() return nullptr

#include <l/Library/LiveActor/ActorAreaFunction.cpp>

areaGroup al::createBuffer(linkChildNum)

#include <l/Library/LiveActor/ActorAreaFunction.cpp>

al::for()

#include <l/Library/LiveActor/ActorAreaFunction.cpp>

AreaObjGroup* al::createLinkAreaGroup(LiveActor* actor, const ActorInitInfo& initInfo, const char* name, const char* groupName, const char* areaName)

#include <l/Library/LiveActor/ActorAreaFunction.h>

AreaObj* al::tryFindAreaObj(const LiveActor* actor, const char* name)

#include <l/Library/LiveActor/ActorAreaFunction.h>

bool al::isInAreaObj(const LiveActor* actor, const char* name)

#include <l/Library/LiveActor/ActorAreaFunction.h>

bool al::isInDeathArea(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAreaFunction.h>

bool al::isInWaterArea(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAreaFunction.h>

bool al::isInPlayerControlOffArea(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAreaFunction.h>

f32 al::calcWaterSinkDepth(const LiveActor* actor)

#include <l/Library/LiveActor/ActorAreaFunction.h>

void al::registerAreaHostMtx(const IUseAreaObj* areaObj, const sead::Matrix34f* mtx, const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorAreaFunction.h>

void al::registerAreaHostMtx(const IUseAreaObj* areaObj, const sead::Matrix34f* mtx, const ActorInitInfo& initInfo, const ValidatorBase& validator)

#include <l/Library/LiveActor/ActorAreaFunction.h>

void al::registerAreaHostMtx(const LiveActor* actor, const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorAreaFunction.h>

void al::registerAreaHostMtx(const LiveActor* actor, const ActorInitInfo& initInfo, const ValidatorBase& validator)

#include <l/Library/LiveActor/ActorAreaFunction.h>

void al::registerAreaSyncHostMtx(const IUseAreaObj* areaObj, const sead::Matrix34f* mtx, const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorAreaFunction.h>

void al::registerAreaSyncHostMtx(const IUseAreaObj* areaObj, const sead::Matrix34f* mtx, const ActorInitInfo& initInfo, const ValidatorBase& validator)

#include <l/Library/LiveActor/ActorAreaFunction.h>

void al::registerAreaSyncHostMtx(const LiveActor* actor, const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorAreaFunction.h>

void al::registerAreaSyncHostMtx(const LiveActor* actor, const ActorInitInfo& initInfo, const ValidatorBase& validator)

#include <l/Library/LiveActor/ActorAreaFunction.h>

bool al::tryReviseVelocityInsideAreaObj(sead::Vector3f* nearestEdgePos, LiveActor* actor, AreaObjGroup* areaGroup, const AreaObj* areaObj)

#include <l/Library/LiveActor/ActorAreaFunction.h>

SwitchKeepOnAreaGroup* al::tryCreateSwitchKeepOnAreaGroup(LiveActor* actor, const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorAreaFunction.h>

SwitchOnAreaGroup* al::tryCreateSwitchOnAreaGroup(LiveActor* actor, const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorAreaFunction.h>

AreaObj* al::tryGetAreaObjPlayerAll(const LiveActor* actor, const AreaObjGroup* areaGroup)

#include <l/Library/LiveActor/ActorAreaFunction.h>

bool al::isInAreaObjPlayerAll(const LiveActor* actor, const AreaObj* areaObj)

#include <l/Library/LiveActor/ActorAreaFunction.h>

bool al::isInAreaObjPlayerAll(const LiveActor* actor, const AreaObjGroup* areaGroup)

#include <l/Library/LiveActor/ActorAreaFunction.h>

bool al::isInAreaObjPlayerAnyOne(const LiveActor* actor, const AreaObj* areaObj)

#include <l/Library/LiveActor/ActorAreaFunction.h>

bool al::isInAreaObjPlayerAnyOne(const LiveActor* actor, const AreaObjGroup* areaGroup)

#include <l/Library/LiveActor/ActorAreaFunction.h>

AreaObjGroup* al::createLinkAreaGroup(const ActorInitInfo& initInfo, const char* name, const char* groupName, const char* areaName)

#include <l/Library/LiveActor/ActorAreaFunction.h>

bool al::isInAreaObjPlayerOne(const PlayerHolder* holder, const char* name)

#include <l/Library/LiveActor/ActorAreaFunction.h>

bool al::isInAreaObjPlayerAll(const PlayerHolder* holder, const char* name)

#include <l/Library/LiveActor/ActorAreaFunction.h>

bool al::isInAreaObjPlayerOneIgnoreAreaTarget(const PlayerHolder* holder, const char* name)

#include <l/Library/LiveActor/ActorAreaFunction.h>

bool al::isClipped(const LiveActor* actor)

#include <l/Library/LiveActor/ActorClippingFunction.h>

bool al::isInvalidClipping(const LiveActor* actor)

#include <l/Library/LiveActor/ActorClippingFunction.h>

void al::initActorClipping(LiveActor* actor, const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorClippingFunction.h>

void al::initGroupClipping(LiveActor* actor, const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorClippingFunction.h>

f32 al::getClippingRadius(const LiveActor* actor)

#include <l/Library/LiveActor/ActorClippingFunction.h>

void al::setClippingInfo(LiveActor* actor, f32, const sead::Vector3f*)

#include <l/Library/LiveActor/ActorClippingFunction.h>

void al::setClippingObb(LiveActor* actor, const sead::BoundBox3f& boundingBox)

#include <l/Library/LiveActor/ActorClippingFunction.h>

const sead::BoundBox3f& al::getClippingObb(LiveActor* actor)

#include <l/Library/LiveActor/ActorClippingFunction.h>

const sead::Vector3f& al::getClippingCenterPos(const LiveActor* actor)

#include <l/Library/LiveActor/ActorClippingFunction.h>

void al::setClippingNearDistance(LiveActor* actor, f32 near)

#include <l/Library/LiveActor/ActorClippingFunction.h>

void al::expandClippingRadiusByShadowLength(LiveActor* actor, sead::Vector3f*, f32 radius)

#include <l/Library/LiveActor/ActorClippingFunction.h>

bool al::tryExpandClippingToGround(LiveActor* actor, sead::Vector3f*, f32)

#include <l/Library/LiveActor/ActorClippingFunction.h>

bool al::tryExpandClippingByShadowMaskLength(LiveActor* actor, sead::Vector3f*)

#include <l/Library/LiveActor/ActorClippingFunction.h>

bool al::tryExpandClippingByDepthShadowLength(LiveActor* actor, sead::Vector3f*)

#include <l/Library/LiveActor/ActorClippingFunction.h>

bool al::tryExpandClippingByExpandObject(LiveActor*, const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorClippingFunction.h>

void al::invalidateClipping(LiveActor* actor)

#include <l/Library/LiveActor/ActorClippingFunction.h>

void al::validateClipping(LiveActor* actor)

#include <l/Library/LiveActor/ActorClippingFunction.h>

void al::onDrawClipping(LiveActor* actor)

#include <l/Library/LiveActor/ActorClippingFunction.h>

void al::offDrawClipping(LiveActor* actor)

#include <l/Library/LiveActor/ActorClippingFunction.h>

void al::onGroupClipping(LiveActor* actor)

#include <l/Library/LiveActor/ActorClippingFunction.h>

void al::offGroupClipping(LiveActor* actor)

#include <l/Library/LiveActor/ActorClippingFunction.h>

bool al::isInClippingFrustum(const LiveActor* actor, const sead::Vector3f&, f32, f32, s32)

#include <l/Library/LiveActor/ActorClippingFunction.h>

bool al::isInClippingFrustum(const ClippingDirector* director, const sead::Vector3f&, f32, f32, s32)

#include <l/Library/LiveActor/ActorClippingFunction.h>

bool al::isInClippingFrustumAllView(const LiveActor* actor, const sead::Vector3f& pos, f32, f32)

#include <l/Library/LiveActor/ActorClippingFunction.h>

Collider* al::getActorCollider(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isExistActorCollider(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::getActorCollisionPartsSensor(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isExistCollisionParts(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isEqualCollisionParts(const LiveActor*, const CollisionParts*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::validateCollisionParts(LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::invalidateCollisionParts(LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::validateCollisionPartsBySystem(LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::invalidateCollisionPartsBySystem(LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::isValidCollisionParts(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::setCollisionPartsSpecialPurposeName(LiveActor*, const char*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::resetAllCollisionMtx(LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::syncCollisionMtx(LiveActor*, const sead::Matrix34f*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::syncCollisionMtx(LiveActor*, CollisionParts*, const sead::Matrix34f*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::setSyncCollisionMtxPtr(LiveActor*, const sead::Matrix34f*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isOnGround(const LiveActor*, u32)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isOnGroundFace(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isCollidedGroundEdgeOrCorner(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isOnGroundNoVelocity(const LiveActor*, u32)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isOnGroundDegree(const LiveActor*, f32, u32)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isOnGroundFaceDegree(const LiveActor*, f32)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isOnGroundNoVelocityDegree(const LiveActor*, f32, u32)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

const sead::Vector3f& al::getOnGroundNormal(const LiveActor*, u32)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::setColliderRadius(LiveActor*, f32)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::setColliderOffsetY(LiveActor*, f32)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

f32 al::getColliderRadius(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

f32 al::getColliderOffsetY(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::getColliderFixReaction(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::calcColliderPos(sead::Vector3f*, const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::validateColliderRobustCheck(LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::invalidateColliderRobustCheck(LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::setColliderReactMovePower(LiveActor*, bool)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::calcColliderFloorRotatePower(sead::Quatf*, LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::calcJumpInertia(sead::Vector3f*, LiveActor*, const sead::Vector3f&, f32)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isCollidedGround(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::calcJumpInertiaWall(sead::Vector3f*, LiveActor*, f32)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isCollidedWall(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::scaleVelocityInertiaWallHit(LiveActor*, f32, f32, f32)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

const sead::Vector3f& al::getCollidedWallNormal(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::calcCollidedNormalSum(const LiveActor*, sead::Vector3f*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::calcGroundNormalOrUpDir(sead::Vector3f*, const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

const sead::Vector3f& al::getCollidedGroundNormal(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::calcGroundNormalOrGravityDir(sead::Vector3f*, const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::setColliderFilterTriangle(LiveActor*, const TriangleFilterBase*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::setColliderFilterCollisionParts(LiveActor*, const CollisionPartsFilterBase*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::createAndSetColliderFilterExistActor(LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::createAndSetColliderFilterExistActor(LiveActor*, LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::createAndSetColliderFilterSubActor(LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::createAndSetColliderSpecialPurpose(LiveActor*, const char*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::createAndSetColliderSpecialPurposeForCollisionActor(LiveActor*, const char*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::createAndSetColliderIgnoreOptionalPurpose(LiveActor*, const char*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::createAndSetColliderSpecialAndIgnoreOptionalPurpose(LiveActor*, const char*, const char*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::createActorCollisionController(LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::setColliderRadius(ActorCollisionController*, f32)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::setColliderRadiusScale(ActorCollisionController*, f32)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::setColliderOffsetY(ActorCollisionController*, f32)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::resetActorCollisionController(ActorCollisionController*, s32)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::updateActorCollisionController(ActorCollisionController*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

const char* al::getCollidedFloorMaterialCodeName(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

const char* al::getCollidedFloorMaterialCodeName(const Collider*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

const char* al::getCollidedWallMaterialCodeName(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

const char* al::getCollidedCeilingMaterialCodeName(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isCollidedFloorCode(const LiveActor*, const char*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isCollidedCollisionCode(const LiveActor*, const char*, const char*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isCollidedWallCode(const LiveActor*, const char*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isCollidedCameraCode(const LiveActor*, const char*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isCollidedMaterialCode(const LiveActor*, const char*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isCollidedGroundFloorCode(const LiveActor*, const char*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isCollidedGroundCollisionCode(const LiveActor*, const char*, const char*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isCollided(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isCollidedCeiling(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isCollidedWallFace(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isCollidedVelocity(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isCollidedWallVelocity(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isCollidedCeilingVelocity(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

const sead::Vector3f& al::getCollidedCeilingNormal(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

const sead::Vector3f& al::getCollidedGroundPos(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

const sead::Vector3f& al::getCollidedWallPos(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

const sead::Vector3f& al::getCollidedCeilingPos(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::calcSpeedCollideWall(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::calcSpeedCollideGround(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::calcSpeedCollideCeiling(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::getCollidedGroundCollisionParts(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::tryGetCollidedGroundCollisionParts(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::getCollidedWallCollisionParts(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::tryGetCollidedWallCollisionParts(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::getCollidedCeilingCollisionParts(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::tryGetCollidedCeilingCollisionParts(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::getCollidedGroundSensor(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

HitSensor* al::tryGetCollidedGroundSensor(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

HitSensor* al::getCollidedWallSensor(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

HitSensor* al::tryGetCollidedWallSensor(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

HitSensor* al::getCollidedCeilingSensor(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

HitSensor* al::tryGetCollidedCeilingSensor(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

HitSensor* al::tryGetCollidedSensor(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::tryGetCollidedPos(sead::Vector3f*, const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::setForceCollisionScaleOne(const LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::followRotateFrontAxisUpGround(LiveActor*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

void al::followRotateFrontAxisUp(LiveActor*, const CollisionParts*)

#include <l/Library/LiveActor/ActorCollisionFunction.h>

bool al::isAlive(const LiveActor* actor)

#include <l/Library/LiveActor/ActorFlagFunction.h>

bool al::isDead(const LiveActor* actor)

#include <l/Library/LiveActor/ActorFlagFunction.h>

bool al::isNoCollide(const LiveActor* actor)

#include <l/Library/LiveActor/ActorFlagFunction.h>

void al::onCalcAnim(LiveActor* actor)

#include <l/Library/LiveActor/ActorFlagFunction.h>

void al::offCalcAnim(LiveActor* actor)

#include <l/Library/LiveActor/ActorFlagFunction.h>

void al::validateShadow(LiveActor* actor)

#include <l/Library/LiveActor/ActorFlagFunction.h>

void al::invalidateShadow(LiveActor* actor)

#include <l/Library/LiveActor/ActorFlagFunction.h>

void al::onCollide(LiveActor* actor)

#include <l/Library/LiveActor/ActorFlagFunction.h>

void al::offCollide(LiveActor* actor)

#include <l/Library/LiveActor/ActorFlagFunction.h>

void al::validateMaterialCode(LiveActor* actor)

#include <l/Library/LiveActor/ActorFlagFunction.h>

void al::invalidateMaterialCode(LiveActor* actor)

#include <l/Library/LiveActor/ActorFlagFunction.h>

void al::validatePuddleMaterial(LiveActor* actor)

#include <l/Library/LiveActor/ActorFlagFunction.h>

void al::invalidatePuddleMaterial(LiveActor* actor)

#include <l/Library/LiveActor/ActorFlagFunction.h>

bool al::isAreaTarget(const LiveActor* actor)

#include <l/Library/LiveActor/ActorFlagFunction.h>

void al::onAreaTarget(LiveActor* actor)

#include <l/Library/LiveActor/ActorFlagFunction.h>

void al::offAreaTarget(LiveActor* actor)

#include <l/Library/LiveActor/ActorFlagFunction.h>

bool al::isUpdateMovementEffectAudioCollisionSensor(const LiveActor* actor)

#include <l/Library/LiveActor/ActorFlagFunction.h>

void al::onUpdateMovementEffectAudioCollisionSensor(LiveActor* actor)

#include <l/Library/LiveActor/ActorFlagFunction.h>

void al::offUpdateMovementEffectAudioCollisionSensor(LiveActor* actor)

#include <l/Library/LiveActor/ActorFlagFunction.h>

void al::initActorSceneInfo(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorUpdate(LiveActor* actor, const ActorInitInfo& info, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorDraw(LiveActor* actor, const ActorInitInfo& info, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorPlayer(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorPlayerPreMovement(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorPlayerMovement(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorPlayerModel(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorPlayerDecoration(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorEnemy(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorEnemyMovement(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorEnemyDecoration(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorEnemyDecorationMovement(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorMapObj(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorMapObjMovement(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorMapObjDecoration(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorNpcDecoration(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorShadowVolume(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorShadowVolumeFillStencil(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorCollisionMapObjDecorationMovement(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorWatchObj(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorDebugMovement(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorModelUpdate(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initExecutorDrcAssistMovement(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorPoseTRSV(LiveActor* actor)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorPoseTRMSV(LiveActor* actor)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorPoseTRGMSV(LiveActor* actor)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorPoseTFSV(LiveActor* actor)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorPoseTFUSV(LiveActor* actor)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorPoseTFGSV(LiveActor* actor)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorPoseTQSV(LiveActor* actor)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorPoseTQGSV(LiveActor* actor)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorPoseTQGMSV(LiveActor* actor)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorSRT(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorModelKeeper(LiveActor*, const ActorInitInfo&, const ActorResource*, s32)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorModelKeeper(LiveActor*, const ActorInitInfo&, const char*, s32, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorModelKeeperByHost(LiveActor*, const LiveActor*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorModelForceCubeMap(LiveActor*, const ActorInitInfo&)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorActionKeeper(LiveActor*, const ActorInitInfo&, const char*, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorActionKeeper(LiveActor*, const ActorResource*, const char*, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorEffectKeeper(LiveActor*, const ActorInitInfo&, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorSeKeeper(LiveActor*, const ActorInitInfo&, const char*, const sead::Vector3f*, const sead::Matrix34f*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorSeKeeper(LiveActor*, const ActorInitInfo&, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorSeKeeperWithout3D(LiveActor*, const ActorInitInfo&, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorBgmKeeper(LiveActor*, const ActorInitInfo&, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

bool al::isInitializedBgmKeeper(LiveActor*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initHitReactionKeeper(LiveActor*, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initHitReactionKeeper(LiveActor*, const Resource*, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorParamHolder(LiveActor*, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorParamHolder(LiveActor*, const Resource*, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initDepthShadowMapCtrl(LiveActor*, const Resource*, const ActorInitInfo&, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initDepthShadowMapCtrlWithoutIter(LiveActor*, s32, bool)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::addDepthShadowMapInfo(const LiveActor*, const char*, s32, s32, s32, f32, bool, const sead::Vector3f&, bool, const sead::Vector3f&, const sead::Vector3f&, bool, const char*, s32, bool, f32, f32, f32, bool, bool, f32, s32, bool)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::declareUseDepthShadowMap(const LiveActor*, s32)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::createDepthShadowMap(const LiveActor*, const char*, s32, s32, s32)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initShadowMaskCtrl(LiveActor*, const ActorInitInfo&, const ByamlIter&, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initShadowMaskCtrlWithoutInitFile(LiveActor*, const ActorInitInfo&, s32)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::createShadowMaskSphere(LiveActor*, const char*, const char*, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::createShadowMaskCube(LiveActor*, const char*, const char*, const char*, const sead::Color4f&, const sead::Vector3f&, f32, f32, f32, const sead::Vector3f&, f32)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::createShadowMaskCylinder(LiveActor*, const char*, const char*, const char*, const sead::Color4f&, const sead::Vector3f&, f32, f32, f32, f32, f32)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::createShadowMaskCastOvalCylinder(LiveActor*, const char*, const char*, const char*, const sead::Color4f&, const sead::Vector3f&, const sead::Vector3f&, f32, f32, f32, f32)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorCollision(LiveActor*, const sead::SafeString&, HitSensor*, const sead::Matrix34f*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorCollisionWithResource(LiveActor*, const Resource*, const sead::SafeString&, HitSensor*, const sead::Matrix34f*, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorCollisionWithArchiveName(LiveActor*, const sead::SafeString&, const sead::SafeString&, HitSensor*, const sead::Matrix34f*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorCollisionWithFilePtr(LiveActor*, void*, const void*, HitSensor*, const sead::Matrix34f*, const char*, const char*, s32)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initStageSwitch(LiveActor*, const ActorInitInfo&)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorItemKeeper(LiveActor*, const ActorInitInfo&, const ByamlIter&)

#include <l/Library/LiveActor/ActorInitFunction.h>

bool al::initActorPrePassLightKeeper(LiveActor*, const Resource*, const ActorInitInfo&, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorOcclusionKeeper(LiveActor*, const Resource*, const ActorInitInfo&, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initSubActorKeeper(LiveActor*, const ActorInitInfo&, const char*, s32)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initSubActorKeeperNoFile(LiveActor*, const ActorInitInfo&, s32)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::registerSubActor(LiveActor*, LiveActor*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::registerSubActorSyncClipping(LiveActor*, LiveActor*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::registerSubActorSyncClippingAndHide(LiveActor*, LiveActor*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::registerSubActorSyncAll(LiveActor*, LiveActor*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::setSubActorOffSyncClipping(LiveActor*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initScreenPointKeeper(LiveActor*, const Resource*, const ActorInitInfo&, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initScreenPointKeeperNoYaml(LiveActor*, s32)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActorMaterialCategory(LiveActor*, const ActorInitInfo&, const char*)

#include <l/Library/LiveActor/ActorInitFunction.h>

void al::initActor(LiveActor* actor, const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

al::if(poseId ! = -1)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(!tryGetActorInitFileIter&,, "", suffix) return

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(!initPose.tryGetStringByKey&, "" Pose) return

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(! initActorPoseKeeperpose, actor) return

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(isEqualString(pose, "TFUSV") && tryGetByamlKeyBoolOrFalse(initPose, "IsFrontUp"))

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(!tryGetByamlScale&,, "" Scale) return

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::setScale(actor, scale)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(isExistModel(actor))

#include <l/Library/LiveActor/ActorInitUtil.cpp>

modelLodCtrl al::init(initLod)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::initActorModelKeeper(actor, initInfo, actorResource, blendAnimMax)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(displayRootJointName ! = nullptr)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(isCreateUniqShader)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(partialAnimGroupNum>= 1) initPartialSklAnim(actor

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(isFixedModel)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(isIgnoreUpdateOnDrawClipping) setIgnoreUpdateDrawClipping(actor

#include <l/Library/LiveActor/ActorInitUtil.cpp>

modelKeeper al::setModelLodCtrl(modelLodCtrl)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(modelLodCtrl)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

modelKeeper al::getModelCtrl()

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(isCalcViewCore1)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(isCalcViewCore2)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(initExecutor.tryGetIterByKey&, ""Updater && iter. isTypeArray())

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(initExecutor.tryGetIterByKey&, "" Drawer)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(numSensors<= 0) return

#include <l/Library/LiveActor/ActorInitUtil.cpp>

actor al::initHitSensor(numSensors)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(name = =nullptr) name

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(initCollision.tryGetStringByKey&, "" Sensor) sensor

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(joint ! = nullptr) jointMtx

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::initActorCollisionWithResource(actor, modelRes, name, sensor, jointMtx, suffix)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

actor al::initCollider(radius, offset. y, planeNum)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(!initEffect.tryGetStringByKey&, "" Name) return

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::initActorEffectKeeper(actor, initInfo, name)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(tryGetActorInitFileIter&,, "", suffix)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(seName ! = nullptr) initActorSeKeeper(actor

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(initSound. isExistKey"BgmUserName") initActorBgmKeeper(actor

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(!initClipping.tryGetIterByKey&, "" GroupClipping) return

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::initGroupClipping(actor, initInfo)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::initActorClipping(actor, initInfo)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(invalidate)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(initClipping.tryGetFloatByKey&, "" Radius)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

else al::if(actor-> getModelKeeper())

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(tryGetByamlBox3f&,, "" Obb) setClippingObb(actor

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::initActorGroupClipping(actor, initInfo, initClipping)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::initDepthShadowMapCtrl(actor, modelRes, initInfo, suffix)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::initShadowMaskCtrl(actor, initInfo, initShadowMask, "InitShadowMask")

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(usingDepthShadow)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(initFlag.tryGetIterByKey&, "" MaterialCode)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::initActorItemKeeper(actor, initInfo, initItem)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

actor al::initScoreKeeper()

#include <l/Library/LiveActor/ActorInitUtil.cpp>

actor al::getActorScoreKeeper()

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::initActorActionKeeper(actor, actorResource, archiveName, suffix)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(!actor-> getModelKeeper()) return

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(! tryStartActionactor, archiveName)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(! modelKeeper) return

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::if(ditherAnimator)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

void al::initActorImpl(LiveActor* actor, const ActorInitInfo& initInfo, const sead::SafeString& folderName, const sead::SafeString& fileName, const char* suffix)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

void al::initActorSuffix(LiveActor* actor, const ActorInitInfo& initInfo, const char* suffix)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::initActorChangeModel(LiveActor* actor, const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

const char* al::getModelName(const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

void al::initActorChangeModelSuffix(LiveActor* actor, const ActorInitInfo& initInfo, const char* suffix)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::initActorWithArchiveName(LiveActor* actor, const ActorInitInfo& initInfo, const sead::SafeString& archiveName, const char* suffix)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::initChildActorWithArchiveNameWithPlacementInfo(LiveActor* actor, const ActorInitInfo& initInfo, const sead::SafeString& archiveName, const char* suffix)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::initChildActorWithArchiveNameNoPlacementInfo(LiveActor* actor, const ActorInitInfo& initInfo, const sead::SafeString& archiveName, const char* suffix)

#include <l/Library/LiveActor/ActorInitUtil.h>

LiveActor* al::createChildLinkSimpleActor(const char* actorName, const char* linkName, const ActorInitInfo& initInfo, bool alive)

#include <l/Library/LiveActor/ActorInitUtil.h>

LiveActor* al::createChildLinkMapPartsActor(const char* actorName, const char* linkName, const ActorInitInfo& initInfo, s32 linkIndex, bool alive)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::initMapPartsActor(LiveActor* actor, const ActorInitInfo& initInfo, const char* suffix)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::initLinksActor(LiveActor* actor, const ActorInitInfo& initInfo, const char* suffix, s32 linkIndex)

#include <l/Library/LiveActor/ActorInitUtil.h>

ActorInitInfo* al::createLinksPlayerActorInfo(LiveActor* actor, const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

const char* al::getLinksActorClassName(const ActorInitInfo& initInfo, const char* linkName, s32 linkIndex)

#include <l/Library/LiveActor/ActorInitUtil.h>

const char* al::getLinksActorDisplayName(const ActorInitInfo& initInfo, const char* linkName, s32 linkIndex)

#include <l/Library/LiveActor/ActorInitUtil.h>

const char* al::getLinksActorObjectName(const ActorInitInfo& initInfo, const char* linkName, s32 linkIndex)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::initCreateActorWithPlacementInfo(LiveActor* actor, const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::initCreateActorWithPlacementInfo(LiveActor* actor, const ActorInitInfo& initInfo, const PlacementInfo& placementInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::initCreateActorNoPlacementInfo(LiveActor* actor, const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::initCreateActorNoPlacementInfoNoViewId(LiveActor* actor, const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

al::if(creationFunction = =nullptr) return nullptr

#include <l/Library/LiveActor/ActorInitUtil.cpp>

actor al::init(childInitInfo)

#include <l/Library/LiveActor/ActorInitUtil.cpp>

LiveActor* al::createPlacementActorFromFactory(const ActorInitInfo& initInfo, const PlacementInfo* placementInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

LiveActor* al::createLinksActorFromFactory(const ActorInitInfo& initInfo, const char* linkName, s32 linkNum)

#include <l/Library/LiveActor/ActorInitUtil.h>

LiveActorGroup* al::createLinksActorGroupFromFactory(const ActorInitInfo& initInfo, const char* linkName, const char* groupName)

#include <l/Library/LiveActor/ActorInitUtil.h>

LiveActorGroup* al::tryCreateLinksActorGroupFromFactory(const ActorInitInfo& initInfo, const char* linkName, const char* groupName)

#include <l/Library/LiveActor/ActorInitUtil.h>

LiveActor* al::tryCreateLinksActorFromFactorySingle(const ActorInitInfo& initInfo, const char* linkName)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::createAndRegisterLinksActorFromFactory(LiveActorGroup* group, const ActorInitInfo& initInfo, const char* linkName)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::makeMapPartsModelName(sead::BufferedSafeString* modelName, sead::BufferedSafeString* path, const PlacementInfo& placementInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::makeMapPartsModelName(sead::BufferedSafeString* modelName, sead::BufferedSafeString* path, const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

const char* al::tryGetMapPartsSuffix(const ActorInitInfo& initInfo, const char* suffix)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::initMapPartsActorWithArchiveName(LiveActor* actor, const ActorInitInfo& initInfo, const char* fileName, const char* suffix)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::initNerve(LiveActor* actor, const Nerve* nerve, s32 maxStates)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::initNerveAction(LiveActor* actor, const char* actionName, alNerveFunction::NerveActionCollector* collector, s32 maxStates)

#include <l/Library/LiveActor/ActorInitUtil.h>

bool al::trySyncStageSwitchAppear(LiveActor* actor)

#include <l/Library/LiveActor/ActorInitUtil.h>

bool al::trySyncStageSwitchKill(LiveActor* actor)

#include <l/Library/LiveActor/ActorInitUtil.h>

bool al::trySyncStageSwitchAppearAndKill(LiveActor* actor)

#include <l/Library/LiveActor/ActorInitUtil.h>

bool al::tryListenStageSwitchAppear(LiveActor* actor)

#include <l/Library/LiveActor/ActorInitUtil.h>

bool al::tryListenStageSwitchKill(LiveActor* actor)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::syncSensorScaleY(LiveActor* actor)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::syncSensorAndColliderScaleY(LiveActor* actor)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::setMaterialCode(LiveActor* actor, const char* materialCode)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::initMaterialCode(LiveActor* actor, const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

bool al::tryAddDisplayRotate(LiveActor* actor, const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

bool al::tryAddDisplayOffset(LiveActor* actor, const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

bool al::tryAddDisplayScale(LiveActor* actor, const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

const PlacementInfo& al::getPlacementInfo(const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

const LayoutInitInfo& al::getLayoutInitInfo(const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

AudioDirector* al::getAudioDirector(const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

CollisionDirector* al::getCollisionDirectorFromInfo(const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

const SceneCameraInfo* al::getSceneCameraInfoFromInfo(const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

GraphicsSystemInfo* al::getGraphicsSystemInfo(const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

agl::DrawContext* al::getDrawContext(const ActorInitInfo& initInfo)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::getActorRecourseDataF32(f32* val, LiveActor* actor, const char* fileName, const char* entryName)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::getActorRecourseDataString(const char** val, LiveActor* actor, const char* fileName, const char* entryName)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::getActorRecourseDataV3f(sead::Vector3f* val, LiveActor* actor, const char* fileName, const char* entryName)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::getActorRecourseDataBox3f(sead::BoundBox3f* box, LiveActor* actor, const char* fileName, const char* entryName)

#include <l/Library/LiveActor/ActorInitUtil.h>

PartsEffectGroup* al::createPartsEffectGroup(LiveActor* actor, const ActorInitInfo& initInfo, s32 maxEffects)

#include <l/Library/LiveActor/ActorInitUtil.h>

void al::updateMaterialCodeGround(LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::updateMaterialCodeAll(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::updateMaterialCodeArea(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::updateMaterialCodeWet(LiveActor* actor, bool)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::updateMaterialCodeWater(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::updateMaterialCodeWater(LiveActor* actor, bool)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::updateMaterialCodePuddle(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::updateMaterialCodePuddle(LiveActor* actor, bool)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::resetMaterialCode(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::showModel(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::showModelIfHide(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isHideModel(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::hideModel(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::hideModelIfShow(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isExistModel(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::switchShowHideModelIfNearCamera(LiveActor* actor, f32)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::blinkModel(LiveActor* actor, s32, s32, s32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcViewModelSystem(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcViewModel(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::showSilhouetteModel(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::hideSilhouetteModel(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isSilhouetteModelHidden(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::showSilhouetteModelIfHide(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::hideSilhouetteModelIfShow(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setModelAlphaMask(LiveActor* actor, f32)

#include <l/Library/LiveActor/ActorModelFunction.h>

f32 al::getModelAlphaMask(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isModelAlphaMask(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::updateModelAlphaMaskCameraDistance(LiveActor* actor, f32, f32, f32, f32)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isExistZPrePass(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isEnableZPrePass(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::validateZPrePass(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::invalidateZPrePass(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::invalidateOcclusionQuery(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::validateOcclusionQuery(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isValidOcclusionQuery(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setFixedModelFlag(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::tryInitFixedModelGpuBuffer(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setIgnoreUpdateDrawClipping(LiveActor* actor, bool value)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setNeedSetBaseMtxAndCalcAnimFlag(LiveActor* actor, bool value)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isViewDependentModel(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isNeedUpdateModel(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setEnvTextureMirror(LiveActor* actor, s32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setEnvTextureProc3D(LiveActor* actor, s32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::forceApplyCubeMap(LiveActor* actor, const char* cubeMapName)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setMaterialProgrammable(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isIncludePrepassCullingShape(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isExistJoint(const LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

s32 al::getJointIndex(const LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

sead::Matrix34f* al::getJointMtxPtr(const LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

sead::Matrix34f* al::getJointMtxPtrByIndex(const LiveActor* actor, s32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::getJointLocalTrans(sead::Vector3f*, const LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcJointPos(sead::Vector3f*, const LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcJointOffsetPos(sead::Vector3f*, const LiveActor* actor, const char*, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcJointPosByIndex(sead::Vector3f*, const LiveActor* actor, s32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcJointSideDir(sead::Vector3f*, const LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcJointUpDir(sead::Vector3f*, const LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcJointFrontDir(sead::Vector3f*, const LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcJointScale(sead::Vector3f*, const LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcJointQuat(sead::Quatf*, const LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::multVecJointMtx(sead::Vector3f*, const sead::Vector3f&, const LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::multVecJointInvMtx(sead::Vector3f*, const sead::Vector3f&, const LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::multMtxJointInvMtx(sead::Matrix34f*, const sead::Matrix34f&, const LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setJointVisibility(LiveActor* actor, const char*, bool)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isJointVisibility(const LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isFaceJointXDirDegreeYZ(const LiveActor* actor, const char*, const sead::Vector3f&, f32, f32)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isFaceJointYDirDegreeZX(const LiveActor* actor, const char*, const sead::Vector3f&, f32, f32)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isFaceJointZDirDegreeXY(const LiveActor* actor, const char*, const sead::Vector3f&, f32, f32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcJointAngleXDirToTargetOnYDir(const LiveActor* actor, const char*, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcJointAngleXDirToTargetOnZDir(const LiveActor* actor, const char*, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcJointAngleYDirToTargetOnXDir(const LiveActor* actor, const char*, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcJointAngleYDirToTargetOnZDir(const LiveActor* actor, const char*, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcJointAngleZDirToTargetOnXDir(const LiveActor* actor, const char*, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcJointAngleZDirToTargetOnYDir(const LiveActor* actor, const char*, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

const char* al::getMaterialName(const LiveActor* actor, s32)

#include <l/Library/LiveActor/ActorModelFunction.h>

s32 al::getMaterialCount(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isExistMaterial(const LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::getMaterialObj(const LiveActor* actor, s32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::getMaterialObj(const LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

s32 al::getMaterialIndex(const LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isExistMaterialTexture(const LiveActor* actor, const char*, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::getMaterialCategory(const LiveActor* actor, s32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::tryGetMaterialCategory(const LiveActor* actor, s32)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isOnlyMaterialCategoryObject(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::showMaterial(LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::hideMaterial(LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::showMaterial(LiveActor* actor, s32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::hideMaterial(LiveActor* actor, s32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::showMaterialAll(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::tryShowMaterial(LiveActor* actor, s32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::tryHideMaterial(LiveActor* actor, s32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::tryShowMaterialAll(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setModelMaterialParameterF32(const LiveActor* actor, s32, const char*, f32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setModelMaterialParameterF32(const LiveActor* actor, const char*, const char*, f32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setModelMaterialParameterV2F(const LiveActor* actor, s32, const char*, const sead::Vector2f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setModelMaterialParameterV2F(const LiveActor* actor, const char*, const char*, const sead::Vector2f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setModelMaterialParameterV3F(const LiveActor* actor, s32, const char*, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setModelMaterialParameterV3F(const LiveActor* actor, const char*, const char*, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setModelMaterialParameterV4F(const LiveActor* actor, s32, const char*, const sead::Vector4f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setModelMaterialParameterV4F(const LiveActor* actor, const char*, const char*, const sead::Vector4f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setModelMaterialParameterRgb(const LiveActor* actor, s32, const char*, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setModelMaterialParameterRgb(const LiveActor* actor, const char*, const char*, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setModelMaterialParameterRgb(const LiveActor* actor, s32, const char*, const sead::Color4f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setModelMaterialParameterRgb(const LiveActor* actor, const char*, const char*, const sead::Color4f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setModelMaterialParameterRgba(const LiveActor* actor, s32, const char*, const sead::Color4f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setModelMaterialParameterRgba(const LiveActor* actor, const char*, const char*, const sead::Color4f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setModelMaterialParameterAlpha(const LiveActor* actor, s32, const char*, f32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setModelMaterialParameterAlpha(const LiveActor* actor, const char*, const char*, f32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setModelMaterialParameterTextureTrans(const LiveActor* actor, const char*, s32, const sead::Vector2f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::getModelMaterialParameterDisplacementScale(const LiveActor* actor, const char*, s32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setModelMaterialParameterDisplacementScale(const LiveActor* actor, const char*, s32, f32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::getModelUniformBlock(const LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::findModelUniformBlock(const LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::swapModelUniformBlock(agl::UniformBlock*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::flushModelUniformBlock(agl::UniformBlock*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::getModelDrawCategoryFromShaderAssign(bool*, bool*, bool*, bool*, const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::trySetOcclusionQueryBox(LiveActor* actor, f32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::trySetOcclusionQueryBox(LiveActor* actor, const sead::BoundBox3f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::trySetOcclusionQueryCenter(LiveActor* actor, const sead::Vector3f*)

#include <l/Library/LiveActor/ActorModelFunction.h>

const char* al::getModelName(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isModelName(const LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

f32 al::calcModelBoundingSphereRadius(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::getBoundingSphereCenterAndRadius(sead::Vector3f*, f32*, const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcModelBoundingBox(sead::BoundBox3f*, const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcModelBoundingBoxMtx(sead::Matrix34f*, const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::submitViewModel(const LiveActor* actor, const sead::Matrix34f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::replaceMaterialTextureRef(LiveActor* actor, nn::g3d::TextureRef*, const char*, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::replaceMaterialResTexture(LiveActor* actor, nn::gfx::ResTexture*, const char*, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::replaceMaterialResTexture(LiveActor*, const char*, const char*, nn::gfx::DescriptorSlot, const nn::gfx::TextureView*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::replaceMaterialLayoutTexture(LiveActor* actor, const LayoutTextureRenderObj*, const char*, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::recreateModelDisplayList(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcPolygonNum(const LiveActor* actor, s32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcPolygonNumCurrentLod(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcPolygonNumCurrentLodWithoutVisAnim(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::getLodLevel(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::getMaterialLodLevel(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::getLodLevelNoClamp(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

s32 al::getLodModelCount(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::forceLodLevel(LiveActor* actor, s32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::unforceLodLevel(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isExistLodModel(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isEnableMaterialLod(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::validateLodModel(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::invalidateLodModel(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isValidateLodModel(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isExistDitherAnimator(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isValidNearDitherAnim(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::stopDitherAnimAutoCtrl(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::restartDitherAnimAutoCtrl(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::validateDitherAnim(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::invalidateDitherAnim(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::validateFarDitherIfInvalidateClipping(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setDitherAnimSphereRadius(LiveActor* actor, f32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setDitherAnimBoundingBox(LiveActor* actor, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setDitherAnimMaxAlpha(LiveActor* actor, f32)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setDitherAnimClippingJudgeLocalOffset(LiveActor* actor, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::setDitherAnimClippingJudgeParam(LiveActor* actor, const char*)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::resetDitherAnimClippingJudgeParam(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::getDitherAnimMinNearDitherAlpha(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

f32 al::getDitherAnimNearClipStartDistance(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

f32 al::getDitherAnimNearClipEndDistance(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::calcDitherAnimJudgeDistance(const LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

void al::createUniqueShader(LiveActor* actor)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isJudgedToClipFrustum(const ClippingDirector*, const sead::Vector3f&, f32, f32)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isJudgedToClipFrustum(const LiveActor* actor, const sead::Vector3f&, f32, f32)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isJudgedToClipFrustum(const LiveActor* actor, f32, f32)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isJudgedToClipFrustumWithoutFar(const ClippingDirector*, const sead::Vector3f&, f32, f32)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isJudgedToClipFrustumWithoutFar(const LiveActor* actor, const sead::Vector3f&, f32, f32)

#include <l/Library/LiveActor/ActorModelFunction.h>

bool al::isJudgedToClipFrustumWithoutFar(const LiveActor* actor, f32, f32)

#include <l/Library/LiveActor/ActorModelFunction.h>

f32 al::modDegree(f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.cpp>

void al::resetPosition(LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::resetPosition(LiveActor* actor, const sead::Vector3f& trans)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::resetRotatePosition(LiveActor* actor, const sead::Vector3f& rot, const sead::Vector3f& trans)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::resetQuatPosition(LiveActor* actor, const sead::Quatf& quat, const sead::Vector3f& trans)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::resetMtxPosition(LiveActor* actor, const sead::Matrix34f& mtx)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::resetActorPosition(LiveActor* actor, const LiveActor* target)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::trySetPosOnGround(LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

const sead::Vector3f& al::getVelocity(const LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

sead::Vector3f* al::getVelocityPtr(LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::separateVelocityHV(sead::Vector3f* horizontal, sead::Vector3f* vertical, const LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::separateVelocityDirHV(sead::Vector3f* horizontal, sead::Vector3f* vertical, const LiveActor* actor, const sead::Vector3f& dir)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::separateVelocityParallelVertical(sead::Vector3f* parallel, sead::Vector3f* vertical, const LiveActor* actor, const sead::Vector3f& dir)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocity(LiveActor* actor, const sead::Vector3f& vel)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocity(LiveActor* actor, f32 x, f32 y, f32 z)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityX(LiveActor* actor, f32 x)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityY(LiveActor* actor, f32 y)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityZ(LiveActor* actor, f32 z)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityZero(LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityZeroX(LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityZeroY(LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityZeroZ(LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityZeroH(LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityZeroH(LiveActor* actor, const sead::Vector3f& gravity)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityZeroV(LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityZeroV(LiveActor* actor, const sead::Vector3f& gravity)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityJump(LiveActor* actor, f32 speed)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityToFront(LiveActor* actor, f32 speed)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityToUp(LiveActor* actor, f32 speed)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityToSide(LiveActor* actor, f32 speed)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityToDirection(LiveActor* actor, const sead::Vector3f& dir, f32 speed)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityToGravity(LiveActor* actor, f32 speed)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocitySeparateHV(LiveActor* actor, const sead::Vector3f& h, const sead::Vector3f& v, f32 speedH, f32 speedV)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocitySeparateHV(LiveActor* actor, const sead::Vector3f& h, f32 speedH, f32 speedV)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::calcVelocitySeparateHV(sead::Vector3f* velocity, const LiveActor* actor, const sead::Vector3f& h, f32 speedH, f32 speedV)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocitySeparateUp(LiveActor* actor, const sead::Vector3f& h, f32 speedH, f32 speedV)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityOnlyDir(LiveActor* actor, const sead::Vector3f& dir, f32 speed)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityOnlyV(LiveActor* actor, f32 speed)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityOnlyGravity(LiveActor* actor, f32 speed)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocity(LiveActor* actor, const sead::Vector3f& vel)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocity(LiveActor* actor, f32 x, f32 y, f32 z)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityX(LiveActor* actor, f32 x)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityY(LiveActor* actor, f32 y)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityZ(LiveActor* actor, f32 z)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityDump(LiveActor* actor, const sead::Vector3f& dir, f32 force)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityJump(LiveActor* actor, f32 force)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityInline(LiveActor* actor, const sead::Vector3f& vel, f32 force)

#include <l/Library/LiveActor/ActorMovementFunction.cpp>

void al::addVelocityToFront(LiveActor* actor, f32 force)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityToUp(LiveActor* actor, f32 force)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityToSide(LiveActor* actor, f32 force)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityToDown(LiveActor* actor, f32 force)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityToDirection(LiveActor* actor, const sead::Vector3f& dir, f32 force)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityToGravity(LiveActor* actor, f32 force)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityToGravityLimit(LiveActor* actor, f32 force, f32 limit)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityToGravityFittedGround(LiveActor* actor, f32 force, u32 maxAirTime)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityToGravityNaturalOrFittedGround(LiveActor* actor, f32 force)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::calcGravityDir(sead::Vector3f* gravity, const LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityToTarget(LiveActor* actor, const sead::Vector3f& target, f32 force)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityToTarget(LiveActor* actor, const sead::Vector3f& target, f32 minForce, f32 maxForce, f32 minDistance, f32 maxDistance)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityToTargetH(LiveActor* actor, const sead::Vector3f& target, f32 force)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityToTargetHV(LiveActor* actor, const sead::Vector3f& target, f32 forceH, f32 forceV)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityDampToTarget(LiveActor* actor, const sead::Vector3f& target, f32 forceDamp)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityDampToTarget(LiveActor* actor, const sead::Vector3f& target, f32 force, f32 damp)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::addVelocityToPlayer(LiveActor* actor, f32 force, const sead::Vector3f& offset)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::addVelocityToPlayerHV(LiveActor* actor, f32 forceH, f32 forceV, const sead::Vector3f& offset)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityFromTarget(LiveActor* actor, const sead::Vector3f& target, f32 force)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityFromTargetHV(LiveActor* actor, const sead::Vector3f& target, f32 forceH, f32 forceV)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::addVelocityFromPlayer(LiveActor* actor, f32 force, const sead::Vector3f& offset)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::addVelocityFromPlayerHV(LiveActor* actor, f32 forceH, f32 forceV, const sead::Vector3f& offset)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityClockwiseToDirection(LiveActor* actor, const sead::Vector3f& dir, f32 force)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::calcVelocityClockwiseToDirection(LiveActor* actor, sead::Vector3f* dirVelocity, const sead::Vector3f& dir)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityClockwiseToTarget(LiveActor* actor, const sead::Vector3f& target, f32 force)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityJumpGroundInertia(LiveActor* actor, const sead::Vector3f& velocity, f32 force)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::tryAddVelocityLimit(LiveActor* actor, const sead::Vector3f& velocity, f32 limit)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::subVelocityExceptDirectionLimit(LiveActor* actor, const sead::Vector3f& direction, f32 subVel, f32 limit)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::scaleVelocity(LiveActor* actor, f32 factor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::scaleVelocityLimit(LiveActor* actor, f32 factor, f32 limit)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::scaleVelocityX(LiveActor* actor, f32 factorX)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::scaleVelocityY(LiveActor* actor, f32 factorY)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::scaleVelocityZ(LiveActor* actor, f32 factorZ)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::scaleVelocityHV(LiveActor* actor, f32 factorH, f32 factorV)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::scaleVelocityDirection(LiveActor* actor, const sead::Vector3f& direction, f32 factor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::scaleVelocityExceptDirection(LiveActor* actor, const sead::Vector3f& direction, f32 factor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::scaleVelocityParallelVertical(LiveActor* actor, const sead::Vector3f& direction, f32 parallel, f32 vertical)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::limitVelocity(LiveActor* actor, f32 limit)

#include <l/Library/LiveActor/ActorMovementFunction.h>

f32 al::calcSpeed(const LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::limitVelocityX(LiveActor* actor, f32 limitX)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::limitVelocityY(LiveActor* actor, f32 limitY)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::limitVelocityZ(LiveActor* actor, f32 limitZ)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::limitVelocityH(LiveActor* actor, f32 limitH)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::limitVelocityHV(LiveActor* actor, f32 limitH, f32 limitV)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::limitVelocityUpGravityH(LiveActor* actor, f32 limitDown, f32 limitUp, f32 limitH)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::limitVelocityDir(LiveActor* actor, const sead::Vector3f& dir, f32 limit)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::limitVelocityDirSign(LiveActor* actor, const sead::Vector3f& dir, f32 limit)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::limitVelocityDirV(LiveActor* actor, const sead::Vector3f& dir, f32 limit)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::limitVelocityDirVRate(LiveActor* actor, const sead::Vector3f& dir, f32 limit, f32 rate)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::limitVelocityParallelVertical(LiveActor* actor, const sead::Vector3f& dir, f32 parallel, f32 vertical)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::limitVelocitySeparateHV(LiveActor* actor, const sead::Vector3f& dir, f32 horizontal, f32 vertical)

#include <l/Library/LiveActor/ActorMovementFunction.h>

u32 al::reboundVelocityPart(LiveActor* actor, f32 rebound, f32 threshold)

#include <l/Library/LiveActor/ActorMovementFunction.h>

u32 al::reboundVelocityPart(LiveActor* actor, f32 ground, f32 wall, f32 ceiling, f32 threshold)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::reboundVelocityFromEachCollision(LiveActor* actor, f32 ground, f32 wall, f32 ceiling, f32 threshold)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::reboundVelocityFromCollision(LiveActor* actor, f32 reboundStrength, f32 reboundMin, f32 friction)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::reboundVelocityFromTriangles(LiveActor* actor, f32 reboundStrength, f32 reboundMin)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::reboundVelocityFromActor(LiveActor* actor, const LiveActor* target, f32 reboundStrength)

#include <l/Library/LiveActor/ActorMovementFunction.h>

al::if(dot<=0. 0f) return false

#include <l/Library/LiveActor/ActorMovementFunction.cpp>

al::addVelocity(actor, direction*dot*-reboundStrength+1.0f)

#include <l/Library/LiveActor/ActorMovementFunction.cpp>

bool al::reboundVelocityFromActor(LiveActor* actor, const LiveActor* target, const sead::Vector3f& targetVelocity, f32 reboundStrength)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::reboundVelocityFromSensor(LiveActor* actor, const HitSensor* sensor, f32 reboundStrength)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::reboundVelocityFromSensor(LiveActor* actor, const HitSensor* sensor, const sead::Vector3f& targetVelocity, f32 reboundStrength)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::calcDirToActor(sead::Vector3f* dir, const LiveActor* actor, const LiveActor* target)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::reboundVelocityBetweenActor(LiveActor* actor, LiveActor* target, const sead::Vector3f& direction, f32 reboundStrength)

#include <l/Library/LiveActor/ActorMovementFunction.cpp>

bool al::reboundVelocityBetweenActor(LiveActor* actor, LiveActor* target, f32 reboundStrength)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::reboundVelocityBetweenSensor(HitSensor* sensorA, HitSensor* sensorB, f32 reboundStrength)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::calcVelocityKeepLengthBetweenActor(sead::Vector3f* vel, const LiveActor* actor, const LiveActor* target, f32 targetLength, f32 force)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityKeepLengthBetweenActor(LiveActor* actor, LiveActor* target, f32 targetLength, f32 force)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityDumpKeepLengthBetweenActor(LiveActor* actor, LiveActor* target, f32 targetLength, f32 lenForce, f32 dumpForce)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::calcVelocityBlowAttack(sead::Vector3f* velocity, const LiveActor* actor, const sead::Vector3f& trans, f32 speedH, f32 speedV)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityBlowAttack(LiveActor* actor, const sead::Vector3f& trans, f32 speedH, f32 speedV)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addVelocityBlowAttack(LiveActor* actor, const HitSensor* sensor, f32 speedH, f32 speedV)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityBlowAttack(LiveActor* actor, const sead::Vector3f& trans, f32 speedH, f32 speedV)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityBlowAttack(LiveActor* actor, const HitSensor* sensor, f32 speedH, f32 speedV)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setVelocityBlowAttackAndTurnToTarget(LiveActor* actor, const sead::Vector3f& target, f32 speedH, f32 speedV)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isVelocityFast(const LiveActor* actor, f32 threshold)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isVelocityFastH(const LiveActor* actor, f32 threshold)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isVelocitySlow(const LiveActor* actor, f32 threshold)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isVelocitySlowH(const LiveActor* actor, f32 threshold)

#include <l/Library/LiveActor/ActorMovementFunction.h>

f32 al::calcSpeedH(const LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

f32 al::calcSpeedV(const LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

f32 al::calcSpeedDirection(const LiveActor* actor, const sead::Vector3f& dir)

#include <l/Library/LiveActor/ActorMovementFunction.h>

f32 al::calcSpeedExceptDir(const LiveActor* actor, const sead::Vector3f& dir)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isNear(const LiveActor* actor, const LiveActor* target, f32 threshold)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isNear(const LiveActor* actor, const sead::Vector3f& trans, f32 threshold)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isNearXZ(const LiveActor* actor, const sead::Vector3f& trans, f32 threshold)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isNearH(const LiveActor* actor, const sead::Vector3f& trans, f32 threshold)

#include <l/Library/LiveActor/ActorMovementFunction.h>

f32 al::calcDistanceH(const LiveActor* actor, const sead::Vector3f& trans)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isNearV(const LiveActor* actor, const sead::Vector3f& trans, f32 threshold)

#include <l/Library/LiveActor/ActorMovementFunction.h>

f32 al::calcDistanceV(const LiveActor* actor, const sead::Vector3f& trans)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isNearHV(const LiveActor* actor, const sead::Vector3f& trans, f32 threshH, f32 threshV)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isNearHV(const LiveActor* actor, const sead::Vector3f& trans, f32 threshH, f32 minV, f32 maxV)

#include <l/Library/LiveActor/ActorMovementFunction.h>

f32 al::calcHeight(const LiveActor* actor, const sead::Vector3f& trans)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isFar(const LiveActor* actor, const LiveActor* target, f32 threshold)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isFar(const LiveActor* actor, const sead::Vector3f& trans, f32 threshold)

#include <l/Library/LiveActor/ActorMovementFunction.h>

f32 al::calcDistance(const LiveActor* actor, const LiveActor* target)

#include <l/Library/LiveActor/ActorMovementFunction.h>

f32 al::calcDistance(const LiveActor* actor, const sead::Vector3f& trans)

#include <l/Library/LiveActor/ActorMovementFunction.h>

f32 al::calcDistanceV(const LiveActor* actor, const LiveActor* target)

#include <l/Library/LiveActor/ActorMovementFunction.h>

f32 al::calcDistanceH(const LiveActor* actor, const LiveActor* target)

#include <l/Library/LiveActor/ActorMovementFunction.h>

f32 al::calcDistanceH(const LiveActor* actor, const sead::Vector3f& trans1, const sead::Vector3f& trans2)

#include <l/Library/LiveActor/ActorMovementFunction.h>

f32 al::calcHeight(const LiveActor* actor, const LiveActor* target)

#include <l/Library/LiveActor/ActorMovementFunction.h>

f32 al::calcDistanceFront(const LiveActor* actor, const sead::Vector3f& trans)

#include <l/Library/LiveActor/ActorMovementFunction.h>

f32 al::calcDistanceFront(const LiveActor* actor, const LiveActor* target)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addRotateAndRepeatX(LiveActor* actor, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addRotateAndRepeatY(LiveActor* actor, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addRotateAndRepeatZ(LiveActor* actor, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addRandomRotateY(LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::calcQuatSide(sead::Vector3f* side, const LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::calcQuatUp(sead::Vector3f* up, const LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::calcQuatFront(sead::Vector3f* front, const LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::calcQuatLocalAxis(sead::Vector3f* local, const LiveActor* actor, s32 axis)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::calcTransOffsetFront(sead::Vector3f* offset, const LiveActor* actor, f32 len)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::calcTransOffsetUp(sead::Vector3f* offset, const LiveActor* actor, f32 len)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::calcTransOffsetSide(sead::Vector3f* offset, const LiveActor* actor, f32 len)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::setTransOffsetLocalDir(LiveActor* actor, const sead::Quatf& quat, const sead::Vector3f& globalOffset, f32 localOffset, s32 axis)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addTransOffsetLocal(LiveActor* actor, const sead::Vector3f& localOffset)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::addTransOffsetLocalDir(LiveActor* actor, f32 localOffset, s32 axis)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::rotateQuatXDirDegree(LiveActor* actor, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::rotateQuatXDirDegree(LiveActor* actor, const sead::Quatf& quat, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::rotateQuatYDirDegree(LiveActor* actor, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::rotateQuatYDirDegree(LiveActor* actor, const sead::Quatf& quat, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::rotateQuatZDirDegree(LiveActor* actor, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::rotateQuatZDirDegree(LiveActor* actor, const sead::Quatf& quat, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::rotateQuatLocalDirDegree(LiveActor* actor, s32 axis, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::rotateQuatLocalDirDegree(LiveActor* actor, const sead::Quatf& quat, s32 axis, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::rotateQuatYDirRandomDegree(LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::rotateQuatYDirRandomDegree(LiveActor* actor, const sead::Quatf& quat)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::turnQuatFrontToDirDegreeH(LiveActor* actor, const sead::Vector3f& dir, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::turnQuatFrontToPosDegreeH(LiveActor* actor, const sead::Vector3f& pos, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::turnQuatFrontFromPosDegreeH(LiveActor* actor, const sead::Vector3f& pos, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::turnFront(LiveActor* actor, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::turnFront(LiveActor* actor, const sead::Vector3f& up, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::turnFrontToPos(LiveActor* actor, const sead::Vector3f& pos, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::turnFrontToDir(LiveActor* actor, const sead::Vector3f& dir, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::turnFrontToDirGetIsFinished(LiveActor* actor, const sead::Vector3f& dir, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::turnDirectionDegree(const LiveActor* actor, sead::Vector3f* vec, const sead::Vector3f& dir, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::turnFrontToTarget(LiveActor* actor, const LiveActor* target, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::turnFrontFromTarget(LiveActor* actor, const LiveActor* target, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::turnFrontToPlayer(LiveActor* actor, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::turnFrontFromPlayer(LiveActor* actor, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::turnDirection(const LiveActor* actor, sead::Vector3f* vec, const sead::Vector3f& dir, f32 cos)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::turnDirectionToTarget(const LiveActor* actor, sead::Vector3f* vec, const sead::Vector3f& target, f32 cos)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::turnDirectionToTargetDegree(const LiveActor* actor, sead::Vector3f* vec, const sead::Vector3f& target, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::turnDirectionFromTargetDegree(const LiveActor* actor, sead::Vector3f* vec, const sead::Vector3f& target, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::turnDirectionAlongGround(const LiveActor* actor, sead::Vector3f* dir)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::turnDirectionAlongGround(LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::turnToDirectionAxis(LiveActor* actor, const sead::Vector3f& horizontal, const sead::Vector3f& vertical, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::turnFrontSpherical(const LiveActor* actor, sead::Vector3f* vec, const sead::Vector3f& targetFront, f32 cos)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::turnFrontSphericalToTarget(const LiveActor* actor, sead::Vector3f* vec, const sead::Vector3f& target, f32 cos)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::turnFrontSphericalToTargetDegree(const LiveActor* actor, sead::Vector3f* vec, const sead::Vector3f& target, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::turnToDirection(LiveActor* actor, const sead::Vector3f& dir, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::turnLocalDirToDirection(LiveActor* actor, const sead::Vector3f& localDir, const sead::Vector3f& targetDir, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::turnToTarget(LiveActor* actor, const sead::Vector3f& target, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::turnToTarget(LiveActor* actor, const LiveActor* target, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::faceToDirection(LiveActor* actor, const sead::Vector3f& dir)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::faceToDirectionSupportUp(LiveActor* actor, const sead::Vector3f& dir)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::faceToTarget(LiveActor* actor, const sead::Vector3f& target)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::faceToTarget(LiveActor* actor, const LiveActor* target)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::faceToSensor(LiveActor* actor, const HitSensor* sensor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::faceToVelocity(LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::calcDirClockwiseToDir(sead::Vector3f* out, const LiveActor* actor, const sead::Vector3f& dir)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::calcDirClockwiseToPos(sead::Vector3f* out, const LiveActor* actor, const sead::Vector3f& target)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::calcDirToActorH(sead::Vector3f* out, const LiveActor* actor, const LiveActor* target)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::calcDirToActorH(sead::Vector3f* out, const LiveActor* actor, const sead::Vector3f& target)

#include <l/Library/LiveActor/ActorMovementFunction.h>

f32 al::calcAngleToTargetH(const LiveActor* actor, const sead::Vector3f& target)

#include <l/Library/LiveActor/ActorMovementFunction.h>

f32 al::calcAngleToTargetV(const LiveActor* actor, const sead::Vector3f& target)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isFaceToTargetDegree(const LiveActor* actor, const sead::Vector3f& target, const sead::Vector3f& face, f32 threshDeg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isFaceToTargetDegree(const LiveActor* actor, const sead::Vector3f& target, f32 threshDeg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isFaceToTargetDegreeHV(const LiveActor* actor, const sead::Vector3f& target, const sead::Vector3f& face, f32 degH, f32 degV)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isFaceToTargetDegreeH(const LiveActor* actor, const sead::Vector3f& target, const sead::Vector3f& face, f32 degH)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isInSightCone(const LiveActor* actor, const sead::Vector3f& target, const sead::Vector3f& face, f32 maxDist, f32 threshDeg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isInSightConeTarget(const LiveActor* actor, const LiveActor* target, f32 maxDist, f32 threshDeg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isInSightConePlayer(const LiveActor* actor, f32 maxDist, f32 threshDeg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isInSightFan(const LiveActor* actor, const sead::Vector3f& target, const sead::Vector3f& face, f32 maxDist, f32 angleH, f32 angleV)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isInSightFanTarget(const LiveActor* actor, const LiveActor* target, f32 maxDist, f32 angleH, f32 angleV)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isInSightBox(const LiveActor* actor, const sead::Vector3f& pos, const sead::BoundBox3f& box)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::walkAndTurnToDirection(LiveActor* actor, const sead::Vector3f& dir, f32 forceFront, f32 forceGravity, f32 decay, f32 deg, bool turnAlongGround)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::walkAndTurnToDirection(LiveActor* actor, sead::Vector3f* front, const sead::Vector3f& dir, f32 forceFront, f32 forceGravity, f32 decay, f32 deg, bool turnAlongGround)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::walkAndTurnPoseToDirection(LiveActor* actor, const sead::Vector3f& dir, const ActorParamMove& param, bool turnAlongGround)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::walkAndTurnToTarget(LiveActor* actor, const sead::Vector3f& target, f32 forceFront, f32 forceGravity, f32 decay, f32 deg, bool turnAlongGround)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::flyAndTurnToDirection(LiveActor* actor, sead::Vector3f* front, const sead::Vector3f& dir, f32 forceFront, f32 forceGravity, f32 decay, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::flyAndTurnToDirection(LiveActor* actor, const sead::Vector3f& dir, f32 forceFront, f32 forceGravity, f32 decay, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::flyAndTurnToTarget(LiveActor* actor, const sead::Vector3f& target, f32 forceFront, f32 forceGravity, f32 decay, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::walkAndTurnToDirectionFittedGroundGravity(LiveActor* actor, sead::Vector3f* front, const sead::Vector3f& dir, f32 forceFront, f32 forceGravity, f32 decay, f32 deg, bool turnAlongGround)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::walkAndTurnToDirectionFittedGroundGravity(LiveActor* actor, const sead::Vector3f& dir, f32 forceFront, f32 forceGravity, f32 decay, f32 deg, bool turnAlongGround)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::walkAndTurnToTargetFittedGroundGravity(LiveActor* actor, const sead::Vector3f& target, f32 forceFront, f32 forceGravity, f32 decay, f32 deg, bool turnAlongGround)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::tryKillByDeathArea(LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::rotateAndKeepColliderPosRate(LiveActor* actor, const sead::Vector3f& up, const sead::Vector3f& front, f32 rate)

#include <l/Library/LiveActor/ActorMovementFunction.h>

void al::calcSpringMovement(LiveActor* actor, const sead::Vector3f& pos, f32 springPos, f32 sinStrength, const sead::Vector3f& offset, f32 constStrength, f32 sinAmpl)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::addVelocityClockwiseToPlayer(LiveActor* actor, f32 force)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::calcDirClockwiseToPlayer(sead::Vector3f* dir, const LiveActor* actor)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::flyAndTurnToPlayer(LiveActor* actor, const ActorParamMove& param)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::escapeFromPlayer(LiveActor* actor, f32 forceFront, f32 forceGravity, f32 decay, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::escapeFromPlayer(LiveActor* actor, sead::Vector3f* front, f32 forceFront, f32 forceGravity, f32 decay, f32 deg)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::walkAndTurnToPlayer(LiveActor* actor, f32 forceFront, f32 forceGravity, f32 decay, f32 deg, bool turnAlongGround)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isPlayerInSightFan(const LiveActor* actor, f32 maxDist, f32 angleH, f32 angleV)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::nextMove(Triangle* triangle, const LiveActor* actor, const sead::Vector3f& velocity, f32 gravity, f32 searchDist)

#include <l/Library/LiveActor/ActorMovementFunction.cpp>

bool al::isFallOrDamageCodeNextMove(const LiveActor* actor, const sead::Vector3f& velocity, f32 gravity, f32 searchDist)

#include <l/Library/LiveActor/ActorMovementFunction.h>

bool al::isFallNextMove(const LiveActor* actor, const sead::Vector3f& velocity, f32 gravity, f32 searchDist)

#include <l/Library/LiveActor/ActorMovementFunction.h>

f32* al::findActorParamF32(const LiveActor* actor, const char* paramName)

#include <l/Library/LiveActor/ActorParamHolder.h>

s32* al::findActorParamS32(const LiveActor* actor, const char* paramName)

#include <l/Library/LiveActor/ActorParamHolder.h>

static void al::rotationAndTranslationFromMatrix(sead::Vector3f* trans, sead::Vector3f* rot, const sead::Matrix34f* mtx)

#include <l/Library/LiveActor/ActorPoseKeeper.cpp>

void al::initActorPoseT(LiveActor* actor, const sead::Vector3f& trans)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::setTrans(LiveActor* actor, const sead::Vector3f& trans)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::initActorPoseTR(LiveActor* actor, const sead::Vector3f& trans, const sead::Vector3f& rotate)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::setRotate(LiveActor* actor, const sead::Vector3f& rotate)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::makeMtxSRT(sead::Matrix34f* mtx, const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::makeMtxRT(sead::Matrix34f* mtx, const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::makeMtxR(sead::Matrix34f* mtx, const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::calcAnimFrontGravityPos(LiveActor* actor, const sead::Vector3f& front)

#include <l/Library/LiveActor/ActorPoseUtil.h>

const sead::Vector3f& al::getGravity(const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

const sead::Vector3f& al::getTrans(const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

const sead::Vector3f& al::getScale(const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::copyPose(LiveActor* actor, const LiveActor* target)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::updatePoseTrans(LiveActor* actor, const sead::Vector3f& trans)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::updatePoseRotate(LiveActor* actor, const sead::Vector3f& rotate)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::updatePoseQuat(LiveActor* actor, const sead::Quatf& quat)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::updatePoseMtx(LiveActor* actor, const sead::Matrix34f* mtx)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::calcSideDir(sead::Vector3f* side, const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::calcLeftDir(sead::Vector3f* left, const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::calcRightDir(sead::Vector3f* right, const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::calcUpDir(sead::Vector3f* up, const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::calcDownDir(sead::Vector3f* down, const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::calcFrontDir(sead::Vector3f* front, const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::calcBackDir(sead::Vector3f* back, const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::calcPoseDir(sead::Vector3f* side, sead::Vector3f* up, sead::Vector3f* front, const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::calcQuat(sead::Quatf* quat, const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

f32 al::calcDistanceSignLocalXDir(const LiveActor* actor, const sead::Vector3f& pos)

#include <l/Library/LiveActor/ActorPoseUtil.h>

f32 al::calcDistanceSignLocalYDir(const LiveActor* actor, const sead::Vector3f& pos)

#include <l/Library/LiveActor/ActorPoseUtil.h>

f32 al::calcDistanceSignLocalZDir(const LiveActor* actor, const sead::Vector3f& pos)

#include <l/Library/LiveActor/ActorPoseUtil.h>

f32 al::calcDistanceLocalXDir(const LiveActor* actor, const sead::Vector3f& pos)

#include <l/Library/LiveActor/ActorPoseUtil.h>

f32 al::calcDistanceLocalYDir(const LiveActor* actor, const sead::Vector3f& pos)

#include <l/Library/LiveActor/ActorPoseUtil.h>

f32 al::calcDistanceLocalZDir(const LiveActor* actor, const sead::Vector3f& pos)

#include <l/Library/LiveActor/ActorPoseUtil.h>

sead::Vector3f* al::getTransPtr(LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::setTrans(LiveActor* actor, f32 x, f32 y, f32 z)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::setTransX(LiveActor* actor, f32 x)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::setTransY(LiveActor* actor, f32 y)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::setTransZ(LiveActor* actor, f32 z)

#include <l/Library/LiveActor/ActorPoseUtil.h>

const sead::Vector3f& al::getRotate(const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

sead::Vector3f* al::getRotatePtr(LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::setRotate(LiveActor* actor, f32 x, f32 y, f32 z)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::setRotateX(LiveActor* actor, f32 x)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::setRotateY(LiveActor* actor, f32 y)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::setRotateZ(LiveActor* actor, f32 z)

#include <l/Library/LiveActor/ActorPoseUtil.h>

sead::Vector3f* al::getScalePtr(LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

sead::Vector3f* al::tryGetScalePtr(LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

f32 al::getScaleX(const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

f32 al::getScaleY(const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

f32 al::getScaleZ(const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::setScale(LiveActor* actor, const sead::Vector3f& scale)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::setScale(LiveActor* actor, f32 x, f32 y, f32 z)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::setScaleAll(LiveActor* actor, f32 scale)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::setScaleX(LiveActor* actor, f32 x)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::setScaleY(LiveActor* actor, f32 y)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::setScaleZ(LiveActor* actor, f32 z)

#include <l/Library/LiveActor/ActorPoseUtil.h>

bool al::isFrontTarget(const LiveActor* actor, const sead::Vector3f& pos)

#include <l/Library/LiveActor/ActorPoseUtil.h>

bool al::isFrontDir(const LiveActor* actor, const sead::Vector3f& dir)

#include <l/Library/LiveActor/ActorPoseUtil.h>

bool al::isBackTarget(const LiveActor* actor, const sead::Vector3f& pos)

#include <l/Library/LiveActor/ActorPoseUtil.h>

bool al::isBackDir(const LiveActor* actor, const sead::Vector3f& dir)

#include <l/Library/LiveActor/ActorPoseUtil.h>

bool al::isLeftTarget(const LiveActor* actor, const sead::Vector3f& pos)

#include <l/Library/LiveActor/ActorPoseUtil.h>

bool al::isLeftDir(const LiveActor* actor, const sead::Vector3f& dir)

#include <l/Library/LiveActor/ActorPoseUtil.h>

bool al::isRightTarget(const LiveActor* actor, const sead::Vector3f& pos)

#include <l/Library/LiveActor/ActorPoseUtil.h>

bool al::isRightDir(const LiveActor* actor, const sead::Vector3f& dir)

#include <l/Library/LiveActor/ActorPoseUtil.h>

bool al::isUpTarget(const LiveActor* actor, const sead::Vector3f& pos)

#include <l/Library/LiveActor/ActorPoseUtil.h>

bool al::isUpDir(const LiveActor* actor, const sead::Vector3f& dir)

#include <l/Library/LiveActor/ActorPoseUtil.h>

bool al::isDownTarget(const LiveActor* actor, const sead::Vector3f& pos)

#include <l/Library/LiveActor/ActorPoseUtil.h>

bool al::isDownDir(const LiveActor* actor, const sead::Vector3f& dir)

#include <l/Library/LiveActor/ActorPoseUtil.h>

const sead::Quatf& al::getQuat(const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

sead::Quatf* al::getQuatPtr(LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

sead::Quatf* al::tryGetQuatPtr(LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::setQuat(LiveActor* actor, const sead::Quatf& quat)

#include <l/Library/LiveActor/ActorPoseUtil.h>

sead::Vector3f* al::getGravityPtr(const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::setGravity(const LiveActor* actor, const sead::Vector3f& gravity)

#include <l/Library/LiveActor/ActorPoseUtil.h>

const sead::Vector3f& al::getFront(const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

sead::Vector3f* al::getFrontPtr(LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::setFront(LiveActor* actor, const sead::Vector3f& front)

#include <l/Library/LiveActor/ActorPoseUtil.h>

const sead::Vector3f& al::getUp(const LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

sead::Vector3f* al::getUpPtr(LiveActor* actor)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::setUp(LiveActor* actor, const sead::Vector3f& up)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::multVecPoseNoTrans(sead::Vector3f* posOut, const LiveActor* actor, const sead::Vector3f& posIn)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::multVecPose(sead::Vector3f* posOut, const LiveActor* actor, const sead::Vector3f& posIn)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::multVecPoseAndScale(sead::Vector3f* posOut, const LiveActor* actor, const sead::Vector3f& posIn)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::multVecInvPose(sead::Vector3f* posOut, const LiveActor* actor, const sead::Vector3f& posIn)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::multMtxInvPose(sead::Matrix34f* mtxOut, const LiveActor* actor, const sead::Matrix34f& mtxIn)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::calcTransLocalOffset(sead::Vector3f* transOut, const LiveActor* actor, const sead::Vector3f& transIn)

#include <l/Library/LiveActor/ActorPoseUtil.h>

void al::multVecInvQuat(sead::Vector3f* posOut, const LiveActor* actor, const sead::Vector3f& posIn)

#include <l/Library/LiveActor/ActorPoseUtil.h>

bool al::isExistModelResource(const LiveActor*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

bool al::isExistAnimResource(const LiveActor*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

void al::tryGetAnimResource(const LiveActor*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

bool al::isExistModelResourceYaml(const LiveActor*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

void al::getModelResource(const LiveActor*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

bool al::isExistAnimResourceYaml(const LiveActor*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

void al::getAnimResource(const LiveActor*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

bool al::isExistModelOrAnimResourceYaml(const LiveActor*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

u8* al::getModelResourceYaml(const LiveActor*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

u8* al::getAnimResourceYaml(const LiveActor*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

u8* al::getModelOrAnimResourceYaml(const LiveActor*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

u8* al::getMapPartsResourceYaml(const ActorInitInfo&, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

u8* al::tryGetMapPartsResourceYaml(const ActorInitInfo&, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

void al::tryMakeInitFileName(sead::BufferedSafeString*, const Resource*, const char*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

void al::tryGetSuffixIter(ByamlIter*, const Resource*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

void al::tryGetInitFileIterAndName(ByamlIter*, sead::BufferedSafeString*, const Resource*, const char*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

void al::tryGetActorInitFileIterAndName(ByamlIter*, sead::BufferedSafeString*, const Resource*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

bool al::tryGetActorInitFileIter(ByamlIter*, const Resource*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

bool al::tryGetActorInitFileIterAndName(ByamlIter*, sead::BufferedSafeString*, const LiveActor*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

bool al::tryGetActorInitFileIter(ByamlIter*, const LiveActor*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

bool al::tryGetActorInitFileName(sead::BufferedSafeString*, const Resource*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

bool al::tryGetActorInitFileName(sead::BufferedSafeString*, const ActorResource*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

bool al::tryGetActorInitFileName(sead::BufferedSafeString*, const LiveActor*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

bool al::tryGetActorInitFileSuffixName(sead::BufferedSafeString*, const Resource*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

bool al::tryGetActorInitFileSuffixName(sead::BufferedSafeString*, const LiveActor*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

const char* al::tryGetActorInitFileSuffixName(const LiveActor*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

const char* al::tryGetActorInitFileSuffixName(const Resource*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

void al::initParameterIoAsActorInfo(ParameterIo*, const LiveActor*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

void al::initParameterIoAndLoad(ParameterIo*, const LiveActor*, const char*, const char*)

#include <l/Library/LiveActor/ActorResourceFunction.h>

void al::stopScene(const LiveActor* actor, s32 stopFrames, s32 delayFrames)

#include <l/Library/LiveActor/ActorSceneFunction.h>

bool al::isStopScene(const LiveActor* actor)

#include <l/Library/LiveActor/ActorSceneFunction.h>

void al::stopScene(SceneStopCtrl* ctrl, s32 stopFrames, s32 delayFrames)

#include <l/Library/LiveActor/ActorSceneFunction.h>

bool al::isStopScene(SceneStopCtrl* ctrl)

#include <l/Library/LiveActor/ActorSceneFunction.h>

void al::requestCaptureScreenCover(const LiveActor* actor, s32 coverFrames)

#include <l/Library/LiveActor/ActorSceneFunction.h>

bool al::requestStartDemo(const LiveActor* actor, const char* name)

#include <l/Library/LiveActor/ActorSceneFunction.h>

void al::requestEndDemo(const LiveActor* actor, const char* name)

#include <l/Library/LiveActor/ActorSceneFunction.h>

void al::addDemoActor(LiveActor* actor)

#include <l/Library/LiveActor/ActorSceneFunction.h>

HitSensor* al::addHitSensor(LiveActor*, const ActorInitInfo&, const char*, u32, f32, u16, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

HitSensor* al::addHitSensorPlayer(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

HitSensor* al::addHitSensorPlayerAttack(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

HitSensor* al::addHitSensorPlayerEye(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

HitSensor* al::addHitSensorEnemy(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

HitSensor* al::addHitSensorEnemyBody(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

HitSensor* al::addHitSensorEnemyAttack(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

HitSensor* al::addHitSensorMapObj(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

HitSensor* al::addHitSensorBindable(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

HitSensor* al::addHitSensorBindableGoal(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

HitSensor* al::addHitSensorBindableAllPlayer(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

HitSensor* al::addHitSensorBindableBubbleOutScreen(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

HitSensor* al::addHitSensorBindableKoura(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

HitSensor* al::addHitSensorBindableRouteDokan(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

HitSensor* al::addHitSensorBindableBubblePadInput(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

HitSensor* al::addHitSensorCollisionParts(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

HitSensor* al::addHitSensorEye(LiveActor*, const ActorInitInfo&, const char*, f32, u16, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::setHitSensorSort(LiveActor*, const char*, const SensorSortCmpFuncBase*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::setHitSensorPosPtr(LiveActor*, const char*, const sead::Vector3f*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

HitSensor* al::getHitSensor(const LiveActor*, const char*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::setHitSensorMtxPtr(LiveActor*, const char*, const sead::Matrix34f*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::setHitSensorJointMtx(LiveActor*, const char*, const char*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::setSensorRadius(LiveActor*, const char*, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::setSensorRadius(LiveActor*, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

f32 al::getSensorRadius(const LiveActor*, const char*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

f32 al::getSensorRadius(const LiveActor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

const sead::Vector3f& al::getSensorPos(const LiveActor*, const char*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

const sead::Vector3f& al::getSensorPos(const LiveActor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::setSensorFollowPosOffset(LiveActor*, const char*, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::setSensorFollowPosOffset(LiveActor*, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

const sead::Vector3f& al::getSensorFollowPosOffset(const LiveActor*, const char*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

const sead::Vector3f& al::getSensorFollowPosOffset(const LiveActor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

ActorSensorController* al::createActorSensorController(LiveActor*, const char*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::setSensorRadius(ActorSensorController*, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::setSensorScale(ActorSensorController*, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::setSensorFollowPosOffset(ActorSensorController*, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

f32 al::getOriginalSensorRadius(const ActorSensorController*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

const sead::Vector3f& al::getOriginalSensorFollowPosOffset(const ActorSensorController*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::resetActorSensorController(ActorSensorController*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::calcPosBetweenSensors(sead::Vector3f*, const HitSensor*, const HitSensor*, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

f32 al::calcDistance(const HitSensor*, const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

const sead::Vector3f& al::getSensorPos(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

f32 al::calcDistanceV(const sead::Vector3f&, const HitSensor*, const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

f32 al::calcDistanceH(const sead::Vector3f&, const HitSensor*, const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::calcDirBetweenSensors(sead::Vector3f*, const HitSensor*, const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::calcDirBetweenSensorsH(sead::Vector3f*, const HitSensor*, const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::calcDirBetweenSensorsNormal(sead::Vector3f*, const HitSensor*, const HitSensor*, sead::Vector3f)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::calcVecBetweenSensors(sead::Vector3f*, const HitSensor*, const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::calcVecBetweenSensorsH(sead::Vector3f*, const HitSensor*, const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::calcVecBetweenSensorsNormal(sead::Vector3f*, const HitSensor*, const HitSensor*, sead::Vector3f)

#include <l/Library/LiveActor/ActorSensorUtil.h>

s32 al::calcStrikeArrowCollideWallAndCeilingBetweenAttackSensor(const LiveActor*, const HitSensor*, const HitSensor*, const sead::Vector3f&, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

LiveActor* al::getSensorHost(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isFaceBetweenSensors(const sead::Vector3f&, const HitSensor*, const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isFaceBetweenSensorsH(const sead::Vector3f&, const HitSensor*, const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isEnableLookAtTargetSensor(const HitSensor*, const sead::Vector3f&, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorValid(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isHitBoxSensor(const HitSensor*, const sead::Vector3f&, const sead::BoundBox3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

f32 al::getSensorRadius(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isHitBoxSensor(const HitSensor*, const sead::Matrix34f&, const sead::BoundBox3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isHitCylinderSensor(const HitSensor*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isHitCylinderSensor(const HitSensor*, const HitSensor*, const sead::Vector3f&, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isHitCylinderSensor(sead::Vector3f*, sead::Vector3f*, const HitSensor*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isHitCylinderSensor(sead::Vector3f*, sead::Vector3f*, const HitSensor*, const HitSensor*, const sead::Vector3f&, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isHitCylinderSensorHeight(const HitSensor*, const HitSensor*, const sead::Vector3f&, f32, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isHitCircleSensor(sead::Vector3f*, sead::Vector3f*, const HitSensor*, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isHitCircleSensor(sead::Vector3f*, sead::Vector3f*, const HitSensor*, const HitSensor*, const sead::Vector3f&, f32, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isHitCircleSensor(const HitSensor*, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isHitCircleSensor(const HitSensor*, const HitSensor*, const sead::Vector3f&, f32, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isHitPlaneSensor(const HitSensor*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isHitPlaneSensor(const HitSensor*, const HitSensor*, const sead::Vector3f&, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

const sead::Vector3f& al::getActorTrans(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

const sead::Vector3f& al::getActorVelocity(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

const sead::Vector3f& al::getActorGravity(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorName(const HitSensor*, const char*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorHostName(const HitSensor*, const char*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorHost(const HitSensor*, const LiveActor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::validateHitSensors(LiveActor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::invalidateHitSensors(LiveActor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorValid(const LiveActor*, const char*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::validateHitSensor(LiveActor*, const char*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::invalidateHitSensor(LiveActor*, const char*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::validateHitSensorBindableAll(LiveActor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorBindableAll(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::validateHitSensorEnemyAll(LiveActor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorEnemy(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::validateHitSensorEnemyAttackAll(LiveActor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorEnemyAttack(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::validateHitSensorEnemyBodyAll(LiveActor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorEnemyBody(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::validateHitSensorEyeAll(LiveActor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorEye(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::validateHitSensorMapObjAll(LiveActor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorMapObj(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::validateHitSensorNpcAll(LiveActor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorNpc(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::validateHitSensorPlayerAll(LiveActor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorPlayerAll(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::validateHitSensorRideAll(LiveActor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorRide(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::invalidateHitSensorEyeAll(LiveActor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::invalidateHitSensorPlayerAll(LiveActor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::invalidateHitSensorPlayerAttackAll(LiveActor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorPlayerAttack(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerAttackTrample(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerTrampleReflect(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerReflectOrTrample(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerHipDrop(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerObjHipDrop(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerObjHipDropReflect(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerObjHipDropHighJump(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerHipDropKnockDown(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerStatueDrop(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerObjStatueDrop(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerObjStatueDropReflect(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerObjStatueDropReflectNoCondition(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerStatueTouch(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerUpperPunch(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerObjUpperPunch(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerRollingAttack(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerRollingReflect(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerObjRollingAttack(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerObjRollingAttackFailure(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerInvincibleAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerFireBallAttack(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerRouteDokanFireBallAttack(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerTailAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerTouch(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerKick(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerCatch(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerSlidingAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerBoomerangAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerBoomerangAttackCollide(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerBoomerangReflect(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerBoomerangBreak(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerBodyAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerBodyLanding(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerBodyAttackReflect(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerClimbAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerSpinAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerGiantAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerCooperationHipDrop(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerClimbSlidingAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerClimbRollingAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerGiantHipDrop(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerDisregard(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerItemGet(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerPutOnEquipment(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerReleaseEquipment(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerReleaseEquipmentGoal(HitSensor* receiver, HitSensor* sender, u32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerFloorTouch(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerDamageTouch(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerCarryFront(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerCarryFrontWallKeep(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerCarryUp(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerCarryKeepDemo(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerCarryWarp(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerLeave(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerRelease(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerReleaseBySwing(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerReleaseDamage(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerReleaseDead(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerReleaseDemo(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerToss(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerInvincibleTouch(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgEnemyAttack(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgEnemyAttackBoomerang(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgEnemyAttackFire(HitSensor* receiver, HitSensor* sender, const char*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgEnemyAttackNeedle(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgEnemyFloorTouch(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgEnemyItemGet(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgEnemyRouteDokanAttack(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgEnemyRouteDokanFire(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgEnemyTouch(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgEnemyUpperPunch(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgEnemyTrample(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgMapObjTrample(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPressureDeath(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgNpcTouch(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgExplosion(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgExplosionCollide(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPush(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPushStrong(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPushVeryStrong(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgHit(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgHitStrong(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgHitVeryStrong(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgKnockDown(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgMapPush(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgVanish(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgChangeAlpha(LiveActor* receiver, f32 alpha)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgShowModel(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgHideModel(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgRestart(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgNeedleBallAttack(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPunpunFloorTouch(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgInvalidateFootPrint(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgKickKouraAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgKickKouraAttackCollide(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgKickKouraGetItem(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgKickKouraReflect(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgKickKouraCollideNoReflect(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgKickKouraBreak(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgKickKouraBlow(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgKickStoneAttack(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgKickStoneAttackCollide(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgKickStoneAttackHold(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgKickStoneAttackReflect(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgKickStoneTrample(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgKillerAttack(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgLiftGeyser(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgWarpStart(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgWarpEnd(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgHoldCancel(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgHoleIn(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgJumpInhibit(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgGoalKill(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgGoal(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgBindStart(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgBindInit(HitSensor* receiver, HitSensor* sender, u32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgBindEnd(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgBindCancel(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgBindCancelByDemo(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgBindDamage(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgBindSteal(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgBindGiant(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgBallAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgBallRouteDokanAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgBallAttackHold(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgBallAttackDRCHold(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgBallAttackCollide(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgBallTrample(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgBallTrampleCollide(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgBallItemGet(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgFireBalCollide(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgFireBallFloorTouch(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgDokanBazookaAttack(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgRideAllPlayerItemGet(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgHideModel(LiveActor* receiver)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgShowModel(LiveActor* receiver)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgRestart(LiveActor* receiver)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgCollisionImpulse(HitSensor* receiver, HitSensor* sender, sead::Vector3f*, const sead::Vector3f&, f32, const sead::Vector3f&, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgSwitchOn(LiveActor* receiver)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgSwitchOnInit(LiveActor* receiver)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgSwitchOffInit(LiveActor* receiver)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgSwitchKillOn(LiveActor* receiver)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgSwitchKillOnInit(LiveActor* receiver)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgSwitchKillOffInit(LiveActor* receiver)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerFloorTouchToColliderGround(LiveActor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerUpperPunchToColliderCeiling(LiveActor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgEnemyFloorTouchToColliderGround(LiveActor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgEnemyUpperPunchToColliderCeiling(LiveActor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgAskSafetyPoint(HitSensor* receiver, HitSensor* sender, sead::Vector3f**)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgAskSafetyPointToColliderGround(LiveActor* receiver, HitSensor* sender, sead::Vector3f**)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgTouchAssist(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgTouchAssistTrig(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgTouchStroke(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgScreenPointInvalidCollisionParts(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgBlockUpperPunch(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgBlockLowerPunch(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgBlockItemGet(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgKillerItemGet(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerKouraAttack(HitSensor* receiver, HitSensor* sender, ComboCounter* comboCounter)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgLightFlash(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgForceAbyss(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgIsNerveSupportFreeze(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgOnSyncSupportFreeze(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgOffSyncSupportFreeze(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgSwordAttackHighLeft(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgSwordAttackLowLeft(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgSwordAttackHighRight(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgSwordAttackLowRight(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgSwordAttackJumpUnder(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgSwordBeamAttack(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgSwordBeamReflectAttack(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgShieldGuard(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgEnemyAttackKnockDown(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgAskMultiPlayerEnemy(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgItemGettable(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgKikkiThrow(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgIsKikkiThrowTarget(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerCloudGet(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgAutoJump(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerTouchShadow(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerPullOutShadow(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerAttackShadow(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerAttackShadowStrong(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPlayerAttackChangePos(HitSensor* receiver, HitSensor* sender, sead::Vector3f* pos)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgAtmosOnlineLight(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgLightBurn(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgMoonLightBurn(HitSensor* receiver, HitSensor* sender)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgString(HitSensor* receiver, HitSensor* sender, const char* str)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgStringV4fPtr(HitSensor* receiver, HitSensor* sender, const char* str, sead::Vector4f* vec)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgStringV4fSensorPtr(HitSensor* receiver, HitSensor* sender, const char* str, sead::Vector4f* vec)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgStringVoidPtr(HitSensor* receiver, HitSensor* sender, const char* str, void* ptr)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPushAll(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPush(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPushStrong(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPushVeryStrong(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgHoldReleaseAll(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgHoldCancel(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerRelease(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerReleaseBySwing(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerReleaseDead(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerReleaseDamage(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerReleaseDemo(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgItemGetDirectAll(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerItemGet(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgRideAllPlayerItemGet(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerTailAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgItemGetByObjAll(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgBallItemGet(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgKickKouraItemGet(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgKillerItemGet(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgItemGetAll(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgFloorTouch(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerFloorTouch(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgEnemyFloorTouch(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgUpperPunch(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerUpperPunch(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgEnemyUpperPunch(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerTrample(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerTrampleReflect(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerHipDropAll(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerStatueDrop(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerObjHipDropAll(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerObjStatueDrop(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerObjHipDropReflectAll(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerObjStatueDropReflect(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerObjHipDropHighJump(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerHipDropKnockDown(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerObjStatueDropReflectNoCondition(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerStatueTouch(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerObjUpperPunch(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerRollingAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerRollingReflect(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerObjRollingAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerObjRollingAttackFailure(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerInvincibleAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerFireBallAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerRouteDokanFireBallAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerKick(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerCatch(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerSlidingAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerBoomerangAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerBoomerangAttackCollide(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerBoomerangReflect(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerBoomerangBreak(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerBodyAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerBodyLanding(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerBodyAttackReflect(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerClimbAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerSpinAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerGiantAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerCooperationHipDrop(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerClimbSlidingAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerClimbRollingAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerGiantHipDrop(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerDisregard(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerDash(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerDamageTouch(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerFloorTouchBind(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerTouch(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerInvincibleTouch(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerGiantTouch(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerObjTouch(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerPutOnEquipment(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerReleaseEquipment(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerReleaseEquipmentGoal(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerCarryFront(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerCarryFrontWallKeep(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerCarryUp(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerCarryKeepDemo(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerCarryWarp(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerLeave(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerToss(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgEnemyAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgEnemyAttackFire(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgEnemyAttackKnockDown(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgEnemyAttackBoomerang(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgEnemyAttackNeedle(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgEnemyItemGet(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgEnemyRouteDokanAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgEnemyRouteDokanFire(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgExplosion(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgExplosionCollide(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgBindStart(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgBindInit(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgBindEnd(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgBindCancel(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgBindCancelByDemo(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgBindDamage(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgBindSteal(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgBindGiant(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPressureDeath(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgNpcTouch(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgHit(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgHitStrong(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgHitVeryStrong(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgKnockDown(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgMapPush(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgVanish(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgChangeAlpha(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgShowModel(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgHideModel(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgRestart(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgEnemyTouch(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgEnemyTrample(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgMapObjTrample(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgNeedleBallAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPunpunFloorTouch(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgInvalidateFootPrint(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgKickKouraAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgKickKouraAttackCollide(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgKickKouraReflect(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgKickKouraCollideNoReflect(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgKickKouraBreak(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgKickKouraBlow(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgKickStoneAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgKickStoneAttackCollide(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgKickStoneAttackHold(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgKickStoneAttackReflect(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgKickStoneTrample(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgKillerAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgLiftGeyser(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgWarpStart(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgWarpEnd(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgHoleIn(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgJumpInhibit(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgGoalKill(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgGoal(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgBallAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgBallRouteDokanAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgBallAttackHold(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgBallAttackDRCHold(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgBallAttackCollide(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgBallTrample(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgBallTrampleCollide(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgFireBallCollide(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgFireBallFloorTouch(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgDokanBazookaAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgSwitchOn(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgSwitchOnInit(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgSwitchOffInit(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgSwitchKillOn(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgSwitchKillOnInit(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgSwitchKillOffInit(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgAskSafetyPoint(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::trySetAskSafetyPointFollowPos(const SensorMsg* msg, sead::Vector3f*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgTouchAssist(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgTouchAssistNoPat(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgTouchAssistTrig(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgTouchAssistTrigOff(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgTouchAssistTrigNoPat(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgTouchAssistBurn(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgTouchAssistAll(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgTouchCarryItem(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgTouchReleaseItem(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgTouchStroke(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgIsNerveSupportFreeze(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgOnSyncSupportFreeze(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgOffSyncSupportFreeze(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgScreenPointInvalidCollisionParts(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgBlockUpperPunch(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgBlockLowerPunch(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgBlockItemGet(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerKouraAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgLightFlash(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgForceAbyss(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgSwordAttackHigh(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgSwordAttackHighLeft(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgSwordAttackHighRight(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgSwordAttackLow(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgSwordAttackLowLeft(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgSwordAttackLowRight(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgSwordBeamAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgSwordBeamReflectAttack(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgSwordAttackJumpUnder(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgShieldGuard(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgAskMultiPlayerEnemy(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgItemGettable(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgKikkiThrow(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgIsKikkiThrowTarget(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerCloudGet(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgAutoJump(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerTouchShadow(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerPullOutShadow(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerAttackShadow(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerAttackShadowStrong(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerAttackChangePos(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgAtmosOnlineLight(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgLightBurn(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgMoonLightBurn(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgString(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgStringV4fPtr(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgStringV4fSensorPtr(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgStringVoidPtr(const SensorMsg* msg)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerTrampleForCrossoverSensor(const SensorMsg* msg, const HitSensor*, const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerTrampleReflectForCrossoverSensor(const SensorMsg* msg, const HitSensor*, const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgPlayerUpperPunchForCrossoverSensor(const SensorMsg* msg, const HitSensor*, const HitSensor*, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMsgKickStoneTrampleForCrossoverSensor(const SensorMsg* msg, const HitSensor*, const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgEnemyAttackForCrossoverSensor(HitSensor*, HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgEnemyAttackForCrossoverCylinderSensor(HitSensor*, HitSensor*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorPlayer(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorPlayerFoot(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorPlayerDecoration(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorPlayerEye(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorPlayerOrPlayerWeapon(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorCollision(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorPlayerFireBall(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorHoldObj(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorLookAt(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorBindableGoal(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorBindableAllPlayer(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorBindableBubbleOutScreen(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorBindableKoura(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorBindableRouteDokan(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorBindableBubblePadInput(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorBindable(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorSimple(const HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

void al::updateHitSensorsAll(LiveActor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isMySensor(const HitSensor*, const LiveActor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorHitAnyPlane(const HitSensor*, const HitSensor*, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::isSensorHitRingShape(const HitSensor*, const HitSensor*, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::tryGetEnemyAttackFireMaterialCode(const char**, const SensorMsg*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPushAndKillVelocityToTarget(LiveActor*, HitSensor*, HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgPushAndKillVelocityToTargetH(LiveActor*, HitSensor*, HitSensor*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::pushAndAddVelocity(LiveActor*, const HitSensor*, const HitSensor*, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::pushAndAddVelocityH(LiveActor*, const HitSensor*, const HitSensor*, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::pushAndAddVelocityV(LiveActor*, const HitSensor*, const HitSensor*, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::tryReceiveMsgPushAndAddVelocity(LiveActor*, const SensorMsg*, const HitSensor*, const HitSensor*, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::tryReceiveMsgPushAndAddVelocityH(LiveActor*, const SensorMsg*, const HitSensor*, const HitSensor*, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::tryReceiveMsgPushAndCalcPushTrans(sead::Vector3f*, const SensorMsg*, const LiveActor*, const HitSensor*, const HitSensor*, f32)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::sendMsgCollidePush(HitSensor*, HitSensor*, const sead::Vector3f&)

#include <l/Library/LiveActor/ActorSensorUtil.h>

bool al::tryReceiveMsgCollidePush(sead::Vector3f*, const SensorMsg*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

f32 al::getChangeAlphaValue(const SensorMsg*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

u32 al::getBindInitType(const SensorMsg*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

const char* al::getMsgString(const SensorMsg*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

const char* al::getMsgStringV4fPtr(const SensorMsg*, sead::Vector4f**)

#include <l/Library/LiveActor/ActorSensorUtil.h>

const char* al::getMsgStringV4fSensorPtr(const SensorMsg*, sead::Vector4f, HitSensor**)

#include <l/Library/LiveActor/ActorSensorUtil.h>

const char* al::getMsgStringVoidPtr(const SensorMsg*, void**)

#include <l/Library/LiveActor/ActorSensorUtil.h>

u32 al::getPlayerReleaseEquipmentGoalType(const SensorMsg*)

#include <l/Library/LiveActor/ActorSensorUtil.h>

#include <l/Library/LiveActor/CreateActorFunction.h>

template<typename T>

LiveActor* al::createActorFunction(const char* actorName)

SubActorInfo* al::getSubActorInfo(const LiveActor* actor, s32 index)

#include <l/Library/LiveActor/LiveActorFunction.cpp>

SubActorInfo* al::getSubActorInfo(const LiveActor* actor, const LiveActor* subActor)

#include <l/Library/LiveActor/LiveActorFunction.cpp>

bool al::isExistSubActorKeeper(const LiveActor* actor)

#include <l/Library/LiveActor/LiveActorFunction.h>

LiveActor* al::getSubActor(const LiveActor* actor, const char* subActorName)

#include <l/Library/LiveActor/LiveActorFunction.h>

LiveActor* al::tryGetSubActor(const LiveActor* actor, const char* subActorName)

#include <l/Library/LiveActor/LiveActorFunction.h>

LiveActor* al::getSubActor(const LiveActor* actor, s32 index)

#include <l/Library/LiveActor/LiveActorFunction.h>

s32 al::getSubActorNum(const LiveActor* actor)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::offSyncClippingSubActor(LiveActor* actor, const LiveActor* subActor)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::offSyncClippingSubActor(LiveActor* actor, const char* subActorName)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::offSyncClippingSubActorAll(LiveActor* actor)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::onSyncClippingSubActor(LiveActor* actor, const LiveActor* subActor)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::onSyncClippingSubActor(LiveActor* actor, const char* subActorName)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::onSyncClippingSubActorAll(LiveActor* actor)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::offSyncAppearSubActor(LiveActor* actor, const LiveActor* subActor)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::offSyncAppearSubActor(LiveActor* actor, const char* subActorName)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::offSyncAppearSubActorAll(LiveActor* actor)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::onSyncAppearSubActor(LiveActor* actor, const LiveActor* subActor)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::onSyncAppearSubActor(LiveActor* actor, const char* subActorName)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::onSyncAppearSubActorAll(LiveActor* actor)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::offSyncHideSubActor(LiveActor* actor, const LiveActor* subActor)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::offSyncHideSubActor(LiveActor* actor, const char* subActorName)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::offSyncHideSubActorAll(LiveActor* actor)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::onSyncHideSubActor(LiveActor* actor, const LiveActor* subActor)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::onSyncHideSubActor(LiveActor* actor, const char* subActorName)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::onSyncHideSubActorAll(LiveActor* actor)

#include <l/Library/LiveActor/LiveActorFunction.h>

bool al::isSyncHideSubActor(const LiveActor* actor, const LiveActor* subActor)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::offSyncAlphaMaskSubActor(LiveActor* actor, const LiveActor* subActor)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::offSyncAlphaMaskSubActor(LiveActor* actor, const char* subActorName)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::offSyncAlphaMaskSubActorAll(LiveActor* actor)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::onSyncAlphaMaskSubActor(LiveActor* actor, const LiveActor* subActor)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::onSyncAlphaMaskSubActor(LiveActor* actor, const char* subActorName)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::onSyncAlphaMaskSubActorAll(LiveActor* actor)

#include <l/Library/LiveActor/LiveActorFunction.h>

bool al::isSyncAlphaMaskSubActor(const LiveActor* actor, const LiveActor* subActor)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::startActionSubActor(const LiveActor* actor, const char* subActorName, const char* action)

#include <l/Library/LiveActor/LiveActorFunction.h>

bool al::isActionEndSubActor(const LiveActor* actor, const char* subActorName)

#include <l/Library/LiveActor/LiveActorFunction.h>

bool al::isActionPlayingSubActor(const LiveActor* actor, const char* subActorName, const char* action)

#include <l/Library/LiveActor/LiveActorFunction.h>

bool al::isActionOneTimeSubActor(const LiveActor* actor, const char* subActorName)

#include <l/Library/LiveActor/LiveActorFunction.h>

bool al::isActionOneTimeSubActor(const LiveActor* actor, const char* subActorName, const char* action)

#include <l/Library/LiveActor/LiveActorFunction.h>

bool al::tryStartActionSubActorAll(const LiveActor* actor, const char* action)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::makeActorDeadSubActorAll(const LiveActor* actor)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::tryValidateCollisionPartsSubActorAll(LiveActor* actor)

#include <l/Library/LiveActor/LiveActorFunction.h>

void al::tryInvalidateCollisionPartsSubActorAll(LiveActor* actor)

#include <l/Library/LiveActor/LiveActorFunction.h>

static void al::syncStageSwitchMakeActorDead(LiveActor* actor)

#include <l/Library/MapObj/BreakMapPartsBase.cpp>

s32 al::calcChildStepCount(const ActorInitInfo& info)

#include <l/Library/MapObj/ChildStep.h>

void al::tryInitSubActorKeeperChildStep(LiveActor* actor, const ActorInitInfo& info)

#include <l/Library/MapObj/ChildStep.h>

void al::createChildStep(const ActorInitInfo& info, LiveActor* parent, bool isSyncClipping)

#include <l/Library/MapObj/ChildStep.h>

void al::registerConveyerSteps(DeriveActorGroup<ConveyerStep>* conveyerStepGroup, const ActorInitInfo& info)

#include <l/Library/MapObj/ConveyerMapParts.cpp>

bool al::isGreaterThanOrEqualToZero(f32 val)

#include <l/Library/MapObj/SeesawMapParts.cpp>

void al::calcWorldPosFromGridIndex(sead::Vector3f* out, const sead::Matrix34f& matrix, const sead::Vector3i& in)

#include <l/Library/Math/MathGridUtil.h>

void al::calcGridIndexFromWorldPos(sead::Vector3i* out, const sead::Matrix34f& matrix, const sead::Vector3f& in)

#include <l/Library/Math/MathGridUtil.h>

sead::Vector3f al::calcGridIndexNext(const sead::Vector3f&, s32)

#include <l/Library/Math/MathGridUtil.h>

f32 al::calcDegreeDirIndexSignedX(s32 index)

#include <l/Library/Math/MathGridUtil.h>

f32 al::calcDegreeDirIndexSignedY(s32 index)

#include <l/Library/Math/MathGridUtil.h>

f32 al::calcDegreeDirIndexSignedZ(s32 index)

#include <l/Library/Math/MathGridUtil.h>

f32 al::calcDirIndexNearXY(const sead::Vector3i&, const sead::Vector3i&)

#include <l/Library/Math/MathGridUtil.h>

f32 al::signDirIndexX(s32)

#include <l/Library/Math/MathGridUtil.h>

f32 al::signDirIndexY(s32)

#include <l/Library/Math/MathGridUtil.h>

f32 al::signDirIndexZ(s32)

#include <l/Library/Math/MathGridUtil.h>

void al::calcGridMinMaxFromOBB(sead::Vector3i*, sead::Vector3i*, const sead::Matrix34f&, const sead::Matrix34f&, const sead::BoundBox3f&)

#include <l/Library/Math/MathGridUtil.h>

void al::expandGridFromOBB(sead::Vector3i*, sead::Vector3i*, const sead::Matrix34f&, const sead::Matrix34f&, const sead::BoundBox3f&)

#include <l/Library/Math/MathGridUtil.h>

f32 al::calcAngleRadian(const sead::Vector3f& a, const sead::Vector3f& b)

#include <l/Library/Math/MathUtil.h>

f32 al::calcAngleDegree(const sead::Vector3f& a, const sead::Vector3f& b)

#include <l/Library/Math/MathUtil.h>

f32 al::calcAngleDegree(const sead::Vector2f& a, const sead::Vector2f& b)

#include <l/Library/Math/MathUtil.h>

bool al::isNearZero(const sead::Vector2f& vec, f32 tolerance)

#include <l/Library/Math/MathUtil.h>

bool al::tryCalcAngleDegree(f32* out, const sead::Vector3f& a, const sead::Vector3f& b)

#include <l/Library/Math/MathUtil.h>

bool al::isNearZero(const sead::Vector3f& vec, f32 tolerance)

#include <l/Library/Math/MathUtil.h>

f32 al::calcAngleOnPlaneRadian(const sead::Vector3f& a, const sead::Vector3f& b, const sead::Vector3f& vertical)

#include <l/Library/Math/MathUtil.h>

void al::verticalizeVec(sead::Vector3f* out, const sead::Vector3f& vertical, const sead::Vector3f& vec)

#include <l/Library/Math/MathUtil.h>

Takes the plane perpendicular to unit vector vertical, projects vec onto it, and stores the result in out. The effect is that vec and out will look equal if looking in the direction of vertical.

f32 al::calcAngleOnPlaneDegree(const sead::Vector3f& a, const sead::Vector3f& b, const sead::Vector3f& vertical)

#include <l/Library/Math/MathUtil.h>

f32 al::calcAngleOnPlaneDegreeOrZero(const sead::Vector3f& a, const sead::Vector3f& b, const sead::Vector3f& vertical)

#include <l/Library/Math/MathUtil.h>

bool al::isParallelDirection(const sead::Vector3f& a, const sead::Vector3f& b, f32 tolerance)

#include <l/Library/Math/MathUtil.h>

s32 al::calcAngleSignOnPlane(const sead::Vector3f& a, const sead::Vector3f& b, const sead::Vector3f& vertical)

#include <l/Library/Math/MathUtil.h>

bool al::isNearAngleRadian(const sead::Vector2f& a, const sead::Vector2f& b, f32 tolerance)

#include <l/Library/Math/MathUtil.h>

void al::normalize(sead::Vector2f* out, const sead::Vector2f& vec)

#include <l/Library/Math/MathUtil.h>

bool al::isNearAngleRadian(const sead::Vector3f& a, const sead::Vector3f& b, f32 tolerance)

#include <l/Library/Math/MathUtil.h>

void al::normalize(sead::Vector3f* out, const sead::Vector3f& vec)

#include <l/Library/Math/MathUtil.h>

bool al::isNearAngleDegree(const sead::Vector2f& a, const sead::Vector2f& b, f32 tolerance)

#include <l/Library/Math/MathUtil.h>

bool al::isNearAngleDegree(const sead::Vector3f& a, const sead::Vector3f& b, f32 tolerance)

#include <l/Library/Math/MathUtil.h>

bool al::tryNormalizeOrZero(sead::Vector3f* vec)

#include <l/Library/Math/MathUtil.h>

bool al::tryNormalizeOrZero(sead::Vector3f* out, const sead::Vector3f& vec)

#include <l/Library/Math/MathUtil.h>

bool al::isNearAngleDegreeHV(const sead::Vector3f& a, const sead::Vector3f& b, const sead::Vector3f& c, f32 d, f32 e)

#include <l/Library/Math/MathUtil.h>

bool al::isNear(f32 value, f32 target, f32 tolerance)

#include <l/Library/Math/MathUtil.h>

bool al::isNear(const sead::Vector2f& value, const sead::Vector2f& target, f32 tolerance)

#include <l/Library/Math/MathUtil.h>

bool al::isNear(const sead::Vector3f& value, const sead::Vector3f& target, f32 tolerance)

#include <l/Library/Math/MathUtil.h>

bool al::isNear(const sead::Color4f& value, const sead::Color4f& target, f32 tolerance)

#include <l/Library/Math/MathUtil.h>

bool al::isNearZero(f32 value, f32 tolerance)

#include <l/Library/Math/MathUtil.h>

bool al::isNearZero(const sead::Matrix34f& value, f32 tolerance)

#include <l/Library/Math/MathUtil.h>

bool al::isNearZeroOrGreater(f32 value, f32 tolerance)

#include <l/Library/Math/MathUtil.h>

bool al::isNearZeroOrLess(f32 value, f32 tolerance)

#include <l/Library/Math/MathUtil.h>

bool al::isExistNearZeroVal(const sead::Vector3f& vec, f32 tolerance)

#include <l/Library/Math/MathUtil.h>

bool al::isNormalize(const sead::Vector3f& vec, f32 tolerance)

#include <l/Library/Math/MathUtil.h>

bool al::isParallelDirection(const sead::Vector2f& a, const sead::Vector2f& b, f32 tolerance)

#include <l/Library/Math/MathUtil.h>

bool al::isNearDirection(const sead::Vector2f& a, const sead::Vector2f& b, f32 tolerance)

#include <l/Library/Math/MathUtil.h>

bool al::isInRange(s32 x, s32 a, s32 b)

#include <l/Library/Math/MathUtil.h>

bool al::isInRange(f32 x, f32 a, f32 b)

#include <l/Library/Math/MathUtil.h>

void al::normalize(sead::Vector2f* vec)

#include <l/Library/Math/MathUtil.h>

void al::normalize(sead::Vector3f* vec)

#include <l/Library/Math/MathUtil.h>

void al::normalize(sead::Matrix33f* mtx)

#include <l/Library/Math/MathUtil.h>

void al::normalize(sead::Matrix34f* mtx)

#include <l/Library/Math/MathUtil.h>

bool al::tryNormalizeOrZero(sead::Vector2f* vec)

#include <l/Library/Math/MathUtil.h>

bool al::tryNormalizeOrZero(sead::Vector2f* out, const sead::Vector2f& vec)

#include <l/Library/Math/MathUtil.h>

bool al::tryNormalizeOrDirZ(sead::Vector3f* vec)

#include <l/Library/Math/MathUtil.h>

bool al::tryNormalizeOrDirZ(sead::Vector3f* out, const sead::Vector3f& vec)

#include <l/Library/Math/MathUtil.h>

u32 al::getMaxAbsElementIndex(const sead::Vector3f& vec)

#include <l/Library/Math/MathUtil.h>

void al::setLength(sead::Vector3f* vec, f32 length)

#include <l/Library/Math/MathUtil.h>

void al::setProjectionLength(sead::Vector3f* out, const sead::Vector3f& vec, f32 length)

#include <l/Library/Math/MathUtil.h>

bool al::limitLength(sead::Vector2f* out, const sead::Vector2f& vec, f32 limit)

#include <l/Library/Math/MathUtil.h>

bool al::limitLength(sead::Vector3f* out, const sead::Vector3f& vec, f32 limit)

#include <l/Library/Math/MathUtil.h>

f32 al::normalizeAbs(f32 x, f32 min, f32 max)

#include <l/Library/Math/MathUtil.h>

f32 al::normalize(f32 x, f32 min, f32 max)

#include <l/Library/Math/MathUtil.h>

f32 al::normalize(s32 x, s32 min, s32 max)

#include <l/Library/Math/MathUtil.h>

f32 al::sign(f32 x)

#include <l/Library/Math/MathUtil.h>

s32 al::sign(s32 x)

#include <l/Library/Math/MathUtil.h>

f32 al::cubeRoot(f32 x)

#include <l/Library/Math/MathUtil.h>

void al::clampV3f(sead::Vector3f* out, const sead::Vector3f& min, const sead::Vector3f& max)

#include <l/Library/Math/MathUtil.h>

void al::clampV2f(sead::Vector2f* out, const sead::Vector2f& min, const sead::Vector2f& max)

#include <l/Library/Math/MathUtil.h>

f32 al::easeIn(f32 t)

#include <l/Library/Math/MathUtil.h>

f32 al::easeOut(f32 t)

#include <l/Library/Math/MathUtil.h>

f32 al::easeInOut(f32 t)

#include <l/Library/Math/MathUtil.h>

f32 al::squareIn(f32 t)

#include <l/Library/Math/MathUtil.h>

f32 al::squareOut(f32 t)

#include <l/Library/Math/MathUtil.h>

f32 al::powerIn(f32 t, f32 exp)

#include <l/Library/Math/MathUtil.h>

f32 al::powerOut(f32 t, f32 exp)

#include <l/Library/Math/MathUtil.h>

f32 al::logarithmIn(f32 t, f32 base)

#include <l/Library/Math/MathUtil.h>

f32 al::logarithmOut(f32 t, f32 base)

#include <l/Library/Math/MathUtil.h>

f32 al::exponentIn(f32 t, f32 exp)

#include <l/Library/Math/MathUtil.h>

f32 al::exponentOut(f32 t, f32 exp)

#include <l/Library/Math/MathUtil.h>

f32 al::hermiteRate(f32 t, f32 m0, f32 m1)

#include <l/Library/Math/MathUtil.h>

f32 al::calcFourthOrderRate(f32 t, f32 scale)

#include <l/Library/Math/MathUtil.h>

f32 al::calcTriangleWave01(f32 t, f32 period)

#include <l/Library/Math/MathUtil.h>

f32 al::calcTriangleWave(f32 t, f32 min, f32 max, f32 period)

#include <l/Library/Math/MathUtil.h>

f32 al::lerpValue(f32 a, f32 b, f32 t)

#include <l/Library/Math/MathUtil.h>

f32 al::calcRate01(f32 t, f32 min, f32 max)

#include <l/Library/Math/MathUtil.h>

f32 al::easeByType(f32 t, s32 easeType)

#include <l/Library/Math/MathUtil.h>

f32 al::hermite(f32 y0, f32 m0, f32 y1, f32 m1, f32 t)

#include <l/Library/Math/MathUtil.h>

Interpolates between y0 and y1 as t goes from 0.0 to 1.0. This interpolation is defined by m0 and m1, which are the rates of change of t at the points y0 and y1 respectively.

f32 al::hermite(f32 y0, f32 m0, f32 y1, f32 m1, f32 t, f32 width)

#include <l/Library/Math/MathUtil.h>

u8 al::reverseBit8(u8 x)

#include <l/Library/Math/MathUtil.h>

u16 al::reverseBit16(u16 x)

#include <l/Library/Math/MathUtil.h>

u32 al::reverseBit32(u32 x)

#include <l/Library/Math/MathUtil.h>

f32 al::calcVanDerCorput(u32 x)

#include <l/Library/Math/MathUtil.h>

void al::calcHammersleyPoint(sead::Vector2f* outPoint, u32 i, u32 num)

#include <l/Library/Math/MathUtil.h>

f32 al::getRandom()

#include <l/Library/Math/MathUtil.h>

f32 al::getRandom(f32 factor)

#include <l/Library/Math/MathUtil.h>

f32 al::getRandom(f32 min, f32 max)

#include <l/Library/Math/MathUtil.h>

s32 al::getRandom(s32 factor)

#include <l/Library/Math/MathUtil.h>

s32 al::getRandom(s32 min, s32 max)

#include <l/Library/Math/MathUtil.h>

f32 al::getRandomDegree()

#include <l/Library/Math/MathUtil.h>

f32 al::getRandomRadian()

#include <l/Library/Math/MathUtil.h>

void al::getRandomVector(sead::Vector3f* vec, f32 factor)

#include <l/Library/Math/MathUtil.h>

void al::getRandomDir(sead::Vector3f* vec)

#include <l/Library/Math/MathUtil.h>

f32 al::modf(f32 a, f32 b)

#include <l/Library/Math/MathUtil.h>

s32 al::modi(s32 a, s32 b)

#include <l/Library/Math/MathUtil.h>

f32 al::calcSpeedMax(f32 accel, f32 friction)

#include <l/Library/Math/MathUtil.h>

f32 al::calcAccel(f32 speed, f32 friction)

#include <l/Library/Math/MathUtil.h>

f32 al::calcFriction(f32 accel, f32 speed)

#include <l/Library/Math/MathUtil.h>

f32 al::round(f32 v)

#include <l/Library/Math/MathUtil.cpp>

void al::roundOffVec(sead::Vector3f* outVec, const sead::Vector3f& vec)

#include <l/Library/Math/MathUtil.h>

void al::roundOffVec(sead::Vector3f* vec)

#include <l/Library/Math/MathUtil.h>

void al::roundOffVec(sead::Vector2f* outVec, const sead::Vector2f& vec)

#include <l/Library/Math/MathUtil.h>

void al::roundOffVec(sead::Vector2f* vec)

#include <l/Library/Math/MathUtil.h>

f32 al::snapToGrid(f32 val, f32 gridSize, f32 offset)

#include <l/Library/Math/MathUtil.h>

void al::snapVecToGrid(sead::Vector3f* outVec, const sead::Vector3f& vec, f32 gridSize, const sead::Vector3f& offset)

#include <l/Library/Math/MathUtil.h>

void al::snapVecToGrid(sead::Vector3f* outVec, const sead::Vector3f& vec, const sead::Vector3f& gridSize, const sead::Vector3f& offset)

#include <l/Library/Math/MathUtil.h>

void al::limitVectorOppositeDir(sead::Vector3f* outVec, const sead::Vector3f& inVec, const sead::Vector3f& dir, f32 scale)

#include <l/Library/Math/MathUtil.h>

void al::scaleVectorDirection(sead::Vector3f* outVec, const sead::Vector3f& inVec, const sead::Vector3f& dir, f32 scale)

#include <l/Library/Math/MathUtil.h>

void al::scaleVectorExceptDirection(sead::Vector3f* outVec, const sead::Vector3f& inVec, const sead::Vector3f& dir, f32 scale)

#include <l/Library/Math/MathUtil.h>

bool al::calcDir(sead::Vector3f* outVec, const sead::Vector3f& vecA, const sead::Vector3f& vecB)

#include <l/Library/Math/MathUtil.h>

bool al::calcDirH(sead::Vector3f* outVec, const sead::Vector3f& vecA, const sead::Vector3f& vecB)

#include <l/Library/Math/MathUtil.h>

bool al::calcDirOnPlane(sead::Vector3f* outVec, const sead::Vector3f& vecA, const sead::Vector3f& vecB, const sead::Vector3f& plane)

#include <l/Library/Math/MathUtil.h>

f32 al::mapRangeLogarithmic(f32 x, f32 min, f32 max, f32 start, f32 end, f32 exponent)

#include <l/Library/Math/MathUtil.h>

void al::calcDirFromLongitudeLatitude(sead::Vector3f* outVec, f32 longitude, f32 latitude)

#include <l/Library/Math/MathUtil.h>

void al::calcLongitudeLatitudeFromDir(f32* longitude, f32* latitude, const sead::Vector3f& dir)

#include <l/Library/Math/MathUtil.h>

u32 al::getMaxAbsElementIndex(const sead::Vector3i& vec)

#include <l/Library/Math/MathUtil.h>

f32 al::getMaxAbsElementValue(const sead::Vector3f& vec)

#include <l/Library/Math/MathUtil.h>

s32 al::getMaxAbsElementValue(const sead::Vector3i& vec)

#include <l/Library/Math/MathUtil.h>

u32 al::getMinAbsElementIndex(const sead::Vector3f& vec)

#include <l/Library/Math/MathUtil.h>

u32 al::getMinAbsElementIndex(const sead::Vector3i& vec)

#include <l/Library/Math/MathUtil.h>

f32 al::getMinAbsElementValue(const sead::Vector3f& vec)

#include <l/Library/Math/MathUtil.h>

s32 al::getMinAbsElementValue(const sead::Vector3i& vec)

#include <l/Library/Math/MathUtil.h>

void al::makeQuatFromTwoAxis(sead::Quatf* outQuat, const sead::Vector3f& vectorA, const sead::Vector3f& vectorB, s32 axisA, s32 axisB)

#include <l/Library/Math/MathUtil.h>

void al::makeQuatFrontUp(sead::Quatf* outQuat, const sead::Vector3f& front, const sead::Vector3f& up)

#include <l/Library/Math/MathUtil.h>

void al::makeQuatFrontSide(sead::Quatf* outQuat, const sead::Vector3f& front, const sead::Vector3f& side)

#include <l/Library/Math/MathUtil.h>

void al::makeQuatFrontNoSupport(sead::Quatf* outQuat, const sead::Vector3f& front)

#include <l/Library/Math/MathUtil.h>

void al::makeQuatUpFront(sead::Quatf* outQuat, const sead::Vector3f& up, const sead::Vector3f& front)

#include <l/Library/Math/MathUtil.h>

void al::makeQuatUpSide(sead::Quatf* outQuat, const sead::Vector3f& up, const sead::Vector3f& side)

#include <l/Library/Math/MathUtil.h>

void al::makeQuatUpNoSupport(sead::Quatf* outQuat, const sead::Vector3f& up)

#include <l/Library/Math/MathUtil.h>

void al::makeQuatSideUp(sead::Quatf* outQuat, const sead::Vector3f& side, const sead::Vector3f& up)

#include <l/Library/Math/MathUtil.h>

void al::makeQuatSideFront(sead::Quatf* outQuat, const sead::Vector3f& side, const sead::Vector3f& front)

#include <l/Library/Math/MathUtil.h>

void al::makeQuatSideNoSupport(sead::Quatf* outQuat, const sead::Vector3f& side)

#include <l/Library/Math/MathUtil.h>

void al::rotateQuatRadian(sead::Quatf* outQuat, const sead::Quatf& quat, const sead::Vector3f& vec, f32 angle)

#include <l/Library/Math/MathUtil.h>

void al::makeQuatXDegree(sead::Quatf* outQuat, f32 angle)

#include <l/Library/Math/MathUtil.h>

void al::makeQuatYDegree(sead::Quatf* outQuat, f32 angle)

#include <l/Library/Math/MathUtil.h>

void al::makeQuatZDegree(sead::Quatf* outQuat, f32 angle)

#include <l/Library/Math/MathUtil.h>

void al::rotateQuatXDirDegree(sead::Quatf* outQuat, const sead::Quatf& quat, f32 angle)

#include <l/Library/Math/MathUtil.h>

void al::rotateQuatYDirDegree(sead::Quatf* outQuat, const sead::Quatf& quat, f32 angle)

#include <l/Library/Math/MathUtil.h>

void al::rotateQuatZDirDegree(sead::Quatf* outQuat, const sead::Quatf& quat, f32 angle)

#include <l/Library/Math/MathUtil.h>

void al::rotateQuatLocalDirDegree(sead::Quatf* outQuat, const sead::Quatf& quat, s32 axis, f32 angle)

#include <l/Library/Math/MathUtil.h>

void al::rotateQuatMoment(sead::Quatf* outQuat, const sead::Quatf& quat, const sead::Vector3f& vec)

#include <l/Library/Math/MathUtil.h>

void al::rotateQuatMomentDegree(sead::Quatf* outQuat, const sead::Quatf& quat, const sead::Vector3f& vec)

#include <l/Library/Math/MathUtil.h>

void al::rotateQuatRollBall(sead::Quatf* outQuat, const sead::Quatf& quat, const sead::Vector3f& vecA, const sead::Vector3f& vecB, f32 scale)

#include <l/Library/Math/MathUtil.h>

void al::calcMomentRollBall(sead::Vector3f* outVec, const sead::Vector3f& vecA, const sead::Vector3f& vecB, f32 scale)

#include <l/Library/Math/MathUtil.h>

void al::calcCirclePointPicking(sead::Vector2f* outPoint, f32 x, f32 y)

#include <l/Library/Math/MathUtil.h>

void al::pickUniformPointsOnCircleHammersley(sead::Vector2f* outPoint, u32 x, u32 y)

#include <l/Library/Math/MathUtil.cpp>

void al::calcDiskPointPicking(sead::Vector2f* outPoint, f32 radius, f32 angle)

#include <l/Library/Math/MathUtil.h>

void al::pickUniformPointsOnDiskHammersley(sead::Vector2f* outPoint, u32 x, u32 y)

#include <l/Library/Math/MathUtil.h>

void al::pickUniformPointOnDisk(sead::Vector2f* outPoint)

#include <l/Library/Math/MathUtil.h>

void al::calcSpherePointPicking(sead::Vector3f* outPoint, f32 x, f32 y)

#include <l/Library/Math/MathUtil.h>

void al::pickUniformPointOnSphere(sead::Vector3f* outPoint)

#include <l/Library/Math/MathUtil.h>

void al::calcParabolicFunctionParam(f32* gravity, f32* initialVelY, f32 maxHeight, f32 verticalDistance)

#include <l/Library/Math/MathUtil.h>

#include <l/Library/Math/MathUtil.h>

template<typename T>

T al::clamp(T value, T min, T max)

bool al::tryCalcAngleOnPlaneDegree(f32* angle, const sead::Vector3f& a, const sead::Vector3f& b, const sead::Vector3f& vertical)

#include <l/Library/Math/MathUtil.h>

bool al::isNearAngleRadianHV(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

#include <l/Library/Math/MathUtil.h>

bool al::isInAngleOnPlaneDegreeHV(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32, f32, f32, f32)

#include <l/Library/Math/MathUtil.h>

bool al::isNormalize(const sead::Matrix34f& mtx)

#include <l/Library/Math/MathUtil.h>

bool al::isReverseDirection(const sead::Vector3f& a, const sead::Vector3f& b, f32 tolerance = 0.01f)

#include <l/Library/Math/MathUtil.h>

bool al::isNearDirection(const sead::Vector3f& a, const sead::Vector3f& b, f32 tolerance = 0.01f)

#include <l/Library/Math/MathUtil.h>

void al::normalizeComplement(sead::Matrix34f* mtx)

#include <l/Library/Math/MathUtil.h>

f32 al::lerpValue(f32, f32, f32, f32, f32)

#include <l/Library/Math/MathUtil.h>

f32 al::lerpDegree(f32, f32, f32)

#include <l/Library/Math/MathUtil.h>

f32 al::lerpRadian(f32, f32, f32)

#include <l/Library/Math/MathUtil.h>

void al::lerpVec(sead::Vector2f*, const sead::Vector2f&, const sead::Vector2f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::lerpVec(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::lerpVecHV(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

#include <l/Library/Math/MathUtil.h>

void al::separateVectorHV(sead::Vector3f*, sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

void al::lerpColor(sead::Color4f*, const sead::Color4f&, const sead::Color4f&, f32)

#include <l/Library/Math/MathUtil.h>

f32 al::lerpLogValueEaseIn(f32, f32, f32, f32)

#include <l/Library/Math/MathUtil.h>

f32 al::lerpLogValueEaseOut(f32, f32, f32, f32)

#include <l/Library/Math/MathUtil.h>

void al::lerpLogVecEaseIn(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

#include <l/Library/Math/MathUtil.h>

void al::lerpLogVecEaseOut(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

#include <l/Library/Math/MathUtil.h>

f32 al::lerpExponentValueEaseIn(f32, f32, f32, f32)

#include <l/Library/Math/MathUtil.h>

f32 al::lerpExponentValueEaseOut(f32, f32, f32, f32)

#include <l/Library/Math/MathUtil.h>

void al::lerpExponentVecEaseIn(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

#include <l/Library/Math/MathUtil.h>

void al::lerpExponentVecEaseOut(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

#include <l/Library/Math/MathUtil.h>

f32 al::clampLeapMinAbs(f32, f32, f32, f32)

#include <l/Library/Math/MathUtil.h>

void al::hermiteVec(sead::Vector3f* out, const sead::Vector3f& p0, const sead::Vector3f& v0, const sead::Vector3f& p1, const sead::Vector3f& v1, f32 t)

#include <l/Library/Math/MathUtil.h>

s32 al::converge(s32, s32, s32)

#include <l/Library/Math/MathUtil.h>

f32 al::converge(f32, f32, f32)

#include <l/Library/Math/MathUtil.h>

f32 al::convergeDegree(f32, f32, f32)

#include <l/Library/Math/MathUtil.h>

f32 al::convergeRadian(f32, f32, f32)

#include <l/Library/Math/MathUtil.h>

void al::convergeVec(sead::Vector2f*, const sead::Vector2f&, const sead::Vector2f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::convergeVec(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

f32 al::diffNearAngleDegree(f32, f32)

#include <l/Library/Math/MathUtil.h>

bool al::isInRangeAngleDegree(f32, f32, f32)

#include <l/Library/Math/MathUtil.h>

bool al::calcEyesAnimAngleInRange(f32*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32, f32, f32, f32)

#include <l/Library/Math/MathUtil.h>

bool al::isSameSign(f32, f32)

#include <l/Library/Math/MathUtil.h>

s32 al::findMaxFromArray(const s32*, s32)

#include <l/Library/Math/MathUtil.h>

void al::separateMinMax(sead::Vector3f*, sead::Vector3f*, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

s32 al::findMinFromArray(const s32*, s32)

#include <l/Library/Math/MathUtil.h>

void al::getRandomDirH(sead::Vector3f*, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

void al::rotateVectorDegree(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::getRandomOnCircle(sead::Vector2f*, f32)

#include <l/Library/Math/MathUtil.h>

void al::getRandomInCircle(sead::Vector2f*, f32)

#include <l/Library/Math/MathUtil.h>

void al::getRandomInCircleMinMaxRadius(sead::Vector2f*, f32, f32)

#include <l/Library/Math/MathUtil.h>

void al::getRandomInCircle(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::getRandomOnSphere(sead::Vector3f*, f32)

#include <l/Library/Math/MathUtil.h>

void al::getRandomInSphere(sead::Vector3f*, f32)

#include <l/Library/Math/MathUtil.h>

bool al::calcRandomDirInCone(sead::Vector3f*, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::getRandomInSphereMinMaxRadius(sead::Vector3f*, f32, f32)

#include <l/Library/Math/MathUtil.h>

void al::initRandomSeed(u32)

#include <l/Library/Math/MathUtil.h>

void al::initRandomSeedByTick()

#include <l/Library/Math/MathUtil.h>

void al::initRandomSeedByString(const char*)

#include <l/Library/Math/MathUtil.h>

bool al::isHalfProbability()

#include <l/Library/Math/MathUtil.h>

bool al::isPercentProbability(f32)

#include <l/Library/Math/MathUtil.h>

void al::getRandomContext(u32*, u32*, u32*, u32*)

#include <l/Library/Math/MathUtil.h>

void al::setRandomContext(u32, u32, u32, u32)

#include <l/Library/Math/MathUtil.h>

void al::makeRandomDirXZ(sead::Vector3f*)

#include <l/Library/Math/MathUtil.h>

f32 al::calcBoxMullerRandomGauss()

#include <l/Library/Math/MathUtil.h>

void al::makeBoxMullerRandomGauss(sead::Vector2f*, f32, f32)

#include <l/Library/Math/MathUtil.h>

bool al::separateScalarAndDirection(f32*, sead::Vector2f*, const sead::Vector2f&)

#include <l/Library/Math/MathUtil.h>

bool al::separateScalarAndDirection(f32*, sead::Vector3f*, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

void al::limitVectorSeparateHV(sead::Vector3f*, const sead::Vector3f&, f32, f32)

#include <l/Library/Math/MathUtil.h>

void al::parallelizeVec(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

void al::calcVectorSeparateHV(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

#include <l/Library/Math/MathUtil.h>

void al::limitVectorParallelVertical(sead::Vector3f*, const sead::Vector3f&, f32, f32)

#include <l/Library/Math/MathUtil.h>

void al::separateVectorParallelVertical(sead::Vector3f*, sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

bool al::addVectorLimit(sead::Vector3f*, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::alongVectorNormalH(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

f32 al::calcDistanceVecToPlane(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

void al::limitPlanePos(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

bool al::limitCylinderInPos(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::limitCylinderInDir(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

bool al::limitCylinderInPos(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::limitCylinderInDir(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

void al::snapVecToDirAxisY(sead::Vector3f*, const sead::Vector3f&, s32)

#include <l/Library/Math/MathUtil.h>

Axis al::calcNearVecFromAxis2(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

Axis al::calcNearVecFromAxis3(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

void al::calcDirVerticalAny(sead::Vector3f*, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

void al::calcDirSlide(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

Axis al::calcNearVecFromAxis3(sead::Vector3f*, const sead::Vector3f&, const sead::Quatf&)

#include <l/Library/Math/MathUtil.h>

void al::calcQuatLocalAxisAll(const sead::Quatf&, sead::Vector3f*, sead::Vector3f*, sead::Vector3f*)

#include <l/Library/Math/MathUtil.h>

void al::addRandomVector(sead::Vector3f*, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::turnRandomVector(sead::Vector3f*, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::makeAxisFrontUp(sead::Vector3f*, sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

void al::makeAxisFrontSide(sead::Vector3f*, sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

void al::makeAxisUpFront(sead::Vector3f*, sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

void al::makeAxisUpSide(sead::Vector3f*, sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

void al::makeQuatFromToQuat(sead::Quatf*, const sead::Quatf&, const sead::Quatf&)

#include <l/Library/Math/MathUtil.h>

void al::makeQuatRotationRate(sead::Quatf*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::makeQuatRotationLimit(sead::Quatf*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::makeQuatAxisRotation(sead::Quatf*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::makeQuatRotateDegree(sead::Quatf*, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::slerpQuat(sead::Quatf*, const sead::Quatf&, const sead::Quatf&, f32)

#include <l/Library/Math/MathUtil.h>

void al::calcQuatSide(sead::Vector3f* out, const sead::Quatf& quat)

#include <l/Library/Math/MathUtil.h>

void al::calcQuatUp(sead::Vector3f* out, const sead::Quatf& quat)

#include <l/Library/Math/MathUtil.h>

void al::calcQuatGravity(sead::Vector3f* out, const sead::Quatf& quat)

#include <l/Library/Math/MathUtil.h>

void al::calcQuatFront(sead::Vector3f* out, const sead::Quatf& quat)

#include <l/Library/Math/MathUtil.h>

f32 al::calcQuatUpY(const sead::Quatf&)

#include <l/Library/Math/MathUtil.h>

f32 al::calcQuatFrontY(const sead::Quatf&)

#include <l/Library/Math/MathUtil.h>

void al::calcQuatLocalAxis(sead::Vector3f*, const sead::Quatf&, s32)

#include <l/Library/Math/MathUtil.h>

void al::calcQuatLocalSignAxis(sead::Vector3f*, const sead::Quatf&, s32)

#include <l/Library/Math/MathUtil.h>

void al::calcQuatRotateDegree(sead::Vector3f*, const sead::Quatf&)

#include <l/Library/Math/MathUtil.h>

void al::calcQuatRotateRadian(sead::Vector3f*, const sead::Quatf&)

#include <l/Library/Math/MathUtil.h>

void al::calcQuatRotateAxisAndDegree(sead::Vector3f*, f32*, const sead::Quatf&)

#include <l/Library/Math/MathUtil.h>

void al::calcQuatRotateAxisAndDegree(sead::Vector3f*, f32*, const sead::Quatf&, const sead::Quatf&)

#include <l/Library/Math/MathUtil.h>

bool al::turnQuat(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::turnQuatXDirRadian(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::turnQuatYDirRadian(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::turnQuatZDirRadian(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::turnQuatXDirRate(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::turnQuatYDirRate(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::turnQuatZDirRate(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::tiltQuatDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::tiltQuatXDirDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::tiltQuatYDirDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::tiltQuatZDirDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::turnQuatWithAxisDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::turnQuatXDirWithYDirDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::turnQuatXDirWithZDirDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::turnQuatYDirWithZDirDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::turnQuatYDirWithXDirDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::turnQuatZDirWithXDirDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::turnQuatZDirWithYDirDegree(sead::Quatf*, const sead::Quatf&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::turnQuatZDirToTargetWithAxis(sead::Quatf*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::turnQuatFrontToDirDegreeH(sead::Quatf*, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::rotateQuatAndTransDegree(sead::Quatf*, sead::Vector3f*, const sead::Quatf&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::turnVecToVecDegree(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::turnVecToVecRate(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::turnVecToVecCos(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::turnVecToVecCosOnPlane(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::turnVecToVecCosOnPlane(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::rotateVectorCenterDegree(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::rotateVectorDegreeX(sead::Vector3f*, f32)

#include <l/Library/Math/MathUtil.h>

void al::rotateVectorDegreeY(sead::Vector3f*, f32)

#include <l/Library/Math/MathUtil.h>

void al::rotateVectorDegreeZ(sead::Vector3f*, f32)

#include <l/Library/Math/MathUtil.h>

void al::rotateVectorQuat(sead::Vector3f*, const sead::Quatf&)

#include <l/Library/Math/MathUtil.h>

f32 al::calcAreaTriangle(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

void al::createBoundingBox(const sead::Vector3f*, u32, sead::Vector3f*, sead::Vector3f*)

#include <l/Library/Math/MathUtil.h>

void al::updateBoundingBox(sead::Vector3f, sead::Vector3f*, sead::Vector3f*)

#include <l/Library/Math/MathUtil.h>

f32 al::calcDistanceToFarthestBoundingBoxVertex(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

void al::calcSphereMargeSpheres(sead::Vector3f*, f32*, const sead::Vector3f&, f32, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::calcCrossLinePoint(sead::Vector2f*, const sead::Vector2f&, const sead::Vector2f&, const sead::Vector2f&, const sead::Vector2f&)

#include <l/Library/Math/MathUtil.h>

f32 al::calcSquaredDistanceSegmentToSegment(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, sead::Vector3f*, sead::Vector3f*)

#include <l/Library/Math/MathUtil.h>

f32 al::calcSquaredDistancePointToSegment(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

f32 al::calcDistancePointToSegment(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

void al::calcPerpendicFootToLineInside(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

void al::calcClosestSegmentPoint(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

f32 al::calcCylinderRadiusDot(const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::checkHitSemilinePlane(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

bool al::checkHitSegmentPlane(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, bool)

#include <l/Library/Math/MathUtil.h>

bool al::checkHitLinePlane(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

bool al::checkHitSegmentSphere(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32, sead::Vector3f*, sead::Vector3f*)

#include <l/Library/Math/MathUtil.h>

bool al::checkHitSegmentSphereNearDepth(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32, sead::Vector3f*, sead::Vector3f*)

#include <l/Library/Math/MathUtil.h>

bool al::checkInCylinder(const sead::Vector3f&, const sead::Vector3f&, f32, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::checkHitSegmentCylinder(const sead::Vector3f&, f32, const sead::Vector3f&, f32, const sead::Vector3f&, const sead::Vector3f&, sead::Vector3f*, sead::Vector3f*)

#include <l/Library/Math/MathUtil.h>

bool al::checkHitHalfLineSphere(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

bool al::checkHitSegmentBox(const sead::Vector3f&, const sead::Vector3f&, const sead::BoundBox3f&, sead::Vector3f*)

#include <l/Library/Math/MathUtil.h>

bool al::checkHitPointCone(const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

#include <l/Library/Math/MathUtil.h>

bool al::checkHitSphereCone(const sead::Vector3f&, f32, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

#include <l/Library/Math/MathUtil.h>

bool al::checkHitSphereSpotLight(const sead::Vector3f&, f32, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

#include <l/Library/Math/MathUtil.h>

bool al::calcBoundingSphereSpotLight(sead::Vector3f*, f32*, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

#include <l/Library/Math/MathUtil.h>

void al::calcBoundingSphereBox3f(sead::Vector3f*, f32*, const sead::BoundBox3f&)

#include <l/Library/Math/MathUtil.h>

void al::calcArrowAabb(sead::BoundBox3f*, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

bool al::isNearCollideSphereAabb(const sead::Vector3f&, f32, const sead::BoundBox3f&)

#include <l/Library/Math/MathUtil.h>

void al::calcBoxFacePoint(sead::Vector3f[4], const sead::BoundBox3f&, Axis)

#include <l/Library/Math/MathUtil.h>

void al::calcBoxFacePoint(sead::Vector3f[4], const sead::BoundBox3f&, Axis, const sead::Matrix34f&)

#include <l/Library/Math/MathUtil.h>

void al::calcBoxFacePoint(sead::Vector3f[4], const sead::BoundBox3f&, Axis, const sead::Quatf&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

void al::calcFittingBoxPoseEqualAxisAll(sead::Quatf*, const sead::Quatf&, const sead::Quatf&)

#include <l/Library/Math/MathUtil.h>

void al::calcFittingBoxPoseEqualAxisNone(sead::Quatf*, const sead::Quatf&, const sead::Quatf&)

#include <l/Library/Math/MathUtil.h>

void al::calcFittingBoxPoseEqualAxisTwo(sead::Quatf*, const sead::Quatf&, const sead::Quatf&, s32)

#include <l/Library/Math/MathUtil.h>

void al::calcFittingBoxPose(sead::Quatf*, const sead::BoundBox3f&, const sead::Quatf&, const sead::Quatf&)

#include <l/Library/Math/MathUtil.h>

f32 al::calcSquaredDistanceToObb(const sead::Vector3f&, const sead::Matrix34f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

f32 al::calcDistanceToObb(const sead::Vector3f&, const sead::Matrix34f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

f32 al::calcSquaredDistanceToObb(const sead::Vector3f&, const sead::Matrix34f&, const sead::Vector3f&, const sead::BoundBox3f&)

#include <l/Library/Math/MathUtil.h>

f32 al::calcDistanceToObb(const sead::Vector3f&, const sead::Matrix34f&, const sead::Vector3f&, const sead::BoundBox3f&)

#include <l/Library/Math/MathUtil.h>

f32 al::calcSquaredDistanceToObb(const sead::Vector3f&, const sead::Matrix34f&)

#include <l/Library/Math/MathUtil.h>

f32 al::calcDistanceToObb(const sead::Vector3f&, const sead::Matrix34f&)

#include <l/Library/Math/MathUtil.h>

void al::calcObbCorners(sead::Vector3f*, const sead::Matrix34f&, const sead::BoundBox3f&)

#include <l/Library/Math/MathUtil.h>

bool al::calcTriangleInteriorAngleDegree(f32*, f32*, f32*, f32, f32, f32)

#include <l/Library/Math/MathUtil.h>

bool al::calcBetweenTwoLinkMtx(sead::Matrix34f*, sead::Matrix34f*, sead::Matrix34f*, const sead::Vector3f&, const sead::Vector3f&, f32, f32)

#include <l/Library/Math/MathUtil.h>

bool al::calcBetweenTwoLinkPos(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, f32, f32, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

bool al::calcReflectionVector(sead::Vector3f*, const sead::Vector3f&, f32, f32)

#include <l/Library/Math/MathUtil.h>

void al::calcReverseVector(sead::Vector3f*, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

f32 al::calcConvergeVibrationValue(f32, f32, f32, f32, f32)

#include <l/Library/Math/MathUtil.h>

bool al::calcSphericalPolarCoordPY(sead::Vector2f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Math/MathUtil.h>

void al::calcBezierPoint(sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

f32 al::calcSpringDumperForce(f32, f32, f32, f32)

#include <l/Library/Math/MathUtil.h>

f32 al::convertSpringEnergyToSpeed(f32, f32, f32)

#include <l/Library/Math/MathUtil.h>

const char* al::axisIndexToString(s32)

#include <l/Library/Math/MathUtil.h>

void al::visitCellsOverlapped(const sead::Vector3f&, const sead::Vector3f&, f32, const VisitCellCallBack&)

#include <l/Library/Math/MathUtil.h>

f32 al::calcMultValueToDestination(u32, f32, f32)

#include <l/Library/Math/MathUtil.h>

f32 al::getHaltonSequence(u32, u32)

#include <l/Library/Math/MathUtil.h>

f32 al::calcFractal(f32, f32, u32, f32, f32, f32, bool)

#include <l/Library/Math/MathUtil.h>

f32 al::calcMultiFractal(f32, f32, f32, u32, f32, f32, f32, bool)

#include <l/Library/Math/MathUtil.h>

f32 al::calcNormalDistribution(f32, f32, f32)

#include <l/Library/Math/MathUtil.h>

bool al::calcVecViewInput(sead::Vector3f*, const sead::Vector2f&, const sead::Vector3f&, const sead::Matrix34f*)

#include <l/Library/Math/MathUtil.h>

bool al::calcDirViewInput(sead::Vector3f*, const sead::Vector2f&, const sead::Vector3f&, const sead::Matrix34f*)

#include <l/Library/Math/MathUtil.h>

bool al::calcVecViewInput2D(sead::Vector3f*, const sead::Vector2f&, const sead::Vector3f&, const sead::Matrix34f*)

#include <l/Library/Math/MathUtil.h>

bool al::calcDirViewInput2D(sead::Vector3f*, const sead::Vector2f&, const sead::Vector3f&, const sead::Matrix34f*)

#include <l/Library/Math/MathUtil.h>

void al::calcBendPosAndFront(sead::Vector3f*, sead::Vector3f*, sead::Vector3f&, f32, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Math/MathUtil.h>

void al::pickUniformPointsOnCircleHammersley(sead::Vector2f* outPoint, f32 x, f32 y)

#include <l/Library/Math/MathUtil.h>

void al::makeBayerMatrix(s32*, s32)

#include <l/Library/Math/MathUtil.h>

u16 al::f32ToF16(f32)

#include <l/Library/Math/MathUtil.h>

f32 al::f16ToF32(u16)

#include <l/Library/Math/MathUtil.h>

void al::makeMtxRotateTrans(sead::Matrix34f* outMtx, const sead::Vector3f& rotate, const sead::Vector3f& trans)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxFromTwoAxis(sead::Matrix34f* outMtx, const sead::Vector3f& vectorA, const sead::Vector3f& vectorB, s32 axisA, s32 axisB)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxFrontUp(sead::Matrix34f* outMtx, const sead::Vector3f& front, const sead::Vector3f& up)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxFrontSide(sead::Matrix34f* outMtx, const sead::Vector3f& front, const sead::Vector3f& side)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxUpFront(sead::Matrix34f* outMtx, const sead::Vector3f& up, const sead::Vector3f& front)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxUpSide(sead::Matrix34f* outMtx, const sead::Vector3f& up, const sead::Vector3f& side)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxSideUp(sead::Matrix34f* outMtx, const sead::Vector3f& side, const sead::Vector3f& up)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxSideFront(sead::Matrix34f* outMtx, const sead::Vector3f& side, const sead::Vector3f& front)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxFrontNoSupport(sead::Matrix34f* outMtx, const sead::Vector3f& front)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxFrontNoSupportPos(sead::Matrix34f* outMtx, const sead::Vector3f& front, const sead::Vector3f& pos)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxUpNoSupport(sead::Matrix34f* outMtx, const sead::Vector3f& up)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxUpNoSupportPos(sead::Matrix34f* outMtx, const sead::Vector3f& up, const sead::Vector3f& pos)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxFrontUpPos(sead::Matrix34f* outMtx, const sead::Vector3f& front, const sead::Vector3f& up, const sead::Vector3f& pos)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxFrontSidePos(sead::Matrix34f* outMtx, const sead::Vector3f& front, const sead::Vector3f& side, const sead::Vector3f& pos)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxUpFrontPos(sead::Matrix34f* outMtx, const sead::Vector3f& up, const sead::Vector3f& front, const sead::Vector3f& pos)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxUpSidePos(sead::Matrix34f* outMtx, const sead::Vector3f& up, const sead::Vector3f& side, const sead::Vector3f& pos)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxSideUpPos(sead::Matrix34f* outMtx, const sead::Vector3f& side, const sead::Vector3f& up, const sead::Vector3f& pos)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxSideFrontPos(sead::Matrix34f* outMtx, const sead::Vector3f& side, const sead::Vector3f& front, const sead::Vector3f& pos)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxFollowTarget(sead::Matrix34f* outMtx, const sead::Matrix34f& baseMtx, const sead::Vector3f& trans, const sead::Vector3f& rotate)

#include <l/Library/Matrix/MatrixUtil.h>

void al::rotateMtxXDirDegree(sead::Matrix34f* outMtx, const sead::Matrix34f& baseMtx, f32 angle)

#include <l/Library/Matrix/MatrixUtil.h>

void al::rotateMtxYDirDegree(sead::Matrix34f* outMtx, const sead::Matrix34f& baseMtx, f32 angle)

#include <l/Library/Matrix/MatrixUtil.h>

void al::rotateMtxZDirDegree(sead::Matrix34f* outMtx, const sead::Matrix34f& baseMtx, f32 angle)

#include <l/Library/Matrix/MatrixUtil.h>

void al::calcMtxScale(sead::Vector3f* outMtx, const sead::Matrix34f& mtx)

#include <l/Library/Matrix/MatrixUtil.h>

void al::calcMtxScale(sead::Vector3f* outMtx, const Matrix43f& mtx)

#include <l/Library/Matrix/MatrixUtil.h>

void al::normalizeMtxScale(sead::Matrix34f* outMtx, const sead::Matrix34f& mtx)

#include <l/Library/Matrix/MatrixUtil.h>

bool al::tryNormalizeMtxScaleOrIdentity(sead::Matrix34f* outMtx, const sead::Matrix34f& mtx)

#include <l/Library/Matrix/MatrixUtil.h>

void al::preScaleMtx(sead::Matrix34f* outMtx, const sead::Vector3f& scale)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxSideNoSupport(sead::Matrix34f* outMtx, const sead::Vector3f& side)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxSideNoSupportPos(sead::Matrix34f* outMtx, const sead::Vector3f& side, const sead::Vector3f& pos)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxQuatPos(sead::Matrix34f* outMtx, const sead::Quatf& quat, const sead::Vector3f& pos)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxQuatScalePos(sead::Matrix34f* outMtx, const sead::Quatf& quat, const sead::Vector3f& scale, const sead::Vector3f& pos)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxQuatScalePos(sead::Matrix44f* outMtx, const sead::Quatf& quat, const sead::Vector3f& scale, const sead::Vector3f& pos)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxProj(sead::Matrix44f*, const sead::Vector2f&, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxProjFromQuatPoseUp(sead::Matrix44f*, const sead::Quatf&, const sead::Vector2f&, const sead::Vector3f&)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxProjFromQuatPoseFront(sead::Matrix44f*, const sead::Quatf&, const sead::Vector2f&, const sead::Vector3f&)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxProjFromQuatPoseSide(sead::Matrix44f*, const sead::Quatf&, const sead::Vector2f&, const sead::Vector3f&)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtxProjFromUp(sead::Matrix44f*, const sead::Vector2f&, const sead::Vector3f&)

#include <l/Library/Matrix/MatrixUtil.h>

void al::rotateMtxCenterPosXDirDegree(sead::Matrix34f*, const sead::Matrix34f&, const sead::Vector3f&, f32)

#include <l/Library/Matrix/MatrixUtil.h>

void al::rotateMtxCenterPosAxisDegree(sead::Matrix34f*, const sead::Matrix34f&, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Matrix/MatrixUtil.h>

void al::rotateMtxCenterPosYDirDegree(sead::Matrix34f*, const sead::Matrix34f&, const sead::Vector3f&, f32)

#include <l/Library/Matrix/MatrixUtil.h>

void al::rotateMtxCenterPosZDirDegree(sead::Matrix34f*, const sead::Matrix34f&, const sead::Vector3f&, f32)

#include <l/Library/Matrix/MatrixUtil.h>

void al::rotateMtxCenterPosQuat(sead::Matrix34f*, const sead::Matrix34f&, const sead::Vector3f&, const sead::Quatf&)

#include <l/Library/Matrix/MatrixUtil.h>

bool al::turnMtxXDirDegree(sead::Matrix34f*, const sead::Matrix34f&, const sead::Vector3f&, f32)

#include <l/Library/Matrix/MatrixUtil.h>

bool al::turnMtxYDirDegree(sead::Matrix34f*, const sead::Matrix34f&, const sead::Vector3f&, f32)

#include <l/Library/Matrix/MatrixUtil.h>

bool al::turnMtxZDirDegree(sead::Matrix34f*, const sead::Matrix34f&, const sead::Vector3f&, f32)

#include <l/Library/Matrix/MatrixUtil.h>

void al::calcCameraPosFromViewMtx(sead::Vector3f*, const sead::Matrix34f&)

#include <l/Library/Matrix/MatrixUtil.h>

void al::calcMtxMul(sead::Vector3f*, const sead::Matrix34f&, const sead::Vector3f&)

#include <l/Library/Matrix/MatrixUtil.h>

void al::calcMtxMul(sead::Vector3f*, const Matrix43f&, const sead::Vector3f&)

#include <l/Library/Matrix/MatrixUtil.h>

void al::calcMtxLocalTrans(sead::Vector3f*, const sead::Matrix34f&, const sead::Vector3f&)

#include <l/Library/Matrix/MatrixUtil.h>

void al::calcTransLocalOffsetByMtx(sead::Vector3f*, const sead::Matrix34f&, const sead::Vector3f&)

#include <l/Library/Matrix/MatrixUtil.h>

void al::addTransMtxLocalOffset(sead::Matrix34f*, const sead::Matrix34f&, const sead::Vector3f&)

#include <l/Library/Matrix/MatrixUtil.h>

void al::blendMtx(sead::Matrix34f*, const sead::Matrix34f&, const sead::Matrix34f&, f32)

#include <l/Library/Matrix/MatrixUtil.h>

void al::blendMtxRotate(sead::Matrix34f*, const sead::Matrix34f&, const sead::Matrix34f&, f32)

#include <l/Library/Matrix/MatrixUtil.h>

void al::blendMtxTrans(sead::Matrix34f*, const sead::Matrix34f&, const sead::Matrix34f&, f32)

#include <l/Library/Matrix/MatrixUtil.h>

f32 al::calcMtxLocalDirAngleOnPlaneToTarget(const sead::Matrix34f*, const sead::Vector3f&, s32, s32)

#include <l/Library/Matrix/MatrixUtil.h>

f32 al::calcMtxLocalDirAngleOnPlaneToDir(const sead::Matrix34f*, const sead::Vector3f&, s32, s32)

#include <l/Library/Matrix/MatrixUtil.h>

bool al::calcRotAxisOrZero(sead::Vector3f*, const sead::Matrix34f&)

#include <l/Library/Matrix/MatrixUtil.h>

void al::calcMxtInvertOrtho(sead::Matrix34f*, const sead::Matrix34f&)

#include <l/Library/Matrix/MatrixUtil.h>

void al::calcNearFarByInvProjection(f32*, f32*, const sead::Matrix44f&)

#include <l/Library/Matrix/MatrixUtil.h>

void al::calcMovedInertiaTensor(sead::Matrix33f*, const sead::Matrix33f&, const sead::Vector3f&, f32)

#include <l/Library/Matrix/MatrixUtil.h>

void al::calcInertiaTensorByMovedTensorAndCenter(sead::Matrix33f*, const sead::Matrix33f&, const sead::Vector3f&, f32)

#include <l/Library/Matrix/MatrixUtil.h>

void al::calcInertiaTensorSphere(sead::Matrix33f*, f32, f32)

#include <l/Library/Matrix/MatrixUtil.h>

void al::calcInertiaTensorBox(sead::Matrix33f*, const sead::Vector3f&, f32)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtx34f(sead::Matrix34f*, const nn::util::neon::MatrixColumnMajor4x3fType&)

#include <l/Library/Matrix/MatrixUtil.h>

void al::makeMtx44f(sead::Matrix44f*, const nn::util::neon::MatrixColumnMajor4x4fType&)

#include <l/Library/Matrix/MatrixUtil.h>

sead::Heap* al::getStationedHeap()

#include <l/Library/Memory/HeapUtil.h>

sead::Heap* al::getSequenceHeap()

#include <l/Library/Memory/HeapUtil.h>

sead::Heap* al::getSceneResourceHeap()

#include <l/Library/Memory/HeapUtil.h>

sead::Heap* al::getSceneHeap()

#include <l/Library/Memory/HeapUtil.h>

sead::Heap* al::getCourseSelectResourceHeap()

#include <l/Library/Memory/HeapUtil.h>

sead::Heap* al::getCourseSelectHeap()

#include <l/Library/Memory/HeapUtil.h>

sead::Heap* al::getWorldResourceHeap()

#include <l/Library/Memory/HeapUtil.h>

sead::Heap* al::tryFindNamedHeap(const char* heapName)

#include <l/Library/Memory/HeapUtil.h>

sead::Heap* al::findNamedHeap(const char* heapName)

#include <l/Library/Memory/HeapUtil.h>

void al::addNamedHeap(sead::Heap* heap, const char* heapName)

#include <l/Library/Memory/HeapUtil.h>

void al::removeNamedHeap(const char* heapName)

#include <l/Library/Memory/HeapUtil.h>

void al::createSequenceHeap()

#include <l/Library/Memory/HeapUtil.h>

void al::freeAllSequenceHeap()

#include <l/Library/Memory/HeapUtil.h>

bool al::printAllSequenceHeap()

#include <l/Library/Memory/HeapUtil.h>

void al::createSceneHeap(const char* stageName, bool backwards)

#include <l/Library/Memory/HeapUtil.h>

void al::createSceneResourceHeap(const char* stageName)

#include <l/Library/Memory/HeapUtil.h>

bool al::isCreatedSceneResourceHeap()

#include <l/Library/Memory/HeapUtil.h>

void al::destroySceneHeap(bool removeCategory)

#include <l/Library/Memory/HeapUtil.h>

void al::createCourseSelectHeap()

#include <l/Library/Memory/HeapUtil.h>

void al::destroyCourseSelectHeap()

#include <l/Library/Memory/HeapUtil.h>

void al::createWorldResourceHeap(bool useCategory)

#include <l/Library/Memory/HeapUtil.h>

void al::destroyWorldResourceHeap(bool removeCategory)

#include <l/Library/Memory/HeapUtil.h>

void al::loadPlayerResource(const char* categoryName)

#include <l/Library/Memory/HeapUtil.h>

void al::freePlayerResource(const char* categoryName)

#include <l/Library/Memory/HeapUtil.h>

void al::setAudioResourceDirectorToMemorySystem(AudioResourceDirector* audioResourceDirector)

#include <l/Library/Memory/HeapUtil.h>

const char* al::getLanguage()

#include <l/Library/Message/MessageHolder.h>

const char* al::getLayoutMessageArcName()

#include <l/Library/Message/MessageHolder.h>

bool al::isMessageTagMark(char16)

#include <l/Library/Message/MessageHolder.h>

bool al::isMessageTagEndMark(char16)

#include <l/Library/Message/MessageHolder.h>

bool al::isMessageTagPageBreak(const IUseMessageSystem*, const char16*)

#include <l/Library/Message/MessageHolder.h>

bool al::isMessageTagPageBreak(const IUseMessageSystem*, const MessageTag&)

#include <l/Library/Message/MessageHolder.h>

bool al::isMessageTagPageBreak(const MessageProjectEx*, const MessageTag&)

#include <l/Library/Message/MessageHolder.h>

const char* al::getMessageTagGroupName(const MessageProjectEx*, s32)

#include <l/Library/Message/MessageHolder.h>

const char* al::getMessageTagGroupName(const IUseMessageSystem*, s32)

#include <l/Library/Message/MessageHolder.h>

const char* al::getMessageTagName(const MessageProjectEx*, s32, s32)

#include <l/Library/Message/MessageHolder.h>

const char* al::getMessageTagName(const IUseMessageSystem*, s32, s32)

#include <l/Library/Message/MessageHolder.h>

bool al::isExistMessageTag(const char16*)

#include <l/Library/Message/MessageHolder.h>

s32 al::calcMessageSizeWithoutNullCharacter(const char16*, const char16*)

#include <l/Library/Message/MessageHolder.h>

bool al::isExistMessageTagTextPaneAnim(const IUseMessageSystem*, const char16*)

#include <l/Library/Message/MessageHolder.h>

bool al::tryGetMessageTagTextAnim(sead::BufferedSafeString*, const IUseMessageSystem*, const char16*)

#include <l/Library/Message/MessageHolder.h>

bool al::isMessageTagVoice(const IUseMessageSystem*, const char16*)

#include <l/Library/Message/MessageHolder.h>

void al::getMessageTagVoiceName(sead::BufferedSafeString*, const IUseMessageSystem*, const char16*)

#include <l/Library/Message/MessageHolder.h>

bool al::tryGetMessageTagVoiceNameInPage(sead::BufferedSafeString*, const IUseMessageSystem*, const char16*)

#include <l/Library/Message/MessageHolder.h>

bool al::isMessageTagPictFont(const IUseMessageSystem*, s32)

#include <l/Library/Message/MessageHolder.h>

bool al::isMessageTagDeviceFont(const IUseMessageSystem*, s32)

#include <l/Library/Message/MessageHolder.h>

bool al::isExistMessageTagPadSwitch(const IUseMessageSystem*, const char16*, s32)

#include <l/Library/Message/MessageHolder.h>

bool al::isMessageTagPadStyle(const IUseMessageSystem*, s32, s32)

#include <l/Library/Message/MessageHolder.h>

bool al::isMessageTagPadPair(const IUseMessageSystem*, s32, s32)

#include <l/Library/Message/MessageHolder.h>

bool al::isMessageTagPadStyle2P(const IUseMessageSystem*, s32, s32)

#include <l/Library/Message/MessageHolder.h>

bool al::isMessageTagAlignLeft(const IUseMessageSystem*, s32, s32)

#include <l/Library/Message/MessageHolder.h>

bool al::isMessageTagAlignCenter(const IUseMessageSystem*, s32, s32)

#include <l/Library/Message/MessageHolder.h>

void al::replaceMessageTagString(sead::WBufferedSafeString*, const IUseMessageSystem*, const char16*, const char16*)

#include <l/Library/Message/MessageHolder.h>

void al::replaceMessageTagTimeDirectRaceTime(sead::WBufferedSafeString*, const IUseMessageSystem*, ReplaceTimeInfo&)

#include <l/Library/Message/MessageHolder.h>

const char16* al::getSystemMessageString(const IUseMessageSystem*, const char*, const char*)

#include <l/Library/Message/MessageHolder.h>

void al::replaceMessageTagTimeDirectDate(sead::WBufferedSafeString*, const IUseMessageSystem*, ReplaceTimeInfo&)

#include <l/Library/Message/MessageHolder.h>

void al::replaceMessageTagTimeDirectDateDetail(sead::WBufferedSafeString*, const IUseMessageSystem*, ReplaceTimeInfo&)

#include <l/Library/Message/MessageHolder.h>

void al::replaceMessageTagScore(sead::WBufferedSafeString*, const IUseMessageSystem*, const char16*, s32, const char*)

#include <l/Library/Message/MessageHolder.h>

void al::replaceMessageTagCoinNum(sead::WBufferedSafeString*, const IUseMessageSystem*, const char16*, s32, const char*)

#include <l/Library/Message/MessageHolder.h>

void al::replaceMessageTagAmiiboName(sead::WBufferedSafeString*, const IUseMessageSystem*, const char16*, const char*, const char*)

#include <l/Library/Message/MessageHolder.h>

void al::replaceMessageTagUserName(sead::WBufferedSafeString*, const IUseMessageSystem*, const char16*, const char16*, const char*)

#include <l/Library/Message/MessageHolder.h>

void al::replaceMessageTagNamedString(sead::WBufferedSafeString*, const IUseMessageSystem*, const char16*, const char16*, const char*)

#include <l/Library/Message/MessageHolder.h>

void al::replaceMessageTagTime(sead::WBufferedSafeString*, const IUseMessageSystem*, const char16*, ReplaceTimeInfo&, const char*)

#include <l/Library/Message/MessageHolder.h>

void al::createReplaceTimeInfoForRaceTime(ReplaceTimeInfo*, s32, s32, s32)

#include <l/Library/Message/MessageHolder.h>

void al::createReplaceTimeInfoForDateTime(ReplaceTimeInfo*, u64)

#include <l/Library/Message/MessageHolder.h>

void al::replacePaneDateTime(LayoutActor*, const char*, u64)

#include <l/Library/Message/MessageHolder.h>

MessageTagDataHolder* al::initMessageTagDataHolder(s32)

#include <l/Library/Message/MessageHolder.h>

void al::registerMessageTagDataScore(MessageTagDataHolder*, const char*, const s32*)

#include <l/Library/Message/MessageHolder.h>

void al::registerMessageTagDataCoinNum(MessageTagDataHolder*, const char*, const s32*)

#include <l/Library/Message/MessageHolder.h>

void al::registerMessageTagDataUserName(MessageTagDataHolder*, const char*, const char16**)

#include <l/Library/Message/MessageHolder.h>

void al::registerMessageTagDataAmiiboName(MessageTagDataHolder*, const char*, const char**)

#include <l/Library/Message/MessageHolder.h>

void al::registerMessageTagDataString(MessageTagDataHolder*, const char*, const char16**)

#include <l/Library/Message/MessageHolder.h>

void al::replaceMessageTagData(sead::WBufferedSafeString*, const IUseMessageSystem*, const MessageTagDataHolder*, const char16*)

#include <l/Library/Message/MessageHolder.h>

s32 al::calcMessageSizeWithoutTag(const char16*, const char16*)

#include <l/Library/Message/MessageHolder.h>

bool al::isExistLayoutMessage(const IUseMessageSystem*, const char*)

#include <l/Library/Message/MessageHolder.h>

bool al::isExistSystemMessage(const IUseMessageSystem*, const char*)

#include <l/Library/Message/MessageHolder.h>

bool al::isExistStageMessage(const IUseMessageSystem*, const char*)

#include <l/Library/Message/MessageHolder.h>

bool al::isExistLabelInLayoutMessage(const IUseMessageSystem*, const char*, const char*)

#include <l/Library/Message/MessageHolder.h>

bool al::isExistLabelInSystemMessage(const IUseMessageSystem*, const char*, const char*)

#include <l/Library/Message/MessageHolder.h>

bool al::isExistLabelInStageMessage(const IUseMessageSystem*, const char*, const char*)

#include <l/Library/Message/MessageHolder.h>

s32 al::calcSystemMessageCharacterNum(const IUseMessageSystem*, const char*, const char*)

#include <l/Library/Message/MessageHolder.h>

s32 al::calcSystemMessageCharacterNumWithoutTag(const IUseMessageSystem*, const char*, const char*)

#include <l/Library/Message/MessageHolder.h>

const char16* al::getLayoutMessageString(const IUseMessageSystem*, const char*, const char*)

#include <l/Library/Message/MessageHolder.h>

const char16* al::getStageMessageString(const IUseMessageSystem*, const char*, const char*)

#include <l/Library/Message/MessageHolder.h>

bool al::tryGetStageMessageString(const char16**, const IUseMessageSystem*, const char*, const char*)

#include <l/Library/Message/MessageHolder.h>

const char16* al::getLayoutMessageString(const IUseMessageSystem*, const char*, s32)

#include <l/Library/Message/MessageHolder.h>

const char16* al::getSystemMessageString(const IUseMessageSystem*, const char*, s32)

#include <l/Library/Message/MessageHolder.h>

s32 al::getSystemMessageLabelNum(const IUseMessageSystem*, const char*)

#include <l/Library/Message/MessageHolder.h>

s32 al::getLayoutMessageLabelNum(const IUseMessageSystem*, const char*)

#include <l/Library/Message/MessageHolder.h>

const char* al::getMessageTagParamName(const IUseMessageSystem*, const MessageTag&, s32)

#include <l/Library/Message/MessageHolder.h>

s32 al::getMessageTagParamNum(const IUseMessageSystem*, const MessageTag&)

#include <l/Library/Message/MessageHolder.h>

void al::getMessageTagParamString(sead::WBufferedSafeString*, const IUseMessageSystem*, const MessageTag&, s32)

#include <l/Library/Message/MessageHolder.h>

void al::getSystemMessageLabelString(sead::BufferedSafeString*, const IUseMessageSystem*, const char*, s32)

#include <l/Library/Message/MessageHolder.h>

void al::getLayoutMessageLabelString(sead::BufferedSafeString*, const IUseMessageSystem*, const char*, s32)

#include <l/Library/Message/MessageHolder.h>

void al::getMessageLine(char16*, u32, const char16*, u32)

#include <l/Library/Message/MessageHolder.h>

s32 al::countMessageLine(const char16*)

#include <l/Library/Message/MessageHolder.h>

bool al::copyMessageExpandTag(char16*, s32, const IUseMessageSystem*, const char16*)

#include <l/Library/Message/MessageHolder.h>

bool al::copyMessageWithoutTag(char16*, s32, const char16*)

#include <l/Library/Message/MessageHolder.h>

bool al::copyMessageWithoutRubyTag(char16*, s32, const IUseMessageSystem*, const char16*)

#include <l/Library/Message/MessageHolder.h>

void al::copyMessageWithoutTagExpandRuby(char16*, s32, const IUseMessageSystem*, const char16*)

#include <l/Library/Message/MessageHolder.h>

s32 al::copyMessageWithTag(char16*, s32, const char16*)

#include <l/Library/Message/MessageHolder.h>

s32 al::copyMessageWithTagOnlyCurrentPage(const IUseMessageSystem*, char16*, s32, const char16*, s32)

#include <l/Library/Message/MessageHolder.h>

const char16* al::getMessageWithPage(const IUseMessageSystem*, const char16*, s32)

#include <l/Library/Message/MessageHolder.h>

void al::copyMessageOnlyRuby(char16*, s32, const IUseMessageSystem*, const char16*)

#include <l/Library/Message/MessageHolder.h>

s32 al::countMessagePage(const IUseMessageSystem*, const char16*, s32)

#include <l/Library/Message/MessageHolder.h>

const char16* al::getNextMessagePage(const IUseMessageSystem*, const char16*)

#include <l/Library/Message/MessageHolder.h>

void* al::getPictureFont(const LayoutSystem*)

#include <l/Library/Message/MessageHolder.h>

bool al::isGreaterEqualMaxLodLevelNoClamp(const ModelKeeper* modelKeeper)

#include <l/Library/Model/ModelShapeUtil.h>

bool al::isLessMaxLodLevelNoClamp(const ModelKeeper* modelKeeper)

#include <l/Library/Model/ModelShapeUtil.h>

void al::setModelProjMtx0(const ModelKeeper*, const sead::Matrix44f&)

#include <l/Library/Model/ModelShapeUtil.h>

RailMoveMovement* al::tryCreateRailMoveMovement(LiveActor* host, const ActorInitInfo& info)

#include <l/Library/Movement/RailMoveMovement.h>

void al::registerFluidSurfaceObj(IUseFluidSurface*, const LiveActor*)

#include <l/Library/Nature/NatureUtil.h>

bool al::isExistFluidSurface(const LiveActor*)

#include <l/Library/Nature/NatureUtil.h>

void al::setWaterRippleFieldScale(const LiveActor*, f32)

#include <l/Library/Nature/NatureUtil.h>

bool al::isInWaterPos(const LiveActor*, const sead::Vector3f&)

#include <l/Library/Nature/NatureUtil.h>

bool al::isInWater(const LiveActor*)

#include <l/Library/Nature/NatureUtil.h>

bool al::isInWaterNoIgnore(const LiveActor*, const sead::Vector3f&)

#include <l/Library/Nature/NatureUtil.h>

bool al::isInSodaWater(const LiveActor*, const sead::Vector3f&)

#include <l/Library/Nature/NatureUtil.h>

bool al::isInIceWaterPos(const LiveActor*, const sead::Vector3f&)

#include <l/Library/Nature/NatureUtil.h>

bool al::isInIceWater(const LiveActor*)

#include <l/Library/Nature/NatureUtil.h>

bool al::isInFirePos(const LiveActor*, const sead::Vector3f&)

#include <l/Library/Nature/NatureUtil.h>

bool al::isInFire(const LiveActor*)

#include <l/Library/Nature/NatureUtil.h>

bool al::isInCloudPos(const LiveActor*, const sead::Vector3f&)

#include <l/Library/Nature/NatureUtil.h>

bool al::isInCloud(const LiveActor*)

#include <l/Library/Nature/NatureUtil.h>

bool al::tryAddRippleMiddle(const LiveActor*)

#include <l/Library/Nature/NatureUtil.h>

bool al::tryAddRippleLarge(const LiveActor*)

#include <l/Library/Nature/NatureUtil.h>

bool al::isWaterAreaIgnore(const AreaObj*)

#include <l/Library/Nature/NatureUtil.h>

const char* al::getFireMaterialCode(const LiveActor*)

#include <l/Library/Nature/NatureUtil.h>

bool al::calcFindWaterSurface(sead::Vector3f*, sead::Vector3f*, const LiveActor*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Nature/NatureUtil.h>

bool al::calcFindWaterSurfaceFlat(sead::Vector3f*, sead::Vector3f*, const LiveActor*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Nature/NatureUtil.h>

bool al::calcFindWaterSurfaceDisplacement(sead::Vector3f*, sead::Vector3f*, const LiveActor*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Nature/NatureUtil.h>

bool al::calcFindWaterSurfaceOverGround(sead::Vector3f*, sead::Vector3f*, const LiveActor*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Nature/NatureUtil.h>

bool al::calcFindFireSurface(sead::Vector3f*, sead::Vector3f*, const LiveActor*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Nature/NatureUtil.h>

bool al::calcFindCloudSurface(sead::Vector3f*, sead::Vector3f*, const LiveActor*, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Nature/NatureUtil.h>

bool al::tryAddRipple(const NatureDirector*, const sead::Vector3f&, f32, f32)

#include <l/Library/Nature/NatureUtil.h>

bool al::tryAddRippleTiny(const LiveActor*)

#include <l/Library/Nature/NatureUtil.h>

bool al::tryAddRippleSmall(const LiveActor*, const sead::Vector3f&)

#include <l/Library/Nature/NatureUtil.h>

bool al::tryAddRippleTiny(const LiveActor*, const sead::Vector3f&)

#include <l/Library/Nature/NatureUtil.h>

bool al::tryAddRippleSmall(const LiveActor*)

#include <l/Library/Nature/NatureUtil.h>

bool al::tryAddRippleMiddle(const LiveActor*, const sead::Vector3f&)

#include <l/Library/Nature/NatureUtil.h>

bool al::tryAddRippleLarge(const LiveActor*, const sead::Vector3f&)

#include <l/Library/Nature/NatureUtil.h>

bool al::tryAddRippleWithRange(const LiveActor*, const sead::Vector3f&, f32, f32, f32, f32)

#include <l/Library/Nature/NatureUtil.h>

bool al::tryAddRipple(const LiveActor*, const sead::Vector3f&, f32, f32)

#include <l/Library/Nature/NatureUtil.h>

bool al::tryAddRippleRandomBlur(const LiveActor*, const sead::Vector3f&, f32, f32, f32)

#include <l/Library/Nature/NatureUtil.h>

bool al::tryAddQuadRipple(const LiveActor*, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, const sead::Vector3f&, f32)

#include <l/Library/Nature/NatureUtil.h>

bool al::tryAddQuadRipple(const LiveActor*, const sead::BoundBox3f&, const sead::Vector3f&, const sead::Quatf&, f32, f32)

#include <l/Library/Nature/NatureUtil.h>

bool al::tryAddQuadRippleByBoxRotateY(const LiveActor*, const sead::BoundBox3f&, const sead::Vector3f&, f32, f32, f32)

#include <l/Library/Nature/NatureUtil.h>

void al::approachWaterSurfaceSpringDumper(LiveActor*, const WaterSurfaceFinder*, f32, f32, f32, f32, f32)

#include <l/Library/Nature/NatureUtil.h>

void al::approachFireSurfaceSpringDumper(LiveActor*, const FireSurfaceFinder*, f32, f32, f32, f32, f32)

#include <l/Library/Nature/NatureUtil.h>

void al::approachWaterSurfaceRate(LiveActor*, const WaterSurfaceFinder*, f32, f32, f32)

#include <l/Library/Nature/NatureUtil.h>

void al::approachFireSurfaceRate(LiveActor*, const FireSurfaceFinder*, f32, f32, f32)

#include <l/Library/Nature/NatureUtil.h>

void al::keepWaterSurfaceHeight(LiveActor*, const WaterSurfaceFinder*, f32)

#include <l/Library/Nature/NatureUtil.h>

void al::syncWaterSurfaceTrans(LiveActor*, const WaterSurfaceFinder*)

#include <l/Library/Nature/NatureUtil.h>

void al::syncFireSurfaceTrans(LiveActor*, const FireSurfaceFinder*)

#include <l/Library/Nature/NatureUtil.h>

void al::syncWaterSurfaceTransH(LiveActor*, const WaterSurfaceFinder*)

#include <l/Library/Nature/NatureUtil.h>

void al::blendWaterSurfaceTransH(LiveActor*, const WaterSurfaceFinder*, f32)

#include <l/Library/Nature/NatureUtil.h>

void al::syncWaterSurfaceUp(LiveActor*, const WaterSurfaceFinder*, f32)

#include <l/Library/Nature/NatureUtil.h>

void al::syncFireSurfaceUp(LiveActor*, const FireSurfaceFinder*, f32)

#include <l/Library/Nature/NatureUtil.h>

void al::calcMatrixFromActorPoseAndWaterSurfaceH(sead::Matrix34f*, const WaterSurfaceFinder*, const LiveActor*)

#include <l/Library/Nature/NatureUtil.h>

void al::setNerve(IUseNerve* user, const Nerve* nerve)

#include <l/Library/Nerve/NerveUtil.h>

void al::setNerveAtStep(IUseNerve* user, const Nerve* nerve, s32 step)

#include <l/Library/Nerve/NerveUtil.h>

bool al::isStep(const IUseNerve* user, s32 step)

#include <l/Library/Nerve/NerveUtil.h>

void al::setNerveAtGreaterEqualStep(IUseNerve* user, const Nerve* nerve, s32 step)

#include <l/Library/Nerve/NerveUtil.h>

bool al::isNerve(const IUseNerve* user, const Nerve* nerve)

#include <l/Library/Nerve/NerveUtil.h>

s32 al::getNerveStep(const IUseNerve* user)

#include <l/Library/Nerve/NerveUtil.h>

const Nerve* al::getCurrentNerve(const IUseNerve* user)

#include <l/Library/Nerve/NerveUtil.h>

bool al::isFirstStep(const IUseNerve* user)

#include <l/Library/Nerve/NerveUtil.h>

bool al::isGreaterStep(const IUseNerve* user, s32 step)

#include <l/Library/Nerve/NerveUtil.h>

bool al::isGreaterEqualStep(const IUseNerve* user, s32 step)

#include <l/Library/Nerve/NerveUtil.h>

bool al::isLessStep(const IUseNerve* user, s32 step)

#include <l/Library/Nerve/NerveUtil.h>

bool al::isLessEqualStep(const IUseNerve* user, s32 step)

#include <l/Library/Nerve/NerveUtil.h>

bool al::isInRangeStep(const IUseNerve* user, s32 startStep, s32 endStep)

#include <l/Library/Nerve/NerveUtil.h>

bool al::isIntervalStep(const IUseNerve* user, s32 interval, s32 offset)

#include <l/Library/Nerve/NerveUtil.h>

bool al::isIntervalOnOffStep(const IUseNerve* user, s32 interval, s32 offset)

#include <l/Library/Nerve/NerveUtil.h>

bool al::isNewNerve(const IUseNerve* user)

#include <l/Library/Nerve/NerveUtil.h>

s32 al::calcNerveInterval(const IUseNerve* user, s32 interval, s32 offset)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveRate(const IUseNerve* user, s32 max)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveRate(const IUseNerve* user, s32 min, s32 max)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveEaseInRate(const IUseNerve* user, s32 max)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveEaseInRate(const IUseNerve* user, s32 min, s32 max)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveEaseOutRate(const IUseNerve* user, s32 max)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveEaseOutRate(const IUseNerve* user, s32 min, s32 max)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveEaseInOutRate(const IUseNerve* user, s32 max)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveEaseInOutRate(const IUseNerve* user, s32 min, s32 max)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveSquareInRate(const IUseNerve* user, s32 max)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveSquareInRate(const IUseNerve* user, s32 min, s32 max)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveSquareOutRate(const IUseNerve* user, s32 max)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveSquareOutRate(const IUseNerve* user, s32 min, s32 max)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveEaseByTypeRate(const IUseNerve* user, s32 max, s32 type)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveEaseByTypeRate(const IUseNerve* user, s32 min, s32 max, s32 type)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNervePowerInRate(const IUseNerve* user, s32 max, f32 power)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNervePowerInRate(const IUseNerve* user, s32 min, s32 max, f32 power)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNervePowerOutRate(const IUseNerve* user, s32 max, f32 power)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNervePowerOutRate(const IUseNerve* user, s32 min, s32 max, f32 power)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveJumpRate(const IUseNerve* user, s32 inMax, s32 upDuration, s32 release)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveEaseInValue(const IUseNerve* user, s32 min, s32 max, f32 start, f32 end)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveStartEndRate(const IUseNerve* user, s32 inMax, s32 upDuration, s32 release)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveEaseInOutValue(const IUseNerve* user, s32 min, s32 max, f32 start, f32 end)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveValue(const IUseNerve* user, s32 max, f32 start, f32 end)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveValue(const IUseNerve* user, s32 min, s32 max, f32 start, f32 end)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveEaseInValue(const IUseNerve* user, s32 max, f32 start, f32 end)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveEaseOutValue(const IUseNerve* user, s32 max, f32 start, f32 end)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveEaseOutValue(const IUseNerve* user, s32 min, s32 max, f32 start, f32 end)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveEaseInOutValue(const IUseNerve* user, s32 max, f32 start, f32 end)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveSquareInValue(const IUseNerve* user, s32 max, f32 start, f32 end)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveSquareInValue(const IUseNerve* user, s32 min, s32 max, f32 start, f32 end)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveSquareOutValue(const IUseNerve* user, s32 max, f32 start, f32 end)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveSquareOutValue(const IUseNerve* user, s32 min, s32 max, f32 start, f32 end)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveEaseByTypeValue(const IUseNerve* user, s32 max, f32 start, f32 end, s32 type)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveEaseByTypeValue(const IUseNerve* user, s32 min, s32 max, f32 start, f32 end, s32 type)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveCosCycle(const IUseNerve* user, s32 max)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveSinCycle(const IUseNerve* user, s32 max)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveRepeatRate(const IUseNerve* user, s32 max)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveRepeatDegree(const IUseNerve* user, s32 max)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveJumpValue(const IUseNerve* user, s32 inMax, s32 upDuration, s32 release, f32 factor)

#include <l/Library/Nerve/NerveUtil.h>

f32 al::calcNerveStartEndValue(const IUseNerve* user, s32 inMax, s32 upDuration, s32 release, f32 start, f32 end)

#include <l/Library/Nerve/NerveUtil.h>

void al::initNerveState(IUseNerve* user, NerveStateBase* state, const Nerve* nerve, const char* name)

#include <l/Library/Nerve/NerveUtil.h>

void al::addNerveState(IUseNerve* user, NerveStateBase* state, const Nerve* nerve, const char* name)

#include <l/Library/Nerve/NerveUtil.h>

bool al::updateNerveState(IUseNerve* user)

#include <l/Library/Nerve/NerveUtil.h>

bool al::updateNerveStateAndNextNerve(IUseNerve* user, const Nerve* nerve)

#include <l/Library/Nerve/NerveUtil.h>

bool al::isStateEnd(const IUseNerve* user)

#include <l/Library/Nerve/NerveUtil.h>

bool al::isAnyNfcTagDetected(const NfpInfo& nfpInfo)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isNormalNfc(const NfpInfo& nfpInfo)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isAmiibo(const NfpInfo& nfpInfo)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isEqualUniqueNfcId(const NfpInfo& nfpInfoA, const NfpInfo& nfpInfoB)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isEqualUniqueNfcId(const nn::nfp::TagInfo& tagInfoA, const nn::nfp::TagInfo& tagInfoB)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isEqualCharacterId(const NfpInfo& nfpInfo, NfpCharacterId characterId)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isEqualCharacterId(const nn::nfp::ModelInfo& modelInfo, const NfpCharacterId& characterId)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isEqualCharacterIdBase(const NfpInfo& nfpInfo, NfpCharacterId characterId)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isEqualNumberingId(const NfpInfo& nfpInfo, s32 numberingId)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isEqualNumberingId(const nn::nfp::ModelInfo& modelInfo, s32 numberingId)

#include <l/Library/Nfp/NfpFunction.h>

bool al::tryGetCharacterId(NfpCharacterId* characterId, const NfpInfo& nfpInfo)

#include <l/Library/Nfp/NfpFunction.h>

bool al::tryGetNumberingId(s32* numberingId, const NfpInfo& nfpInfo)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isCharacterIdBaseMario(const NfpInfo& nfpInfo)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isCharacterIdBaseDrMario(const NfpInfo& nfpInfo)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isCharacterIdBasePeach(const NfpInfo& nfpInfo)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isCharacterIdBaseKoopa(const NfpInfo& nfpInfo)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isCharacterIdBaseYoshi(const NfpInfo& nfpInfo)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isCharacterIdBaseKinopio(const NfpInfo& nfpInfo)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isNeedFormat(const NfpInfo& nfpInfo)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isNeedRestore(const NfpInfo& nfpInfo)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isNeedRegister(const NfpInfo& nfpInfo)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isNeedRegisterNickName(const NfpInfo& nfpInfo)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isValidRegisterInfo(const NfpInfo& nfpInfo)

#include <l/Library/Nfp/NfpFunction.h>

void al::getAmiiboOwnerName(sead::BufferedSafeStringBase<char16>* ownerName, const NfpInfo& nfpInfo)

#include <l/Library/Nfp/NfpFunction.h>

void al::getAmiiboNickName(sead::BufferedSafeStringBase<char16>* nickName, const NfpInfo& nfpInfo)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isInvalidFormatVersion(const NfpInfo& nfpInfo)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isEqualCharacterIdBase(const nn::nfp::ModelInfo& modelInfo, const NfpCharacterId& characterId)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isEqualUniqueNfcId(const nn::nfp::TagInfo& tagInfoA, const NfpInfo& nfpInfoB)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isEqualUniqueNfcId(const nn::nfp::TagId& tagIdA, const nn::nfp::TagId& tagIdB)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isNfpTriggerTouch(NfpDirector*, s32)

#include <l/Library/Nfp/NfpFunction.h>

bool al::tryGetTriggerTouchNfpInfo(NfpDirector*, s32)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isNfpError(NfpDirector*, s32)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isNfpErrorDisableNfcDevice(const nn::Result&)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isNfpErrorBreakTagDisableRestore(const nn::Result&)

#include <l/Library/Nfp/NfpFunction.h>

bool al::isNfpErrorBreakTagEnableRestore(const nn::Result&)

#include <l/Library/Nfp/NfpFunction.h>

void al::showNfpErrorApplet(const nn::Result&)

#include <l/Library/Nfp/NfpFunction.h>

CollisionObj* al::createCollisionObj(const LiveActor* parent, const ActorInitInfo& info, const char* collisionFileName, HitSensor* hitSensor, const char* joinMtxName, const char* suffix)

#include <l/Library/Obj/PartsFunction.h>

CollisionObj* al::createCollisionObjMtx(const LiveActor* parent, const ActorInitInfo& info, const char* collisionFileName, HitSensor* hitSensor, const sead::Matrix34f* joinMtx, const char* suffix)

#include <l/Library/Obj/PartsFunction.h>

PartsModel* al::createPartsModel(LiveActor*, const ActorInitInfo&, const char*, const char*, const sead::Matrix34f*)

#include <l/Library/Obj/PartsFunction.h>

PartsModel* al::createPartsModelFile(LiveActor*, const ActorInitInfo&, const char*, const char*, const char*)

#include <l/Library/Obj/PartsFunction.h>

PartsModel* al::createPartsModelFileSuffix(LiveActor*, const ActorInitInfo&, const char*, const char*, const char*, const char*)

#include <l/Library/Obj/PartsFunction.h>

PartsModel* al::createSimplePartsModel(LiveActor*, const ActorInitInfo&, const char*, const char*, const char*)

#include <l/Library/Obj/PartsFunction.h>

PartsModel* al::createSimplePartsModelSuffix(LiveActor*, const ActorInitInfo&, const char*, const char*, const char*, const char*)

#include <l/Library/Obj/PartsFunction.h>

PartsModel* al::createPartsModelSuffix(LiveActor*, const ActorInitInfo&, const char*, const char*, const char*, const sead::Matrix34f*)

#include <l/Library/Obj/PartsFunction.h>

PartsModel* al::createPartsModelJoint(LiveActor*, const ActorInitInfo&, const char*, const char*, const char*)

#include <l/Library/Obj/PartsFunction.h>

PartsModel* al::createPartsModelSuffixJoint(LiveActor*, const ActorInitInfo&, const char*, const char*, const char*, const char*)

#include <l/Library/Obj/PartsFunction.h>

void al::appearBreakModelRandomRotateY(LiveActor*)

#include <l/Library/Obj/PartsFunction.h>

bool al::updateSyncHostVisible(bool*, LiveActor*, const LiveActor*, bool)

#include <l/Library/Obj/PartsFunction.h>

bool al::isTraceModelRandomRotate(const LiveActor* actor)

#include <l/Library/Obj/PartsFunction.h>

BreakModel* al::createBreakModel(const LiveActor*, const ActorInitInfo&, const char*, const char*, const char*, const sead::Matrix34f*, const char*)

#include <l/Library/Obj/PartsFunction.h>

HostSyncTowerCamera* al::createHostSyncTowerCamera(LiveActor*, const ActorInitInfo&)

#include <l/Library/Obj/PartsFunction.h>

void al::activateHostSyncTowerCamera(HostSyncTowerCamera*)

#include <l/Library/Obj/PartsFunction.h>

void al::deactivateHostSyncTowerCamera(HostSyncTowerCamera*)

#include <l/Library/Obj/PartsFunction.h>

void al::updateHostSyncTowerCamera(HostSyncTowerCamera*)

#include <l/Library/Obj/PartsFunction.h>

KeyMoveCameraObj* al::tryCreateLinksKeyMoveCameraObj(const ActorInitInfo&, const char*)

#include <l/Library/Obj/PartsFunction.h>

KeyMoveCameraObj* al::tryCreateLinksKeyMoveCameraObjWithInterpole(const ActorInitInfo&, const char*)

#include <l/Library/Obj/PartsFunction.h>

bool al::isValidInfo(const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::isPlaced(const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getObjectName(const char** name, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getObjectName(const char** name, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetObjectName(const char** name, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetObjectName(const char** name, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::isObjectName(const ActorInitInfo& initInfo, const char* name)

#include <l/Library/Placement/PlacementFunction.h>

bool al::isObjectName(const PlacementInfo& placementInfo, const char* name)

#include <l/Library/Placement/PlacementFunction.h>

bool al::isObjectNameSubStr(const ActorInitInfo& initInfo, const char* name)

#include <l/Library/Placement/PlacementFunction.h>

bool al::isObjectNameSubStr(const PlacementInfo& placementInfo, const char* name)

#include <l/Library/Placement/PlacementFunction.h>

void al::getClassName(const char** name, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getClassName(const char** name, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetClassName(const char** name, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetClassName(const char** name, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::isClassName(const ActorInitInfo& initInfo, const char* name)

#include <l/Library/Placement/PlacementFunction.h>

bool al::isClassName(const PlacementInfo& placementInfo, const char* name)

#include <l/Library/Placement/PlacementFunction.h>

void al::getDisplayName(const char** name, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getDisplayName(const char** name, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetDisplayName(const char** name, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetDisplayName(const char** name, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getPlacementTargetFile(const char** targetFile, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getTrans(sead::Vector3f* trans, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getTrans(sead::Vector3f* trans, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::multZoneMtx(sead::Vector3f* trans, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetTrans(sead::Vector3f* trans, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetTrans(sead::Vector3f* trans, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getRotate(sead::Vector3f* rotate, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetRotate(sead::Vector3f* rotate, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

#include <l/Library/Placement/PlacementFunction.cpp>

template<typename T>

void al::getRotation(sead::Vector3f* v, const sead::Matrix34f& n)

bool al::tryGetRotate(sead::Vector3f* rotate, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetZoneMatrixTR(sead::Matrix34f* matrix, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getQuat(sead::Quatf* quat, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getQuat(sead::Quatf* quat, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetQuat(sead::Quatf* quat, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetQuat(sead::Quatf* quat, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getScale(sead::Vector3f* scale, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getScale(f32* x, f32* y, f32* z, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetScale(sead::Vector3f* scale, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetScale(sead::Vector3f* scale, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getSide(sead::Vector3f* side, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getSide(sead::Vector3f* side, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetSide(sead::Vector3f* side, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetSide(sead::Vector3f* side, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getUp(sead::Vector3f* up, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getUp(sead::Vector3f* up, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetUp(sead::Vector3f* up, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetUp(sead::Vector3f* up, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getFront(sead::Vector3f* front, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getFront(sead::Vector3f* front, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetFront(sead::Vector3f* front, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetFront(sead::Vector3f* front, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetLocalAxis(sead::Vector3f* dir, const ActorInitInfo& initInfo, s32 axis)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetLocalAxis(sead::Vector3f* dir, const PlacementInfo& placementInfo, s32 axis)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetLocalSignAxis(sead::Vector3f* dir, const ActorInitInfo& initInfo, s32 axis)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetLocalSignAxis(sead::Vector3f* dir, const PlacementInfo& placementInfo, s32 axis)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetMatrixTR(sead::Matrix34f* matrix, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetMatrixTR(sead::Matrix34f* matrix, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetMatrixTRS(sead::Matrix34f* matrix, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetMatrixTRS(sead::Matrix34f* matrix, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetInvertMatrixTR(sead::Matrix34f* matrix, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetInvertMatrixTR(sead::Matrix34f* matrix, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::calcMatrixMultParent(sead::Matrix34f* matrix, const ActorInitInfo& initInfo1, const ActorInitInfo& initInfo2)

#include <l/Library/Placement/PlacementFunction.h>

void al::calcMatrixMultParent(sead::Matrix34f* matrix, const PlacementInfo& placementInfo1, const PlacementInfo& placementInfo2)

#include <l/Library/Placement/PlacementFunction.h>

void al::getArg(s32* arg, const ActorInitInfo& initInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

void al::getArg(s32* arg, const PlacementInfo& placementInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetArg(s32* arg, const ActorInitInfo& initInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetArg(s32* arg, const PlacementInfo& placementInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

void al::getArg(f32* arg, const ActorInitInfo& initInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

void al::getArg(f32* arg, const PlacementInfo& placementInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetArg(f32* arg, const ActorInitInfo& initInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetArg(f32* arg, const PlacementInfo& placementInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

void al::getArg(bool* arg, const ActorInitInfo& initInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

void al::getArg(bool* arg, const PlacementInfo& placementInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetArg(bool* arg, const ActorInitInfo& initInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetArg(bool* arg, const PlacementInfo& placementInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

s32 al::getArgS32(const ActorInitInfo& actorInitInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

f32 al::getArgF32(const ActorInitInfo& actorInitInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

void al::getArgV3f(sead::Vector3f* arg, const ActorInitInfo& actorInitInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

void al::getArgV3f(sead::Vector3f* arg, const PlacementInfo& placementInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetArgV3f(sead::Vector3f* arg, const ActorInitInfo& actorInitInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetArgV3f(sead::Vector3f* arg, const PlacementInfo& placementInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

bool al::isArgBool(const ActorInitInfo& initInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

bool al::isArgBool(const PlacementInfo& placementInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

bool al::isArgString(const ActorInitInfo& initInfo, const char* key, const char* arg)

#include <l/Library/Placement/PlacementFunction.h>

bool al::isArgString(const PlacementInfo& placementInfo, const char* key, const char* arg)

#include <l/Library/Placement/PlacementFunction.h>

void al::getStringArg(const char** arg, const ActorInitInfo& initInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

void al::getStringArg(const char** arg, const PlacementInfo& placementInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

void al::getStringArg(const char** arg, const AreaInitInfo& initInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

const char* al::getStringArg(const ActorInitInfo& initInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

const char* al::getStringArg(const PlacementInfo& placementInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

const char* al::getStringArg(const AreaInitInfo& initInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetStringArg(const char** arg, const ActorInitInfo& initInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetStringArg(const char** arg, const PlacementInfo& initInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetStringArg(const char** arg, const AreaInitInfo& initInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetArgV2f(sead::Vector2f* arg, const ActorInitInfo& initInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetArgV2f(sead::Vector2f* arg, const PlacementInfo& initInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetArgColor(sead::Color4f* arg, const ActorInitInfo& initInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetArgColor(sead::Color4f* arg, const PlacementInfo& initInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

void al::getLayerConfigName(const char** name, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getLayerConfigName(const char** name, const PlacementInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetZoneNameIfExist(const char** name, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getPlacementId(PlacementId* placementId, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetBoolArgOrFalse(const ActorInitInfo& initInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

s32 al::getCountPlacementInfo(const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getPlacementInfoByKey(PlacementInfo* outPlacementInfo, const PlacementInfo& placementInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetPlacementInfoByKey(PlacementInfo* outPlacementInfo, const PlacementInfo& placementInfo, const char* key)

#include <l/Library/Placement/PlacementFunction.h>

void al::getPlacementInfoByIndex(PlacementInfo* outPlacementInfo, const PlacementInfo& placementInfo, s32 index)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetPlacementInfoByIndex(PlacementInfo* outPlacementInfo, const PlacementInfo& placementInfo, s32 index)

#include <l/Library/Placement/PlacementFunction.h>

void al::getPlacementInfoAndKeyNameByIndex(PlacementInfo* outPlacementInfo, const char** outKey, const PlacementInfo& placementInfo, s32 index)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetPlacementInfoAndKeyNameByIndex(PlacementInfo* outPlacementInfo, const char** outKey, const PlacementInfo& placementInfo, s32 index)

#include <l/Library/Placement/PlacementFunction.h>

PlacementId* al::createPlacementId(const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

PlacementId* al::createPlacementId(const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetPlacementId(PlacementId* placementId, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetPlacementId(PlacementId* placementId, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getPlacementId(PlacementId* placementId, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::isEqualPlacementId(const PlacementId& placementId, const PlacementId& otherPlacementId)

#include <l/Library/Placement/PlacementFunction.h>

bool al::isEqualPlacementId(const PlacementInfo& placementInfo, const PlacementInfo& otherPlacementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::isExistRail(const ActorInitInfo& initInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetRailIter(PlacementInfo* railPlacementInfo, const PlacementInfo& placementInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetLinksInfo(PlacementInfo* railPlacementInfo, const PlacementInfo& placementInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetMoveParameterRailIter(PlacementInfo* railPlacementInfo, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetRailPointPos(sead::Vector3f* railPoint, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getRailPointHandlePrev(sead::Vector3f* railPoint, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetRailPointHandlePrev(sead::Vector3f* railPoint, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

void al::getRailPointHandleNext(sead::Vector3f* railPoint, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetRailPointHandleNext(sead::Vector3f* railPoint, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::isExistGraphRider(const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

s32 al::calcLinkChildNum(const ActorInitInfo& initInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

s32 al::calcLinkChildNum(const PlacementInfo& placementInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

bool al::isExistLinkChild(const ActorInitInfo& initInfo, const char* linkName, s32 index)

#include <l/Library/Placement/PlacementFunction.h>

bool al::isExistLinkChild(const PlacementInfo& placementInfo, const char* linkName, s32 index)

#include <l/Library/Placement/PlacementFunction.h>

bool al::isExistLinkChild(const AreaInitInfo& initInfo, const char* linkName, s32 index)

#include <l/Library/Placement/PlacementFunction.h>

s32 al::calcLinkNestNum(const ActorInitInfo& initInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

s32 al::calcLinkNestNum(const PlacementInfo& placementInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

void al::getLinksInfo(PlacementInfo* linkPlacementInfo, const PlacementInfo& placementInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

void al::getLinksInfoByIndex(PlacementInfo* linkPlacementInfo, const PlacementInfo& placementInfo, const char* linkName, s32 index)

#include <l/Library/Placement/PlacementFunction.h>

void al::getLinksInfo(PlacementInfo* linkPlacementInfo, const ActorInitInfo& initInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

void al::getLinksInfoByIndex(PlacementInfo* linkPlacementInfo, const ActorInitInfo& initInfo, const char* linkName, s32 index)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetLinksInfo(PlacementInfo* linkPlacementInfo, const ActorInitInfo& initInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

void al::getLinksMatrix(sead::Matrix34f* matrix, const ActorInitInfo& initInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

void al::getLinksMatrixByIndex(sead::Matrix34f* matrix, const ActorInitInfo& initInfo, const char* linkName, s32 index)

#include <l/Library/Placement/PlacementFunction.h>

void al::getLinkTR(sead::Vector3f* trans, sead::Vector3f* rotate, const PlacementInfo& placementInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

void al::getLinkTR(sead::Vector3f* trans, sead::Vector3f* rotate, const ActorInitInfo& initInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

void al::getLinkTR(sead::Vector3f* trans, sead::Vector3f* rotate, const AreaInitInfo& initInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

void al::getLinksQT(sead::Quatf* quat, sead::Vector3f* trans, const ActorInitInfo& initInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

void al::getLinksQT(sead::Quatf* quat, sead::Vector3f* trans, const PlacementInfo& placementInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetLinksQT(sead::Quatf* quat, sead::Vector3f* trans, const ActorInitInfo& initInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetLinksQTS(sead::Quatf* quat, sead::Vector3f* trans, sead::Vector3f* scale, const ActorInitInfo& initInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetLinksMatrixTR(sead::Matrix34f* matrix, const ActorInitInfo& initInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetLinksMatrixTR(sead::Matrix34f* matrix, const AreaInitInfo& initInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetLinksMatrixTRS(sead::Matrix34f* matrix, const ActorInitInfo& initInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetLinksTrans(sead::Vector3f* trans, const ActorInitInfo& initInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetLinksTrans(sead::Vector3f* trans, const PlacementInfo& placementInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetLinksQuat(sead::Quatf* quat, const ActorInitInfo& initInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetLinksTR(sead::Vector3f* trans, sead::Vector3f* rotate, const ActorInitInfo& initInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

void al::getChildTrans(sead::Vector3f* trans, const PlacementInfo& placementInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

void al::getChildTrans(sead::Vector3f* trans, const ActorInitInfo& initInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

void al::getChildTrans(sead::Vector3f* trans, const AreaInitInfo& initInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

void al::getChildLinkT(sead::Vector3f* trans, const ActorInitInfo& initInfo, const char* linkName, s32 index)

#include <l/Library/Placement/PlacementFunction.h>

void al::getChildLinkTR(sead::Vector3f* trans, sead::Vector3f* rotate, const ActorInitInfo& initInfo, const char* linkName, s32 index)

#include <l/Library/Placement/PlacementFunction.h>

s32 al::calcMatchNameLinkCount(const PlacementInfo& placementInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

s32 al::calcLinkCountClassName(const PlacementInfo& placementInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetZoneMatrixTR(sead::Matrix34f* matrix, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetDisplayOffset(sead::Vector3f* offset, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetDisplayOffset(sead::Vector3f* offset, const PlacementInfo& placementInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetChildDisplayOffset(sead::Vector3f* offset, const ActorInitInfo& initInfo, const char* linkName)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetDisplayRotate(sead::Vector3f* rotate, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

bool al::tryGetDisplayScale(sead::Vector3f* scale, const ActorInitInfo& initInfo)

#include <l/Library/Placement/PlacementFunction.h>

StringTmp<128> al::makeStringPlacementId(const PlacementId* placementId)

#include <l/Library/Placement/PlacementId.h>

void al::startAppear(LayoutActor* layout)

#include <l/Library/Play/Layout/BalloonMessage.cpp>

BalloonMessage* al::createBalloonMessage(const LiveActor* hostActor, const ActorInitInfo& info, const BalloonMessageInitParam& initParam)

#include <l/Library/Play/Layout/BalloonMessage.h>

BalloonMessage* al::createBalloonMessageNoAutoUpdate(const LiveActor* hostActor, const ActorInitInfo& info, const BalloonMessageInitParam& initParam)

#include <l/Library/Play/Layout/BalloonMessage.h>

BalloonMessage* al::createBalloonMessage(const LiveActor* hostActor, const ActorInitInfo& info)

#include <l/Library/Play/Layout/BalloonMessage.h>

BalloonMessage* al::createBalloonMessage(const LiveActor* hostActor, const ActorInitInfo& info, const char* message)

#include <l/Library/Play/Layout/BalloonMessage.h>

SimpleLayoutText* al::createSimpleLayoutText(const ActorInitInfo& info, const char* name, const char* paneName, const char* archiveName)

#include <l/Library/Play/Layout/SimpleLayoutText.h>

void al::addPlayerAccelStick(LiveActor*, sead::Vector3f*, f32, s32, const sead::Matrix34f*)

#include <l/Library/Player/PlayerFunction.h>

void al::addPlayerAccelStickGravity(LiveActor*, sead::Vector3f*, f32, const sead::Vector3f&, s32, const sead::Matrix34f*)

#include <l/Library/Player/PlayerFunction.h>

void al::addPlayerAccelInputGravity(LiveActor*, sead::Vector3f*, const sead::Vector2f&, f32, const sead::Vector3f&, const sead::Matrix34f*)

#include <l/Library/Player/PlayerFunction.h>

bool al::tryCalcTouchWorldPosPlane(const IUseCamera*, sead::Vector3f*, const sead::Vector3f&, const sead::Vector3f&)

#include <l/Library/Player/PlayerFunction.h>

bool al::tryCalcTouchWorldPosPlaneXZ(const IUseCamera*, sead::Vector3f*, f32)

#include <l/Library/Player/PlayerFunction.h>

s32 al::getPlayerNumMax(const PlayerHolder* holder)

#include <l/Library/Player/PlayerUtil.h>

s32 al::getAlivePlayerNum(const PlayerHolder* holder)

#include <l/Library/Player/PlayerUtil.h>

LiveActor* al::getPlayerActor(const PlayerHolder* holder, s32 index)

#include <l/Library/Player/PlayerUtil.h>

const sead::Vector3f& al::getPlayerPos(const PlayerHolder* holder, s32 index)

#include <l/Library/Player/PlayerUtil.h>

LiveActor* al::tryGetPlayerActor(const PlayerHolder* holder, s32 index)

#include <l/Library/Player/PlayerUtil.h>

bool al::isPlayerDead(const PlayerHolder* holder, s32 index)

#include <l/Library/Player/PlayerUtil.h>

bool al::isPlayerAreaTarget(const PlayerHolder* holder, s32 index)

#include <l/Library/Player/PlayerUtil.h>

LiveActor* al::tryFindAlivePlayerActorFirst(const PlayerHolder* holder)

#include <l/Library/Player/PlayerUtil.h>

LiveActor* al::findAlivePlayerActorFirst(const PlayerHolder* holder)

#include <l/Library/Player/PlayerUtil.h>

s32 al::getPlayerNumMax(const LiveActor*)

#include <l/Library/Player/PlayerUtil.h>

s32 al::getAlivePlayerNum(const LiveActor*)

#include <l/Library/Player/PlayerUtil.h>

LiveActor* al::getPlayerActor(const LiveActor*, s32)

#include <l/Library/Player/PlayerUtil.h>

const sead::Vector3f& al::getPlayerPos(const LiveActor*, s32)

#include <l/Library/Player/PlayerUtil.h>

LiveActor* al::tryGetPlayerActor(const LiveActor*, s32)

#include <l/Library/Player/PlayerUtil.h>

bool al::isPlayerDead(const LiveActor*, s32)

#include <l/Library/Player/PlayerUtil.h>

bool al::isPlayerAreaTarget(const LiveActor*, s32)

#include <l/Library/Player/PlayerUtil.h>

LiveActor* al::tryFindAlivePlayerActorFirst(const LiveActor*)

#include <l/Library/Player/PlayerUtil.h>

LiveActor* al::findAlivePlayerActorFirst(const LiveActor*)

#include <l/Library/Player/PlayerUtil.h>

PadRumbleKeeper* al::getPlayerPadRumbleKeeper(const LiveActor*, s32)

#include <l/Library/Player/PlayerUtil.h>

s32 al::getPlayerPort(const PlayerHolder*, s32)

#include <l/Library/Player/PlayerUtil.h>

s32 al::getPlayerPort(const LiveActor*, s32)

#include <l/Library/Player/PlayerUtil.h>

LiveActor* al::findAlivePlayerActorFromPort(const PlayerHolder*, s32)

#include <l/Library/Player/PlayerUtil.h>

LiveActor* al::tryFindAlivePlayerActorFromPort(const PlayerHolder*, s32)

#include <l/Library/Player/PlayerUtil.h>

LiveActor* al::findAlivePlayerActorFromPort(const LiveActor*, s32)

#include <l/Library/Player/PlayerUtil.h>

LiveActor* al::tryFindAlivePlayerActorFromPort(const LiveActor*, s32)

#include <l/Library/Player/PlayerUtil.h>

s32 al::findNearestPlayerId(const LiveActor*, f32)

#include <l/Library/Player/PlayerUtil.h>

LiveActor* al::findNearestPlayerActor(const LiveActor*)

#include <l/Library/Player/PlayerUtil.h>

LiveActor* al::tryFindNearestPlayerActor(const LiveActor*)

#include <l/Library/Player/PlayerUtil.h>

const sead::Vector3f& al::findNearestPlayerPos(const LiveActor*)

#include <l/Library/Player/PlayerUtil.h>

bool al::tryFindNearestPlayerPos(sead::Vector3f*, const LiveActor*)

#include <l/Library/Player/PlayerUtil.h>

bool al::tryFindNearestPlayerDisatanceFromTarget(f32*, const LiveActor*, const sead::Vector3f&)

#include <l/Library/Player/PlayerUtil.h>

bool al::isNearPlayer(const LiveActor*, f32)

#include <l/Library/Player/PlayerUtil.h>

bool al::isNearPlayerH(const LiveActor*, f32)

#include <l/Library/Player/PlayerUtil.h>

bool al::isNearPlayerHCondition(const LiveActor*, f32, bool(*)(const LiveActor*))

#include <l/Library/Player/PlayerUtil.h>

const sead::Vector3f& al::getFarPlayerPosMaxX(const LiveActor*)

#include <l/Library/Player/PlayerUtil.h>

const sead::Vector3f& al::getFarPlayerPosMinX(const LiveActor*)

#include <l/Library/Player/PlayerUtil.h>

u32 al::calcPlayerListOrderByDistance(const LiveActor*, const LiveActor**, u32)

#include <l/Library/Player/PlayerUtil.h>

u32 al::calcAlivePlayerActor(const LiveActor*, const LiveActor**, u32)

#include <l/Library/Player/PlayerUtil.h>

LiveActor* al::tryFindNearestPlayerActorCondition(const LiveActor*, bool(*)(const LiveActor*))

#include <l/Library/Player/PlayerUtil.h>

bool al::tryFindNearestPlayerPosCondition(sead::Vector3f*, const LiveActor*, bool(*)(const LiveActor*))

#include <l/Library/Player/PlayerUtil.h>

bool al::isResetablePlayerPos(const LiveActor*, const sead::Vector3f&, f32, f32)

#include <l/Library/Player/PlayerUtil.h>

bool al::isResetablePlayerPos(const LiveActor*, f32)

#include <l/Library/Player/PlayerUtil.h>

void al::faceToPlayer(LiveActor*)

#include <l/Library/Player/PlayerUtil.h>

RailKeeper* al::createRailKeeper(const PlacementInfo& info, const char* linkName)

#include <l/Library/Rail/RailKeeper.h>

RailKeeper* al::tryCreateRailKeeper(const PlacementInfo& info, const char* linkName)

#include <l/Library/Rail/RailKeeper.h>

RailKeeper* al::createRailKeeperIndex(const PlacementInfo& info, s32 linkIndex, const char* linkName)

#include <l/Library/Rail/RailKeeper.h>

void al::setRailPosToStart(IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

void al::setRailPosToEnd(IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

void al::setRailPosToNearestPos(IUseRail* railHolder, const sead::Vector3f&)

#include <l/Library/Rail/RailUtil.h>

void al::setRailPosToCoord(IUseRail* railHolder, f32)

#include <l/Library/Rail/RailUtil.h>

void al::setRailPosToRailPoint(IUseRail* railHolder, s32)

#include <l/Library/Rail/RailUtil.h>

void al::setSyncRailToStart(LiveActor* actor)

#include <l/Library/Rail/RailUtil.h>

void al::syncRailTrans(LiveActor* actor)

#include <l/Library/Rail/RailUtil.h>

void al::setSyncRailToEnd(LiveActor* actor)

#include <l/Library/Rail/RailUtil.h>

void al::setSyncRailToNearestPos(LiveActor* actor, const sead::Vector3f&)

#include <l/Library/Rail/RailUtil.h>

void al::setSyncRailToNearestRailControlPoint(LiveActor* actor)

#include <l/Library/Rail/RailUtil.h>

void al::setSyncRailToNearestPos(LiveActor* actor)

#include <l/Library/Rail/RailUtil.h>

void al::setSyncRailToCoord(LiveActor* actor, f32 coord)

#include <l/Library/Rail/RailUtil.h>

void al::setSyncRailToRailPoint(LiveActor* actor, s32)

#include <l/Library/Rail/RailUtil.h>

bool al::moveRail(IUseRail* railHolder, f32)

#include <l/Library/Rail/RailUtil.h>

bool al::isRailReachedGoal(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

bool al::moveRailLoop(IUseRail* railHolder, f32)

#include <l/Library/Rail/RailUtil.h>

f32 al::getRailCoord(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

bool al::isRailGoingToEnd(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

f32 al::getRailTotalLength(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

bool al::moveRailTurn(IUseRail* railHolder, f32, f32)

#include <l/Library/Rail/RailUtil.h>

void al::reverseRail(IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

bool al::isRailReachedNearGoal(const IUseRail* railHolder, f32)

#include <l/Library/Rail/RailUtil.h>

bool al::turnToRailDir(LiveActor* actor, f32)

#include <l/Library/Rail/RailUtil.h>

void al::calcRailMoveDir(sead::Vector3f*, const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

bool al::turnToRailDirImmediately(LiveActor* actor)

#include <l/Library/Rail/RailUtil.h>

const sead::Vector3f& al::getRailPos(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

bool al::moveSyncRail(LiveActor* actor, f32)

#include <l/Library/Rail/RailUtil.h>

bool al::moveSyncRailLoop(LiveActor* actor, f32 speed)

#include <l/Library/Rail/RailUtil.h>

bool al::moveSyncRailTurn(LiveActor* actor, f32 speed)

#include <l/Library/Rail/RailUtil.h>

f32 al::calcNearestRailCoord(const IUseRail* railHolder, const sead::Vector3f&)

#include <l/Library/Rail/RailUtil.h>

f32 al::calcNearestRailPos(sead::Vector3f*, const IUseRail* railHolder, const sead::Vector3f&)

#include <l/Library/Rail/RailUtil.h>

void al::calcNearestRailDir(sead::Vector3f*, const IUseRail* railHolder, const sead::Vector3f&)

#include <l/Library/Rail/RailUtil.h>

void al::calcNearestRailPosAndDir(sead::Vector3f*, sead::Vector3f*, const IUseRail* railHolder, const sead::Vector3f&)

#include <l/Library/Rail/RailUtil.h>

void al::calcRailPosDir(sead::Vector3f*, sead::Vector3f*, const IUseRail* railHolder, f32)

#include <l/Library/Rail/RailUtil.h>

void al::calcRailPointPos(sead::Vector3f*, const IUseRail* railHolder, s32)

#include <l/Library/Rail/RailUtil.h>

s32 al::calcNearestRailPointNo(const IUseRail* railHolder, const sead::Vector3f&)

#include <l/Library/Rail/RailUtil.h>

s32 al::calcNearestRailPointNo(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

s32 al::calcCoordNearestRailPointNo(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

s32 al::getRailPartIndex(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

f32 al::calcRailPartRate(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

bool al::isLoopRail(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

s32 al::getRailPointNum(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

f32 al::calcNearestRailPointPosCoord(const IUseRail* railHolder, const sead::Vector3f&)

#include <l/Library/Rail/RailUtil.h>

f32 al::calcRailCoordByPoint(const IUseRail* railHolder, s32)

#include <l/Library/Rail/RailUtil.h>

void al::calcRailUp(sead::Vector3f*, const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

PlacementInfo* al::getRailPointInfo(const IUseRail* railHolder, s32)

#include <l/Library/Rail/RailUtil.h>

s32 al::getRailPointNo(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

s32 al::getNextRailPointNo(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

f32 al::calcRailToGoalLength(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

f32 al::calcRailTotalRate(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

f32 al::calcRailToNextRailPointLength(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

f32 al::calcRailToPreviousRailPointLength(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

s32 al::getRailNum(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

const sead::Vector3f& al::getRailDir(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

bool al::isRailReachedEnd(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

f32 al::getRailPartLength(const IUseRail* railHolder, s32)

#include <l/Library/Rail/RailUtil.h>

bool al::tryGetCurrentRailPointArg(f32*, const IUseRail* railHolder, const char*)

#include <l/Library/Rail/RailUtil.h>

bool al::tryGetNextRailPointArg(f32*, const IUseRail* railHolder, const char*)

#include <l/Library/Rail/RailUtil.h>

bool al::tryGetCurrentRailPointArg(s32*, const IUseRail* railHolder, const char*)

#include <l/Library/Rail/RailUtil.h>

bool al::tryGetNextRailPointArg(s32*, const IUseRail* railHolder, const char*)

#include <l/Library/Rail/RailUtil.h>

bool al::tryGetCurrentRailPointArg(bool*, const IUseRail* railHolder, const char*)

#include <l/Library/Rail/RailUtil.h>

bool al::tryGetNextRailPointArg(bool*, const IUseRail* railHolder, const char*)

#include <l/Library/Rail/RailUtil.h>

bool al::tryGetCurrentRailPointArg(const char**, const IUseRail* railHolder, const char*)

#include <l/Library/Rail/RailUtil.h>

bool al::tryGetNextRailPointArg(const char**, const IUseRail* railHolder, const char*)

#include <l/Library/Rail/RailUtil.h>

bool al::isExistRail(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

bool al::isRailReachedStart(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

bool al::isRailReachedNearGoal(const IUseRail* railHolder, f32, f32)

#include <l/Library/Rail/RailUtil.h>

bool al::isRailReachedEdge(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

bool al::isRailReachedNearRailPoint(const IUseRail* railHolder, f32)

#include <l/Library/Rail/RailUtil.h>

bool al::isRailIncludeBezierPart(const IUseRail* railHolder)

#include <l/Library/Rail/RailUtil.h>

bool al::isRailBezierPart(const IUseRail* railHolder, s32)

#include <l/Library/Rail/RailUtil.h>

bool al::isRailPlusDir(const IUseRail* railHolder, const sead::Vector3f&)

#include <l/Library/Rail/RailUtil.h>

bool al::isRailPlusPoseSide(const LiveActor* actor)

#include <l/Library/Rail/RailUtil.h>

bool al::isRailPlusPoseUp(const LiveActor* actor)

#include <l/Library/Rail/RailUtil.h>

bool al::isRailPlusPoseFront(const LiveActor* actor)

#include <l/Library/Rail/RailUtil.h>

void al::calcRailPosAtCoord(sead::Vector3f*, const IUseRail* railHolder, f32)

#include <l/Library/Rail/RailUtil.h>

void al::calcRailDirAtCoord(sead::Vector3f*, const IUseRail* railHolder, f32)

#include <l/Library/Rail/RailUtil.h>

void al::calcRailPosFront(sead::Vector3f*, const IUseRail* railHolder, f32)

#include <l/Library/Rail/RailUtil.h>

void al::calcRailDirFront(sead::Vector3f*, const IUseRail* railHolder, f32)

#include <l/Library/Rail/RailUtil.h>

void al::calcRailPointPose(sead::Quatf*, const IUseRail* railHolder, s32)

#include <l/Library/Rail/RailUtil.h>

s32 al::calcRailPointNum(const IUseRail* railHolder, f32, f32)

#include <l/Library/Rail/RailUtil.h>

s32 al::calcForwardRailPointNo(const IUseRail* railHolder, s32)

#include <l/Library/Rail/RailUtil.h>

s32 al::calcPreviousRailPointNo(const IUseRail* railHolder, s32)

#include <l/Library/Rail/RailUtil.h>

void al::calcRailClippingInfo(sead::Vector3f*, f32*, const IUseRail* railHolder, f32, f32)

#include <l/Library/Rail/RailUtil.h>

void al::setRailClippingInfo(sead::Vector3f*, LiveActor* actor, f32, f32)

#include <l/Library/Rail/RailUtil.h>

void al::calcAndSyncMoveFitRailDir(IUseRail* railHolder, sead::Vector3f*, f32, const sead::Vector3f&, const sead::Vector3f&, bool)

#include <l/Library/Rail/RailUtil.h>

void al::calcAndSyncMoveFitRailDir(LiveActor* actor, sead::Vector3f*, f32, bool)

#include <l/Library/Rail/RailUtil.h>

LiveActorGroup* al::createRailModelGroup(const IUseRail* railHolder, const ActorInitInfo&, const char*, const char*)

#include <l/Library/Rail/RailUtil.h>

s32 al::calcRailDivideNum(const IUseRail* railHolder, f32, bool)

#include <l/Library/Rail/RailUtil.h>

s32 al::calcRailDivideForcePointNum(const IUseRail* railHolder, f32)

#include <l/Library/Rail/RailUtil.h>

s32 al::calcRailDivideEquallyNum(const IUseRail* railHolder, f32)

#include <l/Library/Rail/RailUtil.h>

void al::placementRailDivide(const IUseRail* railHolder, f32, bool, const RailPlacementCallBack&)

#include <l/Library/Rail/RailUtil.h>

void al::placementRailDivideForcePoint(const IUseRail* railHolder, f32, const RailPlacementCallBack&)

#include <l/Library/Rail/RailUtil.h>

void al::placementRailDivideEqually(const IUseRail* railHolder, f32, const RailPlacementCallBack&)

#include <l/Library/Rail/RailUtil.h>

void al::addResourceCategory(const sead::SafeString&, s32, sead::Heap*)

#include <l/Library/Resource/ResourceHolder.h>

bool al::isEmptyCategoryResource(const sead::SafeString&)

#include <l/Library/Resource/ResourceHolder.h>

void al::createCategoryResourceAll(const sead::SafeString&)

#include <l/Library/Resource/ResourceHolder.h>

void al::removeResourceCategory(const sead::SafeString&)

#include <l/Library/Resource/ResourceHolder.h>

const char* al::getResourceName(const Resource*)

#include <l/Library/Resource/ResourceHolder.h>

const char* al::getResourcePath(const Resource*)

#include <l/Library/Resource/ResourceHolder.h>

bool al::isExistResGraphicsFile(const Resource*)

#include <l/Library/Resource/ResourceHolder.h>

Resource* al::findResource(const sead::SafeString&)

#include <l/Library/Resource/ResourceHolder.h>

Resource* al::findOrCreateResource(const sead::SafeString& path, const char* ext)

#include <l/Library/Resource/ResourceHolder.h>

Resource* al::findOrCreateResourceCategory(const sead::SafeString& path, const sead::SafeString& category, const char* ext)

#include <l/Library/Resource/ResourceHolder.h>

Resource* al::findOrCreateResourceEventData(const char*, const char*)

#include <l/Library/Resource/ResourceHolder.h>

Resource* al::findOrCreateResourceSystemData(const char*, const char*)

#include <l/Library/Resource/ResourceHolder.h>

ActorResource* al::findOrCreateActorResource(ActorResourceHolder*, const char*, const char*)

#include <l/Library/Resource/ResourceHolder.h>

void al::findOrCreateActorResourceWithAnimResource(ActorResourceHolder*, const char*, const char*, const char*, bool)

#include <l/Library/Resource/ResourceHolder.h>

bool al::isExistResourceYaml(const Resource*, const char*, const char*)

#include <l/Library/Resource/ResourceHolder.h>

bool al::isExistResourceYaml(const ActorResource*, const char*, const char*)

#include <l/Library/Resource/ResourceHolder.h>

void al::findResourceYaml(const Resource*, const char*, const char*)

#include <l/Library/Resource/ResourceHolder.h>

void al::findResourceYaml(const ActorResource*, const char*, const char*)

#include <l/Library/Resource/ResourceHolder.h>

bool al::tryFindStageParameterFileDesign(const sead::SafeString&, const sead::SafeString&, s32)

#include <l/Library/Resource/ResourceHolder.h>

void al::loadCategoryArchiveAll(const sead::SafeString&)

#include <l/Library/Resource/ResourceHolder.h>

void al::setCurrentCategoryName(const char*)

#include <l/Library/Resource/ResourceHolder.h>

void al::resetCurrentCategoryName()

#include <l/Library/Resource/ResourceHolder.h>

void al::setCurrentCategoryNameDefault()

#include <l/Library/Resource/ResourceHolder.h>

u8* al::getBymlFromObjectResource(const sead::SafeString&, const sead::SafeString&)

#include <l/Library/Resource/ResourceHolder.h>

u8* al::tryGetBymlFromObjectResource(const sead::SafeString&, const sead::SafeString&)

#include <l/Library/Resource/ResourceHolder.h>

u8* al::getBymlFromLayoutResource(const sead::SafeString&, const sead::SafeString&)

#include <l/Library/Resource/ResourceHolder.h>

u8* al::tryGetBymlFromLayoutResource(const sead::SafeString&, const sead::SafeString&)

#include <l/Library/Resource/ResourceHolder.h>

u8* al::tryGetBymlFromArcName(const sead::SafeString&, const sead::SafeString&)

#include <l/Library/Resource/ResourceHolder.h>

u8* al::getBymlFromArcName(const sead::SafeString&, const sead::SafeString&)

#include <l/Library/Resource/ResourceHolder.h>

u8* al::getByml(const Resource*, const sead::SafeString&)

#include <l/Library/Resource/ResourceHolder.h>

u8* al::tryGetByml(const Resource*, const sead::SafeString&)

#include <l/Library/Resource/ResourceHolder.h>

bool al::setAudioPlayerToResourceSystem(SeadAudioPlayer*, SeadAudioPlayer*)

#include <l/Library/Resource/ResourceHolder.h>

ISceneObj* al::createSceneObj(const IUseSceneObjHolder* objHolder, s32 type)

#include <l/Library/Scene/SceneObjUtil.h>

void al::setSceneObj(const IUseSceneObjHolder* user, ISceneObj* obj, s32 sceneObjId)

#include <l/Library/Scene/SceneObjUtil.h>

ISceneObj* al::getSceneObj(const IUseSceneObjHolder* user, s32 sceneObjId)

#include <l/Library/Scene/SceneObjUtil.h>

ISceneObj* al::tryGetSceneObj(const IUseSceneObjHolder* user, s32 sceneObjId)

#include <l/Library/Scene/SceneObjUtil.h>

bool al::isExistSceneObj(const IUseSceneObjHolder* user, s32 sceneObjId)

#include <l/Library/Scene/SceneObjUtil.h>

void al::deleteSceneObj(const IUseSceneObjHolder* user, s32 sceneObjId)

#include <l/Library/Scene/SceneObjUtil.h>

bool al::tryDeleteSceneObj(const IUseSceneObjHolder* user, s32 sceneObjId)

#include <l/Library/Scene/SceneObjUtil.h>

#include <l/Library/Scene/SceneObjUtil.h>

template<typename T>

T* al::getSceneObj(const IUseSceneObjHolder* user)

#include <l/Library/Scene/SceneObjUtil.h>

template<typename T>

T* al::tryGetSceneObj(const IUseSceneObjHolder* user)

s32 al::getStageInfoMapNum(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

s32 al::getStageInfoDesignNum(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

s32 al::getStageInfoSoundNum(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

StageInfo* al::getStageInfoMap(const Scene* scene, s32 index)

#include <l/Library/Scene/SceneUtil.h>

StageInfo* al::getStageInfoDesign(const Scene* scene, s32 index)

#include <l/Library/Scene/SceneUtil.h>

StageInfo* al::getStageInfoSound(const Scene* scene, s32 index)

#include <l/Library/Scene/SceneUtil.h>

Resource* al::getStageResourceMap(const Scene* scene, s32 index)

#include <l/Library/Scene/SceneUtil.h>

Resource* al::tryGetStageResourceDesign(const Scene* scene, s32 index)

#include <l/Library/Scene/SceneUtil.h>

Resource* al::tryGetStageResourceSound(const Scene* scene, s32 index)

#include <l/Library/Scene/SceneUtil.h>

agl::RenderBuffer* al::getSceneFrameBufferMain(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

agl::DrawContext* al::getSceneDrawContext(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

agl::RenderBuffer* al::getSceneFrameBufferConsole(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

agl::RenderBuffer* al::getSceneFrameBufferHandheld(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

f32 al::getSceneFrameBufferMainAspect(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

bool al::isChangedGraphicsQualityMode(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

AreaObjDirector* al::getSceneAreaObjDirector(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

ExecuteDirector* al::getSceneExecuteDirector(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

PlayerHolder* al::getScenePlayerHolder(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

ItemDirectorBase* al::getSceneItemDirector(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::initActorInitInfo(ActorInitInfo* actorInitInfo, const Scene* scene, const PlacementInfo* placementInfo, const LayoutInitInfo* layoutInfo, const ActorFactory* actorFactory, SceneMsgCtrl* sceneMsgCtrl, GameDataHolderBase* gameDataHolderBase)

#include <l/Library/Scene/SceneUtil.h>

void al::initLayoutInitInfo(LayoutInitInfo* layoutInfo, const Scene* scene, const SceneInitInfo& sceneInfo)

#include <l/Library/Scene/SceneUtil.h>

void al::initPlacementAreaObj(Scene* scene, const ActorInitInfo& actorInfo)

#include <l/Library/Scene/SceneUtil.h>

void al::initPlacementGravityObj(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

bool al::tryGetPlacementInfoAndCount(PlacementInfo* outPlacementInfo, s32* outCount, const StageInfo* stageInfo, const char* key)

#include <l/Library/Scene/SceneUtil.h>

void al::initPlacementObjectMap(Scene* scene, const ActorInitInfo& actorInfo, const char* name)

#include <l/Library/Scene/SceneUtil.h>

void al::initPlacementByStageInfo(const StageInfo* stageInfo, const char* key, const ActorInitInfo& actorInfo)

#include <l/Library/Scene/SceneUtil.h>

void al::initPlacementObjectDesign(Scene* scene, const ActorInitInfo& actorInfo, const char* name)

#include <l/Library/Scene/SceneUtil.h>

void al::initPlacementObjectSound(Scene* scene, const ActorInitInfo& actorInfo, const char* name)

#include <l/Library/Scene/SceneUtil.h>

LiveActor* al::tryInitPlacementSingleObject(Scene* scene, const ActorInitInfo& actorInfo, s32 resourceType, const char* key)

#include <l/Library/Scene/SceneUtil.h>

LiveActor* al::tryInitPlacementSingleObject(Scene* scene, const ActorInitInfo& actorInfo, s32 resourceType, const char* key, const char* name)

#include <l/Library/Scene/SceneUtil.h>

bool al::tryInitPlacementActorGroup(LiveActorGroup* liveActorGroup, Scene* scene, const ActorInitInfo& actorInfo, s32 resourceType, const char* key, const char* name)

#include <l/Library/Scene/SceneUtil.h>

void al::initPlacementByStageInfoSingle(const StageInfo* stageInfo, const char* key, const ActorInitInfo& actorInfo)

#include <l/Library/Scene/SceneUtil.h>

bool al::tryGetPlacementInfo(PlacementInfo* outPlacementInfo, const StageInfo* stageInfo, const char* key)

#include <l/Library/Scene/SceneUtil.h>

void al::getPlacementInfo(PlacementInfo* outPlacementInfo, const StageInfo* stageInfo, const char* key)

#include <l/Library/Scene/SceneUtil.h>

void al::getPlacementInfoAndCount(PlacementInfo* outPlacementInfo, s32* outCount, const StageInfo* stageInfo, const char* key)

#include <l/Library/Scene/SceneUtil.h>

void al::initAreaObjDirector(Scene* scene, const AreaObjFactory* factory)

#include <l/Library/Scene/SceneUtil.h>

void al::initDemoDirector(Scene* scene, DemoDirector* demoDirector)

#include <l/Library/Scene/SceneUtil.h>

void al::initHitSensorDirector(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::initGravityHolder(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::initItemDirector(Scene* scene, ItemDirectorBase* itemDirector)

#include <l/Library/Scene/SceneUtil.h>

void al::initNatureDirector(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::initSwitchAreaDirector(Scene* scene, s32 maxSwitchOnArea, s32 maxSwitchKeepOnArea)

#include <l/Library/Scene/SceneUtil.h>

void al::registerSwitchOnAreaGroup(Scene* scene, SwitchOnAreaGroup* switchOnAreaGroup)

#include <l/Library/Scene/SceneUtil.h>

void al::registerSwitchKeepOnAreaGroup(Scene* scene, SwitchKeepOnAreaGroup* switchKeepOnAreaGroup)

#include <l/Library/Scene/SceneUtil.h>

void al::initGraphicsSystemInfo(Scene* scene, const char* name, s32 index)

#include <l/Library/Scene/SceneUtil.h>

void al::initCameraDirectorImpl(Scene* scene, const CameraPoserFactory* cameraPoserFactory)

#include <l/Library/Scene/SceneUtil.cpp>

void al::initCameraDirector(Scene* scene, const char* name, s32 index, const CameraPoserFactory* cameraPoserFactory)

#include <l/Library/Scene/SceneUtil.cpp>

void al::initCameraDirectorWithoutStageResource(Scene* scene, const CameraPoserFactory* cameraPoserFactory)

#include <l/Library/Scene/SceneUtil.h>

void al::initCameraDirectorFix(Scene* scene, const sead::Vector3f& pos, const sead::Vector3f& lookAtPos, const CameraPoserFactory* cameraPoserFactory)

#include <l/Library/Scene/SceneUtil.h>

void al::initSceneCameraFovyDegree(Scene* scene, f32 fovy)

#include <l/Library/Scene/SceneUtil.h>

void al::initSnapShotCameraAudioKeeper(Scene* scene, IUseAudioKeeper* audioKeeper)

#include <l/Library/Scene/SceneUtil.h>

void al::setCameraAspect(Scene* scene, f32 aspectA, f32 aspectB)

#include <l/Library/Scene/SceneUtil.h>

void al::resetSceneInitEntranceCamera(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::stopCameraByDeathPlayer(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::restartCameraByDeathPlayer(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::startInvalidCameraStopJudgeByDemo(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::endInvalidCameraStopJudgeByDemo(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::startCameraSnapShotMode(Scene* scene, bool useInterpole)

#include <l/Library/Scene/SceneUtil.h>

void al::endCameraSnapShotMode(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

bool al::isCameraReverseInputH(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::onCameraReverseInputH(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::offCameraReverseInputH(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

bool al::isCameraReverseInputV(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::onCameraReverseInputV(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::offCameraReverseInputV(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

s32 al::getCameraStickSensitivityLevel(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::setCameraStickSensitivityLevel(Scene* scene, s32 sensitivityLevel)

#include <l/Library/Scene/SceneUtil.h>

bool al::isValidCameraGyro(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::validateCameraGyro(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::invalidateCameraGyro(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

s32 al::getCameraGyroSensitivityLevel(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::setCameraGyroSensitivityLevel(Scene* scene, s32 sensitivityLevel)

#include <l/Library/Scene/SceneUtil.h>

PauseCameraCtrl* al::initAndCreatePauseCameraCtrl(Scene* scene, f32 value)

#include <l/Library/Scene/SceneUtil.h>

void al::startCameraPause(PauseCameraCtrl* pauseCameraCtrl)

#include <l/Library/Scene/SceneUtil.h>

void al::endCameraPause(PauseCameraCtrl* pauseCameraCtrl)

#include <l/Library/Scene/SceneUtil.h>

AudioDirector* al::initAudioDirectorImpl(Scene* scene, const SceneInitInfo& sceneInfo, AudioDirectorInitInfo& audioDirectorInfo)

#include <l/Library/Scene/SceneUtil.cpp>

void al::initAudioDirector2D(Scene* scene, const SceneInitInfo& sceneInfo, AudioDirectorInitInfo& audioDirectorInfo)

#include <l/Library/Scene/SceneUtil.h>

void al::initAudioDirector3D(Scene* scene, const SceneInitInfo& sceneInfo, AudioDirectorInitInfo& audioDirectorInfo)

#include <l/Library/Scene/SceneUtil.h>

void al::initAudioDirector3D(Scene* scene, const SceneInitInfo& sceneInfo, AudioDirectorInitInfo& audioDirectorInfo, const sead::LookAtCamera* lookAtCamera, const Projection* projection, AreaObjDirector* areaObjDirector)

#include <l/Library/Scene/SceneUtil.h>

void al::initSceneAudioKeeper(Scene* scene, const SceneInitInfo& sceneInfo, const char* name)

#include <l/Library/Scene/SceneUtil.h>

void al::setIsSafeFinalizingInParallelThread(Scene* scene, bool isSafe)

#include <l/Library/Scene/SceneUtil.h>

void al::updateKit(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::updateKitTable(Scene* scene, const char* name)

#include <l/Library/Scene/SceneUtil.h>

void al::updateKitList(Scene* scene, const char* listName, const char* name)

#include <l/Library/Scene/SceneUtil.h>

void al::updateKitList(Scene* scene, const char* name)

#include <l/Library/Scene/SceneUtil.h>

void al::updateLayoutKit(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::updateEffect(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::updateEffectSystem(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::updateEffectPlayer(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::updateEffectDemo(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::updateEffectDemoWithPause(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::updateEffectLayout(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::updateGraphicsPrev(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::updateKitListPrev(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::updateKitListPost(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::updateKitListPostDemoWithPauseNormalEffect(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::updateKitListPostOnNerveEnd(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::drawKit(const Scene* scene, const char* name)

#include <l/Library/Scene/SceneUtil.h>

void al::drawKitList(const Scene* scene, const char* listName, const char* name)

#include <l/Library/Scene/SceneUtil.h>

void al::drawLayoutKit(const Scene* scene, const char* name)

#include <l/Library/Scene/SceneUtil.h>

void al::drawEffectDeferred(const Scene* scene, s32 index)

#include <l/Library/Scene/SceneUtil.h>

void al::startForwardPlayerScreenFader(const Scene* scene, s32 a, s32 b, f32 c)

#include <l/Library/Scene/SceneUtil.h>

void al::endForwardPlayerScreenFader(const Scene* scene, s32 a)

#include <l/Library/Scene/SceneUtil.h>

bool al::isStopScene(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::startCheckViewCtrlByCameraPos(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::startCheckViewCtrlByLookAtPos(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::startCheckViewCtrlByPlayerPos(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

bool al::isExistScreenCoverCtrl(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

bool al::isRequestCaptureScreenCover(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::resetRequestCaptureScreenCover(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

bool al::isOffDrawScreenCover(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::resetCaptureScreenCover(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::validatePostProcessingFilter(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::invalidatePostProcessingFilter(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::incrementPostProcessingFilterPreset(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::decrementPostProcessingFilterPreset(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

s32 al::getPostProcessingFilterPresetId(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

const char* al::getActiveDemoName(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

LiveActor** al::getDemoActorList(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

s32 al::getDemoActorNum(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::updateDemoActor(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::updateDemoActorForPauseEffect(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::stopAllSe(const Scene* scene, u32 index)

#include <l/Library/Scene/SceneUtil.h>

void al::initPadRumble(const Scene* scene, const SceneInitInfo& sceneInfo)

#include <l/Library/Scene/SceneUtil.h>

void al::stopPadRumble(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::pausePadRumble(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::endPausePadRumble(const Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::validatePadRumble(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::invalidatePadRumble(Scene* scene)

#include <l/Library/Scene/SceneUtil.h>

void al::setPadRumblePowerLevel(Scene* scene, s32 powerLevel)

#include <l/Library/Scene/SceneUtil.h>

const Resource* al::getPreLoadFileListArc()

#include <l/Library/Scene/SceneUtil.h>

bool al::tryRequestPreLoadFile(const Scene* scene, const SceneInitInfo& sceneInfo, s32 index, sead::Heap* heap)

#include <l/Library/Scene/SceneUtil.h>

void al::initCameraDirector(Scene* scene, const CameraPoserFactory* cameraPoserFactory)

#include <l/Library/Scene/SceneUtil.h>

u32 al::getDisplayWidth()

#include <l/Library/Screen/ScreenFunction.h>

u32 al::getDisplayHeight()

#include <l/Library/Screen/ScreenFunction.h>

u32 al::getLayoutDisplayWidth()

#include <l/Library/Screen/ScreenFunction.h>

u32 al::getLayoutDisplayHeight()

#include <l/Library/Screen/ScreenFunction.h>

u32 al::getVirtualDisplayWidth()

#include <l/Library/Screen/ScreenFunction.h>

u32 al::getVirtualDisplayHeight()

#include <l/Library/Screen/ScreenFunction.h>

u32 al::getSubDisplayWidth()

#include <l/Library/Screen/ScreenFunction.h>

u32 al::getSubDisplayHeight()

#include <l/Library/Screen/ScreenFunction.h>

bool al::isInScreen(const sead::Vector2f&, f32)

#include <l/Library/Screen/ScreenFunction.h>

bool al::calcWorldPosFromScreen(sead::Vector3f* output, const sead::Vector2f&, const sead::Matrix34f&, f32)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcWorldPosFromScreenPos(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, f32)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcWorldPosFromScreenPos(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, const sead::Vector3f&)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcWorldPosFromScreenPos(sead::Vector3f* output, const SceneCameraInfo*, const sead::Vector2f&, f32, s32)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcWorldPosFromScreenPos(sead::Vector3f* output, const SceneCameraInfo*, const sead::Vector2f&, const sead::Vector3f&, s32)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcWorldPosFromScreenPosSub(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, f32)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcWorldPosFromScreenPosSub(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, const sead::Vector3f&)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcWorldPosFromLayoutPos(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, f32)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcWorldPosFromLayoutPos(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, const sead::Vector3f&)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcWorldPosFromLayoutPos(sead::Vector3f* output, const SceneCameraInfo*, const sead::Vector2f&, s32, s32)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcWorldPosFromLayoutPos(sead::Vector3f* output, const SceneCameraInfo*, const sead::Vector2f&, const sead::Vector3f&, s32)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcWorldPosFromLayoutPosSub(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, f32)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcWorldPosFromLayoutPosSub(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, const sead::Vector3f&)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcScreenPosFromWorldPos(sead::Vector2f* output, const IUseCamera*, const sead::Vector3f&)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcScreenPosFromWorldPosSub(sead::Vector2f* output, const IUseCamera*, const sead::Vector3f&)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcScreenPosFromLayoutPos(sead::Vector2f* output, const sead::Vector2f&)

#include <l/Library/Screen/ScreenFunction.h>

f32 al::calcScreenRadiusFromWorldRadius(const sead::Vector3f&, const IUseCamera*, f32)

#include <l/Library/Screen/ScreenFunction.h>

f32 al::calcScreenRadiusFromWorldRadiusSub(const sead::Vector3f&, const IUseCamera*, f32)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcLayoutPosFromScreenPos(sead::Vector2f* output, const sead::Vector2f&)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcLayoutPosFromWorldPos(sead::Vector2f* output, const IUseCamera*, const sead::Vector3f&)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcLayoutPosFromWorldPos(sead::Vector3f* output, const IUseCamera*, const sead::Vector3f&)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcLayoutPosFromWorldPos(sead::Vector2f* output, const SceneCameraInfo*, const sead::Vector3f&, s32)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcLayoutPosFromWorldPos(sead::Vector3f* output, const SceneCameraInfo*, const sead::Vector3f&, s32)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcLayoutPosFromWorldPosSub(sead::Vector2f* output, const IUseCamera*, const sead::Vector3f&)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcLayoutPosFromWorldPosWithClampOutRange(sead::Vector3f* output, const IUseCamera*, const sead::Vector3f&, f32, s32)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcLayoutPosFromWorldPosWithClampOutRange(sead::Vector3f* output, const SceneCameraInfo*, const sead::Vector3f&, f32, s32)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcLayoutPosFromWorldPosWithClampByScreen(sead::Vector3f* output, const IUseCamera*, const sead::Vector3f&)

#include <l/Library/Screen/ScreenFunction.h>

f32 al::calcLayoutRadiusFromWorldRadius(const sead::Vector3f&, const IUseCamera*, f32)

#include <l/Library/Screen/ScreenFunction.h>

bool al::calcCameraPosToWorldPosDirFromScreenPos(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, f32)

#include <l/Library/Screen/ScreenFunction.h>

bool al::calcCameraPosToWorldPosDirFromScreenPos(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, const sead::Vector3f&)

#include <l/Library/Screen/ScreenFunction.h>

bool al::calcCameraPosToWorldPosDirFromScreenPos(sead::Vector3f* output, const SceneCameraInfo*, const sead::Vector2f&, f32, s32)

#include <l/Library/Screen/ScreenFunction.h>

bool al::calcCameraPosToWorldPosDirFromScreenPos(sead::Vector3f* output, const SceneCameraInfo*, const sead::Vector2f&, const sead::Vector3f&, s32)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcCameraPosToWorldPosDirFromScreenPosSub(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, f32)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcCameraPosToWorldPosDirFromScreenPosSub(sead::Vector3f* output, const IUseCamera*, const sead::Vector2f&, const sead::Vector3f&)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcLineCameraToWorldPosFromScreenPos(sead::Vector3f* output1, sead::Vector3f* output2, const IUseCamera*, const sead::Vector2f&)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcLineCameraToWorldPosFromScreenPos(sead::Vector3f* output1, sead::Vector3f* output2, const IUseCamera*, const sead::Vector2f&, f32, f32)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcLineCameraToWorldPosFromScreenPos(sead::Vector3f* output1, sead::Vector3f* output2, const SceneCameraInfo*, const sead::Vector2f&, s32)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcLineCameraToWorldPosFromScreenPos(sead::Vector3f* output1, sead::Vector3f* output2, const SceneCameraInfo*, const sead::Vector2f&, f32, f32, s32)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcLineCameraToWorldPosFromScreenPosSub(sead::Vector3f* output1, sead::Vector3f* output2, const IUseCamera*, const sead::Vector2f&)

#include <l/Library/Screen/ScreenFunction.h>

void al::calcLineCameraToWorldPosFromScreenPosSub(sead::Vector3f* output1, sead::Vector3f* output2, const IUseCamera*, const sead::Vector2f&, f32, f32)

#include <l/Library/Screen/ScreenFunction.h>

void al::startSe(const IUseAudioKeeper*, const sead::SafeString&)

#include <l/Library/Se/SeFunction.h>

bool al::verifySeKeeperNull(const IUseAudioKeeper*, const sead::SafeString&)

#include <l/Library/Se/SeFunction.h>

bool al::tryStartSe(const IUseAudioKeeper*, const sead::SafeString&)

#include <l/Library/Se/SeFunction.h>

void al::holdSe(const IUseAudioKeeper*, const sead::SafeString&)

#include <l/Library/Se/SeFunction.h>

bool al::tryHoldSe(const IUseAudioKeeper*, const sead::SafeString&)

#include <l/Library/Se/SeFunction.h>

void al::startSeWithParam(const IUseAudioKeeper*, const sead::SafeString&, f32, const char*)

#include <l/Library/Se/SeFunction.h>

bool al::tryStartSeWithParam(const IUseAudioKeeper*, const sead::SafeString&, f32, const char*)

#include <l/Library/Se/SeFunction.h>

void al::holdSeWithParam(const IUseAudioKeeper*, const sead::SafeString&, f32, const char*)

#include <l/Library/Se/SeFunction.h>

bool al::tryHoldSeWithParam(const IUseAudioKeeper*, const sead::SafeString&, f32, const char*)

#include <l/Library/Se/SeFunction.h>

void al::startSeWithMeInfo(const IUseAudioKeeper*, const sead::SafeString&, const MeInfo*)

#include <l/Library/Se/SeFunction.h>

void al::holdSeWithMeInfo(const IUseAudioKeeper*, const sead::SafeString&, const MeInfo*)

#include <l/Library/Se/SeFunction.h>

void al::startSeWithManualControl(const IUseAudioKeeper*, const sead::SafeString&, const SePlayParamList*, const char*, const sead::Vector3f*)

#include <l/Library/Se/SeFunction.h>

bool al::tryStartSeWithManualControl(const IUseAudioKeeper*, const sead::SafeString&, const SePlayParamList*, const char*, const sead::Vector3f*)

#include <l/Library/Se/SeFunction.h>

void al::holdSeWithManualControl(const IUseAudioKeeper*, const sead::SafeString&, const SePlayParamList*, const char*, const sead::Vector3f*)

#include <l/Library/Se/SeFunction.h>

bool al::tryHoldSeWithManualControl(const IUseAudioKeeper*, const sead::SafeString&, const SePlayParamList*, const char*, const sead::Vector3f*)

#include <l/Library/Se/SeFunction.h>

void al::stopSe(const IUseAudioKeeper*, const sead::SafeString&, s32, const char*)

#include <l/Library/Se/SeFunction.h>

void al::stopSeWithoutFreezed(const IUseAudioKeeper*, const sead::SafeString&, s32, const char*)

#include <l/Library/Se/SeFunction.h>

bool al::tryStopSe(const IUseAudioKeeper*, const sead::SafeString&, s32, const char*)

#include <l/Library/Se/SeFunction.h>

void al::tryStopAllSeFromUser(const IUseAudioKeeper*, s32, const char*)

#include <l/Library/Se/SeFunction.h>

void al::stopAllSeFromUser(const IUseAudioKeeper*, s32, const char*)

#include <l/Library/Se/SeFunction.h>

bool al::isPlayingAnySe(const IUseAudioKeeper*, const char*)

#include <l/Library/Se/SeFunction.h>

bool al::checkIsPlayingSe(const IUseAudioKeeper*, const sead::SafeString&, const char*)

#include <l/Library/Se/SeFunction.h>

void al::setLifeTimeForHoldCall(const IUseAudioKeeper*, const char*, s32, const char*)

#include <l/Library/Se/SeFunction.h>

void al::setSeSourceVolume(const IUseAudioKeeper*, f32)

#include <l/Library/Se/SeFunction.h>

void al::setSeKeeperPlayNamePrefix(const IUseAudioKeeper*, const char*)

#include <l/Library/Se/SeFunction.h>

void al::resetSeKeeperPlayNamePrefix(const IUseAudioKeeper*)

#include <l/Library/Se/SeFunction.h>

bool al::isExistSeKeeper(const IUseAudioKeeper*)

#include <l/Library/Se/SeFunction.h>

void al::forceActivateSeKeeper(IUseAudioKeeper*)

#include <l/Library/Se/SeFunction.h>

void al::validateSeKeeper(IUseAudioKeeper*)

#include <l/Library/Se/SeFunction.h>

void al::invalidateSeKeeper(IUseAudioKeeper*)

#include <l/Library/Se/SeFunction.h>

void al::setSeEmitterPoseMtxPtr(const IUseAudioKeeper*, const sead::Matrix34f*, const char*)

#include <l/Library/Se/SeFunction.h>

void al::setSeEmitterPosePosPtr(const IUseAudioKeeper*, const sead::Vector3f*, const char*)

#include <l/Library/Se/SeFunction.h>

void al::tryUpdateSeMaterialCode(IUseAudioKeeper*, const char*)

#include <l/Library/Se/SeFunction.h>

void al::updateSeMaterialWater(IUseAudioKeeper*, bool)

#include <l/Library/Se/SeFunction.h>

void al::updateSeMaterialWet(IUseAudioKeeper*, bool)

#include <l/Library/Se/SeFunction.h>

void al::updateSeMaterialBeyondWall(IUseAudioKeeper*, bool)

#include <l/Library/Se/SeFunction.h>

void al::updateSeMaterialPuddle(IUseAudioKeeper*, bool)

#include <l/Library/Se/SeFunction.h>

void al::resetSeMaterialName(const IUseAudioKeeper*)

#include <l/Library/Se/SeFunction.h>

void al::setSeModifier(const IUseAudioKeeper*, ISeModifier*)

#include <l/Library/Se/SeFunction.h>

void al::setSeUserSyncParamPtr(const IUseAudioKeeper*, const f32*, const char*)

#include <l/Library/Se/SeFunction.h>

void al::setSeUserSyncParamPtrInt(const IUseAudioKeeper*, const s32*, const char*)

#include <l/Library/Se/SeFunction.h>

void al::setSeOutputFromController(SePlayParamList*, s32, bool)

#include <l/Library/Se/SeFunction.h>

void al::setSeOutputTvDrcRemoteAll(SePlayParamList*)

#include <l/Library/Se/SeFunction.h>

bool al::isExistShadow(LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

bool al::isExistShadowMaskCtrl(LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

bool al::isExistShadowMask(LiveActor* actor, const char* maskName)

#include <l/Library/Shadow/ActorShadowUtil.h>

bool al::isExistDepthShadow(LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

bool al::isExistDepthShadowMapCtrl(LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

bool al::isExistAnyShadowCtrl(LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

bool al::isHideShadowMask(const LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::hideShadow(LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::showShadow(LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::showShadowMask(LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::showShadowMask(LiveActor* actor, ShadowMaskBase* mask)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::showShadowMask(LiveActor* actor, const char* maskName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::showShadowMask(LiveActor* actor, ShadowMaskDrawCategory drawCategory)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::hideShadowMask(LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::hideShadowMask(LiveActor* actor, ShadowMaskBase* mask)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::hideShadowMask(LiveActor* actor, const char* maskName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::hideShadowMask(LiveActor* actor, ShadowMaskDrawCategory drawCategory)

#include <l/Library/Shadow/ActorShadowUtil.h>

bool al::isHideShadowMask(LiveActor* actor, const char* maskName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::showDepthShadowMap(LiveActor* actor, s32 mapIdx)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::showDepthShadowMap(const LiveActor* actor, DepthShadowMapInfo* map)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::showDepthShadowMap(LiveActor* actor, const char* mapName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::hideDepthShadowMap(LiveActor* actor, s32 mapIdx)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::hideDepthShadowMap(const LiveActor* actor, DepthShadowMapInfo* map)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::hideDepthShadowMap(LiveActor* actor, const char* mapName)

#include <l/Library/Shadow/ActorShadowUtil.h>

bool al::isHideDepthShadowMap(LiveActor* actor, const char* mapName)

#include <l/Library/Shadow/ActorShadowUtil.h>

bool al::isHideDepthShadowMap(LiveActor* actor, s32 mapIdx)

#include <l/Library/Shadow/ActorShadowUtil.h>

s32 al::getDepthShadowMapNum(LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::validateShadowMask(LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::validateShadowMask(LiveActor* actor, ShadowMaskBase* mask)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::validateShadowMask(LiveActor* actor, const char* maskName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::invalidateShadowMask(LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::invalidateShadowMask(LiveActor* actor, ShadowMaskBase* mask)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::invalidateShadowMask(LiveActor* actor, const char* maskName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::validateDepthShadowMap(LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::validateDepthShadowMap(LiveActor* actor, DepthShadowMapInfo* map)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::validateDepthShadowMap(LiveActor* actor, const char* mapName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::invalidateDepthShadowMap(LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::invalidateDepthShadowMap(LiveActor* actor, DepthShadowMapInfo* map)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::invalidateDepthShadowMap(LiveActor* actor, const char* mapName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::invalidateShadowMask(LiveActor* actor, ShadowMaskDrawCategory drawCategory)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::invalidateShadowMaskIntensityAll(LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setShadowMaskFixed(LiveActor* actor, bool isFixed)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setShadowMaskDropDir(LiveActor* actor, const sead::Vector3f& dropDir)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setShadowMaskDropDir(LiveActor* actor, const sead::Vector3f& dropDir, const char* maskName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setShadowMaskDropDirActorDown(LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setShadowMaskSize(LiveActor* actor, const char* maskName, const sead::Vector3f& size)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setShadowMaskSize(LiveActor* actor, const char* maskName, f32 sizeX, f32 sizeY, f32 sizeZ)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setShadowTextureOffset(LiveActor* actor, const char* maskName, f32 offsetX, f32 offsetY)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::onShadowTextureScroll(LiveActor* actor, const char* maskName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::offShadowTextureScroll(LiveActor* actor, const char* maskName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::calcShadowMaskSize(sead::Vector3f* size, LiveActor* actor, const char* maskName)

#include <l/Library/Shadow/ActorShadowUtil.h>

f32 al::getShadowMaskDropLength(const LiveActor* actor, const char* maskName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setShadowMaskDropLength(LiveActor* actor, f32 dropLength)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setShadowMaskDropLength(LiveActor* actor, f32 dropLength, const char* maskName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setShadowMaskDropLengthScaleWithDrawCategory(LiveActor* actor, f32 dropLengthScale, ShadowMaskDrawCategory drawCategory)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setShadowMaskDropLengthWithDrawCategory(LiveActor* actor, f32 dropLength, ShadowMaskDrawCategory drawCategory)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setShadowMaskDropLengthEvenWithTarget(ShadowMaskBase* targetMask, const char* maskName, const sead::Vector3f&)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setShadowMaskDropLengthEvenWithTarget(ShadowMaskBase* targetMask, const ShadowMaskBase* mask, const sead::Vector3f&)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setShadowMaskDropLengthEvenWithDrawCategory(LiveActor*, ShadowMaskDrawCategory drawCategory, const LiveActor*, const char* maskName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setShadowMaskDropLengthEvenPlaneNormal(const LiveActor* actor, const sead::Vector3f&)

#include <l/Library/Shadow/ActorShadowUtil.h>

s32 al::getDepthShadowMapWidth(const LiveActor* actor, const char* mapName)

#include <l/Library/Shadow/ActorShadowUtil.h>

s32 al::getDepthShadowMapHeight(const LiveActor* actor, const char* mapName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setDepthShadowMapSize(const LiveActor* actor, s32 width, s32 height, const char* mapName)

#include <l/Library/Shadow/ActorShadowUtil.h>

f32 al::getDepthShadowMapLength(const LiveActor* actor, const char* mapName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setDepthShadowMapLength(const LiveActor* actor, f32 length, const char* mapName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setDepthShadowMapLengthFromActorTransFlag(const LiveActor* actor, bool isSetShadowLength, const char* mapName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setDepthShadowMapBoundingBox(const LiveActor* actor, const sead::Vector3f& boundMin, const sead::Vector3f& boundMax, const char* mapName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setDepthShadowMapMaskTypeNone(const LiveActor* actor, const char* mapName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setDepthShadowMapMaskTypeSelf(const LiveActor* actor, const char* mapName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setEnableDepthShadowMapBottomGradation(const LiveActor* actor, const char* mapName, bool isEnableBottomGradation)

#include <l/Library/Shadow/ActorShadowUtil.h>

bool al::isEnableDepthShadowMapBottomGradation(const LiveActor* actor, const char* mapName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setDepthShadowMapBottomGradationLength(const LiveActor* actor, const char* mapName, f32 length)

#include <l/Library/Shadow/ActorShadowUtil.h>

f32 al::getDepthShadowMapBottomGradationLength(const LiveActor* actor, const char* mapName)

#include <l/Library/Shadow/ActorShadowUtil.h>

bool al::isAppendSubActorDepthShadowMap(const LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

f32 al::getShadowMaskDropLengthMax(const LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setShadowMaskColor(const LiveActor* actor, const char* maskName, const sead::Color4f& color)

#include <l/Library/Shadow/ActorShadowUtil.h>

const sead::Color4f& al::getShadowMaskColor(const LiveActor* actor, const char* maskName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setShadowMaskIntensity(const LiveActor* actor, const char* maskName, f32 intensity)

#include <l/Library/Shadow/ActorShadowUtil.h>

f32 al::getShadowMaskIntensity(const LiveActor* actor, const char* maskName)

#include <l/Library/Shadow/ActorShadowUtil.h>

f32 al::getShadowMaskTextureFixedScale(const LiveActor* actor, const char* maskName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setShadowMaskTextureFixedScale(const LiveActor* actor, const char* maskName, f32 scale)

#include <l/Library/Shadow/ActorShadowUtil.h>

const sead::Vector3f& al::getShadowMaskOffset(const LiveActor* actor, const char* maskName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setShadowMaskOffset(const LiveActor* actor, const sead::Vector3f& offset, const char* maskName)

#include <l/Library/Shadow/ActorShadowUtil.h>

bool al::isExistOcclusionLightPosPtr(const LiveActor* actor, const char* occSphereName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setOcclusionLightPosPtr(const LiveActor* actor, const char* occSphereName, const sead::Vector3f* lightPosPtr)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setOcclusionAddOffset(const LiveActor* actor, const char* occSphereName, const sead::Vector3f& offset)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::enableOcclusion(const LiveActor* actor, const char* occSphereName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::disableOcclusion(const LiveActor* actor, const char* occSphereName)

#include <l/Library/Shadow/ActorShadowUtil.h>

bool al::isEnableOcclusion(const LiveActor* actor, const char* occSphereName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::calcSphereDoBoundingInfo(sead::Vector3f*, sead::Vector3f*, f32*, f32*, const LiveActor* actor, const char* occSphereName, f32)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::calcOcclusionSpherePos(sead::Vector3f* pos, const LiveActor* actor, const char* occSphereName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::changeOcclusionGroup(const LiveActor* actor, const char* occSphereName, const char* groupName)

#include <l/Library/Shadow/ActorShadowUtil.h>

OccSphere* al::getOcclusionSphere(const LiveActor* actor, const char* occSphereName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::setOcclusionIgnoreHostHide(const LiveActor* actor, bool isIgnoreHostHide)

#include <l/Library/Shadow/ActorShadowUtil.h>

bool al::findIsInShade(const LiveActor* actor, const sead::Vector3f& pos)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::requestDepthShadowMapLightDir(const LiveActor* actor, const sead::Vector3f& lightDir, const char* mapName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::resetRequestDepthShadowMapLightDir(const LiveActor* actor, const char* mapName)

#include <l/Library/Shadow/ActorShadowUtil.h>

bool al::isRequestDepthShadowMapLightDir(const LiveActor* actor, const char* mapName)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::onDepthShadowModel(LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::offDepthShadowModel(LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::updateDepthShadowMapCtrlShapeVisible(LiveActor* actor)

#include <l/Library/Shadow/ActorShadowUtil.h>

void al::makeStageDataArchivePath(sead::BufferedSafeString* archivePath, const char* stageName, const char* resourceType)

#include <l/Library/Stage/StageResourceUtil.h>

void al::initStageSwitch(IUseStageSwitch* user, StageSwitchDirector* stageSwitchDirector, const PlacementInfo& placementInfo)

#include <l/Library/Stage/StageSwitchUtil.h>

static StageSwitchAccesser* al::getStageSwitchAccesser(const IUseStageSwitch* user, const char* linkName)

#include <l/Library/Stage/StageSwitchUtil.cpp>

bool al::isValidStageSwitch(const IUseStageSwitch* user, const char* linkName)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::isOnStageSwitch(const IUseStageSwitch* user, const char* linkName)

#include <l/Library/Stage/StageSwitchUtil.h>

void al::onStageSwitch(IUseStageSwitch* user, const char* linkName)

#include <l/Library/Stage/StageSwitchUtil.h>

void al::offStageSwitch(IUseStageSwitch* user, const char* linkName)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::tryOnStageSwitch(IUseStageSwitch* user, const char* linkName)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::tryOffStageSwitch(IUseStageSwitch* user, const char* linkName)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::isSameStageSwitch(const IUseStageSwitch* user, const IUseStageSwitch* otherUser, const char* linkName)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::isValidSwitchAppear(const IUseStageSwitch* user)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::isOnSwitchAppear(const IUseStageSwitch* user)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::isValidSwitchKill(const IUseStageSwitch* user)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::isValidSwitchDeadOn(const IUseStageSwitch* user)

#include <l/Library/Stage/StageSwitchUtil.h>

void al::onSwitchDeadOn(IUseStageSwitch* user)

#include <l/Library/Stage/StageSwitchUtil.h>

void al::offSwitchDeadOn(IUseStageSwitch* user)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::tryOnSwitchDeadOn(IUseStageSwitch* user)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::tryOffSwitchDeadOn(IUseStageSwitch* user)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::isValidSwitchStart(const IUseStageSwitch* user)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::isOnSwitchStart(const IUseStageSwitch* user)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::listenStageSwitchOn(IUseStageSwitch* user, const char* eventName, const FunctorBase& action)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::listenStageSwitchOff(IUseStageSwitch* user, const char* eventName, const FunctorBase& action)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::listenStageSwitchOnOff(IUseStageSwitch* user, const char* eventName, const FunctorBase& actionOn, const FunctorBase& actionOff)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::listenStageSwitchOnAppear(IUseStageSwitch* user, const FunctorBase& action)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::listenStageSwitchOnOffAppear(IUseStageSwitch* user, const FunctorBase& actionOn, const FunctorBase& actionOff)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::listenStageSwitchOnKill(IUseStageSwitch* user, const FunctorBase& action)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::listenStageSwitchOnOffKill(IUseStageSwitch* user, const FunctorBase& actionOn, const FunctorBase& actionOff)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::trySyncStageSwitchOnOffAppear(IUseStageSwitch* user, const FunctorBase& actionOn, const FunctorBase& actionOff)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::trySyncStageSwitchOnOffKill(IUseStageSwitch* user, const FunctorBase& actionOn, const FunctorBase& actionOff)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::trySyncStageSwitchOnOffAppearAndKill(IUseStageSwitch* user, const FunctorBase& actionOn, const FunctorBase& actionOff)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::listenStageSwitchOnStart(IUseStageSwitch* user, const FunctorBase& action)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::listenStageSwitchOnOffStart(IUseStageSwitch* user, const FunctorBase& actionOn, const FunctorBase& actionOff)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::listenStageSwitchOnStop(IUseStageSwitch* user, const FunctorBase& action)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::trySyncStageSwitchOnOff(IUseStageSwitch* user, const FunctorBase& actionOn, const FunctorBase& actionOff)

#include <l/Library/Stage/StageSwitchUtil.h>

bool al::tryGetByamlU8(u8* pOut, const ByamlIter& rIter, const char* pKey)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlU16(u16* pOut, const ByamlIter& rIter, const char* pKey)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlS16(s16* pOut, const ByamlIter& rIter, const char* pKey)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlS32(s32* pOut, const ByamlIter& rIter, const char* pKey)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlU32(u32* pOut, const ByamlIter& rIter, const char* pKey)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlS64(s64* pOut, const ByamlIter& rIter, const char* pKey)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlU64(u64* pOut, const ByamlIter& rIter, const char* pKey)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlF32(f32* pOut, const ByamlIter& rIter, const char* pKey)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlV2f(sead::Vector2f* pOut, const ByamlIter& rIter)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlV3f(sead::Vector3f* pOut, const ByamlIter& rIter)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlV4f(sead::Vector4f* pOut, const ByamlIter& rIter)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlScale(sead::Vector3f* pOut, const ByamlIter& rIter)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlV2s32(sead::Vector2i* pOut, const ByamlIter& rIter)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlV3s32(sead::Vector3i* pOut, const ByamlIter& rIter)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlBox3f(sead::BoundBox3f* pOut, const ByamlIter& rIter)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlV3f(sead::Vector3f* pOut, const ByamlIter& sIter, const char* key)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlV2f(sead::Vector2f* pOut, const ByamlIter& sIter, const char* key)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlV4f(sead::Vector4f* pOut, const ByamlIter& sIter, const char* key)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlScale(sead::Vector3f* pOut, const ByamlIter& sIter, const char* key)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlV2s32(sead::Vector2i* pOut, const ByamlIter& sIter, const char* key)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlV3s32(sead::Vector3i* pOut, const ByamlIter& sIter, const char* key)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlBox3f(sead::BoundBox3f* pOut, const ByamlIter& sIter, const char* key)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlString(const char** pOut, const ByamlIter& rIter, const char* key)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlColor(sead::Color4f* pOut, const ByamlIter& rIter)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlColor(sead::Color4f* pOut, const ByamlIter& sIter, const char* key)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlBool(bool* pOut, const ByamlIter& rIter, const char* key)

#include <l/Library/Yaml/ByamlUtil.h>

const char* al::tryGetByamlKeyStringOrNULL(const ByamlIter& rIter, const char* key)

#include <l/Library/Yaml/ByamlUtil.h>

s32 al::tryGetByamlKeyIntOrZero(const ByamlIter& rIter, const char* key)

#include <l/Library/Yaml/ByamlUtil.h>

u32 al::tryGetByamlKeyU32OrZero(const ByamlIter& rIter, const char* key)

#include <l/Library/Yaml/ByamlUtil.h>

f32 al::tryGetByamlKeyFloatOrZero(const ByamlIter& rIter, const char* key)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlKeyBoolOrFalse(const ByamlIter& rIter, const char* key)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlIterByKey(ByamlIter* pOut, const ByamlIter& rIter, const char* key)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::tryGetByamlKeyAndIntByIndex(const char** key, s32* pOut, const ByamlIter& rIter, s32 index)

#include <l/Library/Yaml/ByamlUtil.h>

const char* al::getByamlKeyString(const ByamlIter& rIter, const char* key)

#include <l/Library/Yaml/ByamlUtil.h>

s32 al::getByamlKeyInt(const ByamlIter& rIter, const char* key)

#include <l/Library/Yaml/ByamlUtil.h>

f32 al::getByamlKeyFloat(const ByamlIter& rIter, const char* key)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::getByamlKeyBool(const ByamlIter& rIter, const char* key)

#include <l/Library/Yaml/ByamlUtil.h>

void al::getByamlIterByKey(ByamlIter* pOut, const ByamlIter& rIter, const char* pKey)

#include <l/Library/Yaml/ByamlUtil.h>

void al::getByamlIterByIndex(ByamlIter* pOut, const ByamlIter& rIter, s32 index)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::isTypeBoolByIndex(const ByamlIter& rIter, s32 index)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::isTypeBoolByKey(const ByamlIter& rIter, const char* pKey)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::isTypeIntByIndex(const ByamlIter& rIter, s32 index)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::isTypeIntByKey(const ByamlIter& rIter, const char* pKey)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::isTypeFloatByIndex(const ByamlIter& rIter, s32 index)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::isTypeFloatByKey(const ByamlIter& rIter, const char* pKey)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::isTypeStringByIndex(const ByamlIter& rIter, s32 index)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::isTypeStringByKey(const ByamlIter& rIter, const char* pKey)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::isTypeArrayByIndex(const ByamlIter& rIter, s32 index)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::isTypeArrayByKey(const ByamlIter& rIter, const char* pKey)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::isTypeHashByIndex(const ByamlIter& rIter, s32 index)

#include <l/Library/Yaml/ByamlUtil.h>

bool al::isTypeHashByKey(const ByamlIter& rIter, const char* pKey)

#include <l/Library/Yaml/ByamlUtil.h>

s32 al::getByamlIterDataNum(const ByamlIter& rIter)

#include <l/Library/Yaml/ByamlUtil.h>

void al::printByamlIter(const u8* data)

#include <l/Library/Yaml/ByamlUtil.h>

void al::printByamlIter(const ByamlIter& iter)

#include <l/Library/Yaml/ByamlUtil.h>

void al::printByamlIter_(const ByamlIter& iter, PrintParams* param)

#include <l/Library/Yaml/ByamlUtil.h>

#include <l/Library/Yaml/ByamlUtil.h>

template<ByamlDataType T>

bool al::isTypeByIndex(const ByamlIter& rIter, s32 index)

#include <l/Library/Yaml/ByamlUtil.h>

template<ByamlDataType T>

bool al::isTypeByKey(const ByamlIter& rIter, const char* key)

al::SEAD_ENUM(YamlParamType, Invalid, Bool, F32, S32, U32, V2f, V2s32, V3f, V4f, Q4f, C4f, StringRef, String32, String64, String128, String256, String512, String1024, String2048, String4096)

#include <l/Library/Yaml/ParameterBase.h>

char* al::add(const char* string, sead::TList<const char*>& list)

#include <l/Library/Yaml/Writer/ByamlWriterStringTable.cpp>

u32 al::getFileList(sead::FixedSafeString<256> out[], s32 outSize, const char* path, bool isPathValidconst sead::DirectoryEntry &, const char *, const char* suffix)

#include <l/Project/File/FileLoader.cpp>

static bool al::isDirectoryValid(const sead::DirectoryEntry& entry, const char* suffix)

#include <l/Project/File/FileLoader.cpp>

static bool al::isFileValid(const sead::DirectoryEntry& entry, const char* suffix)

#include <l/Project/File/FileLoader.cpp>

RollingCubePoseKeeper* al::createRollingCubePoseKeeper(const LiveActor* actor, const ActorInitInfo& initInfo)

#include <l/Project/Joint/RollingCubePoseKeeperUtil.h>

RollingCubePoseKeeper* al::createRollingCubePoseKeeper(const sead::BoundBox3f& cubeSize, const ActorInitInfo& initInfo)

#include <l/Project/Joint/RollingCubePoseKeeperUtil.h>

bool al::nextRollingCubeKey(RollingCubePoseKeeper* keeper)

#include <l/Project/Joint/RollingCubePoseKeeperUtil.h>

void al::setStartRollingCubeKey(RollingCubePoseKeeper* keeper)

#include <l/Project/Joint/RollingCubePoseKeeperUtil.h>

void al::setRollingCubeKeyIndex(RollingCubePoseKeeper* keeper, s32 index)

#include <l/Project/Joint/RollingCubePoseKeeperUtil.h>

bool al::isMoveTypeLoopRollingCube(const RollingCubePoseKeeper* keeper)

#include <l/Project/Joint/RollingCubePoseKeeperUtil.h>

void al::fittingToCurrentKeyBoundingBox(sead::Quatf* outQuat, sead::Vector3f* outTrans, const RollingCubePoseKeeper* keeper)

#include <l/Project/Joint/RollingCubePoseKeeperUtil.h>

void al::calcCurrentKeyQT(sead::Quatf* outQuat, sead::Vector3f* outTrans, const RollingCubePoseKeeper* keeper, const sead::Quatf& quat, const sead::Vector3f& trans, f32 rate)

#include <l/Project/Joint/RollingCubePoseKeeperUtil.h>

void al::getCurrentKeyQT(sead::Quatf* outQuat, sead::Vector3f* outTrans, const RollingCubePoseKeeper* keeper)

#include <l/Project/Joint/RollingCubePoseKeeperUtil.h>

f32 al::getCurrentKeyRotateDegree(const RollingCubePoseKeeper* keeper)

#include <l/Project/Joint/RollingCubePoseKeeperUtil.h>

const sead::Vector3f& al::getCurrentKeySlideVec(const RollingCubePoseKeeper* keeper)

#include <l/Project/Joint/RollingCubePoseKeeperUtil.h>

s32 al::getCurrentKeyIndex(const RollingCubePoseKeeper* keeper)

#include <l/Project/Joint/RollingCubePoseKeeperUtil.h>

const PlacementInfo& al::getCurrentKeyPlacementInfo(const RollingCubePoseKeeper* keeper)

#include <l/Project/Joint/RollingCubePoseKeeperUtil.h>

bool al::isMovementCurrentKeyRotate(const RollingCubePoseKeeper* keeper)

#include <l/Project/Joint/RollingCubePoseKeeperUtil.h>

bool al::isMovementCurrentKeySlide(const RollingCubePoseKeeper* keeper)

#include <l/Project/Joint/RollingCubePoseKeeperUtil.h>

f32 al::calcDistanceCurrentKeyRotateCenterToBoxCenter(const RollingCubePoseKeeper* keeper)

#include <l/Project/Joint/RollingCubePoseKeeperUtil.h>

void al::calcMtxLandEffect(sead::Matrix34f* effectMtx, const RollingCubePoseKeeper* keeper, const sead::Quatf& quat, const sead::Vector3f& trans)

#include <l/Project/Joint/RollingCubePoseKeeperUtil.h>

void al::calcRollingCubeClippingInfo(sead::Vector3f* clippingTrans, f32* clippingRadius, const RollingCubePoseKeeper* keeper, f32 offset)

#include <l/Project/Joint/RollingCubePoseKeeperUtil.h>

void al::executeUpdate(LiveActorKit*, const char*)

#include <l/Project/LiveActor/ActorExecuteFunction.h>

void al::executeUpdateTable(LiveActorKit*, const char*)

#include <l/Project/LiveActor/ActorExecuteFunction.h>

void al::executeUpdateList(LiveActorKit*, const char*, const char*)

#include <l/Project/LiveActor/ActorExecuteFunction.h>

void al::executeDraw(const LiveActorKit*, const char*)

#include <l/Project/LiveActor/ActorExecuteFunction.h>

void al::executeDrawList(const LiveActorKit*, const char*, const char*)

#include <l/Project/LiveActor/ActorExecuteFunction.h>

bool al::isActiveDraw(const LiveActorKit*, const char*)

#include <l/Project/LiveActor/ActorExecuteFunction.h>

void al::executeUpdateDrawBuffer(const LiveActorKit*)

#include <l/Project/LiveActor/ActorExecuteFunction.h>

void al::waitUpdateDrawBuffer(const LiveActorKit*)

#include <l/Project/LiveActor/ActorExecuteFunction.h>

void al::executeUpdateCalcView(const LiveActorKit*)

#include <l/Project/LiveActor/ActorExecuteFunction.h>

void al::waitUpdateCalcView(const LiveActorKit*)

#include <l/Project/LiveActor/ActorExecuteFunction.h>

void al::incrementDrawBufferCounter(const LiveActorKit*)

#include <l/Project/LiveActor/ActorExecuteFunction.h>

void al::registSupportFreezeSyncGroup(LiveActor* actor, const ActorInitInfo& info)

#include <MapObj/SubActorLodFixPartsScenarioAction.h>

Variable documentation

static NameToCreator<AreaShapeCreatorFunction> al::sAreaShapeEntries

#include <l/Library/Area/AreaShape.cpp>

const char* al::str2

#include <l/Library/Base/StringUtil.cpp>

const char* al::archiveName

#include <l/Library/Camera/CameraResourceHolder.cpp>

const CameraShaker::ShakeInfo al::WeakShakeLoop

#include <l/Library/Camera/CameraShaker.cpp>

const CameraShaker::ShakeInfo al::ShakeInfos

#include <l/Library/Camera/CameraShaker.cpp>

const char* al::name

#include <l/Library/LiveActor/ActorAreaFunction.cpp>

const char const char* al::groupName

#include <l/Library/LiveActor/ActorAreaFunction.cpp>

const char const char const char* al::areaName

#include <l/Library/LiveActor/ActorAreaFunction.cpp>

AreaObjGroup* al::areaGroup

#include <l/Library/LiveActor/ActorAreaFunction.cpp>

const PlacementInfo& al::actorPlacementInfo

#include <l/Library/LiveActor/ActorAreaFunction.cpp>

const NameToCreator<PoseKeeperCreatorFunction> al::gActorPoseTable

#include <l/Library/LiveActor/ActorInitUtil.cpp>

LiveActor* al::actor

#include <l/Library/LiveActor/ActorInitUtil.cpp>

s32 al::poseId

#include <l/Library/LiveActor/ActorInitUtil.cpp>

return al::false

#include <l/Library/LiveActor/ActorInitUtil.cpp>

const ActorInitInfo& al::initInfo

#include <l/Library/LiveActor/ActorInitUtil.cpp>

const ActorInitInfo Resource* al::modelRes

#include <l/Library/LiveActor/ActorInitUtil.cpp>

const ActorInitInfo Resource const char* al::suffix

#include <l/Library/LiveActor/ActorInitUtil.cpp>

const char* al::pose

#include <l/Library/LiveActor/ActorInitUtil.cpp>

sead::Vector3f al::scale

#include <l/Library/LiveActor/ActorInitUtil.cpp>

const sead::Vector3f& al::prevScale

#include <l/Library/LiveActor/ActorInitUtil.cpp>

scale al::x

#include <l/Library/LiveActor/ActorInitUtil.cpp>

scale al::y

#include <l/Library/LiveActor/ActorInitUtil.cpp>

scale al::z

#include <l/Library/LiveActor/ActorInitUtil.cpp>

sead::BoundBox3f al::modelBoundingBox

#include <l/Library/LiveActor/ActorInitUtil.cpp>

s32 al::lodModelCount

#include <l/Library/LiveActor/ActorInitUtil.cpp>

ModelLodCtrl* al::modelLodCtrl

#include <l/Library/LiveActor/ActorInitUtil.cpp>

const ActorInitInfo Resource ActorResource* al::actorResource

#include <l/Library/LiveActor/ActorInitUtil.cpp>

s32 al::blendAnimMax

#include <l/Library/LiveActor/ActorInitUtil.cpp>

const char* al::displayRootJointName

#include <l/Library/LiveActor/ActorInitUtil.cpp>

bool al::isCreateUniqShader

#include <l/Library/LiveActor/ActorInitUtil.cpp>

s32 al::partialAnimSlotNum

#include <l/Library/LiveActor/ActorInitUtil.cpp>

s32 al::partialAnimGroupNum

#include <l/Library/LiveActor/ActorInitUtil.cpp>

s32 al::partialAnimPartsListBufferSize

#include <l/Library/LiveActor/ActorInitUtil.cpp>

bool al::isFixedModel

#include <l/Library/LiveActor/ActorInitUtil.cpp>

bool al::isIgnoreUpdateOnDrawClipping

#include <l/Library/LiveActor/ActorInitUtil.cpp>

al::true

#include <l/Library/LiveActor/ActorInitUtil.cpp>

ModelKeeper* al::modelKeeper

#include <l/Library/LiveActor/ActorInitUtil.cpp>

MaterialCategoryKeeper* al::materialCategoryKeeper

#include <l/Library/LiveActor/ActorInitUtil.cpp>

GraphicsQualityInfo* al::graphicsQualityInfo

#include <l/Library/LiveActor/ActorInitUtil.cpp>

ModelOcclusionQuery* al::modelOcclusionQuery

#include <l/Library/LiveActor/ActorInitUtil.cpp>

bool al::isCalcViewCore1

#include <l/Library/LiveActor/ActorInitUtil.cpp>

bool al::isCalcViewCore2

#include <l/Library/LiveActor/ActorInitUtil.cpp>

const char* al::updaterCategoryName

#include <l/Library/LiveActor/ActorInitUtil.cpp>

const char* al::drawerCategoryName

#include <l/Library/LiveActor/ActorInitUtil.cpp>

ByamlIter al::iter

#include <l/Library/LiveActor/ActorInitUtil.cpp>

s32 al::numSensors

#include <l/Library/LiveActor/ActorInitUtil.cpp>

sead::FixedSafeString<256> al::unused

#include <l/Library/LiveActor/ActorInitUtil.cpp>

const char* al::sensorName

#include <l/Library/LiveActor/ActorInitUtil.cpp>

HitSensor* al::sensor

#include <l/Library/LiveActor/ActorInitUtil.cpp>

const char* al::joint

#include <l/Library/LiveActor/ActorInitUtil.cpp>

sead::Matrix34f* al::jointMtx

#include <l/Library/LiveActor/ActorInitUtil.cpp>

f32 al::radius

#include <l/Library/LiveActor/ActorInitUtil.cpp>

u32 al::planeNum

#include <l/Library/LiveActor/ActorInitUtil.cpp>

sead::Vector3f al::offset

#include <l/Library/LiveActor/ActorInitUtil.cpp>

const char* al::seName

#include <l/Library/LiveActor/ActorInitUtil.cpp>

const char* al::bgmName

#include <l/Library/LiveActor/ActorInitUtil.cpp>

else al::return

#include <l/Library/LiveActor/ActorInitUtil.cpp>

const ActorInitInfo const ByamlIter& al::initClipping

#include <l/Library/LiveActor/ActorInitUtil.cpp>

ByamlIter al::groupClipping

#include <l/Library/LiveActor/ActorInitUtil.cpp>

bool al::invalidate

#include <l/Library/LiveActor/ActorInitUtil.cpp>

sead::BoundBox3f al::obb

#include <l/Library/LiveActor/ActorInitUtil.cpp>

f32 al::nearClipDistance

#include <l/Library/LiveActor/ActorInitUtil.cpp>

tryGetArg& al::usingDepthShadow

#include <l/Library/LiveActor/ActorInitUtil.cpp>

ByamlIter al::initShadowMask

#include <l/Library/LiveActor/ActorInitUtil.cpp>

ByamlIter al::tmp

#include <l/Library/LiveActor/ActorInitUtil.cpp>

DitherAnimator* al::ditherAnimator

#include <l/Library/LiveActor/ActorInitUtil.cpp>

const PlacementInfo* al::placementInfo

#include <l/Library/LiveActor/ActorInitUtil.cpp>

const char* al::objectName

#include <l/Library/LiveActor/ActorInitUtil.cpp>

const char* al::className

#include <l/Library/LiveActor/ActorInitUtil.cpp>

ActorCreatorFunction al::creationFunction

#include <l/Library/LiveActor/ActorInitUtil.cpp>

const char* al::displayName

#include <l/Library/LiveActor/ActorInitUtil.cpp>

const LiveActor* al::target

#include <l/Library/LiveActor/ActorMovementFunction.cpp>

const LiveActor const sead::Vector3f& al::targetVelocity

#include <l/Library/LiveActor/ActorMovementFunction.cpp>

const LiveActor const sead::Vector3f f32 al::reboundStrength

#include <l/Library/LiveActor/ActorMovementFunction.cpp>

calcDirToActor& al::direction

#include <l/Library/LiveActor/ActorMovementFunction.cpp>

f32 al::dot

#include <l/Library/LiveActor/ActorMovementFunction.cpp>

static sead::FixedSafeString<256> al::sDeviceName

#include <l/Project/File/FileLoader.cpp>