1. Epic GamesDeveloper
  3. FKismetCompilerContext

FKismetCompilerContext

API > API/Editor > API/Editor/KismetCompiler

Inheritance Hierarchy

References

   
Module KismetCompiler
Header /Engine/Source/Editor/KismetCompiler/Public/KismetCompiler.h
Include #include "KismetCompiler.h"

Syntax

class FKismetCompilerContext : public FGraphCompilerContext

Variables

  Type Name Description
Protected variable int32 AverageNodeHeight  
Protected variable int32 AverageNodeWidth Average node size for nodes with no size.
Public variable bool bAssignDelegateSignatureFunction Flag to trigger FMulticastDelegateProperty::SignatureFunction resolution in CreateClassVariablesFromBlueprint:
Public variable int32: 1 bIsFullCompile  
Public variable UBlueprint * Blueprint  
Public variable TMap< UEdGraphNode *, UEdGraphNode * > CallsIntoUbergraph  
Public variable FNetNameMapping ClassScopeNetNameMap 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)
Protected variable FKismetCompilerOptions CompileOptions This struct holds the various compilation options, such as which passes to perform, whether to save intermediate results, etc.
Public variable UEdGraph * ConsolidatedEventGraph The ubergraph; valid from roughly the start of CreateAndProcessEventGraph.
Public variable TMap< UK2Node_CreateDelegate *, FDelegateInfo > ConvertibleDelegates  
Protected variable TSet< FString > CreatedFunctionNames Names of functions created.
Protected variable TMap< FName, FString > DefaultPropertyValueMap Map from UProperties to default object values, to be fixed up after compilation is complete.
Protected variable TIndirectArray< FKismetFunctionContext > FunctionList List of functions currently allocated.
Protected variable FOnFunctionListCompiled FunctionListCompiledEvent Event that is broadcast immediately after the function list for this context has been compiled.
Protected variable TArray< UEdGraph * > GeneratedFunctionGraphs Set of function graphs generated for the class layout at compile time
Protected variable int32 HorizontalNodePadding  
Protected variable int32 HorizontalSectionPadding Padding.
Protected variable UScriptStruct * LinearColorStruct  
Public variable TMap< UEdGraphNode *, UEdGraphNode * > MacroGeneratedNodes Map that can be used to find the macro node that spawned a provided node, if any.
Protected variable int32 MacroRowMaxHeight Maximum height encountered in this row; used to position the next row appropriately.
Protected variable int32 MacroSpawnX Used to space expanded macro nodes when saving intermediate results.
Protected variable int32 MacroSpawnY  
Protected variable int32 MaximumSpawnX  
Protected variable int32 MinimumSpawnX Maximum bounds of the spawning area.
Public variable UBlueprintGeneratedClass * NewClass  
Protected variable TMap< TSubclassOf< class UEdGraphNode >, FNodeHandlingFunctor * > NodeHandlers Map from node class to a handler functor.
Public variable UObject * OldCDO Data that persists across CompileClassLayout/CompileFunctions calls:
Public variable UBlueprintGeneratedClass * OldClass  
Public variable int32 OldGenLinkerIdx  
Public variable FLinkerLoad * OldLinker  
Public variable TMap< FName, FProperty * > RepNotifyFunctionMap Map from UProperties to their RepNotify graph.
Protected variable UScriptStruct * RotatorStruct  
Protected variable UEdGraphSchema_K2 * Schema Schema for the graph being compiled.
Public variable TMap< UEdGraphNode *, UK2Node_Event * > SourceNodeToExpansionEvent Source pin to latent/delegate entry point.
Public variable TMap< UEdGraphPin *, UK2Node_Event * > SourcePinToExpansionEvent  
Public variable UBlueprintGeneratedClass * TargetClass  
Protected variable TMap< class UTimelineTemplate *, class FProperty * > TimelineToMemberVariableMap Map of properties created for timelines; to aid in debug data generation.
Protected variable UScriptStruct * TransformStruct  
Public variable FKismetFunctionContext * UbergraphContext The ubergraph context; valid from the end of CreateAndProcessEventGraph.
Protected variable UScriptStruct * VectorStruct  
Protected variable int32 VerticalSectionPadding  

Constructors

  Type Name Description
Public function  

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

  

Destructors

  Type Name Description
Public function Virtual    

Functions

  Type Name Description
Protected function Virtual void Handles adding the implemented interface information to the class
Protected function void

AdvanceMacroPlacement ( int32 Width,
int32 Height
)

 Advances the macro position tracking.
Protected function void  
Protected function void Build the dynamic bindings objects used to tie events to delegates at runtime
Protected function void 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).
Protected function Virtual void Removes the properties and functions from a class, so that new ones can be created in its place
Public function void

Compile ()

 Compile a blueprint into a class and a set of functions
Public function void

CompileClassLayout ( EInternalCompilerFlags InternalFlags
)

 Compile the class layout of the blueprint
Protected function Virtual void Second phase of compiling a function graph
Public function void

CompileFunctions ( EInternalCompilerFlags InternalFlags
)

 Compile the functions of the blueprint - must be done after compiling the class layout:
Public function 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.)
Protected function Virtual void Copies default values cached for the terms in the DefaultPropertyValueMap to the final CDO
Protected function void Merges pages and creates function stubs, etc...
Public function Virtual void Creates a class variable for each entry in the Blueprint NewVars array
Protected function void

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

  
Protected function FKismetFunctionContext * Creates a new function context and adds it to the function list to be processed.
Protected function Virtual void Creates a list of functions to compile
Protected function 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
Protected function void

CreateLocalVariablesForFunction ( FKismetFunctionContext& Context,
FField**& FunctionPropertyStorageLocation
)

 Creates the properties on a function that store the local and event graph (if applicable) variables
Protected function void

CreateParametersForFunction ( FKismetFunctionContext& Context,
UFunction* ParameterSignature,
FField**& FunctionPropertyStorageLocation
)

 Create the properties on a function for input/output parameters
Protected function void

CreatePropertiesFromList ( UStruct* Scope,
FField**& PropertyStorageLocation,
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
Protected function Virtual UEdGraphSchema_K2 *  
Protected function Static FProperty *

CreateUserDefinedLocalVariableForFunction ( const FBPVariableDescription& Variable,
UFunction* Function,
UBlueprintGeneratedClass* OwningClass,
FField**& FunctionPropertyStorageLocation,
const UEdGraphSchema_K2* Schema,
FCompilerResultsLog& MessageLog
)

 Helper function for CreateUserDefinedLocalVariablesForFunction and compilation manager's FastGenerateSkeletonClass:
Protected function void

CreateUserDefinedLocalVariablesForFunction ( FKismetFunctionContext& Context,
FField**& FunctionPropertyStorageLocation
)

 Creates user defined local variables for function
Protected function FProperty *

CreateVariable ( const FName Name,
const FEdGraphPinType& Type
)

 Creates a class variable
Protected function Const void

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

 Discovers exec pin links for the sourcenode
Protected function Virtual void 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
Protected function void

ExpandTimelineNodes ( UEdGraph* SourceGraph
)

 Expand timeline nodes into necessary nodes
Protected function void

ExpandTunnelsAndMacros ( UEdGraph* SourceGraph
)

 Expands any macro instances and collapses any tunnels in the nodes of SourceGraph
Protected function void

ExpansionStep ( UEdGraph* Graph,
bool bAllowUbergraphExpansions
)

 Expands out nodes that need it.
Protected function Const const UK2Node_FunctionEntry *

FindLocalEntryPoint ( const UFunction* Function
)

 Scan FunctionList and return Entry point, for matching one
Protected function Virtual void Handles final post-compilation setup, flags, creates cached values that would normally be set during deserialization, etc...
Protected function void Handles final post-compilation setup, flags, creates cached values that would normally be set during deserialization, etc...
Public function Static TSharedPtr< FKismetCompilerContext >

GetCompilerForBP ( UBlueprint* BP,
FCompilerResultsLog& InMessageLog,
const FKismetCompilerOptions& InCompileOptions
)

  
Public function FName Picks the name to use for an autogenerated event stub
Public function Const FString

GetGuid ( const UEdGraphNode* Node
)

  
Public function Const const UEdGraphSchema_K2 *  
Protected function Const FName Gets the unique name for this context's ExecuteUbergraph function
Protected function Virtual Const bool

IsNodePure ( const UEdGraphNode* Node
)

 Determines if a node is pure
Protected function void

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

 Maps the nodes in an intermediate tunnel expansion path back to the owning tunnel instance node.
Protected function Virtual void Merges in any all ubergraph pages into the gathering ubergraph
Public function 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.)
Public function FOnFunctionListCompiled & Broadcasts a notification immediately after the function list for this context has been compiled.
Protected function Virtual void  
Protected function Virtual void  
Public function void Called after the CDO has been generated, allows assignment of cached/derived data:
Protected function Virtual void  
Protected function Virtual void Gives derived classes a chance to emit debug data.
Protected function Virtual void Final phase of compiling a function graph; called after all functions have had CompileFunction called
Protected function Virtual void  
Protected function Virtual void

PostExpansionStep ( const UEdGraph* Graph
)

 Gives derived classes a chance to process post-node expansion.
Protected function Virtual void Gives derived classes a chance to hook up any custom logic.
Protected function Virtual void

PrecompileFunction ( FKismetFunctionContext& Context,
EInternalCompilerFlags InternalFlags
)

 First phase of compiling a function graph
Protected function Virtual void Used for performing custom patching during stage IX of the compilation during load.
Protected function Const void  
Protected function Const void  
Protected function void Processes an intermediate tunnel expansion boundary.
Protected function 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.
Protected function void

PropagateValuesToCDO ( UObject* NewCDO,
UObject* OldCDO
)

 Non virtual wrapper to encapsulate functions that occur when the CDO is ready for values:
Protected function void

PruneIsolatedNodes ( UEdGraph* InGraph,
bool bInIncludeNodesThatCouldBeExpandedToRootSet
)

 Prune isolated nodes given the specified graph
Public function void Searches the function graphs and ubergraph pages for any delegate proxies, which are then registered with the compiler context.
Public function Static void

RegisterCompilerForBP ( UClass* BPClass,
CompilerContextFactoryFunction FactoryFunction
)

  
Protected function Virtual void Saves any SubObjects on the blueprint that need to survive the clean
Protected function Virtual void Adds metadata for a particular compiled function based on its characteristics
Protected function Const void Function works only if subclass of AActor or UActorComponent.
Protected function 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.)
Public function void Function used to assign the new class that will be used by the compiler
Protected function void

SetPropertyDefaultValue ( const FProperty* PropertyToSet,
FString& Value
)

 Adds a default value entry into the DefaultPropertyValueMap for the property specified
Public function NodeType *

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

 Spawns an intermediate event node associated with the source node (for error purposes)
Public function 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.
Public function NodeType *

SpawnIntermediateNode ( UEdGraphNode* SourceNode,
UEdGraph* ParentGraph
)

 Spawns an intermediate node associated with the source node (for error purposes)
Public function UK2Node_TemporaryVariable *

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

  
Protected function Virtual void

SpawnNewClass ( const FString& NewClassName
)

  
Protected function Virtual void Performs transformations on specific nodes that require it according to the schema
Public function Const bool  
Public function void 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.
Public function void Ensures that all component class overrides are legal overrides of the parent class
Protected function void Ensures that all function graphs have valid names for compilation/replication
Protected function Virtual bool Validates the generated class
Protected function void

ValidateNoWildcardPinsInGraph ( const UEdGraph* SourceGraph
)

 Checks if pin types are unresolved (e.g. still wildcards).
Protected function void Checks if self pins are connected.
Protected function void Ensures that all timelines have valid names for compilation/replication
Public function void Ensures that all variables have valid names for compilation/replication
Protected function void If a function in the graph cannot be placed as event make sure that it is not.
Protected function void If a function in the graph cannot be overridden make sure that it is not.

Overridden from FGraphCompilerContext

  Type Name Description
Protected function Virtual Const bool

CanIgnoreNode ( const UEdGraphNode* Node
)

 Can this node be ignored for further processing?
Protected function Virtual Const bool Does this pin potentially participate in data dependencies?
Protected function Virtual void

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

 Prunes any nodes that weren't visited from the graph, printing out a warning
Protected function Virtual Const bool Should this node be kept even if it's not reached?
Protected function Virtual Const void

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

 Validates that the interconnection between two pins is schema compatible
Protected function Virtual Const void

ValidateNode ( const UEdGraphNode* Node
)

 Validates that the node is schema compatible
Protected function Virtual Const void

ValidatePin ( const UEdGraphPin* Pin
)

 Validate that the wiring for a single pin is schema compatible

Classes

  Type Name Description
Public struct FDelegateInfo    
Public struct FNameParameterHelper    
Public class FOnFunctionListCompiled    
Protected struct FSubobjectCollection    

Typedefs

Name Description
Super  

Constants

Name Description
OnPostCompile  
OnPreCompile  

Ask questions and help your peers Developer Forums

Write your own tutorials or read those from others Learning Library

On this page