Namespaces
	Execution

Classes
class	RuntimeAssetSystemComponent

struct	FileLoadResult

class	AssetDescription

class	AssetRegistry

class	AssetRegistryRequests

struct	ExecutionLogData

class	ExecutionLogAsset

class	ExecutionLogAssetBus

class	RuntimeAssetDescription

struct	RuntimeData

struct	RuntimeDataOverrides

class	RuntimeAsset

class	RuntimeAssetHandler

struct	RuntimeInputs

class	SubgraphInterfaceAssetDescription

struct	SubgraphInterfaceData

class	SubgraphInterfaceAsset

class	SubgraphInterfaceAssetHandler

class	Connection

class	ConnectionRequests

struct	ContractDescriptor

class	Contract

class	ConnectionLimitContract

class	ContractRTTI

class	DisallowReentrantExecutionContract

class	DisplayGroupConnectedSlotLimitContract

class	DynamicTypeContract

class	IsReferenceTypeContract

class	MathOperatorContract

struct	OverloadSelection

struct	OverloadConfiguration

class	OverloadContractInterface

class	OverloadContract

class	SlotTypeContract

class	SupportsMethodContract

class	RestrictedTypeContract

struct	VersionData

struct	SlotId

struct	GraphIdentifier

struct	RuntimeVariable

struct	NamespacePathHasher

struct	DependencyReport

struct	OrderedDependencies

class	ScriptCanvasSettingsRequests

class	ScopedAuxiliaryEntityHandler

class	SourceDescription

class	SourceHandle

class	ScriptCanvasData

struct	BehaviorContextResultTag

class	Datum

class	DatumNotifications

class	DatumSystemNotifications

class	EBusHandler

class	EBusHandlerNodeRequests

class	Endpoint

class	NamedEndpoint

struct	GraphInfo

struct	VariableIdentifier

struct	BreakTag

struct	BreakpointTag

struct	ContinueTag

struct	ExecutionThreadBeginTag

struct	ExecutionThreadEndTag

struct	GetAvailableScriptTargetsTag

struct	GetActiveEntitiesTag

struct	GetActiveGraphsTag

struct	GetVariableValueTag

struct	GetVariableValuesTag

struct	GraphActivationTag

struct	GraphDeactivationTag

struct	InputSignalTag

struct	OutputSignalTag

struct	ReturnSignalTag

struct	AnnotateNodeSignalTag

struct	StepOverTag

struct	VariableChangeTag

struct	LoggableEvent

struct	TaggedParent

struct	ActiveGraphStatus

struct	ActiveEntityStatus

struct	DatumValue

struct	ActivationInfo

struct	Signal

struct	TaggedDataValue

struct	ExecutionThreadBeginning

struct	GraphInfoEventBase

struct	NodeStateChange

struct	AnnotateNodeSignal

class	ExecutionNotifications

class	LoggableEventVisitor

class	Graph
	Graph is the execution model of a ScriptCanvas graph. More...

class	GraphRequests
	These are public graph requests. More...

class	GraphNotifications

class	GraphConfigurationRequests

class	GraphConfigurationNotifications

class	EndpointNotifications

struct	GraphData
	Structure for maintaining GraphData. More...

class	GraphScopedIdentifier

class	SourceTree

struct	DeserializeResult

struct	SerializationResult

struct	MethodConfiguration

struct	MethodOutputConfig

class	ModifiableDatumView

class	NamedId

struct	VisualExtensionSlotConfiguration

class	NodePropertyInterfaceListener

class	NodePropertyInterface

class	TypedNodePropertyInterface

class	ComboBoxPropertyInterface

class	TypedComboBoxNodePropertyInterface

class	EnumComboBoxNodePropertyInterface

struct	SlotVersionCache

struct	NodeReplacementConfiguration

class	Node

struct	MultipleOutputInvoker

class	Nodeable

class	NodeRequests

class	LogNotifications

class	NodeNotifications

class	NodeFunctionGenericMultiReturnImpl

class	RegistrarGeneric

class	NodelingRequests

class	NodelingNotifications

struct	SystemComponentConfiguration

class	SystemRequests

class	BatchOperationNotifications
	Sends out event for when a batch operation happens on the ScriptCanvas side. More...

class	ScopedBatchOperation

class	SerializationListener

struct	TransientSlotIdentifier

struct	SlotState

class	Slot

class	SlotTypeUtils

struct	SlotDescriptor

struct	DescriptorHelper

struct	SlotDescriptors

struct	SlotConfiguration

struct	ExecutionSlotConfiguration

struct	DataSlotConfiguration

struct	DynamicDataSlotConfiguration

struct	SlotMetadata

class	BehaviorContextObject

struct	TypeProperties

struct	DataRegistry

class	ValidationResults

class	StatusRequests

class	ValidationRequests

class	UnspecifiedDynamicDataTypeEvent

class	InvalidExpressionEvent

class	InvalidPropertyEvent

class	InvalidRandomSignalEvent

class	InvalidVariableTypeEvent

class	ScopedDataConnectionEvent

class	ScriptEventVersionMismatch

class	InvalidReferenceEvent

class	UnknownEndpointEvent

class	UnknownTargetEndpointEvent

class	UnknownSourceEndpointEvent

class	UnusedNodeEvent

class	InvalidFunctionCallNameValidation

class	ParserValidation

class	NotYetImplemented

class	InactiveGraph

class	MultipleExecutionOutConnections

class	MultipleStartNodes

class	FocusOnEntityEffect

class	GreyOutNodeEffect

class	HighlightEntityEffect

class	HighlightVariableEffect

class	ValidationEvent

class	ErrorReporter
	Execution RequestBus for interfacing with a running graph. More...

struct	ExecutionStateConfig

class	ExecutionState
	base abstract class that is the interface for the ScriptCanvas runtime and the hosting environment. It allows for customization of initialization, starting, and stopping execution. It only works on on valid runtime data, and holds user data. For example, in the Entity/Component system, the user data stores the information required to provide the Entity and Component that own the running graph. The actual runtime implementation is entirely up to subclasses. More...

class	ExecutionStateHandler

class	Executor

class	ExecutionStateInterpreted

class	ExecutionStateInterpretedPerActivation

class	ExecutionStateInterpretedPerActivationOnGraphStart

class	ExecutionStateInterpretedPure

class	ExecutionStateInterpretedPureOnGraphStart

class	ExecutionStateInterpretedSingleton

struct	RuntimeComponentUserData

class	RuntimeComponent

struct	DeprecatedNodeLibrary
	Library holds all deprecated generic function nodes which will be cleaned up all together. More...

struct	NodeRegistry

class	ScriptCanvasModuleCommon

class	ScriptCanvasModule
	The ScriptCanvas::Module class coordinates with the application to reflect classes and create system components. More...

class	SystemComponent

class	BehaviorContextUtils

class	DataUtils

class	NodeUtils

class	SerializationUtils

class	VersionConverters

struct	NodeUpdateReport

struct	GraphUpdateReport

class	VersioningUtils

struct	ReplicaNetworkProperties
	Properties that govern Datum replication. More...

class	GraphVariable

class	GraphVariableManagerComponent

class	VariableRequests
	Bus Interface for adding, removing and finding exposed Variable datums associated with a ScriptCanvas Graph. More...

class	CopiedVariableData

class	GraphVariableManagerRequests

class	VariableNodeRequests

class	ScriptEventNodeRequests

struct	RequestByNodeIdTraits

class	GraphVariableManagerNotifications

class	VariableNotifications

class	VariableNodeNotifications

struct	VariableId

class	VariableData
	Variable Data structure for storing mappings of variable names to variable objects. More...

struct	EditableVariableConfiguration

class	EditableVariableData

Typedefs
using	AssetRegistryRequestBus = AZ::EBus< AssetRegistryRequests >

using	ExecutionLogAssetEBus = AZ::EBus< ExecutionLogAssetBus >

using	RuntimeAssetPtr = AZ::Data::Asset< RuntimeAsset >

using	ConnectionRequestBus = AZ::EBus< ConnectionRequests >

using	ContractCreationFunction = AZStd::function< Contract *()>
	Function which will be invoked when a slot is created to allow the creation of a slot contract object.

typedef AZStd::unordered_set< ScriptCanvas::Data::Type >	DataTypeSet

typedef AZStd::unordered_map< size_t, DataTypeSet >	DataSetIndexMapping

typedef AZStd::unordered_map< size_t, ScriptCanvas::Data::Type >	DataIndexMapping

using	GraphPtr = Graph *

using	GraphPtrConst = const Graph *

using	ID = AZ::EntityId

using	NamespacePath = AZStd::vector< AZStd::string >

using	NodeIdList = AZStd::vector< ID >

using	NodePtrList = AZStd::vector< Node * >

using	NodePtrConstList = AZStd::vector< const Node * >

using	PropertyFields = AZStd::vector< AZStd::pair< AZStd::string_view, SlotId > >

using	NamedActiveEntityId = AZ::NamedEntityId

using	NamedNodeId = NamedId< AZ::EntityId >

using	NamedSlotId = NamedId< SlotId >

using	NodeTypeIdentifier = AZStd::size_t

using	EBusEventId = AZ::Crc32

using	EBusBusId = AZ::Crc32

using	ScriptCanvasId = AZ::EntityId

using	DependencySet = AZStd::unordered_set< NamespacePath, NamespacePathHasher >

using	ScriptCanvasSettingsRequestBus = AZ::EBus< ScriptCanvasSettingsRequests >

using	DataPtr = AZStd::intrusive_ptr< ScriptCanvasData >

using	DataPtrConst = AZStd::intrusive_ptr< const ScriptCanvasData >

using	ComparisonOutcome = AZ::Outcome< bool, AZStd::string >

using	DatumNotificationBus = AZ::EBus< DatumNotifications >

using	DatumSystemNotificationBus = AZ::EBus< DatumSystemNotifications >

using	EBusHandlerNodeRequestBus = AZ::EBus< EBusHandlerNodeRequests >

using	Timestamp = AZ::u64

using	ActiveGraphStatusMap = AZStd::unordered_map< AZ::Data::AssetId, ActiveGraphStatus >

using	EntityActiveGraphStatusMap = AZStd::unordered_map< GraphIdentifier, ActiveGraphStatus >

using	ActiveEntityStatusMap = AZStd::unordered_map< AZ::EntityId, ActiveEntityStatus >

using	ActiveEntitiesAndGraphs = AZStd::pair< ActiveEntityStatusMap, ActiveGraphStatusMap >

using	SlotDataMap = AZStd::unordered_map< NamedSlotId, DatumValue >

using	VariableValues = AZStd::unordered_map< VariableId, AZStd::pair< AZStd::string, DatumValue > >

using	Breakpoint = TaggedParent< BreakpointTag, Signal >

using	ExecutionThreadEnd = TaggedParent< ExecutionThreadEndTag, GraphInfo >

using	GraphActivation = TaggedParent< GraphActivationTag, ActivationInfo >

using	GraphDeactivation = TaggedParent< GraphDeactivationTag, ActivationInfo >

using	InputSignal = TaggedParent< InputSignalTag, Signal >

using	OutputSignal = TaggedParent< OutputSignalTag, Signal >

using	ReturnSignal = TaggedParent< ReturnSignalTag, Signal >

using	VariableChange = TaggedDataValue< VariableChangeTag >

using	ExecutionNotificationsBus = AZ::EBus< ExecutionNotifications >

using	EndpointMapConstIterator = AZStd::unordered_multimap< Endpoint, Endpoint >::const_iterator

using	GraphRequestBus = AZ::EBus< GraphRequests >

using	GraphNotificationBus = AZ::EBus< GraphNotifications >

using	GraphConfigurationRequestBus = AZ::EBus< GraphConfigurationRequests >

using	GraphConfigurationNotificationBus = AZ::EBus< GraphConfigurationNotifications >

using	EndpointNotificationBus = AZ::EBus< EndpointNotifications >

typedef GraphScopedIdentifier< VariableId >	GraphScopedVariableId

typedef GraphScopedIdentifier< AZ::EntityId >	GraphScopedNodeId

typedef GraphScopedIdentifier< Endpoint >	GraphScopedEndpoint

using	ExecutionNameMap = AZStd::unordered_multimap< AZStd::string, AZStd::string >

using	ConstSlotsOutcome = AZ::Outcome< AZStd::vector< const Slot * >, AZStd::string >

using	SlotsOutcome = AZ::Outcome< AZStd::vector< Slot * >, AZStd::string >

using	EndpointResolved = AZStd::pair< const Node , const Slot >

using	EndpointsResolved = AZStd::vector< EndpointResolved >

using	NodeRequestBus = AZ::EBus< NodeRequests >

using	LogNotificationBus = AZ::EBus< LogNotifications >

using	NodeNotificationsBus = AZ::EBus< NodeNotifications >

template<typename t_Func , typename t_Traits , t_Func function>
using	NodeFunctionGenericMultiReturn = NodeFunctionGenericMultiReturnImpl< function, t_Traits >

using	NodelingRequestBus = AZ::EBus< NodelingRequests >

using	NodelingNotificationBus = AZ::EBus< NodelingNotifications >

using	SystemRequestBus = AZ::EBus< SystemRequests >

using	BatchOperationNotificationBus = AZ::EBus< BatchOperationNotifications >

using	SerializationListeners = AZStd::vector< SerializationListener * >

using	BehaviorContextObjectPtr = AZStd::intrusive_ptr< BehaviorContextObject >

using	GraphOwnerIdType = AZ::EntityId

using	RuntimeIdType = AZ::EntityId

using	StatusRequestBus = AZ::EBus< StatusRequests >

using	ValidationRequestBus = AZ::EBus< ValidationRequests >

using	ValidationPtr = AZStd::intrusive_ptr< ValidationEvent >

using	ValidationConstPtr = AZStd::intrusive_ptr< const ValidationEvent >

using	VariableDatum = Deprecated::VariableDatum

using	ErrorReporterBus = AZ::EBus< ErrorReporter >

using	ExecutionStateConstPtr = const ExecutionState *

using	ExecutionStatePtr = ExecutionState *

using	ExecutionStateWeakConstPtr = const ExecutionState *

using	ExecutionStateWeakPtr = ExecutionState *

using	ExecutionStateInterpretedConstPtr = const ExecutionStateInterpreted *

using	ExecutionStateInterpretedPtr = ExecutionStateInterpreted *

using	ExecutionStateInterpretedPureConstPtr = const ExecutionStateInterpretedPure *

using	ExecutionStateInterpretedPurePtr = ExecutionStateInterpretedPure *

using	ExecutionStateInterpretedSingletonConstPtr = const ExecutionStateInterpretedSingleton *

using	ExecutionStateInterpretedSingletonPtr = ExecutionStateInterpretedSingleton *

using	ExecutionUserData = AZStd::any

using	ReplacementEndpointPairs = AZStd::unordered_set< AZStd::pair< Endpoint, Endpoint > >

using	ReplacementConnectionMap = AZStd::unordered_map< AZ::EntityId, ReplacementEndpointPairs >

using	GraphVariableMapping = AZStd::unordered_map< VariableId, GraphVariable >

using	VariableRequestBus = AZ::EBus< VariableRequests >

using	VariableValidationOutcome = AZ::Outcome< void, GraphVariableValidationErrorCode >

using	GraphVariableManagerRequestBus = AZ::EBus< GraphVariableManagerRequests >

using	VariableNodeRequestBus = AZ::EBus< VariableNodeRequests, RequestByNodeIdTraits >

using	ScriptEventNodeRequestBus = AZ::EBus< ScriptEventNodeRequests, RequestByNodeIdTraits >

using	GraphVariableManagerNotificationBus = AZ::EBus< GraphVariableManagerNotifications >

using	VariableNotificationBus = AZ::EBus< VariableNotifications >

using	VariableNodeNotificationBus = AZ::EBus< VariableNodeNotifications >

using	NamedVariabledId = NamedId< VariableId >

Enumerations
enum class	IsPreloadedResult { Yes , PreloadBehaviorNotEnforced , DataNotLoaded }

enum class	PropertyStatus : AZ::u8 { Getter , None , Setter }

enum class	GrammarVersion : int { Initial = -1 , BackendSplit = 0 , Current }

enum class	RuntimeVersion : int { Initial = -1 , DirectTraversal = 0 , Current }

enum class	FileVersion : int { Initial = -1 , JSON = 0 , Current }

enum class	EventType { Broadcast , BroadcastQueue , Event , EventQueue , Count }

enum class	ExecutionMode : AZ::u8 { Interpreted , Native , COUNT }

enum class	AzEventIdentifier : size_t

enum class	LoadReferencedAssets { No , Yes }

enum class	MethodType { Event , Free , Member , Getter , Setter , Count }

enum class	UpdateResult { DirtyGraph , DeleteNode , DisableNode , Unknown }

enum class	NodeDisabledFlag : int { None = 0 , User = 1 << 0 , ErrorInUpdate = 1 << 1 , NonUser = ErrorInUpdate }

enum class	CombinedSlotType : AZ::s32 { None = 0 , ExecutionIn , ExecutionOut , DataIn , DataOut , LatentOut }

enum class	ConnectionType : AZ::s32 { Unknown = 0 , Input , Output }

enum class	SlotTypeDescriptor : AZ::s32 { Unknown = 0 , Execution , Data }

enum class	DynamicDataType : AZ::s32 { None = 0 , Value , Container , Any }

enum class	ValidationSeverity { Unknown = -1 , Error , Warning , Informative }

enum class	BuildConfiguration { Release , Performance , Debug }

enum class	ExecutionConfiguration { Release , Performance , Debug , Traced }

enum class	GraphVariableValidationErrorCode { Duplicate , Invalid , Unknown }

enum	ExposeOption : AZ::s32 { None = 0 , None , None = 0 , None = 0 , None = 0 , ComponentInput = 1 << 0 , ComponentOutput = 1 << 1 }

Functions
AZ::Outcome< SourceTree, AZStd::string >	LoadEditorAssetTree (SourceHandle handle, MakeInternalGraphEntitiesUnique makeUniqueEntities)

FileLoadResult	LoadFromFile (AZStd::string_view path, MakeInternalGraphEntitiesUnique makeEntityIdsUnique=MakeInternalGraphEntitiesUnique::Yes, LoadReferencedAssets loadReferencedAssets=LoadReferencedAssets::Yes)

IsPreloadedResult	IsPreloaded (const RuntimeDataOverrides &overrides)

constexpr const char *	ToString (IsPreloadedResult result)

IsPreloadedResult	IsPreloaded (RuntimeAssetPtr asset)

	AZ_CVAR_EXTERNED (bool, g_saveRuntimeAssetsAsPlainTextForDebug)

	AZ_CVAR_EXTERNED (bool, g_saveEditorAssetsAsPlainTextForDebug)

bool	IsNamespacePathEqual (const NamespacePath &lhs, const NamespacePath &rhs)

	DATUM_GET_NUMBER_SPECIALIZE (char)

	DATUM_GET_NUMBER_SPECIALIZE (short)

	DATUM_GET_NUMBER_SPECIALIZE (int)

	DATUM_GET_NUMBER_SPECIALIZE (long)

	DATUM_GET_NUMBER_SPECIALIZE (AZ::s8)

	DATUM_GET_NUMBER_SPECIALIZE (AZ::s64)

	DATUM_GET_NUMBER_SPECIALIZE (unsigned char)

	DATUM_GET_NUMBER_SPECIALIZE (unsigned int)

	DATUM_GET_NUMBER_SPECIALIZE (unsigned long)

	DATUM_GET_NUMBER_SPECIALIZE (unsigned short)

	DATUM_GET_NUMBER_SPECIALIZE (AZ::u64)

	DATUM_GET_NUMBER_SPECIALIZE (float)

	DATUM_SET_NUMBER_SPECIALIZE (char)

	DATUM_SET_NUMBER_SPECIALIZE (short)

	DATUM_SET_NUMBER_SPECIALIZE (int)

	DATUM_SET_NUMBER_SPECIALIZE (long)

	DATUM_SET_NUMBER_SPECIALIZE (AZ::s8)

	DATUM_SET_NUMBER_SPECIALIZE (AZ::s64)

	DATUM_SET_NUMBER_SPECIALIZE (unsigned char)

	DATUM_SET_NUMBER_SPECIALIZE (unsigned int)

	DATUM_SET_NUMBER_SPECIALIZE (unsigned long)

	DATUM_SET_NUMBER_SPECIALIZE (unsigned short)

	DATUM_SET_NUMBER_SPECIALIZE (AZ::u64)

	DATUM_SET_NUMBER_SPECIALIZE (float)

	DATUM_SET_VECTOR_SPECIALIZE (AZ::Vector2)

	DATUM_SET_VECTOR_SPECIALIZE (AZ::Vector3)

	DATUM_SET_VECTOR_SPECIALIZE (AZ::Vector4)

void	ReflectExecutionBusArguments (AZ::ReflectContext *context)

AZStd::string	ToString (const SlotDataMap &map)

AZStd::string	ToString (const VariableValues &variableValues)

DeserializeResult	Deserialize (AZStd::string_view source, MakeInternalGraphEntitiesUnique makeUniqueEntities=MakeInternalGraphEntitiesUnique::Yes, LoadReferencedAssets loadReferencedAssets=LoadReferencedAssets::Yes)

SerializationResult	Serialize (const ScriptCanvasData &graphData, AZ::IO::GenericStream &stream)

template<auto Function, typename t_Traits >
AZ::TypeNameString	GetO3deTypeName (AZ::Adl, AZStd::type_identity< NodeFunctionGenericMultiReturnImpl< Function, t_Traits >>)

template<auto Function, typename t_Traits >
AZ::TypeId	GetO3deTypeId (AZ::Adl, AZStd::type_identity< NodeFunctionGenericMultiReturnImpl< Function, t_Traits >>)

	AZ_RTTI_NO_TYPE_INFO_IMPL_INLINE ((NodeFunctionGenericMultiReturnImpl, AZ_TYPE_INFO_AUTO, AZ_TYPE_INFO_CLASS), Node)

constexpr bool	IsExecution (CombinedSlotType slotType)

constexpr bool	IsExecutionOut (CombinedSlotType slotType)

constexpr bool	IsData (CombinedSlotType slotType)

AZ_INLINE AZStd::string_view	GetInputSlotName ()

AZ_INLINE AZStd::string_view	GetOutputSlotName ()

AZ_INLINE AZStd::string_view	GetSourceSlotName ()

template<AZStd::size_t Capacity>
bool	CompareSignature (AZ::BehaviorMethod *method, const AZStd::array< AZ::Uuid, Capacity > &typeIds)

template<size_t startIndex, typename ArrayType , typename... Args, size_t... Indices>
void	UnpackParameterAtIndex (ArrayType &outArray, AZStd::index_sequence< Indices... >, Args &&... args)

void	BehaviorContextObjectPtrReflect (AZ::ReflectContext *context)

void	InitDataRegistry ()

void	ResetDataRegistry ()

AZ::EnvironmentVariable< DataRegistry >	GetDataRegistry ()

AZ::Outcome< void, AZStd::string >	IsExposable (const AZ::BehaviorMethod &method)

Grammar::FunctionPrototype	ToSignature (const AZ::BehaviorMethod &method)

void	InitLibraries ()

void	ResetLibraries ()

void	ReflectLibraries (AZ::ReflectContext *)

AZStd::vector< AZ::ComponentDescriptor * >	GetLibraryDescriptors ()

AZ::EnvironmentVariable< NodeRegistry >	GetNodeRegistry ()
	Deprecated, following is to support backward compatibility.

static constexpr AZ::Crc32	RemoteToolsKey ("ScriptCanvasRemoteTools")

void	MergeUpdateSlotReport (const AZ::EntityId &scriptCanvasNodeId, GraphUpdateReport &report, const NodeUpdateReport &source)

AZStd::vector< AZStd::pair< Endpoint, Endpoint > >	CollectEndpoints (const AZStd::vector< AZ::Entity * > &connections, bool logEntityNames=false)

void	UpdateConnectionStatus (Graph &graph, const GraphUpdateReport &report)

Variables
constexpr const AZ::u32	RuntimeDataSubId = AZ_CRC_CE("RuntimeData")

constexpr const AZ::u32	SubgraphInterfaceSubId = AZ_CRC_CE("SubgraphInterface")

constexpr const char *	k_EventOutPrefix = "ExecutionSlot:"

constexpr const char *	k_OnVariableWriteEventName = "OnVariableValueChanged"

constexpr const char *	k_OnVariableWriteEbusName = "VariableNotification"

constexpr const AZStd::string_view	k_VersionExplorerWindow = "VersionExplorerWindow"

const BehaviorContextResultTag	s_behaviorContextResultTag {}

static const GraphOwnerIdType	GraphOwnerId = AZ::EntityId(0xacedc0de)

static const RuntimeIdType	UniqueId = AZ::EntityId(0xfee1baad)

static constexpr const char *	s_dataRegistryName = "ScriptCanvasDataRegistry"

constexpr const char *	NotYetImplementedId = "SC-0000"

static const AZ::Crc32	NotYetImplementedCrc = AZ_CRC(NotYetImplementedId)

constexpr const AZ::u32	UserDataMark = AZ_CRC_CE("UserDataMark")

constexpr const char *	k_ExecutionStateAzTypeIdString = "{85C66E59-F012-460E-9756-B36819753F4D}"

static constexpr const char *	s_nodeRegistryName = "ScriptCanvasNodeRegistry"

static const AZ::Name	RemoteToolsName = AZ::Name::FromStringLiteral("ScriptCanvasRemoteTools", nullptr)

static constexpr uint16_t	RemoteToolsPort = 6787

Detailed Description

The EditContext and other facilities give script users, especially ScriptCanvas users the ability to create and initialize objects that cannot be easily created with a sequence of C++ code. Some Editor facilities give users access to private variables in objects that cannot be modified or initialized directly via their public C++ interface.

This ExecutionCloneSource objects exists to facilitate fast construction and initialization of the such objects when needed to execute compiled ScriptCanvas graphs properly.

Function Documentation

◆ LoadFromFile()

FileLoadResult ScriptCanvas::LoadFromFile	(	AZStd::string_view	path,
		MakeInternalGraphEntitiesUnique	makeEntityIdsUnique = `MakeInternalGraphEntitiesUnique::Yes`,
		LoadReferencedAssets	loadReferencedAssets = `LoadReferencedAssets::Yes`
	)

Loads the script canvas file at the given path.

Parameters

path	Path to the file to load
makeEntityIdsUnique	controls if the entity IDs are re-generated for the graph to make them unique. Set to true if there's a chance the graph may be loaded multiple times, so that buses can be used safely with those IDs. Set to false when doing operations that rely on stable entity ID order between runs.
loadReferencedAssets	controls whether referenced assets in the graph are loaded or not. In practice, this controls whether or not the graph and underlying nodes are fully activated.

Returns: An FileLoadResult with either the handle to the data loaded and a string with deserialization issues, or a failure if the file did not load.

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Function Documentation

◆ LoadFromFile()