Native Unreal 5.8 Tools
Native Unreal 5.8 Tools documentation.
Official - Unreal Engine 5.8
The actions on this page wrap Unreal's native AI Toolset Registry (the plugin behind Unreal's own MCP server). ue-mcp reaches the registry in-process and surfaces each official tool as a first-class action inside the matching ue-mcp category, so you call them like any other action - passing the tool's arguments via input. Requires UE 5.8+ with the ToolsetRegistry plugin (and the toolset plugins you want) enabled. Use the epic category to discover them at runtime (status / list_toolsets / describe_toolset / call_tool).
ue-mcp currently wraps 830 official tools across 52 toolsets, grouped below by the ue-mcp category they surface in. Toolsets with no natural home appear under epic.
gas
Wraps 14 official tools.
gas(epic_add_cue_tag)- [Epic GASToolsets.GameplayCueToolset] Adds a new gameplay cue tag to the project. This should ONLY be called after getting explicit direction or permission from the user. Params (pass as input): cueTag, comment?.gas(epic_create_cue_notify_asset)- [Epic GASToolsets.GameplayCueToolset] Creates a new GameplayCueNotify Blueprint asset at the specified content browser location. This should ONLY be called after getting explicit direction or permission from the user. Params (pass as input): cueTag, packagePath, assetName, bIsActor.gas(epic_execute_cue_on_selected_actor)- [Epic GASToolsets.GameplayCueToolset] Executes a gameplay cue non-replicated on the currently selected actor in the editor. Useful for previewing cue effects without network replication. Requires a PIE session or a configured GameplayCueManager to produce visible results. Params (pass as input): cueTag, normalizedMagnitude, location, normal.gas(epic_find_attribute_set_classes)- [Epic GASToolsets.AttributeSetToolset] Returns all AttributeSet subclasses found in the project, including their attributes. Covers both native C++ subclasses and Blueprint subclasses discovered via the asset registry. Params: none.gas(epic_find_cue_notify_assets)- [Epic GASToolsets.GameplayCueToolset] Returns all GameplayCueNotify assets found in the project via the asset registry. Params (pass as input): parentTag.gas(epic_find_cue_tags_without_notifies)- [Epic GASToolsets.GameplayCueToolset] Returns gameplay cue tags that have no corresponding GameplayCueNotify asset in the project. Tags without notifies produce no visible effect when triggered at runtime. Params: none.gas(epic_get_active_effects)- [Epic GASToolsets.AbilitySystemInspectorToolset] Returns all gameplay effects currently active on the actor's AbilitySystemComponent. Params (pass as input): actor.gas(epic_get_active_tags)- [Epic GASToolsets.AbilitySystemInspectorToolset] Returns the gameplay tags currently owned by the actor's AbilitySystemComponent (includes loose tags, effect-granted tags, etc.). Params (pass as input): actor.gas(epic_get_attribute_values)- [Epic GASToolsets.AbilitySystemInspectorToolset] Returns the current base and modified values of all gameplay attributes on the actor's AbilitySystemComponent. Params (pass as input): actor.gas(epic_get_cue_info)- [Epic GASToolsets.GameplayCueToolset] Returns information about a specific gameplay cue, including its notify asset. Params (pass as input): cueTag.gas(epic_get_granted_abilities)- [Epic GASToolsets.AbilitySystemInspectorToolset] Returns all abilities granted to the actor's AbilitySystemComponent. Params (pass as input): actor.gas(epic_list_attributes)- [Epic GASToolsets.AttributeSetToolset] Returns the gameplay attributes defined on a specific AttributeSet class. Params (pass as input): className.gas(epic_list_cues)- [Epic GASToolsets.GameplayCueToolset] Returns gameplay cue tags registered in the project. Params (pass as input): parentTag.gas(epic_remove_cue_tag)- [Epic GASToolsets.GameplayCueToolset] Removes a gameplay cue tag from the project. This should ONLY be called after getting explicit direction or permission from the user. Params (pass as input): cueTag.
niagara
Wraps 56 official tools.
niagara(epic_add_emitter)- [Epic NiagaraToolsets.NiagaraToolset_System] Adds an emitter to a Niagara System. The new emitter will be based on the template emitter, inheriting its configuration and modules. Returns the full emitter topology (no input values — call GetEmitterInputValues for values). Params (pass as input): system, templateEmitter, emitterName.niagara(epic_add_module)- [Epic NiagaraToolsets.NiagaraToolset_System] Adds a module to a script stack. The module will be inserted into the specified script's execution stack. Returns the module topology with all inputs walked (no input values — call GetModuleInputValues for values). Params (pass as input): moduleLocationRef, moduleAsset.niagara(epic_add_renderer)- [Epic NiagaraToolsets.NiagaraToolset_System] Adds a renderer to an emitter. Creates a new renderer of the specified type and adds it to the emitter's renderer list. Returns an FNiagaraExt_RendererRef with the new renderer's Index and RendererClass, usable directly with SetRendererData / GetRendererData without a follow-up topology call. Params (pass as input): newRendererLocation, rendererClass.niagara(epic_add_set_parameter_entry)- [Epic NiagaraToolsets.NiagaraToolset_System] Adds a single parameter to an existing SetParameters module. The module referenced by ModuleRef must be a SetParameters (UNiagaraNodeAssignment) module. Use bIsSetParametersModule in the module topology to confirm before calling. Params (pass as input): moduleRef, entry.niagara(epic_add_set_parameters_module)- [Epic NiagaraToolsets.NiagaraToolset_System] Adds a SetParameters module to a script stack. Unlike AddModule which requires a script asset, a SetParameters module dynamically assigns values to named parameters and generates its own internal script. Use this when you need to set one or more particle/emitter/system parameters directly in the stack. Params (pass as input): moduleLocationRef, parameters.niagara(epic_add_user_variables)- [Epic NiagaraToolsets.NiagaraToolset_System] Adds or updates user variables on a system. If a variable with the same name already exists, it will be replaced with the new definition. Params (pass as input): system, variablesToAdd.niagara(epic_apply_stack_issue_fix)- [Epic NiagaraToolsets.NiagaraToolset_System] Applies a Fix-style stack issue fix identified by IssueId and FixId. Link-style fixes are rejected. The fix is undoable via the editor undo stack. Applying a fix may trigger a recompile; the result waits for that compile to complete so post-fix state is valid. Params (pass as input): system, issueId, fixId.niagara(epic_construct_niagara_bpwrapper_from_component)- [Epic NiagaraToolsets.NiagaraToolset_Blueprint] Creates a Blueprint actor wrapper from a Niagara Component. This generates a new Blueprint actor and preserves all component property values and user variable overrides. Naming convention: NS_MyEffect -> B_MyEffect Params (pass as input): newAssetPath, component, parentClass.niagara(epic_construct_niagara_bpwrapper_from_system)- [Epic NiagaraToolsets.NiagaraToolset_Blueprint] Creates a Blueprint actor wrapper around a Niagara System. This generates a new Blueprint actor with a Niagara component configured to use the specified system. Naming convention: NS_MyEffect -> B_MyEffect Params (pass as input): newAssetPath, system, parentClass.niagara(epic_create_niagara_system)- [Epic NiagaraToolsets.NiagaraToolset_System] Creates a new Niagara System asset. The new system will be based on the template system, inheriting its configuration and emitters. Params (pass as input): assetName, assetPath, templateSystem.niagara(epic_find_niagara_scripts)- [Epic NiagaraToolsets.NiagaraToolset_Assets] Searches for UNiagaraScript assets matching the given filters. Reads filterable metadata from asset registry tags only - no LoadObject required. Tags reflect the exposed (published) version of versioned scripts; this function does not need a version filter and there is no way to discover non-exposed versions through the asset registry. Params (pass as input): folderPath, name, usages, visibilities, moduleUsageBitmask, bRecursive, bIncludeDeprecated.niagara(epic_get_asset_discovery_info)- [Epic NiagaraToolsets.NiagaraToolset_Assets] Returns the project's configured asset discovery groups. Each group describes a content directory's purpose and paths. Params: none.niagara(epic_get_available_dynamic_inputs)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns all available Dynamic Input Module assets compatible with the given type. Dynamic inputs provide procedural value generation for module parameters. Params (pass as input): type.niagara(epic_get_data_interface_schema)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns property schema for a specific Data Interface class. Describes all available properties and their types for the given data interface type. Params (pass as input): dataInterfaceClass.niagara(epic_get_dynamic_input_chain)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns the full recursive chain for a dynamic input: topology metadata and resolved values at every level. The starting input must have value mode Dynamic; an error is surfaced otherwise. The schema expands one full level and emits a typed recursion stub at deeper levels; the wire format recurses to arbitrary depth matching the underlying chain. Params (pass as input): stackInputRef.niagara(epic_get_dynamic_input_schema)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns schema for a dynamic input module in the stack. Describes the inputs and configuration for a procedural value generator. Params (pass as input): dynamicInputReference.niagara(epic_get_dynamic_input_schema_from_asset)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns schema for a dynamic input asset. Standalone function that doesn't require a system context - useful for browsing available dynamic inputs. Params (pass as input): dynamicInputAsset.niagara(epic_get_emitter_data)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns emitter property values as a single JSON-string blob in PropertyValues. The blob contains the full FVersionedNiagaraEmitterData (SimTarget, bLocalSpace, RandomSeed, FixedBounds, etc.) — fields use C++ PascalCase, must be parsed to read individual values. For typed access to common metadata (SimTarget, EmitterName, bEnabled, RendererClasses) prefer GetEmitterSummary — it returns those as named fields directly and avoids a JSON parse step. Use this endpoint when you need the full property set or a less-common field. Params (pass as input): emitterRef.niagara(epic_get_emitter_input_values)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns all resolved input values for every module across all four emitter script stacks. One FNiagaraExt_ModuleInputValues entry per module, each carrying all its resolved input values. Call this in parallel with GetEmitterTopology to get both structure and values in two passes. Params (pass as input): emitterRef.niagara(epic_get_emitter_schema)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns property schema for Niagara Emitter. Describes all available properties and their types that can be set on a Niagara Emitter. Params: none.niagara(epic_get_emitter_summary)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns lightweight emitter metadata: name, enabled state, sim target, renderer classes. Use this when you only need to check metadata without walking the full emitter structure. Params (pass as input): emitterRef.niagara(epic_get_emitter_topology)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns full emitter topology: four script stacks with all modules and inputs, renderer references. All fields always populated. The returned topology carries no input values; call GetEmitterInputValues in parallel. Note: mutation endpoints (AddEmitter, AddModule) also return topology structs — input values require a separate data call. Params (pass as input): emitterRef.niagara(epic_get_module_input_values)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns resolved input values for a single module. Use when you need values for one specific module without walking the whole emitter. Params (pass as input): moduleRef.niagara(epic_get_module_schema)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns schema for a module and all its inputs. Call this after seeing a module in topology to understand what inputs it exposes. Params (pass as input): moduleReference.niagara(epic_get_module_schema_from_asset)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns schema for a module asset. Standalone function that doesn't require a system context - useful for browsing available modules. Params (pass as input): moduleAsset.niagara(epic_get_module_topology)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns module topology: metadata and all inputs (name/type/visibility only, no values). All fields always populated. Params (pass as input): moduleRef.niagara(epic_get_niagara_script_digest)- [Epic NiagaraToolsets.NiagaraToolset_Assets] Returns the decoded asset-registry tag metadata for a Niagara script asset. Looks up the asset by object path in the asset registry and reads its tags; no LoadObject is performed. Returned fields reflect the exposed (published) version when the script uses FVersionedNiagaraScriptData versioning - the registry never carries non-exposed-version metadata. Params (pass as input): objectPath.niagara(epic_get_renderer_data)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns renderer property values. Retrieves the current values of all configurable renderer properties. Params (pass as input): rendererRef.niagara(epic_get_renderer_schema)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns property schema for a specific Renderer class. Describes all available properties and their types for the given renderer type. Params (pass as input): rendererClass.niagara(epic_get_script_stack_input_values)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns all resolved input values for every module in the given script stack. One FNiagaraExt_ModuleInputValues entry per module. Params (pass as input): scriptRef.niagara(epic_get_script_stack_topology)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns script stack topology: all modules and their inputs in execution order. All fields always populated. Params (pass as input): scriptRef.niagara(epic_get_stack_input_data)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns the value of a stack module input. Retrieves the current value and configuration for a specific module input parameter. Params (pass as input): stackInputRef.niagara(epic_get_stack_input_schema)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns schema for a single module input in the stack. Describes the type, metadata, and configuration options for a specific input parameter. Params (pass as input): inputReference.niagara(epic_get_stack_input_topology)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns stack input topology: name, type, visibility, editability. No value payload. For the resolved value call GetStackInputData. For a dynamic-input chain call GetDynamicInputChain. Params (pass as input): stackInputRef.niagara(epic_get_stack_issues)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns all stack issues (errors, warnings, info) from the Niagara module stack, including dismissed ones. Waits for any in-flight compile to complete before collecting. Params (pass as input): system.niagara(epic_get_system_compile_state)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns the current compile state of a Niagara System: aggregate status, per-script compile events, and summary flags. Waits for any in-flight compile to complete before collecting. Params (pass as input): system.niagara(epic_get_system_data)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns system property values. Retrieves the current values of all configurable system-level properties. Params (pass as input): system.niagara(epic_get_system_dependencies)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns the four Used* sets (renderers, data interfaces, modules, dynamic inputs) gathered across all emitters and system scripts. These sets are not included in topology structs; call this endpoint separately when needed. Params (pass as input): system.niagara(epic_get_system_schema)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns property schema for Niagara System. Describes all available properties and their types that can be set on a Niagara System. Params: none.niagara(epic_get_system_summary)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns lightweight system metadata: name, user variables, and one summary entry per emitter. Use this for first contact with an unfamiliar system. For full structural detail call GetEmitterTopology per emitter. Params (pass as input): system.niagara(epic_get_user_variables)- [Epic NiagaraToolsets.NiagaraToolset_Component] Returns all user variable values currently set on the component. This retrieves the current values of all user-exposed parameters that can be overridden at the component level. Params (pass as input): component.niagara(epic_get_user_variables__niagara_toolset_system)- [Epic NiagaraToolsets.NiagaraToolset_System] Returns all user variables defined on the system. User variables are parameters exposed for external control and can be overridden per component instance. Params (pass as input): system.niagara(epic_get_variable)- [Epic NiagaraToolsets.NiagaraToolset_Component] Gets the current value of a specific user variable on the component. This retrieves the current value of a user-exposed parameter, including any component-level overrides. Params (pass as input): component, var.niagara(epic_remove_emitter)- [Epic NiagaraToolsets.NiagaraToolset_System] Removes an emitter from a system. Deletes the specified emitter and all its associated scripts, modules, and renderers. Params (pass as input): emitterToRemove.niagara(epic_remove_module)- [Epic NiagaraToolsets.NiagaraToolset_System] Removes a module from a script stack. Deletes the specified module and all its inputs from the script's execution stack. Params (pass as input): moduleToRemove.niagara(epic_remove_renderer)- [Epic NiagaraToolsets.NiagaraToolset_System] Removes a renderer from an emitter. Deletes the specified renderer from the emitter's renderer list. Params (pass as input): rendererToRemove.niagara(epic_remove_set_parameter_entry)- [Epic NiagaraToolsets.NiagaraToolset_System] Removes a parameter from an existing SetParameters module by name. The module referenced by ModuleRef must be a SetParameters (UNiagaraNodeAssignment) module. Use bIsSetParametersModule in the module topology to confirm before calling. Params (pass as input): moduleRef, parameterName.niagara(epic_remove_user_variables)- [Epic NiagaraToolsets.NiagaraToolset_System] Removes user variables from a system. Deletes the specified user variables from the system's user parameter collection. Params (pass as input): system, variablesToRemove.niagara(epic_set_emitter_data)- [Epic NiagaraToolsets.NiagaraToolset_System] Sets property values on a Niagara Emitter. Applies new values to emitter-level properties based on the provided data structure. Params (pass as input): emitter, emitterData.niagara(epic_set_module_enabled)- [Epic NiagaraToolsets.NiagaraToolset_System] Sets whether a module is enabled. Disabled modules remain in the stack but don't execute. Current state is visible in module topology. Params (pass as input): moduleRef, bEnabled.niagara(epic_set_renderer_data)- [Epic NiagaraToolsets.NiagaraToolset_System] Sets property values on a Niagara Renderer. Applies new values to renderer properties based on the provided data structure. Payload shape varies with the concrete renderer class; call GetRendererSchema for the renderer's class to inspect valid properties before writing. Params (pass as input): renderer, rendererData.niagara(epic_set_stack_input_data)- [Epic NiagaraToolsets.NiagaraToolset_System] Sets the value of a stack module input and returns the resulting stored value. Updates the value and configuration for a specific module input parameter. Params (pass as input): stackInputRef, inputData.niagara(epic_set_system)- [Epic NiagaraToolsets.NiagaraToolset_Component] Sets the Niagara System for a component. Use this instead of setting the Asset property directly to ensure proper initialization. Params (pass as input): niagaraComponent, system, bResetExistingOverrideParameters.niagara(epic_set_system_data)- [Epic NiagaraToolsets.NiagaraToolset_System] Sets property values on a Niagara System. Applies new values to system-level properties based on the provided data structure. Params (pass as input): system, systemData.niagara(epic_set_variable)- [Epic NiagaraToolsets.NiagaraToolset_Component] Sets the value of a user variable on the component. This overrides the default value of a user-exposed parameter on a specific component instance. Params (pass as input): component, variable.niagara(epic_uenum_info)- [Epic NiagaraToolsets.NiagaraToolset_Info] Returns information about a UEnum and all its values. ALWAYS call this when working with a UEnum type to see valid values. Params (pass as input): enum.
pcg
Wraps 31 official tools.
pcg(epic_add_comment_box)- [Epic PCGToolset.PCGToolset] Adds a comment box around the given nodes. Note: If the bounding box of the nodes include other nodes, they will be included in the comment. Params (pass as input): graph, nodes, comment?, color?.pcg(epic_add_node)- [Epic PCGToolset.PCGToolset] Adds a native node to the graph. Params (pass as input): graph, nativeNodeType, nodeName, jsonParams, nodeTitle, nodeComment, xPositionIdx?, yPositionIdx?.pcg(epic_add_subgraph_node)- [Epic PCGToolset.PCGToolset] Adds a subgraph node to the graph. Params (pass as input): graph, subGraphForNode, nodeName, jsonParams, nodeTitle, nodeComment, xPositionIdx?, yPositionIdx?.pcg(epic_connect_node_pins)- [Epic PCGToolset.PCGToolset] Add an edge between two nodes connected to the specified pins. Params (pass as input): fromNode, fromPinLabel, toNode, toPinLabel.pcg(epic_create_graph)- [Epic PCGToolset.PCGToolset] Creates a new saved PCG graph asset. Params (pass as input): name, path?.pcg(epic_disconnect_node_pins)- [Epic PCGToolset.PCGToolset] Removes the edge between two nodes connected to the specified pins. Params (pass as input): fromNode, fromPinLabel, toNode, toPinLabel.pcg(epic_draw_spline)- [Epic PCGToolset.PCGToolset] Triggers the user to draw a spline in the viewport to be used later in the world building. Waits for the user to be done. Params (pass as input): actorLabel, actorTag, bRedraw, bClosedSpline.pcg(epic_execute_graph_instance)- [Epic PCGToolset.PCGToolset] Executes the graph instance and returns any issues encountered during execution. Params (pass as input): pCGVolume.pcg(epic_get_graph_description)- [Epic PCGToolset.PCGToolset] Returns the description of a PCG graph. Params (pass as input): graph.pcg(epic_get_graph_instance_params)- [Epic PCGToolset.PCGToolset] Gets the graph instance params of a specific actor, actor MUST have a graph instance Params (pass as input): pCGVolume.pcg(epic_get_graph_schema)- [Epic PCGToolset.PCGToolset] Returns the schema for a PCG Graph's graph parameters Params (pass as input): graph.pcg(epic_get_graph_structure)- [Epic PCGToolset.PCGToolset] Returns the complete structure of a PCG graph including all nodes, connections, exposed parameters, and comment boxes. Params (pass as input): graph.pcg(epic_get_native_node_schema)- [Epic PCGToolset.PCGToolset] Returns the schema for a PCG node type including input/output pins, parameters, and their types. Params (pass as input): nodeName.pcg(epic_get_node_data_view)- [Epic PCGToolset.PCGToolset] Returns a JSON Data View of a specific node's output data from the last graph execution. On first call, enables inspection so future ExecuteGraphInstance calls store per-node data. If no inspection data exists, returns an error prompting re-execution. IMPORTANT: Inspection state is shared at the graph asset level. If multiple actors use the same graph, you MUST call this tool (and ExecuteGraphInstance) on only one actor at a time. Wait for each call to fully complete before calling on the next actor. Concurrent calls on actors sharing the same graph will cause a freeze. Params (pass as input): pCGVolume, node, pinLabel?, attributeName, startIndex?, endIndex?.pcg(epic_get_node_info)- [Epic PCGToolset.PCGToolset] Returns node details including name, position, and all parameter values. Params (pass as input): node.pcg(epic_list_available_subgraphs)- [Epic PCGToolset.PCGToolset] Lists the PCG graphs that can be used with the Subgraph native node. Only these graphs should be used with the Subgraph native node. Params: none.pcg(epic_list_graph_instances)- [Epic PCGToolset.PCGToolset] Gets all actors with a PCG graph instance in the scene. Params: none.pcg(epic_list_native_nodes)- [Epic PCGToolset.PCGToolset] Returns a list of available native PCG node type names. Params (pass as input): bCommonOnly?.pcg(epic_remove_comment_box)- [Epic PCGToolset.PCGToolset] Removes a comment box from the graph. Does not affect the nodes it contains. Params (pass as input): graph, commentId.pcg(epic_remove_graph_params)- [Epic PCGToolset.PCGToolset] Removes graph parameters to a specific PCG graph, such that they are not overridable anymore. Params (pass as input): graph, paramNames.pcg(epic_remove_node)- [Epic PCGToolset.PCGToolset] Removes the node from the graph, will also remove edges connected to the node. Params (pass as input): graph, node.pcg(epic_reposition_node)- [Epic PCGToolset.PCGToolset] Change the position of node. Params (pass as input): node, xPositionIdx, yPositionIdx.pcg(epic_reset_graph_instance_params)- [Epic PCGToolset.PCGToolset] Resets the given graph instance params back to the graph's default values. Actor MUST have a graph instance. Params (pass as input): pCGVolume, paramNames.pcg(epic_run_pcginstant_graph)- [Epic PCGToolset.PCGSpatialToolset] Runs an instant PCG graph with the specified parameters in fire-and-forget mode (Should be called directly: Not callable in a python context execution context) Params (pass as input): graph, params.pcg(epic_set_graph_description)- [Epic PCGToolset.PCGToolset] Set the description of a PCGGraph Params (pass as input): graph, description.pcg(epic_set_graph_instance_params)- [Epic PCGToolset.PCGToolset] Sets the graph instance params of a specific actor, actor MUST have a graph instance Params (pass as input): pCGVolume, jsonParams.pcg(epic_set_graph_params)- [Epic PCGToolset.PCGToolset] Adds one or more graph user parameters to a specific PCG graph, such that they will be overridable in per graph instance. Params (pass as input): graph, params.pcg(epic_set_node_comment)- [Epic PCGToolset.PCGToolset] Change the comment on the specified node. Params (pass as input): node, nodeComment.pcg(epic_spawn_graph_instance)- [Epic PCGToolset.PCGToolset] Spawns a PCG Volume with associated Graph Instance into the scene, optionally with Graph Param overrides. Params (pass as input): graph, name, transform, jsonParams.pcg(epic_update_comment_box)- [Epic PCGToolset.PCGToolset] Updates an existing comment box with new nodes and value. Note: If the bounding box of the nodes include other nodes, they will be included in the comment. Params (pass as input): graph, commentId, nodes, comment?, color?.pcg(epic_update_node)- [Epic PCGToolset.PCGToolset] Updates a node by changing its params and/or title. Params (pass as input): node, jsonParams, nodeTitle.
widget
Wraps 23 official tools.
widget(epic_add_uicomponent)- [Epic UMGToolSet.UMGToolSet] Adds a UI component of the given class to the named widget. Params (pass as input): widgetBlueprint, widgetName, componentClass.widget(epic_add_widget)- [Epic UMGToolSet.UMGToolSet] Adds a widget to the tree at the specified position. Returns full widget info including Slot pointer. When ParentWidget is null and no root exists, the new widget becomes the root of the tree. Use ObjectTools.list_properties on the returned Widget and Slot to get property names before calling set_properties. Params (pass as input): widgetBlueprint, widgetClass, widgetDisplayName, parentWidget?, childIndex?.widget(epic_bind_to_event_property)- [Epic UMGToolSet.UMGToolSet] Adds a Blueprint event handler graph node bound to a widget's multicast delegate event, Typical events: UButton::OnClicked / OnPressed / OnReleased / OnHovered / OnUnhovered, UCheckBox::OnCheckStateChanged, USlider::OnValueChanged. The matching delegate UPROPERTY must exist on PropertyClass (or a parent of it). Preconditions: - PropertyName must exist in the blueprint. - PropertyClass must be the widget's class (or a parent class) that declares the delegate. Params (pass as input): widgetBlueprint, eventName, propertyName, propertyClass.widget(epic_compile_widget_blueprint)- [Epic UMGToolSet.UMGToolSet] Compiles a widget blueprint. Returns false with error details if compilation fails. Errors include missing BindWidget bindings, type mismatches, and graph errors. Call after all widgets and properties are set. Save separately via AssetTools.save_asset. Params (pass as input): widgetBlueprint.widget(epic_create_widget_blueprint)- [Epic UMGToolSet.UMGToolSet] Creates a new Widget Blueprint asset. Returns the blueprint or nullptr on failure. Params (pass as input): folderPath, assetName, parentClass.widget(epic_get_named_slots)- [Epic UMGToolSet.UMGToolSet] Returns named slot bindings (separate from tree hierarchy). Params (pass as input): widgetBlueprint.widget(epic_get_widget_class_info)- [Epic UMGToolSet.UMGToolSet] Returns the Category, Description and if it's a Panel for a single widget class. Same per-entry data as ListWidgetClasses, but lets callers query a class they already have without scanning every UClass. Returns an empty entry if WidgetClass is null. Can be used to get more information on the class from the Description and Category. Params (pass as input): widgetClass.widget(epic_get_widget_description)- [Epic UMGToolSet.UMGToolSet] Full property dump of every widget in the tree. Each line: [N] Type Name Prop:Value ... slot:(SlotProp:Value ...) N is the 0-based index into result.Widgets -- use result.Widgets[N] to get the widget ref without text parsing. Same indentation format as GetTaggedWidgetDescription; richer per-widget detail. Params (pass as input): widgetBlueprint, startWidget?, maxDepth?.widget(epic_get_widget_tree_depth)- [Epic UMGToolSet.UMGToolSet] Returns the maximum depth of the widget tree. Depth: root with no children = 0; root + children = 1; etc. Params (pass as input): widgetBlueprint, startWidget?.widget(epic_get_widgets)- [Epic UMGToolSet.UMGToolSet] Returns blueprint info and all widgets in depth-first order. Children within each parent are in their panel slot order - this is the hierarchy order shown in the designer. Info contains ParentClass (pass to CreateWidgetBlueprint) and RootWidgetClass. Use ObjectTools.list_properties on each returned Widget and Slot to get property names before calling set_properties. Params (pass as input): widgetBlueprint.widget(epic_list_widget_blueprints)- [Epic UMGToolSet.UMGToolSet] Lists widget blueprints in a content folder. Params (pass as input): folderPath.widget(epic_list_widget_classes)- [Epic UMGToolSet.UMGToolSet] Lists available widget classes, optionally filtered by name substring. Params (pass as input): filter.widget(epic_move_uicomponent)- [Epic UMGToolSet.UMGToolSet] Moves a UI component before or after another component on the same widget. Params (pass as input): widgetBlueprint, widgetName, componentClassToMove, relativeToComponentClass, bMoveAfter.widget(epic_move_widget)- [Epic UMGToolSet.UMGToolSet] Moves a widget to a new parent panel at the specified position. Returns updated widget info with new Slot. Params (pass as input): widgetBlueprint, widget, newParent, childIndex?.widget(epic_remove_uicomponent)- [Epic UMGToolSet.UMGToolSet] Removes a UI component of the given class from the named widget. Params (pass as input): widgetBlueprint, widgetName, componentClass.widget(epic_remove_widget)- [Epic UMGToolSet.UMGToolSet] Removes a widget and its children from the tree. Params (pass as input): widgetBlueprint, widget.widget(epic_rename_widget)- [Epic UMGToolSet.UMGToolSet] Renames a widget. Returns updated widget info or empty on failure. Params (pass as input): widgetBlueprint, widget, newDisplayName.widget(epic_replace_widget_with_child)- [Epic UMGToolSet.UMGToolSet] Replaces a panel widget with its first child, removing the panel from the tree. The widget to replace must be a UPanelWidget with only one child. Params (pass as input): widgetBlueprint, widgetToReplace.widget(epic_replace_widget_with_named_slot)- [Epic UMGToolSet.UMGToolSet] Replaces a host widget with the content of one of its named slots. The host must implement INamedSlotInterface (e.g., a UUserWidget exposing named slots). The slot's content widget is moved up to take the host's place in the tree. Params (pass as input): widgetBlueprint, widgetToReplace, namedSlot.widget(epic_replace_widget_with_template)- [Epic UMGToolSet.UMGToolSet] Replaces a widget instance in the blueprint's widget tree with a new instance created from a different template widget class. Preserves references for members that exist on both classes with a compatible type/signature: bindings, BP graph variable references, animation bindings, and delegate bindings. Members without a compatible counterpart on the new class are listed in the returned report; references to those members in the outer blueprint will become orphaned graph nodes / dangling bindings. Params (pass as input): widgetBlueprint, widgetToReplace, templateClass.widget(epic_set_named_slot_content)- [Epic UMGToolSet.UMGToolSet] Sets content for a named slot. Returns full widget info including Slot pointer. Params (pass as input): widgetBlueprint, hostWidget, slotName, widgetClass, widgetName.widget(epic_toggle_widget_as_variable)- [Epic UMGToolSet.UMGToolSet] Sets the bIsVariable flag. Params (pass as input): widgetBlueprint, widget, bIsVariable.widget(epic_wrap_widgets)- [Epic UMGToolSet.UMGToolSet] Wraps one or more widgets in a new panel widget of the specified class. Only the root-most widgets in the selection are wrapped — children of other selected widgets are skipped because their parent will be wrapped. Returns info for each newly created wrapper. Use ObjectTools.list_properties on each returned Widget and Slot to discover property names before calling set_properties (padding, alignment, anchors, etc. vary per panel class). Params (pass as input): widgetBlueprint, widgets, wrapperClass.
statetree
Wraps 9 official tools.
statetree(epic_get_children)- [Epic state_tree_toolset.toolsets.state_tree.StateTreeTools] Returns child states of a state. Args: state: The state to query. Returns: Child states. Params (pass as input): state.statetree(epic_get_editor_data)- [Epic state_tree_toolset.toolsets.state_tree.StateTreeTools] Returns the editor data for a StateTree asset. Args: state_tree: The StateTree asset. Returns: The editor data object. Params (pass as input): state_tree.statetree(epic_get_enter_conditions)- [Epic state_tree_toolset.toolsets.state_tree.StateTreeTools] Returns enter conditions on a state. Args: state: The state to query. Returns: Condition editor nodes. Params (pass as input): state.statetree(epic_get_evaluators)- [Epic state_tree_toolset.toolsets.state_tree.StateTreeTools] Returns global evaluators. Args: state_tree: The StateTree asset. Returns: Evaluator editor nodes. Params (pass as input): state_tree.statetree(epic_get_global_tasks)- [Epic state_tree_toolset.toolsets.state_tree.StateTreeTools] Returns global tasks that run across all states. Args: state_tree: The StateTree asset. Returns: Global task editor nodes. Params (pass as input): state_tree.statetree(epic_get_node_description)- [Epic state_tree_toolset.toolsets.state_tree.StateTreeTools] Returns a human-readable description for a node. Args: state_tree: The StateTree asset. node: The editor node to describe. Returns: Formatted description string. Params (pass as input): state_tree, node.statetree(epic_get_root_states)- [Epic state_tree_toolset.toolsets.state_tree.StateTreeTools] Returns top-level states of a StateTree. Args: state_tree: The StateTree asset. Returns: Root-level states. Params (pass as input): state_tree.statetree(epic_get_tasks)- [Epic state_tree_toolset.toolsets.state_tree.StateTreeTools] Returns tasks on a state. Args: state: The state to query. Returns: Task editor nodes. Params (pass as input): state.statetree(epic_get_transitions)- [Epic state_tree_toolset.toolsets.state_tree.StateTreeTools] Returns transitions on a state. Args: state: The state to query. Returns: Transitions. Params (pass as input): state.
animation
Wraps 319 official tools.
animation(epic_add_actors)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Add actors from the level to the currently open sequence. Args: actors: List of Actors to bind into the sequence. Returns: List of SequencerBindingProxy objects for the new bindings. Params (pass as input): actors.animation(epic_add_actors_by_name)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Add actors to the sequence by their names in the level. Finds actors by label in the current level and adds them to the currently open sequence as possessable bindings. Args: actor_names: List of actor label strings to find and add. Returns: List of SequencerBindingProxy for the added actors. Params (pass as input): actor_names.animation(epic_add_actors_to_binding)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Add actors to an existing binding. Args: actors: List of Actor objects to add. binding: The binding to add actors to. Params (pass as input): actors, binding.animation(epic_add_backward_solve_graph)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Create a backward solve graph with InverseExecution event. Args: control_rig: The Control Rig to add the graph to. name: Optional custom name (default: "Backward Solve"). Returns: The newly created RigVMGraph with InverseExecution event. Params (pass as input): control_rig, name?.animation(epic_add_binding_to_folder)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Add a binding into a folder for organization. Args: folder: The folder to add the binding to. binding: The binding to organize. Params (pass as input): folder, binding.animation(epic_add_bone)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Add a bone to the Control Rig hierarchy. Args: control_rig: The Control Rig to add the bone to. name: Name for the new bone. parent: Parent element in the hierarchy. None creates at root level. transform: Initial world transform. Uses identity if None. Only specified fields are applied; unset fields use identity. Returns: The RigElementKey for the newly created bone. Params (pass as input): control_rig, name, parent?, transform?.animation(epic_add_control)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Add a control to the hierarchy. Args: control_rig: The Control Rig to add the control to. name: Name for the new control. parent: Parent element in the hierarchy. None creates at root level. settings: Control settings (shape, color, limits). Uses defaults if None. Returns: The RigElementKey for the newly created control. Params (pass as input): control_rig, name, parent?, settings?.animation(epic_add_element)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Add a bone or null element to the Control Rig hierarchy. Args: control_rig: The Control Rig to add the element to. name: Name for the new element. element_type: Type of element to create: "bone" or "null". parent: Parent element in the hierarchy. None creates at root level. transform: Initial world transform. Uses identity if None. Only specified fields are applied; unset fields use identity. Returns: The RigElementKey for the newly created element. Params (pass as input): control_rig, name, element_type, parent?, transform?.animation(epic_add_event_graph)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Create a new graph with the specified event type. Args: control_rig: The Control Rig to add the graph to. event_type: The event type to add (BACKWARD_SOLVE or INTERACTION). name: Optional custom name for the graph. Returns: The newly created RigVMGraph with the event node. Params (pass as input): control_rig, event_type, name?.animation(epic_add_event_node)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Add an event node to the graph. Args: control_rig: The Control Rig containing the graph. graph: The graph to add the event to. event_type: The type of event node. position: Position in the graph. Uses (200, 200) if None. Returns: The created event RigVMNode. Params (pass as input): control_rig, graph, event_type, position?.animation(epic_add_event_repeater_section)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Add an event repeater section to an event track. Args: track: The event track. Returns: The new repeater section. Params (pass as input): track.animation(epic_add_event_trigger_section)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Add an event trigger section to an event track. Args: track: The event track. Returns: The new trigger section. Params (pass as input): track.animation(epic_add_graph)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Create a new empty graph in the Control Rig. Args: control_rig: The Control Rig to add the graph to. name: Name for the new graph. Returns: The newly created RigVMGraph. Params (pass as input): control_rig, name.animation(epic_add_interaction_graph)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Create an interaction graph with InteractionExecution event. Args: control_rig: The Control Rig to add the graph to. name: Optional custom name (default: "Interaction"). Returns: The newly created RigVMGraph with InteractionExecution event. Params (pass as input): control_rig, name?.animation(epic_add_key_bool)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Add a bool key to a channel on a section. Args: section: The section containing the channel. channel_name: Name of the channel. frame: The frame number for the key. value: The bool value. Returns: True when the key was added successfully. Params (pass as input): section, channel_name, frame, value.animation(epic_add_key_float)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Add a float key to a channel on a section. Args: section: The section containing the channel. channel_name: Name of the channel (e.g. 'Location.X'). frame: The frame number for the key. value: The float value. interpolation: Key interpolation mode as a string: "cubic", "linear", "constant", "break", or "" for default (smart auto). Returns: True when the key was added successfully. Params (pass as input): section, channel_name, frame, value, interpolation.animation(epic_add_key_integer)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Add an integer key to a channel on a section. Args: section: The section containing the channel. channel_name: Name of the channel. frame: The frame number for the key. value: The integer value. Returns: True when the key was added successfully. Params (pass as input): section, channel_name, frame, value.animation(epic_add_key_string)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Add a string key to a channel on a section. Args: section: The section containing the channel. channel_name: Name of the channel. frame: The frame number for the key. value: The string value. Returns: True when the key was added successfully. Params (pass as input): section, channel_name, frame, value.animation(epic_add_layer_from_selection)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Add an animation layer from the currently selected objects in Sequencer. Returns: The index of the newly created animation layer. Params: none.animation(epic_add_marked_frame)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Add a marked frame (bookmark) to the sequence. Args: sequence: The LevelSequence to modify. frame: The frame number to mark. Returns: The index of the newly added marked frame. Params (pass as input): sequence, frame.animation(epic_add_null)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Add a null (locator) to the Control Rig hierarchy. Args: control_rig: The Control Rig to add the null to. name: Name for the new null. parent: Parent element in the hierarchy. None creates at root level. transform: Initial world transform. Uses identity if None. Only specified fields are applied; unset fields use identity. Returns: The RigElementKey for the newly created null. Params (pass as input): control_rig, name, parent?, transform?.animation(epic_add_root_folder)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Create a new root-level folder in the sequence. Args: sequence: The LevelSequence to add the folder to. name: The folder name. Returns: The newly created MovieSceneFolder. Params (pass as input): sequence, name.animation(epic_add_section)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Add a new section to a track. Args: track: The track to add a section to. Returns: The newly created MovieSceneSection. Params (pass as input): track.animation(epic_add_spawnable_from_class)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Create a spawnable binding from an actor class. Args: sequence: The LevelSequence to add the spawnable to. actor_class_path: Full class path, e.g. '/Script/Engine.CameraActor' or '/Script/CinematicCamera.CineCameraActor'. Returns: The SequencerBindingProxy for the new spawnable. Params (pass as input): sequence, actor_class_path.animation(epic_add_spawnable_from_instance)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Create a spawnable binding from an existing object instance. Args: sequence: The LevelSequence to add the spawnable to. obj: The object to create a spawnable from. Returns: The SequencerBindingProxy for the new spawnable. Params (pass as input): sequence, obj.animation(epic_add_track_to_binding)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Add a track of the given type to a binding. Args: binding: The binding to add the track to. track_type: The track class (e.g. unreal.MovieSceneSkeletalAnimationTrack). Returns: The newly created MovieSceneTrack. Params (pass as input): binding, track_type.animation(epic_add_track_to_folder)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Add a track into a folder for organization. Args: folder: The folder to add the track to. track: The track to organize. Params (pass as input): folder, track.animation(epic_add_track_to_sequence)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Add a sequence-level (master) track. Args: sequence: The LevelSequence to add the track to. track_type: The track class (e.g. unreal.MovieSceneCameraCutTrack). Returns: The newly created MovieSceneTrack. Params (pass as input): sequence, track_type.animation(epic_add_variable)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Add a member variable to the Control Rig. Args: control_rig: The Control Rig to add the variable to. name: Variable name. type_path: UE type path (e.g., "double", "float", "/Script/CoreUObject.Vector"). is_public: Whether the variable is exposed publicly. is_read_only: Whether the variable is read-only. default_value: Default value as string. Params (pass as input): control_rig, name, type_path, is_public?, is_read_only?, default_value.animation(epic_add_variable_node)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Create a variable getter or setter node. The variable must already exist (created via add_variable first). Args: control_rig: The Control Rig containing the graph. graph: The graph to add the node to. variable_name: Name of the variable to reference. is_getter: True for getter node, False for setter node. position: Position in the graph. Uses (0, 0) if None. Returns: The created variable RigVMNode. Params (pass as input): control_rig, graph, variable_name, is_getter?, position?.animation(epic_bake_channel_keys)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Bake a channel's values over a frame range. Evaluates the channel curve at every frame in the range and returns the computed values. Useful for extracting animation data or verifying interpolation results. Args: section: The section containing the channel. channel_name: Name of the channel (e.g. 'Location.X'). start_frame: Start of the evaluation range. end_frame: End of the evaluation range. Returns: List of float values, one per frame in the range. Params (pass as input): section, channel_name, start_frame, end_frame.animation(epic_bake_space)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Bake Control Rig controls' space over a frame range. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_names: Names of controls to bake. start_frame: Start of the bake range. end_frame: End of the bake range. reduce_keys: If True, perform key reduction after baking. tolerance: Key reduction tolerance. Returns: True if the bake succeeded. Params (pass as input): sequence, control_rig_asset_path, control_names, start_frame, end_frame, reduce_keys?, tolerance?.animation(epic_bake_to_control_rig)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Bake existing animation on a binding into a Control Rig track. Args: sequence: The LevelSequence. binding: The skeletal mesh binding to bake from. control_rig_asset_path: Path to the CR asset to bake into. reduce_keys: If True, perform key reduction after baking. tolerance: Key reduction tolerance. Smaller values keep more keys. reset_controls: If True, reset all controls to initial value per frame. Returns: True if baking succeeded. Params (pass as input): sequence, binding, control_rig_asset_path, reduce_keys?, tolerance?, reset_controls?.animation(epic_bake_transform)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Bake transforms for the given bindings at every frame. Args: bindings: List of SequencerBindingProxy objects to bake. Returns: True if the bake succeeded. Params (pass as input): bindings.animation(epic_blend_values_on_selected)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Perform a blend operation on selected keys or controls. Args: sequence: The LevelSequence (must be open in Sequencer). operation: The blend operation. One of: 'tween', 'blend_to_neighbor', 'push_pull', 'blend_relative', 'blend_to_ease', 'smooth_rough'. blend_value: Blend value, typically -1.0 to 1.0. Returns: True if the blend succeeded. Params (pass as input): sequence, operation, blend_value.animation(epic_change_actor_template_class)- [Epic animation_toolset.toolsets.custom_bindings.SequencerCustomBindingTools] Set the actor class for a spawnable or replaceable template. Args: binding: The spawnable/replaceable binding to modify. actor_class: Full class path of the new actor class. Returns: True if the class was changed successfully. Params (pass as input): binding, actor_class.animation(epic_change_variable_type)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Change the type of an existing variable. Args: control_rig: The Control Rig containing the variable. name: Variable name. new_type: New type path (e.g., "double", "float"). Params (pass as input): control_rig, name, new_type.animation(epic_clear_section_condition)- [Epic animation_toolset.toolsets.conditions.SequencerConditionTools] Remove the condition from a section. Args: section: The section to clear the condition from. Params (pass as input): section.animation(epic_clear_selection)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Clear the current Control Rig control selection. Params: none.animation(epic_clear_track_condition)- [Epic animation_toolset.toolsets.conditions.SequencerConditionTools] Remove the condition from a track. Args: track: The track to clear the condition from. Params (pass as input): track.animation(epic_clear_track_row_condition)- [Epic animation_toolset.toolsets.conditions.SequencerConditionTools] Remove the condition from a specific track row. Args: track: The track to modify. row_index: The row index (0-based). Params (pass as input): track, row_index.animation(epic_close_curve_editor)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Close the Sequencer Curve Editor panel. Params: none.animation(epic_close_sequence)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Close the currently open level sequence editor. Params: none.animation(epic_collapse_anim_layers)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Collapse all sections and layers on a Control Rig track into one section. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. reduce_keys: If True, perform key reduction after collapsing. tolerance: Key reduction tolerance. Returns: True if collapsing succeeded. Params (pass as input): sequence, control_rig_asset_path, reduce_keys?, tolerance?.animation(epic_connect_pins)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Connect two pins together. Args: control_rig: The Control Rig containing the graph. graph: The graph containing the pins. source_pin: The source (output) pin. target_pin: The target (input) pin. Params (pass as input): control_rig, graph, source_pin, target_pin.animation(epic_convert_to_custom_binding)- [Epic animation_toolset.toolsets.custom_bindings.SequencerCustomBindingTools] Convert a binding to a custom binding type. Args: binding: The binding to convert. binding_type_class: Full class path of the custom binding type. Returns: The converted SequencerBindingProxy. Params (pass as input): binding, binding_type_class.animation(epic_convert_to_possessable)- [Epic animation_toolset.toolsets.custom_bindings.SequencerCustomBindingTools] Convert a spawnable binding to a possessable. Args: binding: The spawnable binding to convert. Returns: The new possessable SequencerBindingProxy. Params (pass as input): binding.animation(epic_convert_to_spawnable)- [Epic animation_toolset.toolsets.custom_bindings.SequencerCustomBindingTools] Convert a possessable binding to a spawnable. Args: binding: The possessable binding to convert. Returns: List of new spawnable SequencerBindingProxy objects. Params (pass as input): binding.animation(epic_copy_bindings)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Copy one or more bindings to the Sequencer clipboard. Returns a paste token that can be passed to paste_bindings, or an empty string to consume from the clipboard. The token also lands in the editor clipboard for interactive use. Args: bindings: The bindings to copy. Returns: The paste token string. Params (pass as input): bindings.animation(epic_copy_folders)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Copy one or more folders to the Sequencer clipboard. Args: folders: The folders to copy. Returns: The paste token string. Params (pass as input): folders.animation(epic_copy_sections)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Copy one or more sections to the Sequencer clipboard. Args: sections: The sections to copy. Returns: The paste token string. Params (pass as input): sections.animation(epic_copy_tracks)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Copy one or more tracks to the Sequencer clipboard. Args: tracks: The tracks to copy. Returns: The paste token string. Params (pass as input): tracks.animation(epic_create)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Creates a new Control Rig at the given location. Args: path: The content browser path for the new Control Rig. Returns: The newly created ControlRigBlueprint. Params (pass as input): path.animation(epic_create_camera)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Create a new cine camera actor in the sequence. Args: spawnable: If True, creates as a spawnable. If False, creates as a possessable placed in the level. Returns: The SequencerBindingProxy for the new camera. Params (pass as input): spawnable?.animation(epic_create_level_sequence)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Create a new Level Sequence asset. If an asset already exists at the given path, it will be deleted first to avoid triggering a modal overwrite dialog. Args: package_path: The content browser folder path (e.g. '/Game/Cinematics'). asset_name: The name for the new sequence asset. Returns: The newly created LevelSequence asset. Params (pass as input): package_path, asset_name.animation(epic_create_node)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Create a new RigUnit node in the graph. Args: control_rig: The Control Rig containing the graph. graph: The graph to add the node to. node_type: RigUnit struct name (e.g., "RigUnit_MathFloatAdd") or full path (e.g., "/Script/ControlRig.RigUnit_MathFloatAdd"). position: Position in the graph editor. Uses (0, 0) if None. node_name: Optional custom name for the node. Returns: The created RigVMNode. Params (pass as input): control_rig, graph, node_type, position?, node_name.animation(epic_curve_editor_empty_selection)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Clear all key selection in the Curve Editor. Params: none.animation(epic_curve_editor_select_keys)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Select keys by index in the Curve Editor. Args: channel: The channel proxy containing the keys. indices: List of integer key indices to select. Params (pass as input): channel, indices.animation(epic_delete_all_marked_frames)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Delete all marked frames from the sequence. Args: sequence: The LevelSequence to modify. Params (pass as input): sequence.animation(epic_delete_anim_layer)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Delete an animation layer at the specified index. Args: index: The index of the layer to delete. Returns: True if the layer was deleted successfully. Params (pass as input): index.animation(epic_delete_marked_frame)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Delete a marked frame by index. Args: sequence: The LevelSequence to modify. index: Index of the marked frame to delete. Params (pass as input): sequence, index.animation(epic_delete_node)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Delete a node from the graph. Args: control_rig: The Control Rig containing the graph. graph: The graph containing the node. node: The node to delete. Params (pass as input): control_rig, graph, node.animation(epic_delete_space)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Delete a space-switch key at a specific frame. Performs compensation to the new space automatically. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the control. frame: Frame of the space key to delete. Returns: True if the deletion succeeded. Params (pass as input): sequence, control_rig_asset_path, control_name, frame.animation(epic_disconnect_pins)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Disconnect two pins. Args: control_rig: The Control Rig containing the graph. graph: The graph containing the pins. source_pin: The source (output) pin. target_pin: The target (input) pin. Params (pass as input): control_rig, graph, source_pin, target_pin.animation(epic_duplicate_anim_layer)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Duplicate an animation layer at the specified index. Args: index: The index of the layer to duplicate. Returns: The index of the newly created duplicate layer, or -1 on failure. Params (pass as input): index.animation(epic_empty_selection)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Clear all selection in the Sequencer editor. Params: none.animation(epic_export_anim_sequence)- [Epic animation_toolset.toolsets.import_export.SequencerImportExportTools] Export animation from a sequence binding to an AnimSequence asset. Args: world: The world context. sequence: The source LevelSequence. anim_sequence: The destination AnimSequence asset. binding: The binding whose animation to export. create_link: Whether to create a link between the sequence and the exported AnimSequence. Returns: True if the export succeeded, False otherwise. Params (pass as input): world, sequence, anim_sequence, binding, create_link?.animation(epic_export_fbx)- [Epic animation_toolset.toolsets.import_export.SequencerImportExportTools] Export a level sequence to FBX. Args: world: The world context. sequence: The LevelSequence to export. bindings: The bindings to include in the export. fbx_file_path: The output FBX file path. override_options: Optional FBX export options. Returns: True if the export succeeded, False otherwise. Params (pass as input): world, sequence, bindings, fbx_file_path, override_options?.animation(epic_export_fbx_from_rig)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Export an FBX file from a Control Rig section. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. export_file_path: File system path for the output FBX file. ascii: If True, export in ASCII format instead of binary. Returns: True if the export succeeded. Params (pass as input): sequence, control_rig_asset_path, export_file_path, ascii?.animation(epic_find_binding_by_name)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Find a binding by its display name. Args: sequence: The LevelSequence to search. name: The display name to match. Returns: The matching SequencerBindingProxy. Params (pass as input): sequence, name.animation(epic_find_binding_by_tag)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Find the first binding with the given tag in the sequence. Tags are authored via tag_binding() in this toolset, or via RMB -> Expose on a binding in the Sequencer editor. Args: sequence: The LevelSequence to search. tag_name: The tag name to look up. Returns: The first matching FMovieSceneObjectBindingID. When no binding carries the tag, a default-constructed (invalid) ID is returned - check.is_valid()on the result, or call find_bindings_by_tag() and test the list length instead. Params (pass as input): sequence, tag_name.animation(epic_find_bindings_by_tag)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Find all bindings with the given tag in the sequence. Args: sequence: The LevelSequence to search. tag_name: The tag name to look up. Returns: List of matching FMovieSceneObjectBindingID objects. Params (pass as input): sequence, tag_name.animation(epic_find_marked_frame_by_label)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Find a marked frame by label. Args: sequence: The LevelSequence to search. label: The label to find. Returns: Index of the marked frame, or -1 if not found. Params (pass as input): sequence, label.animation(epic_find_or_create_track)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Add a Control Rig track to a binding using a Control Rig asset. This is the standard way to add a Control Rig to Sequencer. Uses ControlRigSequencerLibrary.find_or_create_control_rig_track. Args: sequence: The LevelSequence. binding: The binding to add the CR track to. control_rig_asset_path: Path to the CR asset (e.g. '/Game/Rigs/CR_Mannequin_Body'). is_layered: If True, create as a layered Control Rig. Returns: JSON string with 'track' refPath and 'control_rig' info. Params (pass as input): sequence, binding, control_rig_asset_path, is_layered?.animation(epic_find_tracks_by_type)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Find all tracks of a specific type on a binding. Args: binding: The binding to search. track_type: The track class to filter by. Returns: List of matching MovieSceneTrack objects. Params (pass as input): binding, track_type.animation(epic_fix_actor_references)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Attempt to auto-fix broken actor references in the current sequence. Params: none.animation(epic_focus_parent_sequence)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Navigate up one level in the sub-sequence hierarchy. Params: none.animation(epic_focus_sub_sequence)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Navigate into a sub-sequence via its sub-section. Use get_sections() on a sub-track to find the sub-section, then pass it here to focus the sub-sequence it references. Args: sub_section: The sub-section referencing the sub-sequence to focus. Params (pass as input): sub_section.animation(epic_force_evaluate)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Force the Sequencer to evaluate and update the viewport. Params: none.animation(epic_frame_selection)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Frame the viewport to the current Control Rig control selection. Params: none.animation(epic_get_actor_transform_at_frame)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get an actor's world transform at a specific frame. Finds the actor by name in the current editor world. Args: sequence: The LevelSequence. actor_name: The name or label of the actor in the level. frame: The frame number. Returns: JSON string with 'location' (x,y,z) and 'rotation' (pitch,yaw,roll). Params (pass as input): sequence, actor_name, frame.animation(epic_get_all_binding_tags)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get every tag name registered in the sequence. Uses the MovieSceneBindingTagExtensions C++ library. Args: sequence: The LevelSequence to query. Returns: List of tag name strings. Params (pass as input): sequence.animation(epic_get_all_bones)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Get all bones in the Control Rig hierarchy. Args: control_rig: The Control Rig to query. Returns: List of RigElementKeys for all bones. Params (pass as input): control_rig.animation(epic_get_all_controls)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Get all controls in the Control Rig hierarchy. Args: control_rig: The Control Rig to query. Returns: List of RigElementKeys for all controls. Params (pass as input): control_rig.animation(epic_get_all_nulls)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Get all nulls (locators) in the Control Rig hierarchy. Args: control_rig: The Control Rig to query. Returns: List of RigElementKeys for all nulls. Params (pass as input): control_rig.animation(epic_get_anim_layers)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get all animation layers from the active Sequencer. Returns: JSON string with a list of layer objects, each containing 'index' and 'name'. Params: none.animation(epic_get_anim_mode_gizmo_scale)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get the editor's transform gizmo size. Reads UTransformGizmoEditorSettings::TransformGizmoSize. The CR-specific gizmo scale was removed in UE 5.8 in favor of this editor-wide setting, so this affects every transform gizmo (level, sequencer, CR, etc.). Returns: The transform gizmo size offset. Default 0.0; range -10..150. Params: none.animation(epic_get_anim_mode_hide_manips)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get whether Animation Mode hides all manipulators. Returns: True if manipulators are hidden. Params: none.animation(epic_get_anim_mode_hierarchy)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get whether the Animation Mode draws hierarchy lines/dots. Returns: True if hierarchy display is on. Params: none.animation(epic_get_anim_mode_local_spaces)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get whether multi-select transforms act in each control's own space. Returns: True if each selected control transforms in its own local space. Params: none.animation(epic_get_anim_mode_nulls)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get whether the Animation Mode draws nulls. Returns: True if null display is on. Params: none.animation(epic_get_anim_mode_only_rig_sel)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get whether Animation Mode restricts viewport selection to rig controls. Returns: True if only rig controls are selectable. Params: none.animation(epic_get_backward_solve_graph)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Get the backward solve graph. The backward solve graph contains the InverseExecution event and runs during IK operations. Args: control_rig: The Control Rig to query. Returns: The backward solve RigVMGraph. Params (pass as input): control_rig.animation(epic_get_binding_id)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the binding ID for a binding proxy. The binding ID can be used with get_bound_objects to resolve what actor or component the binding references at runtime. Args: sequence: The LevelSequence containing the binding. binding: The binding to get the ID for. Returns: The MovieSceneObjectBindingID. Params (pass as input): sequence, binding.animation(epic_get_binding_name)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the display name of a binding. Args: binding: The binding to query. Returns: The binding's display name. Params (pass as input): binding.animation(epic_get_binding_tags)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the tags currently attached to a specific binding. Args: binding: The binding to query. Returns: List of tag name strings. Params (pass as input): binding.animation(epic_get_bindings)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get all bindings in the sequence. Args: sequence: The LevelSequence to query. Returns: List of SequencerBindingProxy objects. Params (pass as input): sequence.animation(epic_get_bool)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get a bool control value at a specific frame. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the bool control. frame: The frame number. Returns: The bool value at the given frame. Params (pass as input): sequence, control_rig_asset_path, control_name, frame.animation(epic_get_bound_objects)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the objects currently resolved by a binding. Args: binding: The binding to resolve. Returns: List of resolved UObject instances. Params (pass as input): binding.animation(epic_get_channel_names)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Get the names of all channels on a section. For example, a 3D Transform section has channels named 'Location.X', 'Location.Y', 'Location.Z', 'Rotation.X', etc. Args: section: The section to query. Returns: List of channel name strings. Params (pass as input): section.animation(epic_get_child_possessables)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get component bindings under an actor binding. Actor bindings can own child possessable bindings for their components (e.g. SkeletalMeshComponent, CameraComponent). Use this to find the component binding when you need to add tracks to a specific component rather than the actor. Args: binding: The actor-level binding to query. Returns: List of child component SequencerBindingProxy objects. Params (pass as input): binding.animation(epic_get_children)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Get children of a hierarchy element. Args: control_rig: The Control Rig to query. item: The element to get children of. recursive: If True, returns all descendants recursively. Returns: List of child RigElementKeys. Params (pass as input): control_rig, item, recursive?.animation(epic_get_clock_source)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the clock source for the sequence. Args: sequence: The LevelSequence to query. Returns: String representation of the clock source. Params (pass as input): sequence.animation(epic_get_connected_pins)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Get all pins connected to this pin. Args: control_rig: The Control Rig containing the pin. pin: The pin to query. Returns: List of connected RigVMPin objects. Params (pass as input): control_rig, pin.animation(epic_get_control_rigs)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get all Control Rigs currently in the sequence. Returns proxy objects with track and rig references. Args: sequence: The LevelSequence to query. Returns: JSON string with list of CR info objects containing 'track', 'control_rig_name', and 'is_layered'. Params (pass as input): sequence.animation(epic_get_controls_info)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get all controls on a Control Rig with their names and types. Returns a list of controls with name and type so the caller can find controls of a specific type (e.g. find a Float control to use with set_float). Possible types: Bool, Float, Integer, Vector2D, Position, Rotator, Scale, Transform, TransformNoScale, EulerTransform. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. Returns: JSON string with a list of objects, each with 'name' and 'type'. Params (pass as input): sequence, control_rig_asset_path.animation(epic_get_controls_mask)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Check if a control is visible (unmasked) on a section. Args: section: The Control Rig parameter section. control_name: The control name to check. Returns: True if the control is visible, False if masked. Params (pass as input): section, control_name.animation(epic_get_current_sequence)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the root level sequence currently open in the Sequencer editor. Returns: The root LevelSequence asset, or None if no sequence is open. Params: none.animation(epic_get_curve_editor_selected_keys)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Get selected key indices for a channel in the Curve Editor. Args: channel: The channel proxy to query. Returns: List of integer key indices that are selected. Params (pass as input): channel.animation(epic_get_custom_binding_objects)- [Epic animation_toolset.toolsets.custom_bindings.SequencerCustomBindingTools] Get the custom binding instances for a binding. Args: binding: The binding to query. Returns: List of UMovieSceneCustomBinding objects. Params (pass as input): binding.animation(epic_get_custom_binding_type)- [Epic animation_toolset.toolsets.custom_bindings.SequencerCustomBindingTools] Get the custom binding class for a binding. Returns the class path of the custom binding type, or an empty string for standard possessable bindings. Args: binding: The binding to query. Returns: Class path string, or empty string. Params (pass as input): binding.animation(epic_get_custom_bindings_of_type)- [Epic animation_toolset.toolsets.custom_bindings.SequencerCustomBindingTools] Find all bindings of a given custom type in the current sequence. Args: binding_type_class: Full class path of the custom binding type. Returns: List of matching SequencerBindingProxy objects. Params (pass as input): binding_type_class.animation(epic_get_deactivated_nodes)- [Epic animation_toolset.toolsets.outliner.SequencerOutlinerTools] Get the currently deactivated outliner nodes. Returns: List of deactivated nodes. Params: none.animation(epic_get_default_value)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Get the default value of a float channel. Args: section: The section containing the channel. channel_name: Name of the channel. Returns: The default value of the channel. Params (pass as input): section, channel_name.animation(epic_get_display_rate)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the display frame rate of a sequence. Args: sequence: The LevelSequence to query. Returns: The display FrameRate. Params (pass as input): sequence.animation(epic_get_elements)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Get hierarchy elements of the specified type. Args: control_rig: The Control Rig to query. element_type: Type of elements to return, or None for all elements. Returns: List of RigElementKeys matching the specified type. Params (pass as input): control_rig, element_type?.animation(epic_get_euler_transform)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get an EulerTransform control value at a specific frame. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the EulerTransform control. frame: The frame number. Returns: JSON string with 'location' (x,y,z), 'rotation' (pitch,yaw,roll), and 'scale' (x,y,z) dicts. Params (pass as input): sequence, control_rig_asset_path, control_name, frame.animation(epic_get_evaluation_type)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the evaluation type of a sequence. Args: sequence: The LevelSequence to query. Returns: String representation of the evaluation type. Params (pass as input): sequence.animation(epic_get_event_graph)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Get a graph containing the specified event type. Args: control_rig: The Control Rig to query. event_type: The event type to search for. Returns: The RigVMGraph containing the specified event. Params (pass as input): control_rig, event_type.animation(epic_get_float)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get a float control value at a specific frame. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the float control. frame: The frame number. Returns: The float value at the given frame. Params (pass as input): sequence, control_rig_asset_path, control_name, frame.animation(epic_get_focused_sequence)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the currently focused level sequence in the hierarchy. When navigated into a sub-sequence, this returns the sub-sequence rather than the root sequence. Returns: The focused LevelSequence asset, or None if no sequence is open. Params: none.animation(epic_get_folder_contents)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the tracks and bindings inside a folder. Args: folder: The folder to inspect. Returns: JSON string with 'track_count' and 'binding_count', plus 'track_names' and 'binding_names' lists. Params (pass as input): folder.animation(epic_get_forward_solve_graph)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Get the forward solve graph (main execution graph). This graph contains the BeginExecution event and runs during normal animation evaluation. Args: control_rig: The Control Rig to query. Returns: The forward solve RigVMGraph. Params (pass as input): control_rig.animation(epic_get_global_transform)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Get global transform of a hierarchy element. Args: control_rig: The Control Rig to query. item: The element to get the transform for. initial: If True, returns the initial (setup) transform. Returns: The element's global transform with translation, rotation (euler), and scale. Params (pass as input): control_rig, item, initial?.animation(epic_get_graph)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Get a specific graph from the Control Rig by name. Args: control_rig: The Control Rig to query. graph_name: Name of the graph (e.g., "RigVMModel"). Returns: The RigVMGraph object. Params (pass as input): control_rig, graph_name.animation(epic_get_int)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get an integer control value at a specific frame. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the integer control. frame: The frame number. Returns: The integer value at the given frame. Params (pass as input): sequence, control_rig_asset_path, control_name, frame.animation(epic_get_interaction_graph)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Get the interaction graph. The interaction graph contains the InteractionExecution event and runs during user interaction with controls. Args: control_rig: The Control Rig to query. Returns: The interaction RigVMGraph. Params (pass as input): control_rig.animation(epic_get_keys)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Get all keys on a channel, returned as a JSON array. Each key entry includes its frame number and value. Args: section: The section containing the channel. channel_name: Name of the channel. Returns: JSON string with a list of key objects, each with 'frame' and 'value' fields. For numeric channels the value is a native JSON number; for exotic channel types that don't round-trip through JSON natively, the value is stringified. Params (pass as input): section, channel_name.animation(epic_get_keys_by_index)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Get specific keys on a channel by their indices, returned as JSON. Useful for resolving the keys behind a Curve Editor selection, which provides indices rather than key objects. Args: section: The section containing the channel. channel_name: Name of the channel. indices: Key indices to look up (0-based). Returns: JSON string with a list of key objects, each with 'frame', 'value', and 'index' fields. An entry is emitted for EVERY requested index in the input order; out-of-range indices are reported with 'frame': None and 'value': None so callers can correlate results with the request. Value uses a native JSON number for numeric channels and a string for exotic types. Params (pass as input): section, channel_name, indices.animation(epic_get_linked_anim_sequences)- [Epic animation_toolset.toolsets.import_export.SequencerImportExportTools] Get content paths of all AnimSequences linked to a LevelSequence. Linked AnimSequences auto-update when the LevelSequence changes. They are created via export_anim_sequence with create_link=True. Args: sequence: The LevelSequence to query. Returns: List of content paths (e.g. '/Game/Anim/Test_Anim') for each linked AnimSequence. Empty list if no links exist. Params (pass as input): sequence.animation(epic_get_linked_level_sequence)- [Epic animation_toolset.toolsets.import_export.SequencerImportExportTools] Get the content path of the LevelSequence linked to an AnimSequence. Args: anim_sequence: The AnimSequence to query. Returns: Content path of the linked LevelSequence, or empty string if no link exists. Params (pass as input): anim_sequence.animation(epic_get_local_transform)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Get local transform of a hierarchy element. Args: control_rig: The Control Rig to query. item: The element to get the transform for. initial: If True, returns the initial (setup) transform. Returns: The element's local transform relative to its parent, with translation, rotation (euler), and scale. Params (pass as input): control_rig, item, initial?.animation(epic_get_locked_nodes)- [Epic animation_toolset.toolsets.outliner.SequencerOutlinerTools] Get the currently locked outliner nodes. Returns: List of locked nodes. Params: none.animation(epic_get_loop_mode)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the current loop playback mode. Returns: True if looping is enabled, False otherwise. Params: none.animation(epic_get_marked_frames)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get all marked frames (bookmarks) in the sequence. Args: sequence: The LevelSequence to query. Returns: List of MovieSceneMarkedFrame objects. Params (pass as input): sequence.animation(epic_get_muted_nodes)- [Epic animation_toolset.toolsets.outliner.SequencerOutlinerTools] Get the currently muted outliner nodes. Returns: List of muted nodes. Params: none.animation(epic_get_node_label)- [Epic animation_toolset.toolsets.outliner.SequencerOutlinerTools] Get the display label of an outliner node. Args: node: The outliner node to query. Returns: The node's display label text. Params (pass as input): node.animation(epic_get_node_position)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Get the position of a node in the graph editor. Args: control_rig: The Control Rig containing the node. node: The node to query. Returns: The node's position as Vector2D. Params (pass as input): control_rig, node.animation(epic_get_outliner_children)- [Epic animation_toolset.toolsets.outliner.SequencerOutlinerTools] Get child nodes of an outliner node. Args: node: The parent outliner node. type_filter: Optional node type name to filter by (e.g. "Track"). Returns: List of child SequencerViewModelScriptingStruct objects. Params (pass as input): node, type_filter?.animation(epic_get_outliner_selection)- [Epic animation_toolset.toolsets.outliner.SequencerOutlinerTools] Get the currently selected nodes in the outliner. Returns: List of selected SequencerViewModelScriptingStruct objects. Params: none.animation(epic_get_outliner_tree)- [Epic animation_toolset.toolsets.outliner.SequencerOutlinerTools] Get a full snapshot of the Sequencer outliner tree. Builds a recursive tree structure from the outliner root nodes. Useful for testing and UI verification. Returns: JSON string encoding a list of objects, each with 'label', 'type', and 'children' (a recursive list of the same structure). Params: none.animation(epic_get_parent)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Get the parent of a hierarchy element. Args: control_rig: The Control Rig to query. item: The element to get the parent of. Returns: The parent's RigElementKey, or an invalid key if item is at root. Params (pass as input): control_rig, item.animation(epic_get_pin_value)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Get the default value of a pin. Args: control_rig: The Control Rig containing the pin. pin: The pin to query. Returns: The pin's default value as a string. Params (pass as input): control_rig, pin.animation(epic_get_pinned_nodes)- [Epic animation_toolset.toolsets.outliner.SequencerOutlinerTools] Get the currently pinned outliner nodes. Returns: List of pinned nodes. Params: none.animation(epic_get_playback_range)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the playback start and end frames of a sequence. Args: sequence: The LevelSequence to query. Returns: JSON string with 'start' and 'end' integer frame numbers. Params (pass as input): sequence.animation(epic_get_playback_speed)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the current playback speed multiplier. Returns: The current speed multiplier. Params: none.animation(epic_get_playhead_frame)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the current playhead position in display rate frames. Returns: The current playhead frame number. Params: none.animation(epic_get_position)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get a position control value at a specific frame. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the position control. frame: The frame number. Returns: JSON string with 'x', 'y', 'z' fields. Params (pass as input): sequence, control_rig_asset_path, control_name, frame.animation(epic_get_priority_order)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get the evaluation priority order of a Control Rig track. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. Returns: The priority order integer. Params (pass as input): sequence, control_rig_asset_path.animation(epic_get_root_folders)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get all root-level folders in the sequence. Args: sequence: The LevelSequence to query. Returns: List of root MovieSceneFolder objects. Params (pass as input): sequence.animation(epic_get_rotator)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get a rotator control value at a specific frame. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the rotator control. frame: The frame number. Returns: JSON string with 'pitch', 'yaw', 'roll' fields. Params (pass as input): sequence, control_rig_asset_path, control_name, frame.animation(epic_get_scale)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get a scale control value at a specific frame. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the scale control. frame: The frame number. Returns: JSON string with 'x', 'y', 'z' fields. Params (pass as input): sequence, control_rig_asset_path, control_name, frame.animation(epic_get_section_blend_type)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the blend type of a section. Args: section: The section to query. Returns: The blend type name string (e.g. 'Absolute', 'Additive'). Params (pass as input): section.animation(epic_get_section_completion_mode)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the completion mode of a section. Args: section: The section to query. Returns: The completion mode name string. Params (pass as input): section.animation(epic_get_section_condition)- [Epic animation_toolset.toolsets.conditions.SequencerConditionTools] Get the condition on a section. Returns the class path of the condition, or an empty string if no condition is set. Args: section: The section to query. Returns: Class path of the condition, or empty string. Params (pass as input): section.animation(epic_get_section_ease_in)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the effective ease-in duration of a section in frames. Args: section: The section to query. Returns: The ease-in duration in frames. Params (pass as input): section.animation(epic_get_section_ease_out)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the effective ease-out duration of a section in frames. Args: section: The section to query. Returns: The ease-out duration in frames. Params (pass as input): section.animation(epic_get_section_post_roll_frames)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the number of post-roll frames configured on a section. Args: section: The section to query. Returns: The post-roll frame count. Params (pass as input): section.animation(epic_get_section_pre_roll_frames)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the number of pre-roll frames configured on a section. Args: section: The section to query. Returns: The pre-roll frame count. Params (pass as input): section.animation(epic_get_section_properties)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get all common properties of a section in a single call. Useful for testing and verification. Returns range, easing, blend type, and completion mode. Args: section: The section to query. Returns: JSON string with keys: 'start', 'end', 'ease_in', 'ease_out', 'blend_type', 'completion_mode'. Params (pass as input): section.animation(epic_get_section_range)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the frame range of a section. Args: section: The section to query. Returns: JSON string with 'start' and 'end' integer frame numbers. Params (pass as input): section.animation(epic_get_section_to_key)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the active section that receives new keys on a track. When keying properties, Sequencer writes to a specific section. This returns that section, which is usually the first section or the one the user has designated. Args: track: The track to query. Returns: The section that receives new keyframes. Params (pass as input): track.animation(epic_get_sections)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get all sections on a track. Args: track: The track to query. Returns: List of MovieSceneSection objects. Params (pass as input): track.animation(epic_get_sections_for_nodes)- [Epic animation_toolset.toolsets.outliner.SequencerOutlinerTools] Get sections associated with the given outliner nodes. Args: nodes: The outliner nodes to query. Returns: List of MovieSceneSection objects associated with the nodes. Params (pass as input): nodes.animation(epic_get_selected_bindings)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the currently selected bindings in the Sequencer editor. Returns: List of selected SequencerBindingProxy objects. Params: none.animation(epic_get_selected_channels)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Get the currently selected channels in the Sequencer editor. Returns: List of selected SequencerChannelProxy objects. Params: none.animation(epic_get_selected_controls)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get the currently selected controls on a Control Rig. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. Returns: List of selected control names. Params (pass as input): sequence, control_rig_asset_path.animation(epic_get_selected_folders)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the currently selected folders in the Sequencer editor. Returns: List of selected MovieSceneFolder objects. Params: none.animation(epic_get_selected_key_channels)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Get channels that have selected keys in the Curve Editor. Returns: List of SequencerChannelProxy objects with selected keys. Params: none.animation(epic_get_selected_sections)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the currently selected sections in the Sequencer editor. Returns: List of selected MovieSceneSection objects. Params: none.animation(epic_get_selected_tracks)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the currently selected tracks in the Sequencer editor. Returns: List of selected MovieSceneTrack objects. Params: none.animation(epic_get_selection_range)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the selection range (green bar) start and end frames. Returns: JSON string with 'start' and 'end' frame numbers. Params: none.animation(epic_get_sequence_lock_state)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Check whether the current level sequence is locked. Returns: True if the sequence is locked, False otherwise. Params: none.animation(epic_get_soloed_nodes)- [Epic animation_toolset.toolsets.outliner.SequencerOutlinerTools] Get the currently soloed outliner nodes. Returns: List of soloed nodes. Params: none.animation(epic_get_sub_sequence_hierarchy)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the current sub-sequence hierarchy path. Returns a list of sub-sections from the root down to the currently focused sub-sequence. Returns: List of sub-section objects in the hierarchy path. Params: none.animation(epic_get_tick_resolution)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the internal tick resolution of a sequence. Args: sequence: The LevelSequence to query. Returns: The tick FrameRate. Params (pass as input): sequence.animation(epic_get_track_condition)- [Epic animation_toolset.toolsets.conditions.SequencerConditionTools] Get the track-level condition. Args: track: The track to query. Returns: Class path of the condition, or empty string. Params (pass as input): track.animation(epic_get_track_display_name)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the display name of a track. Args: track: The track to query. Returns: The track's display name. Params (pass as input): track.animation(epic_get_track_filter_names)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get all available track filter names. Returns: List of track filter name strings. Params: none.animation(epic_get_track_row_condition)- [Epic animation_toolset.toolsets.conditions.SequencerConditionTools] Get the condition on a specific track row. Args: track: The track to query. row_index: The row index (0-based). Returns: Class path of the condition, or empty string. Params (pass as input): track, row_index.animation(epic_get_tracks_on_binding)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get all tracks on a binding. Args: binding: The binding to query. Returns: List of MovieSceneTrack objects. Params (pass as input): binding.animation(epic_get_tracks_on_sequence)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get all sequence-level (master) tracks. Args: sequence: The LevelSequence to query. Returns: List of MovieSceneTrack objects. Params (pass as input): sequence.animation(epic_get_transform)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get the transform value of a Control Rig control at a frame. Automatically detects whether the control is a Transform or EulerTransform type and uses the appropriate API. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which CR. control_name: The control name (e.g. 'body_ctrl'). frame: The frame number. Returns: JSON string with 'location' and 'rotation' dicts. Params (pass as input): sequence, control_rig_asset_path, control_name, frame.animation(epic_get_variable)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Get a specific variable by name. Args: control_rig: The Control Rig to query. name: Variable name. Returns: The variable description. Params (pass as input): control_rig, name.animation(epic_get_vector2d)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get a Vector2D control value at a specific frame. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the Vector2D control. frame: The frame number. Returns: JSON string with 'x' and 'y' fields. Params (pass as input): sequence, control_rig_asset_path, control_name, frame.animation(epic_get_view_range)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the visible time range in the Sequencer timeline. Args: sequence: The LevelSequence to query. Returns: JSON string with 'start' and 'end' in seconds. Params (pass as input): sequence.animation(epic_get_work_range)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Get the work range of the sequence. Args: sequence: The LevelSequence to query. Returns: JSON string with 'start' and 'end' in seconds. Params (pass as input): sequence.animation(epic_get_world_transform)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Get a control's world-space transform at a specific frame. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the control. frame: The frame number. Returns: JSON string with 'location' (x,y,z) and 'rotation' (pitch,yaw,roll). Params (pass as input): sequence, control_rig_asset_path, control_name, frame.animation(epic_has_section_end_frame)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Check if a section has a bounded end frame (vs infinite). Args: section: The section to query. Returns: True if the end frame is bounded. Params (pass as input): section.animation(epic_has_section_start_frame)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Check if a section has a bounded start frame (vs infinite). Args: section: The section to query. Returns: True if the start frame is bounded. Params (pass as input): section.animation(epic_hide_all_controls)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Hide all controls on a Control Rig section (mask everything). Args: section: The Control Rig parameter section. Params (pass as input): section.animation(epic_import_bones_from_asset)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Import bones from the given skeletal mesh to the Control Rig hierarchy. Args: control_rig: The Control Rig to import bones into. skeletal_mesh: The skeletal mesh to import bones from. Returns: List of RigElementKeys for the imported bones. Params (pass as input): control_rig, skeletal_mesh.animation(epic_import_fbx)- [Epic animation_toolset.toolsets.import_export.SequencerImportExportTools] Import FBX data into a level sequence. Args: world: The world context. sequence: The LevelSequence to import into. bindings: The bindings to apply the import to. import_settings: The FBX import settings. fbx_file_path: The input FBX file path. Returns: True if the import succeeded, False otherwise. Params (pass as input): world, sequence, bindings, import_settings, fbx_file_path.animation(epic_import_fbx_to_rig)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Import an FBX file onto a Control Rig track. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. import_file_path: File system path to the FBX file to import. selected_controls: Optional list of control names to import onto. If provided, only these controls will be affected. Returns: True if the import succeeded. Params (pass as input): sequence, control_rig_asset_path, import_file_path, selected_controls.animation(epic_is_camera_cut_locked)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Check if the camera cut is locked to the viewport. Returns: True if the camera is locked to the viewport. Params: none.animation(epic_is_curve_editor_open)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Check whether the Curve Editor panel is currently open. Returns: True if the Curve Editor is open. Params: none.animation(epic_is_curve_shown)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Check if a curve is visible in the Curve Editor. Args: channel: The channel proxy to check. Returns: True if the curve is displayed. Params (pass as input): channel.animation(epic_is_fk_control_rig)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Check if a Control Rig is an FK Control Rig. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. Returns: True if the rig is an FK Control Rig. Params (pass as input): sequence, control_rig_asset_path.animation(epic_is_layered_control_rig)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Check if a Control Rig in the sequence is in layered mode. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. Returns: True if the rig is in layered mode. Params (pass as input): sequence, control_rig_asset_path.animation(epic_is_node_expanded)- [Epic animation_toolset.toolsets.outliner.SequencerOutlinerTools] Check whether an outliner node is expanded. Args: node: The outliner node to query. Returns: True if expanded, False if collapsed. Params (pass as input): node.animation(epic_is_playback_range_locked)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Check if the playback range is locked. Args: sequence: The LevelSequence to query. Returns: True if the playback range is locked. Params (pass as input): sequence.animation(epic_is_playing)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Check whether the sequence is currently playing. Returns: True if the sequence is playing, False otherwise. Params: none.animation(epic_is_sequence_locked)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Check if the current sequence and its descendants are locked. Returns: True if the sequence is locked. Params: none.animation(epic_is_track_filter_active)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Check whether a track filter is currently active. Args: name: The track filter name. Returns: True if the filter is active. Params (pass as input): name.animation(epic_key_controls)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Key the specified controls on the section at the current Sequencer time. Args: section: The Control Rig parameter section. control_names: List of control names to key. Params (pass as input): section, control_names.animation(epic_key_controls_at_frames)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Key the specified controls at specific frame numbers. Args: section: The Control Rig parameter section. control_names: List of control names to key. frames: List of frame numbers at which to set keys. Params (pass as input): section, control_names, frames.animation(epic_link_anim_sequence)- [Epic animation_toolset.toolsets.import_export.SequencerImportExportTools] Link an AnimSequence asset to a level sequence binding. When the sequence is modified, the linked AnimSequence can be automatically updated. Args: sequence: The LevelSequence to link from. anim_sequence: The AnimSequence to link to. binding: The binding to associate the link with. Returns: True on success. Returns False (via the tool_call decorator) if sequence or anim_sequence is None. Params (pass as input): sequence, anim_sequence, binding.animation(epic_list_graphs)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] List all graphs in the Control Rig. Args: control_rig: The Control Rig to query. Returns: List of RigVMGraph objects (excludes function library). Params (pass as input): control_rig.animation(epic_list_nodes)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] List all nodes in a graph. Args: control_rig: The Control Rig containing the graph. graph: The graph to query. Returns: List of RigVMNode objects in the graph. Params (pass as input): control_rig, graph.animation(epic_list_pins)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] List all pins on a node. Args: control_rig: The Control Rig containing the node. node: The node to query. Returns: List of RigVMPin objects on the node. Params (pass as input): control_rig, node.animation(epic_list_variables)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] List all member variables in the Control Rig. Args: control_rig: The Control Rig to query. Returns: List of variable descriptions. Params (pass as input): control_rig.animation(epic_load_anim_into_rig)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Load an animation sequence into a Control Rig section. Finds the skeletal mesh component from the binding associated with the section's track. Args: cr_section: The Control Rig parameter section to load into. anim_sequence_path: Content path to the AnimSequence asset. start_frame: Frame at which to insert the animation. reset_controls: If True, reset controls to initial value per frame. key_reduce: If True, perform key reduction. tolerance: Key reduction tolerance. Returns: True if the load succeeded. Params (pass as input): cr_section, anim_sequence_path, start_frame?, reset_controls?, key_reduce?, tolerance?.animation(epic_merge_anim_layers)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Merge specified animation layers into one. Merges onto the layer with the lowest index. Args: indices: List of layer indices to merge. Returns: True if the merge succeeded. Params (pass as input): indices.animation(epic_mirror_selected_controls)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Apply a mirrored pose to the currently selected controls. Params: none.animation(epic_move_space)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Move a space-switch key from one frame to another. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the control. old_frame: The current frame of the space key. new_frame: The new frame to move the space key to. Returns: True if the move succeeded. Params (pass as input): sequence, control_rig_asset_path, control_name, old_frame, new_frame.animation(epic_open_curve_editor)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Open the Sequencer Curve Editor panel. Params: none.animation(epic_open_sequence)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Open a level sequence asset in the Sequencer editor. Args: sequence: The LevelSequence asset to open. Params (pass as input): sequence.animation(epic_paste_bindings)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Paste bindings from the clipboard (or a token returned by copy_bindings). Args: paste_token: Token from copy_bindings, or empty string to use the editor clipboard. sequence: Destination sequence (informational; the subsystem pastes into the active sequence). parent_folder: Optional folder to paste into. Returns: List of newly-created bindings. Params (pass as input): paste_token, sequence, parent_folder?.animation(epic_paste_folders)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Paste folders from the clipboard into the sequence. Args: paste_token: Token from copy_folders, or empty string. sequence: Destination sequence. parent_folder: Optional folder to paste into (for nesting). Returns: List of newly-created folders. Params (pass as input): paste_token, sequence, parent_folder?.animation(epic_paste_sections)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Paste sections from the clipboard onto the given tracks. Args: paste_token: Token from copy_sections, or empty string. target_tracks: Tracks to paste the sections onto. paste_frame: Frame at which to start the pasted sections. Returns: List of newly-created sections. Params (pass as input): paste_token, target_tracks, paste_frame?.animation(epic_paste_tracks)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Paste tracks from the clipboard onto the given bindings. Args: paste_token: Token from copy_tracks, or empty string. sequence: Destination sequence. target_bindings: Bindings to paste the tracks onto. Pass an empty list to paste as sequence-level tracks. parent_folder: Optional folder to place the pasted tracks under. Returns: List of newly-created tracks. Params (pass as input): paste_token, sequence, target_bindings, parent_folder?.animation(epic_pause)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Pause playback of the current sequence. Params: none.animation(epic_play)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Start playback of the current sequence. Params: none.animation(epic_play_to)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Play from the current position to a specific frame, then stop. Args: frame: The target frame number in display rate. Params (pass as input): frame.animation(epic_rebind_component)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Rebind component bindings to a named component. Args: component_bindings: List of SequencerBindingProxy for the component bindings to rebind. component_name: Name of the target component. Params (pass as input): component_bindings, component_name.animation(epic_refresh_sequence)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Force refresh the Sequencer editor UI on the next tick. Params: none.animation(epic_remove_actors_from_binding)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Remove specific actors from a binding. Args: actors: List of Actor objects to remove. binding: The binding to remove actors from. Params (pass as input): actors, binding.animation(epic_remove_all_bindings)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Remove all bound actors from a binding. Args: binding: The binding to clear. Params (pass as input): binding.animation(epic_remove_binding)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Remove a binding from the sequence. Args: binding: The binding to remove. Params (pass as input): binding.animation(epic_remove_binding_tag)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Remove a tag from the sequence entirely. Clears the tag from every binding that had it and unregisters the tag name from the sequence. Args: sequence: The LevelSequence. tag_name: The tag name to remove. Returns: True on success. Params (pass as input): sequence, tag_name.animation(epic_remove_invalid_bindings)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Remove missing or broken actor references from a binding. Args: binding: The binding to clean up. Params (pass as input): binding.animation(epic_remove_key_at_frame)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Remove a key at a specific frame from a channel. Args: section: The section containing the channel. channel_name: Name of the channel. frame: The frame number of the key to remove. Returns: True if a key was found and removed, False if no key at that frame. Params (pass as input): section, channel_name, frame.animation(epic_remove_root_folder)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Remove a root-level folder from the sequence. Args: sequence: The LevelSequence to modify. folder: The folder to remove. Params (pass as input): sequence, folder.animation(epic_remove_section)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Remove a section from a track. Args: track: The track that owns the section. section: The section to remove. Params (pass as input): track, section.animation(epic_remove_track)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Remove a track from a binding. Args: binding: The binding that owns the track. track: The track to remove. Params (pass as input): binding, track.animation(epic_remove_track_from_sequence)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Remove a sequence-level (master) track. Args: sequence: The LevelSequence to modify. track: The track to remove. Returns: True if the track was removed. Params (pass as input): sequence, track.animation(epic_remove_variable)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Remove a member variable from the Control Rig. Args: control_rig: The Control Rig to modify. name: Variable name to remove. Params (pass as input): control_rig, name.animation(epic_reorder_anim_layers)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Move an animation layer from one index to another. Cannot move the base layer (index 0). Args: old_index: Current index of the layer to move. new_index: Target index to move the layer to. Returns: True if the reorder succeeded. Params (pass as input): old_index, new_index.animation(epic_replace_binding_with_actors)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Replace all bound actors on a binding with new ones. Args: actors: List of Actor objects to bind. binding: The binding to replace actors on. Params (pass as input): actors, binding.animation(epic_save_default_spawnable_state)- [Epic animation_toolset.toolsets.custom_bindings.SequencerCustomBindingTools] Save the current state of a spawnable as its default. Args: binding: The spawnable binding to save defaults for. Params (pass as input): binding.animation(epic_select_bindings)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the binding selection in the Sequencer editor. Args: bindings: The bindings to select. Params (pass as input): bindings.animation(epic_select_channels)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Set the channel selection in the Sequencer editor. Args: channels: List of SequencerChannelProxy objects to select. Params (pass as input): channels.animation(epic_select_control)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Select or deselect a control on a Control Rig. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the control. selected: True to select, False to deselect. Params (pass as input): sequence, control_rig_asset_path, control_name, selected?.animation(epic_select_folders)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the folder selection in the Sequencer editor. Args: folders: The folders to select. Params (pass as input): folders.animation(epic_select_mirrored_controls)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Select the mirrored counterparts of the currently selected controls. Replaces the current selection with mirrored controls. Params: none.animation(epic_select_sections)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the section selection in the Sequencer editor. Args: sections: The sections to select. Params (pass as input): sections.animation(epic_select_tracks)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the track selection in the Sequencer editor. Args: tracks: The tracks to select. Params (pass as input): tracks.animation(epic_set_anim_mode_gizmo_scale)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Set the editor's transform gizmo size. Writes UTransformGizmoEditorSettings::TransformGizmoSize. The CR-specific gizmo scale was removed in UE 5.8 in favor of this editor-wide setting. Args: scale: Gizmo size offset, clamped to [-10.0, 150.0]. 0.0 is default. Returns: True on success. Params (pass as input): scale.animation(epic_set_anim_mode_hide_manips)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Toggle whether Animation Mode hides all manipulators. Args: hide: True to hide all controls and gizmos. Returns: True on success. Params (pass as input): hide.animation(epic_set_anim_mode_hierarchy)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Toggle the Animation Mode hierarchy lines/dots display. Args: enabled: True to show, False to hide. Returns: True on success. Params (pass as input): enabled.animation(epic_set_anim_mode_local_spaces)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Toggle multi-select transforms acting in each control's own space. When True, transforming multiple selected controls respects each control's own local space. When False, all use a shared reference. Args: enabled: True to enable per-control local space. Returns: True on success. Params (pass as input): enabled.animation(epic_set_anim_mode_nulls)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Toggle the Animation Mode nulls display. Args: enabled: True to show, False to hide. Returns: True on success. Params (pass as input): enabled.animation(epic_set_anim_mode_only_rig_sel)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Toggle Animation Mode restricting viewport selection to rig controls. Args: only_rig: True to only allow selecting rig controls in viewport. Returns: True on success. Params (pass as input): only_rig.animation(epic_set_binding_name)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the display name of a binding. Args: binding: The binding to rename. name: The new display name. Params (pass as input): binding, name.animation(epic_set_bool)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Set a bool control value at a specific frame. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the bool control. frame: The frame number. value: The bool value to set. set_key: If True, set a keyframe at this frame. Params (pass as input): sequence, control_rig_asset_path, control_name, frame, value, set_key?.animation(epic_set_byte_track_enum)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Configure a byte track to use a specific enum type. Byte tracks can animate enum properties. Call this after adding the track and before setting property_name_and_path. Args: track: The byte track to configure. enum_class_path: Path to the enum (e.g. the result of unreal.AnimationMode.static_enum()). Params (pass as input): track, enum_class_path.animation(epic_set_camera_cut_binding)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set which camera a camera cut section uses. Args: section: The camera cut section. camera_binding_id: The binding ID of the camera (from get_bindings). Params (pass as input): section, camera_binding_id.animation(epic_set_camera_lock)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Lock or unlock the camera cut to the viewport. Args: lock: True to lock the camera to the viewport, False to unlock. Params (pass as input): lock.animation(epic_set_clock_source)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the clock source for the sequence. Args: sequence: The LevelSequence to modify. clock_source: Clock source string (e.g. 'TICK', 'PLATFORM', 'AUDIO', 'TIMECODE', 'CUSTOM'). Params (pass as input): sequence, clock_source.animation(epic_set_controls_mask)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Set the visibility mask for the specified controls on a section. Args: section: The Control Rig parameter section. control_names: List of control names to affect. visible: True to show, False to hide. Params (pass as input): section, control_names, visible.animation(epic_set_default_value)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Set the default value of a channel. Args: section: The section containing the channel. channel_name: Name of the channel. value: The default value. Params (pass as input): section, channel_name, value.animation(epic_set_display_rate)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the display frame rate of a sequence. Args: sequence: The LevelSequence to modify. numerator: Frame rate numerator (e.g. 30 for 30fps). denominator: Frame rate denominator (default 1). Params (pass as input): sequence, numerator, denominator?.animation(epic_set_euler_transform)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Set an EulerTransform control value at a specific frame. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the EulerTransform control. frame: The frame number. location_x: X location. location_y: Y location. location_z: Z location. rotation_pitch: Pitch in degrees. rotation_yaw: Yaw in degrees. rotation_roll: Roll in degrees. scale_x: X scale. scale_y: Y scale. scale_z: Z scale. set_key: If True, set a keyframe at this frame. Params (pass as input): sequence, control_rig_asset_path, control_name, frame, location_x?, location_y?, location_z?, rotation_pitch?, rotation_yaw?, rotation_roll?, scale_x?, scale_y?, scale_z?, set_key?.animation(epic_set_evaluation_type)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the evaluation type of a sequence. Args: sequence: The LevelSequence to modify. eval_type: Evaluation type string (e.g. 'WITH_SUB_FRAMES', 'FRAME_LOCKED'). Params (pass as input): sequence, eval_type.animation(epic_set_float)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Set a float control value at a specific frame. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the float control. frame: The frame number. value: The float value to set. set_key: If True, set a keyframe at this frame. Params (pass as input): sequence, control_rig_asset_path, control_name, frame, value, set_key?.animation(epic_set_global_transform)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Set global transform of a hierarchy element. Args: control_rig: The Control Rig to modify. item: The element to set the transform for. transform: The new global transform. initial: If True, sets the initial (setup) transform. Params (pass as input): control_rig, item, transform, initial?.animation(epic_set_int)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Set an integer control value at a specific frame. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the integer control. frame: The frame number. value: The integer value to set. set_key: If True, set a keyframe at this frame. Params (pass as input): sequence, control_rig_asset_path, control_name, frame, value, set_key?.animation(epic_set_layered_mode)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Set a Control Rig track to layered or absolute mode. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. is_layered: True for layered, False for absolute. Returns: True if the mode was set successfully. Params (pass as input): sequence, control_rig_asset_path, is_layered.animation(epic_set_local_transform)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Set local transform of a hierarchy element. Args: control_rig: The Control Rig to modify. item: The element to set the transform for. transform: The new local transform. initial: If True, sets the initial (setup) transform. Params (pass as input): control_rig, item, transform, initial?.animation(epic_set_loop_mode)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Enable or disable loop playback. Args: loop: True to enable looping, False to disable. Params (pass as input): loop.animation(epic_set_node_deactivated)- [Epic animation_toolset.toolsets.outliner.SequencerOutlinerTools] Deactivate or reactivate outliner nodes. Args: nodes: List of outliner nodes to modify. deactivated: True to deactivate, False to reactivate. Params (pass as input): nodes, deactivated.animation(epic_set_node_expanded)- [Epic animation_toolset.toolsets.outliner.SequencerOutlinerTools] Expand or collapse outliner nodes. Args: nodes: The nodes to expand or collapse. expanded: True to expand, False to collapse. Params (pass as input): nodes, expanded.animation(epic_set_node_locked)- [Epic animation_toolset.toolsets.outliner.SequencerOutlinerTools] Lock or unlock outliner nodes for editing. Args: nodes: List of outliner nodes to modify. locked: True to lock, False to unlock. Params (pass as input): nodes, locked.animation(epic_set_node_muted)- [Epic animation_toolset.toolsets.outliner.SequencerOutlinerTools] Mute or unmute outliner nodes. Args: nodes: The nodes to mute or unmute. muted: True to mute, False to unmute. Params (pass as input): nodes, muted.animation(epic_set_node_pinned)- [Epic animation_toolset.toolsets.outliner.SequencerOutlinerTools] Pin or unpin outliner nodes. Args: nodes: List of outliner nodes to modify. pinned: True to pin, False to unpin. Params (pass as input): nodes, pinned.animation(epic_set_node_position)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Set the position of a node in the graph editor. Args: control_rig: The Control Rig containing the graph. graph: The graph containing the node. node: The node to move. position: The new position. Params (pass as input): control_rig, graph, node, position.animation(epic_set_node_solo)- [Epic animation_toolset.toolsets.outliner.SequencerOutlinerTools] Solo or unsolo outliner nodes. Args: nodes: The nodes to solo or unsolo. soloed: True to solo, False to unsolo. Params (pass as input): nodes, soloed.animation(epic_set_outliner_selection)- [Epic animation_toolset.toolsets.outliner.SequencerOutlinerTools] Set the outliner selection. Args: nodes: The nodes to select. Params (pass as input): nodes.animation(epic_set_pin_value)- [Epic animation_toolset.toolsets.controlrig.ControlRigTools] Set the default value of a pin. Args: control_rig: The Control Rig containing the graph. graph: The graph containing the pin's node. pin: The pin to modify. value: The new value as a string. Format depends on pin type: - float/double: "1.0" - int: "42" - bool: "true" or "false" - Vector: "(X=1.0,Y=2.0,Z=3.0)" - Rotator: "(Pitch=0.0,Yaw=90.0,Roll=0.0)" - Transform: "(Rotation=(X=0,Y=0,Z=0,W=1),Translation=(X=0,Y=0,Z=0),Scale3D=(X=1,Y=1,Z=1))" - Name/String: "MyValue" - Enum: "EnumValue" (without type prefix) Params (pass as input): control_rig, graph, pin, value.animation(epic_set_playback_range)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the playback start and end frames of a sequence. Args: sequence: The LevelSequence to modify. start_frame: The start frame. end_frame: The end frame. Params (pass as input): sequence, start_frame, end_frame.animation(epic_set_playback_range_locked)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Lock or unlock the playback range. Args: sequence: The LevelSequence to modify. locked: True to lock, False to unlock. Params (pass as input): sequence, locked.animation(epic_set_playback_speed)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the playback speed multiplier. Args: speed: The speed multiplier (e.g. 1.0 for normal, 2.0 for double). Params (pass as input): speed.animation(epic_set_playhead_frame)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the playhead position in display rate frames. Args: frame: The frame number to move the playhead to. Params (pass as input): frame.animation(epic_set_position)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Set a position control value at a specific frame. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the position control. frame: The frame number. x: X component. y: Y component. z: Z component. set_key: If True, set a keyframe at this frame. Params (pass as input): sequence, control_rig_asset_path, control_name, frame, x?, y?, z?, set_key?.animation(epic_set_priority_order)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Set the evaluation priority order of a Control Rig track. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. order: The priority order value to set. Params (pass as input): sequence, control_rig_asset_path, order.animation(epic_set_property_name_and_path)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Configure a property track to animate a specific UProperty. This binds a generic property track (Float, Bool, Byte, etc.) to a specific property on the bound object. For nested properties use dot notation in the path. Examples: display_name="Intensity", property_path="Intensity" display_name="Focus Distance", property_path="FocusSettings.ManualFocusDistance" display_name="Animation Mode", property_path="AnimationMode" Args: track: The property track to configure. display_name: Human-readable name shown in Sequencer UI. property_path: The UProperty path on the bound object. Params (pass as input): track, display_name, property_path.animation(epic_set_rotator)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Set a rotator control value at a specific frame. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the rotator control. frame: The frame number. pitch: Pitch in degrees. yaw: Yaw in degrees. roll: Roll in degrees. set_key: If True, set a keyframe at this frame. Params (pass as input): sequence, control_rig_asset_path, control_name, frame, pitch?, yaw?, roll?, set_key?.animation(epic_set_scale)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Set a scale control value at a specific frame. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the scale control. frame: The frame number. x: X scale. y: Y scale. z: Z scale. set_key: If True, set a keyframe at this frame. Params (pass as input): sequence, control_rig_asset_path, control_name, frame, x?, y?, z?, set_key?.animation(epic_set_section_animation)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the animation asset on a skeletal animation section. After adding a MovieSceneSkeletalAnimationTrack and section, call this to assign which AnimSequence plays in that section. Args: section: The skeletal animation section. anim_sequence_path: Content path to the AnimSequence asset. Params (pass as input): section, anim_sequence_path.animation(epic_set_section_blend_type)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the blend type of a section. Valid values: 'Absolute', 'Additive', 'Relative', 'Override'. Args: section: The section to modify. blend_type: The blend type name string. Params (pass as input): section, blend_type.animation(epic_set_section_completion_mode)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the completion mode of a section. Valid values: 'KeepState', 'RestoreState', 'ProjectDefault'. Args: section: The section to modify. completion_mode: The completion mode name string. Params (pass as input): section, completion_mode.animation(epic_set_section_condition)- [Epic animation_toolset.toolsets.conditions.SequencerConditionTools] Set a condition on a section. Common condition classes: - /Script/MovieSceneTracks.MovieScenePlatformCondition - /Script/MovieSceneTracks.MovieSceneDirectorBlueprintCondition - /Script/MovieScene.MovieSceneGroupCondition Args: section: The section to modify. condition_class: Full class path of the condition type. Params (pass as input): section, condition_class.animation(epic_set_section_ease_in)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the ease-in duration of a section in frames. Enables manual ease override if not already active. Args: section: The section to modify. duration: The ease-in duration in frames. Params (pass as input): section, duration.animation(epic_set_section_ease_out)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the ease-out duration of a section in frames. Enables manual ease override if not already active. Args: section: The section to modify. duration: The ease-out duration in frames. Params (pass as input): section, duration.animation(epic_set_section_end_bounded)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set whether the section end frame is bounded or infinite. Args: section: The section to modify. bounded: True for bounded, False for infinite. Params (pass as input): section, bounded.animation(epic_set_section_post_roll_frames)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the number of frames to post-roll this section after it ends. Post-roll continues evaluation after the section's real end, useful for simulations that need to settle. Args: section: The section to configure. frames: Number of frames to post-roll (must be >= 0). Returns: True when set successfully. Params (pass as input): section, frames.animation(epic_set_section_pre_roll_frames)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the number of frames to pre-roll this section before it starts. Pre-roll evaluates the section before its real start so physics, cloth, or simulation state can warm up. The pre-roll frames do not affect the rendered output of the section. Args: section: The section to configure. frames: Number of frames to pre-roll (must be >= 0). Returns: True when set successfully. Params (pass as input): section, frames.animation(epic_set_section_range)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the frame range of a section. Args: section: The section to modify. start_frame: The start frame. end_frame: The end frame. Params (pass as input): section, start_frame, end_frame.animation(epic_set_section_start_bounded)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set whether the section start frame is bounded or infinite. Args: section: The section to modify. bounded: True for bounded, False for infinite. Params (pass as input): section, bounded.animation(epic_set_selection_range)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the selection range (green bar) start and end frames. Args: start_frame: The start frame number. end_frame: The end frame number. Params (pass as input): start_frame, end_frame.animation(epic_set_sequence_locked)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Lock or unlock the current sequence and its descendants. Args: lock: True to lock, False to unlock. Params (pass as input): lock.animation(epic_set_space)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Set the space for a Control Rig control at a given frame. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the control. space_type: One of 'world', 'default_parent', 'control', or 'bone'. For 'control' or 'bone', space_target must name the element. frame: Frame at which to set the space switch key. space_target: For 'control' or 'bone' types, the name of the target element. Ignored for 'world' and 'default_parent'. Returns: True if the space key was set successfully. Params (pass as input): sequence, control_rig_asset_path, control_name, space_type, frame, space_target.animation(epic_set_tick_resolution)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the internal tick resolution of a sequence. Args: sequence: The LevelSequence to modify. numerator: Numerator of the frame rate. denominator: Denominator of the frame rate. Params (pass as input): sequence, numerator, denominator?.animation(epic_set_track_condition)- [Epic animation_toolset.toolsets.conditions.SequencerConditionTools] Set a condition on a track. Args: track: The track to modify. condition_class: Full class path of the condition type. Params (pass as input): track, condition_class.animation(epic_set_track_display_name)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the display name of a track. Args: track: The track to rename. name: The new display name. Params (pass as input): track, name.animation(epic_set_track_filter_active)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Enable or disable a track filter. Args: name: The track filter name. active: True to enable, False to disable. Params (pass as input): name, active.animation(epic_set_track_row_condition)- [Epic animation_toolset.toolsets.conditions.SequencerConditionTools] Set a condition on a specific track row. Args: track: The track to modify. row_index: The row index (0-based). condition_class: Full class path of the condition type. Params (pass as input): track, row_index, condition_class.animation(epic_set_transform)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Set a transform value on a Control Rig control and optionally key it. Uses ControlRigSequencerLibrary.set_local_control_rig_transform. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which CR (used to find the rig). control_name: The control name (e.g. 'body_ctrl'). frame: The frame number. location_x: X location. location_y: Y location. location_z: Z location. rotation_pitch: Pitch rotation in degrees. rotation_yaw: Yaw rotation in degrees. rotation_roll: Roll rotation in degrees. set_key: If True, set a keyframe at this frame. Params (pass as input): sequence, control_rig_asset_path, control_name, frame, location_x?, location_y?, location_z?, rotation_pitch?, rotation_yaw?, rotation_roll?, set_key?.animation(epic_set_vector2d)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Set a Vector2D control value at a specific frame. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the Vector2D control. frame: The frame number. x: X component. y: Y component. set_key: If True, set a keyframe at this frame. Params (pass as input): sequence, control_rig_asset_path, control_name, frame, x?, y?, set_key?.animation(epic_set_view_range)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the visible time range in the Sequencer timeline. Args: sequence: The LevelSequence to modify. start_seconds: The visible range start in seconds. end_seconds: The visible range end in seconds. Params (pass as input): sequence, start_seconds, end_seconds.animation(epic_set_work_range)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Set the work range of the sequence. Args: sequence: The LevelSequence to modify. start_seconds: The work range start in seconds. end_seconds: The work range end in seconds. Params (pass as input): sequence, start_seconds, end_seconds.animation(epic_set_world_transform)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Set a control's world-space transform at a specific frame. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_name: Name of the control. frame: The frame number. location_x: World X location. location_y: World Y location. location_z: World Z location. rotation_pitch: Pitch in degrees. rotation_yaw: Yaw in degrees. rotation_roll: Roll in degrees. set_key: If True, set a keyframe at this frame. Params (pass as input): sequence, control_rig_asset_path, control_name, frame, location_x?, location_y?, location_z?, rotation_pitch?, rotation_yaw?, rotation_roll?, set_key?.animation(epic_show_all_controls)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Show all controls on a Control Rig section (unmask everything). Args: section: The Control Rig parameter section. Params (pass as input): section.animation(epic_show_curve)- [Epic animation_toolset.toolsets.keyframing.SequencerKeyframingTools] Show or hide a curve in the Curve Editor. Args: channel: The channel proxy for the curve. show: True to show, False to hide. Params (pass as input): channel, show.animation(epic_snap_control_rig)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Snap Control Rig controls to a target actor over a frame range. Args: sequence: The LevelSequence. control_rig_asset_path: Path to identify which Control Rig. control_names: Names of controls to snap. target_actor_name: Name or label of the target actor in the level. start_frame: Start frame of the snap range. end_frame: End frame of the snap range. keep_offset: If True, maintain the initial offset. snap_position: If True, snap position. snap_rotation: If True, snap rotation. snap_scale: If True, snap scale. Returns: True if the snap succeeded. Params (pass as input): sequence, control_rig_asset_path, control_names, target_actor_name, start_frame, end_frame, keep_offset?, snap_position?, snap_rotation?, snap_scale?.animation(epic_tag_binding)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Attach a tag to a binding. If the tag has not been seen in the sequence before, it is automatically registered. Args: binding: The binding to tag. tag_name: The tag name. Returns: True on success. Params (pass as input): binding, tag_name.animation(epic_tween_control_rig)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Perform a tween operation on a Control Rig at the current Sequencer time. The tween blends between the previous and next keyframe values. Args: sequence: The LevelSequence (must be open in Sequencer). control_rig_asset_path: Path to identify which Control Rig. tween_value: Blend value from -1.0 (previous key) to 1.0 (next key). Returns: True if tween succeeded. Params (pass as input): sequence, control_rig_asset_path, tween_value.animation(epic_untag_binding)- [Epic animation_toolset.toolsets.sequencer.SequencerTools] Remove a tag from a binding. Args: binding: The binding to untag. tag_name: The tag name to remove. Returns: True on success. No-op if the binding did not have the tag. Params (pass as input): binding, tag_name.animation(epic_zero_transforms)- [Epic animation_toolset.toolsets.controlrig_sequencer.SequencerControlRigTools] Reset Control Rig transforms to their default (usually zero) values. Args: selection_only: If True, only reset controls on rigs with selected controls. If False, reset all. include_channels: If True, include channels in addition to parent controls. Params (pass as input): selection_only?, include_channels?.
gameplay
Wraps 6 official tools.
gameplay(epic_add_tag)- [Epic GameplayTagsToolset.GameplayTagsToolset] Adds a new gameplay tag to the project. This should ONLY be called after getting explicit direction or permission from the user. Params (pass as input): tagName, comment?, tagSource.gameplay(epic_find_referencers_by_tag)- [Epic GameplayTagsToolset.GameplayTagsToolset] Returns assets that reference a gameplay tag. Params (pass as input): tagName.gameplay(epic_get_tag_info)- [Epic GameplayTagsToolset.GameplayTagsToolset] Returns detailed information about a specific gameplay tag. Params (pass as input): tagName.gameplay(epic_list_tags)- [Epic GameplayTagsToolset.GameplayTagsToolset] Returns gameplay tags registered in the project. Params (pass as input): parentTag.gameplay(epic_remove_tag)- [Epic GameplayTagsToolset.GameplayTagsToolset] Removes a gameplay tag from the project. This should ONLY be called after getting explicit direction or permission from the user. Params (pass as input): tagName.gameplay(epic_rename_tag)- [Epic GameplayTagsToolset.GameplayTagsToolset] Renames a gameplay tag, updating all references in the project. This should ONLY be called after getting explicit direction or permission from the user. Params (pass as input): oldTagName, newTagName.
material
Wraps 35 official tools.
material(epic_add_expression)- [Epic editor_toolset.toolsets.material.MaterialTools] Adds a new expression node to a Material or MaterialFunction graph. Use list_expression_classes to discover available types. Args: material_or_function: The Material or MaterialFunction to add the expression to. expression_class: The type of expression node to create. x: Horizontal position in the graph editor. y: Vertical position in the graph editor. Returns: The newly created MaterialExpression node. Params (pass as input): material_or_function, expression_class, x?, y?.material(epic_clear_parameters)- [Epic editor_toolset.toolsets.material_instance.MaterialInstanceTools] Clears all parameter overrides on a material instance, reverting to parent defaults. Args: instance: The MaterialInstanceConstant to clear. Params (pass as input): instance.material(epic_connect_expressions)- [Epic editor_toolset.toolsets.material.MaterialTools] Connects an expression node's output pin to another expression node's input pin. Args: from_expression: The expression providing the output value. from_output_name: The output pin name. Pass an empty string to use the default (first) output. to_expression: The expression receiving the input. to_input_name: The input pin name to connect to. Use get_expression_input_names to discover valid names. Params (pass as input): from_expression, from_output_name, to_expression, to_input_name.material(epic_connect_to_output)- [Epic editor_toolset.toolsets.material.MaterialTools] Connects an expression node's output to one of the material's output properties. Args: expression: The expression whose output will drive the property. output_name: The output pin name. Pass an empty string to use the default (first) output. material_property: The material output property to connect to. Params (pass as input): expression, output_name, material_property.material(epic_create)- [Epic editor_toolset.toolsets.material_instance.MaterialInstanceTools] Creates a new MaterialInstanceConstant asset derived from a parent material. Material instances expose the parent's parameters without triggering a full shader recompile when parameter values change. Args: folder_path: The content-browser path to the folder for the new asset. asset_name: The name of the new asset. parent: The parent Material or MaterialInstance to derive from. Returns: The newly created MaterialInstanceConstant. Params (pass as input): folder_path, asset_name, parent.material(epic_create_function)- [Epic editor_toolset.toolsets.material.MaterialTools] Creates a new empty MaterialFunction asset. Args: folder_path: The content-browser path to the folder for the new asset. asset_name: The name of the new asset. Returns: The newly created MaterialFunction. Params (pass as input): folder_path, asset_name.material(epic_create_material)- [Epic editor_toolset.toolsets.material.MaterialTools] Creates a new empty Material asset. Warning: Each new Material increases shader compile times. Prefer creating a MaterialInstance from an existing Material where possible. Args: folder_path: The content-browser path to the folder for the new asset. asset_name: The name of the new asset. Returns: The newly created Material. Params (pass as input): folder_path, asset_name.material(epic_create_parameter_collection)- [Epic editor_toolset.toolsets.material.MaterialTools] Creates a new empty MaterialParameterCollection (MPC) asset. An MPC holds named Scalar and Vector parameters with default values that materials can reference at runtime without recompiling shaders. Args: folder_path: The content-browser path to the folder for the new asset. asset_name: The name of the new asset. Returns: The newly created MaterialParameterCollection. Params (pass as input): folder_path, asset_name.material(epic_delete_expression)- [Epic editor_toolset.toolsets.material.MaterialTools] Removes an expression node from a Material or MaterialFunction graph. Args: material_or_function: The Material or MaterialFunction that owns the expression. expression: The expression node to remove. Params (pass as input): material_or_function, expression.material(epic_delete_parameter_group)- [Epic editor_toolset.toolsets.material.MaterialTools] Removes a parameter group, ungrouping all parameters that belong to it. The parameter expressions themselves are not deleted - only their group assignment is cleared. Note: triggers an internal recompile; no separate call to recompile/update is needed. Args: material_or_function: The Material or MaterialFunction to modify. group_name: The name of the group to delete. Params (pass as input): material_or_function, group_name.material(epic_delete_unused_expressions)- [Epic editor_toolset.toolsets.material.MaterialTools] Deletes all expression nodes not connected to any material output. Useful for cleaning up a material graph after reorganising or after the AI has added experimental nodes that were later abandoned. Note: triggers no recompile - call recompile() afterwards if needed. Args: material: The Material to clean up. Params (pass as input): material.material(epic_disconnect_expressions)- [Epic editor_toolset.toolsets.material.MaterialTools] Disconnects the input pin of an expression node, removing whatever is connected to it. Args: to_expression: The expression whose input pin should be disconnected. to_input_name: The input pin name to disconnect. Use get_expression_input_names to discover valid names. Pass an empty string to disconnect the first input. Params (pass as input): to_expression, to_input_name.material(epic_disconnect_from_output)- [Epic editor_toolset.toolsets.material.MaterialTools] Disconnects the expression currently connected to a material output property. Args: material: The Material to modify. material_property: The material output property to disconnect. Params (pass as input): material, material_property.material(epic_get_expression_input_names)- [Epic editor_toolset.toolsets.material.MaterialTools] Returns the names of all input pins on a material expression node. Use these names as to_input_name when calling connect_expressions. Args: expression: The expression node to query. Returns: The input pin names available on the expression. Params (pass as input): expression.material(epic_get_expression_inputs)- [Epic editor_toolset.toolsets.material.MaterialTools] Returns the current wiring of each input pin on a material expression. Use after building or modifying a graph to verify the wiring matches expectations. Args: material_or_function: The Material or MaterialFunction that owns the expression. expression: The expression whose input wiring to read. Returns: One entry per input pin, in declaration order matching get_expression_input_names. The expression field is None for unwired pins. Params (pass as input): material_or_function, expression.material(epic_get_expression_output_names)- [Epic editor_toolset.toolsets.material.MaterialTools] Returns the names of all output pins on a material expression node. Use these names as from_output_name when calling connect_expressions or connect_to_output. The empty string represents the default (first) output of nodes that expose only an unnamed output. Args: expression: The expression node to query. Returns: The output pin names available on the expression. Params (pass as input): expression.material(epic_get_expressions)- [Epic editor_toolset.toolsets.material.MaterialTools] Returns all expression nodes in a Material or MaterialFunction graph. Args: material_or_function: The Material or MaterialFunction to query. Returns: All MaterialExpression nodes in the graph. Params (pass as input): material_or_function.material(epic_get_property_input)- [Epic editor_toolset.toolsets.material.MaterialTools] Returns the expression and output pin feeding a material output property. Use to inspect what drives MP_EmissiveColor, MP_Opacity, MP_BaseColor, etc. Args: material: The Material to query. material_property: The material output property. Returns: A MaterialInputSource with input_name empty. Its expression field is None when the output property is disconnected. Params (pass as input): material, material_property.material(epic_get_referencing_materials)- [Epic editor_toolset.toolsets.material.MaterialTools] Returns asset data for all Materials that reference this MaterialFunction. Args: material_function: The MaterialFunction to query. Returns: Asset data for each Material that uses this function. Params (pass as input): material_function.material(epic_get_scalar_parameter)- [Epic editor_toolset.toolsets.material_instance.MaterialInstanceTools] Gets the current value of a scalar parameter on a material instance. Args: instance: The MaterialInstanceConstant to query. name: The parameter name. Returns: The effective scalar (float) value, inheriting from the parent if not overridden. Params (pass as input): instance, name.material(epic_get_static_switch_parameter)- [Epic editor_toolset.toolsets.material_instance.MaterialInstanceTools] Gets the value of a static switch parameter on a material instance. Note: Overriding static switch parameters triggers a shader recompile. Args: instance: The MaterialInstanceConstant to query. name: The parameter name. Returns: The effective boolean value, inheriting from the parent if not overridden. Params (pass as input): instance, name.material(epic_get_texture_parameter)- [Epic editor_toolset.toolsets.material_instance.MaterialInstanceTools] Gets the texture assigned to a texture parameter on a material instance. Args: instance: The MaterialInstanceConstant to query. name: The parameter name. Returns: The assigned Texture, or None if the parameter is not overridden on this instance. Params (pass as input): instance, name.material(epic_get_vector_parameter)- [Epic editor_toolset.toolsets.material_instance.MaterialInstanceTools] Gets the current value of a vector parameter on a material instance. Args: instance: The MaterialInstanceConstant to query. name: The parameter name. Returns: The effective value as a LinearColor (RGBA), inheriting from the parent if not overridden. Params (pass as input): instance, name.material(epic_layout_expressions)- [Epic editor_toolset.toolsets.material.MaterialTools] Automatically arranges all expression nodes in a Material or MaterialFunction graph. Args: material_or_function: The Material or MaterialFunction whose graph should be tidied. Params (pass as input): material_or_function.material(epic_list_expression_classes)- [Epic editor_toolset.toolsets.material.MaterialTools] Returns MaterialExpression subclasses valid for the given context. Use the results with add_expression. Pass a search string to filter by name, e.g. 'Multiply' or 'Parameter'. Args: material_or_function: The Material or MaterialFunction to filter by context. search: Optional case-insensitive substring filter on the class path. Returns: Matching MaterialExpression subclass paths. Params (pass as input): material_or_function, search.material(epic_list_parameter_groups)- [Epic editor_toolset.toolsets.material.MaterialTools] Returns the unique parameter group names defined in a Material or MaterialFunction. Parameters are organised into groups in the Material Instance editor. This returns the distinct set of group names found across all parameter expressions in the graph. The empty string represents parameters that have not been assigned to a named group. Args: material_or_function: The Material or MaterialFunction to query. Returns: A sorted list of unique group names. Params (pass as input): material_or_function.material(epic_list_parameters)- [Epic editor_toolset.toolsets.material_instance.MaterialInstanceTools] Returns all parameters exposed by a material or instance, with their names and types. Args: material: The Material or MaterialInstance to query. Returns: A list of MaterialParameter entries, each with a name and a type. Params (pass as input): material.material(epic_recompile)- [Epic editor_toolset.toolsets.material.MaterialTools] Recompiles a Material or MaterialFunction after edits. For Materials, raises if the shader fails to compile. For MaterialFunctions, also recompiles any Materials that reference the function. Call this once after a set of graph modifications is complete - after adding or deleting expressions, making connections, or changing expression properties such as parameter names or default values. Args: material_or_function: The Material or MaterialFunction to recompile. Params (pass as input): material_or_function.material(epic_rename_parameter_group)- [Epic editor_toolset.toolsets.material.MaterialTools] Renames a parameter group across all parameter expressions in a Material or MaterialFunction. All parameters currently in old_name will be moved to new_name. If new_name already exists, the parameters are merged into it. Note: triggers an internal recompile; no separate call to recompile/update is needed. Args: material_or_function: The Material or MaterialFunction to modify. old_name: The current name of the group to rename. new_name: The new name for the group. Params (pass as input): material_or_function, old_name, new_name.material(epic_set_parameter_override)- [Epic editor_toolset.toolsets.material_instance.MaterialInstanceTools] Enables or disables a parameter override on a material instance. Enabling sets the override to the current effective value. Disabling reverts to the parent. For non-static parameter types, disabling also discards the prior override value; re-enabling later restores the parent value, not the prior override. Static switches and static component masks preserve their value across toggle. Args: instance: The MaterialInstanceConstant to modify. name: The parameter name. override: True to enable the override, False to clear it. Params (pass as input): instance, name, override.material(epic_set_parent)- [Epic editor_toolset.toolsets.material_instance.MaterialInstanceTools] Changes the parent of a material instance. Args: instance: The MaterialInstanceConstant to modify. parent: The new parent Material or MaterialInstance. Params (pass as input): instance, parent.material(epic_set_scalar_parameter)- [Epic editor_toolset.toolsets.material_instance.MaterialInstanceTools] Sets the value of a scalar parameter on a material instance. Args: instance: The MaterialInstanceConstant to modify. name: The parameter name. value: The new scalar (float) value. Params (pass as input): instance, name, value.material(epic_set_static_switch_parameter)- [Epic editor_toolset.toolsets.material_instance.MaterialInstanceTools] Sets the value of a static switch parameter on a material instance. Args: instance: The MaterialInstanceConstant to modify. name: The parameter name. value: The new boolean value. Params (pass as input): instance, name, value.material(epic_set_texture_parameter)- [Epic editor_toolset.toolsets.material_instance.MaterialInstanceTools] Assigns a texture to a texture parameter on a material instance. Args: instance: The MaterialInstanceConstant to modify. name: The parameter name. value: The Texture asset to assign. Params (pass as input): instance, name, value.material(epic_set_vector_parameter)- [Epic editor_toolset.toolsets.material_instance.MaterialInstanceTools] Sets the value of a vector parameter on a material instance. Args: instance: The MaterialInstanceConstant to modify. name: The parameter name. value: The new value as a LinearColor (RGBA). Use values in the range 0–1 for standard colors; values above 1 are valid for HDR and emissive. Params (pass as input): instance, name, value.
level
Wraps 17 official tools.
level(epic_add_component)- [Epic editor_toolset.toolsets.actor.ActorTools] Adds a component to an actor instance or blueprint. Args: owner: The actor blueprint, instance, or SceneComponent to add to. component_type: The type of component to add. name: The name of the new component. Returns: The newly added actor component. Params (pass as input): owner, component_type, name.level(epic_add_tag)- [Epic editor_toolset.toolsets.actor.ActorTools] Adds a tag to an actor. Args: actor: The actor to modify. tag: The tag to add. Params (pass as input): actor, tag.level(epic_get_actor_bounds)- [Epic editor_toolset.toolsets.actor.ActorTools] Returns the bounding box of an actor. Args: actor: The actor to query. Returns: The world space bounding box for the actor. Params (pass as input): actor.level(epic_get_actor_transform)- [Epic editor_toolset.toolsets.actor.ActorTools] Returns the position, rotation, and scale of an actor. Args: actor: The actor to query. Returns: The world space actor transform. Params (pass as input): actor.level(epic_get_component_actor)- [Epic editor_toolset.toolsets.actor.ActorTools] Returns the actor that owns the specified component. Args: component: The component to query. Returns: The actor that owns this component. Params (pass as input): component.level(epic_get_components)- [Epic editor_toolset.toolsets.actor.ActorTools] Returns the components that an actor contains. Args: actor: The actor to query. component_type: If set, will only return components of this type. Returns: The components in the actor. Params (pass as input): actor, component_type?.level(epic_get_label)- [Epic editor_toolset.toolsets.actor.ActorTools] Returns the actor's human friendly name as it appears in the editor. Args: actor: The actor to query. Returns: The label for the actor. Params (pass as input): actor.level(epic_get_parent_component)- [Epic editor_toolset.toolsets.actor.ActorTools] Returns the parent component that this component is attached to, if any. Args: component: The scene component to query. Returns: The parent SceneComponent if attached to one, otherwise None. Params (pass as input): component.level(epic_get_root_component)- [Epic editor_toolset.toolsets.actor.ActorTools] Returns the root component of an actor, if any. Args: actor: The actor to query. Returns: The actor's root SceneComponent, or None if it has no root component. Params (pass as input): actor.level(epic_get_tags)- [Epic editor_toolset.toolsets.actor.ActorTools] Returns the list of tags on an actor. Args: actor: The actor to query. Returns: The tags on the actor as strings. Params (pass as input): actor.level(epic_has_tag)- [Epic editor_toolset.toolsets.actor.ActorTools] Returns whether an actor has a specific tag. Args: actor: The actor to query. tag: The tag to check for. Returns: True if the actor has the tag, False otherwise. Params (pass as input): actor, tag.level(epic_look_at)- [Epic editor_toolset.toolsets.actor.ActorTools] Rotates an actor so its forward vector points at a world-space position. Args: actor: The actor to rotate. target: The world-space position to face. Params (pass as input): actor, target.level(epic_remove_component)- [Epic editor_toolset.toolsets.actor.ActorTools] Removes a component from an actor instance or blueprint. Args: component: The component to remove. Returns: True if the component was successfully removed. Params (pass as input): component.level(epic_remove_tag)- [Epic editor_toolset.toolsets.actor.ActorTools] Removes a tag from an actor. Args: actor: The actor to modify. tag: The tag to remove. Params (pass as input): actor, tag.level(epic_set_actor_transform)- [Epic editor_toolset.toolsets.actor.ActorTools] Updates the position, rotation, and/or scale of an actor. Args: actor: The actor to modify. xform: The new transform to apply to this actor. worldspace: True means xform is in worldpace. False means relative to parent. Has no effect on actors in blueprints, which only have a default relative transform. Returns: True if an id matching the actor was found and it's position was set. Params (pass as input): actor, xform, worldspace?.level(epic_set_label)- [Epic editor_toolset.toolsets.actor.ActorTools] Sets the human-friendly name of the actor. Args: actor: The actor to modify. label: The new name for the actor. Returns: True if the label was updated correctly. Params (pass as input): actor, label.level(epic_set_parent_component)- [Epic editor_toolset.toolsets.actor.ActorTools] Sets the parent for the specified scene component. For blueprint actors, passing a component as the parent of the root promotes it to the scene root, making the current root a child of it. If the current root is a DefaultSceneRoot, Unreal will automatically remove it. Args: component: The scene component to modify. parent: The new parent component. None will detach the component from its current parent. Returns: True if the reparent succeeded. Params (pass as input): component, parent?.
asset
Wraps 55 official tools.
asset(epic_add_body)- [Epic PhysicsToolsets.PhysicsAssetToolset] Adds a new empty body for the given bone. Params (pass as input): physicsAsset, boneName.asset(epic_add_constraint)- [Epic PhysicsToolsets.PhysicsAssetToolset] Adds a new constraint between two bodies. Both bodies must already exist. Params (pass as input): physicsAsset, bone1Name, bone2Name.asset(epic_add_key)- [Epic editor_toolset.toolsets.curve_table.CurveTableTools] Adds a key to a row. Args: curve_table: The CurveTable to modify. row_name: The name of the row to modify. key: The key to add, containing the time and value. Returns: True if the key was added successfully. Params (pass as input): curve_table, row_name, key.asset(epic_add_row)- [Epic editor_toolset.toolsets.curve_table.CurveTableTools] Adds a new row to the curve table with an optional default value. Args: curve_table: The CurveTable to modify. row_name: The name for the new row. default_value: The default value returned when sampling outside the key range. Params (pass as input): curve_table, row_name, default_value?.asset(epic_can_edit_asset)- [Epic editor_toolset.toolsets.asset.AssetTools] Checks whether an asset can be edited. Args: asset_path: Content path to the asset. Returns: True if the asset can be edited, False if it is checked out or locked by another user in source control. Always True when source control is not enabled. Params (pass as input): asset_path.asset(epic_create)- [Epic editor_toolset.toolsets.curve_table.CurveTableTools] Creates a new CurveTable asset. Args: folder_path: The path to the folder that will contain the asset. asset_name: The name of the asset. Returns: The created CurveTable. Params (pass as input): folder_path, asset_name.asset(epic_create__data_asset_tools)- [Epic editor_toolset.toolsets.data_asset.DataAssetTools] Creates a new DataAsset asset in the project. Args: folder_path: The path to the folder that will contain the asset. asset_name: The name of the asset in the folder. asset_type: The specific kind of DataClass to make. Returns: The DataAsset that was created. Params (pass as input): folder_path, asset_name, asset_type.asset(epic_create_folder)- [Epic editor_toolset.toolsets.asset.AssetTools] Creates a folder at the specified path. Args: path: The project relative path at which to create the folder. Returns: True if the folder could be created or already exists. Params (pass as input): path.asset(epic_create_from_mesh)- [Epic PhysicsToolsets.PhysicsAssetToolset] Creates a physics asset from a skeletal mesh, auto-generating collision bodies for each bone. The asset is placed in the same folder as the mesh with the suffix "_PhysicsAsset". Params (pass as input): meshPath, bAssignToMesh.asset(epic_delete)- [Epic editor_toolset.toolsets.asset.AssetTools] Deletes an asset or folder. Args: path: The current location of the folder or asset. Returns: True if the delete happened successfully. False otherwise. Params (pass as input): path.asset(epic_duplicate)- [Epic editor_toolset.toolsets.asset.AssetTools] Makes a copy of a folder or asset. Args: path: The current location of folder or asset. new_path: The location of the copy. Returns: True if the copy happened successfully. False otherwise. Params (pass as input): path, new_path.asset(epic_exists)- [Epic editor_toolset.toolsets.asset.AssetTools] Determines if a folder or asset exists. Args: path: The path at which an asset or folder might exist. Returns: True if an asset or folder exists at the path. False otherwise. Params (pass as input): path.asset(epic_find_assets)- [Epic editor_toolset.toolsets.asset.AssetTools] Searches the project for assets that match specific criteria. Args: folder_path: The folder to search within. Pass an empty string to search the entire project (/Game/ and all plugin content folders including project plugins and engine plugins). name: If set, will only return assets whose name contains this string (case-insensitive). asset_type: If set, will only return assets that are of this type. recursive: Whether to search subfolders or not. tags: If set, will only return assets whose asset registry tags contain all specified key-value pairs with exact value matches. Returns: A list of asset paths that match the criteria. Params (pass as input): folder_path, name, asset_type?, recursive?, tags?.asset(epic_get_asset_class)- [Epic editor_toolset.toolsets.asset.AssetTools] Gets the class of an asset. Args: asset_path: Content path to the asset. Returns: The class name of the asset (e.g. 'StaticMesh', 'Material', 'HeroCharacter_C'). Params (pass as input): asset_path.asset(epic_get_asset_tags)- [Epic editor_toolset.toolsets.asset.AssetTools] Gets the asset registry tags for an asset. Args: asset_path: Content path to the asset. Returns: A dict mapping tag names to their string values. Params (pass as input): asset_path.asset(epic_get_body_mass_scale)- [Epic PhysicsToolsets.PhysicsAssetToolset] Returns the mass-scale multiplier for the given body. Params (pass as input): physicsAsset, boneName.asset(epic_get_body_names)- [Epic PhysicsToolsets.PhysicsAssetToolset] Returns the bone name for each rigid body in a physics asset. Params (pass as input): physicsAsset.asset(epic_get_body_physics_mode)- [Epic PhysicsToolsets.PhysicsAssetToolset] Returns the physics simulation mode for the given body. Params (pass as input): physicsAsset, boneName.asset(epic_get_body_shapes)- [Epic PhysicsToolsets.PhysicsAssetToolset] Returns all collision shapes assigned to a body. Params (pass as input): physicsAsset, boneName.asset(epic_get_constraints)- [Epic PhysicsToolsets.PhysicsAssetToolset] Returns all constraints in the physics asset with their current angular limits. Params (pass as input): physicsAsset.asset(epic_get_dependencies)- [Epic editor_toolset.toolsets.asset.AssetTools] Lists assets that the specified asset depends on. Args: asset_path: Content path to the asset. Returns: A list of content paths for assets that the given asset depends on. Params (pass as input): asset_path.asset(epic_get_items)- [Epic DataRegistryToolset.DataRegistryTools] Returns cached item data. Items must be loaded in the registry cache to be returned. Params (pass as input): registryName, itemNames.asset(epic_get_keys)- [Epic editor_toolset.toolsets.curve_table.CurveTableTools] Returns all keys for a row. Args: curve_table: The CurveTable to query. row_name: The name of the row to query. Returns: A list of SimpleCurveKey objects for the row. Params (pass as input): curve_table, row_name.asset(epic_get_metadata_tags)- [Epic editor_toolset.toolsets.asset.AssetTools] Gets the metadata tags for an asset. Args: asset_path: Content path to the asset. Returns: A dict mapping tag names to their string values. Params (pass as input): asset_path.asset(epic_get_plugin_content_paths)- [Epic editor_toolset.toolsets.asset.AssetTools] Returns the root content paths for plugins that have content. Args: include_engine: When True, also includes content plugins under the Engine directory. Returns: A list of virtual content root paths (e.g. ['/PluginName/']) for each in-scope plugin that has a content directory. Params (pass as input): include_engine?.asset(epic_get_referencers)- [Epic editor_toolset.toolsets.asset.AssetTools] Lists assets that reference the specified asset. Args: asset_path: Content path to the asset. Returns: A list of content paths for assets that reference the given asset. Params (pass as input): asset_path.asset(epic_get_registry_info)- [Epic DataRegistryToolset.DataRegistryTools] Returns detailed information about a specific registry. Params (pass as input): registryName.asset(epic_get_schema)- [Epic DataRegistryToolset.DataRegistryTools] Returns the item struct schema as JSON. Params (pass as input): registryName.asset(epic_import_file)- [Epic editor_toolset.toolsets.curve_table.CurveTableTools] Imports a file from disk as a CurveTable asset. The file's first column is the row name; subsequent columns are sample times and values. interp_mode controls how the imported keys are interpolated between samples. Args: folder_path: The content-browser folder to create the asset in. asset_name: The name of the new asset. source_file: The absolute path to the source file on disk. interp_mode: Interpolation mode applied to every imported key. Must be RCIM_LINEAR or RCIM_CONSTANT. Returns: The assets produced by the import (typically a single CurveTable). Params (pass as input): folder_path, asset_name, source_file, interp_mode.asset(epic_is_checked_out)- [Epic editor_toolset.toolsets.asset.AssetTools] Checks whether an asset is checked out by the current user. Args: asset_path: Content path to the asset. Returns: True if the asset is currently checked out by the current user. Params (pass as input): asset_path.asset(epic_is_dirty)- [Epic editor_toolset.toolsets.asset.AssetTools] Checks whether an asset has unsaved changes. Args: asset_path: The path to the asset to check. Returns: True if the asset has unsaved changes, False if it is saved. Params (pass as input): asset_path.asset(epic_list_data_sources)- [Epic DataRegistryToolset.DataRegistryTools] Returns the editor-defined sources configured on a Data Registry. These are the sources as authored on the registry asset, before any runtime expansion of meta sources. Params (pass as input): registryName.asset(epic_list_folders)- [Epic editor_toolset.toolsets.asset.AssetTools] Lists the folders contained within a folder. Args: root: The project relative path to the folder to search from. recursive: Subfolders will be searched when this is set to true. Returns: A list of paths to folders Params (pass as input): root_path, recursive?.asset(epic_list_items)- [Epic DataRegistryToolset.DataRegistryTools] Returns all item names in a Data Registry. Params (pass as input): registryName.asset(epic_list_registries)- [Epic DataRegistryToolset.DataRegistryTools] Returns the names of all registered Data Registries. Params (pass as input): structFilter?.asset(epic_list_rows)- [Epic editor_toolset.toolsets.curve_table.CurveTableTools] Lists the names of all rows in the curve table. Args: curve_table: The CurveTable to query. Returns: A list of row names. Params (pass as input): curve_table.asset(epic_list_runtime_sources)- [Epic DataRegistryToolset.DataRegistryTools] Returns the runtime sources for a Data Registry. This is the expanded list including transient child sources generated from meta sources. Will equal ListDataSources when the registry has no meta sources. Params (pass as input): registryName.asset(epic_load_asset)- [Epic editor_toolset.toolsets.asset.AssetTools] Loads an asset from the project. Args: asset_path: The path to the asset to load. Returns: The loaded asset. Params (pass as input): asset_path.asset(epic_move)- [Epic editor_toolset.toolsets.asset.AssetTools] Moves or renames an asset or folder. Args: path: The current location of the folder or asset. new_path: The new location and/or name. Returns: True if the rename happened successfully. False otherwise. Params (pass as input): path, new_path.asset(epic_read_file)- [Epic editor_toolset.toolsets.asset.AssetTools] Reads a text file from disk and returns its contents. Only files under /Game/, an enabled plugin's Content/ directory, or the project Saved/ directory may be read. Only plain text formats are supported. Args: file_path: The path to the file to read. Returns: The text content of the file. Params (pass as input): file_path.asset(epic_remove_body)- [Epic PhysicsToolsets.PhysicsAssetToolset] Removes the body for the given bone along with any constraints that reference it. Raises a script error if PhysicsAsset is null or no body exists for BoneName. Params (pass as input): physicsAsset, boneName.asset(epic_remove_constraint)- [Epic PhysicsToolsets.PhysicsAssetToolset] Removes the constraint between two bodies. Params (pass as input): physicsAsset, bone1Name, bone2Name.asset(epic_remove_row)- [Epic editor_toolset.toolsets.curve_table.CurveTableTools] Removes a row from the curve table. Args: curve_table: The CurveTable to modify. row_name: The name of the row to remove. Params (pass as input): curve_table, row_name.asset(epic_remove_shape)- [Epic PhysicsToolsets.PhysicsAssetToolset] Removes a collision primitive from a body by name. Params (pass as input): physicsAsset, boneName, shapeName.asset(epic_rename_row)- [Epic editor_toolset.toolsets.curve_table.CurveTableTools] Renames a row in the curve table. Args: curve_table: The CurveTable to modify. row_name: The current name of the row. new_row_name: The new name for the row. Params (pass as input): curve_table, row_name, new_row_name.asset(epic_save_assets)- [Epic editor_toolset.toolsets.asset.AssetTools] Saves assets to disk. Args: asset_paths: The paths to the assets to save. Pass an empty list to save all dirty assets. Returns: True if all assets were saved successfully. Params (pass as input): asset_paths.asset(epic_set_body_mass_scale)- [Epic PhysicsToolsets.PhysicsAssetToolset] Sets the mass-scale multiplier for the given body. Params (pass as input): physicsAsset, boneName, massScale.asset(epic_set_body_physics_mode)- [Epic PhysicsToolsets.PhysicsAssetToolset] Sets the physics simulation mode for the given body. Params (pass as input): physicsAsset, boneName, mode.asset(epic_set_box)- [Epic PhysicsToolsets.PhysicsAssetToolset] Adds or replaces a box collision primitive on a body. If any shape with the given name already exists on the body it is removed first. Params (pass as input): physicsAsset, boneName, shapeName, center, rotation, extentX, extentY, extentZ.asset(epic_set_capsule)- [Epic PhysicsToolsets.PhysicsAssetToolset] Adds or replaces a capsule collision primitive on a body. If any shape with the given name already exists on the body it is removed first. The capsule's long axis is its local Z after applying Rotation. Params (pass as input): physicsAsset, boneName, shapeName, center, rotation, radius, length.asset(epic_set_constraint_limits)- [Epic PhysicsToolsets.PhysicsAssetToolset] Updates the angular limits for an existing constraint. Params (pass as input): physicsAsset, info.asset(epic_set_keys)- [Epic editor_toolset.toolsets.curve_table.CurveTableTools] Replaces all keys in a row with the provided list. Args: curve_table: The CurveTable to modify. row_name: The name of the row to modify. keys: The keys to set in the row. Returns: True if all keys were set successfully. Params (pass as input): curve_table, row_name, keys.asset(epic_set_sphere)- [Epic PhysicsToolsets.PhysicsAssetToolset] Adds or replaces a sphere collision primitive on a body. If any shape with the given name already exists on the body it is removed first. Params (pass as input): physicsAsset, boneName, shapeName, center, radius.asset(epic_update_metadata_tags)- [Epic editor_toolset.toolsets.asset.AssetTools] Sets or removes metadata tags on an asset. Args: asset_path: Content path to the asset. set_tags: Tag names mapped to the values to set. remove_tags: Tag names to remove. Removing a tag that does not exist is a no-op. Params (pass as input): asset_path, set_tags?, remove_tags?.asset(epic_write_file)- [Epic editor_toolset.toolsets.asset.AssetTools] Writes text content to a file on disk. Only files under /Game/, an enabled plugin's Content/ directory, or the project Saved/ directory may be written. Only plain text formats are supported. Overwrites the file if it already exists. Args: file_path: The path to the file to write. content: The text content to write. Params (pass as input): file_path, content.
blueprint
Wraps 53 official tools.
blueprint(epic_add_component_bound_event)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Creates a component bound event node in the event graph. Args: component: The component to bind the event to. Must be a component on a Blueprint actor. event_name: The name of the delegate event to bind, e.g. 'OnComponentBeginOverlap'. graph: The event graph to add the node to. Returns: The created or pre-existing component bound event node. Params (pass as input): component, event_name, graph.blueprint(epic_add_event)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Adds an event node to the Blueprint's event graph. If event_name matches an inherited overridable event, the new node is an override of that event. Otherwise a new custom event with the given name is created. Idempotent — if an event node with that name already exists, that node is returned. Args: blueprint: The Blueprint asset to add the event to. event_name: The name of an inherited event to override (e.g. 'ReceiveAnyDamage') or a name for a new custom event. position: Position of the new node in the event graph. Returns: The event node. Params (pass as input): blueprint, event_name, position?.blueprint(epic_add_event_dispatcher)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Adds an event dispatcher to a Blueprint. Args: blueprint: The Blueprint to add the dispatcher to. name: The name of the new event dispatcher. Returns: The event dispatcher graph. Params (pass as input): blueprint, name.blueprint(epic_add_function_graph)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Adds a function graph to the Blueprint. If graph_name matches an inherited overridable function, the new graph is a function-graph override of that function. Idempotent — if a graph with that name already exists, that graph is returned. Args: blueprint: The Blueprint asset to add the function to. graph_name: The name of the new function graph. Params (pass as input): blueprint, graph_name.blueprint(epic_add_function_param)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Adds an input or output to a function or event dispatcher Note: output params are not supported on event dispatchers. Supported parameter types: Primitives: 'bool', 'int', 'float', 'byte', 'string', 'name', 'text' Structs: 'Vector', 'Rotator', 'Transform', 'Vector2D', 'LinearColor' Args: graph: The function or event dispatcher graph to add the parameter to. param_name: The name of the new parameter. param_type: The parameter type as a string (see above). input_param: True to add an input param, false to add an output. container_type: Container type for the parameter. MAP uses string as the key type. Returns: The PinID of the newly created parameter. Params (pass as input): graph, param_name, param_type, input_param, container_type?.blueprint(epic_add_node_pin)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Adds a pin to a node that supports dynamic pin addition. Works for Switch nodes (adds one case pin), Sequence nodes (adds one Then output), commutative binary operators like Add/Multiply (adds one input), Make Array nodes, etc. Args: node: The node to add a pin to. Must support dynamic pin addition. Returns: The PinID of the newly added pin. Params (pass as input): node.blueprint(epic_add_object_function_param)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Adds an object reference input or output to a function or event dispatcher. Note: output params are not supported on event dispatchers. Args: graph: The function or event dispatcher graph to add the param to. param_name: The name of the new param. object_class: The class of object this param will reference. input_param: True to add an input param, false to add an output. container_type: Container type for the param. MAP uses string as the key type. Returns: The PinID of the newly created param. Params (pass as input): graph, param_name, object_class, input_param, container_type?.blueprint(epic_add_object_variable)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Adds a member or local variable that holds an object reference to a Blueprint. Args: blueprint: The Blueprint to add the variable to. name: The variable name. object_class: The class of object this variable will reference. graph: If provided, adds a local variable to this function graph instead of a member variable. container_type: Container type for the variable. MAP uses string as the key type. Params (pass as input): blueprint, name, object_class, graph?, container_type?.blueprint(epic_add_struct_function_param)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Adds a struct input or output to a function or event dispatcher. Note: output params are not supported on event dispatchers. Use this to add parameters of any UStruct type, including custom structs and engine structs not in the basic list supported by add_function_param (e.g. HitResult, GameplayTag). Args: graph: The function or event dispatcher graph to add the parameter to. param_name: The name of the new parameter. struct_type: The struct type for this parameter. input_param: True to add an input param, false to add an output. container_type: Container type for the parameter. MAP uses string as the key type. Returns: The PinID of the newly created parameter. Params (pass as input): graph, param_name, struct_type, input_param, container_type?.blueprint(epic_add_struct_variable)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Adds a member or local variable of a struct type to a Blueprint. Use this to add variables of any UStruct type, including custom structs and engine structs not in the basic list supported by add_variable (e.g. HitResult, GameplayTag). Args: blueprint: The Blueprint to add the variable to. name: The variable name. struct_type: The struct type for this variable. graph: If provided, adds a local variable to this function graph instead of a member variable. container_type: Container type for the variable. MAP uses string as the key type. Params (pass as input): blueprint, name, struct_type, graph?, container_type?.blueprint(epic_add_variable)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Adds a member or local variable to a Blueprint. Supported type names: Primitives: 'bool', 'int', 'float', 'byte', 'string', 'name', 'text' Structs: 'Vector', 'Rotator', 'Transform', 'Vector2D', 'LinearColor' Args: blueprint: The Blueprint to add the variable to. name: The variable name. type_name: The variable type as a string (see above). graph: If provided, adds a local variable to this function graph instead of a member variable. container_type: Container type for the variable. MAP uses string as the key type. Params (pass as input): blueprint, name, type_name, graph?, container_type?.blueprint(epic_arrange_nodes)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Arranges a list of nodes in a readable left-to-right layout. Organizes nodes into columns based on data/execution flow, with producer nodes to the left of the nodes they feed into. Call this after building a graph to avoid nodes overlapping. Connections to nodes outside the list are used as anchors so the arranged nodes integrate cleanly with the rest of the graph. Args: nodes: The nodes to arrange. Params (pass as input): nodes.blueprint(epic_break_pins)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Breaks the connection between two pins. Args: output_pin: The PinID of the output pin to disconnect from. input_pin: The PinID of the input pin to disconnect from. Params (pass as input): output_pin, input_pin.blueprint(epic_compile_blueprint)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Compiles the given Blueprint. Blueprints should be compiled after all graph modifications are complete. Args: blueprint: The Blueprint to compile. warnings_as_errors: If True, raise on compile warnings as well as errors. Defaults to False. Params (pass as input): blueprint, warnings_as_errors?.blueprint(epic_connect_pins)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Makes a connection between source (output) and dest (input) pins. Args: output_pin: The PinID of the output pin to connect from. input_pin: The PinID of the input pin to connect to. Params (pass as input): output_pin, input_pin.blueprint(epic_create)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Creates a new Blueprint asset in the project. Args: folder_path: The path to the folder that will contain the asset. asset_name: The name of the asset in the folder. asset_type: The specific kind of Blueprint to make. Returns: The Blueprint that was created. Params (pass as input): folder_path, asset_name, asset_type.blueprint(epic_create_node)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Adds a new node to the graph. Args: graph: The graph to add a node to type_id: The type of the node to add. Eg 'Development|PrintString', 'Utilities|Operators|Add', a macro like 'Utilities|FlowControl|ForLoop', a dispatcher event handler like 'Default|EventDispatcherOnDamaged', an event like 'AddEvent|EventBeginPlay', or a named custom event with 'AddEvent|Custom|MyEventName'. pos: The x, y position of the created node declaring_class: The class that should own the created node. Only set this when you need to disambiguate nodes that share the same type_id to ensure the correct one is used. Returns: Returns the new node Params (pass as input): graph, type_id, pos, declaring_class?.blueprint(epic_delete_node)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Deletes the node from its graph. Args: node: The node to be deleted Params (pass as input): node.blueprint(epic_find_node_categories)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Retrieves a list of available node categories in a Blueprint graph, optionally filtered by compatible input and/or output pin types Note: Categories are everything before the last | character in a node type id (eg 'Utilities|Operators' in the 'Utilities|Operators|Add' type id) Args: graph: the graph to make the search for category_filter: Substring to match against the node categories (case-insensitive). Pass an empty string to return all categories. context_pins: If set, only returns categories with nodes whose pin types match those specified in this list Returns: Returns node categories that match the input criteria Params (pass as input): graph, category_filter, context_pins.blueprint(epic_find_node_types)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Finds node types that can be created in a particular graph meeting the search criteria. Note: there can be thousands of valid node types in a graph, so type_id_filter should be reasonably specific even if that requires multiple searches. To list all nodes within a category, use a trailing pipe: e.g. 'Utilities|FlowControl|' returns every node under that category. Without the trailing pipe, 'Utilities|FlowControl' also matches any node whose type_id contains that substring (such as a node with category 'Utilities' and title 'FlowControl'). Args: graph: the graph to make the search for type_id_filter: Substring to match against the node type_id (case-insensitive) context_pins: If set, only returns nodes whose pin types match those specified in this list Returns: Returns nodes that match the input criteria Params (pass as input): graph, type_id_filter, context_pins.blueprint(epic_find_nodes)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Finds nodes in a graph by title, class, and/or execution role. All filters are optional and ANDed together. Useful for locating specific event chains in large graphs like EventGraph before reading them with get_connected_subgraph. Args: graph: The graph to search. title: Case-insensitive substring to match against the node's displayed title. Pass an empty string to match any title. node_class: If provided, only returns nodes that are instances of this class or its subclasses. entry_points_only: If True, only returns entry point nodes - nodes with an exec output but no exec input (event nodes, function entry nodes, macro input tunnels, etc.). Nothing can drive these nodes; they start execution themselves. Returns: All nodes in the graph matching the given filters. Params (pass as input): graph, title, node_class?, entry_points_only?.blueprint(epic_get_connected_subgraph)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Returns detailed information for all nodes connected to the given node. Use this alongside find_nodes to read a single event chain from a large graph (like Event Graph) without reading the entire graph. Args: node: The starting node. Returns: Every node reachable from the given node via any connection, including the starting node itself. Params (pass as input): node.blueprint(epic_get_create_event_function)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Returns the function currently bound to a Create Event node. Args: node: The Create Event node. Returns: The bound function name, or empty string if none is set. Params (pass as input): node.blueprint(epic_get_default_object)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Returns the Class Default Object (CDO) for a Blueprint's. ObjectTools list/set/get property will get the CDO automatically, so this should primarily be used before calling tools that want to operate on the object inside the blueprint (like ActorTools). Note: The Blueprint must be compiled for the CDO to reflect the latest state. Args: blueprint: The Blueprint whose CDO to retrieve. Returns: The Class Default Object for the Blueprint's generated class. Params (pass as input): blueprint.blueprint(epic_get_graph)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Retrieves a specific graph from a Blueprint asset by name. Args: blueprint: The Blueprint asset to search within. graph_name: The name of the graph to retrieve (e.g., "EventGraph", "MyFunction") Returns: The graph object matching the specified name. Params (pass as input): blueprint, graph_name.blueprint(epic_get_graph_dsl_docs)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Returns the full syntax reference for write_graph_dsl. Call this before using write_graph_dsl for the first time. Params: none.blueprint(epic_get_node_infos)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Retrieves detailed information for a list of Blueprint graph nodes. Args: nodes: The graph nodes to retrieve information from. Returns: Information about each node, including type, pins, connections, and position. Params (pass as input): nodes.blueprint(epic_get_node_type_pins)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Returns the pin names and types for a node type. Args: graph: The graph context used to resolve the node type. type_id: A node type_id as returned by find_node_types. Returns: NodeInfo with input_pins and output_pins listing each pin's name and type. Params (pass as input): graph, type_id.blueprint(epic_get_parent)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Returns the parent class of a Blueprint. Args: blueprint: The Blueprint whose parent class to retrieve. Returns: The parent class of the Blueprint's generated class. Params (pass as input): blueprint.blueprint(epic_get_pin_value)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Gets the value of a Blueprint graph pin. Args: pin: The PinID of the pin to read. Must be an input pin that supports default values. Returns: The value of the pin as a string. Params (pass as input): pin.blueprint(epic_get_variable_category)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Gets the user-defined category of a Blueprint member variable. Categories group variables in the My Blueprint panel. Variables with no explicit category default to the Blueprint's name in the UI. Args: blueprint: The Blueprint containing the variable. variable_name: The name of the member variable to query. Returns: The category as a string. Empty string if the variable has no custom category override. Params (pass as input): blueprint, variable_name.blueprint(epic_get_variable_replication)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Gets the replication mode of a Blueprint member variable. Args: blueprint: The Blueprint containing the variable. variable_name: The name of the member variable to query. Returns: The replication mode (NONE, REPLICATED, or REP_NOTIFY). Params (pass as input): blueprint, variable_name.blueprint(epic_list_compatible_event_functions)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Lists functions that can be bound to a Create Event node. Args: node: The Create Event node. Returns: A list of function names valid for binding. Params (pass as input): node.blueprint(epic_list_component_events)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Lists the bindable delegate events available on a component. Args: component: The component to query. Must be a component on a Blueprint actor. Returns: The names of all bindable events on the component, e.g. OnComponentBeginOverlap. Params (pass as input): component.blueprint(epic_list_event_dispatchers)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Lists all event dispatchers defined on a Blueprint. Args: blueprint: The Blueprint to list event dispatchers for. Returns: A list of event dispatcher graphs, one per dispatcher. Params (pass as input): blueprint.blueprint(epic_list_events)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Lists all events visible on the Blueprint — locally defined custom events plus inheritable events from the parent class chain and implemented interfaces. Args: blueprint: The Blueprint asset to query. Params (pass as input): blueprint.blueprint(epic_list_functions)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Lists all functions visible on the Blueprint — locally defined plus inheritable ones from the parent class chain and implemented interfaces. Args: blueprint: The Blueprint asset to query. Params (pass as input): blueprint.blueprint(epic_list_graphs)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Lists all graphs in the Blueprint. Args: blueprint: The Blueprint asset with the graphs to list. Returns: list of graphs in the Blueprint. Params (pass as input): blueprint.blueprint(epic_list_variables)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Lists member or local variables defined on a Blueprint. Args: blueprint: The Blueprint to list variables for. graph: If provided, lists local variables in this function graph instead of member variables. Returns: A list of variable names. Params (pass as input): blueprint, graph?.blueprint(epic_read_graph_dsl)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Reads a Blueprint graph and returns a DSL script. The returned code uses the same syntax that write_graph_dsl accepts and can be edited and passed back to write_graph_dsl to modify the graph. Call get_graph_dsl_docs() for the full syntax reference. Args: graph: The graph to read. Returns: An S-expression DSL script representing the graph's logic. Params (pass as input): graph.blueprint(epic_remove_function_graph)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Removes a function graph or event dispatcher from the Blueprint. Note: This will close the Blueprint editor window if it is currently open. Args: blueprint: The Blueprint asset to remove the function graph from. graph_name: The name of the function or dispatcher to remove. Params (pass as input): blueprint, graph_name.blueprint(epic_remove_function_param)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Removes an input or output from a function or event dispatcher. Note: output params are not supported on event dispatchers. Args: graph: The function or event dispatcher graph to remove the param from. param_name: The name of the param to remove. input_param: True to remove an input param, False to remove an output. Params (pass as input): graph, param_name, input_param.blueprint(epic_remove_node_pin)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Removes a specific pin from a node that supports dynamic pin removal. Works for Switch nodes (removes one case pin), Sequence nodes (removes one Then output), commutative binary operators like Add/Multiply (removes one input), Make Array nodes, etc. Args: node: The node to remove a pin from. Must support dynamic pin removal. pin: The PinID of the pin to remove. Params (pass as input): node, pin.blueprint(epic_remove_variable)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Removes a member or local variable from a Blueprint. Args: blueprint: The Blueprint to remove the variable from. name: The name of the variable to remove. graph: If provided, removes a local variable from this function graph instead of a member variable. Params (pass as input): blueprint, name, graph?.blueprint(epic_retarget_node_class)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Replaces a node's baked-in class reference from old_class to new_class in place. If the node's current class reference matches old_class it is replaced with new_class and the node is reconstructed so its pins reflect the new type. If the node already references new_class the call is a no-op. When a Blueprint is duplicated, nodes in the copied graph retain class references pointing to the original Blueprint. Calling this on each node with the original and duplicate classes retargets them without manual delete-recreate-rewire cycles. Handles cast, function call, event, and multicast delegate nodes. The Blueprint must be compiled after all retargeting is complete. Args: node: The node to retarget. old_class: The class currently baked into the node. new_class: The replacement class. Params (pass as input): node, old_class, new_class.blueprint(epic_set_create_event_function)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Binds a function to a Create Event node. Use list_compatible_event_functions to find valid function names. Args: node: The Create Event node. function_name: The name of the function to bind. Params (pass as input): node, function_name.blueprint(epic_set_node_position)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Sets a new position for the node. Args: node: Node to be moved pos: New x, y position of the node in the graph Params (pass as input): node, pos.blueprint(epic_set_parent)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Reparents a Blueprint to a new parent class. The Blueprint must be recompiled after reparenting. Args: blueprint: The Blueprint to reparent. parent_class: The new parent class. Must be a UObject subclass. Params (pass as input): blueprint, parent_class.blueprint(epic_set_pin_value)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Sets the value of a Blueprint graph pin. Args: pin: The PinID of the pin to modify. Must be an input pin that supports default values. value: The value to assign as a string. Format depends on the pin's data type: - Numeric pins (int/float): "42" or "3.14" - Boolean pins: "true" or "false" - String/Name/Text pins: "Hello World" - Object reference pins: "/Game/Path/To/Asset.Asset" Params (pass as input): pin, value.blueprint(epic_set_variable_category)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Sets the user-defined category on a Blueprint member variable. Categories group variables in the My Blueprint panel. Pass an empty string to reset to the default (the Blueprint's name). Args: blueprint: The Blueprint containing the variable. variable_name: The name of the member variable to modify. category: The new category text. Params (pass as input): blueprint, variable_name, category.blueprint(epic_set_variable_instance_editable)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Sets whether a member variable is editable per-instance on actors placed in the level. Args: blueprint: The Blueprint containing the variable. variable_name: The name of the member variable to modify. instance_editable: True to make the variable editable on instances, False to hide it. Params (pass as input): blueprint, variable_name, instance_editable.blueprint(epic_set_variable_replication)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Sets the replication mode on a Blueprint member variable. RepNotify will automatically create an OnRep_ function on the Blueprint if one does not already exist. Args: blueprint: The Blueprint containing the variable. variable_name: The name of the member variable to modify. replication: Replication mode (NONE, REPLICATED, or REP_NOTIFY). Params (pass as input): blueprint, variable_name, replication.blueprint(epic_write_graph_dsl)- [Epic editor_toolset.toolsets.blueprint.BlueprintTools] Populates a Blueprint graph with nodes from a DSL script and compiles the Blueprint. Call get_graph_dsl_docs() for the full syntax reference and examples. Args: graph: The graph to populate with nodes. code: The S-expression DSL script to convert into Blueprint nodes. Params (pass as input): graph, code.
epic
Wraps 212 official tools.
epic(epic_add_comment_box)- [Epic DataflowAgent.DataflowAgentToolset] Adds a comment box around the given nodes. Params (pass as input): graph, nodes, comment?, color?.epic(epic_add_cone)- [Epic editor_toolset.toolsets.primitive.PrimitiveTools] Adds a cone-shaped StaticMeshComponent to an actor. Args: actor: The actor to add the component to. name: The name of the new component. radius: The radius of the cone base. height: The height of the cone. local_transform: The transform of the component relative to the actor. Returns: The new StaticMeshComponent. Params (pass as input): actor, name, radius?, height?, local_transform?.epic(epic_add_cube)- [Epic editor_toolset.toolsets.primitive.PrimitiveTools] Adds a cube-shaped StaticMeshComponent to an actor. Args: actor: The actor to add the component to. name: The name of the new component. dimensions: The x, y, and z size of the cube. local_transform: The transform of the component relative to the actor. Returns: The new StaticMeshComponent. Params (pass as input): actor, name, dimensions?, local_transform?.epic(epic_add_cylinder)- [Epic editor_toolset.toolsets.primitive.PrimitiveTools] Adds a cylinder-shaped StaticMeshComponent to an actor. Args: actor: The actor to add the component to. name: The name of the new component. radius: The radius of the cylinder. height: The height of the cylinder. local_transform: The transform of the component relative to the actor. Returns: The new StaticMeshComponent. Params (pass as input): actor, name, radius?, height?, local_transform?.epic(epic_add_node)- [Epic DataflowAgent.DataflowAgentToolset] Adds a node of the given type to the Dataflow graph. Params (pass as input): graph, typeName, nodeName, jsonParams, x?, y?.epic(epic_add_plugin_dependency)- [Epic PluginToolset.PluginToolset] Adds a dependency entry to a plugin's Plugins array in its .uplugin file. No-ops if a dependency with that name already exists with matching settings. The dependency plugin does not need to be currently discovered. Params (pass as input): pluginName, dependencyName, bOptional, bEnabled.epic(epic_add_rows)- [Epic editor_toolset.toolsets.data_table.DataTableTools] Adds new rows with default values to the data table. Args: data_table: The DataTable to modify. row_names: The names for the new rows. Params (pass as input): data_table, row_names.epic(epic_add_socket)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Adds a named socket to a skeletal mesh attached to a bone. Sockets are named attachment points used to attach weapons, accessories, or effects at a consistent position relative to a bone. Args: mesh: The skeletal mesh asset to modify. socket_name: The name to give the new socket. bone_name: The name of the bone to attach the socket to. Returns: The newly created socket. Params (pass as input): mesh, socket_name, bone_name.epic(epic_add_sphere)- [Epic editor_toolset.toolsets.primitive.PrimitiveTools] Adds a sphere-shaped StaticMeshComponent to an actor. Args: actor: The actor to add the component to. name: The name of the new component. radius: The radius of the sphere. local_transform: The transform of the component relative to the actor. Returns: The new StaticMeshComponent. Params (pass as input): actor, name, radius?, local_transform?.epic(epic_add_to_scene_from_asset)- [Epic editor_toolset.toolsets.scene.SceneTools] Creates a new actor in the scene from an asset. Args: asset_path: The path to the asset to spawn (e.g. '/Game/Blueprints/MyActor'). name: The name of the actor instance. xform: The transform for the new actor. Parent-local whenparentis set; world-space otherwise. parent: If set, the new actor will be a child of this actor. If unset the Actor will be a child of the world. snap_to_ground: If set to true, will attempt to adjust the actors Z position so that the bottom of its bounding box is on the ground. Returns: The created actor or nothing if creation was unsuccessful. Params (pass as input): asset_path, name, xform, parent?, snap_to_ground?.epic(epic_add_to_scene_from_class)- [Epic editor_toolset.toolsets.scene.SceneTools] Creates a new instance of the specified object at the specified transform. Args: actor_type: The Actor class to instantiate. name: The name of the actor instance. xform: The transform for the new actor. Parent-local whenparentis set; world-space otherwise. parent: If set, the new actor will be a child of this actor. If unset the Actor will be a child of the world. snap_to_ground: If set to true, will attempt to adjust the actors Z position so that the bottom of its bounding box is on the ground. Returns: The created actor or nothing if creation was unsuccessful. Params (pass as input): actor_type, name, xform, parent?, snap_to_ground?.epic(epic_add_variable)- [Epic DataflowAgent.DataflowAgentToolset] Adds a new variable to the Dataflow graph. Supported type strings: Primitives : "Bool", "Int32", "Int64", "Float", "Double", "Name", "String" Structs : UScriptStruct name with or without the "F" prefix e.g. "Vector", "FVector", "Transform", "FTransform", "Rotator", "LinearColor" Objects : "Object:<ClassName>" where ClassName is with or without the "U"/"A" prefix e.g. "Object:StaticMesh", "Object:USkeletalMesh" Params (pass as input): graph, name, type.epic(epic_assign_dataflow_template)- [Epic DataflowAgent.DataflowAgentToolset] Assigns a Dataflow template to an existing Dataflow-compatible asset by duplicating the template graph and embedding it. Replaces any existing embedded graph. Params (pass as input): asset, templateId.epic(epic_assign_physics_asset)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Assigns a physics asset to a skeletal mesh. The physics asset must be compatible with the mesh's skeleton. Use this to swap physics assets or assign one to a mesh that has none. Args: mesh: The skeletal mesh asset to modify. physics_asset: The physics asset to assign. Returns: True if the physics asset was assigned successfully. Params (pass as input): mesh, physics_asset.epic(epic_can_edit)- [Epic editor_toolset.toolsets.scene.SceneTools] Checks whether an actor can be edited. Args: actor: The actor to check. Returns: True if the actor can be edited, False if it is checked out or locked by another user in source control. Params (pass as input): actor.epic(epic_capture_asset_image)- [Epic EditorToolset.EditorAppToolset] Renders a thumbnail for the specified asset (e.g. static meshes, skeletal meshes, skeletons, animations, montages, materials, textures). Params (pass as input): assetPath.epic(epic_capture_editor_image)- [Epic EditorToolset.EditorAppToolset] Captures an image of the entire editor application as the user sees it. Params: none.epic(epic_capture_viewport)- [Epic EditorToolset.EditorAppToolset] Captures the level viewport with optional annotations. Annotations rendering overlays a projected 3D world-space grid plus name + position labels on visible actors. The grid is drawn at a configurable ground-plane Z and projected through the camera, with coordinate numbers at intersections (shown in meters). Each labeled actor gets a crosshair at its projected screen position with a leader-line callout placed to avoid overlap. This gives a vision-capable agent spatial awareness: it can reference grid coordinates to direct placement and identify scene contents by label. Params (pass as input): captureTransform?, annotations?, bShowUI?.epic(epic_click)- [Epic SlateInspectorToolset.SlateInspectorToolset] Click a Slate widget identified by its ref. Params (pass as input): ref, button?, doubleClick?, modifiers?.epic(epic_commit_level_instance)- [Epic editor_toolset.toolsets.scene.SceneTools] Saves or discards edits to a level instance and exits edit mode. Args: level_instance: The level instance actor to commit. discard: If True, discards all changes without saving. Defaults to False. Params (pass as input): level_instance, discard?.epic(epic_connect_node_pins)- [Epic DataflowAgent.DataflowAgentToolset] Connects an output pin of one node to an input pin of another. Params (pass as input): fromNode, fromPin, toNode, toPin.epic(epic_create)- [Epic editor_toolset.toolsets.data_table.DataTableTools] Creates a new DataTable asset with the specified column schema. Args: folder_path: The path to the folder that will contain the asset. asset_name: The name of the asset. schema: The struct that defines the columns of the table. Must be a subclass of TableRowBase. Returns: The created DataTable. Params (pass as input): folder_path, asset_name, schema.epic(epic_create__string_table_tools)- [Epic editor_toolset.toolsets.string_table.StringTableTools] Creates a new StringTable asset. Args: folder_path: The path to the folder that will contain the asset. asset_name: The name of the asset. Returns: The created StringTable. Params (pass as input): folder_path, asset_name.epic(epic_create_dataflow_compatible_asset)- [Epic DataflowAgent.DataflowAgentToolset] Creates a new Dataflow-compatible asset (e.g. ChaosClothAsset, GeometryCollection, FleshAsset, GroomAsset) with an empty embedded Dataflow graph. Params (pass as input): className, name, path?.epic(epic_create_dataflow_compatible_asset_from_template)- [Epic DataflowAgent.DataflowAgentToolset] Creates a new Dataflow-compatible asset and initialises its embedded Dataflow graph from a registered template in one step. Params (pass as input): className, name, path, templateId.epic(epic_create_graph)- [Epic DataflowAgent.DataflowAgentToolset] Creates a new saved Dataflow graph asset. Params (pass as input): name, path.epic(epic_create_level_instance)- [Epic editor_toolset.toolsets.scene.SceneTools] Creates a Level Instance actor in the scene referencing an existing level asset. Args: level_path: The content path to the level asset (e.g. '/Game/Maps/MyLevel'). name: The label for the new Level Instance actor. xform: The transform for the new actor. parent: If set, the new actor will be a child of this actor. Returns: The created LevelInstance actor. Params (pass as input): level_path, name, xform, parent?.epic(epic_create_plugin)- [Epic PluginToolset.PluginToolset] Creates a new plugin from a template and loads it into the editor. Use GetPluginTemplateDescriptions to obtain a valid TemplateInfo. Params (pass as input): pluginName, relativePluginLocation, bPlaceInEngine, templateInfo, description.epic(epic_create_skill)- [Epic ToolsetRegistry.AgentSkillToolset] Creates a new AgentSkill. This should ONLY be called after getting explicit direction or permission from the user. Params (pass as input): folderPath, assetName, description, details.epic(epic_delete_folder)- [Epic editor_toolset.toolsets.scene.SceneTools] Deletes a folder from the outliner. Actors directly in the folder are moved to the parent folder. Sub-folders and their actors are preserved by re-rooting them under the parent. For example, deleting 'Lighting' with a sub-folder 'Lighting/Spotlights' leaves 'Spotlights' intact under the parent. Args: folder_path: The folder path to delete (e.g. 'Lighting/Spotlights'). Returns: The number of actors that were moved. Params (pass as input): folder_path.epic(epic_disconnect_node_pins)- [Epic DataflowAgent.DataflowAgentToolset] Removes the connection between two node pins. Params (pass as input): fromNode, fromPin, toNode, toPin.epic(epic_discover_tests)- [Epic AutomationTestToolset.AutomationTestToolset] Initialize automation worker discovery and load the test list. Must be called once before ListTests or RunTests. Takes several seconds as it discovers the local automation worker and enumerates all registered tests. Returns an async result that completes with a JSON status object when tests are available, or an error if discovery fails. Params (pass as input): bForceRediscover?.epic(epic_drag)- [Epic SlateInspectorToolset.SlateInspectorToolset] Drag from one Slate widget to another (mouse down, move, release). Params (pass as input): startRef, endRef, modifiers?.epic(epic_edit_level_instance)- [Epic editor_toolset.toolsets.scene.SceneTools] Opens a level instance for editing. While in edit mode, scene tools such as add_to_scene_from_class and remove_from_scene operate within the level instance's sub-level. Only one level instance can be in edit mode at a time. Call commit_level_instance when done to save or discard changes. Args: level_instance: The level instance actor to open for editing. Params (pass as input): level_instance.epic(epic_execute_tool_script)- [Epic editor_toolset.toolsets.programmatic.ProgrammaticToolset] Execute a Python script against the toolset APIs. Use this to batch multiple tool calls into a single script execution, reducing round-trips and context usage. IMPORTANT: Available modules and usage instructions are described by the value returned byget_execution_environment. You MUST callget_execution_environmentonce in the conversation before using this tool. Read the value in theinstructionsfield in the returned environment info prior to calling this function, so that you understand what APIs are available and how to use them. Before writing a script that calls multiple tools, look up the output schemas (if available) for any tools you plan to use. This returns the JSON schema describing each tool's return value, so you know how to parse results and pass data between calls. Args: script: Python script to execute. Must define arun()function that returns aDict[str, Any]. Returns: JSON-encoded dict returned by the script'srun()function. Raises: SyntaxError: If the script has invalid syntax. ValueError: If the script imports a disallowed module or does not define arun()function. TypeError: Ifrun()does not return a dict. Exception: Any unhandled exception raised by the script. Params (pass as input): script.epic(epic_fill_form)- [Epic SlateInspectorToolset.SlateInspectorToolset] Fill multiple Slate form fields at once. Params (pass as input): fields.epic(epic_find_actors)- [Epic editor_toolset.toolsets.scene.SceneTools] Searches the scene for actors that match specific criteria. Args: root: If set, will only search this actor and its children. name: If set, will only return actors whose label contains this string (case-insensitive). actor_type: If set, will only return actors that are of this type. tag: If set, will only return actors that have this tag. bounds: If set, only returns actors whose bounds overlap this world-space AABB. collision_channels: If set, bounds checks will uses a native physics overlap query restricted to these channels. Non-collision actors will be ignored. Returns: A list of actors that match the criteria. Params (pass as input): root?, name, actor_type?, tag, bounds?, collision_channels.epic(epic_find_similar)- [Epic SemanticSearchToolset.SemanticSearchToolset] Find assets whose embeddings are semantically similar to the given asset's embedding. Vector-only (no BM25). The source asset must already be indexed by the SemanticSearch plugin. Params (pass as input): assetPath, classFilter, pathRegexes, k?.epic(epic_focus_on_actors)- [Epic EditorToolset.EditorAppToolset] Repositions the level editor camera to focus on the specified actors. Cannot be called while PIE is active. Params (pass as input): actors.epic(epic_generate_convex_collisions)- [Epic editor_toolset.toolsets.static_mesh.StaticMeshTools] Generates convex hull collision shapes for a static mesh. Convex hulls provide accurate collision for physics simulation. More hulls improve accuracy but increase runtime cost. Replaces any existing collision. Args: mesh: The static mesh asset to modify. hull_count: The number of convex hulls to generate. max_hull_verts: The maximum number of vertices per hull. hull_precision: Controls the voxel precision of the decomposition. Returns: True if convex collision was generated successfully. Params (pass as input): mesh, hull_count?, max_hull_verts?, hull_precision?.epic(epic_generate_lods)- [Epic editor_toolset.toolsets.static_mesh.StaticMeshTools] Auto-generates LODs for a static mesh using triangle reduction. Each entry in triangle_percents creates one additional LOD. The value is the fraction of triangles to keep relative to LOD 0, from just above 0.0 (nearly empty) to 1.0 (full detail). For example, [0.5, 0.25] creates LOD1 with 50% of the original triangles and LOD2 with 25%. Args: mesh: The static mesh asset to modify. triangle_percents: Triangle retention fraction for each generated LOD. Returns: The total number of LODs after the operation, including LOD 0. Params (pass as input): mesh, triangle_percents.epic(epic_get_actors_in_folder)- [Epic editor_toolset.toolsets.scene.SceneTools] Returns the actors in the specified outliner folder. Args: folder_path: The folder path to query (e.g. 'Lighting/Spotlights'). recursive: If True, also includes actors in sub-folders. Returns: A list of actors in the specified folder. Params (pass as input): folder_path, recursive?.epic(epic_get_all_nodes)- [Epic conversation_toolset.toolsets.conversation.ConversationTools] Returns all reachable nodes in the conversation. Use ObjectTools.get_class and get_properties on each node to inspect type and properties. Each node's GUID is available via its compiled_node_guid attribute. Args: conversation: The ConversationDatabase asset. Returns: A list of UConversationNode UObjects. Params (pass as input): conversation.epic(epic_get_blackboard)- [Epic aimodule_toolset.toolsets.behavior_tree.BehaviorTreeTools] Returns the blackboard asset for this behavior tree. Args: behavior_tree: The BehaviorTree asset to query. Returns: The BlackboardData asset. Params (pass as input): behavior_tree.epic(epic_get_bone_children)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Returns the direct children of a bone. Args: mesh: The skeletal mesh asset to query. bone_name: The name of the bone to query. Returns: A list of direct child bone names, or an empty list for leaf bones. Params (pass as input): mesh, bone_name.epic(epic_get_bone_names)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Returns the names of all bones in a skeletal mesh in hierarchy order. Bone names are used to target specific bones for socket attachment, physics constraints, and animation retargeting. Args: mesh: The skeletal mesh asset to query. Returns: A list of bone names in skeleton order (root first). Params (pass as input): mesh.epic(epic_get_bone_parent)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Returns the name of a bone's parent, or an empty string for the root bone. Args: mesh: The skeletal mesh asset to query. bone_name: The name of the bone to query. Returns: The parent bone name, or '' if the bone is the root. Params (pass as input): mesh, bone_name.epic(epic_get_bounds)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Returns the local-space bounding volume of a skeletal mesh. The bounds represent the reference pose and do not account for animation. Args: mesh: The skeletal mesh asset to query. Returns: The local-space bounding volume as a combined box and sphere. Params (pass as input): mesh.epic(epic_get_bounds__static_mesh_tools)- [Epic editor_toolset.toolsets.static_mesh.StaticMeshTools] Returns the local-space bounding box of a static mesh. Args: mesh: The static mesh asset to query. Returns: The local-space axis-aligned bounding box. Params (pass as input): mesh.epic(epic_get_camera_transform)- [Epic EditorToolset.EditorAppToolset] Returns the position and rotation of the level viewport camera. Params: none.epic(epic_get_children)- [Epic aimodule_toolset.toolsets.behavior_tree.BehaviorTreeTools] Returns direct child nodes of a composite node. Args: composite: A BTCompositeNode (Selector, Sequence, etc.). Returns: A list of child BTNode UObjects. Params (pass as input): composite.epic(epic_get_class)- [Epic editor_toolset.toolsets.object.ObjectTools] Returns the class of an Unreal object. Args: instance: The object instance to query. Returns: The class of the object. Params (pass as input): instance.epic(epic_get_collision_channels)- [Epic editor_toolset.toolsets.scene.SceneTools] Returns all available collision channels for use with find_actors. Returns: A list of all collision channels. Params: none.epic(epic_get_condition_description)- [Epic WorldConditionsToolset.WorldConditionTools] Returns a human-readable description of a single world condition. The condition must be passed as an FInstancedStruct containing an FWorldConditionBase-derived struct. Params (pass as input): condition.epic(epic_get_content_browser_path)- [Epic EditorToolset.EditorAppToolset] Gets the current path of the active content browser. Params: none.epic(epic_get_current_level)- [Epic editor_toolset.toolsets.scene.SceneTools] Returns the path to the current level asset. Returns: The name of the loaded level, if any. Params: none.epic(epic_get_entry)- [Epic editor_toolset.toolsets.string_table.StringTableTools] Returns the source string for a specific key. Args: string_table: The StringTable asset to query. key: The key whose string value to retrieve. Returns: The source string for the key. Params (pass as input): string_table, key.epic(epic_get_execution_environment)- [Epic editor_toolset.toolsets.programmatic.ProgrammaticToolset] Get details about execution environment. This includes instructions on how to write scripts, and constraints, such as what modules may be imported and the script entrypoint and function signature. Returns: Returns the current execution environment. Params: none.epic(epic_get_folders)- [Epic editor_toolset.toolsets.scene.SceneTools] Returns all folder paths currently in use in the outliner. Includes all intermediate parent paths. For example, if an actor is assigned to 'Lighting/Spotlights', both 'Lighting' and 'Lighting/Spotlights' are returned. Returns: A sorted list of unique folder path strings. Params: none.epic(epic_get_game_feature_state)- [Epic GameFeaturesToolset.GameFeaturesToolset] Gets the current state of a Game Feature Plugin. Params (pass as input): pluginName.epic(epic_get_graph_structure)- [Epic DataflowAgent.DataflowAgentToolset] Returns the complete structure of a Dataflow graph including all nodes and connections. Params (pass as input): graph.epic(epic_get_lod_count)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Returns the number of LODs in a skeletal mesh asset. Args: mesh: The skeletal mesh asset to query. Returns: The number of LODs. Params (pass as input): mesh.epic(epic_get_lod_count__static_mesh_tools)- [Epic editor_toolset.toolsets.static_mesh.StaticMeshTools] Returns the number of LODs in a static mesh asset. Args: mesh: The static mesh asset to query. Returns: The number of LODs. Params (pass as input): mesh.epic(epic_get_lod_thresholds)- [Epic editor_toolset.toolsets.static_mesh.StaticMeshTools] Returns the screen-size thresholds at which each LOD becomes active. Screen size is a ratio of the mesh's screen height to the viewport height. A value of 1.0 means the mesh fills the full viewport height; values above 1.0 are valid and mean the mesh must appear larger than the viewport before the next LOD activates. Each LOD activates when the mesh appears smaller than its threshold. Args: mesh: The static mesh asset to query. Returns: A list of screen-size threshold values, one per LOD. Params (pass as input): mesh.epic(epic_get_log_categories)- [Epic EditorToolset.LogsToolset] Returns a sorted list of registered log categories. Params (pass as input): filter.epic(epic_get_log_entries)- [Epic EditorToolset.LogsToolset] Returns log entries from the current session's log file. Params (pass as input): category?, pattern, maxEntries?.epic(epic_get_material)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Returns the material assigned to a named slot on a skeletal mesh. Args: mesh: The skeletal mesh asset to query. slot_name: The name of the material slot to query. Returns: The material assigned to the slot. Params (pass as input): mesh, slot_name.epic(epic_get_material__static_mesh_tools)- [Epic editor_toolset.toolsets.static_mesh.StaticMeshTools] Returns the material assigned to a named slot on a static mesh. Args: mesh: The static mesh asset to query. slot_name: The name of the material slot to query. Returns: The material assigned to the slot. Params (pass as input): mesh, slot_name.epic(epic_get_material_slots)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Returns the names of all material slots in a skeletal mesh. Material slot names are used when assigning materials to specific parts of the mesh. Use these names with get_material and set_material. Args: mesh: The skeletal mesh asset to query. Returns: A list of material slot names. Params (pass as input): mesh.epic(epic_get_material_slots__static_mesh_tools)- [Epic editor_toolset.toolsets.static_mesh.StaticMeshTools] Returns the names of all material slots in a static mesh. Material slot names are used when assigning materials to specific parts of the mesh. Use these names with get_material and set_material. Args: mesh: The static mesh asset to query. Returns: A list of material slot names. Params (pass as input): mesh.epic(epic_get_morph_target_names)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Returns the names of all morph targets on a skeletal mesh. Morph targets (blend shapes) are per-vertex offsets used to deform the mesh, commonly used for facial expressions and cloth simulation. Args: mesh: The skeletal mesh asset to query. Returns: A list of morph target names, or an empty list if none exist. Params (pass as input): mesh.epic(epic_get_namespace)- [Epic editor_toolset.toolsets.string_table.StringTableTools] Returns the namespace of a StringTable asset. Args: string_table: The StringTable asset to query. Returns: The namespace string. Params (pass as input): string_table.epic(epic_get_node_by_guid)- [Epic conversation_toolset.toolsets.conversation.ConversationTools] Returns a conversation node by its GUID. Args: conversation: The ConversationDatabase asset. guid: The GUID (from get_node_guids or entry_points). Returns: The UConversationNode. Params (pass as input): conversation, guid.epic(epic_get_node_connections)- [Epic conversation_toolset.toolsets.conversation.ConversationTools] Returns output connection GUIDs for a conversation node. Args: node: The conversation node to query. Returns: A list of FGuid output connections. Params (pass as input): node.epic(epic_get_node_depth)- [Epic aimodule_toolset.toolsets.behavior_tree.BehaviorTreeTools] Returns the tree depth of a node by its list_nodes index. Args: behavior_tree: The BehaviorTree asset. node_index: Zero-based index into list_nodes output. Returns: The tree depth (0 = root level). Params (pass as input): behavior_tree, node_index.epic(epic_get_node_depths)- [Epic aimodule_toolset.toolsets.behavior_tree.BehaviorTreeTools] Returns tree depths for all nodes, matching list_nodes order. Args: behavior_tree: The BehaviorTree asset. Returns: A list of depth integers. Params (pass as input): behavior_tree.epic(epic_get_node_guids)- [Epic conversation_toolset.toolsets.conversation.ConversationTools] Returns GUIDs of all reachable nodes, in map iteration order. Use with get_node_by_guid to look up specific nodes. Args: conversation: The ConversationDatabase asset. Returns: A list of FGuid structs. Params (pass as input): conversation.epic(epic_get_node_info)- [Epic DataflowAgent.DataflowAgentToolset] Returns information about a node as a JSON object (name, type, position, pins). Params (pass as input): node.epic(epic_get_node_type_schema)- [Epic DataflowAgent.DataflowAgentToolset] Returns the schema for a Dataflow node type including its input/output pins and editable UPROPERTY parameters. Params (pass as input): typeName.epic(epic_get_open_assets)- [Epic EditorToolset.EditorAppToolset] Gets the list of assets currently open in asset editors. Params: none.epic(epic_get_physics_asset)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Returns the physics asset assigned to a skeletal mesh. The physics asset defines the collision bodies and constraints used for ragdoll simulation and per-bone physics. Args: mesh: The skeletal mesh asset to query. Returns: The physics asset assigned to this mesh. Params (pass as input): mesh.epic(epic_get_plugin_dependencies)- [Epic PluginToolset.PluginToolset] Returns the dependency entries from a plugin's Plugins array in its .uplugin file. Params (pass as input): pluginName.epic(epic_get_plugin_dependents)- [Epic PluginToolset.PluginToolset] Returns the names of all discovered plugins that declare a dependency on the given plugin. Params (pass as input): pluginName.epic(epic_get_plugin_descriptor)- [Epic PluginToolset.PluginToolset] Gets the editable descriptor fields for a discovered plugin. Params (pass as input): pluginName.epic(epic_get_plugin_for_asset)- [Epic PluginToolset.PluginToolset] Returns the name of the enabled plugin whose content mount point contains the given asset path. Accepts full asset paths or mount point prefixes (e.g. /PluginName/ or /Game/Path/To/Asset). Params (pass as input): assetPath.epic(epic_get_plugin_info)- [Epic PluginToolset.PluginToolset] Gets metadata for a discovered plugin, including description, version, base directory, content directory, descriptor path, and mounted asset path. Params (pass as input): pluginName.epic(epic_get_plugin_template_descriptions)- [Epic PluginToolset.PluginToolset] Returns the list of available plugin templates. Pass one of the results to CreatePlugin to create a new plugin from that template. Params: none.epic(epic_get_properties)- [Epic editor_toolset.toolsets.object.ObjectTools] Returns the values of one or more properties on an object. Args: instance: The the object to query. properties: The names of the properties to query. Returns: A JSON formatted string of the properties and their values. Params (pass as input): instance, properties.epic(epic_get_query_description)- [Epic WorldConditionsToolset.WorldConditionTools] Returns a human-readable description of a world condition query. Params (pass as input): queryDefinition.epic(epic_get_root_decorators)- [Epic aimodule_toolset.toolsets.behavior_tree.BehaviorTreeTools] Returns root-level decorators on this tree. Args: behavior_tree: The BehaviorTree asset to query. Returns: A list of BTDecorator UObjects. Params (pass as input): behavior_tree.epic(epic_get_rows)- [Epic editor_toolset.toolsets.data_table.DataTableTools] Returns the column values for one or more rows as a JSON string. Args: data_table: The DataTable to query. row_names: The names of the rows to retrieve. Returns: A JSON object mapping each row name to an object of property names and values. Params (pass as input): data_table, row_names.epic(epic_get_schema)- [Epic editor_toolset.toolsets.data_table.DataTableTools] Returns the column schema of the data table as a JSON string. Args: data_table: The DataTable to query. Returns: A JSON formatted string mapping column names to their type info. Params (pass as input): data_table.epic(epic_get_section_count)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Returns the number of sections in a specific LOD of a skeletal mesh. Sections correspond to individual material slots rendered by a single draw call. A mesh may have more sections than material slots if multiple sections share the same material. Args: mesh: The skeletal mesh asset to query. lod_index: The LOD index to query. Defaults to 0 (highest quality). Returns: The number of sections in the specified LOD. Params (pass as input): mesh, lod_index?.epic(epic_get_section_property_values)- [Epic ConfigSettingsToolset.ConfigSettingsToolset] Returns the current values of the specified properties as a JSON object. Raises an error if the section does not exist, has no settings object, or any requested property cannot be read. Params (pass as input): containerName, categoryName, sectionName, propertyNames.epic(epic_get_section_schema)- [Epic ConfigSettingsToolset.ConfigSettingsToolset] Returns a JSON Schema describing the user-visible properties of a settings section. The schema maps each property name to its type, description, and constraints. Raises an error if the section does not exist or has no backing settings object (e.g. uses a custom widget instead). Params (pass as input): containerName, categoryName, sectionName.epic(epic_get_selected_actors)- [Epic EditorToolset.EditorAppToolset] Gets the currently selected actors in the level editor. Params: none.epic(epic_get_selected_assets)- [Epic EditorToolset.EditorAppToolset] Gets the list of assets selected in the content browser. Params: none.epic(epic_get_size)- [Epic editor_toolset.toolsets.texture.TextureTools] Returns the dimensions of a Texture2D in pixels. Args: texture: The Texture2D to query. Returns: A vector x is the width and y is the height, both in pixels. Params (pass as input): texture.epic(epic_get_skeleton)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Returns the skeleton asset associated with a skeletal mesh. The skeleton defines the bone hierarchy shared across all meshes and animations that use it. Args: mesh: The skeletal mesh asset to query. Returns: The skeleton asset bound to this mesh. Params (pass as input): mesh.epic(epic_get_skills)- [Epic ToolsetRegistry.AgentSkillToolset] Returns detailed information about a specific set of AgentSkills. Params (pass as input): skillPaths.epic(epic_get_socket_bone)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Returns the name of the bone that a socket is attached to. Args: mesh: The skeletal mesh asset to query. socket_name: The name of the socket to query. Returns: The name of the parent bone. Params (pass as input): mesh, socket_name.epic(epic_get_socket_names)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Returns the names of all sockets on a skeletal mesh. Sockets are named attachment points parented to bones. They are used to attach weapons, accessories, or effects at a consistent location. Args: mesh: The skeletal mesh asset to query. Returns: A list of socket names, or an empty list if none exist. Params (pass as input): mesh.epic(epic_get_socket_transform)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Returns the local transform of a socket relative to its parent bone. Args: mesh: The skeletal mesh asset to query. socket_name: The name of the socket to query. Returns: The socket's local transform (translation, rotation, scale). Params (pass as input): mesh, socket_name.epic(epic_get_sub_nodes)- [Epic conversation_toolset.toolsets.conversation.ConversationTools] Returns sub-nodes (requirements, choices) attached to a task node. Args: node: The conversation task node to query. Returns: A list of UConversationSubNode UObjects. Params (pass as input): node.epic(epic_get_subtree)- [Epic aimodule_toolset.toolsets.behavior_tree.BehaviorTreeTools] Returns the sub-BT asset referenced by a RunBehavior task. Args: node: Any BTNode. Only RunBehavior tasks have a subtree. Returns: The referenced BehaviorTree asset. Raises: ValueError: If the node does not reference a subtree. Params (pass as input): node.epic(epic_get_table_id)- [Epic editor_toolset.toolsets.string_table.StringTableTools] Returns the table ID for a StringTable asset. The table ID is derived from the asset's package path and is used to reference the string table in text properties and localisation. Args: string_table: The StringTable asset to query. Returns: The table ID as a string. Params (pass as input): string_table.epic(epic_get_test_results)- [Epic AutomationTestToolset.AutomationTestToolset] Get detailed results for the current or most recent test run. Requires DiscoverTests() to have completed. Returns a JSON object with per-test state, duration, errors, and warnings. Params: none.epic(epic_get_test_status)- [Epic AutomationTestToolset.AutomationTestToolset] Get a lightweight status snapshot of the automation controller. Requires DiscoverTests() to have completed. Returns a JSON object with the controller state, enabled test count, and completion/pass/fail counts. Params: none.epic(epic_get_triangle_count)- [Epic editor_toolset.toolsets.static_mesh.StaticMeshTools] Returns the number of triangles in a specific LOD of a static mesh. Args: mesh: The static mesh asset to query. lod_index: The LOD index to query. Defaults to 0 (highest quality). Returns: The number of triangles in the specified LOD. Params (pass as input): mesh, lod_index?.epic(epic_get_verbosity)- [Epic EditorToolset.LogsToolset] Returns the current verbosity level for a log category. Params (pass as input): category?.epic(epic_get_vertex_count)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Returns the number of vertices in a specific LOD of a skeletal mesh. Args: mesh: The skeletal mesh asset to query. lod_index: The LOD index to query. Defaults to 0 (highest quality). Returns: The number of vertices in the specified LOD. Params (pass as input): mesh, lod_index?.epic(epic_get_vertex_count__static_mesh_tools)- [Epic editor_toolset.toolsets.static_mesh.StaticMeshTools] Returns the number of vertices in a specific LOD of a static mesh. Args: mesh: The static mesh asset to query. lod_index: The LOD index to query. Defaults to 0 (highest quality). Returns: The number of vertices in the specified LOD. Params (pass as input): mesh, lod_index?.epic(epic_get_visible_actors)- [Epic EditorToolset.EditorAppToolset] Returns all actors in the current level whose bounds intersect the viewport frustum. Params: none.epic(epic_hover)- [Epic SlateInspectorToolset.SlateInspectorToolset] Hover over a Slate widget, triggering any hover state or tooltip. Params (pass as input): ref.epic(epic_import_file)- [Epic editor_toolset.toolsets.data_table.DataTableTools] Imports a file from disk as a DataTable asset. The file's columns must match the property names in schema. Use search_row_structs to discover usable schema structs. Args: folder_path: The content-browser folder to create the asset in. asset_name: The name of the new asset. source_file: The absolute path to the source file on disk. schema: The struct that defines the columns of the table. Must be a subclass of TableRowBase. Returns: The assets produced by the import (typically a single DataTable). Params (pass as input): folder_path, asset_name, source_file, schema.epic(epic_import_file__skeletal_mesh_tools)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Imports a mesh file from disk as a SkeletalMesh asset. The source file must contain a skeleton hierarchy and skinned mesh data. Args: folder_path: The content-browser folder to create the asset in. asset_name: The name of the new asset. source_file: The absolute path to the source mesh file on disk. skeleton: An existing skeleton to bind the imported mesh to. When None, a new Skeleton asset is created alongside the mesh. import_materials: When True, create Material assets for any materials referenced in the file. When False, the imported mesh has no materials assigned. import_textures: When True, create Texture2D assets for any textures referenced by the imported materials. Only effective when import_materials is True. import_animations: When True, create AnimSequence assets for any animations contained in the file. create_physics_asset: When True, create a PhysicsAsset bound to the imported mesh's skeleton. Returns: The assets produced by the import. The first entry is the imported SkeletalMesh; additional entries may include a newly created Skeleton (when none was supplied), a PhysicsAsset, AnimSequences, Materials, and Texture2Ds, depending on which options are enabled. Params (pass as input): folder_path, asset_name, source_file, skeleton?, import_materials?, import_textures?, import_animations?, create_physics_asset?.epic(epic_import_file__static_mesh_tools)- [Epic editor_toolset.toolsets.static_mesh.StaticMeshTools] Imports a mesh file from disk as a StaticMesh asset. Args: folder_path: The content-browser folder to create the asset in. asset_name: The name of the new asset. source_file: The absolute path to the source mesh file on disk. import_materials: When True, create Material assets for any materials referenced in the file. When False, the imported meshes have no materials assigned. import_textures: When True, create Texture2D assets for any textures referenced by the imported materials. Only effective when import_materials is True. combine_meshes: When True, all meshes in the file are merged into a single StaticMesh. When False, each mesh in the file produces its own StaticMesh asset. Returns: The assets produced by the import. The first entry is the primary StaticMesh; additional entries may include extra StaticMeshes (when combine_meshes is False) and Material/Texture assets (when the corresponding import flags are True). Params (pass as input): folder_path, asset_name, source_file, import_materials?, import_textures?, combine_meshes?.epic(epic_import_file__string_table_tools)- [Epic editor_toolset.toolsets.string_table.StringTableTools] Imports a file from disk as a StringTable asset. The file must have a header row with at least 'Key' and 'SourceString' columns. Additional meta-data columns are imported but the namespace is not - the StringTable's namespace is derived from its asset path. Args: folder_path: The content-browser folder to create the asset in. asset_name: The name of the new asset. source_file: The absolute path to the source file on disk. Returns: The assets produced by the import (a single StringTable). Params (pass as input): folder_path, asset_name, source_file.epic(epic_import_file__texture_tools)- [Epic editor_toolset.toolsets.texture.TextureTools] Imports an image file from disk as a Texture2D asset. Args: folder_path: The content-browser folder to create the asset in. asset_name: The name of the new asset. source_file: The absolute path to the source image file on disk. Returns: The assets produced by the import (typically a single Texture2D). Params (pass as input): folder_path, asset_name, source_file.epic(epic_is_checked_out)- [Epic editor_toolset.toolsets.scene.SceneTools] Checks whether an actor is checked out by the current user. Args: actor: The actor to check. Returns: True if the actor is currently checked out by the current user. Params (pass as input): actor.epic(epic_is_enabled)- [Epic PluginToolset.PluginToolset] Checks whether a discovered plugin is currently enabled. Params (pass as input): pluginName.epic(epic_is_game_feature_active)- [Epic GameFeaturesToolset.GameFeaturesToolset] Checks whether a Game Feature Plugin is active. Raises an error if the subsystem is unavailable or the plugin is not found. Use GetGameFeatureState if you need the current state when the plugin is not active. Params (pass as input): pluginName.epic(epic_is_game_feature_plugin)- [Epic GameFeaturesToolset.GameFeaturesToolset] Return whether or not a plugin is a Game Feature Plugin. Will error if no plugin of this name can be found by the Plugin Manager. Params (pass as input): pluginName.epic(epic_is_nanite_enabled)- [Epic editor_toolset.toolsets.static_mesh.StaticMeshTools] Returns whether Nanite is enabled for a static mesh. Nanite is Unreal's virtualized geometry system that renders highly detailed meshes efficiently. It is most beneficial for meshes with many triangles. Args: mesh: The static mesh asset to query. Returns: True if Nanite is enabled for this mesh. Params (pass as input): mesh.epic(epic_is_pierunning)- [Epic EditorToolset.EditorAppToolset] Returns whether a Play In Editor session is currently running. Params: none.epic(epic_is_plugin_creation_allowed)- [Epic PluginToolset.PluginToolset] Checks whether the editor settings permit plugin creation from the plugin browser. Params: none.epic(epic_is_plugin_modification_allowed)- [Epic PluginToolset.PluginToolset] Checks whether the editor settings permit modifying plugins from the plugin browser. Params: none.epic(epic_list_categories)- [Epic ConfigSettingsToolset.ConfigSettingsToolset] Lists the names of all categories within a settings container, sorted alphabetically. Raises an error if the container does not exist. Params (pass as input): containerName.epic(epic_list_containers)- [Epic ConfigSettingsToolset.ConfigSettingsToolset] Lists the names of all known settings containers, sorted alphabetically. Common containers are "Editor" and "Project". Params: none.epic(epic_list_dataflow_compatible_asset_types)- [Epic DataflowAgent.DataflowAgentToolset] Returns a JSON list of every UClass that can host an embedded Dataflow graph (i.e. implements IDataflowInstanceInterface). Each entry has "className", "displayName", and "modulePath" fields. Use the "className" value as input to CreateDataflowCompatibleAsset or ListDataflowTemplatesForAssetClass. Params: none.epic(epic_list_dataflow_templates_for_asset_class)- [Epic DataflowAgent.DataflowAgentToolset] Returns a JSON list of Dataflow templates registered for the given asset class. Templates registered for parent classes are included (class hierarchy walk). Params (pass as input): className, bIncludeBlank?.epic(epic_list_discovered_game_feature_plugins)- [Epic GameFeaturesToolset.GameFeaturesToolset] Lists all discovered Game Feature Plugins sorted by name. This includes enabled and disabled plugins. Only enabled plugins are known by the Game Features system beyond identifying if a plugin is a Game Feature Plugin. Use the Plugins toolset to do general plugin enable/disable tasks. Params: none.epic(epic_list_discovered_plugins)- [Epic PluginToolset.PluginToolset] Lists the names of all discovered plugins (enabled and disabled), sorted alphabetically. Params: none.epic(epic_list_enabled_game_feature_plugins)- [Epic GameFeaturesToolset.GameFeaturesToolset] Lists all enabled Game Feature Plugins sorted by name. Enabled plugins are the only plugins known by the Game Features system beyond identifying if a plugin is a Game Feature Plugin. Use the Plugins toolset to do general plugin enable/disable tasks. Params: none.epic(epic_list_enabled_plugins)- [Epic PluginToolset.PluginToolset] Lists the names of all enabled plugins, sorted alphabetically. Params: none.epic(epic_list_entry_points)- [Epic conversation_toolset.toolsets.conversation.ConversationTools] Returns entry points (FConversationEntryList structs). Args: conversation: The ConversationDatabase asset. Returns: A list of FConversationEntryList structs. Params (pass as input): conversation.epic(epic_list_keys)- [Epic editor_toolset.toolsets.string_table.StringTableTools] Lists all keys in the string table. Args: string_table: The StringTable asset to query. Returns: A list of key strings. Params (pass as input): string_table.epic(epic_list_node_types)- [Epic DataflowAgent.DataflowAgentToolset] Returns a JSON list of all registered Dataflow node types. Params (pass as input): bCommonOnly?.epic(epic_list_nodes)- [Epic aimodule_toolset.toolsets.behavior_tree.BehaviorTreeTools] Returns a flat list of all node UObjects in tree order. Order: root decorators, then DFS (composite, services, per-child decorators, child node). Args: behavior_tree: The BehaviorTree asset to inspect. Returns: A list of BTNode UObjects. Params (pass as input): behavior_tree.epic(epic_list_observers)- [Epic SlateInspectorToolset.SlateInspectorToolset] List all active observers as a JSON array for debugging. Each entry includes the observer identifier, whether it is the root observer, the root widget ref (if any), max depth, and cached snapshot size. Params: none.epic(epic_list_properties)- [Epic editor_toolset.toolsets.object.ObjectTools] Returns a list of properties that are on the specified object. Args: instance: The object to query. Returns: A list of properties on the object. Params (pass as input): instance.epic(epic_list_rows)- [Epic editor_toolset.toolsets.data_table.DataTableTools] Lists the names of all rows in the data table. Args: data_table: The DataTable to query. Returns: A list of row names. Params (pass as input): data_table.epic(epic_list_sections)- [Epic ConfigSettingsToolset.ConfigSettingsToolset] Lists the names of all sections within a settings category, sorted alphabetically. Raises an error if the container or category does not exist. Params (pass as input): containerName, categoryName.epic(epic_list_skills)- [Epic ToolsetRegistry.AgentSkillToolset] Gets a summary of all AgentSkills in the project. Params: none.epic(epic_list_speakers)- [Epic conversation_toolset.toolsets.conversation.ConversationTools] Returns speaker/participant information. Args: conversation: The ConversationDatabase asset. Returns: A list of FCommonDialogueBankParticipant structs. Params (pass as input): conversation.epic(epic_list_tests)- [Epic AutomationTestToolset.AutomationTestToolset] List available automation tests. Requires DiscoverTests() to have completed. Returns a JSON object: {"tests": ["path1", ...], "total": N, "returned": N}. Params (pass as input): nameFilter, tagFilter, limit?.epic(epic_list_variables)- [Epic DataflowAgent.DataflowAgentToolset] Returns all variables defined on the Dataflow graph as a JSON array. Each entry contains "name", "type", and "value" fields. Params (pass as input): graph.epic(epic_load_level)- [Epic editor_toolset.toolsets.scene.SceneTools] Loads a level in the editor. Args: level_path: The path to the level asset. Params (pass as input): level_path.epic(epic_merge_actors)- [Epic editor_toolset.toolsets.scene.SceneTools] Merges multiple StaticMesh actors into a single mesh asset and actor. Args: actors: The StaticMeshActors to merge. All must be in the same level. output_path: Content path for the merged mesh asset (e.g. '/Game/Meshes/Merged'). name: Label for the new merged actor. Defaults to the last segment of output_path. destroy_source_actors: If True, removes the source actors after merging. Returns: The merged StaticMeshActor. Params (pass as input): actors, output_path, name, destroy_source_actors?.epic(epic_observe)- [Epic SlateInspectorToolset.SlateInspectorToolset] Register an observer on a widget subtree so its refs are continuously kept up to date (~100ms tick). Call this on the window or panel you are about to work with. It ensures new widgets appearing in that subtree are assigned refs automatically. Unobserve when you are done. A shallow root observer (depth 0) already covers top-level windows. Params (pass as input): ref, maxDepth?.epic(epic_open_editor_for_asset)- [Epic EditorToolset.EditorAppToolset] Opens an asset editor for the specified asset. Params (pass as input): assetPath.epic(epic_press_key)- [Epic SlateInspectorToolset.SlateInspectorToolset] Press and release a keyboard key on the currently focused Slate widget. Supports modifier prefixes: "Ctrl+C", "Shift+1". Params (pass as input): key.epic(epic_remove_collisions)- [Epic editor_toolset.toolsets.static_mesh.StaticMeshTools] Removes all collision shapes from a static mesh. Args: mesh: The static mesh asset to modify. Returns: True if all collision shapes were removed. Params (pass as input): mesh.epic(epic_remove_comment_box)- [Epic DataflowAgent.DataflowAgentToolset] Removes a comment box node from the graph. Params (pass as input): graph, commentId.epic(epic_remove_entry)- [Epic editor_toolset.toolsets.string_table.StringTableTools] Removes an entry from the string table. Args: string_table: The StringTable asset to modify. key: The key of the entry to remove. Params (pass as input): string_table, key.epic(epic_remove_from_scene)- [Epic editor_toolset.toolsets.scene.SceneTools] Deletes an actor from the scene. Args: actor: The actor to remove. Returns: True if the actor was removed. Params (pass as input): actor.epic(epic_remove_lods)- [Epic editor_toolset.toolsets.static_mesh.StaticMeshTools] Removes all auto-generated LODs from a static mesh, keeping only LOD 0. Args: mesh: The static mesh asset to modify. Returns: True if LODs were removed successfully. Params (pass as input): mesh.epic(epic_remove_node)- [Epic DataflowAgent.DataflowAgentToolset] Removes a node and all its connections from the Dataflow graph. Params (pass as input): graph, node.epic(epic_remove_plugin_dependency)- [Epic PluginToolset.PluginToolset] Removes a dependency entry from a plugin's Plugins array in its .uplugin file. Params (pass as input): pluginName, dependencyName.epic(epic_remove_rows)- [Epic editor_toolset.toolsets.data_table.DataTableTools] Removes rows from the data table. Args: data_table: The DataTable to modify. row_names: The names of the rows to remove. Params (pass as input): data_table, row_names.epic(epic_remove_socket)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Removes a named socket from a skeletal mesh. Args: mesh: The skeletal mesh asset to modify. socket_name: The name of the socket to remove. Returns: True if the socket was removed successfully. Params (pass as input): mesh, socket_name.epic(epic_remove_variable)- [Epic DataflowAgent.DataflowAgentToolset] Removes a variable from the Dataflow graph. Params (pass as input): graph, name.epic(epic_rename_folder)- [Epic editor_toolset.toolsets.scene.SceneTools] Renames a folder in the outliner. Updates the folder path for all actors in the folder and any sub-folders. For example, renaming 'Lighting' to 'Lights' also updates actors in 'Lighting/Spotlights' to 'Lights/Spotlights'. If the new path already exists then the affected actors will be merged into it. Args: old_path: The current folder path (e.g. 'Lighting'). new_path: The new folder path (e.g. 'Lights'). Returns: The number of actors whose folder path was updated. Params (pass as input): old_path, new_path.epic(epic_rename_rows)- [Epic editor_toolset.toolsets.data_table.DataTableTools] Renames one or more rows in the data table. Args: data_table: The DataTable to modify. renames: A mapping of existing row names to their new names. Params (pass as input): data_table, renames.epic(epic_rename_socket)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Renames a socket on a skeletal mesh. Args: mesh: The skeletal mesh asset to modify. old_name: The current name of the socket. new_name: The new name to give the socket. Returns: True if the socket was renamed successfully. Params (pass as input): mesh, old_name, new_name.epic(epic_reposition_node)- [Epic DataflowAgent.DataflowAgentToolset] Moves a node to a new position in the graph editor. Params (pass as input): node, x, y.epic(epic_request_activate_game_feature)- [Epic GameFeaturesToolset.GameFeaturesToolset] Requests activation of a Game Feature Plugin. Returns true if the activation request was submitted successfully. The actual activation happens asynchronously -- poll GetGameFeatureState() or IsGameFeatureActive() to confirm completion. Raises an error if the subsystem is unavailable or the plugin is not found. Params (pass as input): pluginName.epic(epic_request_deactivate_game_feature)- [Epic GameFeaturesToolset.GameFeaturesToolset] Requests deactivation of a Game Feature Plugin. Returns true if the deactivation request was submitted successfully. The actual deactivation happens asynchronously -- poll GetGameFeatureState() to confirm completion. Raises an error if the subsystem is unavailable or the plugin is not found. Params (pass as input): pluginName.epic(epic_reset_properties)- [Epic editor_toolset.toolsets.object.ObjectTools] Resets one or more properties on an object to their default values, removing any per-instance overrides. Args: instance: The object with the properties to reset. properties: The names of the properties to reset to their defaults. Returns: True if all properties were reset. False otherwise. Params (pass as input): instance, properties.epic(epic_reset_section_to_defaults)- [Epic ConfigSettingsToolset.ConfigSettingsToolset] Resets the settings in a section to their default values. Raises an error if the section does not exist or reset is not supported. Params (pass as input): containerName, categoryName, sectionName.epic(epic_run_tests)- [Epic AutomationTestToolset.AutomationTestToolset] Run a set of automation tests by name. Requires DiscoverTests() to have completed. Starts executing the specified tests and returns an async result that completes with a JSON summary when all tests finish. Params (pass as input): testNames.epic(epic_run_tests_by_filter)- [Epic AutomationTestToolset.AutomationTestToolset] Run automation tests selected by a filter expression. Requires DiscoverTests() to have completed. Much faster than RunTests when targeting a large batch because the engine narrows the report tree in a single pass instead of running a per-leaf membership check against the requested name list. Filter syntax (multiple expressions joined by '+'): "StartsWith:System.Engine" prefix match against the full test path "^Foo" prefix anchor (equivalent to StartsWith:) "Bar$" suffix anchor "Substring" bare token matches anywhere in the path "Group:Smoke" expand a named group from AutomationControllerSettings ini Groups Returns an async result that completes with the same JSON summary as RunTests. Params (pass as input): filterExpression.epic(epic_save_actor)- [Epic editor_toolset.toolsets.scene.SceneTools] Saves the actor to disk. Args: actor: The actor to save. Params (pass as input): actor.epic(epic_save_section)- [Epic ConfigSettingsToolset.ConfigSettingsToolset] Saves the settings in a section. Raises an error if the section does not exist or saving is not supported. Params (pass as input): containerName, categoryName, sectionName.epic(epic_screen_coords_to_world)- [Epic EditorToolset.EditorAppToolset] Finds the world position of the nearest solid object at a given set of normalized view space coords. Params (pass as input): coords, traceDistance?.epic(epic_screenshot)- [Epic SlateInspectorToolset.SlateInspectorToolset] Screenshot a Slate widget or the active editor window. Prefer this over SceneTools.take_screenshot for Editor UI; use SceneTools only for 3D viewport. Params (pass as input): ref.epic(epic_search)- [Epic SemanticSearchToolset.SemanticSearchToolset] Run a semantic search over the Content Browser assets indexed by the SemanticSearch plugin. Params (pass as input): query, classFilter, pathRegexes, k?.epic(epic_search_cvars)- [Epic EditorToolset.EditorAppToolset] Finds all console variables that contain a given name. Params (pass as input): name.epic(epic_search_row_structs)- [Epic editor_toolset.toolsets.data_table.DataTableTools] Finds structs that can be used as a DataTable schema. Args: struct_name: If set, will filter structs by name using wildcard match. Returns: A list of structs derived from TableRowBase that match the criteria. Params (pass as input): struct_name?.epic(epic_search_subclasses)- [Epic editor_toolset.toolsets.object.ObjectTools] Finds all subclasses of a given class. Args: base_class: The class to search subclasses of. class_name: Optional case-insensitive substring filter on the class path. Returns: A list of subclasses matching the filter. Params (pass as input): base_class, class_name.epic(epic_select_actors)- [Epic EditorToolset.EditorAppToolset] Selects the specified actors in the current scene. Params (pass as input): actors.epic(epic_select_assets)- [Epic EditorToolset.EditorAppToolset] Selects the specified assets in the content browser. Completes once the content browser has applied the selection. Params (pass as input): assetPaths.epic(epic_select_option)- [Epic SlateInspectorToolset.SlateInspectorToolset] Select an option in a Slate combobox by its text label. Opens the dropdown, finds the matching text, and clicks it. Params (pass as input): ref, value.epic(epic_set_actor_folder)- [Epic editor_toolset.toolsets.scene.SceneTools] Assigns an actor to the specified folder in the outliner. Creates the folder implicitly if it does not already exist. Pass an empty string to move the actor to the root of the outliner. Args: actor: The actor to move. folder_path: The folder path to assign (e.g. 'Lighting/Spotlights'). Pass an empty string to move the actor to the root. Params (pass as input): actor, folder_path.epic(epic_set_camera_transform)- [Epic EditorToolset.EditorAppToolset] Sets the position and rotation of the level viewport camera. Params (pass as input): transform.epic(epic_set_content_browser_path)- [Epic EditorToolset.EditorAppToolset] Navigates the active content browser to the specified folder path. Params (pass as input): path.epic(epic_set_entry)- [Epic editor_toolset.toolsets.string_table.StringTableTools] Adds or updates an entry in the string table. If the key already exists its value is replaced; otherwise a new entry is created. Args: string_table: The StringTable asset to modify. key: The key for the entry. value: The source string value for the entry. Params (pass as input): string_table, key, value.epic(epic_set_lod_thresholds)- [Epic editor_toolset.toolsets.static_mesh.StaticMeshTools] Sets the screen-size thresholds at which each LOD becomes active. Screen size is a ratio of the mesh's screen height to the viewport height. A value of 1.0 means the mesh fills the full viewport height; values above 1.0 are valid and mean the mesh must appear larger than the viewport before the next LOD activates. Thresholds must be in strictly descending order (LOD 0 has the largest threshold), and there must be exactly one threshold per LOD. Args: mesh: The static mesh asset to modify. thresholds: Screen-size threshold values, one per LOD, in descending order. Returns: True if the thresholds were applied successfully. Params (pass as input): mesh, thresholds.epic(epic_set_material)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Assigns a material to a named slot on a skeletal mesh asset. This affects all instances of the mesh that do not override the slot material. Args: mesh: The skeletal mesh asset to modify. slot_name: The name of the material slot to assign to. material: The material to assign. Returns: True if the material was assigned successfully. Params (pass as input): mesh, slot_name, material.epic(epic_set_material__static_mesh_tools)- [Epic editor_toolset.toolsets.static_mesh.StaticMeshTools] Assigns a material to a named slot on a static mesh asset. This affects all instances of the mesh that do not override the slot material. Use set_component_material_override to change materials on a single instance. Args: mesh: The static mesh asset to modify. slot_name: The name of the material slot to assign to. material: The material to assign. Returns: True if the material was assigned successfully. Params (pass as input): mesh, slot_name, material.epic(epic_set_nanite_enabled)- [Epic editor_toolset.toolsets.static_mesh.StaticMeshTools] Enables or disables Nanite for a static mesh. Changing this setting triggers a mesh rebuild. Nanite is most beneficial for high-polygon meshes. Low-polygon meshes may not benefit from Nanite. Args: mesh: The static mesh asset to modify. enabled: True to enable Nanite, False to disable it. Params (pass as input): mesh, enabled.epic(epic_set_plugin_enabled)- [Epic PluginToolset.PluginToolset] Enables or disables a plugin in the project config. The change takes effect on the next editor restart. Params (pass as input): pluginName, bEnabled.epic(epic_set_properties)- [Epic editor_toolset.toolsets.object.ObjectTools] Sets the values of properties on an object. Args: instance: The object with the property. values: A JSON formatted string of the properties to set and their values. For instanced sub-object properties, pass a class path as the instance member. Returns: True if the property was set. False otherwise. Params (pass as input): instance, values.epic(epic_set_rows)- [Epic editor_toolset.toolsets.data_table.DataTableTools] Sets column values for one or more rows. Args: data_table: The DataTable to modify. values: A JSON object mapping row names to objects of camelCase property names and values to update. Only specified properties are updated; others remain unchanged. Params (pass as input): data_table, values.epic(epic_set_section_properties)- [Epic ConfigSettingsToolset.ConfigSettingsToolset] Sets one or more properties on a settings section from a JSON object and saves. PropertiesJson must be a JSON object mapping property names to new values, in the same format returned by GetSectionPropertyValues. Raises an error if the section does not exist, cannot be edited, has no settings object, the default config file is not writable, or any property cannot be set. Params (pass as input): containerName, categoryName, sectionName, propertiesJson.epic(epic_set_socket_transform)- [Epic editor_toolset.toolsets.skeletal_mesh.SkeletalMeshTools] Sets the local transform of a socket relative to its parent bone. Args: mesh: The skeletal mesh asset to modify. socket_name: The name of the socket to modify. transform: The new local transform for the socket. Params (pass as input): mesh, socket_name, transform.epic(epic_set_variable)- [Epic DataflowAgent.DataflowAgentToolset] Sets the value of an existing variable using its serialized string representation. The format depends on the variable's type (e.g., "3.14" for float, "true" for bool, "42" for int, "MyName" for FName). Params (pass as input): graph, name, value.epic(epic_set_verbosity)- [Epic EditorToolset.LogsToolset] Sets the verbosity level for a log category. Params (pass as input): category?, verbosity.epic(epic_snapshot)- [Epic SlateInspectorToolset.SlateInspectorToolset] Capture a Slate UI accessibility snapshot. Use this to read the current widget tree and discover refs for action tools (Click, Type, Hover, etc.). A shallow root observer (depth 0) covers top-level windows automatically. Before interacting with a specific window or panel, call Observe() on it to get deep coverage, then Snapshot that subtree to see its contents. Refs discovered by a previous Snapshot remain usable. You do NOT need to call Snapshot again before every action. Params (pass as input): ref, maxDepth?, bIncludeSourceLocations?.epic(epic_start_pie)- [Epic EditorToolset.EditorAppToolset] Starts a Play-In-Editor or Simulate-In-Editor session using the current level. Completes after the engine fires PostPIEStarted (session fully started, BeginPlay called) and Options.WarmupSeconds have elapsed, giving project- specific initialization (services, authentication, plugin warmup) time to settle before the agent inspects state or logs. Raises an error if a play session is already running. Params (pass as input): options.epic(epic_stop_pie)- [Epic EditorToolset.EditorAppToolset] Stops the currently running play session (PIE or Simulate). Raises an error if no play session is running. Params: none.epic(epic_stop_tests)- [Epic AutomationTestToolset.AutomationTestToolset] Stop all currently running tests. Requires DiscoverTests() to have completed. If a RunTests async result is pending, it will be completed with an error. Params: none.epic(epic_trace_world)- [Epic editor_toolset.toolsets.scene.SceneTools] Traces a line through the world and returns the distance to the first hit. Args: start: The start point of the trace in world space. end: The end point of the trace in world space. Returns: The distance from start to the hit point, or None if nothing was hit. Params (pass as input): start, end.epic(epic_type)- [Epic SlateInspectorToolset.SlateInspectorToolset] Type text into a Slate text input widget. Focuses the widget first, then sends one key event per character. Params (pass as input): ref, text, submit?.epic(epic_unobserve)- [Epic SlateInspectorToolset.SlateInspectorToolset] Remove an observer by its identifier. Params (pass as input): identifier.epic(epic_update_node)- [Epic DataflowAgent.DataflowAgentToolset] Updates an existing node's editable properties via JSON. Params (pass as input): node, jsonParams.epic(epic_update_plugin_descriptor)- [Epic PluginToolset.PluginToolset] Updates a plugin's descriptor fields and writes them to its .uplugin file. Checks out the file via source control if source control is enabled. No-ops if the serialized descriptor is unchanged (file is not touched). Params (pass as input): pluginName, newDescriptor.epic(epic_update_skill)- [Epic ToolsetRegistry.AgentSkillToolset] Updates an existing AgentSkill. This should ONLY be called after getting explicit direction or permission from the user. Params (pass as input): skillPath, description, details.epic(epic_validate_new_plugin_name_and_location)- [Epic PluginToolset.PluginToolset] Validates that PluginName and RelativePluginLocation are acceptable for a new plugin. Params (pass as input): pluginName, relativePluginLocation, bPlaceInEngine, templateInfo.epic(epic_wait_for)- [Epic SlateInspectorToolset.SlateInspectorToolset] Check if text is present or absent in the Slate widget tree. Non-blocking: checks once and returns immediately. Poll to wait. Params (pass as input): text, textGone.epic(epic_windows)- [Epic SlateInspectorToolset.SlateInspectorToolset] List, select, or close top-level Slate editor windows. Params (pass as input): action?, index?.epic(epic_world_pos_to_screen_coords)- [Epic EditorToolset.EditorAppToolset] Converts a world-space position into normalized screen space based on the editor viewport camera. Params (pass as input): position.