UnrealEngine
CtrlK
  • Home
  • Unreal Engine
  • Code
  • News
  • Help Center
  • Become a Code angel
    • Get Started
    • What is Unreal Engine Blueprint?
    • What is Unreal Engine C++ API
    • Why one over the Other?
  • Blueprints
    • Event System & Execution Flow
      • What fires first? What’s an Event Tick?
      • Nodes that control logic: Branch, Sequence, DoOnce
    • Variables & Data Types
      • Understanding Bool, Float, Struct, etc.
      • Editable, Expose on Spawn, etc.
    • Functions vs Macros vs Events
      • When to use each
      • Pure vs Impure nodes
    • Blueprint Communication (Interface, Casting, Events)
      • Interfaces, Casting, and Event Dispatchers
      • When to use what
      • Direct vs loosely coupled messaging
    • Construction Scripts
      • Generating logic at editor time
      • Mesh placements, previews, logic baking
    • Blueprint Inheritance
      • Parent blueprints
      • Inheriting variables, logic
      • Child → Parent overrides
    • Timeline, Curves & Lerp
      • Smooth movement, animations
      • Creating and using float curves, vector curves
    • Async Loading, Latent Actions
      • Using Delay, Async Load Asset, Load Stream Level
      • Preventing logic blocking
    • Debugging Tools for Blueprints
      • Breakpoints, Print String, Watches
      • Execution flow visualizer
  • C++ Programming
    • Project Setup & Build.cs Basics
      • Creating Your First C++ Project
      • Understanding .Target.cs and .Build.cs Files
      • Managing Third-Party Dependencies
      • Module Rules & Folder Structure Best Practices
    • UObject, AActor, UComponent Breakdown
      • Understanding the UObject System
      • Difference Between AActor, UObject, UComponent
      • Lifecycle of Actors & Components
      • When to Use What (UObject vs Actor vs SceneComponent)
    • Memory Management & Smart Pointers
      • Garbage Collection in UE (UObject-based)
      • Raw vs Smart Pointers (TSharedPtr, TWeakPtr, TUniquePtr)
      • New/Delete vs NewObject()/ConstructObject()
      • Memory Debugging Tips
    • C++ to Blueprint Exposure (UPROPERTY, UFUNCTION)
      • UPROPERTY Deep Dive: Flags, Meta Tags, Categories
      • UFUNCTION Breakdown: BlueprintCallable, BlueprintPure, NetMulticast etc.
      • Best Practices for Exposing Systems to Blueprint
      • Custom Events and BlueprintImplementable Functions
    • Gameplay Framework (GameMode, PlayerController, etc.)
      • GameMode, GameState, PlayerController - Responsibilities
      • Pawn vs Character vs SpectatorPawn
      • GameInstance: Global State Across Levels
      • Subsystems: GameInstanceSubsystem, WorldSubsystem, etc.
    • Custom Actors & Components
      • Creating a Custom Actor (With Inputs & Meshes)
      • Creating Custom Scene Components (Reusable Gameplay)
      • Tick Functions and Actor Lifecycles
      • Spawning and Managing Actors Dynamically
    • Editor Extensions with C++
      • Creating Custom Editor Tabs & Tools
      • Custom Asset Types and Details Panels
      • Slate vs UMG: When and How to Use
      • Editor Utility Widgets + Automation Tools
    • Logging, Debugging, and Performance Profiling
      • UE_LOG, Custom Log Categories, and Verbosity
      • Using Breakpoints and Visual Studio Debugger with UE
      • Unreal Insights, Stat Commands, and GPU Profiler
      • Trace System and Bottleneck Analysis
  • Editor Scripting (Python & C++)
    • Python Editor Basics
      • Setting up Python in Unreal
      • Using the Output Log & Scripting Console
      • Running scripts manually or on startup
      • Use case: Quick asset replacement script to save hours
    • Accessing Assets, Levels, Actors
      • Navigating and modifying the Content Browser via Python
      • Accessing and changing actors in the level
      • Loading/saving assets with scripting
      • Use case: Auto-load and validate level contents for daily reviews
    • Batch Editing, Mass Rename, Auto Setup
      • Mass renaming conventions with regex or rules
      • Auto-pivot setups, batch material assignment, asset tagging
      • Scene cleanup and automation logic
      • Page 1
    • Custom Menus, Toolbars, and Commands
      • Creating new menu entries and buttons with Python/C++
      • Binding custom tools to shortcuts or right-click menus
      • Registering/unregistering menus properly
      • Use case: Add a one-click “Scene Validator” button in the main toolbar
    • Creating Custom Editor Widgets
      • Intro to Slate (C++) and Editor Utility Widgets (BP)
      • Using PySide/PyQt or Unreal’s native systems for UI
      • Data display, editable fields, dynamic interaction
      • se case: Build a light manager with toggles, color pickers, etc.
    • Exposing Tools to Artists (via UI or scripts)
      • Making tools idiot-proof 🥹 (checkboxes, dropdowns, sanity checks)
      • Using commandlets or UI bridges
      • Logging and error handling
      • Use case: Tool that lets an artist “select all foliage and re-center pivots” via UI
    • Editor Utility Widgets (BP + Python Hybrid)
      • When to use BP vs Python
      • Building hybrid tools (logic in Python, interface in BP)
      • Deployment tips + sharing with teams
      • Use case: An in-editor UI that lets you spawn pre-set level blocks with rules
  • Data Handling (Structs, Tables, Curves, Assets)
    • Creating Structs & Enums
      • What Are Structs and Enums in Unreal?
      • Creating Structs (BP + C++)
      • Structs in UPROPERTY & Functions
      • Nested Structs & Advanced Struct Design
      • Creating Enums (Scoped & Traditional)
      • Enum Usage in Switches and UI
      • Best Practices: Versioning Structs
    • Data Tables (CSV/JSON import)
      • What is a DataTable in Unreal?
      • Creating & Importing from CSV/JSON
      • Reading DataTables in BP and C++
      • Struct Linking with Tables
      • Iterating and Searching Tables
      • Localized Data Tables
      • Editing Tables in the Editor
    • Curve Assets (Float/Vector/Rich)
      • Introduction to Curve Assets (Float, Vector, Rich)
      • Creating and Editing Curve Assets
      • Using Curves in Blueprints
      • Using Curves in C++ Logic
      • Timeline vs Curve Assets
      • Driving Gameplay Systems with Curves (e.g. XP growth, camera shake, AI behavior)
    • Using Data Assets for Configs
      • What Are Data Assets?
      • Creating PrimaryDataAsset Subclasses
      • Using Data Assets for Game Configs (Weapons, Enemies, Levels)
      • Linking Data Assets to Blueprints
      • Data Assets vs Data Tables: When to Use What
      • Inheritance in Data Assets
    • SaveGame System & Serialization
      • SaveGame Class Basics
      • Storing Player Stats & Inventory
      • Binary vs JSON Save Formats
      • Save Slots and Versioning
      • Autosave & Load Game Flow
      • Custom Serialization (Advanced)
    • Custom Asset Types
      • Why Create Custom Assets?
      • Making a New Asset Type in C++
      • Defining How It Appears in the Editor
      • Custom Thumbnails, Context Menus, and Icons
      • Using Custom Assets in Gameplay Systems
    • Content-Only Systems (No Code Required)
      • Building Data-Driven Features Using Just BP & Assets
      • BP-Only Systems with Structs, Tables, Curves
      • Replacing Switches with Data Assets for Flexibility
      • Organizing Content-Only Projects
      • Scaling & Balancing Without Touching Code
  • Creating Custom Plugins
    • Plugin Folder Structure
    • Making Engine/Editor/Runtime Plugins
      • Runtime Plugin
      • Editor Plugin
      • Engine Plugin
    • Plugin Descriptor (uplugin)
    • Using Modules (Public vs Private)
    • Blueprint Function Libraries as Plugins
    • Packaging Plugins for Sharing/Marketplace
    • Licensing, Folder Structure Best Practices
  • Performance & Optimization (Code-Side)
    • CPU vs GPU Bound Explanation
      • What it means to be CPU-bound or GPU-bound
      • How to identify bottlenecks in either
      • Common symptoms in Unreal
      • Profiling tools: Stat Unit, GPU Profiler, Insights
    • Async Programming & Multithreading
      • Difference between async and multi-threading
      • AsyncTask, FRunnable, FQueuedThreadPool
      • Ensuring thread safety (mutexes, TAtomic, etc.)
      • Common pitfalls in game dev async code
    • Garbage Collection Tips
      • How UE4/UE5 Garbage Collector works
      • UObject lifecycle
      • UPROPERTY() macros and GC interaction
      • Avoiding memory leaks and dangling references
      • When to use TWeakObjectPtr, TSharedPtr, TUniquePtr
    • Tick Optimization (Timers, Conditions)
      • Avoiding heavy Tick() functions
      • Alternatives: FTimerHandle, FDelegateHandle, Conditional Tick
      • Pausing, throttling, or removing unnecessary ticks
      • Best practices for actors/components with Tick
    • Logging & Stats System
      • Using UE_LOG with categories and verbosity levels
      • Creating custom log channels
      • Using STAT, DECLARE_CYCLE_STAT, SCOPE_CYCLE_COUNTER
      • Unreal Insights for detailed profiling
    • Packaging for Different Platforms
      • Optimization considerations per target (mobile, desktop, console)
      • Cooked content vs runtime-loaded assets
      • Compression settings and asset sizes
      • Platform-specific settings in .ini files
  • Advanced Patterns
    • ECS (Entity Component Systems) in Unreal
      • Creating your own lightweight ECS (for gameplay logic)
      • When & why to use ECS in Unreal (vs Actor model)
      • Using Mass Framework (UE5+)
    • Behavior Trees from Code
      • Setting up Behavior Trees via C++
      • Creating custom nodes (Task, Decorator, Services)
      • Injecting data from code into BT runtime
      • Using AIController to bridge between Pawn & Tree
    • Service-Driven Architecture (Game Services)
      • Creating singleton-style game services (audio, quests, UI…)
      • How to register, call, and manage services cleanly
      • Benefits: modularity, reusability, clean up project architecture
    • Finite State Machines (in C++/BP)
      • Creating FSM with Enums or State Classes
      • Implementing State Transitions & Conditions
      • Driving FSM from AnimBlueprint or Game Logic
      • Visual FSM Debugging
    • Event Bus / Observer Pattern
      • How to decouple classes with event buses
      • Creating a simple observer system with delegates/events
      • se cases: UI updates, player events, gameplay triggers
    • Data-Driven Design
      • Moving behavior logic into configs (structs, tables, curves)
      • Reducing code clutter by empowering designers
      • Making scalable & reusable gameplay systems
  • REAL USE CASES
    • How to [Do Something] to [Something]
      • Intro
    • LET’S MAKE A...
      • Intro
    • Help Us
Powered by GitBook
On this page
  1. Editor Scripting (Python & C++)

Python Editor Basics

Setting up Python in UnrealUsing the Output Log & Scripting ConsoleRunning scripts manually or on startupUse case: Quick asset replacement script to save hours
PreviousEditor Scripting (Python & C++)NextSetting up Python in Unreal