Namespaces
namespace	Execution

Classes
struct	ActivationInfo

struct	ActiveEntityStatus

struct	ActiveGraphStatus

struct	AnnotateNodeSignal

struct	AnnotateNodeSignalTag

class	AssetDescription

class	AssetRegistry

class	AssetRegistryRequests

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

class	BehaviorContextObject

struct	BehaviorContextResultTag

class	BehaviorContextUtils

struct	BreakpointTag

struct	BreakTag

class	ComboBoxPropertyInterface

class	Connection

class	ConnectionLimitContract

class	ConnectionRequests

struct	ContinueTag

class	Contract

struct	ContractDescriptor

class	ContractRTTI

class	CopiedVariableData

struct	DataRegistry

struct	DataSlotConfiguration

class	DataUtils

class	Datum

class	DatumNotifications

class	DatumSystemNotifications

struct	DatumValue

struct	DependencyReport

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

struct	DescriptorHelper

struct	DeserializeResult

class	DisallowReentrantExecutionContract

class	DisplayGroupConnectedSlotLimitContract

struct	DynamicDataSlotConfiguration

class	DynamicTypeContract

class	EBusHandler

class	EBusHandlerNodeRequests

struct	EditableVariableConfiguration

class	EditableVariableData

class	Endpoint

class	EndpointNotifications

class	EnumComboBoxNodePropertyInterface

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

class	ExecutionLogAsset

class	ExecutionLogAssetBus

struct	ExecutionLogData

class	ExecutionNotifications

struct	ExecutionSlotConfiguration

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

struct	ExecutionStateConfig

class	ExecutionStateHandler

class	ExecutionStateInterpreted

class	ExecutionStateInterpretedPerActivation

class	ExecutionStateInterpretedPerActivationOnGraphStart

class	ExecutionStateInterpretedPure

class	ExecutionStateInterpretedPureOnGraphStart

class	ExecutionStateInterpretedSingleton

struct	ExecutionThreadBeginning

struct	ExecutionThreadBeginTag

struct	ExecutionThreadEndTag

class	Executor

struct	FileLoadResult

class	FocusOnEntityEffect

struct	GetActiveEntitiesTag

struct	GetActiveGraphsTag

struct	GetAvailableScriptTargetsTag

struct	GetVariableValuesTag

struct	GetVariableValueTag

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

struct	GraphActivationTag

class	GraphConfigurationNotifications

class	GraphConfigurationRequests

struct	GraphData
	Structure for maintaining GraphData. More...

struct	GraphDeactivationTag

struct	GraphIdentifier

struct	GraphInfo

struct	GraphInfoEventBase

class	GraphNotifications

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

class	GraphScopedIdentifier

struct	GraphUpdateReport

class	GraphVariable

class	GraphVariableManagerComponent

class	GraphVariableManagerNotifications

class	GraphVariableManagerRequests

class	GreyOutNodeEffect

class	HighlightEntityEffect

class	HighlightVariableEffect

class	InactiveGraph

struct	InputSignalTag

class	InvalidExpressionEvent

class	InvalidFunctionCallNameValidation

class	InvalidPropertyEvent

class	InvalidRandomSignalEvent

class	InvalidReferenceEvent

class	InvalidVariableTypeEvent

class	IsReferenceTypeContract

struct	LoggableEvent

class	LoggableEventVisitor

class	LogNotifications

class	MathOperatorContract

struct	MethodConfiguration

struct	MethodOutputConfig

class	ModifiableDatumView

class	MultipleExecutionOutConnections

struct	MultipleOutputInvoker

class	MultipleStartNodes

class	NamedEndpoint

class	NamedId

struct	NamespacePathHasher

class	Node

class	Nodeable

class	NodeFunctionGenericMultiReturnImpl

class	NodelingNotifications

class	NodelingRequests

class	NodeNotifications

class	NodePropertyInterface

class	NodePropertyInterfaceListener

struct	NodeRegistry

struct	NodeReplacementConfiguration

class	NodeRequests

struct	NodeStateChange

struct	NodeUpdateReport

class	NodeUtils

class	NotYetImplemented

struct	OrderedDependencies

struct	OutputSignalTag

struct	OverloadConfiguration

class	OverloadContract

class	OverloadContractInterface

struct	OverloadSelection

class	ParserValidation

class	RegistrarGeneric

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

struct	RequestByNodeIdTraits

class	RestrictedTypeContract

struct	ReturnSignalTag

class	RuntimeAsset

class	RuntimeAssetDescription

class	RuntimeAssetHandler

class	RuntimeAssetSystemComponent

class	RuntimeComponent

struct	RuntimeComponentUserData

struct	RuntimeData

struct	RuntimeDataOverrides

struct	RuntimeInputs

struct	RuntimeVariable

class	ScopedAuxiliaryEntityHandler

class	ScopedBatchOperation

class	ScopedDataConnectionEvent

class	ScriptCanvasData

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

class	ScriptCanvasModuleCommon

class	ScriptCanvasSettingsRequests

class	ScriptEventNodeRequests

class	ScriptEventVersionMismatch

class	SerializationListener

struct	SerializationResult

class	SerializationUtils

struct	Signal

class	Slot

struct	SlotConfiguration

struct	SlotDescriptor

struct	SlotDescriptors

struct	SlotId

struct	SlotMetadata

struct	SlotState

class	SlotTypeContract

class	SlotTypeUtils

struct	SlotVersionCache

class	SourceDescription

class	SourceHandle

class	SourceTree

class	StatusRequests

struct	StepOverTag

class	SubgraphInterfaceAsset

class	SubgraphInterfaceAssetDescription

class	SubgraphInterfaceAssetHandler

struct	SubgraphInterfaceData

class	SupportsMethodContract

class	SystemComponent

struct	SystemComponentConfiguration

class	SystemRequests

struct	TaggedDataValue

struct	TaggedParent

struct	TransientSlotIdentifier

class	TypedComboBoxNodePropertyInterface

class	TypedNodePropertyInterface

struct	TypeProperties

class	UnknownEndpointEvent

class	UnknownSourceEndpointEvent

class	UnknownTargetEndpointEvent

class	UnspecifiedDynamicDataTypeEvent

class	UnusedNodeEvent

class	ValidationEvent

class	ValidationRequests

class	ValidationResults

struct	VariableChangeTag

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

struct	VariableId

struct	VariableIdentifier

class	VariableNodeNotifications

class	VariableNodeRequests

class	VariableNotifications

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

class	VersionConverters

struct	VersionData

class	VersioningUtils

struct	VisualExtensionSlotConfiguration

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