Reopen namespace to define DataPatch class. More...

Namespaces
namespace	Constants
	Important constants.

namespace	DeprecatedTypeNames

namespace	Environment

namespace	Intersect

namespace	IO
	PathView implementation.

Classes
class	Aabb

struct	AddressType

class	AddressTypeElement

class	AddressTypeSerializer

struct	Adl

class	AllocatorBase

struct	AllocatorDebugConfig

class	AllocatorGlobalWrapper

class	AllocatorInstance

class	AllocatorManager

class	AllocatorPointerWrapper

class	AllocatorWrapper

struct	AnyTypeInfoConcept

struct	AnyTypeInfoConcept< ValueType, AZStd::enable_if_t< AZStd::is_abstract< ValueType >::value > >

struct	AnyTypeInfoConcept< ValueType, AZStd::enable_if_t<!AZStd::is_abstract< ValueType >::value &&!AZStd::Internal::template_is_copy_constructible< ValueType >::value > >

struct	AnyTypeInfoConcept< ValueType, AZStd::enable_if_t<!AZStd::is_abstract< ValueType >::value &&AZStd::Internal::template_is_copy_constructible< ValueType >::value > >

struct	ApplicationTypeQuery

class	AssetManagerComponent

class	AssetSerializer

class	AssetTypeInfo

class	Attribute

class	AttributeData

class	AttributeFunction

class	AttributeFunction< R(Args...)>

class	AttributeInvocable

class	AttributeInvoker

class	AttributeMemberData

class	AttributeMemberData< T C::* >

class	AttributeMemberFunction

class	AttributeMemberFunction< R(C::*)(Args...) const >

class	AttributeMemberFunction< R(C::*)(Args...)>

class	AttributeReader

struct	auto_partitioner

class	AzCoreModule

struct	AzDeprecatedTypeNameVisitor

struct	AzDeprecatedTypeNameVisitor< AZStd::tuple< Types... > >

struct	AzDeprecatedTypeNameVisitor< R(Args...)>

struct	AzDeprecatedTypeNameVisitor< T & >

struct	AzDeprecatedTypeNameVisitor< T && >

struct	AzDeprecatedTypeNameVisitor< T * >

struct	AzDeprecatedTypeNameVisitor< T const & >

struct	AzDeprecatedTypeNameVisitor< T const && >

struct	AzDeprecatedTypeNameVisitor< T const >

class	AZStdAlloc

class	AZStdFunctorAllocator

class	AZStdIAllocator

class	AzStdReflectionComponent

struct	AzTypeInfo

class	BaseJsonImporter

class	BaseJsonIntegerSerializer

class	BaseJsonMatrixSerializer

class	BaseJsonSerializer

class	BaseJsonVectorSerializer

struct	BehaviorArgument

struct	BehaviorArgumentValueTypeTag_t

struct	BehaviorAzEventDescription

class	BehaviorClass

class	BehaviorContext

class	BehaviorContextEvents

class	BehaviorDefaultValue

class	BehaviorEBus

struct	BehaviorEBusEventSender

class	BehaviorEBusHandler

class	BehaviorInterfaceProxy

class	BehaviorMethod

struct	BehaviorObject

class	BehaviorObjectSignalsInterface

struct	BehaviorParameter

struct	BehaviorParameterMetadata

struct	BehaviorParameterOverrides

class	BehaviorProperty

class	BehaviorValues

class	BetterPseudoRandom_UnixLike

class	BetterPseudoRandom_Windows

class	BezierSpline

struct	BranchOnResultInfo

class	Capsule
	A class representing a capsule (a cylinder with a hemispherical cap at each end). More...

class	CatmullRomSpline

struct	CheckedOperationInfo

class	ChildAllocatorSchema

struct	ClampedIntegralLimits
	A collection of methods for clamping and constraining integer values and ranges to that of a reference integer type. More...

class	Color
	A color class with 4 components, RGBA. More...

class	CommandLine

struct	CompareScheduledEventPtrs

class	Component

class	ComponentApplication

class	ComponentApplicationRequests
	Interface that components can use to make requests of the main application. More...

class	ComponentApplicationRequestsEBusTraits

class	ComponentBus

class	ComponentConfig

class	ComponentDescriptor

struct	ComponentDescriptorBusTraits

class	ComponentDescriptorDefault

class	ComponentDescriptorHelper

class	ConfigurableStack

class	ConfigurableStackInterface

class	Console

struct	ConsoleCommandMemberFunctorSignature

struct	ConsoleCommandMemberFunctorSignature< T, AZStd::enable_if_t< AZStd::is_class_v< T > > >

class	ConsoleDataContainer

class	ConsoleDataContainer< BASE_TYPE, ThreadSafety::RequiresLock >

class	ConsoleDataContainer< BASE_TYPE, ThreadSafety::UseStdAtomic >

class	ConsoleDataWrapper

class	ConsoleFunctor
	Console functor which wraps a function call into an object instance. More...

class	ConsoleFunctor< void, _REPLICATES_VALUE >

class	ConsoleFunctorBase

struct	ConsoleReplicateHelper

struct	ConsoleReplicateHelper< _TYPE, false >

struct	ConsoleReplicateHelper< _TYPE, true >

struct	ConsoleReplicateHelper< AZStd::string, true >

struct	ConsoleReplicateHelper< float, true >

struct	ConsoleReplicateHelper< int, true >

class	Crc32

struct	DataOverlayInfo

class	DataOverlayInstanceId

class	DataOverlayInstanceMsgs

class	DataOverlayProviderMsgs

class	DataOverlayTarget

class	DataOverlayToken

class	DataPatch

struct	DataPatchNodeInfo

class	DataPatchNotifications
	Notifications broadcast by the data patching system. More...

class	DataPatchUpgradeManager

class	DataStream

class	Dependency

class	DeprecatedComponentMetadata

struct	DomInvokeHelper

struct	DomInvokeHelper< AZStd::function< R(Args...)> >

class	DynamicModuleDescriptor

class	DynamicModuleHandle

class	DynamicSerializableField

class	DynamicSliceAsset

class	EBus

struct	EBusAggregateResults

struct	EBusConnectionPolicy

class	EBusEnvironment

struct	EBusEnvironmentStoragePolicy

struct	EBusEventProcessingPolicy

struct	EBusGlobalStoragePolicy

struct	EBusQueuePolicy

struct	EBusQueuePolicy< true, Bus, MutexType >

struct	EBusReduceResult

struct	EBusReduceResult< T &, Aggregator >

class	EBusSharedDispatchMutex

class	EBusSharedDispatchMutexCallstackLockGuard

class	EBusSharedDispatchMutexConnectLockGuard

class	EBusSharedDispatchMutexDispatchLockGuard

struct	EBusSharedDispatchTraits

struct	EBusThreadLocalStoragePolicy

struct	EBusTraits

class	EditContext

class	Entity

class	EntityComponentIdPair

class	EntityEvents

class	EntityId

class	EntitySystemEvents

class	EnumConstantJsonSerializer

struct	EnumTypeFromVectorOfEnumConstants

struct	EnumTypeFromVectorOfEnumConstants< AZStd::vector< Edit::EnumConstant< EnumType > > >

class	EnvironmentVariable
	EnvironmentVariable holds a pointer to the actual variable, it should be used as any smart pointer. Event though most of the it will be "static" as it's treated as a global. More...

class	Event

class	EventHandler
	A handler class that can connect to an Event. More...

struct	EventHandlerCreationFunctionHolder

class	EventSchedulerSystemComponent
	This is scheduled event queue class to run all scheduled events at appropriate intervals. More...

struct	ExplicitOverloadInfo

struct	ExportedComponent

class	FixedVertices

class	FloatArrayTextSerializer

class	FloatBasedContainerSerializer
	Custom template to cover all fundamental AZMATH classes. More...

class	Frustum
	A frustum class that can be used for efficient primitive intersection tests. More...

class	FunctionalScriptProperty

class	GenericClassInfo

class	HaltonSequence

struct	has_common_type_helper

struct	has_common_type_helper< AZStd::void_t< std::common_type_t< Types... > >, Types... >

struct	HasAZClassAllocator

struct	HasAZClassAllocator< T, decltype(T::AZ_CLASS_ALLOCATOR_Allocate(), void())>

struct	HasAZRtti

class	Hemisphere
	A simple bounding hemisphere class for fast intersection testing. More...

class	HphaSchema

class	HphaSchemaBase

class	HSM

class	IAllocator

class	IAllocatorTrackingRecorder

class	IAllocatorWithTracking

class	IConsole

class	IEventScheduler
	This is an AZ::Interface<> for managing scheduled events. Users should not require any direct interaction with this interface, ScheduledEvent is a self contained abstraction. More...

class	IEventSchedulerRequests

class	ILogger
	This is an AZ::Interface<> for logging. Usage: #include <AzCore/Console/ILogger.h> AZLOG_INFO("Your message here"); AZLOG_WARN("Your warn message here");. More...

class	ILoggerRequests

struct	InputRestriction

class	InstancePool

class	InstancePoolBase

class	InstancePoolManager

class	InstancePoolManagerInterface

class	Interface

class	IRttiHelper

struct	Iterator_VM

class	Iterator_VM< AZStd::unordered_map< t_Key, t_Value, t_Hasher, t_EqualKey, t_Allocator > >

class	Iterator_VM< AZStd::unordered_set< t_Key, t_Hasher, t_EqualKey, t_Allocator > >

class	Iterator_VM< AZStd::vector< t_Value, t_Allocator > >

class	ITime
	This is an AZ::Interface<> for managing time related operations. AZ::ITime and associated types may not operate in realtime. These abstractions are to allow our application simulation to operate both slower and faster than realtime in a well defined and user controllable manner The rate at which time passes for AZ::ITime is controlled by the cvar t_simulationTickScale t_simulationTickScale == 0 means simulation time should halt 0 < t_simulationTickScale < 1 will cause time to pass slower than realtime, with t_simulationTickScale 0.1 being roughly 1/10th realtime t_simulationTickScale == 1 will cause time to pass at roughly realtime t_simulationTickScale > 1 will cause time to pass faster than normal, with t_simulationTickScale 10 being roughly 10x realtime. More...

class	ITimeRequests

class	Job

class	JobCancelGroup

class	JobCompletion

class	JobCompletionSpin

class	JobContext

class	JobEmpty

class	JobFunction

class	JobManager

class	JobManagerComponent

struct	JobManagerDesc

class	JobManagerEvents

struct	JobManagerThreadDesc

class	JsonAnySerializer

struct	JsonApplyPatchSettings
	Optional settings used while applying a patch to a json value. More...

class	JsonArraySerializer

class	JsonBaseContext

class	JsonBasicContainerSerializer

class	JsonBitsetSerializer

class	JsonBoolSerializer

class	JsonByteStreamSerializer

class	JsonCharSerializer

class	JsonColorSerializer

class	JsonConfigurableStackSerializer

struct	JsonCreatePatchSettings
	Optional settings used while creating a patch for a json value. More...

class	JsonDeserializer

class	JsonDeserializerContext

struct	JsonDeserializerSettings
	Optional settings used while loading a json value to an object. More...

class	JsonDoubleSerializer

class	JsonEntityIdSerializer

class	JsonEntitySerializer

class	JsonFloatSerializer

struct	JsonImportMetadata

class	JsonImportResolver

struct	JsonImportSettings

class	JsonIntSerializer

class	JsonLongLongSerializer

class	JsonLongSerializer

class	JsonMapSerializer

class	JsonMatrix3x3Serializer

class	JsonMatrix3x4Serializer

class	JsonMatrix4x4Serializer

class	JsonMerger

class	JsonOptionalSerializer

class	JsonOSStringSerializer

class	JsonPathSerializer

class	JsonQuaternionSerializer

class	JsonRegistrationContext

class	JsonSerialization

class	JsonSerializationMetadata
	Holds a collection of generic settings objects to be used by custom serializers. More...

class	JsonSerializer

class	JsonSerializerContext

struct	JsonSerializerSettings
	Optional settings used while storing an object to a json value. More...

class	JsonShortSerializer

class	JsonSmartPointerSerializer

class	JsonStringSerializer

class	JsonSystemComponent

class	JsonTransformSerializer

class	JsonTupleSerializer

class	JsonUnorderedMapSerializer

class	JsonUnorderedMultiMapSerializer

class	JsonUnorderedSetContainerSerializer

class	JsonUnsignedCharSerializer

class	JsonUnsignedIntSerializer

class	JsonUnsignedLongLongSerializer

class	JsonUnsignedLongSerializer

class	JsonUnsignedShortSerializer

class	JsonUnsupportedTypesSerializer

class	JsonUuidSerializer

class	JsonVariantSerializer

class	JsonVector2Serializer

class	JsonVector3Serializer

class	JsonVector4Serializer

class	LinearlyInterpolatedSample

class	LinearlyInterpolatedSample< Quaternion >

class	LinearlyInterpolatedSample< Vector3 >

class	LinearSpline

class	LineSegment
	LineSegment defined by two Vector3, an start and a end. More...

class	LoggerSystemComponent
	Implementation of the ILogger system interface. More...

class	LossyCasted

struct	LuaNativeThread

class	LuaScriptData

struct	LuaUserData

class	Matrix3x3

class	Matrix3x4

class	Matrix4x4

class	MatrixMxN
	Matrix with ROW_COUNT rows and COL_COUNT columns. More...

class	MockSettingsRegistry

class	MockTimeSystem

class	Module

struct	ModuleData

struct	ModuleDataImpl

class	ModuleEntity

class	ModuleManager

class	ModuleManagerRequests
	Requests related to module reloading. More...

class	MultipleDependentJob

class	Name

class	NamedEntityId

class	NameDictionary

class	NameJsonSerializer

class	NameRef

class	NameSerializer
	Provides flattened serialization of Name objects as a simple string. More...

class	NonUniformScaleRequests
	Requests for working with non-uniform scale. More...

struct	NullBusId

struct	NullMutex

class	NumericCasted

class	Obb
	An oriented bounding box. More...

class	ObjectStream

struct	OnDemandReflection

struct	OnDemandReflection< AZ::Event< T... > >

struct	OnDemandReflection< AZ::Outcome< ValueT, ErrorT > >

struct	OnDemandReflection< AZ::Outcome< ValueT, void > >

struct	OnDemandReflection< AZ::Outcome< void, ErrorT > >

struct	OnDemandReflection< AZ::Outcome< void, void > >

struct	OnDemandReflection< AZStd::any >

struct	OnDemandReflection< AZStd::array< T, N > >
	OnDemand reflection for AZStd::array. More...

struct	OnDemandReflection< AZStd::chrono::duration< Rep, Period > >

struct	OnDemandReflection< AZStd::intrusive_ptr< T > >
	OnDemand reflection for AZStd::intrusive_ptr. More...

struct	OnDemandReflection< AZStd::optional< T > >

struct	OnDemandReflection< AZStd::pair< T1, T2 > >

struct	OnDemandReflection< AZStd::shared_ptr< T > >
	OnDemand reflection for AZStd::shared_ptr. More...

struct	OnDemandReflection< AZStd::tuple< T... > >

struct	OnDemandReflection< AZStd::unordered_map< Key, MappedType, Hasher, EqualKey, Allocator > >
	OnDemand reflection for AZStd::unordered_map. More...

struct	OnDemandReflection< AZStd::unordered_set< Key, Hasher, EqualKey, Allocator > >
	OnDemand reflection for AZStd::unordered_set. More...

struct	OnDemandReflection< AZStd::vector< T, A > >
	OnDemand reflection for AZStd::vector. More...

struct	OnDemandReflection< Data::Asset< T > >
	OnDemandReflection for any generic Data::Asset<T> More...

class	OnDemandReflectionOwner

class	OrderedEvent

class	OrderedEventHandler
	A handler class that can connect to an Event that will be called in order based on priority. More...

class	OSAllocator

class	Outcome

struct	OverloadArgumentGroupInfo

struct	OverloadInfo

struct	OverloadVariance

class	PackedVector3

class	Plane

class	PlatformHelper
	Platform Helper is an utility class that can be used to retrieve platform related information. More...

class	PolygonPrism

class	PoolAllocation

class	PoolAllocator

class	PoolSchema

struct	PositionSplineQueryResult

struct	PrioritizeScheduledEventPtrs

struct	ProcessMemInfo
	Stores Process Memory information data. More...

class	Quaternion

class	Ray
	Ray defined by two Vector3, an orign and a normalized direction. More...

struct	RaySplineQueryResult

class	ReflectContext

class	ReflectionEnvironment

class	ReflectionManager

struct	RegisteredReflectionContextResult

struct	ReplaceInvocableReturnType

struct	ReplaceInvocableReturnType< NewReturnType, OldReturnType(Args...)>

struct	s128

class	Sample

class	ScheduledEvent

struct	ScheduledEventHandle

struct	ScopedBehaviorEBusHandler

class	ScopedBehaviorOnDemandReflector

class	ScopedContextPath

class	ScopedContextReporter

class	ScopedStackedString
	Scoped object that manages the life cycle of a single entry on the string stack. More...

class	ScriptAsset

class	ScriptContext

class	ScriptContextDebug

class	ScriptDataContext

class	ScriptDebug

struct	ScriptLoadResult

class	ScriptProperties

class	ScriptProperty

class	ScriptPropertyAsset

class	ScriptPropertyBoolean

class	ScriptPropertyBooleanArray

class	ScriptPropertyGenericClass

class	ScriptPropertyGenericClassArray

class	ScriptPropertyGenericClassMap

class	ScriptPropertyGenericClassMapImpl

class	ScriptPropertyNil

class	ScriptPropertyNumber

class	ScriptPropertyNumberArray

class	ScriptPropertySerializer

class	ScriptPropertyString

class	ScriptPropertyStringArray

class	ScriptPropertyTable

class	ScriptPropertyWatcher

class	ScriptPropertyWatcherInterface

class	ScriptSystemComponent

class	ScriptSystemRequests

class	ScriptTimePoint
	Wrapper that reflects a AZStd::chrono::steady_clock::time_point to script. More...

struct	ScriptValue
	Script value implementation for all value and reference types. The push Function will always create an object COPY, this will be slower than just using pointers. More...

struct	ScriptValue< AZ::s64 >

struct	ScriptValue< AZ::u64 >

struct	ScriptValue< AZStd::any >

struct	ScriptValue< AZStd::basic_string< Element, Traits, Allocator > >

struct	ScriptValue< bool >

struct	ScriptValue< char >

struct	ScriptValue< const AZStd::any & >

struct	ScriptValue< const AZStd::any >

struct	ScriptValue< const AZStd::basic_string< Element, Traits, Allocator > & >

struct	ScriptValue< const AZStd::basic_string< Element, Traits, Allocator > >

struct	ScriptValue< const char * >

struct	ScriptValue< double >

struct	ScriptValue< float >

struct	ScriptValue< int ** >

struct	ScriptValue< int >

struct	ScriptValue< long >

struct	ScriptValue< short >

struct	ScriptValue< T * >
	Script value implementation for generic pointer types, always prefer pointer types. More...

struct	ScriptValue< unsigned char >

struct	ScriptValue< unsigned int >

struct	ScriptValue< unsigned long >

struct	ScriptValue< unsigned short >

struct	ScriptValue< void * >

struct	ScriptValueGeneric

struct	ScriptValueGeneric< T, true >

struct	SemanticVersion

class	SerializeContext

struct	SerializeGenericTypeInfo

struct	SerializeGenericTypeInfo< AZ::Outcome< t_Success, t_Failure > >
	Generic specialization for AZ::Outcome. More...

struct	SerializeGenericTypeInfo< AZStd::array< T, Size > >
	Generic specialization for AZStd::array. More...

struct	SerializeGenericTypeInfo< AZStd::basic_string< E, T, A > >
	Generic specialization for AZStd::string. More...

struct	SerializeGenericTypeInfo< AZStd::bitset< NumBits > >

struct	SerializeGenericTypeInfo< AZStd::fixed_vector< T, Capacity > >
	Generic specialization for AZStd::fixed_vector. More...

struct	SerializeGenericTypeInfo< AZStd::forward_list< T, A > >
	Generic specialization for AZStd::forward_list. More...

struct	SerializeGenericTypeInfo< AZStd::intrusive_ptr< T > >

struct	SerializeGenericTypeInfo< AZStd::list< T, A > >
	Generic specialization for AZStd::list. More...

struct	SerializeGenericTypeInfo< AZStd::map< K, M, C, A > >
	Generic specialization for AZStd::map. More...

struct	SerializeGenericTypeInfo< AZStd::optional< T > >

struct	SerializeGenericTypeInfo< AZStd::pair< T1, T2 > >
	Generic specialization for AZStd::pair. More...

struct	SerializeGenericTypeInfo< AZStd::set< K, C, A > >

struct	SerializeGenericTypeInfo< AZStd::shared_ptr< T > >

struct	SerializeGenericTypeInfo< AZStd::tuple< Types... > >
	Generic specialization for AZStd::tuple. More...

struct	SerializeGenericTypeInfo< AZStd::unique_ptr< T, Deleter > >

struct	SerializeGenericTypeInfo< AZStd::unordered_map< K, M, H, E, A > >
	Generic specialization for AZStd::unordered_map. More...

struct	SerializeGenericTypeInfo< AZStd::unordered_multimap< K, M, H, E, A > >
	Generic specialization for AZStd::unordered_multimap. More...

struct	SerializeGenericTypeInfo< AZStd::unordered_multiset< K, H, E, A > >
	Generic specialization for AZStd::unordered_multiset. More...

struct	SerializeGenericTypeInfo< AZStd::unordered_set< K, H, E, A > >
	Generic specialization for AZStd::unordered_set. More...

struct	SerializeGenericTypeInfo< AZStd::vector< AZ::u8, A > >
	Generic specialization for AZStd::vector<AZ::u8,Allocator> byte stream. If this conflics with a normal vector<unsigned char> create a new type. More...

struct	SerializeGenericTypeInfo< AZStd::vector< T, A > >
	Generic specialization for AZStd::vector. More...

struct	SerializeGenericTypeInfo< ConfigurableStack< StackBaseType > >

struct	SerializeGenericTypeInfo< Data::Asset< T > >

struct	SerializeGenericTypeInfo< Internal::RValueToLValueWrapper< T > >
	Generic specialization for our internal RValue wrapper.

struct	SerializeTypeInfo

struct	SetResult

class	SettingsRegistryImpl

class	SettingsRegistryInterface

class	SettingsRegistryOriginTracker

class	Sfmt

class	Sha1

class	SharedMemory

class	SharedMemory_Common

class	SharedMemory_Mac

class	SharedMemory_Unimplemented

class	SharedMemory_Windows

class	SharedMemoryRingBuffer

struct	simple_partitioner

class	SimpleLcgRandom

class	SimpleLcgRandomVec4
	This class is a vectorized implementation of LCG, allowing for the generation of 4 random values in parallel. More...

class	SimpleSchemaAllocator

struct	SizeType

struct	SizeType< 0, false >

struct	SizeType< 0, true >

struct	SizeType< 1, false >

struct	SizeType< 1, true >

struct	SizeType< 2, false >

struct	SizeType< 2, true >

struct	SizeType< 3, false >

struct	SizeType< 3, true >

struct	SizeType< 4, false >

struct	SizeType< 4, true >

struct	SizeType< 5, false >

struct	SizeType< 5, true >

struct	SizeType< 6, false >

struct	SizeType< 6, true >

struct	SizeType< 7, false >

struct	SizeType< 7, true >

struct	SizeType< 8, false >

struct	SizeType< 8, true >

class	SliceAsset

class	SliceAssetHandler

class	SliceAssetSerializationNotifications

class	SliceComponent

class	SliceEntityHierarchyInterface

class	SliceEvents

class	SliceInstanceEvents

class	SliceMetadataInfoComponent

class	SliceMetadataInfoManipulationRequests

class	SliceMetadataInfoNotifications

class	SliceMetadataInfoRequests

class	SliceSystemComponent

struct	Specifier

class	Sphere
	A simple bounding sphere class for fast intersection testing. More...

class	Spline

struct	SplineAddress

class	StackedString

struct	static_partitioner

class	StreamerComponent

class	structured_task_group

class	StubTimeSystem

class	SystemAllocator

class	SystemTickEvents

struct	TaskDescriptor

class	TaskExecutor

class	TaskGraph

class	TaskGraphActiveInterface

class	TaskGraphEvent

class	TaskGraphSystemComponent

class	TaskToken

class	ThreadPoolAllocator

class	ThreadPoolSchema

class	ThreadPoolSchemaHelper

class	ThreadSafeDeque

class	ThreadSafeObject

class	TickEvents

class	TickRequests

class	TimeSystem
	Implementation of the ITime system interface. More...

class	Transform

class	TransformConfig
	Component configuration for the transform component. More...

class	TransformInterface

class	TransformNotification

struct	u128

class	UninterpolatedSample

class	UninterpolatedSample< Quaternion >

class	UninterpolatedSample< Vector3 >

struct	UnwrapperFuncDeleter

struct	UnwrapperUserData

class	UserSettings

class	UserSettingsComponent

class	UserSettingsComponentRequests

struct	UserSettingsContainer

class	UserSettingsFileLocator

class	UserSettingsMessages

class	UserSettingsNotifications

class	UserSettingsOwnerRequests

class	UserSettingsProvider

struct	Uuid

class	UuidSerializer

class	VariableVertices

class	Vector2
	2-dimensional vector class. More...

class	Vector3
	3-dimensional vector class. More...

class	Vector4

class	VectorN
	N-dimensional vector class. More...

struct	Version

class	VertexContainer

class	VertexContainerNotificationInterface

class	VertexRequests
	EBus traits for vertex requests. More...

struct	ViewFrustumAttributes
	Attributes required to construct a Frustum from a view volume. More...

class	ZLib

class	ZStd

Typedefs
using	AssetTypeInfoBus = AZ::EBus< AssetTypeInfo >

using	s8 = int8_t

using	u8 = uint8_t

using	s16 = int16_t

using	u16 = uint16_t

using	s32 = int32_t

using	u32 = uint32_t

using	s64 = signed long long

using	u64 = unsigned long long

typedef AZ::u32	ComponentServiceType
	ID of a user-defined component service. The system uses it to build a dependency tree.

using	ImmutableEntityVector = AZStd::vector< AZ::Entity const * >

using	ComponentTypeList = AZStd::vector< Uuid >
	List of Component class type IDs.

using	ComponentValidationResult = AZ::Outcome< void, AZStd::string >

using	ComponentDescriptorBus = AZ::EBus< ComponentDescriptor, ComponentDescriptorBusTraits >

using	EntityAddedEvent = AZ::Event< AZ::Entity * >

using	EntityRemovedEvent = AZ::Event< AZ::Entity * >

using	EntityActivatedEvent = AZ::Event< AZ::Entity * >

using	EntityDeactivatedEvent = AZ::Event< AZ::Entity * >

using	ComponentApplicationBus = AZ::EBus< ComponentApplicationRequests, ComponentApplicationRequestsEBusTraits >
	Used by components to make requests of the component application.

typedef AZ::u64	ComponentId

using	PlatformTagSet = AZStd::unordered_set< AZ::Crc32 >

using	CustomExportCallbackFunc = AZStd::function< ExportedComponent(AZ::Component *thisComponent, const PlatformTagSet &tags)>

typedef AZ::EBus< EntitySystemEvents >	EntitySystemBus

typedef AZ::EBus< EntityEvents >	EntityBus

using	NonUniformScaleChangedEvent = AZ::Event< const AZ::Vector3 & >

using	NonUniformScaleRequestBus = AZ::EBus< NonUniformScaleRequests >

typedef AZ::EBus< TickEvents >	TickBus

typedef AZ::EBus< TickRequests >	TickRequestBus

using	SystemTickBus = AZ::EBus< SystemTickEvents >

using	TransformChangedEvent = Event< const Transform &, const Transform & >

using	ParentChangedEvent = Event< EntityId, EntityId >

using	ChildChangedEvent = Event< ChildChangeType, EntityId >

using	TransformBus = AZ::EBus< TransformInterface >

using	TransformNotificationBus = AZ::EBus< TransformNotification >

using	PerformCommandResult = Outcome< void, AZStd::string >

using	ConsoleCommandContainer = AZStd::fixed_vector< AZStd::basic_string_view< char, AZStd::char_traits< char > >, MaxConsoleCommandPlusArgsLength >

using	CVarFixedString = AZStd::basic_fixed_string< char, MaxCVarStringLength, AZStd::char_traits< char > >

using	ConsoleCommandInvokedEvent = AZ::Event< AZStd::basic_string_view< char, AZStd::char_traits< char > >, const ConsoleCommandContainer &, ConsoleFunctorFlags, ConsoleInvokedFrom >

using	DispatchCommandNotFoundEvent = AZ::Event< AZStd::basic_string_view< char, AZStd::char_traits< char > >, const ConsoleCommandContainer &, ConsoleInvokedFrom >

using	ILoggerRequestBus = AZ::EBus< ILogger, ILoggerRequests >

using	IEventSchedulerRequestBus = AZ::EBus< IEventScheduler, IEventSchedulerRequests >

using	InterfaceErrorString = AZStd::fixed_string< 256 >

using	InterfaceRegisterOutcome = AZ::Outcome< void, InterfaceErrorString >

typedef AZ::EBus< JobManagerEvents >	JobManagerBus

using	PackedVector3f = PackedVector3< float >

using	PackedVector3i = PackedVector3< int32_t >

using	PolygonPrismPtr = AZStd::shared_ptr< PolygonPrism >

using	ConstPolygonPrismPtr = AZStd::shared_ptr< const PolygonPrism >

using	BetterPseudoRandom = BetterPseudoRandom_Platform

using	SplinePtr = AZStd::shared_ptr< Spline >

using	ConstSplinePtr = AZStd::shared_ptr< const Spline >

using	IndexFunction = AZStd::function< void(size_t)>

using	VoidFunction = AZStd::function< void()>

using	BoolFunction = AZStd::function< void(bool)>

template<typename Vertex >
using	FixedVerticesRequestBus = EBus< FixedVertices< Vertex >, VertexRequests >
	Type to inherit to implement FixedVertices interface.

template<typename Vertex >
using	VariableVerticesRequestBus = EBus< VariableVertices< Vertex >, VertexRequests >
	Type to inherit to implement VariableVertices interface.

typedef AZStdAlloc< OSAllocator >	OSStdAllocator

template<class Allocator >
using	ThreadPoolBase = Internal::PoolAllocatorHelper< ThreadPoolSchemaHelper< Allocator > >

using	InitializeDynamicModuleFunction = void(*)()

using	UninitializeDynamicModuleFunction = void(*)()

using	CreateModuleClassFunction = AZ::Module ()()

using	DestroyModuleClassFunction = void()(AZ::Module module)

typedef Internal::EnvironmentInterface *	EnvironmentInstance

using	ModuleDescriptorList = AZStd::vector< DynamicModuleDescriptor, OSStdAllocator >

using	CreateStaticModulesCallback = AZStd::function< void(AZStd::vector< AZ::Module * > &)>

using	ModuleManagerRequestBus = AZ::EBus< ModuleManagerRequests >

using	AssetPlatformFixedString = AZStd::fixed_string< 32 >

using	AssetPlatformCombinedString = AZStd::fixed_string<(AssetPlatformFixedString{}.max_size()+1) *PlatformId::NumPlatformIds >

template<class T >
using	AzEnumTraits = typename Internal::GetAzEnumTraits_Impl< AZStd::remove_cvref_t< T > >::type

template<class T >
using	HasAzEnumTraits = AZStd::bool_constant< Internal::HasAzEnumTraitsImpl< AZStd::remove_cvref_t< T > > >

template<typename T >
using	decay_array = AZStd::conditional_t< AZStd::is_array_v< AZStd::remove_reference_t< T > >, std::remove_extent_t< AZStd::remove_reference_t< T > > *, T && >

using	BehaviorDefaultValuePtr = AZStd::intrusive_ptr< BehaviorDefaultValue >

using	InputIndices = AZStd::vector< AZ::u8 >

using	BehaviorFunction = AZStd::function< void(BehaviorArgument result, BehaviorArgument arguments, int numArguments)>

using	EventHandlerCreationFunction = AZStd::function< BehaviorObject(void *, BehaviorFunction &&)>

using	UnwrapperPtr = AZStd::unique_ptr< void, UnwrapperFuncDeleter >

using	BehaviorClassUnwrapperFunction = void()(void , BehaviorObject &, const UnwrapperUserData &)

template<class Function >
using	BehaviorParameterOverridesArray = AZStd::array< BehaviorParameterOverrides, AZStd::function_traits< Function >::num_args >

using	BehaviorContextBus = AZ::EBus< BehaviorContextEvents >

using	BehaviorObjectSignals = AZ::EBus< BehaviorObjectSignalsInterface >

using	StaticReflectionFunctionPtr = void()(ReflectContext context)

using	ReflectionFunction = AZStd::function< void(ReflectContext *context)>
	Must be function object, as these are typically virtual member functions (see ComponentDescriptor::Reflect)

using	AttributeUniquePtr = AZStd::unique_ptr< AZ::Attribute, Internal::AttributeDeleter >

typedef AZ::u32	AttributeId

typedef AZStd::pair< AttributeId, Attribute * >	AttributePair

typedef AZStd::vector< AttributePair >	AttributeArray

template<typename T >
using	AttributeContainerType = AZStd::conditional_t< AZStd::is_member_pointer< T >::value, AZStd::conditional_t< AZStd::is_member_function_pointer< T >::value, AttributeMemberFunction< T >, AttributeMemberData< T > >, AZStd::conditional_t< AZStd::is_function< AZStd::remove_pointer_t< T > >::value, AttributeFunction< AZStd::remove_pointer_t< T > >, AZStd::conditional_t< AZStd::function_traits< T >::value, AttributeInvocable< typename AZStd::function_traits< T >::function_type >, AttributeData< T > > > >

using	TypeId = Uuid

using	RTTI_EnumCallback = void()(const AZ::TypeId &, void )
	RTTI Visitor.

using	DeprecatedTypeNameCallback = AZStd::function< void(AZStd::string_view)>

using	TypeNameString = AZStd::fixed_string< 512 >

using	TemplateId = AZ::Uuid
	An identifier which used to reference a Class Template.

using	ScriptTypeId = Uuid

using	ScriptShortTypeId = size_t

typedef AZ::u32	ScriptContextId

using	StackVariableAllocator = AZStd::static_buffer_allocator< 256, 16 >

using	LuaLoadFromStack = bool()(lua_State , int, AZ::BehaviorArgument &, AZ::BehaviorClass , AZ::StackVariableAllocator )

using	LuaPushToStack = void()(lua_State , AZ::BehaviorArgument &)

using	LuaPrepareValue = bool()(AZ::BehaviorArgument &, AZ::BehaviorClass , AZ::StackVariableAllocator &, AZStd::allocator *backupAllocator)

typedef AZ::EBus< ScriptPropertyWatcherInterface >	ScriptPropertyWatcherBus

using	InMemoryScriptModules = AZStd::vector< AZStd::pair< AZStd::string, AZ::Data::Asset< AZ::ScriptAsset > > >

using	ScriptSystemRequestBus = AZ::EBus< ScriptSystemRequests >

typedef u32	DataOverlayProviderId

typedef EBus< DataOverlayInstanceMsgs >	DataOverlayInstanceBus

typedef EBus< DataOverlayProviderMsgs >	DataOverlayProviderBus

using	DataPatchNotificationBus = AZ::EBus< DataPatchNotifications >

template<class T >
using	InvocableReturnType = AZStd::conditional_t< AZStd::function_traits< T >::value, typename AZStd::function_traits< T >::return_type, T >

template<class T >
using	EnumTypeFromVectorOfEnumConstants_t = typename EnumTypeFromVectorOfEnumConstants< T >::type

template<class NewReturnType , class InvocableType >
using	ReplaceInvocableReturnType_t = typename ReplaceInvocableReturnType< NewReturnType, InvocableType >::type

using	JsonByteStream = AZStd::vector< AZ::u8 >
	Alias for AZStd::vector<AZ::u8>.

using	ReporterString = AZStd::fixed_string< 1024 >

using	ObjectStreamWriteOverrideCB = AZStd::function< ObjectStreamWriteOverrideResponse(SerializeContext::EnumerateInstanceCallContext &callContext, const void classPtr, const SerializeContext::ClassData &classData, const SerializeContext::ClassElement classElement)>

using	AttributePtr = AZStd::shared_ptr< Attribute >

using	AttributeSharedPair = AZStd::pair< AttributeId, AttributePtr >

using	SettingsRegistry = Interface< SettingsRegistryInterface >

using	PrefabComponent = SliceComponent

using	PrefabAsset = SliceAsset

using	DynamicPrefabAsset = DynamicSliceAsset

typedef EBus< SliceEvents >	SliceBus

using	SliceInstanceNotificationBus = AZ::EBus< SliceInstanceEvents >

using	SliceAssetSerializationNotificationBus = AZ::EBus< SliceAssetSerializationNotifications >

using	SliceEntityHierarchyRequestBus = AZ::EBus< SliceEntityHierarchyInterface >

using	PrefabEvents = SliceEvents

using	PrefabBus = SliceBus

using	SliceMetadataInfoRequestBus = EBus< SliceMetadataInfoRequests >

using	SliceMetadataInfoManipulationBus = EBus< SliceMetadataInfoManipulationRequests >

using	SliceMetadataInfoNotificationBus = EBus< SliceMetadataInfoNotifications >

typedef AZStd::basic_string< char, AZStd::char_traits< char >, OSStdAllocator >	OSString

using	ITimeRequestBus = AZ::EBus< ITime, ITimeRequests >

using	NiceTimeSystemMock = ::testing::NiceMock< MockTimeSystem >

using	NiceSettingsRegistrySimpleMock = ::testing::NiceMock< MockSettingsRegistry >

typedef EBus< UserSettingsFileLocator >	UserSettingsFileLocatorBus

using	UserSettingsComponentRequestBus = AZ::EBus< UserSettingsComponentRequests >

typedef EBus< UserSettingsMessages >	UserSettingsBus

typedef EBus< UserSettingsOwnerRequests >	UserSettingsOwnerRequestBus

typedef EBus< UserSettingsNotifications >	UserSettingsNotificationBus

using	SharedMemory_Platform = SharedMemory_Unimplemented

using	BetterPseudoRandom_Platform = BetterPseudoRandom_UnixLike

Enumerations
enum	ComponentTickBus { TICK_FIRST = 0 , TICK_PLACEMENT = 50 , TICK_INPUT = 75 , TICK_GAME = 80 , TICK_ANIMATION = 100 , TICK_PHYSICS_SYSTEM = 200 , TICK_PHYSICS = TICK_PHYSICS_SYSTEM + 1 , TICK_ATTACHMENT = 500 , TICK_PRE_RENDER = 750 , TICK_DEFAULT = 1000 , TICK_UI = 2000 , TICK_LAST = 100000 }

enum class	ChildChangeType { Added , Removed }

enum class	OnParentChangedBehavior : AZ::u8 { Update , DoNotUpdate }
	Used to control the behavior of an entity's transform when its parent's transform changes at runtime. More...

enum class	ThreadSafety { RequiresLock , UseStdAtomic }

enum class	GetValueResult { Success , NotImplemented , TypeNotConvertible , ConsoleVarNotFound }

enum class	ConsoleFunctorFlags { Null = 0 , DontReplicate = (1 << 0) , ServerOnly = (1 << 1) , ReadOnly = (1 << 2) , IsCheat = (1 << 3) , IsInvisible = (1 << 4) , IsDeprecated = (1 << 5) , NeedsReload = (1 << 6) , AllowClientSet = (1 << 7) , DontDuplicate = (1 << 8) }

enum class	ConsoleSilentMode { Silent , NotSilent }

enum class	ConsoleInvokedFrom { AzConsole , AzNetworking , CryBinding }

enum class	LogLevel : int8_t { Trace = 1 , Debug = 2 , Info = 3 , Notice = 4 , Warn = 5 , Error = 6 , Fatal = 7 }
	This essentially maps to standard syslog logging priorities to allow the logger to easily plug into standard logging services.

enum class	EBusAddressPolicy { Single , ById , ByIdAndOrdered }

enum class	EBusHandlerPolicy { Single , Multiple , MultipleAndOrdered }

enum class	InterpolationMode : u32 { NoInterpolation , LinearInterpolation }

enum class	IntegralTypeDiff { LSignedRSignedEqSize , LSignedRUnsignedEqSize , LUnsignedRSignedEqSize , LUnsignedRUnsignedEqSize , LSignedRSignedLWider , LSignedRUnsignedLWider , LUnsignedRSignedLWider , LUnsignedRUnsignedLWider , LSignedRSignedRWider , LSignedRUnsignedRWider , LUnsignedRSignedRWider , LUnsignedRUnsignedRWider }
	Enumerations to describe the sign and size relationship between two integer types. More...

enum class	IntegralCompare { LessThan , Equal , GreaterThan }
	Comparison result returned by SafeIntegralCompare.

enum class	IntersectResult { Interior , Overlaps , Exterior }
	Intersection classifications.

enum class	RandomDistributionType : AZ::u32 { Normal , UniformReal }

enum class	ModuleInitializationSteps : u8 { None , Load , CreateClass , RegisterComponentDescriptors , ActivateEntity }

enum class	PlatformFlags : AZ::u32 { Platform_NONE = 0x00 , Platform_PC = 1 << PlatformId::PC , Platform_LINUX = 1 << PlatformId::LINUX_ID , Platform_ANDROID = 1 << PlatformId::ANDROID_ID , Platform_IOS = 1 << PlatformId::IOS , Platform_MAC = 1 << PlatformId::MAC_ID , Platform_PROVO = 1 << PlatformId::PROVO , Platform_SALEM = 1 << PlatformId::SALEM , Platform_JASPER = 1 << PlatformId::JASPER , Platform_SERVER = 1 << PlatformId::SERVER , Platform_ALL = 1ULL << 30 , Platform_ALL_CLIENT = 1ULL << 31 , AllNamedPlatforms = Platform_PC \| Platform_LINUX \| Platform_ANDROID \| Platform_IOS \| Platform_MAC \| Platform_PROVO \| Platform_SALEM \| Platform_JASPER \| Platform_SERVER }

enum class	PlatformID { PLATFORM_WINDOWS_64 , PLATFORM_LINUX_64 , PLATFORM_APPLE_IOS , PLATFORM_APPLE_MAC , PLATFORM_ANDROID_64 , PLATFORM_MAX }

enum class	AttributeIsValid : AZ::u8 { IfPresent }

enum	eBehaviorBusForwarderEventIndices { Result , UserData , ParameterFirst , Count }

enum class	VariantOnThis { No , Yes }

enum class	RttiKind { None , Intrusive , External }

enum class	TypeTraits : AZ::u64 { is_signed = 0b1 , is_unsigned = 0b10 , is_enum = 0b100 , is_pointer = 0b1000 , is_template = 0b10000 }

enum class	AcquisitionOnPush { None , ScriptAcquire }

enum class	ObjectToLua { ByReference , ByValue }

enum	ScriptContextIds : ScriptContextId { DefaultScriptContextId = 0 , CryScriptContextId = 1 }

enum class	ImportTracking : AZ::u8 { None = 0 , Dependencies = (1<<0) , Imports = (1<<1) , All = (Dependencies \| Imports) }

enum class	JsonMergeApproach { JsonPatch , JsonMergePatch }

enum class	JsonSerializerCompareResult { Less , Equal , Greater , Error }

enum class	RegisteredReflectionContext { None = 0 , JsonRegistrationContext = 1 , SerializeContext }

enum class	ObjectStreamWriteOverrideResponse { CompletedWrite , FallbackToDefaultWrite , AbortWrite }

enum class	TaskPriority : uint8_t { CRITICAL = 0 , HIGH = 1 , MEDIUM = 2 , LOW = 3 , PRIORITY_COUNT = 4 }

Functions
	AZ_TYPE_INFO_SPECIALIZE (Data::AssetLoadBehavior, "{DAF9ECED-FEF3-4D7A-A220-8CFD6A5E6DA1}")

	AZ_TYPE_INFO_TEMPLATE_WITH_NAME (AZ::Data::Asset, "Asset", "{C891BF19-B60C-45E2-BFD0-027D15DDC939}", AZ_TYPE_INFO_CLASS)

const Uuid &	GetAssetClassId ()

template<typename T >
T	SizeAlignUp (T s, size_t a)

template<typename T >
T	SizeAlignDown (T s, size_t a)

template<typename T >
T *	PointerAlignUp (T *p, size_t a)

template<typename T >
T *	PointerAlignDown (T *p, size_t a)

constexpr size_t	AlignUpToPowerOfTwo (size_t value)

template<typename T , typename S >
T	AliasCast (S source)

	AZ_DEFINE_ENUM_BITWISE_OPERATORS (ApplicationTypeQuery::Masks)

	AZ_TYPE_INFO_SPECIALIZE (TransformConfig::ParentActivationTransformMode, "{03FD8A24-CE8F-4651-A3CC-09F40D36BC2C}")

const char *	GetEnumString (GetValueResult value)

	AZ_DEFINE_ENUM_BITWISE_OPERATORS (ConsoleFunctorFlags)

template<size_t N>
bool	operator< (const Version< N > &a, const Version< N > &b)

template<size_t N>
bool	operator> (const Version< N > &a, const Version< N > &b)

template<size_t N>
bool	operator<= (const Version< N > &a, const Version< N > &b)

template<size_t N>
bool	operator>= (const Version< N > &a, const Version< N > &b)

template<size_t N>
bool	operator== (const Version< N > &a, const Version< N > &b)

template<size_t N>
bool	operator!= (const Version< N > &a, const Version< N > &b)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_PREFIX_UUID (AZ::Event, "Event", "{B7388760-18BF-486A-BE96-D5765791C53C}", AZ_TYPE_INFO_INTERNAL_TYPENAME_VARARGS)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_PREFIX_UUID (AZ::EventHandler, "EventHandler", "{F85EFDA5-FBD0-4557-A3EF-9E077B41EA59}", AZ_TYPE_INFO_INTERNAL_TYPENAME_VARARGS)

	AZ_TYPE_INFO_SPECIALIZE (AZ::IO::PathView, "{A3F81F4A-F87C-4CD6-8328-7E9C9C83D131}")

	AZ_TYPE_INFO_SPECIALIZE (AZ::IO::Path, "{88E0A40F-3085-4CAB-8B11-EF5A2659C71A}")

	AZ_TYPE_INFO_SPECIALIZE (AZ::IO::FixedMaxPath, "{FA6CA49F-376A-417C-9767-DD50744DF203}")

	AZ_TYPE_INFO_SPECIALIZE (AZ::IO::BlockCacheConfig::BlockSize, "{5D4D597D-4605-462D-A27D-8046115C5381}")

	AZ_TYPE_INFO_SPECIALIZE (AZ::IO::ReadSplitterConfig::SplitSize, "{2D6B3695-3F62-42EB-9DFE-FBABED395C58}")

template<class IndexType , class Function , class Partition >
void	parallel_for (IndexType start, IndexType end, IndexType step, const Function &function, const Partition &partition, JobContext *jobContext=nullptr)

template<class IndexType , class Function >
void	parallel_for (IndexType start, IndexType end, IndexType step, const Function &function, JobContext *jobContext=nullptr)

template<class IndexType , class Function , class Partition >
void	parallel_for (IndexType start, IndexType end, const Function &function, const Partition &partition, JobContext *jobContext=nullptr)

template<class IndexType , class Function >
void	parallel_for (IndexType start, IndexType end, const Function &function, JobContext *jobContext=nullptr)

template<class IndexType , class Function , class Partition >
void	parallel_for_start (IndexType start, IndexType end, IndexType step, const Function &function, Job dependent, const Partition &partition, JobContext jobContext=nullptr, AZStd::stack_allocator *allocator=nullptr)

template<class IndexType , class Function >
void	parallel_for_start (IndexType start, IndexType end, IndexType step, const Function &function, Job dependent, JobContext jobContext=nullptr, AZStd::stack_allocator *allocator=nullptr)

template<class IndexType , class Function , class Partition >
void	parallel_for_start (IndexType start, IndexType end, const Function &function, Job dependent, const Partition &partition, JobContext jobContext=nullptr, AZStd::stack_allocator *allocator=nullptr)

template<class IndexType , class Function >
void	parallel_for_start (IndexType start, IndexType end, const Function &function, Job dependent, JobContext jobContext=nullptr, AZStd::stack_allocator *allocator=nullptr)

template<class Iterator , class Function , class Partition >
void	parallel_for_each (Iterator start, Iterator end, const Function &function, const Partition &partition, JobContext *jobContext=nullptr)

template<class Iterator , class Function >
void	parallel_for_each (Iterator start, Iterator end, const Function &function, JobContext *jobContext=nullptr)

template<class Iterator , class Function , class Partition >
void	parallel_for_each_start (Iterator start, Iterator end, const Function &function, Job dependent, const Partition &partition, JobContext jobContext=nullptr, AZStd::stack_allocator *allocator=nullptr)

template<class Iterator , class Function >
void	parallel_for_each_start (Iterator start, Iterator end, const Function &function, Job dependent, JobContext jobContext=nullptr, AZStd::stack_allocator *allocator=nullptr)

template<typename F1 , typename F2 >
void	parallel_invoke (const F1 &f1, const F2 &f2, JobContext *jobContext=nullptr)

template<typename F1 , typename F2 , typename F3 >
void	parallel_invoke (const F1 &f1, const F2 &f2, const F3 &f3, JobContext *jobContext=nullptr)

template<typename F1 , typename F2 , typename F3 , typename F4 >
void	parallel_invoke (const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4, JobContext *jobContext=nullptr)

template<typename F1 , typename F2 , typename F3 , typename F4 , typename F5 >
void	parallel_invoke (const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4, const F5 &f5, JobContext *jobContext=nullptr)

template<typename F1 , typename F2 , typename F3 , typename F4 , typename F5 , typename F6 >
void	parallel_invoke (const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4, const F5 &f5, const F6 &f6, JobContext *jobContext=nullptr)

template<typename F1 , typename F2 , typename F3 , typename F4 , typename F5 , typename F6 , typename F7 >
void	parallel_invoke (const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4, const F5 &f5, const F6 &f6, const F7 &f7, JobContext *jobContext=nullptr)

template<typename F1 , typename F2 , typename F3 , typename F4 , typename F5 , typename F6 , typename F7 , typename F8 >
void	parallel_invoke (const F1 &f1, const F2 &f2, const F3 &f3, const F4 &f4, const F5 &f5, const F6 &f6, const F7 &f7, const F8 &f8, JobContext *jobContext=nullptr)

template<class Function >
JobFunction< Function > *	CreateJobFunction (const Function &processFunction, bool isAutoDelete, JobContext *context=nullptr)
	Convenience function to create (aznew JobFunction with any function signature). Delete the function with delete (or isAutoDelete set to true)

void	DeleteJobFunction (Job *jobFunction)
	For delete symmetry.

AZ_MATH_INLINE const Color	operator* (float multiplier, const Color &rhs)

constexpr u32	MatrixTimes (u32 *mat, u32 vec)

Frustum::PlaneId	operator++ (Frustum::PlaneId &planeId)

AZ_MATH_INLINE Vector3	Vector2ToVector3 (const Vector2 &v)

AZ_MATH_INLINE Vector3	Vector2ToVector3 (const Vector2 &v, const float z)

AZ_MATH_INLINE Vector4	Vector2ToVector4 (const Vector2 &v)

AZ_MATH_INLINE Vector4	Vector2ToVector4 (const Vector2 &v, const float z)

AZ_MATH_INLINE Vector4	Vector2ToVector4 (const Vector2 &v, const float z, const float w)

AZ_MATH_INLINE Vector2	Vector3ToVector2 (const Vector3 &v)

AZ_MATH_INLINE Vector4	Vector3ToVector4 (const Vector3 &v)

AZ_MATH_INLINE Vector4	Vector3ToVector4 (const Vector3 &v, const float w)

AZ_MATH_INLINE Vector2	Vector4ToVector2 (const Vector4 &v)

AZ_MATH_INLINE Vector3	Vector4ToVector3 (const Vector4 &v)

template<typename Vertex >
static const Vertex &	ScriptIndexRead (VertexContainer< Vertex > *thisPtr, int index)

template<typename Vertex >
static void	ScriptUpdateVertex (VertexContainer< Vertex > *thisPtr, int index, const Vertex &vertex)

template<typename Vertex >
static void	ScriptInsertVertex (VertexContainer< Vertex > *thisPtr, int index, const Vertex &vertex)

template<typename Vertex >
static void	ScriptRemoveVertex (VertexContainer< Vertex > *thisPtr, int index)

	AZ_TYPE_INFO_SPECIALIZE (InterpolationMode, "{3095F41E-C2C6-474A-BB05-68B228097626}")

void	MathReflect (ReflectContext *context)

AZStd::string	Vector3ToString (const Vector3 &v)

AZStd::string	Vector4ToString (const Vector4 &v)

AZStd::string	QuaternionToString (const Quaternion &v)

AZStd::string	TransformToString (const Transform &t)

float	GetTransformEpsilon ()

template<typename t_Argument , typename t_Constructed >
bool	ConstructOnTypedArgument (t_Constructed &constructed, ScriptDataContext &dc, int index)

constexpr bool	IsPowerOfTwo (uint32_t testValue)

constexpr uint32_t	Log2 (uint64_t maxValue)
	Calculates at compile-time the integral log base 2 of the input value.

template<uint64_t MAX_VALUE>
constexpr uint32_t	RequiredBytesForBitfield ()
	Calculates at compile-time the number of bytes required to represent the given set of input bits.

template<uint64_t MAX_VALUE>
constexpr uint32_t	RequiredBytesForValue ()
	Calculates at compile-time the number of bytes required to represent the given max value.

template<uint32_t Alignment>
AZ_MATH_INLINE bool	IsAligned (const void *addr)
	Compile-time check of address alignment.

template<typename LeftType , typename RightType >
constexpr IntegralTypeDiff	IntegralTypeCompare ()
	Compares two integer types and returns their sign and size relationship.

template<typename LeftType , typename RightType >
constexpr IntegralCompare	SafeIntegralCompare (LeftType lhs, RightType rhs)

constexpr float	RadToDeg (float rad)
	Converts radians to degrees.

constexpr float	DegToRad (float deg)
	Converts degrees to radians.

AZ_MATH_INLINE bool	IsClose (float a, float b, float tolerance=Constants::Tolerance)

AZ_MATH_INLINE bool	IsClose (double a, double b, double tolerance=Constants::Tolerance)

AZ_MATH_INLINE float	GetSign (float x)
	Returns x >= 0.0f ? 1.0f : -1.0f.

template<typename T >
constexpr T	GetClamp (T value, T min, T max)
	Returns the clamped value.

template<typename T >
constexpr T	GetMin (T a, T b)

template<typename T >
constexpr T	GetMax (T a, T b)

template<typename T >
constexpr T	Lerp (const T &a, const T &b, float t)
	Returns a linear interpolation between 2 values.

constexpr float	Lerp (float a, float b, float t)
	Returns a linear interpolation between 2 values.

constexpr double	Lerp (double a, double b, double t)

float	LerpInverse (float a, float b, float value)
	Returns a value t where Lerp(a, b, t) == value (or 0 if a == b).

double	LerpInverse (double a, double b, double value)

template<typename T >
constexpr AZStd::enable_if_t< AZStd::is_integral< T >::value, bool >	IsEven (T a)
	Returns true if the number provided is even.

template<typename T >
constexpr AZStd::enable_if_t< AZStd::is_integral< T >::value, bool >	IsOdd (T a)
	Returns true if the number provided is odd.

AZ_MATH_INLINE float	GetAbs (float a)

AZ_MATH_INLINE double	GetAbs (double a)

AZ_MATH_INLINE float	GetMod (float a, float b)

AZ_MATH_INLINE double	GetMod (double a, double b)

AZ_MATH_INLINE int	Wrap (int value, int maxValue)
	Wraps [0, maxValue].

AZ_MATH_INLINE int	Wrap (int value, int minValue, int maxValue)
	Wraps [minValue, maxValue].

AZ_MATH_INLINE float	GetFloatQNaN ()

template<typename T >
AZ_MATH_INLINE bool	IsCloseMag (T x, T y, T epsilonValue=AZStd::numeric_limits< T >::epsilon())
	IsCloseMag(x, y, epsilon) returns true if y and x are sufficiently close, taking magnitude of x and y into account in the epsilon.

template<typename T >
AZ_MATH_INLINE T	ClampIfCloseMag (T x, T y, T epsilonValue=AZStd::numeric_limits< T >::epsilon())
	ClampIfCloseMag(x, y, epsilon) returns y when x and y are within epsilon of each other (taking magnitude into account). Otherwise returns x.

AZ_MATH_INLINE bool	IsNormalDouble (double x)

AZ_MATH_INLINE bool	IsFiniteFloat (float x)

template<typename T >
constexpr T	DivideAndRoundUp (T value, T alignment)

template<typename T >
constexpr T	RoundUpToMultiple (T value, T alignment)

Quaternion	CreateRandomQuaternion (SimpleLcgRandom &rng)

Vector3	operator* (const Vector3 &lhs, const Matrix3x3 &rhs)

Vector3 &	operator*= (Vector3 &lhs, const Matrix3x3 &rhs)

Matrix3x3	operator* (float lhs, const Matrix3x3 &rhs)
	Pre-multiplies the matrix by a scalar.

Matrix3x4	operator* (float lhs, const Matrix3x4 &rhs)
	Pre-multiplies the matrix by a scalar.

AZ_MATH_INLINE void	ConvertTo4x4 (const Simd::Vec4::FloatType in3x4, Simd::Vec4::FloatType out4x4)

const Vector3	operator* (const Vector3 &lhs, const Matrix4x4 &rhs)

Vector3 &	operator*= (Vector3 &lhs, const Matrix4x4 &rhs)

const Vector4	operator* (const Vector4 &lhs, const Matrix4x4 &rhs)

Vector4 &	operator*= (Vector4 &lhs, const Matrix4x4 &rhs)

Matrix4x4	operator* (float lhs, const Matrix4x4 &rhs)
	Pre-multiplies the matrix by a scalar.

void	OuterProduct (const VectorN &lhs, const VectorN &rhs, MatrixMxN &output)

void	VectorMatrixMultiply (const MatrixMxN &matrix, const VectorN &vector, VectorN &output)
	Multiplies the input vector of dimensionality RowCount, with the current matrix and stores the result in the provided output vector of dimensionality ColCount.

void	VectorMatrixMultiplyLeft (const VectorN &vector, const MatrixMxN &matrix, VectorN &output)
	Left-multiplies the input vector of dimensionality ColCount, with the current matrix and stores the result in the provided output vector of dimensionality RowCount.

void	MatrixMatrixMultiply (const MatrixMxN &lhs, const MatrixMxN &rhs, MatrixMxN &output)

Matrix4x4 *	MakePerspectiveFovMatrixRH (Matrix4x4 &out, float fovY, float aspectRatio, float nearDist, float farDist, bool reverseDepth=false)

Matrix4x4 *	MakeFrustumMatrixRH (Matrix4x4 &out, float left, float right, float bottom, float top, float nearDist, float farDist, bool reverseDepth=false)

Matrix4x4 *	MakeOrthographicMatrixRH (Matrix4x4 &out, float left, float right, float bottom, float top, float nearDist, float farDist, bool reverseDepth=false)

Vector3	MatrixTransformPosition (const Matrix4x4 &matrix, const Vector3 &inPosition)
	Transforms a position by a matrix. This function can be used with any generic cases which include projection matrices.

void	SetPerspectiveMatrixFOV (Matrix4x4 &out, float fovY, float aspectRatio)

float	GetPerspectiveMatrixFOV (const Matrix4x4 &m)

void	SetPerspectiveMatrixNearFar (Matrix4x4 &out, float nearDist, float farDist, bool reverseDepth=true)

Obb	operator* (const class Transform &transform, const Obb &obb)

	AZ_TYPE_INFO_TEMPLATE (PackedVector3, "{AE80F5E2-F809-4E2A-AE63-39F171C62819}", AZ_TYPE_INFO_TYPENAME)

void	PolygonPrismReflect (ReflectContext *context)

Vector3	ConvertQuaternionToEulerDegrees (const Quaternion &q)
	Non-member functionality belonging to the AZ namespace.

Vector3	ConvertQuaternionToEulerRadians (const Quaternion &q)

Quaternion	ConvertEulerRadiansToQuaternion (const Vector3 &eulerRadians)

Quaternion	ConvertEulerDegreesToQuaternion (const Vector3 &eulerDegrees)

void	ConvertQuaternionToAxisAngle (const Quaternion &quat, Vector3 &outAxis, float &outAngle)

Quaternion	operator* (float multiplier, const Quaternion &rhs)

bool	IsUnit (const Transform &t)
	Helper method to quickly determine whether or not a given transform includes a scale.

float	GetHaltonNumber (uint32_t index, uint32_t base)

void	SplineReflect (ReflectContext *context)

RaySplineQueryResult	IntersectSpline (const Transform &worldFromLocal, const Vector3 &src, const Vector3 &dir, const Spline &spline)
	Util function to intersect a ray in world space against a spline. Use the provided transform to transform the ray into the local space of the spline.

Vector3	ConvertTransformToEulerDegrees (const Transform &transform)

Vector3	ConvertTransformToEulerRadians (const Transform &transform)

Transform	ConvertEulerDegreesToTransform (const Vector3 &eulerDegrees)

Transform	ConvertEulerRadiansToTransform (const Vector3 &eulerRadians)

constexpr Uuid	operator+ (const Uuid &lhs, const Uuid &rhs)

Vector2	operator* (float multiplier, const Vector2 &rhs)
	Allows pre-multiplying by a float.

AZ::Vector3	Vector3RadToDeg (const AZ::Vector3 &radians)

AZ::Vector3	Vector3DegToRad (const AZ::Vector3 &degrees)

AZ_MATH_INLINE Vector3	operator* (float multiplier, const Vector3 &rhs)

AZ_MATH_INLINE Vector4	operator* (float multiplier, const Vector4 &rhs)

void	VertexContainerReflect (ReflectContext *context)

	AZ_TYPE_INFO_TEMPLATE (VertexContainer, "{39A06CC2-D2C4-4803-A2D1-0E674A61EF4E}", AZ_TYPE_INFO_TYPENAME)

template<typename Vertex >
Vertex	AdaptVertexIn (const AZ::Vector3 &)

template<>
AZ::Vector3	AdaptVertexIn< AZ::Vector3 > (const AZ::Vector3 &vector)

template<>
AZ::Vector2	AdaptVertexIn< AZ::Vector2 > (const AZ::Vector3 &vector)

template<typename Vertex >
AZ::Vector3	AdaptVertexOut (const Vertex &)

template<>
AZ::Vector3	AdaptVertexOut< AZ::Vector3 > (const AZ::Vector3 &vector)

template<>
AZ::Vector3	AdaptVertexOut< AZ::Vector2 > (const AZ::Vector2 &vector)

	AZ_TYPE_INFO_SPECIALIZE (Debug::AllocationRecords::Mode, "{C007B46A-3827-42DC-B56D-0484BC9942A9}")

AZ_FORCE_INLINE bool	operator== (const AllocatorPointerWrapper &a, const AllocatorPointerWrapper &b)

AZ_FORCE_INLINE bool	operator!= (const AllocatorPointerWrapper &a, const AllocatorPointerWrapper &b)

template<typename Allocator >
AZ_FORCE_INLINE bool	operator== (const AllocatorGlobalWrapper< Allocator > &, const AllocatorGlobalWrapper< Allocator > &)

template<typename Allocator >
AZ_FORCE_INLINE bool	operator!= (const AllocatorGlobalWrapper< Allocator > &, const AllocatorGlobalWrapper< Allocator > &)

	AZ_TYPE_INFO_TEMPLATE (AllocatorGlobalWrapper, "{0994AE22-B98C-427B-A8EC-110F50D1ECC1}", AZ_TYPE_INFO_TYPENAME)

	AZ_TYPE_INFO_TEMPLATE (AZStdAlloc, "{42D0AA1E-3C6C-440E-ABF8-435931150470}", AZ_TYPE_INFO_CLASS)

template<class Allocator >
AZ_FORCE_INLINE bool	operator== (const AZStdAlloc< Allocator > &a, const AZStdAlloc< Allocator > &b)

template<class Allocator >
AZ_FORCE_INLINE bool	operator!= (const AZStdAlloc< Allocator > &a, const AZStdAlloc< Allocator > &b)

void *	OperatorNew (std::size_t size)

void	OperatorDelete (void *ptr)

void	OperatorDelete (void *ptr, std::size_t size)

void *	OperatorNewArray (std::size_t size)

void	OperatorDeleteArray (void *ptr)

void	OperatorDeleteArray (void *ptr, std::size_t size)

template<class T , class U >
bool	operator== (EnvironmentVariable< T > const &a, EnvironmentVariable< U > const &b)

template<class T , class U >
bool	operator!= (EnvironmentVariable< T > const &a, EnvironmentVariable< U > const &b)

template<class T , class U >
bool	operator== (EnvironmentVariable< T > const &a, U *b)

template<class T , class U >
bool	operator!= (EnvironmentVariable< T > const &a, U *b)

template<class T , class U >
bool	operator== (T *a, EnvironmentVariable< U > const &b)

template<class T , class U >
bool	operator!= (T *a, EnvironmentVariable< U > const &b)

template<class T >
bool	operator== (EnvironmentVariable< T > const &a, std::nullptr_t)

template<class T >
bool	operator!= (EnvironmentVariable< T > const &a, std::nullptr_t)

template<class T >
bool	operator== (std::nullptr_t, EnvironmentVariable< T > const &a)

template<class T >
bool	operator!= (std::nullptr_t, EnvironmentVariable< T > const &a)

template<class T >
bool	operator< (EnvironmentVariable< T > const &a, EnvironmentVariable< T > const &b)

bool	ShouldUseSystemComponent (const ComponentDescriptor &descriptor, const AZStd::vector< Crc32 > &requiredTags, const SerializeContext &serialize)

constexpr AZStd::in_place_t	Success ()

template<class ValueT , class >
constexpr ValueT	Success (ValueT &&rhs)

constexpr AZStd::unexpected< AZStd::unexpect_t >	Failure ()

template<class ValueT , class >
constexpr AZStd::unexpected< ValueT >	Failure (ValueT &&rhs)

	AZ_TYPE_INFO_SPECIALIZE (AZStd::unexpect_t, "{D293EBFF-F38A-420D-AB93-837FF08ED9BE}")

	AZ_TYPE_INFO_TEMPLATE (Outcome, "{C1DB96E5-922A-4387-B658-B4BE7FB94EA0}", AZ_TYPE_INFO_CLASS, AZ_TYPE_INFO_CLASS)

	AZ_ENUM_WITH_UNDERLYING_TYPE (PlatformId, int,(Invalid, -1), PC, LINUX_ID, ANDROID_ID, IOS, MAC_ID, PROVO, SALEM, JASPER, SERVER, ALL, ALL_CLIENT, NumPlatformIds)
	This platform enum have platform values in sequence and can also be used to get the platform count.

	AZ_DEFINE_ENUM_BITWISE_OPERATORS (PlatformFlags)

const char *	PlatformIdToPalFolder (PlatformId platform)

const char *	OSPlatformToDefaultAssetPlatform (AZStd::string_view osPlatform)

bool	IsBigEndian (PlatformID)

const char *	GetPlatformName (PlatformID platform)

bool	QueryMemInfo (ProcessMemInfo &meminfo)

	AZ_TYPE_INFO_TEMPLATE (Iterator_VM, "{55E371F4-4051-4E20-B205-8F11DBCE0907}", AZ_TYPE_INFO_CLASS)

template<typename... T>
BehaviorObject	CreateConnectedAZEventHandler (void *voidPtr, BehaviorFunction &&function)

template<typename... T>
AZStd::vector< AZ::TypeId >	ToTypeIds ()

bool	MethodReturnsAzEventByReferenceOrPointer (const AZ::BehaviorMethod &method)
	Checks if the supplied BehaviorMethod returns AZ::Event by either pointer or reference.

bool	ValidateAzEventDescription (const AZ::BehaviorContext &context, const AZ::BehaviorMethod &method)

	AZ_TYPE_INFO_SPECIALIZE (Script::Attributes::OperatorType, "{26B98C03-7E07-4E3E-9E31-03DA2168E896}")

	AZ_TYPE_INFO_SPECIALIZE (Script::Attributes::StorageType, "{57FED71F-B590-4002-9599-A48CB50B0F8E}")

AZ::BehaviorContext *	GetDefaultBehaviorContext ()

ExplicitOverloadInfo	GetExplicitOverloads (const AZStd::string &name)

ExplicitOverloadInfo	GetExplicitOverloads (const BehaviorMethod &method)

AZStd::string	GetOverloadName (const BehaviorMethod &, size_t overloadIndex, AZStd::string nameOverride={})

AZStd::string	GetOverloadName (const BehaviorMethod &, size_t overloadIndex, const OverloadVariance &variance, AZStd::string nameOverride={})

AZStd::vector< AZStd::string >	GetOverloadNames (const BehaviorMethod &method, AZStd::string nameOverride={})

OverloadVariance	GetOverloadVariance (const BehaviorMethod &method, const AZStd::vector< AZStd::pair< const BehaviorMethod , const BehaviorClass > > &overloads, VariantOnThis onThis)

AZStd::vector< AZStd::pair< const BehaviorMethod , const BehaviorClass > >	OverloadsToVector (const BehaviorMethod &, const BehaviorClass *)

void	RemovePropertyGetterNameArtifacts (AZStd::string &name)

void	RemovePropertySetterNameArtifacts (AZStd::string &name)

void	RemovePropertyNameArtifacts (AZStd::string &name)

AZStd::string	ReplaceCppArtifacts (AZStd::string_view sourceName)

void	StripQualifiers (AZStd::string &name)

bool	TypeCompare (const BehaviorParameter &a, const BehaviorParameter &b)
	returns true iff a and b have the same type and traits

	AZ_TYPE_INFO_SPECIALIZE (AZStd::chrono::nanoseconds, "{5CEA0194-A74C-448A-AC10-3F7A6A8EEFB4}")

	AZ_TYPE_INFO_SPECIALIZE (AZStd::chrono::microseconds, "{1BF1728B-E0EB-4AA1-9937-7D1D7869E398}")

	AZ_TYPE_INFO_SPECIALIZE (AZStd::chrono::milliseconds, "{414B61DC-8042-44DC-82A5-C70DFE04CB65}")

	AZ_TYPE_INFO_SPECIALIZE (AZStd::chrono::seconds, "{63D98FB5-0802-4850-96F6-71046DF38C94}")

	AZ_HAS_MEMBER (NoOnDemandReflection, NoSpecializationFunction, void,())

template<typename ContainerType >
Attribute *	FindAttribute (AttributeId id, const ContainerType &attrArray)

template<typename Arg >
bool	CanInvokeFromDomArrayEntry (const AZ::Dom::Value &domArray, size_t index)

template<typename... T>
bool	CanInvokeFromDomArray (const AZ::Dom::Value &domArray)

template<typename R , typename... Args>
Dom::Value	InvokeFromDomArray (const AZStd::function< R(Args...)> &invokeFunction, const AZ::Dom::Value &domArray)

template<typename Invocable >
	AttributeInvocable (Invocable &&) -> AttributeInvocable< AZStd::conditional_t< AZStd::function_traits< Invocable >::value, typename AZStd::function_traits< Invocable >::function_type, AZStd::remove_cvref_t< Invocable > > >

template<typename T >
IRttiHelper *	GetRttiHelper ()

template<class T >
void	RttiEnumHierarchy (RTTI_EnumCallback cb, void *userData)
	Enumerate class hierarchy (static) based on input type. Safe to call for type not supporting AZRtti returns the AzTypeInfo<T>::Uuid only.

template<class T , class U >
T	RttiCast (U ptr)
	Performs a RttiCast when possible otherwise return NULL. Safe to call for type not supporting AZRtti (returns NULL unless type fully match).

template<class T >
T	RttiCast (AZStd::nullptr_t)
	Specialization for nullptr_t, it's convertible to anything.

template<class T , class U >
AZStd::shared_ptr< typename AZStd::remove_pointer< T >::type >	RttiCast (const AZStd::shared_ptr< U > &ptr)
	RttiCast specialization for shared_ptr.

template<class T , class U >
AZStd::intrusive_ptr< typename AZStd::remove_pointer< T >::type >	RttiCast (const AZStd::intrusive_ptr< U > &ptr)

template<class T >
AZ::Internal::AddressTypeHelper< T >::type	RttiAddressOf (T ptr, const AZ::TypeId &id)

template<class U >
AZ::TypeId	RttiTypeId ()

template<class U >
AZ::TypeId	RttiTypeId (const U &data)

template<class T , class U >
bool	RttiIsTypeOf (const U &data)

template<class U >
bool	RttiIsTypeOf (const AZ::TypeId &id, U data)

	AZ_HAS_MEMBER_QUAL (AZRttiIntrusive, RTTI_GetType, AZ::TypeId,(), const)

template<class T >
constexpr auto	GetO3deTypeName (AZ::Adl, AZStd::type_identity< T >) -> AZStd::enable_if_t< AZStd::is_enum_v< T >, TypeNameString >

template<class T >
constexpr auto	GetO3deTypeId (AZ::Adl, AZStd::type_identity< T >) -> AZStd::enable_if_t< AZStd::is_enum_v< T >, AZ::TypeId >

template<class R , class... Args>
AZ::TypeNameString	GetO3deTypeName (AZ::Adl, AZStd::type_identity< R(Args...)>)

template<class R , class... Args>
AZ::TypeId	GetO3deTypeId (AZ::Adl, AZStd::type_identity< R(Args...)>)

template<class R , class C , class... Args>
AZ::TypeNameString	GetO3deTypeName (AZ::Adl, AZStd::type_identity< R(C::*)(Args...)>)

template<class R , class C , class... Args>
AZ::TypeId	GetO3deTypeId (AZ::Adl, AZStd::type_identity< R(C::*)(Args...)>)

template<class R , class C , class... Args>
AZ::TypeNameString	GetO3deTypeName (AZ::Adl, AZStd::type_identity< R(C::*)(Args...) const >)

template<class R , class C , class... Args>
AZ::TypeId	GetO3deTypeId (AZ::Adl, AZStd::type_identity< R(C::*)(Args...) const >)

template<class R , class C >
AZ::TypeNameString	GetO3deTypeName (AZ::Adl, AZStd::type_identity< R C::* >)

template<class R , class C >
AZ::TypeId	GetO3deTypeId (AZ::Adl, AZStd::type_identity< R C::* >)

template<class T >
AZ::TypeNameString	GetO3deTypeName (AZ::Adl, AZStd::type_identity< std::reference_wrapper< T > >)

template<class T >
AZ::TypeId	GetO3deTypeId (AZ::Adl, AZStd::type_identity< std::reference_wrapper< T > >)

	AZ_TYPE_INFO_SPECIALIZE_WITH_NAME_DECL (AZ::Uuid)
	Add GetO3deTypeName and GetO3deTypeId declarations for commonly used O3DE types.

	AZ_TYPE_INFO_SPECIALIZE_WITH_NAME_DECL (PlatformID)

template<class T , class Functor >
static constexpr void	VisitDeprecatedNameOrCurrentName (Functor &&visitCallback)

template<class T >
static constexpr void	AggregateTypeNameOld (char *buffer, size_t bufferSize)

	AZ_DEFINE_ENUM_BITWISE_OPERATORS (AZ::TypeTraits)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZE_WITH_NAME_DECL (char)
	Add GetO3deTypeName and GetO3deTypeId overloads for built-in types.

	AZ_TYPE_INFO_INTERNAL_SPECIALIZE_WITH_NAME_DECL (AZ::s8)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZE_WITH_NAME_DECL (short)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZE_WITH_NAME_DECL (int)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZE_WITH_NAME_DECL (long)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZE_WITH_NAME_DECL (AZ::s64)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZE_WITH_NAME_DECL (unsigned char)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZE_WITH_NAME_DECL (unsigned short)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZE_WITH_NAME_DECL (unsigned int)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZE_WITH_NAME_DECL (unsigned long)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZE_WITH_NAME_DECL (AZ::u64)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZE_WITH_NAME_DECL (float)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZE_WITH_NAME_DECL (double)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZE_WITH_NAME_DECL (bool)

	AZ_TYPE_INFO_INTERNAL_SPECIALIZE_WITH_NAME_DECL (void)

void	GetO3deTypeName (...)=delete
	TypeName.

void	GetO3deTypeId (...)=delete
	Type Uuid.

void	GetO3deClassTemplateId (...)
	Template Uuid.

template<class T , class U >
constexpr bool	operator== (AzTypeInfo< T > const &lhs, AzTypeInfo< U > const &rhs)

template<class T , class U >
constexpr bool	operator!= (AzTypeInfo< T > const &lhs, AzTypeInfo< U > const &rhs)

LuaLoadFromStack	FromLuaStack (AZ::BehaviorContext context, const AZ::BehaviorParameter param, AZ::BehaviorClass *&behaviorClass)

LuaPushToStack	ToLuaStack (AZ::BehaviorContext context, const AZ::BehaviorParameter param, LuaPrepareValue prepareParamOut, AZ::BehaviorClass &behaviorClass)

void	StackPush (lua_State lua, AZ::BehaviorContext context, AZ::BehaviorArgument &param)

void	StackPush (lua_State *lua, AZ::BehaviorArgument &param)

bool	StackRead (lua_State lua, int index, AZ::BehaviorContext context, AZ::BehaviorArgument &param, AZ::StackVariableAllocator *)

bool	StackRead (lua_State lua, int index, AZ::BehaviorArgument &param, AZ::StackVariableAllocator =nullptr)

	AZ_TYPE_INFO_SPECIALIZE (AZStd::chrono::steady_clock::time_point, "{5C48FD59-7267-405D-9C06-1EA31379FE82}")

	AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZ::Internal::RValueToLValueWrapper, "RValueToLValueWrapper", "{2590807F-5748-4CD0-A475-83EF5FD216CF}", AZ_TYPE_INFO_TYPENAME)

static AZ_INLINE constexpr AZ::TypeId	GetGenericClassInfoVectorTypeId ()

static AZ_INLINE constexpr AZ::TypeId	GetGenericClassInfoFixedVectorTypeId ()

static AZ_INLINE constexpr AZ::TypeId	GetGenericClassInfoArrayTypeId ()

static AZ_INLINE constexpr AZ::TypeId	GetGenericClassSetTypeId ()

static AZ_INLINE constexpr AZ::TypeId	GetGenericClassUnorderedSetTypeId ()

static AZ_INLINE constexpr AZ::TypeId	GetGenericOutcomeTypeId ()

AZ_INLINE constexpr AZ::TypeId	GetGenericClassPairTypeId ()

AZ_INLINE constexpr AZ::TypeId	GetGenericClassTupleTypeId ()

AZ_INLINE constexpr AZ::TypeId	GetGenericClassMapTypeId ()

static AZ_INLINE constexpr AZ::TypeId	GetGenericClassUnorderedMapTypeId ()

template<typename ToType , typename FromType >
JsonSerializationResult::ResultCode	JsonNumericCast (ToType &result, FromType value, AZStd::string_view path, const AZ::JsonSerializationResult::JsonIssueCallback &reporting)

	AZ_DEFINE_ENUM_BITWISE_OPERATORS (ImportTracking)

	AZ_TYPE_INFO_SPECIALIZE (ObjectStreamWriteOverrideCB, "{87B1A36B-8C8A-42B6-A0B5-E770D9FDBAD4}")

	AZ_TYPE_INFO_SPECIALIZE_WITH_NAME_DECL (ObjectStreamWriteOverrideResponse)

template<typename T , typename ContainerType = AttributeContainerType<T>>
AttributePtr	CreateModuleAttribute (T &&attrValue)

SerializeContext::PerModuleGenericClassInfo &	GetCurrentSerializeContextModule ()

	AZ_TYPE_INFO_TEMPLATE_WITH_NAME_DECL (SerializeContext::DataPatchTypeUpgrade, AZ_TYPE_INFO_CLASS, AZ_TYPE_INFO_CLASS)

	AZ_TYPE_INFO_TEMPLATE (ConfigurableStack, "{0A3D2038-6E6A-4EFD-A1B4-F30D947E21B1}", AZ_TYPE_INFO_TYPENAME)

template<bool handleEvent>
bool	DummyStateHandler (HSM &, const HSM::Event &)

	AZ_TYPE_SAFE_INTEGRAL (TimeMs, int64_t)
	This is a strong typedef for representing a millisecond value since application start.

	AZ_TYPE_SAFE_INTEGRAL (TimeUs, int64_t)

TimeMs	GetElapsedTimeMs ()
	This is a simple convenience wrapper.

TimeUs	GetElapsedTimeUs ()
	This is a simple convenience wrapper.

TimeMs	GetRealElapsedTimeMs ()
	This is a simple convenience wrapper.

TimeUs	GetRealElapsedTimeUs ()
	This is a simple convenience wrapper.

TimeUs	GetSimulationTickDeltaTimeUs ()
	This is a simple convenience wrapper.

TimeUs	GetRealTickDeltaTimeUs ()
	This is a simple convenience wrapper.

TimeUs	GetLastSimulationTickTime ()
	This is a simple convenience wrapper.

TimeUs	TimeMsToUs (TimeMs value)
	Converts from milliseconds to microseconds.

TimeMs	TimeUsToMs (TimeUs value)
	Converts from microseconds to milliseconds.

float	TimeMsToSeconds (TimeMs value)
	Converts from milliseconds to seconds.

double	TimeMsToSecondsDouble (TimeMs value)
	Converts from milliseconds to seconds.

float	TimeUsToSeconds (TimeUs value)
	Converts from microseconds to seconds.

double	TimeUsToSecondsDouble (TimeUs value)
	Converts from microseconds to seconds.

auto	TimeMsToChrono (TimeMs value)
	Converts from milliseconds to AZStd::chrono::time_point.

auto	TimeUsToChrono (TimeUs value)
	Converts from microseconds to AZStd::chrono::time_point.

TimeMs	SecondsToTimeMs (const double value)
	A utility function to convert from seconds to TimeMs.

TimeUs	SecondsToTimeUs (const double value)
	A utility function to convert from seconds to TimeUs.

	AZ_TYPE_SAFE_INTEGRAL (HashValue32, u32)

	AZ_TYPE_SAFE_INTEGRAL (HashValue64, u64)

HashValue32	TypeHash32 (const uint8_t *buffer, uint64_t length)

HashValue64	TypeHash64 (const uint8_t *buffer, uint64_t length)

HashValue64	TypeHash64 (const uint8_t *buffer, uint64_t length, HashValue64 seed)

HashValue64	TypeHash64 (const uint8_t *buffer, uint64_t length, HashValue64 seed1, HashValue64 seed2)

template<typename T >
HashValue32	TypeHash32 (const T &t)

template<typename T >
HashValue64	TypeHash64 (const T &t)

template<typename T >
HashValue64	TypeHash64 (const T &t, HashValue64 seed)

template<typename T >
HashValue64	TypeHash64 (const T &t, HashValue64 seed1, HashValue64 seed2)

HashValue32	TypeHash32 (const char *value)

HashValue64	TypeHash64 (const char *value)

HashValue64	TypeHash64 (const char *value, HashValue64 seed)

HashValue64	TypeHash64 (const char *value, HashValue64 seed1, HashValue64 seed2)


float	Abs (float value)

float	Mod (float value, float divisor)

float	Wrap (float value, float maxValue)

float	Wrap (float value, float minValue, float maxValue)

float	AngleMod (float value)

void	SinCos (float angle, float &sin, float &cos)

float	Sin (float angle)

float	Cos (float angle)

float	Acos (float value)

float	Atan (float value)

float	Atan2 (float y, float x)

float	Sqrt (float value)

float	InvSqrt (float value)


VectorN	operator+ (float lhs, const VectorN &rhs)

VectorN	operator- (float lhs, const VectorN &rhs)

VectorN	operator* (float lhs, const VectorN &rhs)

Variables
static const ComponentId	InvalidComponentId = 0

static constexpr TypeId	TransformComponentTypeId { AZStd::string_view("{22B10178-39B6-4C12-BB37-77DB45FDD3B6}") }
	The typeId of game component AzFramework::TransformComponent.

static constexpr TypeId	EditorTransformComponentTypeId { AZStd::string_view("{27F1E1A1-8D9D-4C3B-BD3A-AFB9762449C0}") }
	The typeId of editor component AzToolsFramework::Components::TransformComponent.

constexpr size_t	MaxConsoleCommandPlusArgsLength = 64

constexpr size_t	MaxCVarStringLength = 256

const Transform	g_transformIdentity

template<class T >
constexpr bool	HasAZClassAllocator_v = AZ::HasAZClassAllocator<T>::value

const char	InitializeDynamicModuleFunctionName [] = "InitializeDynamicModule"

const char	UninitializeDynamicModuleFunctionName [] = "UninitializeDynamicModule"

const char	CreateModuleClassFunctionName [] = "CreateModuleClass"

const char	DestroyModuleClassFunctionName [] = "DestroyModuleClass"

constexpr char	PlatformPC [] = "pc"

constexpr char	PlatformLinux [] = "linux"

constexpr char	PlatformAndroid [] = "android"

constexpr char	PlatformIOS [] = "ios"

constexpr char	PlatformMac [] = "mac"

constexpr char	PlatformProvo [] = "provo"

constexpr char	PlatformSalem [] = "salem"

constexpr char	PlatformJasper [] = "jasper"

constexpr char	PlatformServer [] = "server"

constexpr char	PlatformCodeNameWindows [] = "Windows"

constexpr char	PlatformCodeNameLinux [] = "Linux"

constexpr char	PlatformCodeNameAndroid [] = "Android"

constexpr char	PlatformCodeNameiOS [] = "iOS"

constexpr char	PlatformCodeNameMac [] = "Mac"

constexpr char	PlatformCodeNameProvo [] = "Provo"

constexpr char	PlatformCodeNameSalem [] = "Salem"

constexpr char	PlatformCodeNameJasper [] = "Jasper"

constexpr char	PlatformAll [] = "all"

constexpr char	PlatformAllClient [] = "all_client"

constexpr size_t	MaxPlatformCodeNames = 16

constexpr int	NumClientPlatforms = 8

constexpr int	NumPlatforms = NumClientPlatforms + 1

template<class T >
constexpr bool	HasAzEnumTraits_v = HasAzEnumTraits<T>::value

static const AZ::Crc32	RuntimeEBusAttribute = AZ_CRC("RuntimeEBus", 0x466b899b)
	Signals that this reflected ebus should only be available at runtime, helps tools filter out data driven ebuses.

constexpr const char *	k_PropertyNameGetterSuffix = "::Getter"

constexpr const char *	k_PropertyNameSetterSuffix = "::Setter"

constexpr BehaviorArgumentValueTypeTag_t	BehaviorArgumentValueTypeTag

template<class T >
constexpr bool	HasAZRttiExternal_v = false

template<class T >
constexpr bool	HasAZRtti_v = HasAZRtti<T>::value

template<class T , class = void>
constexpr bool	HasDeprecatedTypeNameVisitor_v = false

template<class T >
constexpr AzDeprecatedTypeNameVisitor< T >	DeprecatedTypeNameVisitor {}

template<class T , class = void>
constexpr bool	HasUnqualifiedGetO3deTypeName_v = false

template<class T >
constexpr bool	HasGetO3deTypeName_v = HasUnqualifiedGetO3deTypeName_v<T>

template<class T , class = void>
constexpr bool	HasUnqualifiedGetO3deTypeId_v = false

template<class T >
constexpr bool	HasGetO3deTypeId_v = HasUnqualifiedGetO3deTypeId_v<T>

template<class T , class = void>
constexpr bool	HasUnqualifiedGetO3deClassTemplateId_v = false

template<class T >
constexpr bool	HasGetO3deClassTemplateId_v = HasUnqualifiedGetO3deClassTemplateId_v<T>

constexpr const char *	k_scriptLoadBinary = "b"

constexpr const char *	k_scriptLoadBinaryOrText = "bt"

constexpr const char *	k_scriptLoadRawText = "t"

constexpr const char *	k_accessElementNameUnchecked = "AtUnchecked"

constexpr const char *	k_accessElementName = "At"

constexpr const char *	k_sizeName = "Size"

constexpr const char *	k_iteratorConstructorName = "Iterate_VM"

constexpr const char *	k_iteratorGetKeyName = "GetKeyUnchecked"

constexpr const char *	k_iteratorIsNotAtEndName = "IsNotAtEnd"

constexpr const char *	k_iteratorModValueName = "ModValueUnchecked"

constexpr const char *	k_iteratorNextName = "Next"

template<class T >
constexpr bool	IsVectorOfEnumConstants_v = false

template<class T >
constexpr bool	IsInvocableThatReturnsVectorOfEnumConstants_v = IsVectorOfEnumConstants_v<InvocableReturnType<T>>

template<class T >
constexpr bool	IsVectorOfPairTypeToString_v = false

template<class T >
constexpr bool	IsInvocableThatReturnsVectorOfPairs_v = IsVectorOfPairTypeToString_v<InvocableReturnType<T>>

constexpr char	JsonPointerEscape = '~'

constexpr AZStd::string_view	JsonPointerEncodedEscape = "~0"

constexpr char	JsonPointerReferenceTokenPrefix = '/'

constexpr AZStd::string_view	JsonPointerEncodedReferenceTokenPrefix = "~1"

constexpr char const *	c_serializeBaseClassStrings [] = { "BaseClass1", "BaseClass2", "BaseClass3" }

constexpr size_t	c_serializeMaxNumBaseClasses = 3

static const PlatformID	g_currentPlatform = PlatformID::PLATFORM_ANDROID_64

static const PlatformID	g_currentPlatform = PlatformID::PLATFORM_APPLE_IOS

static const PlatformID	g_currentPlatform = PlatformID::PLATFORM_LINUX_64

static const PlatformID	g_currentPlatform = PlatformID::PLATFORM_APPLE_MAC


static constexpr float	MinTransformScale = 1e-2f

static constexpr float	MaxTransformScale = 1e9f

Detailed Description

Reopen namespace to define DataPatch class.

Namespace for string functions.

include AZStd containers generics

Data types with specific length. They should be used ONLY when we serialize data if they have native type equivalent, which should take precedence.

A utility file to convert AZ Vectors between each other

Having a separate utility system like this means that Vector classes do not need to rely on each other.

By default AZCore doesn't overload operator new and delete. This is a no-no for middle-ware. You are encouraged to do that in your executable. What you need to do is to pipe all allocation trough AZCore memory manager. AZCore relies on AZ_CLASS_ALLOCATOR to specify the class default allocator or on explicit azcreate/azdestroy calls which provide the allocator. If you class doesn't not implement the AZ_CLASS_ALLOCATOR when you call a new/delete they will use the global operator new/delete. In addition if you call aznew on a class without AZ_CLASS_ALLOCATOR you will need to implement new operator specific to aznew call signature. So in an exception free environment (AZLibs don't have exception support) you need to implement the following functions:

void* operator new(std::size_t); void* operator new[](std::size_t); void operator delete(void*); void operator delete[](void*);

You can implement those functions anyway you like, or you can use the provided implementations for you! Global New/Delete Operators All allocations will happen using the AZ::SystemAllocator. Make sure you create it properly before any new calls. If you use our default new implementation you should map the global functions like that:

void* operator new(std::size_t size) { return AZ::OperatorNew(size); } void* operator new[](std::size_t size) { return AZ::OperatorNewArray(size); } void operator delete(void* ptr) { AZ::OperatorDelete(ptr); } void operator delete[](void* ptr) { AZ::OperatorDeleteArray(ptr); }

Stores information about memory usage of process, All size values are in bytes.

ObjectStream provides load/save functionality of structured object data. It works in conjunction with SerializeContext. After serializable classes have been reflected in a SerializeContext, objects of such types can be serialized in and out through the ObjectStream interface.

Operation: To serialize objects, a GenericStream and SerializeContext are provided to the ObjectStream along with an operation callback and a completion callback. When loading, each root object created by ObjectStream is passed to the ClassReadyCB supplied to transfer ownership of the object to the user. When saving, classWriterCB is called from the saving thread. The user then calls ObjectStream::WriteClass() for each root object that needs to be written before returning from the callback. CompletionCB is called to indicate that the object stream operation is complete.

The StringFunc namespace is where we put string functions that extend some std::string functionality to regular c-strings, make easier implementations of common but complex AZStd::strings routines, implement features that are not in std (or not yet in std), and a host of functions to more easily manipulate file paths. Some simply do additional error checking on top of the std, or make it more readable.

This file is to be included from UnixLike SystemFile implementations only. It should NOT be included by the user.

Typedef Documentation

◆ BetterPseudoRandom

using AZ::BetterPseudoRandom = typedef BetterPseudoRandom_Platform

As an attempt to improve the pseudo-random (rand, time) we use a better random. The cost of computing one if making it to great for high performance application, but it's a great tool to get a good seed.

◆ ConsoleCommandInvokedEvent

using AZ::ConsoleCommandInvokedEvent = typedef AZ::Event<AZStd::basic_string_view<char, AZStd::char_traits<char> >, const ConsoleCommandContainer&, ConsoleFunctorFlags, ConsoleInvokedFrom>

Called on invocation of any console command.

Parameters

command	the full command being executed on the console
commandArgs	the array of arguments that was supplied to PeformCommand
flags	the set of flags associated with the command being executed
invokedFrom	the source point that initiated console invocation

◆ CreateModuleClassFunction

using AZ::CreateModuleClassFunction = typedef AZ::Module * (*)()

extern "C" AZ_DLL_EXPORT

AZ::Module* CreateModuleClass()

AZ::Module

Definition: Module.h:33

Function by which a dynamic module creates its AZ::Module class. This will be called after InitializeDynamicModule().

◆ CreateStaticModulesCallback

using AZ::CreateStaticModulesCallback = typedef AZStd::function<void(AZStd::vector<AZ::Module*>&)>

Function signature for static module registrars.

◆ DestroyModuleClassFunction

using AZ::DestroyModuleClassFunction = typedef void(*)(AZ::Module* module)

extern "C" AZ_DLL_EXPORT

void DestroyModuleClass(AZ::Module* module)

Function by which a dynamic module destroys its AZ::Module class. This will be callled before UninitializeDynamicModule().

◆ DispatchCommandNotFoundEvent

using AZ::DispatchCommandNotFoundEvent = typedef AZ::Event<AZStd::basic_string_view<char, AZStd::char_traits<char> >, const ConsoleCommandContainer&, ConsoleInvokedFrom>

Called when a command to dispatch has not been found within the AZ Console.

Parameters

command	the full command that was not found
commandArgs	the array of arguments that was supplied to PeformCommand
invokedFrom	the source point that initiated console invocation

◆ DynamicPrefabAsset

using AZ::DynamicPrefabAsset = typedef DynamicSliceAsset

Deprecated:: Use DynamicSliceAsset.

◆ EntityBus

typedef AZ::EBus<EntityEvents> AZ::EntityBus

The EBus for notification events dispatched by a specific entity. The events are defined in the AZ::EntityEvents class.

◆ EntitySystemBus

typedef AZ::EBus<EntitySystemEvents> AZ::EntitySystemBus

The EBus for systemwide entity notification events. The events are defined in the AZ::EntitySystemEvents class.

◆ InitializeDynamicModuleFunction

using AZ::InitializeDynamicModuleFunction = typedef void(*)()

Functions that the AZ::ComponentApplication expects to find in a dynamic module.

extern "C" AZ_DLL_EXPORT

void InitializeDynamicModule(void* sharedEnvironment)

The very first function invoked in a dynamic module. Implementations should attach to the environment.

Parameters

sharedEnvironment is an AZ::EnvironmentInstance.

◆ ModuleDescriptorList

using AZ::ModuleDescriptorList = typedef AZStd::vector<DynamicModuleDescriptor, OSStdAllocator>

Type for storing module references.

◆ ObjectStreamWriteOverrideCB

using AZ::ObjectStreamWriteOverrideCB = typedef AZStd::function<ObjectStreamWriteOverrideResponse(SerializeContext::EnumerateInstanceCallContext& callContext, const void* classPtr, const SerializeContext::ClassData& classData, const SerializeContext::ClassElement* classElement)>

< Callback that the object stream invokes to override saving an instance of the registered class

Parameters

callContext	EnumerateInstanceCallContext which contains the WriteElement BeingElemCB and the CloseElement EndElemCB the callContext parameter can be passed to the SerializeContext::EnumerateInstance to continue object stream writing
classPtr	class type which is of pointer to the type represented by the m_typeId value
classData	reference to this instance Class Data that will be supplied to the callback
classElement	class element pointer which contains information about the element being serialized. root elements have a nullptr classElement

Returns: enum to indicate that the override has saved the registered class and that the default writing should be skipped. Returning false will have the WriteElement code fallback to using the default logic

◆ PrefabAsset

using AZ::PrefabAsset = typedef SliceAsset

Deprecated:: Use SliceAsset.

◆ PrefabBus

using AZ::PrefabBus = typedef SliceBus

Deprecated:: Use SliceBus.

◆ PrefabComponent

typedef SliceComponent AZ::PrefabComponent

Deprecated:: Use SliceComponent.

Deprecated:: Use SliceComponent.

Deprecated:: Use SliceComponent.

◆ PrefabEvents

using AZ::PrefabEvents = typedef SliceEvents

Deprecated:: Use SliceEvents.

◆ ReporterString

using AZ::ReporterString = typedef AZStd::fixed_string<1024>

Type alias for a non-dynamic allocating string type that can be used to format messages to send to the JsonIssueCallback. NOTE: Any string type that is convertible to AZStd::string_view can be used. This alias is provided for convenience.

◆ SliceEntityHierarchyRequestBus

using AZ::SliceEntityHierarchyRequestBus = typedef AZ::EBus<SliceEntityHierarchyInterface>

The EBus for requests for the parent and children of an entity for the purposes of slice dependency hierarchies. The events are defined in the AZ:: class.

◆ StaticReflectionFunctionPtr

using AZ::StaticReflectionFunctionPtr = typedef void(*)(ReflectContext* context)

Function type to called for on demand reflection within methods, properties, etc. OnDemandReflection functions must be static, so we can optimize by just using function pointer instead of object

◆ SystemTickBus

using AZ::SystemTickBus = typedef AZ::EBus<SystemTickEvents>

The EBus for system tick notification events. The events are defined in the AZ::SystemTickEvents class.

◆ TickBus

typedef AZ::EBus<TickEvents> AZ::TickBus

The EBus for tick notification events. The events are defined in the AZ::TickEvents class.

◆ TickRequestBus

typedef AZ::EBus<TickRequests> AZ::TickRequestBus

The EBus for tick-related requests. The events are defined in the AZ::TickRequests class.

◆ TransformBus

using AZ::TransformBus = typedef AZ::EBus<TransformInterface>

The EBus for requests to position and parent an entity. The events are defined in the AZ::TransformInterface class.

◆ TransformNotificationBus

using AZ::TransformNotificationBus = typedef AZ::EBus<TransformNotification>

The EBus for transform notification events. The events are defined in the AZ::TransformNotification class.

◆ TypeId

typedef AZ::Uuid AZ::TypeId

Used to reference unique types by their unique id.

◆ UninitializeDynamicModuleFunction

using AZ::UninitializeDynamicModuleFunction = typedef void(*)()

extern "C" AZ_DLL_EXPORT

void UninitializeDynamicModule()

The very last function invoked in a dynamic module. Implementations should detach from the AZ::Environment.

Enumeration Type Documentation

◆ ComponentTickBus

enum AZ::ComponentTickBus

Values to help you set when a particular handler is notified of ticks.

Enumerator
TICK_FIRST	First position in the tick handler order.
TICK_PLACEMENT	Suggested tick handler position for components that need to be early in the tick order.
TICK_INPUT	Suggested tick handler position for input components.
TICK_GAME	Suggested tick handler for game-related components.
TICK_ANIMATION	Suggested tick handler position for animation components.
TICK_PHYSICS_SYSTEM	Suggested tick handler position for physics systems. Note: This should only be used for the Physics System.
TICK_PHYSICS	Suggested tick handler position for physics components.
TICK_ATTACHMENT	Suggested tick handler position for attachment components.
TICK_PRE_RENDER	Suggested tick handler position to update render-related data.
TICK_DEFAULT	Default tick handler position when the handler is constructed.
TICK_UI	Suggested tick handler position for UI components.
TICK_LAST	Last position in the tick handler order.

◆ EBusAddressPolicy

enum class AZ::EBusAddressPolicy

strong

Defines how many addresses exist on the EBus.

Enumerator
Single	(Default) The EBus has a single address.
ById	The EBus has multiple addresses; the order in which addresses receive events is undefined. Events that are addressed to an ID are received by handlers that are connected to that ID. Events that are broadcast without an ID are received by handlers at all addresses.
ByIdAndOrdered	The EBus has multiple addresses; the order in which addresses receive events is defined. Events that are addressed to an ID are received by handlers that are connected to that ID. Events that are broadcast without an ID are received by handlers at all addresses. The order in which addresses receive events is defined by AZ::EBusTraits::BusIdOrderCompare.

◆ EBusHandlerPolicy

enum class AZ::EBusHandlerPolicy

strong

Defines how many handlers can connect to an address on the EBus and the order in which handlers at each address receive events.

Enumerator
Single	The EBus supports one handler for each address.
Multiple	(Default) Allows any number of handlers for each address; handlers at an address receive events in the order in which the handlers are connected to the EBus.
MultipleAndOrdered	Allows any number of handlers for each address; the order in which each address receives an event is defined by AZ::EBusTraits::BusHandlerOrderCompare.

◆ IntegralTypeDiff

enum class AZ::IntegralTypeDiff

strong

Enumerations to describe the sign and size relationship between two integer types.

Enumerator
LSignedRSignedEqSize	Left integer is signed, right integer is signed, both are equal in size.
LSignedRUnsignedEqSize	Left integer is signed, right integer is unsigned, both are equal in size.
LUnsignedRSignedEqSize	Left integer is unsigned, right integer is signed, both are equal in size.
LUnsignedRUnsignedEqSize	Left integer is unsigned, right integer is unsigned, both are equal in size.
LSignedRSignedLWider	Left integer is signed, right integer is signed, left integer is wider.
LSignedRUnsignedLWider	Left integer is signed, right integer is unsigned, left integer is wider.
LUnsignedRSignedLWider	Left integer is unsigned, right integer is signed, left integer is wider.
LUnsignedRUnsignedLWider	Left integer is unsigned, right integer is unsigned, left integer is wider.
LSignedRSignedRWider	Left integer is signed, right integer is signed, right integer is wider.
LSignedRUnsignedRWider	Left integer is signed, right integer is unsigned, right integer is wider.
LUnsignedRSignedRWider	Left integer is unsigned, right integer is signed, right integer is wider.
LUnsignedRUnsignedRWider	Left integer is unsigned, right integer is unsigned, right integer is wider.

◆ InterpolationMode

enum class AZ::InterpolationMode : u32

strong

Behavior types for smoothing of transform between network updates.

◆ JsonMergeApproach

enum class AZ::JsonMergeApproach

strong

Enumerator
JsonPatch	Uses JSON Patch to merge two json documents. See https://tools.ietf.org/html/rfc6902.
JsonMergePatch	Uses JSON Merge Patch to merge two json documents. See https://tools.ietf.org/html/rfc7386.

◆ ModuleInitializationSteps

enum class AZ::ModuleInitializationSteps : u8

strong

Describes the steps taken when loading and initializing a module.

Note: Not to be used as flags!

Enumerator
None	The module hasn't been initialized.
Load	Loads a dynamic module (populates GetDynamicModuleHandle())
CreateClass	Initializes the module class (populates GetModule())
RegisterComponentDescriptors	Registers all of the component descriptors from a module.
ActivateEntity	Instantiates system components and activates the entity.

◆ OnParentChangedBehavior

enum class AZ::OnParentChangedBehavior : AZ::u8

strong

Used to control the behavior of an entity's transform when its parent's transform changes at runtime.

Enumerator
Update	Update this entity's transform based on the parent's new world transform and this entity's local transform (default).
DoNotUpdate	Do not update this entity's world transform when the parent's transform changes.

◆ PlatformID

enum class AZ::PlatformID

strong

Enum of supported platforms. Just for user convenience.

Enumerator
PLATFORM_MAX	Must be last.

◆ RandomDistributionType

enum class AZ::RandomDistributionType : AZ::u32

strong

An enum representing the different random distributions available

These map to random distributions in std::random. Those distributions have no common base class so this is an enum to help determine which random distribution is needed.

◆ RegisteredReflectionContext

enum class AZ::RegisteredReflectionContext

strong

Represents entries of which reflection context a type is registered

Only one value is returned. The values are NOT bitwise-ORed together if the type is registered with multiple context, the JsonRegistrationContext is set before the SerializeContext

◆ TypeTraits

enum class AZ::TypeTraits : AZ::u64

strong

Type Trait structure for tracking of C++ type trait data within the SerializeContext ClassData structure;

Enumerator
is_signed	Stores the result of the std::is_signed check for a registered type.
is_unsigned	Stores the result of the std::is_unsigned check for a registered type NOTE: While this might seem to be redundant due to is_signed, it is NOT Only numeric types have a concept of signedness
is_enum	Stores the result of the std::is_enum check.
is_pointer	Stores if the type represents an object pointer type NOTE: This should not be set for a member pointer(i.e T::*)
is_template	Stores if the type represents a template.

◆ VariantOnThis

enum class AZ::VariantOnThis

strong

/ returns a map of 0 based argument index --> vector<BehaviorParameter*>>. no two rows should have the same type

e.g.:

overloaded argument index = 1 void myOverload(EntityId, float); // overload index 0 void myOverload(EntityId, bool); // overload index 1 void myOverload(EntityId, string); // overload index 2

would yield: 1 -> { BP*(float), BP*(bool), BP*(string),

The argument index (0) is omitted, since it is EntityId in all cases, and never overloaded

Function Documentation

◆ Abs()

AZ_MATH_INLINE float AZ::Abs ( float value )

Simd optimized math functions.

◆ AliasCast()

template<typename T , typename S >

T AZ::AliasCast ( S source )

Does an safe alias cast using a union. This will allow you to properly cast types that when strict aliasing is enabled.

◆ AlignUpToPowerOfTwo()

constexpr size_t AZ::AlignUpToPowerOfTwo ( size_t value )

inlineconstexpr

Rounds up a value to next power of 2. For example to round 8388609((2^23) + 1) up to 16777216(2^24) the following occurs Subtract one from the value in case it is already equal to a power of 2 8388609 - 1 = 8388608 Propagate the highest one bit in the value to all the lower bits 8388608 = 0b100'0000'0000'0000'0000'0000 in binary

0b100'0000'0000'0000'0000'0000

|0b010'0000'0000'0000'0000'0000 (>> 1)

0b110'0000'0000'0000'0000'0000 (Now there are 2 consecutive 1-bits)

|0b001'1000'0000'0000'0000'0000 (>> 2)

0b111'1000'0000'0000'0000'0000 (Now there are 4 consecutive 1-bits)

|0b000'0111'1000'0000'0000'0000 (>> 4)

0b111'1111'1000'0000'0000'0000 (Now there are 8 consecutive 1-bits)

|0b000'0000'0111'1111'1000'0000 (>> 8)

0b111'1111'1111'1111'1000'0000 (Now there are 16 consecutive 1-bits)

|0b000'0000'0000'0000'0111'1111 (>> 16)

0b111'1111'1111'1111'1111'1111 (Now there are 23 consecutive 1-bits)

|0b000'0000'0000'0000'0000'0000 (>> 32)

0b111'1111'1111'1111'1111'1111 Finally since all the one bits are set in the value, adding one pushes it to next power of 2 0b1000'0000'0000'0000'0000'0000 = 16777216

◆ AZ_TYPE_SAFE_INTEGRAL()

AZ::AZ_TYPE_SAFE_INTEGRAL	(	TimeUs	,
		int64_t
	)

This is a strong typedef for representing a microsecond value since application start. Using int64_t as the underlying type, this is good to represent approximately 292,471 years

◆ ConvertEulerDegreesToQuaternion()

AZ_MATH_INLINE Quaternion AZ::ConvertEulerDegreesToQuaternion ( const Vector3 & eulerDegrees )

O3DE_DEPRECATION_NOTICE(GHI-10929)

Deprecated:: use Quaternion::CreateFromEulerDegreesXYZ

Parameters

eulerDegrees A vector containing component-wise rotation angles in degrees.

Returns: a quaternion made from composition of rotations around principle axes.

◆ ConvertEulerDegreesToTransform()

AZ_MATH_INLINE Transform AZ::ConvertEulerDegreesToTransform ( const Vector3 & eulerDegrees )

Create a transform from Euler Angles (e.g. rotation angles in X, Y, and Z)

Parameters

Vector3 eulerDegrees A vector containing component-wise rotation angles in degrees.

Returns: Transform A transform made from the rotational components.

◆ ConvertEulerRadiansToQuaternion()

AZ_MATH_INLINE Quaternion AZ::ConvertEulerRadiansToQuaternion ( const Vector3 & eulerRadians )

O3DE_DEPRECATION_NOTICE(GHI-10929)

Deprecated:: use Quaternion::CreateFromEulerRadiansXYZ

Parameters

eulerRadians A vector containing component-wise rotation angles in radians.

Returns: a quaternion made from composition of rotations around principle axes.

◆ ConvertEulerRadiansToTransform()

AZ_MATH_INLINE Transform AZ::ConvertEulerRadiansToTransform ( const Vector3 & eulerRadians )

Create a rotation transform from Euler angles in radian around each base axis. This version uses precise sin/cos for a more accurate conversion.

Parameters

Vector3 eulerDegrees A vector containing component-wise rotation angles in radian.

Returns: Transform A transform made from the composite of rotations first around z-axis, and y-axis and then x-axis.

◆ ConvertQuaternionToAxisAngle()

AZ_MATH_INLINE void AZ::ConvertQuaternionToAxisAngle	(	const Quaternion &	quat,
		Vector3 &	outAxis,
		float &	outAngle
	)

Populate axis and angle of rotation from Quaternion.

Parameters

[in]	quat	A source quaternion
[out]	outAxis	A Vector3 defining the rotation axis.
[out]	outAngle	A float rotation angle around the axis in radians.

◆ ConvertQuaternionToEulerDegrees()

AZ_MATH_INLINE Vector3 AZ::ConvertQuaternionToEulerDegrees ( const Quaternion & q )

Non-member functionality belonging to the AZ namespace.

Create, from a quaternion, a set of Euler angles of rotations around first z-axis, then y-axis and then x-axis.

Parameters

q	a quaternion representing the rotation

Returns: A vector containing component-wise rotation angles in degrees.

◆ ConvertQuaternionToEulerRadians()

AZ_MATH_INLINE Vector3 AZ::ConvertQuaternionToEulerRadians ( const Quaternion & q )

Create, from a quaternion, a set of Euler angles of rotations around first z-axis, then y-axis and then x-axis.

Parameters

q	a quaternion representing the rotation

Returns: A vector containing component-wise rotation angles in radians.

◆ ConvertTransformToEulerDegrees()

AZ_MATH_INLINE Vector3 AZ::ConvertTransformToEulerDegrees ( const Transform & transform )

Non-member functionality belonging to the AZ namespace

Converts a transform to corresponding component-wise Euler angles.

Parameters

Transform transform The input transform to decompose.

Returns: Vector3 A vector containing component-wise rotation angles in degrees.

◆ CreateModuleAttribute()

template<typename T , typename ContainerType = AttributeContainerType<T>>

AttributePtr AZ::CreateModuleAttribute ( T && attrValue )

Creates AZ::Attribute that is allocated using the the SerializeContext PerModule allocator associated with current module

Parameters

attrValue	value to store within the attribute
ContainerType	second parameter which is used for function parameter deduction

◆ CreateRandomQuaternion()

Quaternion AZ::CreateRandomQuaternion ( SimpleLcgRandom & rng )

Creates a unit quaternion uniformly sampled from the space of all possible rotations. See Graphics Gems III, chapter 6.

◆ DivideAndRoundUp()

template<typename T >

constexpr T AZ::DivideAndRoundUp	(	T	value,
		T	alignment
	)

constexpr

Returns the value divided by alignment, where the result is rounded up if the remainder is non-zero. Example: alignment: 4 Value: 0 1 2 3 4 5 6 7 8 Result: 0 1 1 1 1 2 2 2 2

Parameters

value	The numerator.
alignment	The denominator. The result will be rounded up to the nearest multiple of alignment. Must be non-zero or it will lead to undefined behavior

◆ DummyStateHandler()

template<bool handleEvent>

bool AZ::DummyStateHandler	(	HSM &	,
		const HSM::Event &
	)

Default empty handler.

◆ Failure() [1/2]

constexpr AZStd::unexpected< AZStd::unexpect_t > AZ::Failure ( )

constexpr

Used to return a failure case in a function returning an AZ::Outcome<..., void>.

◆ Failure() [2/2]

template<class ValueT , class >

constexpr AZStd::unexpected< ValueT > AZ::Failure ( ValueT && rhs )

constexpr

Used to return a failure case in a function returning an AZ::Outcome<..., ValueT>. rhs is a universal reference: can either copy or move

◆ GetHaltonNumber()

float AZ::GetHaltonNumber	(	uint32_t	index,
		uint32_t	base
	)

inline

Halton sequences are deterministic, quasi-random sequences with low discrepancy. They are useful for generating evenly distributed points. See https://en.wikipedia.org/wiki/Halton_sequence for more information. Returns a single halton number.

Parameters

index	The index of the number. Indices start at 1. Using index 0 will return 0.
base	The numerical base of the halton number.

◆ GetMax()

template<typename T >

constexpr T AZ::GetMax	(	T	a,
		T	b
	)

constexpr

Return the bigger of the 2 values.

Note: we don't use names like clamp, min and max because many implementations define it as a macro.

◆ GetMin()

template<typename T >

constexpr T AZ::GetMin	(	T	a,
		T	b
	)

constexpr

Return the smaller of the 2 values.

Note: we don't use names like clamp, min and max because many implementations define it as a macro.

◆ GetO3deClassTemplateId()

void AZ::GetO3deClassTemplateId ( ... )

Template Uuid.

Unimplemented of GetO3deClassTemplateId function which provides a symbolfor name lookup when GetAzTemplateId() function overload is not available The return type is void to distinguish it from actual overloads which return AZ::Uuid This function should be overloaded for class template (not types) using the signature of AZ::TemplateId GetO3deClassTemplateId(decltype(GetTemplateIdentity<ActualType>())) For example to overload GetO3deClassTemplateId for AZStd::vector the following signature should be used AZ::TemplateId GetO3deClassTemplateId(AZ::Adl{}, decltype(GetTemplateIdentity<AZStd::vector>()))

◆ IsPowerOfTwo()

constexpr bool AZ::IsPowerOfTwo ( uint32_t testValue )

constexpr

Compile-time test for power of two, useful for static asserts usage: IsPowerOfTwo<(thing you're testing)>::Value

◆ JsonNumericCast()

template<typename ToType , typename FromType >

JsonSerializationResult::ResultCode AZ::JsonNumericCast	(	ToType &	result,
		FromType	value,
		AZStd::string_view	path,
		const AZ::JsonSerializationResult::JsonIssueCallback &	reporting
	)

A helper function to casts between numeric types, and consider the data which is being converted comes from user data. If a conversion from FromType to ToType will not cause overflow or underflow, the result is stored in result, and the function returns Success Otherwise, the target is left untouched.

◆ MakeFrustumMatrixRH()

Matrix4x4 * AZ::MakeFrustumMatrixRH	(	Matrix4x4 &	out,
		float	left,
		float	right,
		float	bottom,
		float	top,
		float	nearDist,
		float	farDist,
		bool	reverseDepth = `false`
	)

Builds a right-handed perspective projection matrix from frustum data. The generated projection matrix transforms vectors to clip space which x is in [-1, 1] range and positive x points to right y is in [-1, 1] range and positive y points to top z is in [ 0, 1] range and negative near and negative far map to [0, 1] or [1, 0] if reverseDepth is set to 1

Parameters

out	Matrix which stores output result
left	The x coordinate of left side of frustum at near view-plane
right	The x coordinate of right side of frustum at near view-plane
bottom	The y coordinate of bottom side of frustum at near view-plane
top	The y coordinate of top side of frustum at near view-plane
near	Distance to the near view-plane. Must be greater than zero.
far	Distance to the far view-plane. Must be greater than zero.
reverseDepth	Set to true to reverse depth which means near distance maps to 1 and far distance maps to 0.

Returns: Pointer of the output matrix

◆ MakeOrthographicMatrixRH()

Matrix4x4 * AZ::MakeOrthographicMatrixRH	(	Matrix4x4 &	out,
		float	left,
		float	right,
		float	bottom,
		float	top,
		float	nearDist,
		float	farDist,
		bool	reverseDepth = `false`
	)

Builds a right-handed orthographic projection matrix from frustum data. Expected use-cases are view-to-clip matrix of directional light, so the frustum may contain the view point (light origin). The generated projection matrix transforms vectors to clip space which x is in [-1, 1] range and positive x points to right y is in [-1, 1] range and positive y points to top z is in [ 0, 1] range and negative z in original space will be transformed to forward in clip space

Parameters

out	Matrix which stores output result
left	The x coordinate of left view-plane
right	The x coordinate of right view-plane
bottom	The y coordinate of bottom view-plane
top	The y coordinate of top view-plane
near	Distance to the near view-plane. Must be no less than zero.
far	Distance to the far view-plane. Must be greater than zero.
reverseDepth	Set to true to reverse depth which means near distance maps to 1 and far distance maps to 0.

Returns: Pointer of the output matrix

◆ MakePerspectiveFovMatrixRH()

Matrix4x4 * AZ::MakePerspectiveFovMatrixRH	(	Matrix4x4 &	out,
		float	fovY,
		float	aspectRatio,
		float	nearDist,
		float	farDist,
		bool	reverseDepth = `false`
	)

Builds a right-handed perspective projection matrix with fov and near/far distances. The generated projection matrix transforms vectors to clip space which x is in [-1, 1] range and positive x points to right y is in [-1, 1] range and positive y points to top z is in [ 0, 1] range and negative near and negative far map to [0, 1] or [1, 0] if reverseDepth is set to 1

Parameters

out	Matrix which stores output result
fovY	Field of view in the y direction, in radians. Must be greater than zero.
aspectRatio	Aspect ratio, defined as view space width divided by height. Must be greater than zero.
near	Distance to the near view-plane. Must be greater than zero.
far	Distance to the far view-plane. Must be greater than zero.
reverseDepth	Set to true to reverse depth which means near distance maps to 1 and far distance maps to 0.

Returns: Pointer of the output matrix

◆ MathReflect()

void AZ::MathReflect ( ReflectContext * context )

Reflect different aspects of math (depending on context)

◆ MatrixMatrixMultiply()

AZ_MATH_INLINE void AZ::MatrixMatrixMultiply	(	const MatrixMxN &	lhs,
		const MatrixMxN &	rhs,
		MatrixMxN &	output
	)

Multiplies the two input matrices to produce the output matrix. The column count of the right-hand side matrix must match the row count of the left-hand side matrix The output matrix must have dimensionality rhs.rowCount x lhs.colCount

◆ operator*() [1/4]

AZ_MATH_INLINE Vector3 AZ::operator*	(	const Vector3 &	lhs,
		const Matrix3x3 &	rhs
	)

Pre-multiplies the matrix by a vector. Note that this is not the usual multiplication order for transformations.

◆ operator*() [2/4]

AZ_MATH_INLINE const Vector3 AZ::operator*	(	const Vector3 &	lhs,
		const Matrix4x4 &	rhs
	)

Pre-multiplies the matrix by a vector. Assumes that the w-component of the Vector3 is 1.0, and returns the result as a Vector3, without calculating the result w-component. Use the Vector4 version of this function to get the full result. Note that this is not the usual multiplication order for transformations.

◆ operator*() [3/4]

AZ_MATH_INLINE const Vector4 AZ::operator*	(	const Vector4 &	lhs,
		const Matrix4x4 &	rhs
	)

Pre-multiplies the matrix by a vector. Note that this is not the usual multiplication order for transformations.

◆ operator*() [4/4]

AZ_MATH_INLINE Quaternion AZ::operator*	(	float	multiplier,
		const Quaternion &	rhs
	)

Scalar multiplication of a quaternion, allows scalar * quaternion syntax.

Parameters

multiplier	the scalar value to use.
rhs	the quaternion to scale.

Returns: a quaternion where each component of rhs is scaled by multiplier.

◆ operator*=() [1/3]

AZ_MATH_INLINE Vector3 & AZ::operator*=	(	Vector3 &	lhs,
		const Matrix3x3 &	rhs
	)

Pre-multiplies the matrix by a vector in-place. Note that this is not the usual multiplication order for transformations.

◆ operator*=() [2/3]

AZ_MATH_INLINE Vector3 & AZ::operator*=	(	Vector3 &	lhs,
		const Matrix4x4 &	rhs
	)

Pre-multiplies the matrix by a vector in-place. Assumes that the w-component of the Vector3 is 1.0, and returns the result as a Vector3, without calculating the result w-component. Use the Vector4 version of this function to get the full result. Note that this is not the usual multiplication order for transformations.

◆ operator*=() [3/3]

AZ_MATH_INLINE Vector4 & AZ::operator*=	(	Vector4 &	lhs,
		const Matrix4x4 &	rhs
	)

Pre-multiplies the matrix by a vector in-place. Note that this is not the usual multiplication order for transformations.

◆ operator+()

AZ_MATH_INLINE VectorN AZ::operator+	(	float	lhs,
		const VectorN &	rhs
	)

Operators that allow scalars as lhs operands.

◆ OuterProduct()

AZ_MATH_INLINE void AZ::OuterProduct	(	const VectorN &	lhs,
		const VectorN &	rhs,
		AZ::MatrixMxN &	output
	)

Computes the outer product of two vectors to produce an MxN matrix. The dimensionality of the resulting matrix will be M = lhs.dimensionality, N = rhs.dimensionality

◆ parallel_for() [1/2]

template<class IndexType , class Function , class Partition >

void AZ::parallel_for	(	IndexType	start,
		IndexType	end,
		const Function &	function,
		const Partition &	partition,
		JobContext *	jobContext = `nullptr`
	)

Parallel for loop over a range. The function must have a single int parameter and return void. This function will block until the loop is complete. It can be called from within a job, or from a non-worker thread, in which case the thread will block on a completion event. Works with both small and large ranges, the iterations will be distributed efficiently in either case.

◆ parallel_for() [2/2]

template<class IndexType , class Function , class Partition >

void AZ::parallel_for	(	IndexType	start,
		IndexType	end,
		IndexType	step,
		const Function &	function,
		const Partition &	partition,
		JobContext *	jobContext = `nullptr`
	)

TODO Parallel for loop over a range with a step. The function must have a single int parameter and return void. This function will block until the loop is complete. It can be called from within a job, or from a non-worker thread, in which case the thread will block on a completion event. Works with both small and large ranges, the iterations will be distributed efficiently in either case.

◆ parallel_for_each()

template<class Iterator , class Function , class Partition >

void AZ::parallel_for_each	(	Iterator	start,
		Iterator	end,
		const Function &	function,
		const Partition &	partition,
		JobContext *	jobContext = `nullptr`
	)

Parallel for loop over a range of items. The function must have a single parameter of type T, the iterator value type, and return void. This function will block until the loop is complete. It can be called from within a job, or from a non-worker thread, in which case the thread will block on a completion event. Works with both small and large ranges, the iterations will be distributed efficiently in either case. It works with both forward iterators and random access iterators, but performance will be better with random access iterators.

◆ parallel_for_each_start()

template<class Iterator , class Function , class Partition >

void AZ::parallel_for_each_start	(	Iterator	start,
		Iterator	end,
		const Function &	function,
		Job *	dependent,
		const Partition &	partition,
		JobContext *	jobContext = `nullptr`,
		AZStd::stack_allocator *	allocator = `nullptr`
	)

Parallel for loop over a range of items. The function must have a single parameter of type T, the iterator value type, and return void. This function will return immediately once the loop has been started, so you must supply a dependent job which will be notified when the loop completes. It can be called from within a job, or from a non-worker thread. Works with both small and large ranges, the iterations will be distributed efficiently in either case. It works with both forward iterators and random access iterators, but performance will be better with random access iterators.

◆ parallel_for_start() [1/2]

template<class IndexType , class Function , class Partition >

void AZ::parallel_for_start	(	IndexType	start,
		IndexType	end,
		const Function &	function,
		Job *	dependent,
		const Partition &	partition,
		JobContext *	jobContext = `nullptr`,
		AZStd::stack_allocator *	allocator = `nullptr`
	)

Parallel for loop over a range. The function must have a single int parameter and return void. This function will return immediately once the loop has been started, so you must supply a dependent job which will be notified when the loop completes. It can be called from within a job, or from a non-worker thread. Works with both small and large ranges, the iterations will be distributed efficiently in either case.

◆ parallel_for_start() [2/2]

template<class IndexType , class Function , class Partition >

void AZ::parallel_for_start	(	IndexType	start,
		IndexType	end,
		IndexType	step,
		const Function &	function,
		Job *	dependent,
		const Partition &	partition,
		JobContext *	jobContext = `nullptr`,
		AZStd::stack_allocator *	allocator = `nullptr`
	)

Parallel for loop over a range with a step. The function must have a single int parameter and return void. This function will return immediately once the loop has been started, so you must supply a dependent job which will be notified when the loop completes. It can be called from within a job, or from a non-worker thread. Works with both small and large ranges, the iterations will be distributed efficiently in either case.

◆ parallel_invoke()

template<typename F1 , typename F2 >

void AZ::parallel_invoke	(	const F1 &	f1,
		const F2 &	f2,
		JobContext *	jobContext = `nullptr`
	)

Invokes the specified functions in parallel and waits until they are all complete. Overloads for up to 8 function parameters are provided.

◆ QueryMemInfo()

bool AZ::Process::QueryMemInfo ( ProcessMemInfo & meminfo )

Retrieve information about memory usage of current process.

Parameters

meminfo Output parameter where information is saved.

◆ RoundUpToMultiple()

template<typename T >

constexpr T AZ::RoundUpToMultiple	(	T	value,
		T	alignment
	)

constexpr

Returns the value rounded up to a multiple of alignment. This function will work for non power of two alignments. If your alignment is guaranteed to be a power of two, SizeAlignUp in base.h is a more efficient implementation. Example: roundTo: 4 Value: 0 1 2 3 4 5 6 7 8 Result: 0 4 4 4 4 8 8 8 8

Parameters

value	The number to round up.
alignment	Round up to the nearest multiple of alignment. Must be non-zero or it will lead to undefined behavior

◆ SafeIntegralCompare()

template<typename LeftType , typename RightType >

constexpr IntegralCompare AZ::SafeIntegralCompare	(	LeftType	lhs,
		RightType	rhs
	)

constexpr

Safely compares two integers of any sign and width combination and returns an IntegralCompare result that is the whether lhs is less than, equal to or greater than rhs.

◆ SetPerspectiveMatrixNearFar()

void AZ::SetPerspectiveMatrixNearFar	(	Matrix4x4 &	out,
		float	nearDist,
		float	farDist,
		bool	reverseDepth = `true`
	)

Adjust the near/far planes of an existing right-handed perspective projection matrix.

Parameters

out	Matrix which stores output result.
near	Distance to the near view-plane. Must be no less than zero.
far	Distance to the far view-plane. Must be greater than zero.
reverseDepth	Set to true to reverse depth which means near distance maps to 1 and far distance maps to 0.

◆ ShouldUseSystemComponent()

bool AZ::ShouldUseSystemComponent	(	const ComponentDescriptor &	descriptor,
		const AZStd::vector< Crc32 > &	requiredTags,
		const SerializeContext &	serialize
	)

Checks if a component should be used as a System Component in a given context.

Parameters

descriptor	The descriptor for the component being checked
requiredTags	The tags the component must have one of for true to be returned
serialize	The serialize context to pull attributes for the component from

Returns: whether the component represented by descriptor has at least one tag that is present in required tags

◆ Success() [1/2]

constexpr AZStd::in_place_t AZ::Success ( )

constexpr

Used to return a success case in a function returning an AZ::Outcome<void, ...>.

◆ Success() [2/2]

template<class ValueT , class >

constexpr ValueT AZ::Success ( ValueT && rhs )

constexpr

Used to return a success case in a function returning an AZ::Outcome<ValueT, ...>. rhs is a universal reference: can either copy or move

◆ TypeHash32()

HashValue32 AZ::TypeHash32	(	const uint8_t *	buffer,
		uint64_t	length
	)

Hashes a contiguous array of bytes starting at buffer and ending at buffer + length

Parameters

[in]	buffer	pointer to the memory to be hashed
[in]	length	the length in bytes of memory to read for generating the hash

Returns: 32 bit resulting hash

◆ TypeHash64() [1/3]

HashValue64 AZ::TypeHash64	(	const uint8_t *	buffer,
		uint64_t	length
	)

Hashes a contiguous array of bytes starting at buffer and ending at buffer + length

Parameters

[in]	buffer	pointer to the memory to be hashed
[in]	length	the length in bytes of memory to read for generating the hash

Returns: 64 bit resulting hash

◆ TypeHash64() [2/3]

HashValue64 AZ::TypeHash64	(	const uint8_t *	buffer,
		uint64_t	length,
		HashValue64	seed
	)

Hashes a contiguous array of bytes starting at buffer and ending at buffer + length

Parameters

[in]	buffer	pointer to the memory to be hashed
[in]	length	the length in bytes of memory to read for generating the hash
[in]	seed	a seed that is hashed into the result

Returns: 64 bit resulting hash

◆ TypeHash64() [3/3]

HashValue64 AZ::TypeHash64	(	const uint8_t *	buffer,
		uint64_t	length,
		HashValue64	seed1,
		HashValue64	seed2
	)

Hashes a contiguous array of bytes starting at buffer and ending at buffer + length

Parameters

[in]	buffer	pointer to the memory to be hashed
[in]	length	the length in bytes of memory to read for generating the hash
[in]	seed1	first seed that is hashed into the result
[in]	seed2	second seed that is also hashed into the result

Returns: 64 bit resulting hash

◆ ValidateAzEventDescription()

bool AZ::ValidateAzEventDescription	(	const AZ::BehaviorContext &	context,
		const AZ::BehaviorMethod &	method
	)

Validates that a method that returns an AZ::Event fulfills the following conditions.

It has an AzEventDescription that stores a BehaviorAzEventDescription instance
The number of parameters that the method accepts, matches the number of elements in the parameter names array
Neither the AZ::Event name nor any of it's parameters are an empty string

◆ Vector2ToVector3() [1/2]

Vector3 AZ::Vector2ToVector3 ( const Vector2 & v )

Converts a Vector2 to a Vector3

Parameters

v	The Vector2 to convert

Returns: A Vector3 created from the given Vector2 with 0 for the Z component

O3DE_DEPRECATION_NOTICE(GHI-10596)

Deprecated:: use AZ::Vector3 constructor

◆ Vector2ToVector3() [2/2]

Vector3 AZ::Vector2ToVector3	(	const Vector2 &	v,
		const float	z
	)

Converts a Vector2 to a Vector3

Parameters

v	The Vector2 to convert
z	The new value for the resulting Vector3's Z component

Returns: A Vector3 created from the given values

O3DE_DEPRECATION_NOTICE(GHI-10596)

Deprecated:: use AZ::Vector3 constructor

◆ Vector2ToVector4() [1/3]

Vector4 AZ::Vector2ToVector4 ( const Vector2 & v )

Converts a Vector2 to a Vector4

Parameters

v	The Vector2 to convert

Returns: A Vector4 created from the given Vector2 with 0 for the Z and W components

O3DE_DEPRECATION_NOTICE(GHI-10596)

Deprecated:: use AZ::Vector4 constructor

◆ Vector2ToVector4() [2/3]

Vector4 AZ::Vector2ToVector4	(	const Vector2 &	v,
		const float	z
	)

Converts a Vector2 to a Vector4

Parameters

v	The Vector2 to convert
z	The new value for the resulting Vector4's Z component

Returns: A Vector4 created from the given values with a 0 for the W component

O3DE_DEPRECATION_NOTICE(GHI-10596)

Deprecated:: use AZ::Vector4 constructor

◆ Vector2ToVector4() [3/3]

Vector4 AZ::Vector2ToVector4	(	const Vector2 &	v,
		const float	z,
		const float	w
	)

Converts a Vector2 to a Vector4

Parameters

v	The Vector2 to convert
z	The new value for the resulting Vector4's Z component
w	The new value for the resulting Vector4's W component

Returns: A Vector4 created from the given values

O3DE_DEPRECATION_NOTICE(GHI-10596)

Deprecated:: use AZ::Vector4 constructor

◆ Vector3RadToDeg()

AZ_MATH_INLINE Vector3 AZ::Vector3RadToDeg ( const AZ::Vector3 & radians )

Non member functionality belonging to the AZ namespace. Degrees-Radians conversions on AZ::Vector3

◆ Vector3ToVector2()

Vector2 AZ::Vector3ToVector2 ( const Vector3 & v )

Converts a Vector3 to a Vector2

The Z value of the Vector3 will be dropped

Parameters

v	The Vector3 to convert to a Vector2

Returns: A Vector2 created from the given Vector2

O3DE_DEPRECATION_NOTICE(GHI-10596)

Deprecated:: use AZ::Vector2 constructor

◆ Vector3ToVector4() [1/2]

Vector4 AZ::Vector3ToVector4 ( const Vector3 & v )

Converts a Vector3 to a Vector4

Parameters

v	The Vector3 to convert to a Vector4

Returns: A Vector4 created from the given Vector3 with a 0 for the W component

O3DE_DEPRECATION_NOTICE(GHI-10596)

Deprecated:: use AZ::Vector4 constructor

◆ Vector3ToVector4() [2/2]

Vector4 AZ::Vector3ToVector4	(	const Vector3 &	v,
		const float	w
	)

Converts a Vector3 to a Vector4

Parameters

v	The Vector3 to convert to a Vector4
w	The new value for the resulting Vector4's W component

Returns: A Vector4 created from the given values

O3DE_DEPRECATION_NOTICE(GHI-10596)

Deprecated:: use AZ::Vector4 constructor

◆ Vector4ToVector2()

Vector2 AZ::Vector4ToVector2 ( const Vector4 & v )

Converts a Vector4 to a Vector2

The Z and W components of the given Vector4 will be dropped

Parameters

v	The Vector2 to convert to a Vector4

Returns: A Vector4 created from the given Vector2 with 0s for the Z and W components

O3DE_DEPRECATION_NOTICE(GHI-10596)

Deprecated:: use AZ::Vector2 constructor

◆ Vector4ToVector3()

Vector3 AZ::Vector4ToVector3 ( const Vector4 & v )

Converts a Vector4 to a Vector3

The W component of the given Vector4 will be dropped

Parameters

v	The Vector3 to convert to a Vector4

Returns: A Vector4 created from the given Vector3 with a 0 for the W component

O3DE_DEPRECATION_NOTICE(GHI-10596)

Deprecated:: use AZ::Vector3 constructor

Variable Documentation

◆ MinTransformScale

constexpr float AZ::MinTransformScale = 1e-2f

staticconstexpr

Limits for transform scale values. The scale should not be zero to avoid problems with inverting.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ BetterPseudoRandom

◆ ConsoleCommandInvokedEvent

◆ CreateModuleClassFunction

◆ CreateStaticModulesCallback

◆ DestroyModuleClassFunction

◆ DispatchCommandNotFoundEvent

◆ DynamicPrefabAsset

◆ EntityBus

◆ EntitySystemBus

◆ InitializeDynamicModuleFunction

◆ ModuleDescriptorList

◆ ObjectStreamWriteOverrideCB

◆ PrefabAsset

◆ PrefabBus

◆ PrefabComponent

◆ PrefabEvents

◆ ReporterString

◆ SliceEntityHierarchyRequestBus

◆ StaticReflectionFunctionPtr

◆ SystemTickBus

◆ TickBus

◆ TickRequestBus

◆ TransformBus

◆ TransformNotificationBus

◆ TypeId

◆ UninitializeDynamicModuleFunction

Enumeration Type Documentation

◆ ComponentTickBus

◆ EBusAddressPolicy

◆ EBusHandlerPolicy

◆ IntegralTypeDiff

◆ InterpolationMode

◆ JsonMergeApproach

◆ ModuleInitializationSteps

◆ OnParentChangedBehavior

◆ PlatformID

◆ RandomDistributionType

◆ RegisteredReflectionContext

◆ TypeTraits

◆ VariantOnThis

Function Documentation

◆ Abs()

◆ AliasCast()

◆ AlignUpToPowerOfTwo()

|0b010'0000'0000'0000'0000'0000 (>> 1)

|0b001'1000'0000'0000'0000'0000 (>> 2)

|0b000'0111'1000'0000'0000'0000 (>> 4)

|0b000'0000'0111'1111'1000'0000 (>> 8)

|0b000'0000'0000'0000'0111'1111 (>> 16)

|0b000'0000'0000'0000'0000'0000 (>> 32)

◆ AZ_TYPE_SAFE_INTEGRAL()

◆ ConvertEulerDegreesToQuaternion()

◆ ConvertEulerDegreesToTransform()

◆ ConvertEulerRadiansToQuaternion()

◆ ConvertEulerRadiansToTransform()

◆ ConvertQuaternionToAxisAngle()

◆ ConvertQuaternionToEulerDegrees()

◆ ConvertQuaternionToEulerRadians()

◆ ConvertTransformToEulerDegrees()

◆ CreateModuleAttribute()

◆ CreateRandomQuaternion()

◆ DivideAndRoundUp()

◆ DummyStateHandler()

◆ Failure() [1/2]

◆ Failure() [2/2]

◆ GetHaltonNumber()

◆ GetMax()

◆ GetMin()

◆ GetO3deClassTemplateId()

◆ IsPowerOfTwo()

◆ JsonNumericCast()

◆ MakeFrustumMatrixRH()