🎭 Actors and Components

What is an Actor?

Imagine you're setting up a stage for a play. You need props—a table, a chair, a lamp. You need lighting—spotlights, ambient fixtures. You need sound—speakers for background music and sound effects. You might even need invisible elements like trigger zones that cue the next scene. In Unreal Engine, every single one of these elements—visible or invisible—is called an Actor.

The term "Actor" comes from the theater metaphor we mentioned—just as a play has actors on stage, your game level has Actors in the world. But unlike human actors who can only play one role, Unreal Actors are incredibly flexible. A single Actor might be a static prop, or it might be an enemy character with AI, or a door that opens when you approach it.

Everything is an Actor

When you look at your level in the Unreal Editor, nearly everything you see (and many things you don't see) is an Actor:

• Visible Actors: 3D models (Static Mesh Actors), particle effects, decals, text renders, skeletal meshes (animated characters)
• Lighting Actors: Directional lights (sun), point lights, spot lights, sky lights, rect lights
• Audio Actors: Ambient sound actors, audio components, sound cues
• Gameplay Actors: Player start points, triggers, volumes, spawn points, cameras
• Invisible Helpers: Collision volumes, navigation meshes, reflection captures, atmospheric elements

Actors in the Outliner

Every Actor placed in your level appears in the Outliner panel (typically on the right side of the editor). The Outliner is like a cast list for your stage—it shows every Actor present in the current level, organized hierarchically.

Figure: The Outliner panel showing various Actors organized hierarchically. The selected Actor (Floor) is highlighted.

When you select an Actor in the Outliner, it becomes highlighted in the viewport, and its properties appear in the Details panel. This three-way connection—Outliner, Viewport, and Details—is how you'll interact with Actors constantly while building your levels.

Actor Properties

Every Actor has a set of properties that define its behavior and appearance. When you select an Actor and look at the Details panel, you'll see categories like:

• Transform: Location, Rotation, and Scale—where the Actor is, how it's oriented, and how big it is
• Rendering: Whether the Actor is visible, casts shadows, or affects reflections
• Collision: How the Actor interacts with physics and other Actors
• Actor-specific properties: Settings unique to that type of Actor (light intensity for lights, sound volume for audio Actors, etc.)

Changing these properties in the Details panel immediately updates how the Actor behaves and appears in your level.

Figure: The relationship between Actors and the editor panels

The Actor-Component Model

Here's where Unreal's design becomes truly elegant. Rather than having thousands of different specialized Actor types that each do one specific thing, Unreal uses a modular system called the Actor-Component Model. This is one of the most important concepts to understand in Unreal Engine.

What are Components?

A Component is a piece of functionality that you can attach to an Actor to give it specific capabilities. Think of Components like accessories or attachments—each one adds a particular feature to the base Actor.

Let's use a concrete example. Imagine you want to create a lamp Actor in your level. What does a lamp need?

• A Static Mesh Component to display the lamp's 3D model
• A Point Light Component to actually emit light
• Maybe a Particle System Component if you want glowing dust particles around the bulb
• Maybe an Audio Component if the lamp hums or buzzes

Instead of having a specialized "LampActor" class in the engine, you take a base Actor and attach these Components to it. The Actor itself is just a container—the Components are what give it functionality.

Figure: The Details panel showing an Actor's Components. Each Component (Static Mesh, Point Light, Particle System, Audio) adds different capabilities to the lamp Actor.

Figure: A lamp Actor composed of multiple Components

Why This Model is Powerful

The Actor-Component model provides several huge advantages:

1. Flexibility: You can mix and match Components to create exactly the behavior you need without being limited to pre-defined Actor types
2. Reusability: The same Components can be used across many different Actors. The Light Component that illuminates your lamp works the same way in a streetlight, a torch, or a glowing crystal
3. Organization: Each Component handles one specific aspect of functionality, making the system easier to understand and debug
4. Extensibility: You can create custom Components with unique behaviors and attach them to any Actor

Common Component Types

Unreal Engine comes with dozens of built-in Component types. Here are the most commonly used ones you'll encounter:

When you create a Blueprint or place an Actor in your level, you're working with this Component system whether you realize it or not. Understanding this foundation helps you appreciate how Unreal gives you building blocks instead of rigid, pre-defined objects.

Common Actor Types

While all Actors share the same fundamental structure (containers for Components), Unreal provides many pre-configured Actor classes that come with commonly-used Component setups. These are the Actor types you'll place in your levels most frequently.

Static Mesh Actor

The workhorse of level building. A Static Mesh Actor displays a 3D model that doesn't animate or deform (hence "static"). Buildings, rocks, furniture, vehicles, props—if it's a solid, non-animated object, it's typically a Static Mesh Actor.

• Default Components: Static Mesh Component
• Common uses: Environment geometry, props, decorations
• Performance note: Static meshes can be batched together for efficient rendering

Light Actors

These Actors emit light to illuminate your level. There are several types:

• Directional Light: Simulates sunlight—parallel rays that illuminate everything equally
• Point Light: Emits light in all directions from a single point (like a lightbulb)
• Spot Light: Emits a cone of light in one direction (like a flashlight)
• Rect Light: Emits light from a rectangular surface (like a window or TV screen)

We'll cover lighting in depth in Module 4, but for now, know that these are essential for making your levels visible and establishing mood.

Camera Actor

Defines a viewpoint in your level. During gameplay, the player's view is rendered from a camera. Camera Actors are also used for:

• Cutscenes and cinematics
• Security camera views
• Alternative perspective switches
• Testing composition and framing

Trigger Volumes and Collision Actors

These are invisible gameplay elements that detect when players or other Actors enter, exit, or overlap them:

• Trigger Box: A box-shaped volume that fires events when something enters it
• Trigger Sphere: A spherical trigger volume
• Blocking Volume: An invisible wall that prevents movement through an area

You'll use these extensively for gameplay logic—opening doors, starting cutscenes, spawning enemies, etc.

Blueprint Actors

These are custom Actors you create using Unreal's visual scripting system (Blueprints). They can combine any Components you want with custom logic. We'll dive deep into Blueprints in Module 5, but examples include:

• Interactive doors that open and close
• Collectible items that disappear when touched
• Moving platforms
• Enemy characters with AI behavior

Figure: Common Actor types you'll work with in Unreal Engine. Each serves a specific purpose in building your levels.

Transform Properties: Location, Rotation, and Scale

Every Actor in your level exists in 3D space, and three fundamental properties define exactly where it is, how it's oriented, and how big it is. Together, these properties are called the Transform.

Understanding 3D Coordinates

Before diving into transforms, you need to understand how Unreal represents 3D space. Like most 3D applications, Unreal uses a three-axis coordinate system:

Figure: Unreal Engine's 3D coordinate system. X (red) = forward/back, Y (green) = left/right, Z (blue) = up/down.

• X-axis (Red): Forward and backward (positive X = forward)
• Y-axis (Green): Left and right (positive Y = right)
• Z-axis (Blue): Up and down (positive Z = up)

Location

Location defines where the Actor is positioned in 3D space using X, Y, and Z coordinates. Each value is measured in centimeters from the world origin (0, 0, 0).

Examples:

• Location: (0, 0, 0) - At the world origin
• Location: (500, 0, 0) - 5 meters forward (500cm) from the origin
• Location: (0, -300, 200) - 3 meters left and 2 meters up from the origin

When you move an Actor in the viewport using the move gizmo (we'll cover that next), you're changing its Location values.

Rotation

Rotation defines how the Actor is oriented in 3D space. Instead of X, Y, Z coordinates, rotation uses three angles measured in degrees: Roll, Pitch, and Yaw.

Figure: The three types of rotation. Roll (X-axis), Pitch (Y-axis), and Yaw (Z-axis) control how an Actor is oriented in space.

• Roll (X-axis): Rotation around the forward/backward axis—like an airplane banking left or right
• Pitch (Y-axis): Rotation around the left/right axis—like an airplane's nose going up or down
• Yaw (Z-axis): Rotation around the up/down axis—like turning your head left or right

In the Details panel, you'll see rotation displayed as (X=0, Y=0, Z=0) where each value is in degrees. A value of 0 means no rotation, 90 means a quarter turn, 180 is a half turn, and 360 is a full rotation back to the starting position.

Scale

Scale controls the size of the Actor. Like Location, it uses X, Y, and Z values, but these represent multipliers rather than distances.

• Scale: (1, 1, 1) - Original size (100%)
• Scale: (2, 2, 2) - Twice as large in all dimensions (200%)
• Scale: (0.5, 0.5, 0.5) - Half size (50%)
• Scale: (1, 2, 1) - Normal width/height, but stretched to double length along Y-axis

Figure: Different scale values. Uniform scaling (equal X, Y, Z) maintains proportions, while non-uniform scaling can distort the Actor.

Pivot Points and Transform Gizmos

Now that you understand what transforms are, let's look at how you actually manipulate them in the Unreal Editor using visual tools called gizmos.

What is a Pivot Point?

Every Actor has a pivot point (also called the "origin" or "anchor point")—a specific point within or around the Actor that defines where its Location is measured from and where rotations occur around.

Think of a door. A door rotates around its hinges, not around its center. In 3D terms, the door's pivot point would be placed at the hinge location. When you rotate the door Actor, it swings open naturally around that pivot.

Figure: Pivot point placement matters! A door with its pivot at the hinge rotates correctly, while a center pivot creates unrealistic movement.

Pivot points are usually set in your 3D modeling software before importing assets into Unreal. For most objects, the pivot is at the base center (for characters and props) or at a functionally important point (like hinges for doors, axles for wheels).

Transform Gizmos

Gizmos are the colorful 3D widgets that appear when you select an Actor in the viewport. They provide visual, interactive controls for manipulating Location, Rotation, and Scale.

Figure: The three transform gizmos. Use W/E/R to switch between them, or Space to cycle through.

Duplicating, Grouping, and Organizing Actors

As your levels grow more complex, you'll need efficient ways to manage dozens or hundreds of Actors. Unreal provides several tools for organizing and manipulating multiple Actors at once.

Duplicating Actors

There are multiple ways to duplicate an Actor:

1. Ctrl+W: Select an Actor and press Ctrl+W to duplicate it in place (slightly offset)
2. Alt+Drag: Hold Alt while dragging an Actor with the move gizmo to create a copy
3. Ctrl+C, Ctrl+V: Copy and paste like any software

Duplicated Actors inherit all properties from the original, including materials, lighting settings, and any custom configurations.

Grouping Actors

When you have multiple Actors that logically belong together (like all the pieces of furniture in a room), you can group them:

1. Select multiple Actors (hold Ctrl and click each one)
2. Press Ctrl+G to group them
3. The grouped Actors now move, rotate, and scale together as one unit
4. Press Ctrl+Shift+G to ungroup

Groups appear in the Outliner with a special folder icon, and you can nest groups within groups for hierarchical organization.

Folders in the Outliner

For organizational purposes (without affecting transforms), you can create folders in the Outliner:

1. Right-click in the Outliner
2. Select Create Folder
3. Name it something descriptive (e.g., "Furniture", "Lighting", "Props")
4. Drag Actors into the folder to organize them

Folders are purely organizational—they don't create parent-child relationships like attaching Actors does.

Attaching Actors (Parent-Child Relationships)

You can create true hierarchical relationships where one Actor is the parent and others are children:

1. Select the Actor you want to become the child
2. Drag it onto another Actor in the Outliner (the parent)
3. The child Actor becomes indented under the parent

When you move, rotate, or scale the parent Actor, all children move with it. This is useful for:

• Attaching a lamp to a ceiling so they move together
• Attaching wheels to a car body
• Creating compound objects that need to stay together

Selection Shortcuts

Efficiently selecting Actors is crucial for productivity:

Summary

In this lesson, you've learned the fundamental building blocks of every Unreal project: Actors and Components. Let's recap the essential concepts:

Key Takeaways

• 🎭 Actors are the "what"—any object that can be placed in a level, from 3D models to lights to invisible triggers
• 🔧 Components are the "how"—modular pieces of functionality that you attach to Actors to give them capabilities
• 📦 Common Actor types include Static Mesh Actors, Lights, Cameras, Triggers, Audio, Particles, and custom Blueprints
• 📍 Transform properties define where (Location), how oriented (Rotation), and how big (Scale) every Actor is in 3D space
• 🎯 Pivot points determine where rotations occur and where the Actor's Location is measured from
• 🛠️ Transform gizmos provide visual, interactive controls: W for Move, E for Rotate, R for Scale
• 📋 Organization tools like duplication (Ctrl+W), grouping (Ctrl+G), folders, and parent-child relationships keep complex levels manageable

What's Next?

Now that you understand Actors and how to manipulate them, the next step is learning about specific types of geometry creation. In Lesson 2.3: BSP Geometry (Brush Modeling), you'll learn how to use Unreal's built-in tools to create architectural spaces and level geometry without needing external 3D modeling software.