🎨 Materials and Lighting Basics

What Are Materials?

Imagine you have a perfectly modeled 3D chair—every edge, curve, and detail is geometrically accurate. But when you look at it in your level, it's just a flat gray shape. Without materials, there's no wood grain, no leather texture, no shine on the metal legs. Materials are what transform gray geometry into believable surfaces.

Materials Are Visual Programs

In Unreal Engine, materials are created using a node-based visual scripting system. Instead of writing code, you connect blocks (nodes) together to define how light interacts with the surface. Think of it like a flowchart where data flows from left to right:

• Input nodes: Textures, constants, parameters
• Math nodes: Add, multiply, blend operations
• Output node: The final material result with properties like color and roughness

Figure: Material data flows from input nodes (left) through processing nodes to the output node (right).

Why Materials Matter

Materials are responsible for almost everything you see in a game:

• Realism: A wooden table looks wooden because its material simulates wood grain, subtle color variation, and the way light scatters on rough wood surfaces
• Performance: Well-optimized materials render quickly; complex materials can tank framerate
• Consistency: Materials ensure all wood in your game looks consistently "woody," all metal looks metallic
• Art direction: Materials define the visual style—realistic, stylized, cartoon, sci-fi, fantasy
• Special effects: Water ripples, glowing force fields, holographic displays—all materials

Materials vs. Textures

A common beginner confusion: What's the difference between a material and a texture?

Think of it this way: Textures are the ingredients (flour, sugar, eggs). Materials are the recipe that combines ingredients to make a cake. You apply the cake (material) to your 3D mesh.

Physically Based Rendering (PBR) Fundamentals

Unreal Engine uses a rendering technique called Physically Based Rendering (PBR). Understanding PBR is essential to creating convincing materials.

Why PBR?

Before PBR, game artists manually "faked" how materials looked under different lighting. A shiny metal sword might look great in one scene but terrible in another because the shading wasn't based on physics. PBR solves this:

• ✅ Consistency: Materials look correct under any lighting condition
• ✅ Realism: Follows real-world light physics
• ✅ Artist-friendly: Intuitive parameters (roughness, metallic) instead of obscure shader values
• ✅ Industry standard: PBR workflows are used across games, film, and visualization

The Core PBR Material Inputs

Every PBR material in Unreal is built from a few key inputs. Understanding these is crucial:

Figure: The key PBR material input channels and their purposes.

1. Base Color (Albedo)

Base Color is the inherent color of the surface—what it looks like under pure white light with no shadows or reflections. It's also called "Albedo."

• For non-metals: This is the actual color (red paint, green grass, brown wood)
• For metals: This becomes the reflection color (gold reflects yellow/orange, copper reflects orange/brown)
• Input: RGB color (0-1 range for each channel, or texture)

2. Metallic

Metallic is a binary choice: Is this surface a metal or not?

• 0 (Non-metal): Plastic, wood, cloth, stone, organic materials—most things
• 1 (Metal): Iron, copper, gold, silver, aluminum, chrome
• In between: Rarely used—maybe for oxidized metal (0.8), or metal dust on surface (0.2)

In the real world, things are either conductors (metals) or insulators (everything else). PBR respects this by treating Metallic as mostly binary.

3. Roughness

Roughness defines the microsurface—how smooth or rough the surface is at a tiny scale.

• 0 (Smooth): Perfect mirror—sharp, clear reflections
• 0.1-0.3: Glossy—shiny plastic, polished metal, wet surfaces
• 0.4-0.6: Semi-gloss—painted walls, satin fabric
• 0.7-0.9: Matte—unfinished wood, rough stone, fabric
• 1.0 (Rough): Completely diffuse—clay, chalk, heavily weathered surfaces

Roughness is one of the most important properties—it dramatically affects how materials look. A shiny surface catches the eye; a matte surface recedes.

Figure: The same sphere at different roughness values shows how surface finish affects reflections.

4. Normal

Normal maps add surface detail without adding geometry. They "trick" the lighting calculation into thinking the surface has bumps, scratches, grooves, and texture.

• Input: A special texture (typically blue/purple-ish) that encodes surface normal directions
• Effect: Makes flat surfaces appear to have depth and detail
• When to use: Almost always—it's how you add bricks to a wall, grain to wood, stitching to fabric

Normal maps are created in 3D modeling software (baked from high-poly models) or generated from height maps.

5. Emissive

Emissive makes surfaces glow—they emit light rather than just reflect it.

• Input: Color (RGB) with intensity
• Use cases: Neon signs, LED displays, glowing crystals, lava, lightsabers
• Note: Emissive doesn't actually cast light on other objects unless you enable specific settings (bloom, light propagation)

Other Inputs (Less Common)

Specular: Controls Fresnel reflections (edge reflections). Usually left at default (0.5). Only change for special cases like wet surfaces (0.6-0.7) or certain plastics.

Opacity: For transparent/translucent materials (glass, water, ghosts). Requires changing material blend mode from "Opaque" to "Translucent" or "Masked."

Ambient Occlusion (AO): Pre-calculated shadows in crevices. Often baked into textures. Adds subtle darkening where surfaces meet.

PBR Best Practices

1. Start simple: Begin with Base Color, Metallic, and Roughness
2. Reference reality: Look at real-world materials—wood is never 100% rough, metal is never perfectly smooth
3. Vary roughness: Real surfaces have variation—add subtle roughness noise/texture
4. Metallic is binary: Use 0 or 1 for 99% of materials
5. Test in different lighting: PBR's strength is consistency—verify your material looks good in daylight, night, indoor, outdoor

The Material Editor

The Material Editor is where you create and edit materials using Unreal's node-based visual scripting system. Think of it as a canvas where you wire together nodes to define how a surface should look.

Opening the Material Editor

1. In Content Browser, find a material asset (or create one: right-click → Material)
2. Double-click the material
3. The Material Editor opens in a new window

Material Editor Interface

Figure: The Material Editor interface with palette, node graph canvas, and preview panel.

Key Areas of the Material Editor

1. Node Palette (Left)

The palette contains all available nodes organized by category:

• Texture: Texture Sample nodes for importing textures
• Constants: Fixed values (numbers, colors)
• Parameters: Values that can be changed in Material Instances
• Math: Add, Multiply, Divide, Lerp (blend), etc.
• Utility: Comments, reroute nodes, switches

To add a node: Drag from palette, or right-click in canvas and search.

2. Node Graph Canvas (Center)

This is where you build your material. The workflow:

1. Add nodes from the palette or by right-clicking
2. Connect nodes by dragging from output pins (right side) to input pins (left side)
3. Wire to output—everything eventually connects to the Material Output node
4. Compile—Unreal processes your node graph into a shader

Navigation:

• Pan: Middle-mouse drag, or right-click drag
• Zoom: Mouse wheel
• Select: Click nodes, drag selection box
• Move nodes: Click and drag

3. Preview Panel (Right)

Shows a real-time preview of your material on a 3D shape (sphere, cube, plane, or custom mesh). As you edit nodes, the preview updates.

You can rotate the preview object (click and drag) and change lighting to see how your material responds.

4. Details Panel (Bottom Right)

Shows properties of the selected node or the material itself:

• Material Domain: Surface, Deferred Decal, Light Function, etc.
• Blend Mode: Opaque, Masked, Translucent, Additive
• Shading Model: Default Lit, Unlit, Subsurface, Clear Coat, etc.
• Two Sided: Whether backfaces are visible

Understanding Node Pins

Nodes have input pins (left side) and output pins (right side). Pins are color-coded by data type:

You can connect mismatched types—Unreal converts automatically (e.g., connecting a Vector3 to a Float uses the first component).

Creating Your First Material

Let's create a simple material from scratch to understand the workflow. We'll make a basic colored, glossy plastic material.

Step 1: Create a New Material

1. In Content Browser, navigate to a folder (e.g., Content/MyProject/Materials/)
2. Right-click in empty space → Material
3. Name it M_PlasticRed
4. Double-click to open in Material Editor

Step 2: Set Base Color

1. Right-click in the node graph
2. Type "constant 3" and select Constant3Vector (this creates an RGB color)
3. Place the node somewhere left of the Material Output node
4. Double-click the Constant3Vector node
5. In the color picker, choose a red color (e.g., R=0.8, G=0.1, B=0.1)
6. Drag from the output pin of your color node to the Base Color input on Material Output

You should see the preview sphere turn red!

Step 3: Set Metallic

1. Right-click in graph, type "constant" and select Constant (single number)
2. Place it below your color node
3. Click the node, in Details panel set its value to 0 (plastic is non-metal)
4. Connect it to the Metallic input on Material Output

Step 4: Set Roughness

1. Add another Constant node
2. Set its value to 0.2 (glossy plastic)
3. Connect to Roughness input

Now your material should look like shiny red plastic!

Step 5: Save and Apply

1. Click Save button (or Ctrl+S)
2. Click Apply to compile the material
3. Close the Material Editor
4. Drag M_PlasticRed from Content Browser onto a mesh in your level
5. The mesh should now appear as red plastic!

Experiment: Make Variations

Try modifying your material:

• Change color: Double-click the Constant3Vector, pick a different color
• Make it matte: Change Roughness to 0.8
• Make it metal: Change Metallic to 1.0—now it's red chrome!
• Add variety: Right-click → "Multiply", multiply Base Color by another color to darken or tint

Working with Textures

While constant values are great for learning, real materials use textures—images that provide detailed color, roughness variation, and surface detail. Let's enhance our material with textures.

Texture Types in PBR

A typical PBR material uses several texture maps, each serving a different purpose:

Importing Textures

1. Get texture files (PNG, JPG, TGA, EXR)
2. In Content Browser, navigate to Content/MyProject/Textures/
3. Drag texture files from Windows Explorer into Content Browser
4. They import as Texture assets (automatically)

Using Textures in Materials

To add a texture to your material:

1. Open your material in Material Editor
2. Hold T key and left-click in the graph—this creates a Texture Sample node
3. With the node selected, look at Details panel
4. Click the dropdown next to "Texture"
5. Select your imported texture
6. Connect the RGB output to Base Color (or appropriate input)

Texture Sample outputs:

• RGB: The full color (use for Base Color)
• R, G, B, A: Individual channels (useful for packing multiple grayscale maps into one texture)

Texture Coordinates and Tiling

By default, textures map using UV Channel 0 (created in your 3D software). But you can control how textures tile and scale:

To add texture tiling:

1. Right-click → search "Texture Coordinate"
2. This node outputs UV coordinates
3. Right-click → "Multiply"
4. Connect Texture Coordinate → Multiply → Texture Sample's UV input
5. On the Multiply node, set the other input to something like (2, 2) to tile the texture 2x

Packing Textures for Efficiency

A pro technique: pack multiple grayscale maps into one texture's RGB channels:

• Red channel: Metallic map
• Green channel: Roughness map
• Blue channel: Ambient Occlusion map

This saves texture memory (1 texture instead of 3). Create the packed texture in image editing software, then in the material, connect the R output to Metallic, G to Roughness, B to AO.

Material Instances

Imagine you have a wood material. You want oak, pine, mahogany, walnut—all wood, but different colors and grain patterns. Do you create separate materials for each? No! You use Material Instances.

Why Use Material Instances?

• ✅ Performance: Instances don't require shader recompilation—you can change them in real-time
• ✅ Efficiency: Hundreds of instances can exist from one parent material
• ✅ Iteration speed: Artists can tweak colors and values instantly
• ✅ Consistency: All instances share the same base shader logic

Creating Parameters in Parent Material

For Material Instances to work, the parent material must have parameters—values that can be changed:

1. Open your material (e.g., M_PlasticRed)
2. Select your Constant3Vector (Base Color)
3. Right-click it → Convert to Parameter
4. Name it TintColor
5. Set a default value (your red color)
6. Do the same for Roughness constant → name it RoughnessValue
7. Save the material

Now your material has exposed parameters that instances can override!

Creating a Material Instance

1. In Content Browser, right-click your parent material (M_PlasticRed)
2. Select Create Material Instance
3. Name it MI_PlasticBlue
4. Double-click to open the Material Instance Editor

Editing Material Instances

The Material Instance Editor is simpler than the Material Editor—no nodes, just a list of parameters:

1. You'll see TintColor and RoughnessValue listed
2. Check the checkbox next to TintColor to enable overriding
3. Click the color swatch, change it to blue
4. Check and change RoughnessValue to 0.4 (less glossy)
5. Save

Now you have a blue plastic material that's a variant of your red one! Changes are instant—no shader compilation.

Figure: One parent material with parameters spawns multiple Material Instances with different values.

Parameter Types

You can convert various node types to parameters:

• Scalar Parameter: Single float value (roughness, metallic, opacity)
• Vector Parameter: RGB color (Base Color, tint color, emissive color)
• Texture Parameter: Allows swapping textures per instance
• Static Switch Parameter: Toggles features on/off (no performance cost when off)

Light Types and Properties

Materials define how surfaces look, but without lighting, everything is black. Lighting reveals materials and creates mood, atmosphere, and depth. Unreal Engine provides several light types, each suited for different purposes.

The Four Main Light Types

Figure: The main light types and their characteristics.

Key Light Properties

Every light has adjustable properties in the Details panel:

Intensity

Brightness of the light. Higher = brighter. Units vary by light type (lux for Directional, candelas for Point).

Light Color

RGB color of the light. Warm colors (yellow/orange) for sunset, cool colors (blue) for moonlight, white for neutral.

Attenuation Radius (Point/Spot)

How far the light reaches before fading to black. Visualized as a sphere/cone in the editor.

Inner/Outer Cone Angle (Spot)

Defines the spotlight's beam shape. Inner cone is full brightness, outer cone fades to zero.

Source Radius/Length (Rect)

Physical size of the area light. Larger = softer shadows.

Indirect Lighting Intensity

Controls how much the light bounces. Higher values create more realistic global illumination.

Cast Shadows

Whether the light creates shadows. Shadows are expensive—disable for background/fill lights.

Temperature

Physically accurate color based on Kelvin temperature (e.g., 6500K = daylight, 2700K = warm incandescent).

Light Mobility: Static, Stationary, and Movable

One of the most important lighting concepts in Unreal is Light Mobility. This setting determines how the light is rendered and has massive performance implications.

The Three Mobility Types

Static Lights

Static lights are completely baked—their lighting is pre-calculated and stored in lightmap textures. They cannot move or change at runtime.

Advantages:

• Zero performance cost during gameplay
• Beautiful, soft shadows with multiple bounces (global illumination)
• Ambient occlusion in crevices
• Can have unlimited numbers without performance hit

Disadvantages:

• Requires "building lighting" (preprocessing step)
• Cannot change color, intensity, or position at runtime
• Dynamic objects (characters, props) only receive indirect lighting

Stationary Lights

Stationary lights are a hybrid—they bake indirect lighting but cast dynamic shadows for moving objects.

Advantages:

• Baked indirect lighting (bounces, global illumination)
• Dynamic shadows for moving objects
• Can change color and intensity at runtime (not position)
• Good balance of quality and performance

Disadvantages:

• Limited to 4 overlapping stationary lights per area (Unreal limitation)
• More expensive than static, cheaper than fully movable

Movable Lights

Movable lights are fully dynamic—everything is calculated in real-time every frame.

Advantages:

• Can move, rotate, change color/intensity freely
• No pre-calculation needed
• Perfect for interactive lighting (flashlights, flicker effects)

Disadvantages:

• Expensive—every light costs performance
• No indirect lighting/global illumination
• Shadows can be harsh without careful setup
• Limited shadow resolution

Building and Baking Lighting

When you use Static or Stationary lights, Unreal needs to build lighting—a process that pre-calculates light bounces, shadows, and global illumination. This creates the beautiful, realistic lighting you see in finished games.

Why Build Lighting?

Calculating how light bounces around a scene with full global illumination is incredibly computationally expensive. Doing it in real-time at 60 FPS is impossible (without Lumen in UE5). So Unreal:

1. Traces millions of light rays offline (during development)
2. Bakes the results into lightmap textures
3. At runtime, meshes display these pre-calculated lightmaps—zero cost!

How to Build Lighting

1. In the editor toolbar, find the Build button (or press Ctrl+Shift+;)
2. Click it to start the build process
3. A progress bar appears in the bottom-right
4. Wait for completion (can take seconds to hours depending on scene complexity)
5. Lighting updates throughout the level

You'll notice lights now have soft, realistic shadows, and indirect lighting fills dark areas with subtle color bounces.

Lightmass Settings

Unreal's baked lighting system is called Lightmass. You can control quality in World Settings → Lightmass:

• Num Indirect Lighting Bounces: How many times light bounces (3-10 for realism, default 3)
• Indirect Lighting Quality: Resolution of bounced light (1-4, higher = better but slower)
• Indirect Lighting Smoothness: Blurs indirect lighting (higher = softer)

Build Quality Levels

Next to the Build button is a dropdown:

• Preview: Very fast, low quality—for quick iteration
• Medium: Balanced—decent quality, reasonable time
• High: Good quality—takes longer
• Production: Final quality—very slow, for shipping

Use Preview during development, Production for final builds.

Common Lighting Build Issues

Lighting Needs to Be Rebuilt

Symptom: Red "LIGHTING NEEDS TO BE REBUILT" text in viewport.
Solution: Build lighting. This is normal after placing/moving lights.

Light Leaking Through Walls

Symptom: Light appears on the wrong side of geometry.
Solution: Increase Lightmap Resolution on the mesh (Details → Overridden Light Map Res → 64, 128, or 256).

Splotchy/Patchy Lighting

Symptom: Ugly artifacts in baked lighting.
Solution: Ensure meshes have proper Lightmap UVs (Channel 1). Regenerate in Static Mesh Editor if needed.

Very Long Build Times

Symptom: Build takes hours.
Solution: Reduce Lightmass quality settings, use lower lightmap resolution, build on Preview/Medium quality for iteration.

Summary

Materials and lighting are the visual foundation of your Unreal projects. Together, they transform gray geometry into believable, atmospheric worlds. Let's recap the essential concepts:

Key Takeaways

• 🎨 Materials define how surfaces interact with light—their color, reflectivity, roughness, and texture
• ⚛️ PBR (Physically Based Rendering) uses real-world physics for consistent, realistic materials across all lighting conditions
• 🔑 Core PBR inputs: Base Color (albedo), Metallic (0 or 1), Roughness (0=shiny, 1=matte), Normal (surface detail)
• 🖼️ Textures are images that provide color patterns and detail data—they're inputs to materials
• 🔧 Material Editor is a node-based system for building materials by wiring together input/math/output nodes
• 📋 Material Instances are lightweight variants that change exposed parameters without shader recompilation
• 💡 Light types: Directional (sun), Point (bulb), Spot (flashlight), Rect (area), Sky (ambient)
• ⚡ Light mobility: Static (baked, zero cost), Stationary (hybrid), Movable (dynamic, expensive)
• 🏗️ Building lighting pre-calculates global illumination for Static/Stationary lights into lightmaps
• ✨ Lumen (UE5) provides real-time dynamic GI, eliminating the need for light builds in many workflows

What's Next?

You've now completed Module 2! You understand levels, actors, geometry creation (BSP), Static Meshes, materials, and lighting—the core building blocks of 3D environments. The next module will introduce Module 3: Blueprint Visual Scripting, where you'll learn to make your worlds interactive through Unreal's powerful visual programming system.