1. Epic GamesDeveloper
  3. FKismetCompilerContext

FKismetCompilerContext

API > API/Editor > API/Editor/KismetCompiler

   
Name FKismetCompilerContext
Type class
Header File /Engine/Source/Editor/KismetCompiler/Public/KismetCompiler.h
Include Path #include "KismetCompiler.h"

Syntax

class FKismetCompilerContext : public FGraphCompilerContext

Inheritance Hierarchy

Derived Classes

Constructors

Name Remarks Include Path Unreal Specifiers

FKismetCompilerContext ( UBlueprint* SourceSketch,
FCompilerResultsLog& InMessageLog,
const FKismetCompilerOptions& InCompilerOptions
)

   KismetCompiler.h  

Destructors

Name Remarks Include Path Unreal Specifiers

virtual ~FKismetCompilerContext()

   KismetCompiler.h  

Classes

Name Remarks
FOnFunctionListCompiled  

Structs

Name Remarks
FDelegateInfo  
FNameParameterHelper  
FSubobjectCollection  

Typedefs

Name Type Remarks Include Path
Super FGraphCompilerContext   KismetCompiler.h

Constants

Name Type Remarks Include Path
OnPostCompile FSimpleMulticastDelegate   KismetCompiler.h
OnPreCompile FSimpleMulticastDelegate   KismetCompiler.h

Variables

Public

Name Type Remarks Include Path Unreal Specifiers
bAssignDelegateSignatureFunction bool Flag to trigger FMulticastDelegateProperty::SignatureFunction resolution in CreateClassVariablesFromBlueprint: KismetCompiler.h  
bIsFullCompile int32   KismetCompiler.h  
Blueprint UBlueprint *   KismetCompiler.h  
CallsIntoUbergraph TMap< UEdGraphNode *, UEdGraphNode * >   KismetCompiler.h  
ClassScopeNetNameMap FNetNameMapping Map from a name to the number of times it's been 'created' (identical nodes create the same variable names, so they need something appended) KismetCompiler.h  
ConsolidatedEventGraph UEdGraph * The ubergraph; valid from roughly the start of CreateAndProcessEventGraph. KismetCompiler.h  
ConvertibleDelegates TMap< UK2Node_CreateDelegate *, FDelegateInfo >   KismetCompiler.h  
MacroGeneratedNodes TMap< UEdGraphNode *, UEdGraphNode * > Map that can be used to find the macro node that spawned a provided node, if any. KismetCompiler.h  
NewClass UBlueprintGeneratedClass *   KismetCompiler.h  
OldCDO UObject * Data that persists across CompileClassLayout/CompileFunctions calls: KismetCompiler.h  
OldClass UBlueprintGeneratedClass *   KismetCompiler.h  
OldGenLinkerIdx int32   KismetCompiler.h  
OldLinker FLinkerLoad *   KismetCompiler.h  
RepNotifyFunctionMap TMap< FName, FProperty * > Map from UProperties to their RepNotify graph. KismetCompiler.h  
TargetClass UBlueprintGeneratedClass *   KismetCompiler.h  
UbergraphContext FKismetFunctionContext * The ubergraph context; valid from the end of CreateAndProcessEventGraph. KismetCompiler.h  

Functions

Public

Name Remarks Include Path Unreal Specifiers

void AddPostCDOCompiledStep ( TFunction< void(const UObject::FPostCDOCompiledContext&, UObject*)>&& StepFunction
)

 Adds the given "StepFunction" to be run after the CDO has been compiled in FKismetCompilerContext::PostCDOCompiled. KismetCompiler.h  

void Compile()

 Compile a blueprint into a class and a set of functions KismetCompiler.h  
Compile the class layout of the blueprint KismetCompiler.h  

void CompileFunctions ( EInternalCompilerFlags InternalFlags
)

 Compile the functions of the blueprint - must be done after compiling the class layout: KismetCompiler.h  

FPinConnectionResponse CopyPinLinksToIntermediate ( UEdGraphPin& SourcePin,
UEdGraphPin& IntermediatePin
)

 Copies pin links over from the source-pin to the specified intermediate, and validates the result (additionally logs a redirect from the intermediate-pin back to the source so we can back trace for debugging, etc.) KismetCompiler.h  

virtual void CreateClassVariablesFromBlueprint()

 Creates a class variable for each entry in the Blueprint NewVars array KismetCompiler.h  

FName GetEventStubFunctionName ( UK2Node_Event* SrcEventNode
)

 Picks the name to use for an autogenerated event stub KismetCompiler.h  

FString GetGuid ( const UEdGraphNode* Node
) const

   KismetCompiler.h  

const UEdGraphSchema_K2 * GetSchema()

   KismetCompiler.h  

FPinConnectionResponse MovePinLinksToIntermediate ( UEdGraphPin& SourcePin,
UEdGraphPin& IntermediatePin
)

 Moves pin links over from the source-pin to the specified intermediate, and validates the result (additionally logs a redirect from the intermediate-pin back to the source so we can back trace for debugging, etc.) KismetCompiler.h  

FOnFunctionListCompiled & OnFunctionListCompiled()

 Broadcasts a notification immediately after the function list for this context has been compiled. KismetCompiler.h  

void PostCDOCompiled ( const UObject::FPostCDOCompiledContext& Context
)

 Called after the CDO has been generated, allows assignment of cached/derived data: KismetCompiler.h  
Searches the function graphs and ubergraph pages for any delegate proxies, which are then registered with the compiler context. KismetCompiler.h  

void ResetAndPopulateBlueprintGeneratedVariables()

 Resets the blueprint's GeneratedVariables list and calls PopulateBlueprintGeneratedVariables KismetCompiler.h  

void SetNewClass ( UBlueprintGeneratedClass* ClassToUse
)

 Function used to assign the new class that will be used by the compiler KismetCompiler.h  

NodeType * SpawnIntermediateEventNode ( UEdGraphNode* SourceNode,
UEdGraphPin* SourcePin,
UEdGraph* ParentGraph
)

   KismetCompiler.h  

UEdGraph * SpawnIntermediateFunctionGraph ( const FString& InDesiredFunctionName,
const UFunction* InSignature,
bool bUseUniqueName
)

 Spawn an intermediate function graph for this compilation using the specified desired name (and optional signature), which may be modified to make it unique. KismetCompiler.h  

NodeType * SpawnIntermediateNode ( UEdGraphNode* SourceNode,
UEdGraph* ParentGraph
)

 Spawns an intermediate node associated with the source node (for error purposes) KismetCompiler.h  

UK2Node_TemporaryVariable * SpawnInternalVariable ( UEdGraphNode* SourceNode,
FName Category,
FName SubCategory,
UObject* SubcategoryObject,
EPinContainerType PinContainerType,
const FEdGraphTerminalType& ValueTerminalType
)

   KismetCompiler.h  

bool UsePersistentUberGraphFrame()

   KismetCompiler.h  
Ensures that all class reference Properties are legal overrides of the parent class by checking the default value set on any PC_Class variable types. KismetCompiler.h  

void ValidateComponentClassOverrides()

 Ensures that all component class overrides are legal overrides of the parent class KismetCompiler.h  

void ValidateVariableNames()

 Ensures that all variables have valid names for compilation/replication KismetCompiler.h  

Protected

Name Remarks Include Path Unreal Specifiers

virtual void AddInterfacesFromBlueprint ( UClass* Class
)

 Handles adding the implemented interface information to the class KismetCompiler.h  

void AdvanceMacroPlacement ( int32 Width,
int32 Height
)

 Advances the macro position tracking. KismetCompiler.h  

void AutoAssignNodePosition ( UEdGraphNode* Node
)

   KismetCompiler.h  

void BuildDynamicBindingObjects ( UBlueprintGeneratedClass* Class
)

 Build the dynamic bindings objects used to tie events to delegates at runtime KismetCompiler.h  

void CheckConnectionResponse ( const FPinConnectionResponse& Response,
const UEdGraphNode* Node
)

 Checks a connection response, and errors if it didn't succeed (not public, users should be using MovePinLinksToIntermediate/CopyPinLinksToIntermediate instead of wrapping their own with this). KismetCompiler.h  

virtual void CleanAndSanitizeClass ( UBlueprintGeneratedClass* ClassToClean,
UObject*& OldCDO
)

 Removes the properties and functions from a class, so that new ones can be created in its place KismetCompiler.h  

virtual void CompileFunction ( FKismetFunctionContext& Context
)

 Second phase of compiling a function graph KismetCompiler.h  

virtual void CopyTermDefaultsToDefaultObject ( UObject* DefaultObject
)

 Copies default values cached for the terms in the DefaultPropertyValueMap to the final CDO KismetCompiler.h  

void CreateAndProcessUbergraph()

 Merges pages and creates function stubs, etc... KismetCompiler.h  

void CreateCommentBlockAroundNodes ( const TArray< UEdGraphNode* >& Nodes,
UObject* SourceObject,
UEdGraph* TargetGraph,
FString CommentText,
FLinearColor CommentColor,
int32& Out_OffsetX,
int32& Out_OffsetY
)

   KismetCompiler.h  

FKismetFunctionContext * CreateFunctionContext()

 Creates a new function context and adds it to the function list to be processed. KismetCompiler.h  

virtual void CreateFunctionList()

 Creates a list of functions to compile KismetCompiler.h  

void CreateFunctionStubForEvent ( UK2Node_Event* Event,
UObject* OwnerOfTemporaries
)

 Create a stub function graph for the event node, and have it invoke the correct point in the ubergraph KismetCompiler.h  

void CreateLocalVariablesForFunction ( FKismetFunctionContext& Context,
FField::FLinkedListBuilder& PropertyListBuilder
)

 Creates the properties on a function that store the local and event graph (if applicable) variables KismetCompiler.h  

FMulticastDelegateProperty * CreateMulticastDelegateVariable ( const FName Name,
const FEdGraphPinType& Type
)

 Creates a multicast delegate variable & associated signature graph / function, use to generate events KismetCompiler.h  

FMulticastDelegateProperty * CreateMulticastDelegateVariable ( const FName Name
)

 Creates a multicast delegate variable & associated signature graph / Function, use to generate events KismetCompiler.h  

void CreateParametersForFunction ( FKismetFunctionContext& Context,
UFunction* ParameterSignature,
FField::FLinkedListBuilder& PropertyListBuilder
)

 Create the properties on a function for input/output parameters KismetCompiler.h  

void CreatePropertiesFromList ( UStruct* Scope,
FField::FLinkedListBuilder& PropertyListBuilder,
TIndirectArray< FBPTerminal >& Terms,
EPropertyFlags PropertyFlags,
bool bPropertiesAreLocal,
bool bPropertiesAreParameters
)

 Creates a property with flags including PropertyFlags in the Scope structure for each entry in the Terms array KismetCompiler.h  

virtual UEdGraphSchema_K2 * CreateSchema()

   KismetCompiler.h  

void CreateUserDefinedLocalVariablesForFunction ( FKismetFunctionContext& Context,
FField::FLinkedListBuilder& PropertyListBuilder
)

 Creates user defined local variables for function KismetCompiler.h  

FProperty * CreateVariable ( const FName Name,
const FEdGraphPinType& Type
)

 Creates a class variable KismetCompiler.h  

void DetermineNodeExecLinks ( UEdGraphNode* SourceNode,
TMap< UEdGraphPin*, UEdGraphPin* >& SourceNodeLinks
) const

 Discovers exec pin links for the sourcenode KismetCompiler.h  

virtual void EnsureProperGeneratedClass ( UClass*& TargetClass
)

 Backwards Compatability: Ensures that the passed in TargetClass is of the proper type (e.g. BlueprintGeneratedClass, AnimBlueprintGeneratedClass), and NULLs the reference if it is not KismetCompiler.h  

void ExpandTimelineNodes ( UEdGraph* SourceGraph
)

 Expand timeline nodes into necessary nodes KismetCompiler.h  

void ExpandTunnelsAndMacros ( UEdGraph* SourceGraph
)

 Expands any macro instances and collapses any tunnels in the nodes of SourceGraph KismetCompiler.h  

void ExpansionStep ( UEdGraph* Graph,
bool bAllowUbergraphExpansions
)

 Expands out nodes that need it. KismetCompiler.h  

const UK2Node_FunctionEntry * FindLocalEntryPoint ( const UFunction* Function
) const

 Scan FunctionList and return Entry point, for matching one KismetCompiler.h  

virtual void FinishCompilingClass ( UClass* Class
)

 Handles final post-compilation setup, flags, creates cached values that would normally be set during deserialization, etc... KismetCompiler.h  

void FinishCompilingFunction ( FKismetFunctionContext& Context
)

 Handles final post-compilation setup, flags, creates cached values that would normally be set during deserialization, etc... KismetCompiler.h  

FName GetUbergraphCallName()

 Gets the unique name for this context's ExecuteUbergraph function KismetCompiler.h  

virtual void InitializeGeneratedEventNodes ( EInternalCompilerFlags InternalFlags
)

 Called to initialize generated event nodes that came from generated ubergraph pages after delegate signature compilation is done KismetCompiler.h  

virtual bool IsNodePure ( const UEdGraphNode* Node
) const

 Determines if a node is pure KismetCompiler.h  

void MapExpansionPathToTunnelInstance ( const UEdGraphNode* InnerExpansionNode,
const UEdGraphNode* OuterTunnelInstance
)

 Maps the nodes in an intermediate tunnel expansion path back to the owning tunnel instance node. KismetCompiler.h  

virtual void MergeGraphIntoUbergraph ( UEdGraph* SourceGraph,
UEdGraph* Ubergraph
)

 Merges a single ubergraph page into the main ubergraph KismetCompiler.h  

virtual void MergeUbergraphPagesIn ( UEdGraph* Ubergraph
)

 Merges in any all ubergraph pages into the gathering ubergraph KismetCompiler.h  

virtual void OnNewClassSet ( UBlueprintGeneratedClass* ClassToUse
)

   KismetCompiler.h  

virtual void OnPostCDOCompiled ( const UObject::FPostCDOCompiledContext& Context
)

   KismetCompiler.h  

virtual void PopulateBlueprintGeneratedVariables()

 Compilers are expected to populate the blueprint's full list of GeneratedVariables here as the list is reset at this point KismetCompiler.h  

virtual void PostCompile()

   KismetCompiler.h  

virtual void PostCompileDiagnostics()

 Gives derived classes a chance to emit debug data. KismetCompiler.h  

virtual void PostcompileFunction ( FKismetFunctionContext& Context
)

 Final phase of compiling a function graph; called after all functions have had CompileFunction called KismetCompiler.h  

virtual void PostCreateSchema()

   KismetCompiler.h  

virtual void PostExpansionStep ( const UEdGraph* Graph
)

 Gives derived classes a chance to process post-node expansion. KismetCompiler.h  

virtual void PreCompile()

 Gives derived classes a chance to hook up any custom logic. KismetCompiler.h  

virtual void PrecompileFunction ( FKismetFunctionContext& Context,
EInternalCompilerFlags InternalFlags
)

 First phase of compiling a function graph KismetCompiler.h  

virtual void PreCompileUpdateBlueprintOnLoad ( UBlueprint* BP
)

 Used for performing custom patching during stage IX of the compilation during load. KismetCompiler.h  

void PrintVerboseInformation ( UClass* Class
) const

   KismetCompiler.h  

void PrintVerboseInfoStruct ( UStruct* Struct
) const

   KismetCompiler.h  

void ProcessIntermediateTunnelBoundary ( UK2Node_Tunnel* TunnelInput,
UK2Node_Tunnel* TunnelOutput
)

 Processes an intermediate tunnel expansion boundary. KismetCompiler.h  

virtual void ProcessOneFunctionGraph ( UEdGraph* SourceGraph,
bool bInternalFunction
)

 Merges macros/subgraphs into the graph and validates it, creating a function list entry if it's reasonable. KismetCompiler.h  

void PropagateValuesToCDO ( UObject* NewCDO,
UObject* OldCDO
)

 Non virtual wrapper to encapsulate functions that occur when the CDO is ready for values: KismetCompiler.h  

void PruneIsolatedNodes ( UEdGraph* InGraph,
bool bInIncludeNodesThatCouldBeExpandedToRootSet
)

 Prune isolated nodes given the specified graph KismetCompiler.h  

virtual void SaveSubObjectsFromCleanAndSanitizeClass ( FSubobjectCollection& SubObjectsToSave,
UBlueprintGeneratedClass* ClassToClean
)

 Saves any SubObjects on the blueprint that need to survive the clean KismetCompiler.h  

virtual void SetCalculatedMetaDataAndFlags ( UFunction* Function,
UK2Node_FunctionEntry* EntryNode,
const UEdGraphSchema_K2* Schema
)

 Adds metadata for a particular compiled function based on its characteristics KismetCompiler.h  

void SetCanEverTick ()

 Function works only if subclass of AActor or UActorComponent. KismetCompiler.h  

void SetPropertyDefaultValue ( const FProperty* PropertyToSet,
FString& Value
)

 Adds a default value entry into the DefaultPropertyValueMap for the property specified KismetCompiler.h  

virtual void SpawnNewClass ( const FString& NewClassName
)

   KismetCompiler.h  

virtual void TransformNodes ( FKismetFunctionContext& Context
)

 Performs transformations on specific nodes that require it according to the schema KismetCompiler.h  

void ValidateFunctionGraphNames()

 Ensures that all function graphs have valid names for compilation/replication KismetCompiler.h  

virtual bool ValidateGeneratedClass ( UBlueprintGeneratedClass* Class
)

 Validates the generated class KismetCompiler.h  

void ValidateNoWildcardPinsInGraph ( const UEdGraph* SourceGraph
)

 Checks if pin types are unresolved (e.g. still wildcards). KismetCompiler.h  

void ValidateSelfPinsInGraph ( FKismetFunctionContext& Context
)

 Checks if self pins are connected. KismetCompiler.h  

void ValidateTimelineNames()

 Ensures that all timelines have valid names for compilation/replication KismetCompiler.h  

void VerifyValidOverrideEvent ( const UEdGraph* Graph
)

 If a function in the graph cannot be placed as event make sure that it is not. KismetCompiler.h  

void VerifyValidOverrideFunction ( const UEdGraph* Graph
)

 If a function in the graph cannot be overridden make sure that it is not. KismetCompiler.h  

Overridden from FGraphCompilerContext

Name Remarks Include Path Unreal Specifiers

virtual bool CanIgnoreNode ( const UEdGraphNode* Node
) const

 Can this node be ignored for further processing? KismetCompiler.h  

virtual bool PinIsImportantForDependancies ( const UEdGraphPin* Pin
) const

 Does this pin potentially participate in data dependencies? KismetCompiler.h  

virtual void PruneIsolatedNodes ( const TArray< UEdGraphNode* >& RootSet,
TArray< UEdGraphNode* >& GraphNodes
)

 Prunes any nodes that weren't visited from the graph, printing out a warning KismetCompiler.h  

virtual bool ShouldForceKeepNode ( const UEdGraphNode* Node
) const

 Should this node be kept even if it's not reached? KismetCompiler.h  

virtual void ValidateLink ( const UEdGraphPin* PinA,
const UEdGraphPin* PinB
) const

 Validates that the interconnection between two pins is schema compatible KismetCompiler.h  

virtual void ValidateNode ( const UEdGraphNode* Node
) const

 Validates that the node is schema compatible KismetCompiler.h  

virtual void ValidatePin ( const UEdGraphPin* Pin
) const

 Validate that the wiring for a single pin is schema compatible KismetCompiler.h  

Static

Name Remarks Include Path Unreal Specifiers

static FProperty * CreateUserDefinedLocalVariableForFunction ( const FBPVariableDescription& Variable,
UFunction* Function,
UBlueprintGeneratedClass* OwningClass,
FField::FLinkedListBuilder& PropertyListBuilder,
const UEdGraphSchema_K2* Schema,
FCompilerResultsLog& MessageLog
)

 Helper function for CreateUserDefinedLocalVariablesForFunction and compilation manager's FastGenerateSkeletonClass: KismetCompiler.h  

static TSharedPtr< FKismetCompilerContext > GetCompilerForBP ( UBlueprint* BP,
FCompilerResultsLog& InMessageLog,
const FKismetCompilerOptions& InCompileOptions
)

   KismetCompiler.h  

static void RegisterCompilerForBP ( UClass* BPClass,
CompilerContextFactoryFunction FactoryFunction
)

   KismetCompiler.h  

static void SetDefaultInputValueMetaData ( UFunction* Function,
const TArray< TSharedPtr< FUserPinInfo > >& InputData
)

 Reflects each pin's user set, default value into the function's metadata (so it can be queried for later by CallFunction nodes, etc.) KismetCompiler.h  

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page