🏗️ BSP Geometry (Brush Modeling)

What is BSP Geometry?

Imagine you're a level designer in the early days of game development. You have an idea for a complex multi-room dungeon, but you don't have time to model every wall, floor, and ceiling in a 3D modeling program like Blender or Maya. You need to prototype quickly, test your layout, and iterate on the design. This is where BSP geometry comes in.

BSP has been part of Unreal Engine since the very beginning—it was the primary way to build levels in Unreal Engine 1 and 2. While modern workflows have largely replaced BSP with Static Meshes and modular level design, BSP remains a powerful tool for rapid prototyping and blocking out level layouts.

The Core Concept: Building with Volumes

Think of BSP like working with clay or foam blocks. You start with empty space (or a solid mass), and you either:

• Add material to create solid shapes (walls, floors, pillars)
• Remove material to carve out hollow spaces (rooms, doorways, alcoves)

This additive and subtractive approach is fundamentally different from traditional 3D modeling, where you work with surfaces and polygons. With BSP, you're sculpting space itself.

Figure: BSP concept - Additive brushes create solid geometry (left), subtractive brushes carve out hollow spaces (right).

Why BSP Still Matters

You might wonder: if BSP is an "old" technique, why learn it? Here are the compelling reasons:

1. Rapid Prototyping: BSP is incredibly fast for blocking out level layouts. You can test the flow and pacing of your level before committing to detailed art assets.
2. No External Tools Required: Everything happens inside Unreal. No need to switch to Blender, export files, re-import, and iterate—just build and test immediately.
3. Perfect for Greyboxing: "Greyboxing" (or "blockout") is the industry-standard practice of building levels with simple geometry to test gameplay before creating final art. BSP is ideal for this.
4. Learning Tool: Understanding BSP helps you grasp spatial reasoning and level construction principles that apply to all 3D development.
5. Quick Edits: Need to adjust a room size or add a wall? BSP changes happen in seconds, while reimporting a Static Mesh takes longer.

BSP in Modern Unreal Engine

It's important to set proper expectations: BSP is primarily a prototyping tool in modern Unreal workflows. For final shipped games, you'll typically use Static Meshes created in external 3D software or Unreal's built-in modeling tools. BSP has some limitations:

• Less efficient rendering compared to optimized Static Meshes
• Can create visual artifacts (cracks, Z-fighting) if not carefully managed
• Limited support for advanced features like Nanite (UE5's virtualized geometry)
• Harder to create complex organic shapes

That said, BSP remains an invaluable tool for the early stages of level design and for creating simple architectural spaces quickly.

Additive vs. Subtractive Brushes

The foundation of BSP geometry is understanding the two types of brushes: Additive and Subtractive. Every piece of BSP geometry you create falls into one of these categories.

Additive Brushes

An Additive Brush creates solid geometry—it adds matter to the world. When you place an additive brush, you're saying "this space is now filled with solid material."

Think of additive brushes as the LEGO bricks you stack to build structures. Common uses include:

• Walls: Vertical planes that block movement and sight
• Floors: Horizontal surfaces players walk on
• Ceilings: Overhead surfaces that define room boundaries
• Pillars and columns: Vertical supports and decorative elements
• Platforms: Raised areas players can climb onto

When you first place a BSP brush in Unreal, it defaults to Additive. In the editor, additive brushes typically appear with a subtle blue tint (when in Wireframe or BSP mode) to distinguish them from the world.

Subtractive Brushes

A Subtractive Brush does the opposite—it carves out space, removing geometry to create hollow areas. When you place a subtractive brush, you're saying "this space should be empty air."

Think of subtractive brushes like a sculptor's chisel—they remove material to reveal the form underneath. Common uses include:

• Rooms: Carving interior spaces from solid blocks
• Doorways: Cutting openings in walls for passage
• Windows: Creating openings for visibility and light
• Alcoves and niches: Indentations in walls for decoration or pickups
• Tunnels and passages: Carving paths through terrain

Subtractive brushes appear with a reddish/pink tint in the editor, making them easy to distinguish from additive brushes.

How They Work Together

The real power of BSP comes from combining additive and subtractive brushes. Here's a typical workflow:

1. Start with a large additive brush to create a solid block of geometry
2. Use subtractive brushes to carve out rooms and corridors within that block
3. Add more additive brushes for internal walls, pillars, or details
4. Use additional subtractive brushes for doorways, windows, or decorative cutouts

Figure: The typical BSP workflow - start with additive blocks, carve out interiors with subtractive brushes, then add details.

Brush Order and Priority

When multiple brushes overlap, Unreal processes them in a specific order. Understanding this order helps you predict how your geometry will look:

1. Base assumption: The world starts as empty space (void)
2. Additive brushes are processed first, creating solid geometry
3. Subtractive brushes are processed second, carving away from the additive geometry
4. If brushes of the same type overlap, the order they were created matters (later ones take priority)

Think of it like working with layers in Photoshop or painting on a canvas—earlier layers can be covered or modified by later ones.

Creating Basic Architecture with BSP

Now that you understand the theory, let's look at the practical steps for creating BSP geometry in Unreal Engine. We'll build up from simple shapes to a complete room.

Accessing BSP Brushes

BSP brushes are found in the Place Actors panel under the Geometry category:

1. Open the Place Actors panel (left side, or press Shift+1)
2. Click on the Geometry category
3. You'll see several brush shapes: Box, Cone, Cylinder, Sphere, and more
4. Drag any brush into your viewport to place it

Figure: The Place Actors panel showing the Geometry category with common BSP brush types.

Building Your First Room

Let's walk through creating a simple room step by step. This is the foundational technique you'll use for all BSP work.

Step 1: Create the Outer Walls

1. From Place Actors → Geometry, drag a Box brush into your level
2. This creates an additive box (you'll see it as a blue/purple solid cube)
3. Select the box and look at the Details panel
4. Find the Brush Settings section
5. Set the dimensions:
   • X (length): 400 cm (4 meters)
   • Y (width): 600 cm (6 meters)
   • Z (height): 300 cm (3 meters)
6. This creates a solid block that will become your room's outer shell

Step 2: Carve Out the Interior

1. Place another Box brush inside the first one
2. Position it in the center (you can use the move gizmo)
3. With this new box selected, look at the Details panel
4. Find Brush Type and change it from "Additive" to "Subtractive"
5. The box should change color (usually to pink/red)
6. Set its dimensions slightly smaller than the outer box:
   • X: 340 cm (leaves 30cm thick walls on front/back)
   • Y: 540 cm (leaves 30cm thick walls on sides)
   • Z: 240 cm (leaves 30cm floor, 30cm ceiling)
7. Position it so there's equal spacing all around (30cm walls, floor, ceiling)

Congratulations! You've created your first BSP room—a hollow box with walls, floor, and ceiling.

Step 3: Add a Doorway

1. Place another Box brush
2. Set it to Subtractive
3. Size it like a doorway:
   • X: 100 cm (depth—extends through the wall)
   • Y: 90 cm (standard door width)
   • Z: 200 cm (standard door height)
4. Position it at one of the walls, at floor level
5. It should cut through the wall, creating an opening

You now have a complete room with an entrance!

Common BSP Shapes and Their Uses

BSP Operations and Tools

Beyond simply placing additive and subtractive brushes, Unreal provides several tools for manipulating and refining your BSP geometry. These operations give you greater control over the final result.

CSG Operations

CSG (Constructive Solid Geometry) is the technical term for the Boolean operations that BSP uses. While Unreal handles most CSG automatically, understanding the underlying operations helps you troubleshoot issues and create complex shapes.

Figure: The three main CSG operations. Unreal automatically applies Union and Subtraction based on brush type.

Brush Editing Tools

Once you've placed BSP brushes, you can modify them in several ways:

1. Geometry Editing Mode

Geometry Editing Mode lets you manipulate individual vertices, edges, and faces of a BSP brush:

1. Select a BSP brush
2. Press Shift+5 or click the "Geometry Editing" button in the toolbar
3. You'll see the brush's vertices (corner points) appear as small boxes
4. Click and drag vertices to reshape the brush
5. Hold Ctrl to select multiple vertices
6. Press Shift+5 again to exit Geometry Editing Mode

2. Brush Properties

Every BSP brush has properties you can adjust in the Details panel:

• Brush Type: Switch between Additive and Subtractive
• X, Y, Z: Change dimensions
• Hollow: Makes the brush hollow (walls with thickness)
• Wall Thickness: When Hollow is enabled, controls wall thickness
• Tessellation: For curves (cylinders, spheres), controls smoothness

3. Build Geometry

After making changes to BSP, you need to rebuild geometry for the changes to take effect:

1. Click Build in the toolbar (or press Ctrl+Shift+;)
2. You can also go to Build → Build Geometry in the menu
3. Unreal will process all BSP and update lighting/visibility
4. Watch the bottom-right corner for the build progress

Think of "building" like compiling code—you're telling Unreal to process all the BSP brushes and generate the final geometry that will render in-game.

Aligning Brushes

Unreal provides tools to align brushes precisely:

• Snap to Grid: Hold Ctrl while dragging to snap to grid increments
• Grid Settings: Change grid size in the toolbar (common values: 10, 25, 50, 100)
• Align to Actor: Right-click brush → Align → Align to Floor/Ceiling/Wall
• Make Coplanar: Select two brushes, right-click → Make Coplanar to align their faces

Proper alignment prevents gaps, cracks, and visual glitches in your BSP geometry.

BSP Limitations and Performance Considerations

While BSP is great for prototyping, it has several limitations you should understand—especially if you're tempted to use it for final production geometry.

Why BSP Has Fallen Out of Favor

In early Unreal Engine versions (UE1, UE2), BSP was the primary way to build levels. Modern game development has largely moved away from BSP for several reasons:

Common BSP Problems

When working with BSP, you'll likely encounter these issues:

1. BSP Holes / Cracks

Thin black lines appearing at brush intersections. Causes: Floating-point precision errors, non-coplanar surfaces, overlapping brushes. Fix: Rebuild geometry, align brushes to grid, ensure surfaces are flush.

2. Z-Fighting

Flickering between two overlapping surfaces. Causes: Two brush faces occupying the same space. Fix: Offset one surface slightly, or merge brushes into one.

3. Invalid Brush

Error message after editing geometry. Causes: Creating non-planar faces, self-intersecting geometry, degenerate triangles. Fix: Undo changes, rebuild from simpler brushes, avoid extreme vertex editing.

4. Lighting Artifacts

Splotchy shadows, light leaks, or black surfaces. Causes: BSP doesn't have explicit lightmap UVs, small surfaces, overlapping geometry. Fix: Increase lightmap resolution, rebuild lighting, convert to Static Mesh with proper UVs.

Figure: Common BSP issues - cracks at seams, Z-fighting flicker, and lighting artifacts.

Best Practices for BSP

If you're using BSP (for prototyping or otherwise), follow these guidelines to minimize problems:

1. Keep it simple: Avoid complex intersecting geometry—use clean, orthogonal shapes
2. Align to grid: Always snap brushes to grid (10, 25, 50, 100cm increments)
3. Rebuild frequently: Press Ctrl+Shift+; often to catch errors early
4. Avoid small details: Don't use BSP for trim, molding, or fine details—use Static Meshes
5. Limit brush count: Fewer, larger brushes perform better than many small ones
6. Test collision: Add a player character and physically walk through your spaces
7. Plan for conversion: Design with the knowledge you'll convert to Static Meshes later

Converting BSP to Static Mesh

Once you've prototyped your level with BSP and you're happy with the layout, it's time to convert it to Static Meshes for better performance and fewer visual issues. Unreal makes this process straightforward.

Why Convert?

Converting BSP to Static Meshes gives you several advantages:

• ✅ Better performance: Static Meshes render more efficiently
• ✅ Cleaner visuals: No more BSP cracks or Z-fighting
• ✅ Nanite support: Can enable UE5's virtualized geometry for extreme detail
• ✅ Better lighting: Proper lightmap UVs eliminate artifacts
• ✅ Simplified collision: Can create custom, optimized collision meshes
• ✅ Reusability: Converted meshes become assets you can use elsewhere

The Conversion Process

Here's how to convert BSP geometry to Static Meshes:

1. Select the BSP brushes you want to convert (you can select multiple)
2. Go to Brush → Create Static Mesh in the menu (or right-click and choose "Convert to Static Mesh")
3. A dialog will appear asking where to save the new mesh
4. Choose a location in your Content Browser (create a "Geometry" folder if needed)
5. Name the mesh descriptively (e.g., "SM_Room_Prototype_01")
6. Click Create Static Mesh
7. The original BSP brushes remain in the level—you can delete them or keep them as reference
8. A new Static Mesh Actor is created in the same location with the geometry

Figure: The professional workflow from BSP prototype to final production assets.

Post-Conversion Steps

After converting to Static Mesh, you'll want to refine the mesh:

1. Open the Static Mesh Editor: Double-click the new mesh in Content Browser
2. Generate Lightmap UVs: Go to Details → LOD0 → Generate Lightmap UVs (fixes lighting artifacts)
3. Create collision: Collision → Add Box/Capsule Simplified Collision (or auto-generate)
4. Apply materials: Replace the default BSP material with proper materials
5. Set up LODs: For distant viewing, create Level of Detail meshes (optional but recommended)
6. Enable Nanite (UE5): In Details, enable "Nanite" for massive performance gains with complex geometry

Alternative: Replace with Modular Assets

Instead of converting BSP directly, you might choose to replace it with modular mesh pieces:

1. Keep your BSP as a reference (make it invisible or put in a "Reference" folder)
2. Create or obtain modular wall, floor, ceiling, and door pieces
3. Place these meshes to match your BSP layout
4. Delete the original BSP once replacement is complete

This approach gives you more control over the final look and often results in better visual quality, but takes longer than simply converting.

Summary

BSP geometry is a powerful prototyping tool that has been part of Unreal Engine since the beginning. While modern workflows favor Static Meshes for final production, BSP remains essential for rapid level design iteration. Let's recap what you've learned:

Key Takeaways

• 🏗️ BSP (Binary Space Partitioning) lets you create 3D geometry directly in Unreal using additive and subtractive volumes called "brushes"
• ➕ Additive brushes create solid geometry (walls, floors, ceilings)
• ➖ Subtractive brushes carve out hollow spaces (rooms, doorways, windows)
• 🎯 Best use case: Greyboxing and prototyping level layouts before creating final art assets
• 🛠️ CSG operations: Union (add), Subtraction (carve), and Intersection combine brushes to create complex shapes
• ⚠️ Limitations: BSP has performance issues, visual artifacts, and lacks Nanite support—not ideal for final production
• 🔄 Conversion workflow: Prototype with BSP → Convert to Static Mesh → Polish with materials and lighting
• ✅ Best practices: Align to grid, keep geometry simple, rebuild frequently, and plan to convert or replace BSP before shipping

What's Next?

Now that you can create basic architectural geometry with BSP, the next lesson will introduce Lesson 2.4: Static Meshes and Assets. You'll learn how to import 3D models from external software, work with Unreal's built-in modeling tools, and build levels using modular mesh sets—the modern approach to level construction.