Namespace for file functions. More...

Namespaces
	ViewportColors
	Various colors used by the editor and shared between objects.

	ViewportConstants
	Various constants used by the editor.

Classes
class	ApplicationRequests

class	ApplicationLifecycleEvents

class	LevelLoadBlockerRequests

class	ILevelSystemLifecycle

class	LevelSystemLifecycleNotifications

class	Application

class	AssetBundleManifest

class	AssetCatalog

class	AssetCatalogEvents

class	LegacyAssetEvents

class	AssetCatalogComponent

class	AssetRegistry

struct	SeedInfo

class	AssetSeedListReflector

class	BenchmarkAsset

class	BenchmarkSettingsAsset

class	CustomAssetTypeComponent

class	GenericAssetHandlerBase

class	GenericAssetHandler

class	SimpleAssetReferenceBase

class	SimpleAssetReference

class	VersionSearchRule

class	MatchingRule

class	XmlSchemaAttribute

class	XmlSchemaElement

class	SearchRuleDefinition

class	DependencySearchRule

class	XmlSchemaAsset

class	AzFrameworkModule

class	AzFrameworkNativeUIModule

class	CommandRegistration

class	AzFrameworkConfigurationSystemComponent

class	ConsoleRequests

class	ConsoleNotifications

class	EditorEntityEvents

class	NativeUISystemComponent

class	NonUniformScaleComponent

class	TransformComponent
	Fundamental component that describes the entity in 3D space. More...

class	DeviceAttributeDeviceModel
	Device attribute for getting device model name e.g. "Pixel 3 XL". More...

class	DeviceAttributeGPUModel

class	DeviceAttribute

class	DeviceAttributeRegistrarInterface

class	DeviceAttributeRAM

class	DeviceAttributesSystemComponent
	System component responsible for managing device attributes. More...

class	BehaviorComponentId

class	BehaviorEntity

class	EntityContext

class	EntityContextRequests

class	EntityContextEvents

class	EntityIdContextQueries

class	DebugDisplayRequests
	DebugDisplayRequests provides a debug draw api to be used by components and viewport features. More...

struct	ViewportInfo
	Structure to hold information relevant to a given viewport. More...

class	EntityDebugDisplayEvents

class	ViewportDebugDisplayEvents

class	DebugDisplayEvents

class	EntityOwnershipService

class	EntityOwnershipServiceInterface

class	EntityOwnershipServiceNotifications

class	GameEntityContextRequests

class	GameEntityContextEvents

class	GameEntityContextComponent

class	PrefabEntityOwnershipService

class	SliceEntityOwnershipService

class	SliceEntityOwnershipServiceRequests

class	SliceGameEntityOwnershipService

class	SliceGameEntityOwnershipServiceRequests

class	SliceGameEntityOwnershipServiceNotifications

struct	TextDrawParameters
	Standard parameters for drawing text on screen. More...

class	FontDrawInterface

class	FontQueryInterface

struct	GemInfo
	This struct stores gem related information. More...

class	InputChannelNotifications

class	InputDeviceNotifications

class	InputSystemNotifications
	EBus interface used to listen for input system notifications. More...

class	InputTextNotifications

class	InputChannelRequests
	EBus interface used to query for available input channels. More...

class	InputDeviceRequests
	EBus interface used to query input devices for their associated input channels and state. More...

class	InputDeviceImplementationRequest
	Templated EBus interface used to create a custom implementation for a specific device type. More...

class	InputDeviceImplementationRequestHandler

class	InputHapticFeedbackRequests
	EBus interface used to send haptic feedback requests to connected input devices. More...

class	InputLightBarRequests
	EBus interface used to send light bar requests to connected input devices. More...

class	InputMotionSensorRequests
	EBus interface used to send motion sensor requests to connected input devices. More...

class	InputSystemCursorRequests
	EBus interface used to query/change the state, position, or appearance of the system cursor. More...

class	InputSystemCursorConstraintRequests
	EBus interface to request the window or view used to clip and/or normalize the system cursor. More...

class	InputSystemRequests
	EBus interface used to send requests to the input system. More...

class	InputTextEntryRequests
	EBus interface used to send text entry requests to connected input devices. More...

class	InputChannel

class	InputChannelAnalog

class	InputChannelAnalogWithPosition2D

class	InputChannelAxis1D

class	InputChannelAxis2D

class	InputChannelAxis3D

class	InputChannelDelta

class	InputChannelDeltaWithSharedPosition2D

class	InputChannelDigital

class	InputChannelDigitalWithPosition2D

struct	ModifierKeyStates
	Custom data struct to store the current state of all modifier keys. More...

class	InputChannelDigitalWithSharedModifierKeyStates

class	InputChannelDigitalWithSharedPosition2D

class	InputChannelId
	Class that identifies a specific input channel. More...

class	InputChannelQuaternion

class	InputContext

class	InputContextComponentRequests

class	InputContextComponent

class	InputDeviceGamepad

class	InputDevice

class	InputDeviceId
	Class that identifies a specific input device. More...

class	InputDeviceKeyboard

class	InputDeviceMotion

class	InputDeviceMouse

class	InputDeviceTouch

class	InputDeviceVirtualKeyboard

class	InputChannelEventFilter

class	InputChannelEventFilterInclusionList
	Class that filters input channel events based on included input channels and devices. More...

class	InputChannelEventFilterExclusionList
	Class that filters input channel events based on excluded input channels and devices. More...

class	InputChannelEventListener

class	InputChannelEventSink
	Class that consumes all input event that pass the specified filter. More...

class	InputTextEventListener
	Class that handles input text event notifications by priority. More...

class	InputMapping

class	InputMappingAnd

class	InputMappingOr

class	InputSystemComponent

struct	RemoteStorageDriveConfig

class	RemoteStorageDrive

class	LogFile

class	LogComponent

class	MissingAssetLogger

class	MissingAssetNotifications

class	Sample

class	LinearlyInterpolatedSample

class	LinearlyInterpolatedSample< AZ::Vector3 >

class	LinearlyInterpolatedSample< AZ::Quaternion >

class	UninterpolatedSample

class	UninterpolatedSample< AZ::Vector3 >

class	UninterpolatedSample< AZ::Quaternion >

class	MetricsPlainTextNameRegistrationBusTraits

class	RemoteToolsMessage

class	RemoteToolsEndpointInfo

class	IRemoteTools

class	SocketConnection

class	EngineConnectionEvents

class	PaintBrush

class	PaintBrushNotifications
	PaintBrushNotificationBus is used to send out notifications whenever anything about the paintbrush has changed. More...

class	PaintBrushSession

class	PaintBrushSettings
	Defines the specific paintbrush settings to use with a paintbrush. More...

class	PaintBrushSystemComponent
	PaintBrushSystemComponent generically manages runtime paint brush sessions for any components that support runtime painting. More...

class	CharacterPhysicsDataRequests

class	CharacterPhysicsDataNotifications

class	ProcessOutput

class	ProcessCommunicator

class	ProcessCommunicatorForChildProcess

class	StdInOutCommunication

class	StdProcessCommunicator

class	StdInOutProcessCommunicatorData

class	StdInOutProcessCommunicator

class	StdProcessCommunicatorForChildProcess

class	StdInOutProcessCommunicatorForChildProcess

class	ProcessWatcher

class	QualityCVarGroup

class	QualitySystemEvents

class	QualitySystemComponent

struct	AabbUnionAggregator

class	Scene

class	SceneSystemComponent

class	ISceneSystem

class	ISceneSystemRequests

struct	ScriptCompileRequest

struct	ScriptPropertyGroup

class	ScriptComponent

class	ScriptDebugAgentEvents

class	ScriptDebugRequest

class	ScriptDebugBreakpointRequest

class	ScriptDebugSetValue

class	ScriptDebugAck

class	ScriptDebugAckBreakpoint

class	ScriptDebugAckExecute

class	ScriptDebugEnumLocalsResult

class	ScriptDebugEnumContextsResult

class	ScriptDebugGetValueResult

class	ScriptDebugSetValueResult

class	ScriptDebugCallStackResult

class	ScriptDebugRegisteredGlobalsResult

class	ScriptDebugRegisteredClassesResult

class	ScriptDebugRegisteredEBusesResult

struct	ScriptUserMethodInfo

struct	ScriptUserPropertyInfo

struct	ScriptUserClassInfo

struct	ScriptUserEBusMethodInfo

struct	ScriptUserEBusInfo

class	SliceEntityRequests

class	SliceInstantiationResults

class	SliceInstantiationTicket

class	InMemorySpawnableAssetContainer

class	RootSpawnableNotifications
	Notifications send when the root spawnable updates. Events will always be called from the main thread. More...

class	RootSpawnableDefinition

class	Spawnable

class	SpawnableAssetEvents

class	SpawnableAssetHandler

class	SpawnableEntitiesContainer

class	SpawnableEntityContainerView

class	SpawnableConstEntityContainerView

class	SpawnableIndexEntityPair

class	SpawnableIndexEntityIterator

class	SpawnableConstIndexEntityContainerView

struct	EntityAliasTypeChange
	Information used when updating the type of an entity alias. More...

class	EntitySpawnTicket

struct	SpawnAllEntitiesOptionalArgs

struct	SpawnEntitiesOptionalArgs

struct	DespawnAllEntitiesOptionalArgs

struct	DespawnEntityOptionalArgs

struct	RetrieveTicketOptionalArgs

struct	ReloadSpawnableOptionalArgs

struct	UpdateEntityAliasTypesOptionalArgs

struct	ListEntitiesOptionalArgs

struct	ClaimEntitiesOptionalArgs

struct	BarrierOptionalArgs

struct	LoadBarrierOptionalArgs

class	SpawnableEntitiesDefinition

class	SpawnableEntitiesManager

class	SpawnableMetaData

class	SpawnableMonitor

class	SpawnableSystemComponent

struct	Camera

struct	MotionEvent
	Generic motion type. More...

struct	CursorEvent

struct	ScrollEvent

struct	DiscreteInputEvent

struct	InputState
	Encapsulates an InputEvent in addition to the current key state of the modifiers. More...

class	CameraInput

struct	CameraProps
	Properties to use to configure behavior across all types of camera. More...

class	Cameras

class	CameraSystem
	Responsible for updating a series of cameras given various inputs. More...

class	RotateCameraInput
	A camera input to handle motion deltas that can change the orientation of the camera (update pitch and yaw). More...

struct	PanAxes
	Axes to use while panning the camera. More...

class	PanCameraInput
	A camera input to handle motion deltas that can pan the camera (translate in two axes). More...

struct	TranslateCameraInputChannelIds
	Groups all camera translation inputs. More...

class	TranslateCameraInput
	A camera input to handle discrete events that can translate the camera (translate in three axes). More...

class	OrbitScrollDollyCameraInput
	A camera input to handle discrete scroll events that can modify the camera offset. More...

class	OrbitMotionDollyCameraInput
	A camera input to handle motion deltas that can modify the camera offset. More...

class	LookScrollTranslationCameraInput
	A camera input to handle discrete scroll events that can scroll (translate) the camera along its forward axis. More...

class	OrbitCameraInput

class	FocusCameraInput

class	CustomCameraInput

struct	CameraState
	Represents the camera state populated by the viewport camera. More...

class	ClickDetector

struct	CursorState
	Utility type to wrap a current and last cursor position. More...

class	MultiViewportController

class	MultiViewportControllerInstanceInterface
	The interface used by MultiViewportController to manage individual instances. More...

struct	ScreenPoint
	A wrapper around an X and Y screen position. More...

struct	ScreenVector

struct	ScreenSize
	A wrapper around a screen width and height. More...

class	SingleViewportController

class	ViewportRequests

struct	ViewportBorderPadding
	The additional padding around the viewport when a viewport border is active. More...

class	ViewportBorderRequests
	For performing queries about the state of the viewport border. More...

class	ViewportImGuiNotifications
	Provides an interface to notify about different states of the ImGui. More...

struct	ViewportControllerInputEvent
	An event dispatched to ViewportControllers when input occurs. More...

struct	ViewportControllerUpdateEvent
	An event dispatched to ViewportControllers every tick. More...

class	ViewportControllerInterface

class	ViewportControllerList

class	BoundsRequests
	Implemented by components that provide bounds for use with various systems. More...

class	IEntityBoundsUnion

class	IEntityBoundsUnionTraits

class	EntityVisibilityBoundsUnionSystem
	Provide a unified hook between entities and the visibility system. More...

class	EntityVisibilityQuery
	Utility class to encapsulate entity visibility queries against the view frustum. More...

struct	VisibilityNode

struct	VisibilityEntry
	Data for an object that is added to the visibility system. More...

class	IVisibilityScene
	This is the interface for managing objects and visibility queries for a given scene. More...

class	IVisibilitySystem
	This is an AZ::Interface<> useful for extremely fast, CPU only, proximity and visibility queries. More...

class	IVisibilitySystemRequests

class	OcclusionRequests
	OcclusionRequests provides an interface for integrating with occlusion culling systems. Use the interface to create occlusion views that configure the camera state and context for making occlusion queries. Creating multiple occlusion views also allows queries to be made across multiple threads. More...

class	OctreeNode

class	OctreeScene

class	OctreeSystemComponent

struct	OctreeDebug

struct	VisibleGeometry
	VisibleGeometry describes visible geometry surfaces stored as generic indexed triangle lists. More...

class	VisibleGeometryRequests
	Interface for components to provide generic geometric data, potentially for occlusion culling and other systems. More...

struct	WindowGeometry

struct	WindowStyleMasks
	A simple structure to encapsulate different native window style masks. More...

class	NativeWindow

struct	WindowSize
	A simple structure to contain window size. More...

struct	WindowPosOptions
	Options for resizing and moving the window. More...

class	WindowRequests

class	WindowNotifications

class	ExclusiveFullScreenRequests

class	WindowSystemRequests
	The WindowSystemRequestBus is a broadcast bus for sending requests to the window system. More...

class	WindowSystemNotifications
	The WindowSystemNotificationBus is used to broadcast an event whenever a new window is created. More...

class	AndroidLifecycleEvents

class	AndroidEventDispatcher

class	AndroidAppRequests

class	RawInputNotificationsAndroid

class	CommunicatorHandleImpl

struct	StartupInfo

struct	ProcessData

class	UTF16ToUTF8Converter
	Class used to convert sequences of UTF-16 code units to UTF-8 code points. More...

class	XcbApplication

class	XcbConnectionManager

class	XcbConnectionManagerBusTraits

class	XcbEventHandler

class	XcbEventHandlerBusTraits

class	XcbInputDeviceKeyboard

class	XcbInputDeviceMouse

struct	XcbDeleterFreeFunctionWrapper

class	XcbNativeWindow

class	IosLifecycleEvents

class	RawInputNotificationsIos

class	LinuxLifecycleEvents

class	InputDeviceGamepadLinux
	Platform specific implementation for Linux game-pad input devices. More...

struct	LibEVDevWrapper

class	DarwinLifecycleEvents

class	RawInputNotificationsMac

class	WindowsLifecycleEvents

class	ApplicationWindows

class	RawInputNotificationsWindows

class	InputDeviceGamepadWindows
	Platform specific implementation for Windows game-pad input devices. More...

class	InputDeviceKeyboardWindows
	Platform specific implementation for Windows keyboard input devices. More...

class	InputDeviceMouseWindows
	Platform specific implementation for Windows mouse input devices. More...

class	NativeWindowImpl_Win32

Typedefs
using	LevelLoadBlockerBus = AZ::EBus< LevelLoadBlockerRequests >

using	LevelSystemLifecycleInterface = AZ::Interface< ILevelSystemLifecycle >

using	LevelSystemLifecycleNotificationBus = AZ::EBus< LevelSystemLifecycleNotifications >

using	AssetCatalogEventBus = AZ::EBus< AssetCatalogEvents >

using	LegacyAssetEventBus = AZ::EBus< LegacyAssetEvents >

using	AssetSeedList = AZStd::vector< SeedInfo >

using	AssetSystemInfoBus = AZ::EBus< AssetSystem::AssetSystemInfoNotifications >

using	AssetSystemRequestBus = AZ::EBus< AssetSystem::AssetSystemRequests >

using	AssetSystemConnectionNotificationsBus = AZ::EBus< AssetSystem::AssetSystemConnectionNotifications >

using	AssetSystemStatusBus = AZ::EBus< AssetSystem::AssetSystemStatus >

using	AssetInfoString = AZStd::basic_string< char, AZStd::char_traits< char >, AZStd::static_buffer_allocator< 128, AZStd::alignment_of< char >::value > >

using	CommandLine = AZ::CommandLine

using	CommandFunction = AZStd::function< CommandResult(const AZStd::vector< AZStd::string_view > &args)>

using	CommandRegistrationBus = AZ::EBus< CommandRegistration >

typedef AZ::EBus< ConsoleRequests >	ConsoleRequestBus

typedef AZ::EBus< ConsoleNotifications >	ConsoleNotificationBus

using	TransformComponentConfiguration = AZ::TransformConfig

using	DeviceAttributeRegistrar = AZ::Interface< DeviceAttributeRegistrarInterface >

using	EntityContextId = AZ::Uuid

using	EntityList = AZStd::vector< AZ::Entity * >

using	EntityContextRequestBus = AZ::EBus< EntityContextRequests >

using	EntityContextEventBus = AZ::EBus< EntityContextEvents >

using	EntityIdContextQueryBus = AZ::EBus< EntityIdContextQueries >

using	DebugDisplayRequestBus = AZ::EBus< DebugDisplayRequests >
	Inherit from DebugDisplayRequestBus::Handler to implement the DebugDisplayRequests interface.

using	EntityDebugDisplayEventBus = AZ::EBus< EntityDebugDisplayEvents >

using	ViewportDebugDisplayEventBus = AZ::EBus< ViewportDebugDisplayEvents >

using	DebugDisplayEventBus = AZ::EBus< DebugDisplayEvents >

using	EntityIdList = AZStd::vector< AZ::EntityId >

using	OnEntitiesAddedCallback = AZStd::function< void(const EntityList &)>

using	OnEntitiesRemovedCallback = AZStd::function< void(const EntityIdList &)>

using	ValidateEntitiesCallback = AZStd::function< bool(const EntityList &)>

using	EntityOwnershipServiceNotificationBus = AZ::EBus< EntityOwnershipServiceNotifications >

using	GameEntityContextRequestBus = AZ::EBus< GameEntityContextRequests >

using	GameEntityContextEventBus = AZ::EBus< GameEntityContextEvents >

using	SliceInstanceUnorderedSet = AZStd::unordered_set< AZ::SliceComponent::SliceInstanceAddress >

using	RootSliceAsset = AZ::Data::Asset< AZ::SliceAsset >

using	SliceEntityOwnershipServiceRequestBus = AZ::EBus< SliceEntityOwnershipServiceRequests >

using	SliceGameEntityOwnershipServiceRequestBus = AZ::EBus< SliceGameEntityOwnershipServiceRequests >

using	SliceGameEntityOwnershipServiceNotificationBus = AZ::EBus< SliceGameEntityOwnershipServiceNotifications >

using	FontId = uint32_t

using	InputChannelNotificationBus = AZ::EBus< InputChannelNotifications >

using	InputDeviceNotificationBus = AZ::EBus< InputDeviceNotifications >

using	InputSystemNotificationBus = AZ::EBus< InputSystemNotifications >

using	InputTextNotificationBus = AZ::EBus< InputTextNotifications >

using	InputChannelRequestBus = AZ::EBus< InputChannelRequests >

using	InputDeviceRequestBus = AZ::EBus< InputDeviceRequests >

using	InputHapticFeedbackRequestBus = AZ::EBus< InputHapticFeedbackRequests >

using	InputLightBarRequestBus = AZ::EBus< InputLightBarRequests >

using	InputMotionSensorRequestBus = AZ::EBus< InputMotionSensorRequests >

using	InputSystemCursorRequestBus = AZ::EBus< InputSystemCursorRequests >

using	InputSystemCursorConstraintRequestBus = AZ::EBus< InputSystemCursorConstraintRequests >

using	InputSystemRequestBus = AZ::EBus< InputSystemRequests >

using	InputTextEntryRequestBus = AZ::EBus< InputTextEntryRequests >

using	SharedModifierKeyStates = AZStd::shared_ptr< ModifierKeyStates >
	Alias for verbose shared_ptr class.

using	InputContextComponentRequestBus = AZ::EBus< InputContextComponentRequests >

using	MissingAssetNotificationBus = AZ::EBus< MissingAssetNotifications >

using	MetricsPlainTextNameRegistrationBus = AZ::EBus< MetricsPlainTextNameRegistrationBusTraits >

using	RemoteToolsMessagePointer = AZStd::intrusive_ptr< RemoteToolsMessage >

using	RemoteToolsMessageQueue = AZStd::deque< RemoteToolsMessagePointer, AZ::OSStdAllocator >

using	RemoteToolsEndpointContainer = AZStd::unordered_map< AZ::u32, RemoteToolsEndpointInfo >

using	RemoteToolsEndpointStatusEvent = AZ::Event< RemoteToolsEndpointInfo >

using	RemoteToolsEndpointConnectedEvent = AZ::Event< bool >

using	RemoteToolsEndpointChangedEvent = AZ::Event< AZ::u32, AZ::u32 >

using	ReceivedRemoteToolsMessages = AZStd::fixed_vector< RemoteToolsMessagePointer, 128 >

using	RemoteToolsInterface = AZ::Interface< IRemoteTools >

using	PaintBrushNotificationBus = AZ::EBus< PaintBrushNotifications >

using	PaintBrushSessionBus = AZ::EBus< PaintBrushSession >

using	CharacterPhysicsDataRequestBus = AZ::EBus< CharacterPhysicsDataRequests >

using	CharacterPhysicsDataNotificationBus = AZ::EBus< CharacterPhysicsDataNotifications >

using	StdProcessCommunicatorHandle = AZStd::unique_ptr< CommunicatorHandleImpl >

using	SceneSystemInterface = AZ::Interface< ISceneSystem >

using	ILoggerRequestBus = AZ::EBus< ISceneSystem, ISceneSystemRequests >

typedef AZ::EBus< ScriptDebugAgentEvents >	ScriptDebugAgentBus

typedef AZStd::vector< ScriptUserMethodInfo >	ScriptUserMethodList

typedef AZStd::vector< ScriptUserPropertyInfo >	ScriptUserPropertyList

typedef AZStd::vector< ScriptUserClassInfo >	ScriptUserClassList

typedef AZStd::vector< ScriptUserEBusMethodInfo >	ScriptUserEBusMethodList

typedef AZStd::vector< ScriptUserEBusInfo >	ScriptUserEBusList

using	SliceEntityRequestBus = AZ::EBus< SliceEntityRequests >

using	SliceInstantiationResultBus = AZ::EBus< SliceInstantiationResults >

using	RootSpawnableNotificationBus = AZ::EBus< RootSpawnableNotifications >

using	RootSpawnableInterface = AZ::Interface< RootSpawnableDefinition >

using	SpawnableAsset = AZ::Data::Asset< AzFramework::Spawnable >

using	SpawnableAssetVector = AZStd::vector< AZ::Data::Asset< AzFramework::Spawnable > >

using	SpawnableAssetEventsBus = AZ::EBus< SpawnableAssetEvents >

using	EntitySpawnCallback = AZStd::function< void(EntitySpawnTicket::Id, SpawnableConstEntityContainerView)>

using	EntityPreInsertionCallback = AZStd::function< void(EntitySpawnTicket::Id, SpawnableEntityContainerView)>

using	EntityDespawnCallback = AZStd::function< void(EntitySpawnTicket::Id)>

using	RetrieveEntitySpawnTicketCallback = AZStd::function< void(EntitySpawnTicket &&)>

using	ReloadSpawnableCallback = AZStd::function< void(EntitySpawnTicket::Id, SpawnableConstEntityContainerView)>

using	UpdateEntityAliasTypesCallback = AZStd::function< void(EntitySpawnTicket::Id)>

using	ListEntitiesCallback = AZStd::function< void(EntitySpawnTicket::Id, SpawnableConstEntityContainerView)>

using	ListIndicesEntitiesCallback = AZStd::function< void(EntitySpawnTicket::Id, SpawnableConstIndexEntityContainerView)>

using	ClaimEntitiesCallback = AZStd::function< void(EntitySpawnTicket::Id, SpawnableEntityContainerView)>

using	BarrierCallback = AZStd::function< void(EntitySpawnTicket::Id)>

using	SpawnableEntitiesInterface = AZ::Interface< SpawnableEntitiesDefinition >

using	SpawnableMetaDataArrayIndex = SpawnableMetaDataArraySize

using	HorizontalMotionEvent = MotionEvent< struct HorizontalMotionTag >

using	VerticalMotionEvent = MotionEvent< struct VerticalMotionTag >

using	InputEvent = AZStd::variant< AZStd::monostate, HorizontalMotionEvent, VerticalMotionEvent, CursorEvent, ScrollEvent, DiscreteInputEvent >
	Represents a type-safe union of input events that are handled by the camera system.

using	PanAxesFn = AZStd::function< PanAxes(const Camera &camera)>
	PanAxes build function that will return a pair of pan axes depending on the camera orientation.

using	TranslationDeltaFn = AZStd::function< void(Camera &camera, const AZ::Vector3 &delta)>

using	TranslationAxesFn = AZStd::function< AZ::Matrix3x3(const Camera &camera)>
	Axes to use while translating the camera.

using	FocusOffsetFn = AZStd::function< AZ::Vector3(float)>

using	ViewportRequestBus = AZ::EBus< ViewportRequests >

using	ViewportBorderRequestBus = AZ::EBus< ViewportBorderRequests >

using	ViewportImGuiNotificationBus = AZ::EBus< ViewportImGuiNotifications >

using	ViewportControllerPtr = AZStd::shared_ptr< ViewportControllerInterface >

using	ConstViewportControllerPtr = AZStd::shared_ptr< const ViewportControllerInterface >

using	ViewportControllerListPtr = AZStd::shared_ptr< ViewportControllerList >

using	ConstViewportControllerListPtr = AZStd::shared_ptr< const ViewportControllerList >

using	FloatSeconds = AZStd::chrono::duration< float >

using	ViewportId = int

using	BoundsRequestBus = AZ::EBus< BoundsRequests >

using	IEntityBoundsUnionRequestBus = AZ::EBus< IEntityBoundsUnion, IEntityBoundsUnionTraits >

using	IVisibilitySystemRequestBus = AZ::EBus< IVisibilitySystem, IVisibilitySystemRequests >

using	OcclusionRequestBus = AZ::EBus< OcclusionRequests >

using	VisibleGeometryContainer = AZStd::vector< VisibleGeometry >

using	VisibleGeometryRequestBus = AZ::EBus< VisibleGeometryRequests >

using	NativeWindowHandle = void *

using	WindowRequestBus = AZ::EBus< WindowRequests >

using	WindowNotificationBus = AZ::EBus< WindowNotifications >

using	ExclusiveFullScreenRequestBus = AZ::EBus< ExclusiveFullScreenRequests >

using	WindowSystemRequestBus = AZ::EBus< WindowSystemRequests >

using	WindowSystemNotificationBus = AZ::EBus< WindowSystemNotifications >

using	RawInputNotificationBusAndroid = AZ::EBus< RawInputNotificationsAndroid >

using	LocalUserId = AZ::u32
	Alias for the type of a local user id.

using	XcbConnectionManagerBus = AZ::EBus< XcbConnectionManager, XcbConnectionManagerBusTraits >

using	XcbConnectionManagerInterface = AZ::Interface< XcbConnectionManager >

using	XcbEventHandlerBus = AZ::EBus< XcbEventHandler, XcbEventHandlerBusTraits >

template<typename T , auto fn>
using	XcbUniquePtr = AZStd::unique_ptr< T, XcbDeleterFreeFunctionWrapper< fn > >

template<typename T >
using	XcbStdFreePtr = XcbUniquePtr< T, ::free >

using	RawInputNotificationBusIos = AZ::EBus< RawInputNotificationsIos >

using	RawInputNotificationBusMac = AZ::EBus< RawInputNotificationsMac >

using	RawInputNotificationBusWindows = AZ::EBus< RawInputNotificationsWindows >

Enumerations
enum class	CommandResult { Success , Error , ErrorWrongNumberOfArguments , ErrorCommandNotFound }

enum	CommandFlags : AZ::u32 { NoValue = 0x00000000 , Cheat = 0x00000002 , Development = 0x00000004 , Restricted = 0x00080000 , Invisible = 0x00100000 , BlockFrame = 0x00400000 }

enum	EAuxGeomPublicRenderflagBitMasks : AZ::u32 { e_Mode2D3DShift = 31 , e_Mode2D3DMask = 0x1u << e_Mode2D3DShift , e_AlphaBlendingShift = 29 , e_AlphaBlendingMask = 0x3u << e_AlphaBlendingShift , e_DrawInFrontShift = 28 , e_DrawInFrontMask = 0x1u << e_DrawInFrontShift , e_FillModeShift = 26 , e_FillModeMask = 0x3u << e_FillModeShift , e_CullModeShift = 24 , e_CullModeMask = 0x3u << e_CullModeShift , e_DepthWriteShift = 23 , e_DepthWriteMask = 0x1u << e_DepthWriteShift , e_DepthTestShift = 22 , e_DepthTestMask = 0x1u << e_DepthTestShift , e_PublicParamsMask = e_Mode2D3DMask \| e_AlphaBlendingMask \| e_DrawInFrontMask \| e_FillModeMask \| e_CullModeMask \| e_DepthWriteMask \| e_DepthTestMask }

enum	EAuxGeomPublicRenderflags_Mode2D3D : AZ::u32 { e_Mode3D = 0x0u << e_Mode2D3DShift , e_Mode2D = 0x1u << e_Mode2D3DShift }

enum	EAuxGeomPublicRenderflags_AlphaBlendMode : AZ::u32 { e_AlphaNone = 0x0u << e_AlphaBlendingShift , e_AlphaAdditive = 0x1u << e_AlphaBlendingShift , e_AlphaBlended = 0x2u << e_AlphaBlendingShift }

enum	EAuxGeomPublicRenderflags_DrawInFrontMode : AZ::u32 { e_DrawInFrontOff = 0x0u << e_DrawInFrontShift , e_DrawInFrontOn = 0x1u << e_DrawInFrontShift }

enum	EAuxGeomPublicRenderflags_FillMode : AZ::u32 { e_FillModeSolid = 0x0u << e_FillModeShift , e_FillModeWireframe = 0x1u << e_FillModeShift , e_FillModePoint = 0x2u << e_FillModeShift }

enum	EAuxGeomPublicRenderflags_CullMode : AZ::u32 { e_CullModeNone = 0x0u << e_CullModeShift , e_CullModeFront = 0x1u << e_CullModeShift , e_CullModeBack = 0x2u << e_CullModeShift }

enum	EAuxGeomPublicRenderflags_DepthWrite : AZ::u32 { e_DepthWriteOn = 0x0u << e_DepthWriteShift , e_DepthWriteOff = 0x1u << e_DepthWriteShift }

enum	EAuxGeomPublicRenderflags_DepthTest : AZ::u32 { e_DepthTestOn = 0x0u << e_DepthTestShift , e_DepthTestOff = 0x1u << e_DepthTestShift }

enum class	TextHorizontalAlignment : uint16_t { Left , Right , Center }

enum class	TextVerticalAlignment : uint16_t { Top , Bottom , Center }

enum class	SystemCursorState { Unknown , ConstrainedAndHidden , ConstrainedAndVisible , UnconstrainedAndHidden , UnconstrainedAndVisible }
	State of the system cursor. More...

enum class	ModifierKeyMask : int { None = 0x0000 , AltL = 0x0001 , AltR = 0x0002 , CtrlL = 0x0004 , CtrlR = 0x0008 , ShiftL = 0x0010 , ShiftR = 0x0020 , SuperL = 0x0040 , SuperR = 0x0080 , AltAny = (AltL \| AltR) , CtrlAny = (CtrlL \| CtrlR) , ShiftAny = (ShiftL \| ShiftR) , SuperAny = (SuperL \| SuperR) }

enum class	InterpolationMode : AZ::u32 { NoInterpolation , LinearInterpolation }

enum	ProcessCommunicationType { COMMUNICATOR_TYPE_STDINOUT , COMMUNICATOR_TYPE_NONE }

enum	ProcessPriority { PROCESSPRIORITY_NORMAL , PROCESSPRIORITY_BELOWNORMAL , PROCESSPRIORITY_IDLE }

enum class	ViewportControllerPriority : uint8_t { Highest = 0 , High , Normal , Low , Lowest , DispatchToAllPriorities }

Functions
const char *	SimpleAssetTypeGetName (const AZ::Data::AssetType &assetType)

const char *	SimpleAssetTypeGetFileFilter (const AZ::Data::AssetType &assetType)

bool	GetGemsInfo (AZStd::vector< GemInfo > &gemInfoList, AZ::SettingsRegistryInterface &settingsRegistry)

ModifierKeyMask	GetCorrespondingModifierKeyMask (const InputChannelId &channelId)

static const LocalUserId	LocalUserIdAny (std::numeric_limits< AZ::u32 >::max())
	Constant representing any local user id.

static const LocalUserId	LocalUserIdNone (std::numeric_limits< AZ::u32 >::max() - 1)
	Constant representing no local user id.

float	AdjustForDeadZoneAndNormalizeAnalogInput (float value, float deadZone, float maximumAbsoluteValue)

AZ::Vector2	AdjustForDeadZoneAndNormalizeThumbStickInput (float valueX, float valueY, float radialDeadZone, float maximumRadiusValue)

bool	IsAnyKeyOrButton (const InputChannel &inputChannel)

template<class InputChannelClass , typename RawEventType >
void	ProcessRawInputEventQueues (AZStd::unordered_map< InputChannelId, AZStd::vector< RawEventType >> &rawEventQueuesById, const AZStd::unordered_map< InputChannelId, InputChannelClass * > &inputChannelsById)

void	ProcessRawInputTextEventQueue (AZStd::vector< AZStd::string > &rawTextEventQueue)

	AZ_ENUM_CLASS_WITH_UNDERLYING_TYPE (PaintBrushBlendMode, uint8_t,(Normal, 0),(Add, 1),(Subtract, 2),(Multiply, 3),(Screen, 4),(Darken, 5),(Lighten, 6),(Average, 7),(Overlay, 8))
	The different types of blend modes supported by the paint brush tool.

	AZ_ENUM_CLASS_WITH_UNDERLYING_TYPE (PaintBrushSmoothMode, uint8_t,(Gaussian, 0),(Mean, 1),(Median, 2))
	The different types of smoothing modes supported by the paint brush tool.

	AZ_ENUM_CLASS (QualityLevel,(Invalid, -2),(LevelFromDeviceRules, -1),(DefaultQualityLevel, 0))

	AZ_TYPE_INFO_SPECIALIZE (QualityLevel, "{9AABD1B2-D433-49FE-A89D-2BEF09A252C0}")

	AZ_DEFINE_ENUM_ARITHMETIC_OPERATORS (QualityLevel)

	AZ_DEFINE_ENUM_RELATIONAL_OPERATORS (QualityLevel)

	AZ_ENUM_CLASS (DeviceRuleResolution,(Invalid, -1),(Min, 0),(Max, 1),(First, 2),(Last, 3))

	AZ_TYPE_INFO_SPECIALIZE (DeviceRuleResolution, "{DB0E23FC-433A-4A95-BEFA-8E39E3A1E344}")

	AZ_DEFINE_ENUM_ARITHMETIC_OPERATORS (DeviceRuleResolution)

	AZ_DEFINE_ENUM_RELATIONAL_OPERATORS (DeviceRuleResolution)

void	ConstructScriptAssetPaths (ScriptCompileRequest &request)

AZ::Outcome< void, AZStd::string >	CompileScript (ScriptCompileRequest &request)

AZ::Outcome< void, AZStd::string >	CompileScriptAndAsset (ScriptCompileRequest &request)

AZ::Outcome< void, AZStd::string >	CompileScript (ScriptCompileRequest &request, AZ::ScriptContext &context)

AZ::Outcome< AZStd::string, AZStd::string >	CompileScriptAndSaveAsset (ScriptCompileRequest &request)

bool	SaveLuaAssetData (const AZ::LuaScriptData &data, AZ::IO::GenericStream &stream)

void	ReflectScriptDebugClasses (AZ::ReflectContext *reflection)

AZ::ComponentDescriptor *	CreateScriptDebugAgentFactory ()

static constexpr AZ::Crc32	LuaToolsKey ("LuaRemoteTools")

	AZ_TYPE_SAFE_INTEGRAL (SpawnablePriority, uint8_t)

	AZ_DEFINE_ENUM_BITWISE_OPERATORS (AzFramework::SpawnableEntitiesManager::CommandQueuePriority)

	AZ_TYPE_SAFE_INTEGRAL (SpawnableMetaDataArraySize, uint64_t)

	AZ_CVAR_EXTERNED (bool, ed_cameraSystemUseCursor)

AZ::Vector3	EulerAngles (const AZ::Matrix3x3 &orientation)

void	MovePivotDetached (Camera &camera, const AZ::Vector3 &pivot)
	Helper to allow the pivot to be positioned without altering the camera's position.

void	UpdateCameraFromTransform (Camera &camera, const AZ::Transform &transform)
	Extracts Euler angles (orientation) and translation from the transform and writes the values to the camera.

void	UpdateCameraFromTranslationAndRotation (Camera &camera, const AZ::Vector3 &translation, const AZ::Vector3 &eulerAngles)
	Writes the translation value and Euler angles to the camera.

float	SmoothValueTime (float smoothness, float deltaTime)

float	SmoothValue (float target, float current, float smoothness, float deltaTime)

float	SmoothValue (float target, float current, float time)

Camera	SmoothCamera (const Camera &currentCamera, const Camera &targetCamera, const CameraProps &cameraProps, float deltaTime)

AZStd::tuple< float, float >	CameraPitchMinMaxRadians ()
	Returns min/max values for camera pitch (in radians).

AZStd::tuple< float, float >	CameraPitchMinMaxRadiansWithTolerance ()

float	ClampPitchRotation (const float pitch)

float	WrapYawRotation (const float yaw)

PanAxes	LookPan (const Camera &camera)
	PanAxes to use while in 'look' or 'orbit' camera behavior.

PanAxes	OrbitPan (const Camera &camera)

void	TranslatePivotLook (Camera &camera, const AZ::Vector3 &delta)

void	TranslateOffsetOrbit (Camera &camera, const AZ::Vector3 &delta)

AZ::Matrix3x3	LookTranslation (const Camera &camera)
	TranslationAxes to use while in 'look' or 'orbit' camera behavior.

AZ::Matrix3x3	OrbitTranslation (const Camera &camera)
	Optional TranslationAxes to use while in 'orbit' camera behavior.

AZ::Vector3	FocusLook (float)

AZ::Vector3	FocusOrbit (const float length)

InputState	BuildInputEvent (const InputChannel &inputChannel, const AzFramework::ModifierKeyStates &modifiers, const WindowSize &windowSize)
	Map from a generic InputChannel event to a camera specific InputEvent.

CameraState	CreateCamera (const AZ::Transform &transform, float nearPlane, float farPlane, float verticalFovRad, const ScreenSize &viewportSize)
	Create a camera at the given transform, specifying the near and far clip planes as well as the fov with a specific viewport size.

CameraState	CreateDefaultCamera (const AZ::Transform &transform, const ScreenSize &viewportSize)

CameraState	CreateIdentityDefaultCamera (const AZ::Vector3 &position, const ScreenSize &viewportSize)

CameraState	CreateCameraFromWorldFromViewMatrix (const AZ::Matrix4x4 &worldFromView, const ScreenSize &viewportSize)

void	SetCameraClippingVolume (CameraState &cameraState, float nearPlane, float farPlane, float verticalFovRad)
	Override the default near/far clipping planes and fov of the camera.

void	SetCameraClippingVolumeFromPerspectiveFovMatrixRH (CameraState &cameraState, const AZ::Matrix4x4 &clipFromView)
	Override the default near/far clipping planes and fov of the camera by inferring them the specified right handed transform into clip space.

float	RetrieveFov (const AZ::Matrix4x4 &clipFromView)
	Retrieve the field of view (Fov) from the perspective projection matrix (view space to clip space).

void	SetCameraTransform (CameraState &cameraState, const AZ::Transform &transform)
	Set the transform for an existing camera.

void	ScreenGeometryReflect (AZ::ReflectContext *context)

const ScreenVector	operator- (const ScreenPoint &lhs, const ScreenPoint &rhs)

ScreenPoint &	operator+= (ScreenPoint &lhs, const ScreenVector &rhs)

ScreenPoint &	operator-= (ScreenPoint &lhs, const ScreenVector &rhs)

const ScreenPoint	operator+ (const ScreenPoint &lhs, const ScreenVector &rhs)

const ScreenPoint	operator- (const ScreenPoint &lhs, const ScreenVector &rhs)

ScreenVector &	operator+= (ScreenVector &lhs, const ScreenVector &rhs)

ScreenVector &	operator-= (ScreenVector &lhs, const ScreenVector &rhs)

const ScreenVector	operator+ (const ScreenVector &lhs, const ScreenVector &rhs)

const ScreenVector	operator- (const ScreenVector &lhs, const ScreenVector &rhs)

const bool	operator== (const ScreenPoint &lhs, const ScreenPoint &rhs)

const bool	operator!= (const ScreenPoint &lhs, const ScreenPoint &rhs)

const bool	operator== (const ScreenVector &lhs, const ScreenVector &rhs)

const bool	operator!= (const ScreenVector &lhs, const ScreenVector &rhs)

const bool	operator== (const ScreenSize &lhs, const ScreenSize &rhs)

const bool	operator!= (const ScreenSize &lhs, const ScreenSize &rhs)

ScreenVector &	*operator=** (ScreenVector &lhs, const float rhs)

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

ScreenSize &	*operator=** (ScreenSize &lhs, const float rhs)

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

float	ScreenVectorLength (const ScreenVector &screenVector)

AZ::Vector2	Vector2FromScreenPoint (const ScreenPoint &screenPoint)
	Return an AZ::Vector2 from a ScreenPoint.

AZ::Vector3	Vector3FromScreenPoint (const ScreenPoint &screenPoint, const float z=0.0f)
	Return an AZ::Vector3 from a ScreenPoint (including z/depth value, defaulting to 0.0f).

AZ::Vector2	Vector2FromScreenVector (const ScreenVector &screenVector)
	Return an AZ::Vector2 from a ScreenVector.

AZ::Vector2	Vector2FromScreenSize (const ScreenSize &screenSize)
	Return an AZ::Vector2 from a ScreenSize.

ScreenPoint	ScreenPointFromVector2 (const AZ::Vector2 &vector2)
	Return a ScreenPoint from an AZ::Vector2.

ScreenVector	ScreenVectorFromVector2 (const AZ::Vector2 &vector2)
	Return a ScreenVector from an AZ::Vector2.

ScreenSize	ScreenSizeFromVector2 (const AZ::Vector2 &vector2)
	Return a ScreenSize from an AZ::Vector2.

ScreenPoint	ScreenPointFromNdc (const AZ::Vector2 &screenNdc, const ScreenSize &viewportSize)

AZ::Vector2	NdcFromScreenPoint (const ScreenPoint &screenPoint, const ScreenSize &viewportSize)

AZ::Vector3	WorldToScreenNdc (const AZ::Vector3 &worldPosition, const AZ::Matrix3x4 &cameraView, const AZ::Matrix4x4 &cameraProjection)
	Projects a position in world space to screen space normalized device coordinates for the given camera.

ScreenPoint	WorldToScreen (const AZ::Vector3 &worldPosition, const CameraState &cameraState)
	Projects a position in world space to screen space for the given camera.

ScreenPoint	WorldToScreen (const AZ::Vector3 &worldPosition, const AZ::Matrix3x4 &cameraView, const AZ::Matrix4x4 &cameraProjection, const ScreenSize &viewportSize)

AZ::Vector3	ScreenToWorld (const ScreenPoint &screenPosition, const CameraState &cameraState)

AZ::Vector3	ScreenToWorld (const ScreenPoint &screenPosition, const AZ::Matrix3x4 &inverseCameraView, const AZ::Matrix4x4 &inverseCameraProjection, const ScreenSize &viewportSize)

AZ::Vector3	ScreenNdcToWorld (const AZ::Vector2 &ndcPosition, const AZ::Matrix3x4 &inverseCameraView, const AZ::Matrix4x4 &inverseCameraProjection)

AZ::Matrix4x4	CameraProjection (const CameraState &cameraState)
	Returns the camera projection for the current camera state.

AZ::Matrix4x4	InverseCameraProjection (const CameraState &cameraState)
	Returns the inverse of the camera projection for the current camera state.

AZ::Matrix3x4	CameraView (const CameraState &cameraState)

AZ::Matrix3x4	InverseCameraView (const CameraState &cameraState)

AZ::Matrix3x4	CameraTransform (const CameraState &cameraState)

AZ::Matrix3x4	CameraTransformFromCameraView (const AZ::Matrix3x4 &cameraView)

AZ::Matrix3x4	CameraViewFromCameraTransform (const AZ::Matrix3x4 &cameraTransform)

AZ::Frustum	FrustumFromCameraState (const CameraState &cameraState)
	Returns a frustum representing the camera transform and view volume in world space.

AZ::ViewFrustumAttributes	ViewFrustumAttributesFromCameraState (const CameraState &cameraState)
	Returns a structure representing frustum attributes for the current camera state.

float	AspectRatio (const ScreenSize &screenSize)

AZ::Aabb	CalculateEntityLocalBoundsUnion (const AZ::Entity *entity)

AZ::Aabb	CalculateEntityWorldBoundsUnion (const AZ::Entity *entity)

	AZ_ENUM_CLASS_WITH_UNDERLYING_TYPE (OcclusionState, uint32_t, Unknown, Hidden, Visible)

	AZ_TYPE_INFO_SPECIALIZE (OcclusionState, "{1F6EE4E1-FD5C-4D80-AC72-E2C6C5E4A53F}")

void	DisplayFrustum (const AZ::Frustum &frustum, DebugDisplayRequests &debugDisplay)

void	DisplayFrustum (const AZ::ViewFrustumAttributes &viewFrustumAttribs, DebugDisplayRequests &debugDisplay)

void	DisplayFrustum (const AZ::Transform &worldFromView, float aspect, float fovRadians, float nearClip, float farClip, DebugDisplayRequests &debugDisplay)

void	DisplayOctreeDebug (const OctreeDebug &octreeDebug, DebugDisplayRequests &debugDisplay)

void	LocalUserIdReflect (AZ::ReflectContext *context)
	Reflection (AZ::u32 is already reflected)

AZStd::string	LocalUserIdToString (const LocalUserId &localUserId)
	Convert to a string (use for debugging purposes only)

const InputChannelId *	GetInputChannelIdFromRawKeyEvent (AZ::u32 scanCode, AZ::u32 virtualKeyCode, bool hasExtendedKeyPrefix)

AZStd::unordered_map< InputChannelId, AZ::u32 >	ConstructScanCodeByInputChannelIdMap ()

AZ::u32	GetScanCodeFromInputChannelId (const InputChannelId &inputChannelId)

Variables
constexpr const char *	AssetBundleManifestTypeId = "{8628A669-7B19-4C48-A7CB-F670CC9586FD}"

constexpr const char	s_benchmarkAssetExtension [] = "benchmark"

constexpr const char	s_benchmarkSettingsAssetExtension [] = "benchmarksettings"

constexpr AZ::Uuid	SimpleAssetReferenceTypeId { "{D03D0CF6-9A61-4DBA-AC53-E62453CE940D}" }

constexpr AZ::s32	g_defaultSceneEntityDebugDisplayId = AZ_CRC_CE("MainViewportEntityDebugDisplayId")

static constexpr FontId	InvalidFontId = 0xffffffffu

static constexpr AZ::u32	SelfNetworkId = 0xFFFFFFFF

static constexpr AZ::u32	InvalidRemoteToolsConnectionId = 0xFFFFFFFF

static const AZ::Name	LuaToolsName = AZ::Name::FromStringLiteral("LuaRemoteTools", nullptr)

static constexpr uint16_t	LuaToolsPort = 6777

static constexpr SpawnablePriority	SpawnablePriority_Highest { 0 }

static constexpr SpawnablePriority	SpawnablePriority_High { 32 }

static constexpr SpawnablePriority	SpawnablePriority_Default { 128 }

static constexpr SpawnablePriority	SpawnablePriority_Low { 192 }

static constexpr SpawnablePriority	SpawnablePriority_Lowest { 255 }

constexpr float	CameraPitchTolerance = 1.0e-4f
	Tolerance to use when limiting pitch to avoid reaching +/-Pi/2 exactly.

constexpr float	DefaultMouseMoveDeadZone = 2.0f

static constexpr ViewportId	InvalidViewportId = std::numeric_limits<ViewportId>::max()

static constexpr uint8_t	s_XcbResponseTypeMask = 0x7f

Detailed Description

Namespace for file functions.

Common structures for Render geometry queries.

Asset references are simply game-folder relative paths. This will change as the asset system comes online, but in the mean time we need something we can reflect and use intuitively in the editor.

Asset types are a simple class with a required API, e.g.:

class MyAsset { static const char* GetName() { return "MyAsset"; } static const char* GetFileFilter() { return "*.myasset;*.myasset2"; } static const char* GetUuid() { return "{00000000-0000-0000-0000-000000000000}"; } }

You must register your asset type's information with the environment and serialization context: SimpleAssetReference<MyAsset>::Register(serializeContext);

You can now reflect references to your asset from components, etc. e.g.: In class header: AzFramework::SimpleAssetReference<MyAsset> m_asset; In reflection: ->DataElement("SimpleAssetRef", &MeshComponent::m_meshAsset, "My Asset", "The asset to use")g

"SimpleAssetRef" tells the UI to use the corresponding widget. UI code will make use of your registered asset information to browse for the correct file types.

The FileFunc namespace is where we put some higher level file reading and writing operations.

Typedef Documentation

◆ AssetSystemInfoBus

using AzFramework::AssetSystemInfoBus = typedef AZ::EBus<AssetSystem::AssetSystemInfoNotifications>

AssetSystemBus removed - if you have a system which was using it use AssetCatalogEventBus for asset updates

◆ CommandFunction

using AzFramework::CommandFunction = typedef AZStd::function<CommandResult(const AZStd::vector<AZStd::string_view>& args)>

The command callback signature

◆ EntityContextEventBus

using AzFramework::EntityContextEventBus = typedef AZ::EBus<EntityContextEvents>

The EBus for entity context events. The events are defined in the AzFramework::EntityContextEvents class. If you want to receive event notifications from a specific entity context, such as the game entity context, use the bus specific to that context. If you want to receive event notifications from multiple types of entity contexts, use this bus.

◆ EntityContextId

typedef AZ::Uuid AzFramework::EntityContextId

Unique ID for an entity context.

◆ EntityContextRequestBus

using AzFramework::EntityContextRequestBus = typedef AZ::EBus<EntityContextRequests>

The EBus for requests to the entity context. The events are defined in the AzFramework::EntityContextRequests class. If you want to make requests to a specific entity context, such as the game entity context, use the bus specific to that context. If you want to make requests to multiple types of entity contexts, use this bus.

◆ EntityIdContextQueryBus

using AzFramework::EntityIdContextQueryBus = typedef AZ::EBus<EntityIdContextQueries>

The EBus for querying an entity about its context. The events are defined in the AzFramework::EntityIdContextQueries class.

◆ GameEntityContextEventBus

using AzFramework::GameEntityContextEventBus = typedef AZ::EBus<GameEntityContextEvents>

The EBus for game entity context events. The events are defined in the AzFramework::GameEntityContextEvents class.

◆ GameEntityContextRequestBus

using AzFramework::GameEntityContextRequestBus = typedef AZ::EBus<GameEntityContextRequests>

The EBus for requests to the game entity context. The events are defined in the AzFramework::GameEntityContextRequests class.

◆ SliceInstantiationResultBus

using AzFramework::SliceInstantiationResultBus = typedef AZ::EBus<SliceInstantiationResults>

The EBus that notifies you about the results of your slice instantiation requests. The events are defined in the AzFramework::SliceInstantiationResults class.

◆ TransformComponentConfiguration

using AzFramework::TransformComponentConfiguration = typedef AZ::TransformConfig

Deprecated:: Use AZ::TransformConfig

◆ TranslationDeltaFn

using AzFramework::TranslationDeltaFn = typedef AZStd::function<void(Camera& camera, const AZ::Vector3& delta)>

TranslationDeltaFn is used by PanCameraInput and TranslateCameraInput

Note: Choose the appropriate function if the behavior should be operating as a free look camera (TranslatePivotLook) or an orbit camera (TranslateOffsetOrbit).

Enumeration Type Documentation

◆ CommandFlags

enum AzFramework::CommandFlags : AZ::u32

Flags to combine for a command to describe its behavior in the command callback system Note: the command flag values should match "enum EVarFlags" values inside IConsole.h

◆ CommandResult

enum AzFramework::CommandResult

strong

Standard results from a command callback function

◆ InterpolationMode

enum AzFramework::InterpolationMode : AZ::u32

strong

Behavior types for smoothing of transform between network updates.

◆ SystemCursorState

enum AzFramework::SystemCursorState

strong

State of the system cursor.

Enumerator
Unknown	The state of the system cursor is not known.
ConstrainedAndHidden	Constrained to the application's main window and hidden.
ConstrainedAndVisible	Constrained to the application's main window and visible.
UnconstrainedAndHidden	Free to move outside the main window but hidden while inside.
UnconstrainedAndVisible	Free to move outside the application's main window and visible.

◆ ViewportControllerPriority

enum AzFramework::ViewportControllerPriority : uint8_t

strong

Controller Priority determines when controllers receive input and update events. Controller Priority is provided by the list containing a viewport controller. Input channel events are received from highest to lowest priority order, allowing high priority controllers to consume input events and stop their propagation. Viewport update events are received from lowest to highest priority order, allowing high priority controllers to be the last to update the viewport state.

Controller lists may receive DispatchToAllPriorities events, which will in turn dispatch events to all of their children in priority order.

See also: AzFramework::ViewportControllerList

Note: Because of this behavior, a ViewportControllerList that belongs to another ViewportControllerList shall not receive a DispatchToAllPriorities event, and instead shall receive multiple events from its parent at all priority levels.

Function Documentation

◆ AdjustForDeadZoneAndNormalizeAnalogInput()

float AzFramework::AdjustForDeadZoneAndNormalizeAnalogInput	(	float	value,
		float	deadZone,
		float	maximumAbsoluteValue
	)

inline

Utility function to adjust and normalize an analog input value so that values within a given dead-zone are set to zero, and values outside ramp up smoothly to a given max absolute value.

Parameters

[in]	value	The analog value to adjust and normalize
[in]	deadZone	The dead zone within which the value will be set to zero
[in]	maximumAbsoluteValue	The maximum absolute value that the value will be clamped to

Returns: The analog value adjusted and normalized using the supplied dead-zone and max values

◆ AdjustForDeadZoneAndNormalizeThumbStickInput()

AZ::Vector2 AzFramework::AdjustForDeadZoneAndNormalizeThumbStickInput	(	float	valueX,
		float	valueY,
		float	radialDeadZone,
		float	maximumRadiusValue
	)

inline

Utility function to adjust and normalize thumb-stick values so that values within the given radial dead-zone are set to zero, and values outside ramp up smoothly to a given max radius.

Parameters

[in]	valueX	The thumb-stick x-axis value to adjust and normalize
[in]	valueY	The thumb-stick y-axis value to adjust and normalize
[in]	radialDeadZone	The radial dead zone within which the values will be set to zero
[in]	maximumRadiusValue	The maximum radius value that will be used to clamp the values

Returns: The thumb-stick values adjusted and normalized using the supplied dead-zone and max

◆ AspectRatio()

float AzFramework::AspectRatio ( const ScreenSize & screenSize )

inline

Returns the aspect ratio of the screen/viewport dimensions.

Note: Ensure ScreenSize represents a valid viewport size/dimension before calling this function.

◆ CalculateEntityLocalBoundsUnion()

AZ::Aabb AzFramework::CalculateEntityLocalBoundsUnion ( const AZ::Entity * entity )

Returns a union of all local Aabbs provided by components implementing the BoundsRequestBus.

Note: It is preferred to call this function as opposed to GetLocalBounds directly as more than one component may be implementing this bus on an Entity and so only the first result (Aabb) will be returned.

◆ CalculateEntityWorldBoundsUnion()

AZ::Aabb AzFramework::CalculateEntityWorldBoundsUnion ( const AZ::Entity * entity )

Returns a union of all world Aabbs provided by components implementing the BoundsRequestBus.

Note: It is preferred to call this function as opposed to GetWorldBounds directly as more than one component may be implementing this bus on an Entity and so only the first result (Aabb) will be returned.

◆ CameraPitchMinMaxRadiansWithTolerance()

AZStd::tuple<float, float> AzFramework::CameraPitchMinMaxRadiansWithTolerance ( )

inline

Returns min/max values for camera pitch (in radians) including a small tolerance at each extreme (looking directly up or down) to avoid floating point accuracy issues.

◆ CameraTransform()

AZ::Matrix3x4 AzFramework::CameraTransform ( const CameraState & cameraState )

Returns the camera transform for the current camera state.

Note: This is the inverse of 'v' in the MVP transform going from view space to world space (worldFromView).

◆ CameraTransformFromCameraView()

AZ::Matrix3x4 AzFramework::CameraTransformFromCameraView ( const AZ::Matrix3x4 & cameraView )

Takes a camera view (the world to camera space transform) and returns the corresponding camera transform (the world position and orientation of the camera).

Note: The parameter is the viewFromWorld transform (the 'v' in MVP) going from world space to view space. The return value is worldFromView transform going from view space to world space.

◆ CameraView()

AZ::Matrix3x4 AzFramework::CameraView ( const CameraState & cameraState )

Returns the camera view for the current camera state.

Note: This is the 'v' in the MVP transform going from world space to view space (viewFromWorld).

◆ CameraViewFromCameraTransform()

AZ::Matrix3x4 AzFramework::CameraViewFromCameraTransform ( const AZ::Matrix3x4 & cameraTransform )

Takes a camera transform (the world position and orientation of the camera) and returns the corresponding camera view (to be used to transform from world to camera space).

Note: The parameter is the worldFromView transform going from view space to world space. The return value is viewFromWorld transform (the 'v' in MVP) going from view space to world space.

◆ ClampPitchRotation()

float AzFramework::ClampPitchRotation ( const float pitch )

inline

Clamps pitch to be +/-90 degrees (-Pi/2, Pi/2) with a minor tolerance at each extreme.

Parameters

pitch Pitch angle in radians.

◆ ConstructScanCodeByInputChannelIdMap()

AZStd::unordered_map<InputChannelId, AZ::u32> AzFramework::ConstructScanCodeByInputChannelIdMap ( )

inline

Construct a map of Windows scan codes indexed by their corresponding input channel id

Returns: A map of Windows scan codes indexed by their corresponding input channel id

◆ CreateCameraFromWorldFromViewMatrix()

CameraState AzFramework::CreateCameraFromWorldFromViewMatrix	(	const AZ::Matrix4x4 &	worldFromView,
		const ScreenSize &	viewportSize
	)

Create a camera transformed by the given view to world matrix with a specific viewport size.

Note: The near/far clip planes and fov are sensible default values - please use SetCameraClippingVolume to override them.

◆ CreateDefaultCamera()

CameraState AzFramework::CreateDefaultCamera	(	const AZ::Transform &	transform,
		const ScreenSize &	viewportSize
	)

Create a camera at the given transform with a specific viewport size.

Note: The near/far clip planes and fov are sensible default values - please use SetCameraClippingVolume to override them.

◆ CreateIdentityDefaultCamera()

CameraState AzFramework::CreateIdentityDefaultCamera	(	const AZ::Vector3 &	position,
		const ScreenSize &	viewportSize
	)

Create a camera at the given position (no orientation) with a specific viewport size.

Note: The near/far clip planes and fov are sensible default values - please use SetCameraClippingVolume to override them.

◆ EulerAngles()

AZ::Vector3 AzFramework::EulerAngles ( const AZ::Matrix3x3 & orientation )

Returns Euler angles (pitch, roll, yaw) for the incoming orientation.

Note: Order of rotation is Z, Y, X.

◆ FocusLook()

AZ::Vector3 AzFramework::FocusLook ( float )

inline

Callback to use for FocusCameraInput when a free look camera is being used.

Note: This is when offset is zero.

◆ FocusOrbit()

AZ::Vector3 AzFramework::FocusOrbit ( const float length )

inline

Callback to use for FocusCameraInput when a orbit camera is being used.

Note: This is when offset is non zero.

◆ GetGemsInfo()

bool AzFramework::GetGemsInfo	(	AZStd::vector< GemInfo > &	gemInfoList,
		AZ::SettingsRegistryInterface &	settingsRegistry
	)

Returns a list of GemInfo of all the gems that are active for the for the specified game project. Please note that the game project could be in a different location to the engine therefore we need the assetRoot param.

◆ GetInputChannelIdFromRawKeyEvent()

const InputChannelId* AzFramework::GetInputChannelIdFromRawKeyEvent	(	AZ::u32	scanCode,
		AZ::u32	virtualKeyCode,
		bool	hasExtendedKeyPrefix
	)

inline

Get the input channel id that corresponds to a raw keyboard key event

Parameters

[in]	scanCode	The Windows scan code of the key that was pressed
[in]	virtualKeyCode	The Windows virtual key code that was generated by the key press
[in]	hasExtendedKeyPrefix	Does the Windows scan code have the extended key prefix set?

Returns: The corresponding input channel id if found, nullptr otherwise

◆ GetScanCodeFromInputChannelId()

AZ::u32 AzFramework::GetScanCodeFromInputChannelId ( const InputChannelId & inputChannelId )

inline

Get the Windows scan code that corresponds to an input channel id

Parameters

[in] inputChannelId The input channel id whose corresponding scan code to return

Returns: The corresponding Windows scan code id if found, 0 otherwise

◆ InverseCameraView()

AZ::Matrix3x4 AzFramework::InverseCameraView ( const CameraState & cameraState )

Returns the inverse of the camera view for the current camera state.

Note: This is the same as the CameraTransform but corrected for Z up.

◆ NdcFromScreenPoint()

AZ::Vector2 AzFramework::NdcFromScreenPoint	(	const ScreenPoint &	screenPoint,
		const ScreenSize &	viewportSize
	)

inline

Returns a position in normalized device coordinates (in the range [0.0-1.0, 0.0-1.0]) from a screen space position (in the range [0-viewportSize.x, 0-viewportSize.y]).

◆ OrbitPan()

PanAxes AzFramework::OrbitPan ( const Camera & camera )

inline

Optional PanAxes to use while in 'orbit' camera behavior.

Note: This will move the camera in the local X/Y plane instead of usual X/Z plane.

◆ ProcessRawInputEventQueues()

template<class InputChannelClass , typename RawEventType >

void AzFramework::ProcessRawInputEventQueues	(	AZStd::unordered_map< InputChannelId, AZStd::vector< RawEventType >> &	rawEventQueuesById,
		const AZStd::unordered_map< InputChannelId, InputChannelClass * > &	inputChannelsById
	)

inline

Function template that processes a generic raw input event queue, given an InputChannelClass that defines a ProcessRawInputEvent function that takes a RawEventType as the only parameter.

Parameters

[in]	rawEventQueuesById	A map (keyed by id) of raw input event queues.
[in]	inputChannelsById	A map (keyed by id) of the input channels to potentially update.

◆ ProcessRawInputTextEventQueue()

void AzFramework::ProcessRawInputTextEventQueue ( AZStd::vector< AZStd::string > & rawTextEventQueue )

inline

Utility function that processes a queue of raw input text events.

Parameters

[in] rawTextEventQueue The queue of raw text events (all encoded using UTF-8)

◆ ScreenNdcToWorld()

AZ::Vector3 AzFramework::ScreenNdcToWorld	(	const AZ::Vector2 &	ndcPosition,
		const AZ::Matrix3x4 &	inverseCameraView,
		const AZ::Matrix4x4 &	inverseCameraProjection
	)

Unprojects a position in screen space normalized device coordinates to world space. Note: The position returned will be on the near clip plane of the camera in world space.

◆ ScreenPointFromNdc()

ScreenPoint AzFramework::ScreenPointFromNdc	(	const AZ::Vector2 &	screenNdc,
		const ScreenSize &	viewportSize
	)

inline

Returns a position in screen space (in the range [0-viewportSize.x, 0-viewportSize.y]) from normalized device coordinates (in the range 0.0-1.0).

◆ ScreenToWorld() [1/2]

AZ::Vector3 AzFramework::ScreenToWorld	(	const ScreenPoint &	screenPosition,
		const AZ::Matrix3x4 &	inverseCameraView,
		const AZ::Matrix4x4 &	inverseCameraProjection,
		const ScreenSize &	viewportSize
	)

Overload of ScreenToWorld that accepts camera values that can be precomputed if this function is called many times in a loop.

◆ ScreenToWorld() [2/2]

AZ::Vector3 AzFramework::ScreenToWorld	(	const ScreenPoint &	screenPosition,
		const CameraState &	cameraState
	)

Unprojects a position in screen space pixel coordinates to world space. Note: The position returned will be on the near clip plane of the camera in world space.

◆ SimpleAssetTypeGetFileFilter()

const char* AzFramework::SimpleAssetTypeGetFileFilter ( const AZ::Data::AssetType & assetType )

Retrieves the file filter for an asset type. This information is stored in the environment, so it's accessible from any module.

◆ SimpleAssetTypeGetName()

const char* AzFramework::SimpleAssetTypeGetName ( const AZ::Data::AssetType & assetType )

Retrieves the name of an asset by asset type (which is actually a name Crc). This information is stored in the environment, so it's accessible from any module.

◆ SmoothCamera()

Camera AzFramework::SmoothCamera	(	const Camera &	currentCamera,
		const Camera &	targetCamera,
		const CameraProps &	cameraProps,
		float	deltaTime
	)

An interpolation function to smoothly interpolate all camera properties from currentCamera to targetCamera. The camera returned will be some value between current and target camera.

Note: The rate of interpolation can be customized with CameraProps.

◆ SmoothValueTime()

float AzFramework::SmoothValueTime	(	float	smoothness,
		float	deltaTime
	)

Returns the time ('t') input value to use with SmoothValue. Useful if it is to be reused for multiple calls to SmoothValue.

◆ TranslateOffsetOrbit()

void AzFramework::TranslateOffsetOrbit	(	Camera &	camera,
		const AZ::Vector3 &	delta
	)

inline

Update the offset camera position.

Note: delta still needs to be transformed to world space (as with TranslatePivotLook) but internally this is undone to be performed in local space when being applied to m_offset.

◆ TranslatePivotLook()

void AzFramework::TranslatePivotLook	(	Camera &	camera,
		const AZ::Vector3 &	delta
	)

inline

Update the pivot camera position.

Note: delta will need to have been transformed to world space, e.g. To move the camera right, (1, 0, 0) must first be transformed by the orientation of the camera before being applied to m_pivot.

◆ WorldToScreen()

ScreenPoint AzFramework::WorldToScreen	(	const AZ::Vector3 &	worldPosition,
		const AZ::Matrix3x4 &	cameraView,
		const AZ::Matrix4x4 &	cameraProjection,
		const ScreenSize &	viewportSize
	)

Overload of WorldToScreen that accepts camera values that can be precomputed if this function is called many times in a loop.

◆ WrapYawRotation()

float AzFramework::WrapYawRotation ( const float yaw )

inline

Ensures yaw wraps between 0 and 360 degrees (0, 2Pi).

Parameters

yaw	Yaw angle in radians.

Variable Documentation

◆ DefaultMouseMoveDeadZone

constexpr float AzFramework::DefaultMouseMoveDeadZone = 2.0f

inlineconstexpr

Default value to use for detecting if the mouse has moved far enough after a mouse down to no longer register a click when a mouse up occurs.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ AssetSystemInfoBus

◆ CommandFunction

◆ EntityContextEventBus

◆ EntityContextId

◆ EntityContextRequestBus

◆ EntityIdContextQueryBus

◆ GameEntityContextEventBus

◆ GameEntityContextRequestBus

◆ SliceInstantiationResultBus

◆ TransformComponentConfiguration

◆ TranslationDeltaFn

Enumeration Type Documentation

◆ CommandFlags

◆ CommandResult

◆ InterpolationMode

◆ SystemCursorState

◆ ViewportControllerPriority

Function Documentation

◆ AdjustForDeadZoneAndNormalizeAnalogInput()

◆ AdjustForDeadZoneAndNormalizeThumbStickInput()

◆ AspectRatio()

◆ CalculateEntityLocalBoundsUnion()

◆ CalculateEntityWorldBoundsUnion()

◆ CameraPitchMinMaxRadiansWithTolerance()

◆ CameraTransform()

◆ CameraTransformFromCameraView()

◆ CameraView()

◆ CameraViewFromCameraTransform()

◆ ClampPitchRotation()

◆ ConstructScanCodeByInputChannelIdMap()

◆ CreateCameraFromWorldFromViewMatrix()

◆ CreateDefaultCamera()

◆ CreateIdentityDefaultCamera()

◆ EulerAngles()

◆ FocusLook()

◆ FocusOrbit()

◆ GetGemsInfo()

◆ GetInputChannelIdFromRawKeyEvent()

◆ GetScanCodeFromInputChannelId()

◆ InverseCameraView()

◆ NdcFromScreenPoint()

◆ OrbitPan()

◆ ProcessRawInputEventQueues()

◆ ProcessRawInputTextEventQueue()

◆ ScreenNdcToWorld()

◆ ScreenPointFromNdc()

◆ ScreenToWorld() [1/2]

◆ ScreenToWorld() [2/2]

◆ SimpleAssetTypeGetFileFilter()

◆ SimpleAssetTypeGetName()

◆ SmoothCamera()

◆ SmoothValueTime()

◆ TranslateOffsetOrbit()

◆ TranslatePivotLook()

◆ WorldToScreen()

◆ WrapYawRotation()

Variable Documentation

◆ DefaultMouseMoveDeadZone