unreal

unreal._redirect_warning(message, category, filename, lineno, file=None, line=None)

unreal.find_asset(name: str, type: Union[Class, type] = Object.static_class(), follow_redirectors: bool = True) → Any -- find an already loaded Unreal asset with the given name, optionally validating its type

unreal.find_object(outer: Optional[Object], name: str, type: Union[Class, type] = Object.static_class(), follow_redirectors: bool = True) → Any -- find an already loaded Unreal object with the given outer and name, optionally validating its type

unreal.find_package(name: str) → Optional[Package] -- find an already loaded Unreal package with the given name

unreal.flush_generated_type_reinstancing() → None -- flush any pending reinstancing requests for Python generated types

unreal.generate_class(class_type: type) → None -- generate an Unreal class for the given Python type

unreal.generate_enum(enum_type: type) → None -- generate an Unreal enum for the given Python type

unreal.generate_struct(struct_type: type) → None -- generate an Unreal struct for the given Python type

unreal.get_blueprint_generated_types(paths: Iterable[str]) -> Optional[Union[type, Tuple[type, ...]]] -- get the Python types (will return a tuple for multiple types) for the given set of Blueprint asset paths (may be a sequence type or set of arguments)

unreal.get_default_object(type: Union[Class, type]) → Any -- get the Unreal class default object (CDO) of the given type

unreal.get_editor_subsystem(subsystem: Union[Class, type[_EditorSubsystemTypeVar]]) → Optional[_EditorSubsystemTypeVar] -- returns the requested Editor subsystem or None

unreal.get_engine_subsystem(subsystem: Union[Class, type[_EngineSubsystemTypeVar]]) → Optional[_EngineSubsystemTypeVar] -- returns the requested Engine subsystem or None

unreal.get_interpreter_executable_path() → str -- get the path to the Python interpreter executable of the Python SDK this plugin was compiled against

unreal.get_type_from_class(class_: Class) → type -- get the best matching Python type for the given Unreal class

unreal.get_type_from_enum(enum: Enum) → type -- get the best matching Python type for the given Unreal enum

unreal.get_type_from_struct(struct: Struct) → type -- get the best matching Python type for the given Unreal struct

unreal.is_editor() → bool -- tells if the editor is running or not

unreal.load_asset(name: str, type: Union[Class, type] = Object.static_class(), follow_redirectors: bool = True) → Any -- load an Unreal asset with the given name, optionally validating its type

unreal.load_class(outer: Optional[Object], name: str, type: Union[Class, type] = Object.static_class()) → Optional[Class] -- load an Unreal class with the given outer and name, optionally validating its base type

unreal.load_module(module: str) → None -- load the given Unreal module and generate any Python code for its reflected types

unreal.load_object(outer: Optional[Object], name: str, type: Union[Class, type] = Object.static_class(), follow_redirectors: bool = True) → Any -- load an Unreal object with the given outer and name, optionally validating its type

unreal.load_package(name: str) → Optional[Package] -- load an Unreal package with the given name

unreal.LOCTABLE(id: Union[Name, str], key: str) → Text -- get a localized Text from the given string table id and key

unreal.log(arg: Any) → None -- log the given argument as information in the LogPython category

unreal.log_error(arg: Any) → None -- log the given argument as an error in the LogPython category

unreal.log_flush() → None -- flush the log to disk.

unreal.log_warning(arg: Any) → None -- log the given argument as a warning in the LogPython category

unreal.new_object(type: Union[Class, type], outer: Optional[Object] = None, name: Union[Name, str] = '', base_type: Optional[Object] = None) → Any -- create an Unreal object of the given class (and optional outer and name), optionally validating its type

unreal.NSLOCTEXT(ns: str, key: str, source: str) → Text -- create a localized Text from the given namespace, key, and source string

unreal.parent_external_window_to_slate(external_window_handle: object, parent_search_method: SlateParentWindowSearchMethod = SlateParentWindowSearchMethod.ACTIVE_WINDOW) → None -- parent the given OS specific external window handle to a suitable Slate window

unreal.purge_object_references(obj: Object, include_inners: bool = True) → None -- purge all references to the given Unreal object from any living Python objects

unreal.register_python_shutdown_callback(callable: Callable[[], None]) → object -- register the given callable (with no input arguments) as a callback to execute immediately before Python shutdown

unreal.register_slate_post_tick_callback(callable: Union[Callable[[float], None], DelegateBase]) → object -- register the given callable (taking a single float) as a pre-tick callback in Slate

unreal.register_slate_pre_tick_callback(callable: Union[Callable[[float], None], DelegateBase]) → object -- register the given callable (taking a single float) as a pre-tick callback in Slate

unreal.reload(module: str) → None -- reload the given Unreal Python module.

unreal.uclass()

decorator used to define UClass types from Python

unreal.uenum()

decorator used to define UEnum types from Python

unreal.ufunction(meta=None, ret=None, params=None, override=None, static=None, pure=None, getter=None, setter=None)

decorator used to define UFunction fields from Python

unreal.unregister_python_shutdown_callback(handle: object) → None -- unregister the given handle from a previous call to register_python_shutdown_callback

unreal.unregister_slate_post_tick_callback(handle: object) → None -- unregister the given handle from a previous call to register_slate_post_tick_callback

unreal.unregister_slate_pre_tick_callback(handle: object) → None -- unregister the given handle from a previous call to register_slate_pre_tick_callback

unreal.uproperty(type, meta=None, getter=None, setter=None)

function used to define UProperty fields from Python

unreal.ustruct()

decorator used to define UStruct types from Python

unreal.uvalue(val, meta=None)

function used to define constant values from Python