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. Data Handling (Structs, Tables, Curves, Assets)
  2. Custom Asset Types

Custom Thumbnails, Context Menus, and Icons

PreviousDefining How It Appears in the EditorNextUsing Custom Assets in Gameplay Systems