Open 3D Engine AzCore API Reference  22.10.0
O3DE is an open-source, fully-featured, high-fidelity, modular 3D engine for building games and simulations, available to every industry.
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
AZ Namespace Reference

Reopen namespace to define DataPatch class. More...

Namespaces

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

Classes

class  Aabb
 
class  AllocatorBase
 
struct  AllocatorDebugConfig
 
class  AllocatorInstance
 
class  AllocatorManager
 
class  AllocatorScope
 
class  AllocatorWrapper
 
struct  AnyTypeInfoConcept
 
struct  AnyTypeInfoConcept< ValueType, AZStd::enable_if_t< AZStd::is_abstract< ValueType >::value > >
 
struct  AnyTypeInfoConcept< ValueType, AZStd::enable_if_t<!AZStd::is_abstract< ValueType >::value &&!AZStd::Internal::template_is_copy_constructible< ValueType >::value > >
 
struct  AnyTypeInfoConcept< ValueType, AZStd::enable_if_t<!AZStd::is_abstract< ValueType >::value &&AZStd::Internal::template_is_copy_constructible< ValueType >::value > >
 
struct  ApplicationTypeQuery
 
class  AssetManagerComponent
 
class  AssetSerializer
 
class  AssetTypeInfo
 
class  Attribute
 
class  AttributeData
 
class  AttributeFunction
 
class  AttributeFunction< R(Args...)>
 
class  AttributeInvocable
 
class  AttributeInvoker
 
class  AttributeMemberData
 
class  AttributeMemberData< T C::* >
 
class  AttributeMemberFunction
 
class  AttributeMemberFunction< R(C::*)(Args...) const >
 
class  AttributeMemberFunction< R(C::*)(Args...)>
 
class  AttributeReader
 
struct  auto_partitioner
 
class  AzCoreModule
 
class  AZStdAlloc
 
class  AZStdFunctorAllocator
 
class  AZStdIAllocator
 
class  AzStdReflectionComponent
 
struct  AzTypeInfo
 
struct  AzTypeInfo< R C::*, false >
 
struct  AzTypeInfo< R(Args...), false >
 
struct  AzTypeInfo< R(C::*)(Args...) const, false >
 
struct  AzTypeInfo< R(C::*)(Args...), false >
 
struct  AzTypeInfo< T, false >
 
struct  AzTypeInfo< T, true >
 
class  BaseJsonImporter
 
class  BaseJsonIntegerSerializer
 
class  BaseJsonMatrixSerializer
 
class  BaseJsonSerializer
 
class  BaseJsonVectorSerializer
 
struct  BehaviorArgument
 
struct  BehaviorAzEventDescription
 
class  BehaviorClass
 
class  BehaviorContext
 
class  BehaviorContextEvents
 
class  BehaviorDefaultValue
 
class  BehaviorEBus
 
struct  BehaviorEBusEventSender
 
class  BehaviorEBusHandler
 
class  BehaviorInterfaceProxy
 
class  BehaviorMethod
 
struct  BehaviorObject
 
class  BehaviorObjectSignalsInterface
 
struct  BehaviorParameter
 
struct  BehaviorParameterMetadata
 
struct  BehaviorParameterOverrides
 
class  BehaviorProperty
 
class  BehaviorValues
 
class  BestFitExternalMapAllocator
 
class  BestFitExternalMapSchema
 
class  BetterPseudoRandom_UnixLike
 
class  BetterPseudoRandom_Windows
 
class  BezierSpline
 
struct  BranchOnResultInfo
 
class  Capsule
 A class representing a capsule (a cylinder with a hemispherical cap at each end). More...
 
class  CatmullRomSpline
 
struct  CheckedOperationInfo
 
class  ChildAllocatorSchema
 
struct  ClampedIntegralLimits
 A collection of methods for clamping and constraining integer values and ranges to that of a reference integer type. More...
 
class  Color
 A color class with 4 components, RGBA. More...
 
class  CommandLine
 
struct  CompareScheduledEventPtrs
 
class  Component
 
class  ComponentApplication
 
class  ComponentApplicationRequests
 Interface that components can use to make requests of the main application. More...
 
class  ComponentApplicationRequestsEBusTraits
 
class  ComponentBus
 
class  ComponentConfig
 
class  ComponentDescriptor
 
struct  ComponentDescriptorBusTraits
 
class  ComponentDescriptorDefault
 
class  ComponentDescriptorHelper
 
class  ConfigurableStack
 
class  ConfigurableStackInterface
 
class  Console
 
class  ConsoleDataContainer
 
class  ConsoleDataContainer< BASE_TYPE, ThreadSafety::RequiresLock >
 
class  ConsoleDataContainer< BASE_TYPE, ThreadSafety::UseStdAtomic >
 
class  ConsoleDataWrapper
 
class  ConsoleFunctor
 Console functor which wraps a function call into an object instance. More...
 
class  ConsoleFunctor< void, _REPLICATES_VALUE >
 
class  ConsoleFunctorBase
 
struct  ConsoleReplicateHelper
 
struct  ConsoleReplicateHelper< _TYPE, false >
 
struct  ConsoleReplicateHelper< _TYPE, true >
 
class  Crc32
 
struct  DataOverlayInfo
 
class  DataOverlayInstanceId
 
class  DataOverlayInstanceMsgs
 
class  DataOverlayProviderMsgs
 
class  DataOverlayTarget
 
class  DataOverlayToken
 
class  DataPatch
 
struct  AddressType
 
class  AddressTypeElement
 
class  AddressTypeSerializer
 
struct  has_common_type_helper
 
struct  has_common_type_helper< AZStd::void_t< std::common_type_t< Types... > >, Types... >
 
struct  DataPatchNodeInfo
 
class  DataPatchNotifications
 Notifications broadcast by the data patching system. More...
 
class  DataPatchUpgradeManager
 
class  DataStream
 
struct  DefaultFailure
 
struct  DefaultFailure< void >
 
class  DeprecatedComponentMetadata
 
struct  AzDeprecatedTypeNameVisitor
 
struct  AzDeprecatedTypeNameVisitor< AZStd::tuple< Types... > >
 
struct  AzDeprecatedTypeNameVisitor< R(Args...)>
 
struct  AzDeprecatedTypeNameVisitor< T & >
 
struct  AzDeprecatedTypeNameVisitor< T && >
 
struct  AzDeprecatedTypeNameVisitor< T * >
 
struct  AzDeprecatedTypeNameVisitor< T const & >
 
struct  AzDeprecatedTypeNameVisitor< T const && >
 
struct  AzDeprecatedTypeNameVisitor< T const >
 
struct  DomInvokeHelper
 
struct  DomInvokeHelper< AZStd::function< R(Args...)> >
 
class  DynamicModuleDescriptor
 
class  DynamicModuleHandle
 
class  DynamicSerializableField
 
class  DynamicSliceAsset
 
class  EBus
 
struct  EBusAggregateResults
 
struct  EBusConnectionPolicy
 
class  EBusEnvironment
 
struct  EBusEnvironmentStoragePolicy
 
struct  EBusEventProcessingPolicy
 
struct  EBusGlobalStoragePolicy
 
struct  EBusQueuePolicy
 
struct  EBusQueuePolicy< true, Bus, MutexType >
 
struct  EBusReduceResult
 
struct  EBusReduceResult< T &, Aggregator >
 
class  EBusSharedDispatchMutex
 
class  EBusSharedDispatchMutexCallstackLockGuard
 
class  EBusSharedDispatchMutexConnectLockGuard
 
class  EBusSharedDispatchMutexDispatchLockGuard
 
struct  EBusSharedDispatchTraits
 
struct  EBusThreadLocalStoragePolicy
 
struct  EBusTraits
 
class  EditContext
 
class  Entity
 
class  EntityComponentIdPair
 
class  EntityEvents
 
class  EntityId
 
class  EntitySystemEvents
 
class  EnvironmentVariable
 EnvironmentVariable holds a pointer to the actual variable, it should be used as any smart pointer. Event though most of the it will be "static" as it's treated as a global. More...
 
class  Event
 
class  EventHandler
 A handler class that can connect to an Event. More...
 
struct  EventHandlerCreationFunctionHolder
 
class  EventSchedulerSystemComponent
 This is scheduled event queue class to run all scheduled events at appropriate intervals. More...
 
struct  ExplicitOverloadInfo
 
struct  ExportedComponent
 
class  FixedVertices
 
class  FloatArrayTextSerializer
 
class  FloatBasedContainerSerializer
 Custom template to cover all fundamental AZMATH classes. More...
 
class  Frustum
 A frustum class that can be used for efficient primitive intersection tests. More...
 
class  FunctionalScriptProperty
 
class  GenericClassInfo
 
class  HaltonSequence
 
struct  HasAZRtti
 
struct  HasAZRttiExternal
 
class  HeapSchema
 
class  HphaSchema
 
class  HphaSchemaBase
 
class  HSM
 
class  IAllocator
 
class  IAllocatorSchema
 
class  IConsole
 
class  IEventScheduler
 This is an AZ::Interface<> for managing scheduled events. Users should not require any direct interaction with this interface, ScheduledEvent is a self contained abstraction. More...
 
class  IEventSchedulerRequests
 
class  ILogger
 This is an AZ::Interface<> for logging. Usage: #include <AzCore/Console/ILogger.h> AZLOG_INFO("Your message here"); AZLOG_WARN("Your warn message here");. More...
 
class  ILoggerRequests
 
struct  InputRestriction
 
class  Interface
 
class  IRttiHelper
 
struct  Iterator_VM
 
class  Iterator_VM< AZStd::unordered_map< t_Key, t_Value, t_Hasher, t_EqualKey, t_Allocator > >
 
class  Iterator_VM< AZStd::unordered_set< t_Key, t_Hasher, t_EqualKey, t_Allocator > >
 
class  Iterator_VM< AZStd::vector< t_Value, t_Allocator > >
 
class  ITime
 This is an AZ::Interface<> for managing time related operations. AZ::ITime and associated types may not operate in realtime. These abstractions are to allow our application simulation to operate both slower and faster than realtime in a well defined and user controllable manner The rate at which time passes for AZ::ITime is controlled by the cvar t_simulationTickScale t_simulationTickScale == 0 means simulation time should halt 0 < t_simulationTickScale < 1 will cause time to pass slower than realtime, with t_simulationTickScale 0.1 being roughly 1/10th realtime t_simulationTickScale == 1 will cause time to pass at roughly realtime t_simulationTickScale > 1 will cause time to pass faster than normal, with t_simulationTickScale 10 being roughly 10x realtime. More...
 
class  ITimeRequests
 
class  Job
 
class  JobCancelGroup
 
class  JobCompletion
 
class  JobCompletionSpin
 
class  JobContext
 
class  JobEmpty
 
class  JobFunction
 
class  JobManager
 
class  JobManagerComponent
 
struct  JobManagerDesc
 
class  JobManagerEvents
 
struct  JobManagerThreadDesc
 
class  JsonAnySerializer
 
struct  JsonApplyPatchSettings
 Optional settings used while applying a patch to a json value. More...
 
class  JsonArraySerializer
 
class  JsonBaseContext
 
class  JsonBasicContainerSerializer
 
class  JsonBitsetSerializer
 
class  JsonBoolSerializer
 
class  JsonByteStreamSerializer
 
class  JsonCharSerializer
 
class  JsonColorSerializer
 
class  JsonConfigurableStackSerializer
 
struct  JsonCreatePatchSettings
 Optional settings used while creating a patch for a json value. More...
 
class  JsonDeserializer
 
class  JsonDeserializerContext
 
struct  JsonDeserializerSettings
 Optional settings used while loading a json value to an object. More...
 
class  JsonDoubleSerializer
 
class  JsonEntityIdSerializer
 
class  JsonEntitySerializer
 
class  JsonFloatSerializer
 
class  JsonImportResolver
 
struct  JsonImportSettings
 
class  JsonIntSerializer
 
class  JsonLongLongSerializer
 
class  JsonLongSerializer
 
class  JsonMapSerializer
 
class  JsonMatrix3x3Serializer
 
class  JsonMatrix3x4Serializer
 
class  JsonMatrix4x4Serializer
 
class  JsonMerger
 
class  JsonOptionalSerializer
 
class  JsonOSStringSerializer
 
class  JsonPathSerializer
 
class  JsonQuaternionSerializer
 
class  JsonRegistrationContext
 
class  JsonSerialization
 
class  JsonSerializationMetadata
 Holds a collection of generic settings objects to be used by custom serializers. More...
 
class  JsonSerializer
 
class  JsonSerializerContext
 
struct  JsonSerializerSettings
 Optional settings used while storing an object to a json value. More...
 
class  JsonShortSerializer
 
class  JsonSmartPointerSerializer
 
class  JsonStringSerializer
 
class  JsonSystemComponent
 
class  JsonTransformSerializer
 
class  JsonTupleSerializer
 
class  JsonUnorderedMapSerializer
 
class  JsonUnorderedMultiMapSerializer
 
class  JsonUnorderedSetContainerSerializer
 
class  JsonUnsignedCharSerializer
 
class  JsonUnsignedIntSerializer
 
class  JsonUnsignedLongLongSerializer
 
class  JsonUnsignedLongSerializer
 
class  JsonUnsignedShortSerializer
 
class  JsonUnsupportedTypesSerializer
 
class  JsonUuidSerializer
 
class  JsonVariantSerializer
 
class  JsonVector2Serializer
 
class  JsonVector3Serializer
 
class  JsonVector4Serializer
 
class  LinearlyInterpolatedSample
 
class  LinearlyInterpolatedSample< Quaternion >
 
class  LinearlyInterpolatedSample< Vector3 >
 
class  LinearSpline
 
class  LineSegment
 LineSegment defined by two Vector3, an start and a end. More...
 
class  LoggerSystemComponent
 Implementation of the ILogger system interface. More...
 
class  LossyCasted
 
struct  LuaNativeThread
 
class  LuaScriptData
 
struct  LuaUserData
 
class  MallocSchema
 
class  Matrix3x3
 
class  Matrix3x4
 
class  Matrix4x4
 
class  MemoryComponent
 
class  MockSettingsRegistry
 
class  MockTimeSystem
 
class  Module
 
struct  ModuleData
 
struct  ModuleDataImpl
 
class  ModuleEntity
 
class  ModuleManager
 
class  ModuleManagerRequests
 Requests related to module reloading. More...
 
class  MultipleDependentJob
 
class  Name
 
class  NamedEntityId
 
class  NameDictionary
 
class  NameJsonSerializer
 
class  NameRef
 
class  NameSerializer
 Provides flattened serialization of Name objects as a simple string. More...
 
class  NonUniformScaleRequests
 Requests for working with non-uniform scale. More...
 
struct  NullBusId
 
struct  NullMutex
 
class  NumericCasted
 
class  Obb
 An oriented bounding box. More...
 
class  ObjectStream
 
struct  OnDemandReflection
 
struct  OnDemandReflection< AZ::Event< T... > >
 
struct  OnDemandReflection< AZ::Outcome< ValueT, ErrorT > >
 
struct  OnDemandReflection< AZ::Outcome< ValueT, void > >
 
struct  OnDemandReflection< AZ::Outcome< void, ErrorT > >
 
struct  OnDemandReflection< AZ::Outcome< void, void > >
 
struct  OnDemandReflection< AZStd::any >
 
struct  OnDemandReflection< AZStd::array< T, N > >
 OnDemand reflection for AZStd::array. More...
 
struct  OnDemandReflection< AZStd::basic_string< Element, Traits, Allocator > >
 OnDemand reflection for AZStd::basic_string. More...
 
struct  OnDemandReflection< AZStd::basic_string_view< Element, Traits > >
 OnDemand reflection for AZStd::basic_string_view. More...
 
struct  OnDemandReflection< AZStd::intrusive_ptr< T > >
 OnDemand reflection for AZStd::intrusive_ptr. More...
 
struct  OnDemandReflection< AZStd::optional< T > >
 
struct  OnDemandReflection< AZStd::pair< T1, T2 > >
 
struct  OnDemandReflection< AZStd::shared_ptr< T > >
 OnDemand reflection for AZStd::shared_ptr. More...
 
struct  OnDemandReflection< AZStd::tuple< T... > >
 
struct  OnDemandReflection< AZStd::unordered_map< Key, MappedType, Hasher, EqualKey, Allocator > >
 OnDemand reflection for AZStd::unordered_map. More...
 
struct  OnDemandReflection< AZStd::unordered_set< Key, Hasher, EqualKey, Allocator > >
 OnDemand reflection for AZStd::unordered_set. More...
 
struct  OnDemandReflection< AZStd::vector< T, A > >
 OnDemand reflection for AZStd::vector. More...
 
struct  OnDemandReflection< Data::Asset< T > >
 OnDemandReflection for any generic Data::Asset<T> More...
 
class  OnDemandReflectionOwner
 
class  OrderedEvent
 
class  OrderedEventHandler
 A handler class that can connect to an Event that will be called in order based on priority. More...
 
class  OSAllocator
 
class  Outcome
 
struct  OverloadArgumentGroupInfo
 
struct  OverloadInfo
 
struct  OverloadVariance
 
class  OverrunDetectionAllocator
 
class  OverrunDetectionSchema
 
class  PackedVector3
 
class  Plane
 
class  PlatformHelper
 Platform Helper is an utility class that can be used to retrieve platform related information. More...
 
class  PolygonPrism
 
class  PoolAllocation
 
class  PoolAllocator
 
class  PoolSchema
 
struct  PositionSplineQueryResult
 
struct  PrioritizeScheduledEventPtrs
 
class  Quaternion
 
class  Ray
 Ray defined by two Vector3, an orign and a normalized direction. More...
 
struct  RaySplineQueryResult
 
class  ReflectContext
 
class  ReflectionEnvironment
 
class  ReflectionManager
 
struct  s128
 
class  Sample
 
class  ScheduledEvent
 
struct  ScheduledEventHandle
 
struct  ScopedBehaviorEBusHandler
 
class  ScopedBehaviorOnDemandReflector
 
class  ScopedContextPath
 
class  ScopedContextReporter
 
class  ScopedStackedString
 Scoped object that manages the life cycle of a single entry on the string stack. More...
 
class  ScriptAsset
 
class  ScriptContext
 
class  ScriptContextDebug
 
class  ScriptDataContext
 
class  ScriptDebug
 
struct  ScriptLoadResult
 
class  ScriptProperties
 
class  ScriptProperty
 
class  ScriptPropertyAsset
 
class  ScriptPropertyBoolean
 
class  ScriptPropertyBooleanArray
 
class  ScriptPropertyGenericClass
 
class  ScriptPropertyGenericClassArray
 
class  ScriptPropertyGenericClassMap
 
class  ScriptPropertyGenericClassMapImpl
 
class  ScriptPropertyNil
 
class  ScriptPropertyNumber
 
class  ScriptPropertyNumberArray
 
class  ScriptPropertySerializer
 
class  ScriptPropertyString
 
class  ScriptPropertyStringArray
 
class  ScriptPropertyTable
 
class  ScriptPropertyWatcher
 
class  ScriptPropertyWatcherInterface
 
class  ScriptSystemComponent
 
class  ScriptSystemRequests
 
class  ScriptTimePoint
 Wrapper that reflects a AZStd::chrono::system_clock::time_point to script. More...
 
struct  ScriptValue
 Script value implementation for all value and reference types. The push Function will always create an object COPY, this will be slower than just using pointers. More...
 
struct  ScriptValue< AZ::s64 >
 
struct  ScriptValue< AZ::u64 >
 
struct  ScriptValue< AZStd::any >
 
struct  ScriptValue< AZStd::basic_string< Element, Traits, Allocator > >
 
struct  ScriptValue< bool >
 
struct  ScriptValue< char >
 
struct  ScriptValue< const AZStd::any & >
 
struct  ScriptValue< const AZStd::any >
 
struct  ScriptValue< const AZStd::basic_string< Element, Traits, Allocator > & >
 
struct  ScriptValue< const AZStd::basic_string< Element, Traits, Allocator > >
 
struct  ScriptValue< const char * >
 
struct  ScriptValue< double >
 
struct  ScriptValue< float >
 
struct  ScriptValue< int ** >
 
struct  ScriptValue< int >
 
struct  ScriptValue< long >
 
struct  ScriptValue< short >
 
struct  ScriptValue< T * >
 Script value implementation for generic pointer types, always prefer pointer types. More...
 
struct  ScriptValue< unsigned char >
 
struct  ScriptValue< unsigned int >
 
struct  ScriptValue< unsigned long >
 
struct  ScriptValue< unsigned short >
 
struct  ScriptValue< void * >
 
struct  ScriptValueGeneric
 
struct  ScriptValueGeneric< T, true >
 
class  SerializeContext
 
struct  SerializeGenericTypeInfo
 
struct  SerializeGenericTypeInfo< AZ::Outcome< t_Success, t_Failure > >
 Generic specialization for AZ::Outcome. More...
 
struct  SerializeGenericTypeInfo< AZStd::array< T, Size > >
 Generic specialization for AZStd::array. More...
 
struct  SerializeGenericTypeInfo< AZStd::basic_string< E, T, A > >
 Generic specialization for AZStd::string. More...
 
struct  SerializeGenericTypeInfo< AZStd::bitset< NumBits > >
 
struct  SerializeGenericTypeInfo< AZStd::fixed_vector< T, Capacity > >
 Generic specialization for AZStd::fixed_vector. More...
 
struct  SerializeGenericTypeInfo< AZStd::forward_list< T, A > >
 Generic specialization for AZStd::forward_list. More...
 
struct  SerializeGenericTypeInfo< AZStd::intrusive_ptr< T > >
 
struct  SerializeGenericTypeInfo< AZStd::list< T, A > >
 Generic specialization for AZStd::list. More...
 
struct  SerializeGenericTypeInfo< AZStd::map< K, M, C, A > >
 Generic specialization for AZStd::map. More...
 
struct  SerializeGenericTypeInfo< AZStd::optional< T > >
 
struct  SerializeGenericTypeInfo< AZStd::pair< T1, T2 > >
 Generic specialization for AZStd::pair. More...
 
struct  SerializeGenericTypeInfo< AZStd::set< K, C, A > >
 
struct  SerializeGenericTypeInfo< AZStd::shared_ptr< T > >
 
struct  SerializeGenericTypeInfo< AZStd::tuple< Types... > >
 Generic specialization for AZStd::tuple. More...
 
struct  SerializeGenericTypeInfo< AZStd::unique_ptr< T, Deleter > >
 
struct  SerializeGenericTypeInfo< AZStd::unordered_map< K, M, H, E, A > >
 Generic specialization for AZStd::unordered_map. More...
 
struct  SerializeGenericTypeInfo< AZStd::unordered_multimap< K, M, H, E, A > >
 Generic specialization for AZStd::unordered_multimap. More...
 
struct  SerializeGenericTypeInfo< AZStd::unordered_multiset< K, H, E, A > >
 Generic specialization for AZStd::unordered_multiset. More...
 
struct  SerializeGenericTypeInfo< AZStd::unordered_set< K, H, E, A > >
 Generic specialization for AZStd::unordered_set. More...
 
struct  SerializeGenericTypeInfo< AZStd::vector< AZ::u8, A > >
 Generic specialization for AZStd::vector<AZ::u8,Allocator> byte stream. If this conflics with a normal vector<unsigned char> create a new type. More...
 
struct  SerializeGenericTypeInfo< AZStd::vector< T, A > >
 Generic specialization for AZStd::vector. More...
 
struct  SerializeGenericTypeInfo< ConfigurableStack< StackBaseType > >
 
struct  SerializeGenericTypeInfo< Data::Asset< T > >
 
struct  SerializeGenericTypeInfo< Internal::RValueToLValueWrapper< T > >
 Generic specialization for our internal RValue wrapper.
 
struct  SerializeTypeInfo
 
struct  SetResult
 
class  SettingsRegistryImpl
 
class  SettingsRegistryInterface
 
class  SettingsRegistryOriginTracker
 
class  Sfmt
 
class  Sha1
 
class  SharedMemory
 
class  SharedMemory_Common
 
class  SharedMemory_Mac
 
class  SharedMemory_Unimplemented
 
class  SharedMemory_Windows
 
class  SharedMemoryRingBuffer
 
struct  simple_partitioner
 
class  SimpleLcgRandom
 
class  SimpleSchemaAllocator
 
struct  SizeType
 
struct  SizeType< 0, false >
 
struct  SizeType< 0, true >
 
struct  SizeType< 1, false >
 
struct  SizeType< 1, true >
 
struct  SizeType< 2, false >
 
struct  SizeType< 2, true >
 
struct  SizeType< 3, false >
 
struct  SizeType< 3, true >
 
struct  SizeType< 4, false >
 
struct  SizeType< 4, true >
 
struct  SizeType< 5, false >
 
struct  SizeType< 5, true >
 
struct  SizeType< 6, false >
 
struct  SizeType< 6, true >
 
struct  SizeType< 7, false >
 
struct  SizeType< 7, true >
 
struct  SizeType< 8, false >
 
struct  SizeType< 8, true >
 
class  SliceAsset
 
class  SliceAssetHandler
 
class  SliceAssetSerializationNotifications
 
class  SliceComponent
 
class  SliceEntityHierarchyInterface
 
class  SliceEvents
 
class  SliceInstanceEvents
 
class  SliceMetadataInfoComponent
 
class  SliceMetadataInfoManipulationRequests
 
class  SliceMetadataInfoNotifications
 
class  SliceMetadataInfoRequests
 
class  SliceSystemComponent
 
class  Sphere
 A simple bounding sphere class for fast intersection testing. More...
 
class  Spline
 
struct  SplineAddress
 
class  StackedString
 
struct  static_partitioner
 
class  StreamerComponent
 
class  structured_task_group
 
class  StubTimeSystem
 
class  SystemAllocator
 
class  SystemTickEvents
 
struct  TaskDescriptor
 
class  TaskExecutor
 
class  TaskGraph
 
class  TaskGraphActiveInterface
 
class  TaskGraphEvent
 
class  TaskGraphSystemComponent
 
class  TaskToken
 
class  ThreadPoolAllocator
 
class  ThreadPoolSchema
 
class  ThreadPoolSchemaHelper
 
class  ThreadSafeDeque
 
class  ThreadSafeObject
 
class  TickEvents
 
class  TickRequests
 
class  TimeSystem
 Implementation of the ITime system interface. More...
 
class  Transform
 
class  TransformConfig
 Component configuration for the transform component. More...
 
class  TransformInterface
 
class  TransformNotification
 
struct  CanonicalTypeIdTag
 
struct  GenericTypeIdTag
 
struct  PointerRemovedTypeIdTag
 
struct  u128
 
class  UninterpolatedSample
 
class  UninterpolatedSample< Quaternion >
 
class  UninterpolatedSample< Vector3 >
 
class  UserSettings
 
class  UserSettingsComponent
 
class  UserSettingsComponentRequests
 
struct  UserSettingsContainer
 
class  UserSettingsFileLocator
 
class  UserSettingsMessages
 
class  UserSettingsNotifications
 
class  UserSettingsOwnerRequests
 
class  UserSettingsProvider
 
struct  Uuid
 
class  UuidSerializer
 
class  VariableVertices
 
class  Vector2
 2-dimensional vector class. More...
 
class  Vector3
 3-dimensional vector class. More...
 
class  Vector4
 
class  VertexContainer
 
class  VertexContainerNotificationInterface
 
class  VertexRequests
 EBus traits for vertex requests. More...
 
struct  ViewFrustumAttributes
 Attributes required to construct a Frustum from a view volume. More...
 
class  ZLib
 
class  ZStd
 

Typedefs

using AssetTypeInfoBus = AZ::EBus< AssetTypeInfo >
 
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 >
 
typedef AZ::EBus< ComponentDescriptor, ComponentDescriptorBusTraitsComponentDescriptorBus
 
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< EntitySystemEventsEntitySystemBus
 
typedef AZ::EBus< EntityEventsEntityBus
 
using NonUniformScaleChangedEvent = AZ::Event< const AZ::Vector3 & >
 
using NonUniformScaleRequestBus = AZ::EBus< NonUniformScaleRequests >
 
typedef AZ::EBus< TickEventsTickBus
 
typedef AZ::EBus< TickRequestsTickRequestBus
 
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 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 >
 
typedef AZ::EBus< JobManagerEventsJobManagerBus
 
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< OSAllocatorOSStdAllocator
 
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 ValueT >
using SuccessValue = Internal::OutcomeStorage< typename AZStd::decay< ValueT >::type, 0u >
 Aliases for usage with AZ::Success() and AZ::Failure()
 
template<class ValueT >
using FailureValue = Internal::OutcomeStorage< typename AZStd::decay< ValueT >::type, 1u >
 
using AssetPlatformFixedString = AZStd::fixed_string< 32 >
 
using AssetPlatformCombinedString = AZStd::fixed_string<(AssetPlatformFixedString{}.max_size()+1) *PlatformId::NumPlatformIds >
 
template<class T >
using AzEnumTraits = typename Internal::GetAzEnumTraits_Impl< AZStd::remove_cvref_t< T > >::type
 
template<class T >
using HasAzEnumTraits = AZStd::bool_constant< Internal::HasAzEnumTraitsImpl< AZStd::remove_cvref_t< T > >>
 
template<typename T >
using decay_array = AZStd::conditional_t< AZStd::is_array_v< AZStd::remove_reference_t< T > >, std::remove_extent_t< AZStd::remove_reference_t< T > > *, T && >
 
using BehaviorClassUnwrapperFunction = void(*)(void *, void *&, AZ::Uuid &, void *)
 Typedef for class unwrapping callback (i.e. used for things like smart_ptr<T> to unwrap for 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 &&)>
 
template<class Function >
using BehaviorParameterOverridesArray = AZStd::array< BehaviorParameterOverrides, AZStd::function_traits< Function >::num_args >
 
using BehaviorContextBus = AZ::EBus< BehaviorContextEvents >
 
typedef AZ::EBus< BehaviorObjectSignalsInterfaceBehaviorObjectSignals
 
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)
 
typedef AZ::u32 AttributeId
 
typedef AZStd::pair< AttributeId, Attribute * > AttributePair
 
typedef AZStd::vector< AttributePairAttributeArray
 
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 > >> >
 
typedef void(* RTTI_EnumCallback) (const AZ::TypeId &, void *)
 RTTI typeId.
 
using TypeId = AZ::Uuid
 
using DeprecatedTypeNameCallback = AZStd::function< void(AZStd::string_view)>
 
template<typename Element , size_t MaxElementCount, typename Traits >
using FixedStringTypeInfo = AZStd::basic_fixed_string< Element, MaxElementCount, Traits >
 
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< ScriptPropertyWatcherInterfaceScriptPropertyWatcherBus
 
using InMemoryScriptModules = AZStd::vector< AZStd::pair< AZStd::string, AZ::Data::Asset< AZ::ScriptAsset > >>
 
using ScriptSystemRequestBus = AZ::EBus< ScriptSystemRequests >
 
typedef u32 DataOverlayProviderId
 
typedef EBus< DataOverlayInstanceMsgsDataOverlayInstanceBus
 
typedef EBus< DataOverlayProviderMsgsDataOverlayProviderBus
 
using DataPatchNotificationBus = AZ::EBus< DataPatchNotifications >
 
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< SliceEventsSliceBus
 
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 >, OSStdAllocatorOSString
 
using ITimeRequestBus = AZ::EBus< ITime, ITimeRequests >
 
using NiceTimeSystemMock = ::testing::NiceMock< MockTimeSystem >
 
using NiceSettingsRegistrySimpleMock = ::testing::NiceMock< MockSettingsRegistry >
 
typedef EBus< UserSettingsFileLocatorUserSettingsFileLocatorBus
 
using UserSettingsComponentRequestBus = AZ::EBus< UserSettingsComponentRequests >
 
typedef EBus< UserSettingsMessagesUserSettingsBus
 
typedef EBus< UserSettingsOwnerRequestsUserSettingsOwnerRequestBus
 
typedef EBus< UserSettingsNotificationsUserSettingsNotificationBus
 
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  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  PlatformFlags : AZ::u32 {
  Platform_NONE = 0x00, Platform_PC = 1 << PlatformId::PC, Platform_LINUX = 1 << PlatformId::LINUX_ID, Platform_ANDROID = 1 << PlatformId::ANDROID_ID,
  Platform_IOS = 1 << PlatformId::IOS, Platform_MAC = 1 << PlatformId::MAC_ID, Platform_PROVO = 1 << PlatformId::PROVO, Platform_SALEM = 1 << PlatformId::SALEM,
  Platform_JASPER = 1 << PlatformId::JASPER, Platform_SERVER = 1 << PlatformId::SERVER, Platform_ALL = 1ULL << 30, Platform_ALL_CLIENT = 1ULL << 31,
  AllNamedPlatforms = Platform_PC | Platform_LINUX | Platform_ANDROID | Platform_IOS | Platform_MAC | Platform_PROVO | Platform_SALEM | Platform_JASPER | Platform_SERVER
}
 
enum  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 }
 
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 UuidGetAssetClassId ()
 
template<typename T >
SizeAlignUp (T s, size_t a)
 
template<typename 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)
 
template<typename T , typename S >
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)
 
 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::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.
 
const AZ_MATH_INLINE 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)
 
Vector3operator*= (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)
 
Vector3operator*= (Vector3 &lhs, const Matrix4x4 &rhs)
 
const Vector4 operator* (const Vector4 &lhs, const Matrix4x4 &rhs)
 
Vector4operator*= (Vector4 &lhs, const Matrix4x4 &rhs)
 
Matrix4x4 operator* (float lhs, const Matrix4x4 &rhs)
 Pre-multiplies the matrix by a scalar.
 
Matrix4x4MakePerspectiveFovMatrixRH (Matrix4x4 &out, float fovY, float aspectRatio, float nearDist, float farDist, bool reverseDepth=false)
 
Matrix4x4MakeFrustumMatrixRH (Matrix4x4 &out, float left, float right, float bottom, float top, float nearDist, float farDist, bool reverseDepth=false)
 
Matrix4x4MakeOrthographicMatrixRH (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)
 
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_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)
 
 AZ_HAS_MEMBER (AZClassAllocator, AZ_CLASS_ALLOCATOR_DECLARED, void,())
 
void * OperatorNew (std::size_t size, const char *fileName, int lineNum, const char *name=nullptr)
 
void * OperatorNew (std::size_t size)
 
void OperatorDelete (void *ptr)
 
void OperatorDelete (void *ptr, std::size_t size)
 
void * OperatorNewArray (std::size_t size, const char *fileName, int lineNum, const char *name=nullptr)
 
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)
 
SuccessValue< void > Success ()
 
template<class ValueT , class >
SuccessValue< ValueT > Success (ValueT &&rhs)
 
FailureValue< void > Failure ()
 
template<class ValueT , class >
FailureValue< ValueT > Failure (ValueT &&rhs)
 
 AZ_TYPE_INFO_TEMPLATE (Outcome, "{C1DB96E5-922A-4387-B658-B4BE7FB94EA0}", AZ_TYPE_INFO_CLASS, AZ_TYPE_INFO_CLASS)
 
 AZ_ENUM_WITH_UNDERLYING_TYPE (PlatformId, int,(Invalid, -1), PC, LINUX_ID, ANDROID_ID, IOS, MAC_ID, PROVO, SALEM, JASPER, SERVER, ALL, ALL_CLIENT, NumPlatformIds)
 This platform enum have platform values in sequence and can also be used to get the platform count.
 
 AZ_DEFINE_ENUM_BITWISE_OPERATORS (PlatformFlags)
 
const char * PlatformIdToPalFolder (PlatformId platform)
 
const char * OSPlatformToDefaultAssetPlatform (AZStd::string_view osPlatform)
 
bool IsBigEndian (PlatformID)
 
const char * GetPlatformName (PlatformID platform)
 
 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::TypeIdToTypeIds ()
 
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::BehaviorContextGetDefaultBehaviorContext ()
 
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::stringGetOverloadNames (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
 
template<typename ContainerType >
AttributeFindAttribute (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, Invocable >>
 
 AZ_HAS_MEMBER (AZRttiIntrusive, RTTI_Enable, void,())
 
template<typename T >
IRttiHelperGetRttiHelper ()
 
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 >
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 >
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 , typename TypeIdResolverTag = AZStd::false_type>
const AZ::TypeIdRttiTypeId ()
 
template<class U >
const AZ::TypeIdRttiTypeId (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_DEFINE_ENUM_BITWISE_OPERATORS (AZ::TypeTraits)
 
template<class T , class U >
bool operator== (AzTypeInfo< T > const &lhs, AzTypeInfo< U > const &rhs)
 
template<class T , class U >
bool operator!= (AzTypeInfo< T > const &lhs, AzTypeInfo< U > const &rhs)
 
template<class T , class Functor >
static constexpr void VisitDeprecatedNameOrCurrentName (Functor &&visitCallback)
 
template<class T >
static constexpr void AggregateTypeNameOld (char *buffer, size_t bufferSize)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE (char, "{3AB0037F-AF8D-48ce-BCA0-A170D18B2C03}")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE (AZ::s8, "{58422C0E-1E47-4854-98E6-34098F6FE12D}")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE (short, "{B8A56D56-A10D-4dce-9F63-405EE243DD3C}")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE (int, "{72039442-EB38-4d42-A1AD-CB68F7E0EEF6}")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE (long, "{8F24B9AD-7C51-46cf-B2F8-277356957325}")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE (AZ::s64, "{70D8A282-A1EA-462d-9D04-51EDE81FAC2F}")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE (unsigned char, "{72B9409A-7D1A-4831-9CFE-FCB3FADD3426}")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE (unsigned short, "{ECA0B403-C4F8-4b86-95FC-81688D046E40}")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE (unsigned int, "{43DA906B-7DEF-4ca8-9790-854106D3F983}")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE (unsigned long, "{5EC2D6F7-6859-400f-9215-C106F5B10E53}")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE (AZ::u64, "{D6597933-47CD-4fc8-B911-63F3E2B0993A}")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE (float, "{EA2C3E90-AFBE-44d4-A90D-FAAF79BAF93D}")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE (double, "{110C4B14-11A8-4e9d-8638-5051013A56AC}")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE (bool, "{A0CA880C-AFE4-43cb-926C-59AC48496112}")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE (AZ::Uuid, "{E152C105-A133-4d03-BBF8-3D4B2FBA3E2A}")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE (void, "{C0F1AFAD-5CB3-450E-B0F5-ADB5D46B0E22}")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE (Crc32, "{9F4E062E-06A0-46D4-85DF-E0DA96467D3A}")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE (PlatformID, "{0635D08E-DDD2-48DE-A7AE-73CC563C57C3}")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE (AZStd::monostate, "{B1E9136B-D77A-4643-BE8E-2ABDA246AE0E}")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE_CV (T, T *, "", "*")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE_CV (T, T &, "", "&")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE_CV (T, T &&, "", "&&")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE_CV (T, const T *, "const ", "*")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE_CV (T, const T &, "const ", "&")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE_CV (T, const T &&, "const ", "&&")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZE_CV (T, const T, "const ", "")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::less, "{41B40AFC-68FD-4ED9-9EC7-BA9992802E1B}", AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::less_equal, "{91CC0BDC-FC46-4617-A405-D914EF1C1902}", AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::greater, "{907F012A-7A4F-4B57-AC23-48DC08D0782E}", AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::greater_equal, "{EB00488F-E20F-471A-B862-F1E3C39DDA1D}", AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::equal_to, "{4377BCED-F78C-4016-80BB-6AFACE6E5137}", AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::hash, "{EFA74E54-BDFA-47BE-91A7-5A05DA0306D7}", AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::pair, "{919645C1-E464-482B-A69B-04AA688B6847}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::vector, "{A60E3E61-1FF6-4982-B6B8-9E4350C4C679}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::list, "{E1E05843-BB02-4F43-B7DC-3ADB28DF42AC}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::forward_list, "{D7E91EA3-326F-4019-87F0-6F45924B909A}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::set, "{6C51837F-B0C9-40A3-8D52-2143341EDB07}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::unordered_set, "{8D60408E-DA65-4670-99A2-8ABB574625AE}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::unordered_multiset, "{B5950921-7F70-4806-9C13-8C7DF841BB90}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::map, "{F8ECF58D-D33E-49DC-BF34-8FA499AC3AE1}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::unordered_map, "{41171F6F-9E5E-4227-8420-289F1DD5D005}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::unordered_multimap, "{9ED846FA-31C1-4133-B4F4-91DF9750BA96}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::shared_ptr, "{FE61C84E-149D-43FD-88BA-1C3DB7E548B4}", AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::intrusive_ptr, "{530F8502-309E-4EE1-9AEF-5C0456B1F502}", AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::optional, "{AB8C50C0-23A7-4333-81CD-46F648938B1C}", AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::basic_string, "{C26397ED-8F60-4DF6-8320-0D0C592DA3CD}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::char_traits, "{9B018C0C-022E-4BA4-AE91-2C1E8592DBB2}", AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::basic_string_view, "{D348D661-6BDE-4C0A-9540-FCEA4522D497}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::fixed_vector, "{74044B6F-E922-4FD7-915D-EFC5D1DC59AE}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_AUTO)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::fixed_list, "{508B9687-8410-4A73-AE0C-0BA15CF3F773}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_AUTO)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::fixed_forward_list, "{0D9D2AB2-F0CC-4E30-A209-A33D78717649}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_AUTO)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::array, "{911B2EA8-CCB1-4F0C-A535-540AD00173AE}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_AUTO)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZStd::bitset, "{6BAE9836-EC49-466A-85F2-F4B1B70839FB}", AZ_TYPE_INFO_INTERNAL_AUTO)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (FixedStringTypeInfo, "{FA339E31-C383-49C7-80AC-5E1A3D8FA296}", AZ_TYPE_INFO_INTERNAL_TYPENAME, AZ_TYPE_INFO_INTERNAL_AUTO, AZ_TYPE_INFO_INTERNAL_TYPENAME)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_PREFIX_UUID (AZStd::variant, "AZStd::variant", s_variantTypeId, AZ_TYPE_INFO_INTERNAL_TYPENAME_VARARGS)
 
 AZ_TYPE_INFO_INTERNAL_FUNCTION_VARIATION_SPECIALIZATION (AZStd::function, "{C9F9C644-CCC3-4F77-A792-F5B5DBCA746E}")
 
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::system_clock::time_point, "{5C48FD59-7267-405D-9C06-1EA31379FE82}")
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_POSTFIX_UUID (AZ::Internal::RValueToLValueWrapper, "{2590807F-5748-4CD0-A475-83EF5FD216CF}", AZ_TYPE_INFO_TYPENAME)
 
static const AZ_INLINE Uuid GetGenericClassInfoVectorTypeId ()
 
static const AZ_INLINE Uuid GetGenericClassInfoFixedVectorTypeId ()
 
static const AZ_INLINE Uuid GetGenericClassInfoArrayTypeId ()
 
static const AZ_INLINE Uuid GetGenericClassSetTypeId ()
 
static const AZ_INLINE Uuid GetGenericClassUnorderedSetTypeId ()
 
static const AZ_INLINE Uuid GetGenericOutcomeTypeId ()
 
const AZ_INLINE Uuid GetGenericClassPairTypeId ()
 
const AZ_INLINE Uuid GetGenericClassTupleTypeId ()
 
const AZ_INLINE Uuid GetGenericClassMapTypeId ()
 
static const AZ_INLINE Uuid 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 (ObjectStreamWriteOverrideResponse, "{BDF960A8-0F18-4E9D-96DA-F800A122C42D}")
 
template<typename T , typename ContainerType = AttributeContainerType<T>>
AttributePtr CreateModuleAttribute (T &&attrValue)
 
SerializeContext::PerModuleGenericClassInfoGetCurrentSerializeContextModule ()
 
 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_INFO_INTERNAL_VARIATION_SPECIALIZATION_2_CONCAT_1 (AZStd::unique_ptr, "{B55F90DA-C21E-4EB4-9857-87BE6529BA6D}", T, Deleter)
 
 AZ_TYPE_INFO_INTERNAL_SPECIALIZED_TEMPLATE_PREFIX_UUID (AZStd::tuple, "AZStd::tuple", "{F99F9308-DC3E-4384-9341-89CBF1ABD51E}", AZ_TYPE_INFO_INTERNAL_TYPENAME_VARARGS)
 
 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)
 

Variables

static const ComponentId InvalidComponentId = 0
 
static const TypeId TransformComponentTypeId = "{22B10178-39B6-4C12-BB37-77DB45FDD3B6}"
 The typeId of game component AzFramework::TransformComponent.
 
static const TypeId EditorTransformComponentTypeId = "{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
 
const char InitializeDynamicModuleFunctionName [] = "InitializeDynamicModule"
 
const char UninitializeDynamicModuleFunctionName [] = "UninitializeDynamicModule"
 
const char CreateModuleClassFunctionName [] = "CreateModuleClass"
 
const char DestroyModuleClassFunctionName [] = "DestroyModuleClass"
 
constexpr char PlatformPC [] = "pc"
 
constexpr char PlatformLinux [] = "linux"
 
constexpr char PlatformAndroid [] = "android"
 
constexpr char PlatformIOS [] = "ios"
 
constexpr char PlatformMac [] = "mac"
 
constexpr char PlatformProvo [] = "provo"
 
constexpr char PlatformSalem [] = "salem"
 
constexpr char PlatformJasper [] = "jasper"
 
constexpr char PlatformServer [] = "server"
 
constexpr char PlatformCodeNameWindows [] = "Windows"
 
constexpr char PlatformCodeNameLinux [] = "Linux"
 
constexpr char PlatformCodeNameAndroid [] = "Android"
 
constexpr char PlatformCodeNameiOS [] = "iOS"
 
constexpr char PlatformCodeNameMac [] = "Mac"
 
constexpr char PlatformCodeNameProvo [] = "Provo"
 
constexpr char PlatformCodeNameSalem [] = "Salem"
 
constexpr char PlatformCodeNameJasper [] = "Jasper"
 
constexpr char PlatformAll [] = "all"
 
constexpr char PlatformAllClient [] = "all_client"
 
constexpr size_t MaxPlatformCodeNames = 16
 
constexpr int NumClientPlatforms = 8
 
constexpr int NumPlatforms = NumClientPlatforms + 1
 
template<class T >
constexpr bool HasAzEnumTraits_v = HasAzEnumTraits<T>::value
 
const static 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"
 
template<class T , class = void>
constexpr bool HasDeprecatedTypeNameVisitor_v = false
 
template<class T >
constexpr AzDeprecatedTypeNameVisitor< T > DeprecatedTypeNameVisitor {}
 
static constexpr const char * s_variantTypeId { "{1E8BB1E5-410A-4367-8FAA-D43A4DE14D4B}" }
 
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"
 
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
 

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 size, const char* fileName, int lineNum, const char* name, const AZ::Internal::AllocatorDummy*); void* operator new[](std::size_t size, const char* fileName, int lineNum, const char* name, const AZ::Internal::AllocatorDummy*); 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, const char* fileName, int lineNum, const char* name, const AZ::Internal::AllocatorDummy*) { return AZ::OperatorNew(size,fileName,lineNum,name); } void* operator new[](std::size_t size, const char* fileName, int lineNum, const char* name, const AZ::Internal::AllocatorDummy*) { return AZ::OperatorNewArray(size,fileName,lineNum,name); } 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); }

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

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

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

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

Typedef Documentation

◆ BetterPseudoRandom

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

◆ ConsoleCommandInvokedEvent

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

Called on invocation of any console command.

Parameters
commandthe full command being executed on the console
commandArgsthe array of arguments that was supplied to PeformCommand
flagsthe set of flags associated with the command being executed
invokedFromthe source point that initiated console invocation

◆ CreateModuleClassFunction

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

◆ CreateStaticModulesCallback

Function signature for static module registrars.

◆ DestroyModuleClassFunction

using AZ::DestroyModuleClassFunction = typedef void(*)(AZ::Module* module)
extern "C" AZ_DLL_EXPORT
void DestroyModuleClass(AZ::Module* module)

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

◆ DispatchCommandNotFoundEvent

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

Parameters
commandthe full command that was not found
commandArgsthe array of arguments that was supplied to PeformCommand
invokedFromthe source point that initiated console invocation

◆ DynamicPrefabAsset

◆ EntityBus

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

◆ EntitySystemBus

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

◆ InitializeDynamicModuleFunction

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

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

extern "C" AZ_DLL_EXPORT
void InitializeDynamicModule(void* sharedEnvironment)

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

Parameters
sharedEnvironmentis an AZ::EnvironmentInstance.

◆ ModuleDescriptorList

Type for storing module references.

◆ ObjectStreamWriteOverrideCB

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

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

Parameters
callContextEnumerateInstanceCallContext which contains the WriteElement BeingElemCB and the CloseElement EndElemCB the callContext parameter can be passed to the SerializeContext::EnumerateInstance to continue object stream writing
classPtrclass type which is of pointer to the type represented by the m_typeId value
classDatareference to this instance Class Data that will be supplied to the callback
classElementclass element pointer which contains information about the element being serialized. root elements have a nullptr classElement
Returns
enum to indicate that the override has saved the registered class and that the default writing should be skipped. Returning false will have the WriteElement code fallback to using the default logic

◆ PrefabAsset

using AZ::PrefabAsset = typedef SliceAsset

◆ PrefabBus

using AZ::PrefabBus = typedef SliceBus
Deprecated:
Use SliceBus.

◆ PrefabComponent

◆ PrefabEvents

using AZ::PrefabEvents = typedef SliceEvents

◆ SliceEntityHierarchyRequestBus

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

◆ StaticReflectionFunctionPtr

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

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

◆ SystemTickBus

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

◆ TickBus

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

◆ TickRequestBus

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

◆ TransformBus

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

◆ TransformNotificationBus

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

◆ TypeId

Used to reference unique types by their unique id.

◆ UninitializeDynamicModuleFunction

using AZ::UninitializeDynamicModuleFunction = typedef void(*)()
extern "C" AZ_DLL_EXPORT
void UninitializeDynamicModule()

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

Enumeration Type Documentation

◆ ComponentTickBus

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

Enumerator
TICK_FIRST 

First position in the tick handler order.

TICK_PLACEMENT 

Suggested tick handler position for components that need to be early in the tick order.

TICK_INPUT 

Suggested tick handler position for input components.

TICK_GAME 

Suggested tick handler for game-related components.

TICK_ANIMATION 

Suggested tick handler position for animation components.

TICK_PHYSICS_SYSTEM 

Suggested tick handler position for physics systems. Note: This should only be used for the Physics System.

TICK_PHYSICS 

Suggested tick handler position for physics components.

TICK_ATTACHMENT 

Suggested tick handler position for attachment components.

TICK_PRE_RENDER 

Suggested tick handler position to update render-related data.

TICK_DEFAULT 

Default tick handler position when the handler is constructed.

TICK_UI 

Suggested tick handler position for UI components.

TICK_LAST 

Last position in the tick handler order.

◆ EBusAddressPolicy

enum AZ::EBusAddressPolicy
strong

Defines how many addresses exist on the EBus.

Enumerator
Single 

(Default) The EBus has a single address.

ById 

The EBus has multiple addresses; the order in which addresses receive events is undefined. Events that are addressed to an ID are received by handlers that are connected to that ID. Events that are broadcast without an ID are received by handlers at all addresses.

ByIdAndOrdered 

The EBus has multiple addresses; the order in which addresses receive events is defined. Events that are addressed to an ID are received by handlers that are connected to that ID. Events that are broadcast without an ID are received by handlers at all addresses. The order in which addresses receive events is defined by AZ::EBusTraits::BusIdOrderCompare.

◆ EBusHandlerPolicy

enum AZ::EBusHandlerPolicy
strong

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

Enumerator
Single 

The EBus supports one handler for each address.

Multiple 

(Default) Allows any number of handlers for each address; handlers at an address receive events in the order in which the handlers are connected to the EBus.

MultipleAndOrdered 

Allows any number of handlers for each address; the order in which each address receives an event is defined by AZ::EBusTraits::BusHandlerOrderCompare.

◆ IntegralTypeDiff

enum AZ::IntegralTypeDiff
strong

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

Enumerator
LSignedRSignedEqSize 

Left integer is signed, right integer is signed, both are equal in size.

LSignedRUnsignedEqSize 

Left integer is signed, right integer is unsigned, both are equal in size.

LUnsignedRSignedEqSize 

Left integer is unsigned, right integer is signed, both are equal in size.

LUnsignedRUnsignedEqSize 

Left integer is unsigned, right integer is unsigned, both are equal in size.

LSignedRSignedLWider 

Left integer is signed, right integer is signed, left integer is wider.

LSignedRUnsignedLWider 

Left integer is signed, right integer is unsigned, left integer is wider.

LUnsignedRSignedLWider 

Left integer is unsigned, right integer is signed, left integer is wider.

LUnsignedRUnsignedLWider 

Left integer is unsigned, right integer is unsigned, left integer is wider.

LSignedRSignedRWider 

Left integer is signed, right integer is signed, right integer is wider.

LSignedRUnsignedRWider 

Left integer is signed, right integer is unsigned, right integer is wider.

LUnsignedRSignedRWider 

Left integer is unsigned, right integer is signed, right integer is wider.

LUnsignedRUnsignedRWider 

Left integer is unsigned, right integer is unsigned, right integer is wider.

◆ InterpolationMode

enum AZ::InterpolationMode : u32
strong

Behavior types for smoothing of transform between network updates.

◆ JsonMergeApproach

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.

◆ ModuleInitializationSteps

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.

◆ PlatformID

enum AZ::PlatformID
strong

Enum of supported platforms. Just for user convenience.

Enumerator
PLATFORM_MAX 

Must be last.

◆ RandomDistributionType

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.

◆ TypeTraits

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.

◆ VariantOnThis

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

◆ Abs()

AZ_MATH_INLINE float AZ::Abs ( float  value)

Simd optimized math functions.

◆ AliasCast()

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

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

◆ AZ_HAS_MEMBER()

AZ::AZ_HAS_MEMBER ( AZClassAllocator  ,
AZ_CLASS_ALLOCATOR_DECLARED  ,
void  ,
()   
)

Helper class to determine if type T has a AZ_CLASS_ALLOCATOR defined, so we can safely call aznew on it. - AZClassAllocator<ClassType>....

◆ AZ_TYPE_SAFE_INTEGRAL()

AZ::AZ_TYPE_SAFE_INTEGRAL ( TimeUs  ,
int64_t   
)

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

◆ ConvertEulerDegreesToQuaternion()

AZ_MATH_INLINE Quaternion AZ::ConvertEulerDegreesToQuaternion ( const Vector3 eulerDegrees)
Parameters
eulerDegreesA vector containing component-wise rotation angles in degrees.
Returns
a quaternion made from composition of rotations around principle axes.

◆ ConvertEulerDegreesToTransform()

AZ_MATH_INLINE Transform AZ::ConvertEulerDegreesToTransform ( const Vector3 eulerDegrees)

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

Parameters
Vector3eulerDegrees A vector containing component-wise rotation angles in degrees.
Returns
Transform A transform made from the rotational components.

◆ ConvertEulerRadiansToQuaternion()

AZ_MATH_INLINE Quaternion AZ::ConvertEulerRadiansToQuaternion ( const Vector3 eulerRadians)
Parameters
eulerRadiansA vector containing component-wise rotation angles in radians.
Returns
a quaternion made from composition of rotations around principle axes.

◆ ConvertEulerRadiansToTransform()

AZ_MATH_INLINE Transform AZ::ConvertEulerRadiansToTransform ( const Vector3 eulerRadians)

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

Parameters
Vector3eulerDegrees A vector containing component-wise rotation angles in radian.
Returns
Transform A transform made from the composite of rotations first around z-axis, and y-axis and then x-axis.

◆ ConvertQuaternionToAxisAngle()

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

Populate axis and angle of rotation from Quaternion.

Parameters
[in]quatA source quaternion
[out]outAxisA Vector3 defining the rotation axis.
[out]outAngleA float rotation angle around the axis in radians.

◆ ConvertQuaternionToEulerDegrees()

AZ_MATH_INLINE Vector3 AZ::ConvertQuaternionToEulerDegrees ( const Quaternion q)

Non-member functionality belonging to the AZ namespace.

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

Parameters
qa quaternion representing the rotation
Returns
A vector containing component-wise rotation angles in degrees.

◆ ConvertQuaternionToEulerRadians()

AZ_MATH_INLINE Vector3 AZ::ConvertQuaternionToEulerRadians ( const Quaternion q)

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

Parameters
qa quaternion representing the rotation
Returns
A vector containing component-wise rotation angles in radians.

◆ ConvertTransformToEulerDegrees()

AZ_MATH_INLINE Vector3 AZ::ConvertTransformToEulerDegrees ( const Transform transform)

Non-member functionality belonging to the AZ namespace

Converts a transform to corresponding component-wise Euler angles.

Parameters
Transformtransform The input transform to decompose.
Returns
Vector3 A vector containing component-wise rotation angles in degrees.

◆ CreateModuleAttribute()

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

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

Parameters
attrValuevalue to store within the attribute
ContainerTypesecond parameter which is used for function parameter deduction

◆ CreateRandomQuaternion()

Quaternion AZ::CreateRandomQuaternion ( SimpleLcgRandom rng)

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

◆ DivideAndRoundUp()

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

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

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

◆ DummyStateHandler()

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

Default empty handler.

◆ Failure() [1/2]

FailureValue< void > AZ::Failure ( )
inline

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

◆ Failure() [2/2]

template<class ValueT , class >
FailureValue< ValueT > AZ::Failure ( ValueT &&  rhs)
inline

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

◆ GetHaltonNumber()

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

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

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

◆ GetMax()

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

Return the bigger of the 2 values.

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

◆ GetMin()

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

Return the smaller of the 2 values.

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

◆ IsPowerOfTwo()

constexpr bool AZ::IsPowerOfTwo ( uint32_t  testValue)
constexpr

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

◆ JsonNumericCast()

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

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

◆ MakeFrustumMatrixRH()

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

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

Parameters
outMatrix which stores output result
leftThe x coordinate of left side of frustum at near view-plane
rightThe x coordinate of right side of frustum at near view-plane
bottomThe y coordinate of bottom side of frustum at near view-plane
topThe y coordinate of top side of frustum at near view-plane
nearDistance to the near view-plane. Must be greater than zero.
farDistance to the far view-plane. Must be greater than zero.
reverseDepthSet to true to reverse depth which means near distance maps to 1 and far distance maps to 0.
Returns
Pointer of the output matrix

◆ MakeOrthographicMatrixRH()

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

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

Parameters
outMatrix which stores output result
leftThe x coordinate of left view-plane
rightThe x coordinate of right view-plane
bottomThe y coordinate of bottom view-plane
topThe y coordinate of top view-plane
nearDistance to the near view-plane. Must be no less than zero.
farDistance to the far view-plane. Must be greater than zero.
reverseDepthSet to true to reverse depth which means near distance maps to 1 and far distance maps to 0.
Returns
Pointer of the output matrix

◆ MakePerspectiveFovMatrixRH()

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

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

Parameters
outMatrix which stores output result
fovYField of view in the y direction, in radians. Must be greater than zero.
aspectRatioAspect ratio, defined as view space width divided by height. Must be greater than zero.
nearDistance to the near view-plane. Must be greater than zero.
farDistance to the far view-plane. Must be greater than zero.
reverseDepthSet to true to reverse depth which means near distance maps to 1 and far distance maps to 0.
Returns
Pointer of the output matrix

◆ MathReflect()

void AZ::MathReflect ( ReflectContext context)

Reflect different aspects of math (depending on context)

◆ operator*() [1/4]

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

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

◆ operator*() [2/4]

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

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

◆ operator*() [3/4]

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

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

◆ operator*() [4/4]

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

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

Parameters
multiplierthe scalar value to use.
rhsthe quaternion to scale.
Returns
a quaternion where each component of rhs is scaled by multiplier.

◆ operator*=() [1/3]

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

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

◆ operator*=() [2/3]

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

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

◆ operator*=() [3/3]

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

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

◆ parallel_for() [1/2]

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

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

◆ parallel_for() [2/2]

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

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

◆ parallel_for_each()

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

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

◆ parallel_for_each_start()

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

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

◆ parallel_for_start() [1/2]

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

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

◆ parallel_for_start() [2/2]

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

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

◆ parallel_invoke()

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

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

◆ RoundUpToMultiple()

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

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

Parameters
valueThe number to round up.
alignmentRound up to the nearest multiple of alignment. Must be non-zero or it will lead to undefined behavior

◆ SafeIntegralCompare()

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

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

◆ SetPerspectiveMatrixNearFar()

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

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

Parameters
outMatrix which stores output result.
nearDistance to the near view-plane. Must be no less than zero.
farDistance to the far view-plane. Must be greater than zero.
reverseDepthSet to true to reverse depth which means near distance maps to 1 and far distance maps to 0.

◆ ShouldUseSystemComponent()

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

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

Parameters
descriptorThe descriptor for the component being checked
requiredTagsThe tags the component must have one of for true to be returned
serializeThe serialize context to pull attributes for the component from
Returns
whether the component represented by descriptor has at least one tag that is present in required tags

◆ Success() [1/2]

SuccessValue< void > AZ::Success ( )
inline

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

◆ Success() [2/2]

template<class ValueT , class >
SuccessValue< ValueT > AZ::Success ( ValueT &&  rhs)
inline

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

◆ TypeHash32()

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

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

Parameters
[in]bufferpointer to the memory to be hashed
[in]lengththe length in bytes of memory to read for generating the hash
Returns
32 bit resulting hash

◆ TypeHash64() [1/3]

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

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

Parameters
[in]bufferpointer to the memory to be hashed
[in]lengththe length in bytes of memory to read for generating the hash
Returns
64 bit resulting hash

◆ TypeHash64() [2/3]

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

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

Parameters
[in]bufferpointer to the memory to be hashed
[in]lengththe length in bytes of memory to read for generating the hash
[in]seeda seed that is hashed into the result
Returns
64 bit resulting hash

◆ TypeHash64() [3/3]

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

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

Parameters
[in]bufferpointer to the memory to be hashed
[in]lengththe length in bytes of memory to read for generating the hash
[in]seed1first seed that is hashed into the result
[in]seed2second seed that is also hashed into the result
Returns
64 bit resulting hash

◆ ValidateAzEventDescription()

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

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

  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

◆ Vector2ToVector3() [1/2]

Vector3 AZ::Vector2ToVector3 ( const Vector2 v)

Converts a Vector2 to a Vector3

Parameters
vThe Vector2 to convert
Returns
A Vector3 created from the given Vector2 with 0 for the Z component

O3DE_DEPRECATION_NOTICE(GHI-10596)

Deprecated:
use AZ::Vector3 constructor

◆ Vector2ToVector3() [2/2]

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

Converts a Vector2 to a Vector3

Parameters
vThe Vector2 to convert
zThe new value for the resulting Vector3's Z component
Returns
A Vector3 created from the given values

O3DE_DEPRECATION_NOTICE(GHI-10596)

Deprecated:
use AZ::Vector3 constructor

◆ Vector2ToVector4() [1/3]

Vector4 AZ::Vector2ToVector4 ( const Vector2 v)

Converts a Vector2 to a Vector4

Parameters
vThe Vector2 to convert
Returns
A Vector4 created from the given Vector2 with 0 for the Z and W components

O3DE_DEPRECATION_NOTICE(GHI-10596)

Deprecated:
use AZ::Vector4 constructor

◆ Vector2ToVector4() [2/3]

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

Converts a Vector2 to a Vector4

Parameters
vThe Vector2 to convert
zThe new value for the resulting Vector4's Z component
Returns
A Vector4 created from the given values with a 0 for the W component

O3DE_DEPRECATION_NOTICE(GHI-10596)

Deprecated:
use AZ::Vector4 constructor

◆ Vector2ToVector4() [3/3]

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

Converts a Vector2 to a Vector4

Parameters
vThe Vector2 to convert
zThe new value for the resulting Vector4's Z component
wThe new value for the resulting Vector4's W component
Returns
A Vector4 created from the given values

O3DE_DEPRECATION_NOTICE(GHI-10596)

Deprecated:
use AZ::Vector4 constructor

◆ Vector3RadToDeg()

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

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

◆ Vector3ToVector2()

Vector2 AZ::Vector3ToVector2 ( const Vector3 v)

Converts a Vector3 to a Vector2

The Z value of the Vector3 will be dropped

Parameters
vThe Vector3 to convert to a Vector2
Returns
A Vector2 created from the given Vector2

O3DE_DEPRECATION_NOTICE(GHI-10596)

Deprecated:
use AZ::Vector2 constructor

◆ Vector3ToVector4() [1/2]

Vector4 AZ::Vector3ToVector4 ( const Vector3 v)

Converts a Vector3 to a Vector4

Parameters
vThe Vector3 to convert to a Vector4
Returns
A Vector4 created from the given Vector3 with a 0 for the W component

O3DE_DEPRECATION_NOTICE(GHI-10596)

Deprecated:
use AZ::Vector4 constructor

◆ Vector3ToVector4() [2/2]

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

Converts a Vector3 to a Vector4

Parameters
vThe Vector3 to convert to a Vector4
wThe new value for the resulting Vector4's W component
Returns
A Vector4 created from the given values

O3DE_DEPRECATION_NOTICE(GHI-10596)

Deprecated:
use AZ::Vector4 constructor

◆ Vector4ToVector2()

Vector2 AZ::Vector4ToVector2 ( const Vector4 v)

Converts a Vector4 to a Vector2

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

Parameters
vThe Vector2 to convert to a Vector4
Returns
A Vector4 created from the given Vector2 with 0s for the Z and W components

O3DE_DEPRECATION_NOTICE(GHI-10596)

Deprecated:
use AZ::Vector2 constructor

◆ Vector4ToVector3()

Vector3 AZ::Vector4ToVector3 ( const Vector4 v)

Converts a Vector4 to a Vector3

The W component of the given Vector4 will be dropped

Parameters
vThe Vector3 to convert to a Vector4
Returns
A Vector4 created from the given Vector3 with a 0 for the W component

O3DE_DEPRECATION_NOTICE(GHI-10596)

Deprecated:
use AZ::Vector3 constructor

Variable Documentation

◆ MinTransformScale

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

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

AZ::Module
Definition: Module.h:32