AZ Namespace Reference

Reopen namespace to define DataPatch class. More...

Namespaces
	Constants
	Important constants.
	DeprecatedTypeNames
	Environment
	Intersect
	IO
	PathView implementation.

Classes
class	AssetManagerComponent
class	AssetSerializer
struct	SerializeGenericTypeInfo< Data::Asset< T > >
struct	OnDemandReflection< Data::Asset< T > >
	OnDemandReflection for any generic Data::Asset<T> More...
class	AssetTypeInfo
class	AzCoreModule
struct	s128
struct	u128
class	LossyCasted
class	NumericCasted
class	Component
class	ComponentDescriptor
struct	ComponentDescriptorBusTraits
class	ComponentDescriptorHelper
class	ComponentDescriptorDefault
class	ReflectionEnvironment
class	ComponentApplication
struct	ApplicationTypeQuery
class	ComponentApplicationRequests
	Interface that components can use to make requests of the main application. More...
class	ComponentApplicationRequestsEBusTraits
class	ComponentBus
class	ComponentConfig
class	EntityComponentIdPair
struct	ExportedComponent
class	Entity
class	EntitySystemEvents
class	EntityEvents
class	EntityId
class	JsonEntityIdSerializer
class	JsonEntitySerializer
class	DeprecatedComponentMetadata
class	NamedEntityId
class	NonUniformScaleRequests
	Requests for working with non-uniform scale. More...
class	TickEvents
class	TickRequests
class	SystemTickEvents
class	TransformInterface
class	TransformNotification
class	TransformConfig
	Component configuration for the transform component. More...
class	ZLib
class	ZStd
class	Console
class	ConsoleDataContainer
class	ConsoleDataContainer< BASE_TYPE, ThreadSafety::RequiresLock >
class	ConsoleDataContainer< BASE_TYPE, ThreadSafety::UseStdAtomic >
class	ConsoleDataWrapper
class	ConsoleFunctorBase
struct	ConsoleCommandMemberFunctorSignature
struct	ConsoleCommandMemberFunctorSignature< T, AZStd::enable_if_t< AZStd::is_class_v< T > > >
class	ConsoleFunctor
	Console functor which wraps a function call into an object instance. More...
class	ConsoleFunctor< void, _REPLICATES_VALUE >
struct	ConsoleReplicateHelper
struct	ConsoleReplicateHelper< _TYPE, false >
struct	ConsoleReplicateHelper< _TYPE, true >
struct	ConsoleReplicateHelper< int, true >
struct	ConsoleReplicateHelper< float, true >
struct	ConsoleReplicateHelper< AZStd::string, true >
class	IConsole
class	Event
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
class	LoggerSystemComponent
	Implementation of the ILogger system interface. More...
struct	Specifier
class	Dependency
struct	Version
struct	SemanticVersion
struct	NullMutex
struct	NullBusId
struct	EBusTraits
class	EBus
class	EBusSharedDispatchMutex
class	EBusSharedDispatchMutexConnectLockGuard
class	EBusSharedDispatchMutexDispatchLockGuard
class	EBusSharedDispatchMutexCallstackLockGuard
struct	EBusSharedDispatchTraits
struct	EBusEnvironmentStoragePolicy
class	EBusEnvironment
class	EventHandler
	A handler class that can connect to an Event. More...
struct	CompareScheduledEventPtrs
struct	PrioritizeScheduledEventPtrs
class	EventSchedulerSystemComponent
	This is scheduled event queue class to run all scheduled events at appropriate intervals. More...
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	OrderedEventHandler
	A handler class that can connect to an Event that will be called in order based on priority. More...
class	OrderedEvent
struct	EBusConnectionPolicy
struct	EBusGlobalStoragePolicy
struct	EBusThreadLocalStoragePolicy
struct	EBusQueuePolicy
struct	EBusQueuePolicy< true, Bus, MutexType >
struct	EBusEventProcessingPolicy
struct	EBusReduceResult
struct	EBusReduceResult< T &, Aggregator >
struct	EBusAggregateResults
class	ScheduledEvent
struct	ScheduledEventHandle
class	InstancePoolBase
class	InstancePool
class	InstancePoolManagerInterface
class	InstancePoolManager
class	Interface
class	StreamerComponent
class	SharedMemory
class	SharedMemoryRingBuffer
class	SharedMemory_Common
struct	auto_partitioner
struct	static_partitioner
struct	simple_partitioner
class	Job
class	JobCancelGroup
class	JobCompletion
class	JobCompletionSpin
class	JobContext
class	JobEmpty
class	JobFunction
class	JobManager
class	JobManagerEvents
class	JobManagerComponent
struct	JobManagerThreadDesc
struct	JobManagerDesc
class	MultipleDependentJob
class	structured_task_group
class	Aabb
class	Capsule
	A class representing a capsule (a cylinder with a hemispherical cap at each end). More...
class	Color
	A color class with 4 components, RGBA. More...
class	JsonColorSerializer
class	Crc32
struct	ViewFrustumAttributes
	Attributes required to construct a Frustum from a view volume. More...
class	Frustum
	A frustum class that can be used for efficient primitive intersection tests. More...
class	Hemisphere
	A simple bounding hemisphere class for fast intersection testing. More...
class	Sample
class	LinearlyInterpolatedSample
class	LinearlyInterpolatedSample< Vector3 >
class	LinearlyInterpolatedSample< Quaternion >
class	UninterpolatedSample
class	UninterpolatedSample< Vector3 >
class	UninterpolatedSample< Quaternion >
class	LineSegment
	LineSegment defined by two Vector3, an start and a end. More...
class	BaseJsonMatrixSerializer
class	JsonMatrix3x3Serializer
class	JsonMatrix3x4Serializer
class	JsonMatrix4x4Serializer
class	UuidSerializer
class	FloatArrayTextSerializer
class	FloatBasedContainerSerializer
	Custom template to cover all fundamental AZMATH classes. More...
struct	SizeType
struct	SizeType< 8, false >
struct	SizeType< 7, false >
struct	SizeType< 6, false >
struct	SizeType< 5, false >
struct	SizeType< 4, false >
struct	SizeType< 3, false >
struct	SizeType< 2, false >
struct	SizeType< 1, false >
struct	SizeType< 0, false >
struct	SizeType< 8, true >
struct	SizeType< 7, true >
struct	SizeType< 6, true >
struct	SizeType< 5, true >
struct	SizeType< 4, true >
struct	SizeType< 3, true >
struct	SizeType< 2, true >
struct	SizeType< 1, true >
struct	SizeType< 0, true >
struct	ClampedIntegralLimits
	A collection of methods for clamping and constraining integer values and ranges to that of a reference integer type. More...
class	BaseJsonVectorSerializer
class	JsonVector2Serializer
class	JsonVector3Serializer
class	JsonVector4Serializer
class	JsonQuaternionSerializer
class	Matrix3x3
class	Matrix3x4
class	Matrix4x4
class	Obb
	An oriented bounding box. More...
class	PackedVector3
class	Plane
class	PolygonPrism
class	Quaternion
class	SimpleLcgRandom
class	HaltonSequence
class	Ray
	Ray defined by two Vector3, an orign and a normalized direction. More...
class	Sfmt
class	Sha1
class	Sphere
	A simple bounding sphere class for fast intersection testing. More...
struct	SplineAddress
struct	PositionSplineQueryResult
struct	RaySplineQueryResult
class	Spline
class	LinearSpline
class	BezierSpline
class	CatmullRomSpline
class	Transform
class	JsonTransformSerializer
struct	Uuid
class	JsonUuidSerializer
class	Vector2
	2-dimensional vector class. More...
class	Vector3
	3-dimensional vector class. More...
class	Vector4
class	VertexContainer
class	FixedVertices
class	VariableVertices
class	VertexRequests
	EBus traits for vertex requests. More...
class	VertexContainerNotificationInterface
class	AllocatorBase
class	AllocatorInstance
class	AllocatorManager
class	IAllocatorTrackingRecorder
class	IAllocatorWithTracking
class	AllocatorWrapper
class	AllocatorPointerWrapper
class	AllocatorGlobalWrapper
class	ChildAllocatorSchema
class	HphaSchemaBase
class	HphaSchema
struct	AllocatorDebugConfig
class	IAllocator
class	AZStdAlloc
class	AZStdIAllocator
class	AZStdFunctorAllocator
struct	HasAZClassAllocator
struct	HasAZClassAllocator< T, decltype(T::AZ_CLASS_ALLOCATOR_Allocate(), void())>
class	OSAllocator
class	PoolAllocation
class	PoolSchema
class	ThreadPoolSchema
class	ThreadPoolSchemaHelper
class	PoolAllocator
class	ThreadPoolAllocator
class	SimpleSchemaAllocator
class	SystemAllocator
class	DynamicModuleHandle
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	Module
class	ModuleEntity
struct	ModuleDataImpl
class	ModuleManager
struct	ModuleData
class	DynamicModuleDescriptor
class	ModuleManagerRequests
	Requests related to module reloading. More...
class	NameRef
class	Name
class	NameDictionary
class	NameJsonSerializer
class	NameSerializer
	Provides flattened serialization of Name objects as a simple string. More...
class	Outcome
class	AttributeInvoker
class	AttributeReader
struct	OnDemandReflection< AZStd::intrusive_ptr< T > >
	OnDemand reflection for AZStd::intrusive_ptr. More...
struct	OnDemandReflection< AZStd::shared_ptr< T > >
	OnDemand reflection for AZStd::shared_ptr. More...
struct	Iterator_VM
class	Iterator_VM< AZStd::vector< t_Value, t_Allocator > >
struct	OnDemandReflection< AZ::Event< T...> >
struct	OnDemandReflection< AZStd::vector< T, A > >
	OnDemand reflection for AZStd::vector. More...
struct	OnDemandReflection< AZStd::array< T, N > >
	OnDemand reflection for AZStd::array. More...
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::pair< T1, T2 > >
struct	OnDemandReflection< AZStd::tuple< T...> >
class	Iterator_VM< AZStd::unordered_map< t_Key, t_Value, t_Hasher, t_EqualKey, t_Allocator > >
struct	OnDemandReflection< AZStd::unordered_map< Key, MappedType, Hasher, EqualKey, Allocator > >
	OnDemand reflection for AZStd::unordered_map. More...
class	Iterator_VM< AZStd::unordered_set< t_Key, t_Hasher, t_EqualKey, t_Allocator > >
struct	OnDemandReflection< AZStd::unordered_set< Key, Hasher, EqualKey, Allocator > >
	OnDemand reflection for AZStd::unordered_set. More...
struct	OnDemandReflection< AZStd::any >
struct	OnDemandReflection< AZStd::optional< T > >
class	AzStdReflectionComponent
struct	BehaviorObject
struct	BehaviorParameter
struct	BehaviorParameterMetadata
struct	BehaviorParameterOverrides
struct	BehaviorArgumentValueTypeTag_t
struct	BehaviorArgument
class	BehaviorDefaultValue
class	BehaviorValues
struct	BehaviorAzEventDescription
class	BehaviorMethod
struct	InputRestriction
struct	BranchOnResultInfo
struct	CheckedOperationInfo
struct	OverloadArgumentGroupInfo
struct	ExplicitOverloadInfo
struct	EventHandlerCreationFunctionHolder
struct	UnwrapperFuncDeleter
struct	UnwrapperUserData
class	BehaviorClass
class	BehaviorProperty
struct	BehaviorEBusEventSender
class	ScopedBehaviorOnDemandReflector
class	BehaviorEBus
class	BehaviorEBusHandler
class	BehaviorContextEvents
class	BehaviorContext
struct	SetResult
struct	OverloadInfo
struct	OverloadVariance
struct	ScopedBehaviorEBusHandler
class	BehaviorInterfaceProxy
class	BehaviorObjectSignalsInterface
struct	OnDemandReflection
struct	OnDemandReflection< AZStd::chrono::duration< Rep, Period > >
class	OnDemandReflectionOwner
class	ReflectContext
class	Attribute
class	AttributeData
class	AttributeMemberData
class	AttributeMemberData< T C::* >
struct	DomInvokeHelper
struct	DomInvokeHelper< AZStd::function< R(Args...)> >
class	AttributeFunction
class	AttributeFunction< R(Args...)>
class	AttributeInvocable
class	AttributeMemberFunction
class	AttributeMemberFunction< R(C::*)(Args...)>
class	AttributeMemberFunction< R(C::*)(Args...) const >
class	ReflectionManager
class	IRttiHelper
struct	HasAZRtti
struct	Adl
struct	AzTypeInfo
class	LuaScriptData
class	ScriptAsset
struct	LuaUserData
class	ScriptDataContext
struct	ScriptValueGeneric
struct	ScriptValueGeneric< T, true >
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< T * >
	Script value implementation for generic pointer types, always prefer pointer types. More...
struct	ScriptValue< int ** >
struct	ScriptValue< char >
struct	ScriptValue< short >
struct	ScriptValue< int >
struct	ScriptValue< AZ::s64 >
struct	ScriptValue< long >
struct	ScriptValue< unsigned char >
struct	ScriptValue< unsigned short >
struct	ScriptValue< unsigned int >
struct	ScriptValue< AZ::u64 >
struct	ScriptValue< unsigned long >
struct	ScriptValue< float >
struct	ScriptValue< double >
struct	ScriptValue< bool >
struct	ScriptValue< const char * >
struct	ScriptValue< void * >
struct	ScriptValue< AZStd::any >
struct	ScriptValue< const AZStd::any & >
struct	ScriptValue< const AZStd::any >
struct	ScriptValue< const AZStd::basic_string< Element, Traits, Allocator > >
struct	ScriptValue< AZStd::basic_string< Element, Traits, Allocator > >
struct	ScriptValue< const AZStd::basic_string< Element, Traits, Allocator > & >
class	ScriptContext
struct	LuaNativeThread
class	ScriptContextDebug
class	ScriptDebug
class	ScriptProperties
class	ScriptProperty
class	FunctionalScriptProperty
class	ScriptPropertyNil
class	ScriptPropertyBoolean
class	ScriptPropertyNumber
class	ScriptPropertyString
class	ScriptPropertyGenericClass
class	ScriptPropertyNumberArray
class	ScriptPropertyBooleanArray
class	ScriptPropertyStringArray
class	ScriptPropertyGenericClassArray
class	ScriptPropertyAsset
class	ScriptPropertySerializer
class	ScriptPropertyGenericClassMap
class	ScriptPropertyGenericClassMapImpl
class	ScriptPropertyTable
class	ScriptPropertyWatcher
class	ScriptPropertyWatcherInterface
struct	ScriptLoadResult
class	ScriptSystemRequests
class	ScriptSystemComponent
class	ScriptTimePoint
	Wrapper that reflects a AZStd::chrono::steady_clock::time_point to script. More...
struct	SerializeGenericTypeInfo< AZStd::vector< T, A > >
	Generic specialization for AZStd::vector. More...
struct	SerializeGenericTypeInfo< AZStd::fixed_vector< T, Capacity > >
	Generic specialization for AZStd::fixed_vector. More...
struct	SerializeGenericTypeInfo< AZStd::list< T, A > >
	Generic specialization for AZStd::list. More...
struct	SerializeGenericTypeInfo< AZStd::forward_list< T, A > >
	Generic specialization for AZStd::forward_list. More...
struct	SerializeGenericTypeInfo< AZStd::array< T, Size > >
	Generic specialization for AZStd::array. More...
struct	SerializeGenericTypeInfo< AZStd::set< K, C, A > >
struct	SerializeGenericTypeInfo< AZStd::unordered_set< K, H, E, A > >
	Generic specialization for AZStd::unordered_set. More...
struct	SerializeGenericTypeInfo< AZStd::unordered_multiset< K, H, E, A > >
	Generic specialization for AZStd::unordered_multiset. More...
struct	SerializeGenericTypeInfo< AZ::Outcome< t_Success, t_Failure > >
	Generic specialization for AZ::Outcome. More...
struct	SerializeGenericTypeInfo< AZStd::pair< T1, T2 > >
	Generic specialization for AZStd::pair. More...
struct	SerializeGenericTypeInfo< AZStd::tuple< Types...> >
	Generic specialization for AZStd::tuple. More...
struct	SerializeGenericTypeInfo< Internal::RValueToLValueWrapper< T > >
	Generic specialization for our internal RValue wrapper.
struct	SerializeGenericTypeInfo< AZStd::map< K, M, C, A > >
	Generic specialization for AZStd::map. More...
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::basic_string< E, T, A > >
	Generic specialization for AZStd::string. 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::bitset< NumBits > >
struct	SerializeGenericTypeInfo< AZStd::shared_ptr< T > >
struct	SerializeGenericTypeInfo< AZStd::intrusive_ptr< T > >
struct	SerializeGenericTypeInfo< AZStd::unique_ptr< T, Deleter > >
struct	SerializeGenericTypeInfo< AZStd::optional< T > >
class	DataOverlayToken
struct	DataOverlayInfo
class	DataOverlayInstanceId
class	DataOverlayInstanceMsgs
class	DataOverlayProviderMsgs
class	DataOverlayTarget
class	DataPatch
struct	DataPatchNodeInfo
class	DataPatchNotifications
	Notifications broadcast by the data patching system. More...
class	DataPatchUpgradeManager
class	DynamicSerializableField
class	EditContext
struct	EnumTypeFromVectorOfEnumConstants
struct	EnumTypeFromVectorOfEnumConstants< AZStd::vector< Edit::EnumConstant< EnumType > > >
struct	ReplaceInvocableReturnType
struct	ReplaceInvocableReturnType< NewReturnType, OldReturnType(Args...)>
class	JsonAnySerializer
class	JsonArraySerializer
class	JsonBaseContext
class	JsonDeserializerContext
class	JsonSerializerContext
class	ScopedContextReporter
class	ScopedContextPath
class	BaseJsonSerializer
class	JsonBasicContainerSerializer
class	JsonBoolSerializer
class	JsonByteStreamSerializer
class	JsonDoubleSerializer
class	JsonFloatSerializer
class	BaseJsonIntegerSerializer
class	JsonCharSerializer
class	JsonShortSerializer
class	JsonIntSerializer
class	JsonLongSerializer
class	JsonLongLongSerializer
class	JsonUnsignedCharSerializer
class	JsonUnsignedShortSerializer
class	JsonUnsignedIntSerializer
class	JsonUnsignedLongSerializer
class	JsonUnsignedLongLongSerializer
class	JsonDeserializer
class	BaseJsonImporter
class	JsonImportResolver
struct	JsonImportSettings
class	JsonMerger
class	JsonSerialization
class	JsonSerializationMetadata
	Holds a collection of generic settings objects to be used by custom serializers. More...
struct	JsonDeserializerSettings
	Optional settings used while loading a json value to an object. More...
struct	JsonSerializerSettings
	Optional settings used while storing an object to a json value. More...
struct	JsonApplyPatchSettings
	Optional settings used while applying a patch to a json value. More...
struct	JsonCreatePatchSettings
	Optional settings used while creating a patch for a json value. More...
class	JsonSerializer
class	JsonSystemComponent
class	JsonMapSerializer
class	JsonUnorderedMapSerializer
class	JsonUnorderedMultiMapSerializer
class	JsonPathSerializer
class	JsonRegistrationContext
class	JsonSmartPointerSerializer
class	StackedString
class	ScopedStackedString
	Scoped object that manages the life cycle of a single entry on the string stack. More...
class	JsonStringSerializer
class	JsonOSStringSerializer
class	JsonTupleSerializer
class	JsonUnorderedSetContainerSerializer
class	JsonUnsupportedTypesSerializer
class	JsonVariantSerializer
class	JsonOptionalSerializer
class	JsonBitsetSerializer
class	DataStream
class	ObjectStream
class	SerializeContext
class	GenericClassInfo
struct	SerializeGenericTypeInfo
struct	AnyTypeInfoConcept
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	AnyTypeInfoConcept< ValueType, AZStd::enable_if_t< AZStd::is_abstract< ValueType >::value > >
struct	SerializeTypeInfo
class	CommandLine
class	ConfigurableStackInterface
class	ConfigurableStack
struct	SerializeGenericTypeInfo< ConfigurableStack< StackBaseType > >
class	JsonConfigurableStackSerializer
class	SettingsRegistryInterface
class	SettingsRegistryImpl
class	SettingsRegistryOriginTracker
class	SliceAsset
class	DynamicSliceAsset
class	SliceAssetHandler
class	SliceEvents
class	SliceInstanceEvents
class	SliceAssetSerializationNotifications
class	SliceEntityHierarchyInterface
class	SliceComponent
class	SliceMetadataInfoRequests
class	SliceMetadataInfoManipulationRequests
class	SliceMetadataInfoNotifications
class	SliceMetadataInfoComponent
class	SliceSystemComponent
class	HSM
struct	TaskDescriptor
class	TaskExecutor
class	TaskGraphActiveInterface
class	TaskToken
class	TaskGraphEvent
class	TaskGraph
class	TaskGraphSystemComponent
class	ThreadSafeDeque
class	ThreadSafeObject
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	TimeSystem
	Implementation of the ITime system interface. More...
class	MockTimeSystem
class	StubTimeSystem
class	MockSettingsRegistry
class	UserSettings
class	UserSettingsFileLocator
class	UserSettingsComponentRequests
class	UserSettingsComponent
class	UserSettingsMessages
class	UserSettingsOwnerRequests
class	UserSettingsNotifications
struct	UserSettingsContainer
class	UserSettingsProvider
class	SharedMemory_Unimplemented
class	BetterPseudoRandom_UnixLike
class	SharedMemory_Mac
class	SharedMemory_Windows
class	BetterPseudoRandom_Windows

Typedefs
using	AssetTypeInfoBus = AZ::EBus< AssetTypeInfo >
typedef int8_t	s8
typedef uint8_t	u8
typedef int16_t	s16
typedef uint16_t	u16
typedef int32_t	s32
typedef uint32_t	u32
typedef int64_t	s64
typedef uint64_t	u64
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 >
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	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	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	ChildChangeType { Added, Removed }
enum	OnParentChangedBehavior : AZ::u8 { OnParentChangedBehavior::Update, OnParentChangedBehavior::DoNotUpdate }
	Used to control the behavior of an entity's transform when its parent's transform changes at runtime. More...
enum	ThreadSafety { RequiresLock, UseStdAtomic }
enum	GetValueResult { Success, NotImplemented, TypeNotConvertible, ConsoleVarNotFound }
enum	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	ConsoleSilentMode { Silent, NotSilent }
enum	ConsoleInvokedFrom { AzConsole, AzNetworking, CryBinding }
enum	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	EBusAddressPolicy { EBusAddressPolicy::Single, EBusAddressPolicy::ById, EBusAddressPolicy::ByIdAndOrdered }
enum	EBusHandlerPolicy { EBusHandlerPolicy::Single, EBusHandlerPolicy::Multiple, EBusHandlerPolicy::MultipleAndOrdered }
enum	InterpolationMode : u32 { NoInterpolation, LinearInterpolation }
enum	IntegralTypeDiff {   IntegralTypeDiff::LSignedRSignedEqSize, IntegralTypeDiff::LSignedRUnsignedEqSize, IntegralTypeDiff::LUnsignedRSignedEqSize, IntegralTypeDiff::LUnsignedRUnsignedEqSize,   IntegralTypeDiff::LSignedRSignedLWider, IntegralTypeDiff::LSignedRUnsignedLWider, IntegralTypeDiff::LUnsignedRSignedLWider, IntegralTypeDiff::LUnsignedRUnsignedLWider,   IntegralTypeDiff::LSignedRSignedRWider, IntegralTypeDiff::LSignedRUnsignedRWider, IntegralTypeDiff::LUnsignedRSignedRWider, IntegralTypeDiff::LUnsignedRUnsignedRWider }
	Enumerations to describe the sign and size relationship between two integer types. More...
enum	IntegralCompare { LessThan, Equal, GreaterThan }
	Comparison result returned by SafeIntegralCompare.
enum	IntersectResult { Interior, Overlaps, Exterior }
	Intersection classifications.
enum	RandomDistributionType : AZ::u32 { Normal, UniformReal }
enum	ModuleInitializationSteps : u8 {   ModuleInitializationSteps::None, ModuleInitializationSteps::Load, ModuleInitializationSteps::CreateClass, ModuleInitializationSteps::RegisterComponentDescriptors,   ModuleInitializationSteps::ActivateEntity }
enum	PlatformID {   PLATFORM_WINDOWS_64, PLATFORM_LINUX_64, PLATFORM_APPLE_IOS, PLATFORM_APPLE_MAC,   PLATFORM_ANDROID_64, PlatformID::PLATFORM_MAX }
enum	AttributeIsValid : AZ::u8 { IfPresent }
enum	eBehaviorBusForwarderEventIndices { Result, UserData, ParameterFirst, Count }
enum	VariantOnThis { No, Yes }
enum	RttiKind { None, Intrusive, External }
enum	TypeTraits : AZ::u64 {   TypeTraits::is_signed = 0b1, TypeTraits::is_unsigned = 0b10, TypeTraits::is_enum = 0b100, TypeTraits::is_pointer = 0b1000,   TypeTraits::is_template = 0b10000 }
enum	AcquisitionOnPush { None, ScriptAcquire }
enum	ObjectToLua { ByReference, ByValue }
enum	ScriptContextIds : ScriptContextId { DefaultScriptContextId = 0, CryScriptContextId = 1 }
enum	ImportTracking : AZ::u8 { None = 0, Dependencies = (1<<0), Imports = (1<<1), All = (Dependencies | Imports) }
enum	JsonMergeApproach { JsonMergeApproach::JsonPatch, JsonMergeApproach::JsonMergePatch }
enum	JsonSerializerCompareResult { Less, Equal, Greater, Error }
enum	ObjectStreamWriteOverrideResponse { CompletedWrite, FallbackToDefaultWrite, AbortWrite }
enum	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.
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. More...
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)
bool	IsBigEndian (PlatformID)
const char *	GetPlatformName (PlatformID platform)
	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)
	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 (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. More...
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)

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"
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	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

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.

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

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

extern "C" AZ_DLL_EXPORT
AZ::Module* CreateModuleClass()

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

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

Function signature for static module registrars.

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().

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

using AZ::DynamicPrefabAsset = typedef DynamicSliceAsset

Deprecated:

Use DynamicSliceAsset.

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.

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

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

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.

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

Type for storing module references.

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

using AZ::PrefabAsset = typedef SliceAsset

Deprecated:

Use SliceAsset.

using AZ::PrefabBus = typedef SliceBus

Deprecated:

Use SliceBus.

typedef SliceComponent AZ::PrefabComponent

Deprecated:

Use SliceComponent.

Deprecated:

Use SliceComponent.

Deprecated:

Use SliceComponent.

using AZ::PrefabEvents = typedef SliceEvents

Deprecated:

Use SliceEvents.

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.

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

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

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

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

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

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

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

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.

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

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

typedef AZ::Uuid AZ::TypeId

Used to reference unique types by their unique id.

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

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.

enum 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.

enum 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.

enum 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.

enum AZ::InterpolationMode : u32

strong

Behavior types for smoothing of transform between network updates.

enum 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.

enum 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.

enum 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.

enum AZ::PlatformID

strong

Enum of supported platforms. Just for user convenience.

Enumerator
PLATFORM_MAX	Must be last.

enum 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.

enum 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.

enum 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

AZ_MATH_INLINE float AZ::Abs

(

float

value

)

Simd optimized math functions.

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.

constexpr size_t AZ::AlignUpToPowerOfTwo ( size_t  value )

inline

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::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

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.

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.

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.

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.

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.

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.

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.

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.

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

Quaternion AZ::CreateRandomQuaternion

(

SimpleLcgRandom &

rng

)

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

template<typename T >

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

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

template<bool handleEvent>

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

Default empty handler.

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

(

)

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

template<class ValueT , class >

constexpr AZStd::unexpected< ValueT > AZ::Failure

(

ValueT &&

rhs

)

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

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.

template<typename T >

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

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.

template<typename T >

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

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.

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>()))

constexpr bool AZ::IsPowerOfTwo

(

uint32_t

testValue

)

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

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.

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

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

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

void AZ::MathReflect

(

ReflectContext *

context

)

Reflect different aspects of math (depending on context)

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

template<typename T >

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

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

template<typename LeftType , typename RightType >

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

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.

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.

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

constexpr AZStd::in_place_t AZ::Success

(

)

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

template<class ValueT , class >

constexpr ValueT AZ::Success

(

ValueT &&

rhs

)

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

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

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

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

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

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

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

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

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

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

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

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

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

AZ_MATH_INLINE Vector3 AZ::Vector3RadToDeg

(

const AZ::Vector3 &

radians

)

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

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

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

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

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

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

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

static

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