Ultimate Building Toolkit

Create editable building exteriors in Unreal Engine 5.8: draw a footprint, select an architectural preset, register your modular meshes, place details, and produce static mesh or PCG output.

Install and create a building

1. Install the plugin for Unreal Engine 5.8, enable Ultimate Building Toolkit in Edit > Plugins, and restart the editor. PCG and ProceduralMeshComponent are engine dependencies enabled by the plugin. Windows x64 is the release validation target.
2. Choose Tools > Building Editor, or use Building Editor in the viewport toolbar.
3. Press N, then click two opposite corners for a rectangle. Press D to draw a custom outline; click its corners and press Enter. Select the building and press F to frame it.
4. Adjust dimensions, floors, roof and facade in the panel. The panel uses metres; advanced Details properties use centimetres.
5. Press E to edit outline points. Drag a white handle; use a green midpoint to insert a corner. Rectangles and L footprints become custom polygons when edited this way. Courtyards retain dimension controls to preserve their hole.
6. Save the level. Save reusable settings with Tools > Save Selected Building Presets. A preset is copied when applied; later building edits do not silently change the source preset.

Q selects, S toggles snapping, P places a detail, R rebuilds, V changes the deterministic seed, Tab switches full/compact controls, and Esc cancels an operation. Undo uses Unreal's normal Ctrl+Z.

Register a modular kit

Use mesh registration to describe the source mesh's usable dimensions, pivot and exterior direction before assigning it to a wall/window/door/trim slot. Choose native size, uniform fit or explicit stretch-to-fit according to the asset. Native kit UVs and material assignments are preserved; procedural infill has its own material and repeat size. Avoid stretching a detailed brick module to span an arbitrary wall: repeat appropriate modules and use controlled infill instead.

Test one building on all four sides before applying a profile district-wide. Check corners, floor joins, outward-facing detail surfaces, window/door clearance and the roof. Mesh bounds alone cannot determine the artistic front of an arbitrary asset. See Custom mesh registration and Asset authoring.

Balconies, roofs and lighting

Use anchored details and rules for balcony furnishings, rooftop equipment, solar panels and decals. Placement uses the registered dimensions; warnings report invalid or obstructed candidates. Check the actual mesh after registration, especially assets with off-centre pivots or oversized bounds. See Balconies and roof details.

The Building Night Lighting controller supports clock, sun-elevation and manual preview modes with a master enable switch. Connect the clock/sun to your game's time system. Only registered light fixtures and participating emissive materials follow it; it does not rewrite arbitrary third-party materials. See Night lighting.

Authoring, baking and game performance

The editable actor is an authoring representation. Auto Rebuild can reconstruct its geometry when construction is rerun; it does not mean that every building regenerates every frame. Disable Auto Rebuild during bulk edits, then explicitly rebuild and inspect the result. Limit the loaded World Partition area while editing a large district.

Buildings saved with early development builds need one explicit rebuild and level save before packaging. This registers their generated mesh instances and decals as persistent output. Rebuild and save the source in the editor; game-start regeneration is not required to repair those old files.

Tools > Bake Selected Buildings creates separate static mesh assets and retains the editable actors. Place the bake, check its materials and collision, and remove the editable duplicate from the runtime representation to avoid overlapping geometry. Retain an authoring copy outside the cooked runtime map if future regeneration is needed. Verify decals and managed lights separately; a mesh bake is not a bake of every gameplay actor.

HLOD generation is a later optimization step for distant geometry. It does not disable source generation. Configure streaming and HLOD layers together, then compare an actual packaged game before/after. Keep detailed repeated props instanced when suitable. There is no guaranteed district size or frame rate.

PCG graph creation snapshots building settings. Subsequent edits to the original actor do not automatically update that graph. Runtime generation is an explicit project choice; a static city can use generated, saved output instead. See the PCG and baking sections of the plugin guide.

Materials and included assets

Show Plugin Content in the Content Browser to find the packaged materials and meshes. Source scans and furniture are credited in Starter materials and Office Poly Haven. No purchased KitBash3D, Soul City, game district, protagonist, or Ultimate Road Tool assets are included in the core plugin. You can register your own appropriately licensed kits.

Parallax relief affects shading, not silhouette or collision. Optional Nanite displacement needs project renderer settings and a suitable static mesh bake. The interior shader uses projected room imagery; it is not a navigable interior. See Interior mapping for the viewing limitations and controls.

Troubleshooting

• A building retains its old shape: inspect Status and Warnings. Invalid edits retain the last valid geometry. If Auto Rebuild is off, rebuild explicitly.
• An imported module faces inward: correct the module's exterior direction/pivot in its kit profile and retest every side.
• Stretched or mismatched brick scale: preserve native UVs on source modules; set the generated wall material and physical repeat to match. Do not assume unrelated kits share texel density.
• Duplicate or flickering faces: check for an editable actor and its baked replacement occupying the same location, then inspect kit joins and infill.
• Slow editing: reduce the loaded region, defer rebuilding during bulk edits, and profile mesh, material, lighting and collision costs separately.
• Missing dependencies in an example: use the core example with this plugin enabled. The optional road adapter/example additionally requires Ultimate Road Tool and is a separate integration.

Support: https://www.unrealtools.com. Independent third-party tools for Unreal Engine; no Epic Games endorsement is implied.

Ultimate Building Toolkit

An Unreal Engine 5.8 building exterior authoring plugin with editable footprints, modular mesh registration, anchored details, facade materials and PCG output. The core plugin has no Aura game or Ultimate Road Tool dependency.

Start with the quick-start guide for installation, viewport editing, modular kits, night lighting, baking and troubleshooting.

Use the building editor

Enable Ultimate Building Toolkit in Edit > Plugins and restart Unreal. PCG and ProceduralMeshComponent are required engine plugins. Enable Show Plugin Content in the Content Browser to browse the packaged materials, meshes and presets. The separate example project's introductory map is /Game/BuildingToolkit/L_BuildingShowcase.

In any enabled project, choose Building Editor in the mode toolbar, or run Building.Editor in Unreal's console. Its teal accents, buttons, spacing, typography and full/compact layout match Ultimate Road Tool.

Press N, then click two opposing footprint corners to place a building. S toggles 1 m snapping. The first click picks the surface elevation; the second stays at that height. Select a preset first to use its facade, roof and materials. Placement is world-axis aligned; rotate the actor afterwards. Custom-outline presets are applied to an existing actor instead of being resized by rectangle drawing.

D draws a custom polygon; click its corners and press Enter to finish. Angled and concave outlines are supported. E edits corners; drag a white handle, click a green midpoint + to insert, or press Delete on a selected corner. I enters insertion mode. Editing a rectangle or L converts it to a custom outline. Courtyards retain their Width/Depth/Wing Width controls so point editing cannot erase the hole.

P places the selected mesh or decal on a roof, facade or balcony floor. Q selects, R rebuilds, V varies the seed, Tab switches between the full panel and rounded bottom toolbar, and Esc cancels. Ctrl+Z and right-mouse navigation retain Unreal's normal behaviour. Width, depth, floor height and bay size use metres in the panel. Advanced Details settings use centimetres. The panel limits wing width to leave a viable recess. Corner handles work in perspective and orthographic views.

Alternatively, Tools > Add Toolkit Building creates a building at the origin. Select it and press F to focus. Edit Building > Settings in Details. Changes rebuild automatically; turn off Auto Rebuild for batched edits, then use Rebuild Building. The Status field reports errors, warnings, part counts and the latest generation time. Invalid changes retain the last valid mesh. They cannot be baked until corrected.

Implemented

• Rectangle, L-shaped and open courtyard footprints, plus simple custom polygons.
• Configurable floor count, slabs, wall thickness, facade bays, windows and doors.
• Real wall openings with jambs, heads, sills and frames. Door panels are optional.
• Gable, shed and flat roofs; joined L-gable ridges/valleys and open courtyard roofs.
• Deterministic variation and persistent facade overrides.
• Doorway-aware balcony furnishings, wall equipment with fitted brackets/conduit, and editable rooftop hatch, vent and antenna rules.
• Seven material slots: Wall, Floor, Roof, Frame, Glass, Door and Trim.
• Mitered perimeter segments and inset slabs to avoid exposed coincident faces.
• Continuous building-space texture coordinates across coplanar generated parts.
• Registered facade meshes, mesh kits, roof/facade props, decals and detail rules.
• Balconies with upper-floor doors and anchored props; deterministic flat-roof scatter and slope-aligned solar arrays.
• Poly Haven height maps with procedural parallax relief and an optional Nanite displacement bake.
• A world-projected Poly Haven office palette, assembled seating and masked foliage, with anchored terrace examples.
• A procedural mesh with seven semantic sections, plus grouped native mesh instances and decals.
• Preset assets, static mesh baking, and a native PCG Building Layout node.
• Stable per-actor building IDs for external placement/parcel systems.

Dimensions are centimetres. Footprints are centred at the actor origin. Ground-floor finished floor elevation is local Z=0. Positive X follows the Front wall; its exterior faces -Y. Custom outlines are counterclockwise in XY; each corner's Id names its outgoing wall. Keep these IDs stable when moving corners. Custom corners must have Z=0 and produce a simple outline. Up to 32 corners, 64 floors and 2,048 facade slots are allowed, subject to the 30,000-part geometry budget.

Custom gables use a bounding ridge clipped to the footprint. They do not infer a full architectural roof skeleton. Converting an L to Custom changes that roof policy. See Asset authoring for mesh dimensions, pivots and detail anchors. See Balconies and roof details for the new panel actions, and Starter materials for height settings and displacement limits. See Office Poly Haven palette for the scanned office surfaces, furniture, source credits and reproduction workflow.

Preserve an entrance or window

Add an item to Openings, naming its Edge Id, Floor and Bay (both zero-based). For example, Front / 0 / 0 / Empty creates an open doorway in the first ground-floor bay. Solid, Window, Door and Empty override random selection. Empty omits the door panel. Width/Height=0 inherit the default opening dimensions; Offset moves it along the wall within that bay. There must be sufficient wall on both sides and above the opening.

Changing the seed or roof preserves these overrides. Resizing redistributes bays, so the override follows its named slot rather than holding a world-space coordinate. If a slot disappears, the override remains saved and a warning identifies it. Duplicate overrides or explicitly requested openings that cannot fit cause a validation error.

The Preset field selects a source; Apply Preset explicitly copies its settings, openings and materials. Later edits are local. Tools > Save Selected Building Presets creates uniquely named assets under /Game/Buildings/Presets.

PCG

Tools > Create PCG Graph from Selected Buildings creates a graph under /Game/Buildings/PCG. Assign the graph to a PCG component and Generate. Graph creation snapshots the selected building's settings; later actor edits do not update that graph. Edit the Building Layout node to change it.

Newly created graphs build structural surfaces with the same geometry and UV builder as the editable actor. Registered meshes remain instanced and decals remain separate. This preserves texture density when the footprint changes.

For custom graph authoring, the native node also exposes Boxes, Gables, Sheds, Triangles, Meshes and Decals. Lower-level primitive transforms scale centred 100 cm primitives. Bounds are +/-50 cm before scale. Attributes are StableId (string), PartKind (integer matching the enum), and Material (material asset path). Output is relative to the executing PCG component, including its transform. Use these attributes to filter, substitute kit meshes and add detail. The Meshes pin carries registered asset paths in Mesh, native transforms and actual bounds. Decals carry Material, Size and SortOrder; the graph spawns Building Decal Actors and refreshes them. Use mesh registration to accommodate different bounds and pivots. When manually using scaled primitive pins rather than the generated surface path, use suitable world-aligned materials for consistent texture density.

The actor and PCG node call the same bounded, world-independent layout solver. The actor does not require a PCG component to preview geometry. Generated graphs use procedural structural surfaces and native mesh spawners; automatic city placement is a separate integration layer.

Baking and game use

Tools > Bake Selected Buildings saves new Static Mesh assets under /Game/Buildings/Baked. The editable actor remains in place. Baking preserves material slots, includes registered mesh instances with their original materials, creates lightmap UVs and uses complex-as-simple collision. Decals remain separate components on the editable actor; they cannot be stored in a Static Mesh asset. Baking does not create HLODs, mesh simplification, merged city cells or an interactive door system. The separate Nanite bake action enables Nanite on the output mesh. Procedural glass is non-blocking; optional door panels block. Configure PCG spawner collision separately for your game's requirements.

Road integration

The separate BuildingStreetBridge plugin adds an opt-in four-road rectangular block prototype in the development repository; it is not included in the core download. The core toolkit works without it. A custom city layer should publish stable parcel IDs, buildable polygons, frontage and elevation to this toolkit. Road edits should update only intersecting parcels and report conflicts with locked buildings. Arbitrary road-network parcel extraction is not implemented.

Scope and limits

Full shape grammar, hip roofs and editable roof zones, interior room/stair solvers, automatic terrain foundations, arbitrary road-network parcel extraction, spatial indexing and incremental geometry rebuilding are not provided by the core toolkit. City population and streaming need project-specific integration.

The preview assembles solid parts; hidden internal surfaces remain and the output is not a welded CAD solid. Detail rules provide basic bounds and opening clearance, not comprehensive scene collision avoidance. Dimensions support gameplay geometry, not architectural compliance.

The Unreal Automation window exposes the BuildingToolkit tests after compiling. Automation covers footprint areas and courtyard exclusion, override preservation, invalid-input retention, deterministic IDs, triangle winding, doorway collision, and PCG/actor layout equivalence.

Office blocks

The office benchmark adds a 24-floor glass/metal tower, a substantial podium and mechanical crown. Reusable facade styles define floor/edge bands with glazing, mullions, fins and shades. Geometry tiers and optional interior slabs control authoring cost. See Office architecture for usage, measured budgets and remaining city-scale performance work.

Office glazing now supports shader interiors: parallax rooms, a library of 100 furnished variations, blinds and selective night lighting. The saved comparison map covers editable, rotated PCG and Nanite output. Room-grid controls and current footprint/scale limits are documented alongside the material. L_InteriorLibrary100 presents all 100 named rooms in a labelled gallery. Ten room-family presets and individual room presets share one texture array/material.

The night lighting controls synchronize window emission and explicitly registered fixtures with the sun or game clock. The mixed street benchmark includes seven editable buildings and day/night previews. Local Fab kit acceptance covers Soul City, Modular Building Set and Modern Villa Kit; their licensed assets and derived bakes are excluded from this repository.

Mesh kits and building details

The toolkit separates the footprint, facade slots and asset registration. A mesh does not need to share the dimensions or pivot of another mesh in the kit.

Register a facade module

In the Building Editor's advanced panel, expand Mesh Kit > Modules and add a module. Choose Solid Wall, Window, Door or Trim and assign its Static Mesh. A Building Mesh Kit data asset shares the same modules and detail rules across buildings; local modules take precedence. Edge Id and first/last floor restrict where a module can appear. Weights select variants deterministically from the building seed.

The module convention is X across the facade, Y depth and Z up. Set Orientation when the source art uses different axes. Scale defaults to one. Actual mesh bounds supply the size and centre; enable Override Bounds when decorative projections make those bounds unsuitable. Logical Size and Logical Center describe the intended module cell in the mesh's local coordinates. Offset positions the art relative to that cell.

Native meshes retain their material slots and UVs. Procedural wall infill completes the remaining bay. Assets that cannot fit report a warning/error rather than being silently squashed. Empty doorway overrides omit a door module. This is module substitution and fitting, not a complete facade grammar or automatic interpretation of arbitrary art.

Place props and decals

Choose a Prop mesh or Decal material, press P, then click the selected building's roof or facade. Q finishes. Meshes keep their original size and materials. Antennas, satellite dishes, air conditioners and other Static Mesh assets use this same path. Placement requires collision on the receiving building. Decal materials must use the Deferred Decal domain; decal size includes projection depth.

The resulting entries appear under Details > Items. Edit their registered asset, orientation, offset, scale, collision, surface anchor or decal dimensions there. Roof anchors use normalized X/Y across the footprint bounds; facade anchors use an edge Id, distance along that edge and normalized building height. Z is lift in cm. Local anchors use building-local cm. Resizing relocates the surface anchor without scaling the prop. Align to Surface is optional. Removed facades and anchors outside the roof are retained and reported so authored work is recoverable.

Detail Rules repeat an item on roofs/facades using spacing, clearance, probability, count limits and seed. Basic bounds and opening checks avoid common overlaps. They do not replace complete scene collision testing. Individual item movement currently uses the advanced panel; dedicated prop gizmos and inner-courtyard facade placement are still future work. Mesh kit assets can be created through Content Browser's Data Asset action using Building Mesh Kit.

Shape editing

D draws a simple polygon of up to 32 corners, including concave and angled shapes. Enter or clicking the first point closes it; Backspace removes the last draft point. E exposes white corner handles and green midpoint insertion controls; drag, insert and Delete participate in undo. S toggles the 1 m grid. The full panel and Tab compact toolbar follow the Street Editor's colors, spacing and viewport interaction.

L-gables join two roof wings with shared ridges/valleys. Custom gables use a bounding ridge clipped to the outline; they do not solve arbitrary hip/intersecting roof networks. Moving an L's corner converts it to Custom and therefore changes this roof policy. Courtyard holes remain controlled through width, depth and wing width. Invalid insets, self-intersections and collapsed overhangs preserve the last valid preview.

Output and validation

Baking includes native mesh LOD0 geometry/materials and generates lightmap UVs. Decals remain separate components on the editable actor. Newly created PCG graphs generate UV-preserving structural surfaces, registered mesh instances and decal actors. Graphs snapshot settings; recreate a graph or edit its layout settings after changing the source building. Existing graphs with scaled canonical primitives must be recreated to use the shared surface builder. Kit profiles calibrate generated wall texture size.

Verify a new profile on editable, PCG and baked output. Check native dimensions, materials, decals and collision in the target project.

Design references

The packaged starter material palette supplies five Poly Haven PBR sets, semantic defaults and upright roof equipment mounts. It includes commercial redistribution provenance and source assets.

SideFX's Building Generator Utility separates module dimensions from visible bounds. That supports explicit logical cells for projecting trim and unusual pivots. Its Building Generator also illustrates why wall, corner, ledge and floor-pattern responsibilities belong in separate authoring controls. The current toolkit implements only part of that scope.

Epic's PCG shape grammar is relevant to the next facade-pattern layer. City Sample informs the separation between city metadata and building art, while Epic's decal materials documentation supplies the material/projection requirements.

The core does not implement a complete shape grammar, editable roof zones or general road-network parcel extraction. Profile city-scale results separately.

Balconies and roof details

Open Tools > Building Editor and select a building. Actions use the Street Editor panel styling and full/compact layout. Advanced settings expose the authored arrays; changes rebuild the same building and support undo.

Balconies

Add balcony to selected facade creates a slab, three-sided railing and an upper-floor doorway. Select a footprint corner in Edit mode to choose its outgoing facade; otherwise the first facade is used. The action searches upper floors and bays for a clear slot. At least two floors are required.

In Settings → Balconies, edit the unique Name, Edge Id, zero-based Floor/Bay, Width, Depth, Slab Thickness and Rail Height (centimetres). Floor 1 is the first floor above ground. Create Door supplies a door only when there is no explicit opening override. Railing can be disabled. The slab uses Floor material and rails use Trim. Up to 64 balconies are supported. Invalid, overlapping or facade-crossing balconies are retained with warnings and omitted from generated geometry.

Choose a mesh in the prop picker, press P, then click the balcony floor. The item is anchored to its balcony name and follows building edits. Its Position X/Y are normalized across width/outward depth; Z is lift in centimetres. Native mesh bounds, scale, orientation and pivot determine floor contact. Oversized items are rejected rather than squeezed to fit. Removing or renaming a balcony retains its items with a missing-anchor warning. Use the item's Balcony Id to reattach it.

Generated balcony parts and registered props flow through preview, PCG and mesh baking. Individual prop editing uses Advanced Settings; dedicated prop transform gizmos and custom railing modules remain future work.

Furniture and wall equipment

Furnish balconies: seat + planter fits the original slatted bench along the left side and a timber planter near the outer right corner. Both preserve their native size. A doorway-width corridor with 15 cm side clearance remains open, including wider or offset explicit opening overrides. Existing furnishings and obstructed slots are skipped. The planter includes soil; add your own foliage mesh for planting. Replace either mesh in Items, or supply custom meshes to the Blueprint/Python FurnishBalconies helper.

Mount prop beside balcony door uses the Prop mesh on the first balcony with a free equipment slot. It creates two fitted brackets and a service conduit. Registered asset +Y faces into the wall; adjust Asset → Orientation for meshes with different source axes. For example, the local HVAC pack's unit needs Yaw -90. The action reserves door clearance and starts with a 12 cm wall gap and a centre 110 cm above the balcony.

The new Balcony Wall surface follows Balcony Id. Position X is normalized across balcony width, Y is normalized over one floor's height, and Z is the wall gap in centimetres. Wall Mount Block supplies the bracket mesh; Service Conduit toggles its connection. The supplied metal block works with arbitrary pivots and native dimensions. These mounts appear in preview, PCG and baked output. Keep Balcony Door Clear can also be enabled on manually authored floor items. Invalid placements remain authored with warnings, so they can be corrected without losing the item.

Add rooftop service details adds editable rules for a raised hatch, up to four louvred vents and one antenna on flat roofs. Pitched roofs receive an upright antenna with roof-contact supports. Existing service rules are skipped. The palette is original distributable geometry; materials use the toolkit's timber, concrete and metal. The closed hatch is visual dressing and does not cut a playable opening. Bounds and clearance checks are not building-code validation or a complete rooftop path planner.

Flat roof scatter

Choose a mesh and click Scatter prop mesh on flat roof. This creates a deterministic Detail Rule with a Flat Only filter, jitter, yaw variation and a count limit. Set the building seed or rule Seed to produce another arrangement. Custom air conditioners, vents, furniture or other registered assets retain their own dimensions and materials.

In Settings → Detail Rules, Spacing, Row Spacing, Grid Offset and Clearance are centimetres; Row Spacing zero uses Spacing. The roof bounding box distributes grid cells with at least the requested spacing. Grid Offset slides the grid without moving the roof. Probability controls density; Max Count caps the result. Jitter is 0–1; Yaw Variation is degrees. Bounds checks avoid courtyard holes, roof edges and previously placed prop bounds, but are not full scene collision tests. Some slots can be skipped; inspect the rule's warning count.

Sloped roof solar arrays

Add solar panel array creates a Pitched Only rule with the included original Meshes/SM_SolarPanel. The 110 × 175 cm panel has metal framing, a cell grid and mounting rails. Landscape orientation is the starter default. It follows the roof slope, with its long side along the eaves; candidates crossing a ridge or extending past an edge are rejected. Adjust spacing and Grid Offset to fit narrow roof wings. A valid roof can have no valid slots for a large mesh.

Replace Item → Asset → Mesh to use a custom solar panel; set its orientation, scale and optional logical bounds for its mounting footprint. Align To Surface follows the slope. Disable Generate Roof Mount for panels that include their own mounts. Preferred Roof Direction is a building-local XY downhill direction, with Direction Tolerance in degrees; zero accepts all directions. This is a directional placement filter, not a sunlight/yield simulation. Solar array rules are reusable through mesh kits and presets.

The separate showcase includes a furnished balcony, rooftop services and a solar example. Use the included detail meshes or register your own. Purchased HVAC models and their development test maps are excluded from distribution.

Building detail sample

The seven buildings in L_StreetBenchmark use separate fidelity facade profiles and material instances under /UltimateBuildingToolkit/StreetFidelity. The road layout is presentation context; this example does not require Ultimate Road Tool.

The heritage facade adds an open stone entrance portal with 17 arch blocks, columns, fanlight, cast lettering, stepped dentil cornices, window pediments and Juliet guards. Brick examples add drainpipes, guards and larger shopfront glazing. The office tower has separate curtain-wall and crown bands and rooftop mechanical screens. Its podium adds two roof planters with Poly Haven jacaranda trees, seating and a continuous terrace guard. Apartment balconies widen to 4 metres, with side troughs outside the reserved door corridor.

All architectural pieces are registered mesh attachments in building settings. They use measured mesh bounds, preserve their materials, and participate in regeneration, preset export, PCG generation and static-mesh baking. They can be edited or replaced through the existing item tools. These are sample arrangements, not new automatic architecture rules for arbitrary building shapes.

Materials and source assets

M_WeatheredLimestone adds restrained vertical weathering and shallow joint normal relief to the existing scanned stone surface. The relief affects shading, not silhouettes or collision. M_ArchitecturalGlazing preserves the room-array interior shader and global night controls, with per-pane coating variation and subtle reflection distortion. Each building has a separate occupancy seed.

Fourteen original meshes include editable Blender sources and FBX exports in SourceArt/StreetFidelity/Original. The jacaranda model and its 2K maps are CC0 from Poly Haven, with authors and download checksums in SourceArt/StreetFidelity/manifest.json. Powered by Poly Haven. Imported meshes have Nanite enabled; foliage uses masked two-sided materials. Static-mesh baking reads each source mesh's LOD0 fallback geometry; source Nanite fallback settings therefore determine how much small detail the combined bake retains.

Use the saved examples and presets to explore these assemblies. Keep native instances when source Nanite detail or repeated-mesh memory efficiency matters. Empty balcony troughs can be populated with your own planting assets.

These examples do not provide playable interiors, animated trees, a full facade grammar or a city streaming system. Profile the resulting meshes and materials against your game's target hardware.

Custom wall mesh registration

In the Building Editor's existing settings panel, expand Mesh Kit → Modules (or edit a BuildingMeshKit asset). Each module exposes Exterior Facing beside its mesh and fit mode. It declares the mesh's visible exterior side, after any correction in Asset → Orientation:

First orient the source so Z is up. Then choose the side that should face outside. Registration preserves handedness and applies the same convention on every wall, including courtyard and concave walls. Existing presets retain the −Y default. It does not infer the visible side from bounds: bounds alone cannot distinguish the front and back of a one-sided facade.

The source mesh, its pivot and its materials are unchanged. Logical Size/Center use built mesh coordinates (including import build scale), and Asset Offset remains in wall coordinates: X along the wall, +Y into the building, Z up. Native Size retains source dimensions; Uniform Fit retains proportions. Stretch to Fit supports cardinal facing changes and permutes scale axes correctly. A rotated stretch that would require shear is rejected with a message to use uniform fit or reorient the source mesh.

Placement measures the built render bounds, excluding culling padding. Unreal's editor bounds can instead come from an unscaled MeshDescription; using those dimensions for an imported mesh can create overlapping bays and open floor seams. Logical bounds remain an explicit override for the module's intended joining cell. For example, register a projecting cornice around the underlying wall plane, so the cornice does not push the entire wall behind its filler panels.

Disable Facade → Automatic Floor Trim when the kit includes floor cornices. Otherwise the toolkit adds another band at each floor. Native Size needs bay and floor dimensions that accommodate the built mesh; Uniform Fit can leave filler space because it preserves proportions.

Reusable surface settings

In the BuildingMeshKit asset, Surfaces adds two settings:

Assign the profile under Mesh Kit and reuse it on other buildings. Source modules keep their own materials and UVs. A custom wall material explicitly set on the building overrides the profile material; the starter default or an empty slot uses the profile. For example, a 300 x 280 repeat keeps the same brick size when a generated wall gets longer. Match these values to the kit's visible wall texture; they are not the module's outer dimensions.

Newly created PCG graphs generate structural surfaces through the same geometry and UV builder as editable actors. Their native modules remain instanced. Existing graphs must be recreated to replace the old scaled primitive surfaces. PCG manages the generated surface component during regeneration and cleanup. These live procedural surfaces are not Nanite; bake the building for a static mesh output.

This works with ordinary tiling UV materials without modifying their shaders. An atlas material needs an appropriate tiling material for generated surfaces; one repeat size cannot reproduce every source mesh's hand-authored UV layout.

Editing the footprint

Select the editable BuildingActor, open Building Editor, then choose Edit points (E). Actors with a PCG or Baked suffix are generated outputs. Refresh their graph or bake after editing the source footprint.

Authored decorations

In Items → Asset, Orientation puts the mounting back toward +Y and the visible front toward −Y; Scale controls the full object, including hanging geometry. Place the full projected footprint on solid wall, with clearance from windows. Do not treat a custom wall module's bounding box as proof that it is solid: the module may contain its own windows. The local Soul City bracket/banner example uses yaw 180°, scale 0.35, and masonry bay seams. Its checks use the explicitly identified Glass_Opaque material triangles as window exclusion areas. This is a registration for that kit, not automatic window recognition for arbitrary meshes.

PCG graphs and presets store a snapshot of the building settings. After correcting an editable building, recreate its PCG graph and regenerate the PCG component; rebake static outputs as well. Changing the actor does not update old graph or bake assets automatically.

Check a new kit

Inspect the generated building from every side. Outward-facing and upright orientation, module spacing, corners, open windows and internal geometry need visual checks; correct instance counts and material slots alone do not prove a good fit. Test a resized footprint and a rotated actor before using the profile throughout a district. Purchased kit assets and development test maps are not included.

Furnished interior library

The office glazing uses 100 baked, furnished room variations, selected by one shared box-projection material. These are ten room programs with ten design schemes each, including changes to staging, storage, wall treatments and lighting. They are not 100 entirely unrelated architectural floor plans.

Browse and use

Open /Game/BuildingToolkit/L_InteriorLibrary100 in the separate example project to see all 100 labelled windows. Rows are room programs and columns are design schemes. The gallery has brighter presentation-only child instances and a fixed front-view capture preview, so higher rows do not just show ceilings. Set a gallery child's PreviewMode to 0 to examine camera-driven parallax there. Its centred grid and preview settings are separate from the production building presets.

In the Content Browser, enable plugin content and open: /UltimateBuildingToolkit/Materials/Office/Interiors/Library.

• Rooms: 100 named MI_Room_000_... through MI_Room_099_... presets.
• Families: ten presets that randomise within a room program.
• TA_InteriorRooms_100: one texture array containing the entire library.
• Captures: the 100 source textures used to construct that array.

Assign a room or family instance to the building's Glass material slot (index 4). Duplicate an instance before changing it, then match its room grid to the facade. The existing teal Building Editor forms and material assignment workflow remain in use. MI_OfficeInterior_Tower and MI_OfficeInterior_Podium mix all 100 rooms. Their asset paths are unchanged, so existing presets, PCG graphs and Nanite bakes retain their references. Entrance doors keep their separate coated-glass material.

The schemes are Nordic Oak, Midnight Walnut, Terracotta Atelier, Coastal Linen, Sage Workshop, Graphite Brass, Burgundy Club, Cobalt Gallery, Sandstone Calm and Forest Modern. The final digit of the room ID identifies the scheme.

Material controls

M_InteriorLibrary contains one custom expression and a small parameter graph. Room contents are data in the texture array, not a chain of 100 shader branches.

A nonnegative RoomIndex takes precedence over RoomFamily. Room selection and occupancy are deterministic for the same facade coordinates and seed. Changing seed changes the distribution without regenerating building geometry.

NightAmount blends from 0 to 1; it does not change the level's sun or sky. MI_OfficeInterior_Night is a night preset. Lighting is artistic, not photometric. The room captures contain baked indirect light; switching night amount modulates the baked appearance rather than physically relighting individual objects. Blinds occupy a separate shallow depth and occlude the room behind the glass.

Mapping contract and limits

The shader intersects a virtual room box, reprojects the hit point from its capture centre and samples a forward-hemisphere panorama. The source room is 4 m wide, 3.88 m high and 5.5 m deep. Each axis adapts to the configured facade bay/floor/depth. The capture and engine handedness are reconciled so rooms are not mirrored.

Coordinates are anchored to the owning building/PCG actor, not each glass instance. Vertical face normals define the horizontal basis, supporting translation and yaw rotation. The owner origin uses UE 5.8 shader helpers; other engine versions need a compile check. Resize buildings through Settings and keep their actor scale at 1. Set a PCGVolume's actor scale to 1 before generating these building graphs.

Match BayWidthCm and FloorHeightCm to the actual generated bays and floors. The layout solver redistributes bays if an edge does not divide evenly. Different bay widths per edge do not yet auto-calibrate the material. Partitioned PCG/HLOD origin rebasing still needs separate validation.

This is an exterior-window illusion. Furniture and its lighting are baked into room projections; furniture does not have independent ray-traced depth. Extreme side angles, very close cameras and large changes to room proportions can reveal stretching. Corners are independent rooms. Collision, reflections and gameplay still see the glass surface. Use actual interior geometry for enterable rooms or hero close-ups. The old procedural M_OfficeInterior and OfficeInterior.ush are retained as legacy assets; shipped example instances now use M_InteriorLibrary.

Source assets

The furnished room captures and their presets are bundled and work offline. Poly Haven clay plaster and wood surfaces come from the starter palette; the modern armchair, potted plant and occasional traditional sofa also come from Poly Haven. Original files, texture dependencies, authors, URLs and checksums are recorded under SourceArt/InteriorMapping/Furniture/manifest.json. Poly Haven assets are CC0.

The library catalogue maps all 100 room IDs to their asset paths. Duplicate the supplied instances to change room selection, exposure and grid calibration. Replacing a room capture requires updating the texture array as well as the individual source texture; these are distinct assets.

Performance

The shader samples one texture-array slice for a room, regardless of library size. It adds no interior furniture actors or furniture draw calls. Mipmaps are generated independently per slice, with clamped addressing and a 150–350 m detail fade. The 100 1024-square BC7 slices require approximately 133.34 MiB with all mip levels resident, excluding engine overhead. Streaming is enabled on the asset; actual residency depends on the platform and texture-array streaming support. A 512-pixel maximum texture size reduces the theoretical full-chain budget to about 33.33 MiB. These are estimates, not measured GPU timings or a city-scale performance guarantee.

Night lighting and mixed-building validation

Use Building Editor → Night lighting → Setup / select once per level. The panel follows the existing street-tool typography, spacing and teal accents. Day and Night are lighting previews. Auto follows the assigned directional sun, or the Clock mode when no sun is assigned. Toggle lights is the master switch. Selecting the controller exposes clock, twilight and fixture settings.

The runtime Building Night Lighting actor updates every 0.25 seconds in the editor and game. Sun mode is off at and above the horizon and fades on across the configured below-horizon twilight angle. Clock mode is off throughout daylight, fades after sunset and before sunrise, and wraps negative/multi-day clock values. Call SetTimeOfDay from the game's time system with Mode=Clock. Call SetLightingEnabled for a gameplay or accessibility switch. A missing sun in Sun mode fails closed. Only one controller writes per world.

MPC_BuildingLighting publishes NightAmount and LightingEnabled. The supplied interior material uses both by default. Its artificial light term is exactly zero during the day; daylight fill remains separate. LightingEnabled=0 on a material instance disables that material's artificial light. UseGlobalLighting=0 opts into a local NightAmount for material previews. The explicit Night material and the room inspection gallery use this local preview option.

The Fixtures array explicitly registers light actors and their night intensities, using each component's configured units. The controller does not scan and modify unrelated lights. Add movable spot/point/rect lights where illumination is needed; window emission is not a substitute for reliable street lighting. Supplied street fixtures use lumens, bounded attenuation and maximum draw distance. Their material also reads the collection. Level fixtures are independent actors: parent/move them with a building or use your own construction logic when changing its location.

Imported kit materials keep their authored appearance. To make their emission follow this system, multiply their emissive input by the two collection scalars in a project-owned material copy. Merely registering a light actor does not rewrite arbitrary third-party material graphs. The controller drives illumination; the game's sky, weather and sun movement remain the responsibility of its time system.

Example and performance

/Game/BuildingToolkit/L_StreetBenchmark in the separate example project contains seven editable buildings with stone, brick, apartment, podium and tower architecture, CC0 surfaces/furniture, balconies, roof equipment and 28 managed fixtures. Its presets are under /Game/BuildingToolkit/Street/Presets. Use the Building Editor's Day, Night, Auto and Toggle lights controls to inspect the controller.

Preview buttons affect building lighting. A night sky and directional sunlight must also be configured by your level or time-of-day system. Do not expect the building controller to replace a weather or sky system.

The editable sample is an authoring example. For game use, evaluate baked output, preserved native instances, streaming, fixture draw distances and material cost in a packaged build. Window interiors are projected imagery with oblique-angle limits; they do not create enterable rooms.

Using third-party kits

Purchased kits are not included. Register their dimensions and facing, preserve their authored materials, and explicitly integrate any emission with the lighting collection if desired. Instanced meshes need suitable material usage flags.

Static-mesh baking preserves vertex colours and up to four source material UV sets, then generates a separate lightmap channel. Sources with more than four material UV sets are rejected instead of silently losing channels. Use native instances for such assets. The bake does not enable cooked CPU access on source meshes.

Office architecture

Open /Game/BuildingToolkit/L_OfficeBenchmark in the separate example project. The editable example has a 72 x 56 m, three-floor podium, a 48 x 36 m, 24-floor tower and a mechanical crown. Total structural height is 120 m, plus roof parapets. This is an exterior authoring benchmark; it has no occupied interior, lifts or stairs. The glazing now adds parallax shader rooms, with furniture, blinds and night-light controls, while the building remains an exterior shell.

Authoring

Select a BuildingActor and open Tools > Building Editor. Architecture Style uses the same asset picker and green section styling as the rest of the tool. Choose DA_OfficeCurtainWall or DA_OfficePodium under the plugin's Facades folder. Existing houses with no style retain their original window generation.

Create a Data Asset of type Building Facade Style for your own architecture. Each named band specifies an inclusive, zero-based floor range and optionally a stable edge ID. Empty Edge ID means every facade. Overlapping floor/edge ranges are rejected; split the ranges instead of relying on hidden precedence.

Bands control opening proportions, recess, frame dimensions, pane subdivisions, projecting fins and sunshades. Explicit opening overrides and registered window or door meshes take precedence. Meshes still use their registered bounds and fitting policy. Balcony doors remain doors. Style changes require rebuilding the buildings that reference the style; they are not pushed automatically.

Under Settings > Architecture, Facade Detail selects Envelope, Frames or Architectural. These are authored geometry tiers, not automatic distance LODs. Under Structure, turn off Interior Slabs for exterior-only blocks. Ground and roof slabs remain. The example uses separate volumes: resizing the podium does not automatically reposition the tower or crown. The Poly Haven terrace furniture uses roof anchors and follows the podium height and footprint bounds.

The office presets are in /Game/BuildingToolkit/Office/Presets; the tower PCG graph is in its PCG folder. The graph snapshots building settings and references the facade asset. Editing that shared asset affects future graph generations.

Rendering and budgets

The window material combines an opaque reflective coating with parallax room interiors; entry doors retain the earlier coating. These rooms are visual only. The sample uses satin aluminum, champagne metal, dark spandrels and world-space paving. The daylight cubemap comes from Unreal's Engine content. No purchased prop pack is required by this benchmark.

The Poly Haven office palette adds scanned surface materials, physical tiling, close-range relief and eighteen roof-anchored furniture/plant instances. Its podium preset and PCG graph retain those assets and native materials.

Buildings allow 1–64 floors subject to the existing 2,048 facade-slot and 30,000 part budgets. Wide 64-floor blocks can exceed those budgets. Split large schemes into volumes, increase bay size or reduce geometry detail. Invalid edits retain the last valid preview and report the error.

The detailed tower contains 13,848 structural parts. Part count is not draw-call count: the editable actor combines its generated surfaces into material sections. New PCG graphs use those same structural surfaces and instance registered meshes. Older example graphs using scaled primitives can be recreated from their editable building to adopt the surface path; the interior comparison demonstrates it.

Procedural previews serialize their geometry, so detailed authoring maps can be large and expensive to save. Disable Auto Rebuild during bulk changes and rebuild explicitly when ready. Evaluate baked meshes and retained native instances for game use; avoid rendering the editable and baked versions at the same transform.

Baking and PCG do not create streaming cells or HLODs. Configure collision, streaming, HLOD and material quality for the target game, then measure a packaged build. The example is not a city-scale frame-rate or memory guarantee.

Shared authoring output

The editable actor and PCG output share the same layout solver. Facade bands, roof geometry, balconies and attachments retain separate settings. Save a preset to reuse an arrangement; recreate generated graphs and bakes after changing it.

Poly Haven office palette

The office benchmark uses scanned concrete facade surfaces, granite entrance details, staggered concrete paving, assembled timber-and-metal benches and planted pots. All imported content lives under /UltimateBuildingToolkit/PolyHavenOffice. These assets are included for offline use; no account or runtime download is needed.

Materials

Choose the MI_PH_* instances in the Materials folder for building material slots. The shared M_WorldSurface projects in world space with triplanar blending, so scaled primitives and PCG output retain physical texture size. TileSizeCm is the width of the entire repeating scan, not the width of one brick or paver. The source dimensions set repeats of 1.59–2.00 metres. Tint, NormalStrength, RoughnessMultiplier and DepthCm provide local art direction.

The master uses diffuse, DirectX normal, packed AO/roughness/metallic and height. Normals are reoriented into world space. Editable procedural meshes use 16-step parallax relief per active projection, fading between 8 and 18 metres. Nanite uses the unshifted coordinates and inward geometric displacement instead, avoiding double relief. Depth is bounded to 1 cm; the selected concrete/paving/stone defaults are 0.10–0.35 cm. This does not change collision, and parallax cannot change the preview silhouette. Nanite tessellation must be enabled in the target project.

World projection stays fixed in the world: moving an actor changes its sampled texture position. It is intended for static architectural surfaces. Use the original UV-based starter master or an asset's own UV material when the texture must move with the mesh. Triplanar sampling and close-range parallax cost more than a simple UV material; measure cooked performance on the target platform.

Furniture and greenery

Models/modular_street_seating/SM_PH_OfficeBench is a 190 × 67 × 87 cm assembled bench. The source FBX is a layout of loose modular components. The included Blender assembly constructs a usable seat from its wood, supports and armrests while preserving source UVs. The original FBX remains in SourceArt for other assemblies.

Models/potted_plant_02/SM_potted_plant_02 measures 70 × 66 × 84 cm at native size. Its leaves use masked, two-sided foliage shading and a separate ceramic-pot material. The source OpenGL model normals have their green channel flipped on import. Building surface normals use the supplied DirectX maps without a second flip. LeafTint controls the foliage color; the benchmark uses a restrained exterior tint.

The podium contains six benches and twelve pots as stable, normalized roof anchors under Settings > Items. The example scales pots uniformly to 1.25. Anchors follow the podium's roof height and footprint bounds and preserve native mesh dimensions, pivots and material slots through rebuilding, presets, PCG and baking. Furniture collision is disabled in this decorative sample. Placement has no wind animation. Separate tower and crown volumes are not automatic obstacles for roof scattering; the authored terrace row deliberately stays in front of the tower.

For another building, use the existing viewport mesh picker and P placement, or register either mesh in an attachment/rule. No separate form or UI style is introduced.

Use the included assets

The Unreal assets are ready to assign through the Content Browser and building material/item settings. Blender and Python are not needed to use the plugin. Duplicate a supplied preset or material instance before changing it.

A static mesh bake is a separate asset. Replace the editable representation when placing that bake; overlapping both outputs produces coincident surfaces.

Credits and redistribution

Powered by Poly Haven. The original asset files are CC0, including commercial use and redistribution. Source URLs, authors, dimensions, exact download URLs and MD5 hashes are retained in SourceArt/PolyHavenOffice/manifest.json; derived bench modifications are recorded in Derived/PH_OfficeBench.json. This permission applies to the asset files, not Poly Haven's logo, site text or example renders.

• Concrete Tiles 02, Granite Tile 02 and Granite Tile 03: Charlotte Baglioni.
• Precast Concrete Wall: Dimitrios Savva.
• Concrete Wall 006: Charlotte Baglioni (photography), Dario Barresi (processing).
• Modular Street Seating: Stuart Attenborrow.
• Potted Plant 02: Rico Cilliers.

The warmer patterned granite and weathered precast sets remain optional palette alternatives; the main facade uses Concrete Wall 006. The office glazing remains the toolkit's opaque coated-glass approximation, now supplemented by a separate parallax interior pass. Surface scans alone do not provide playable interiors or make the toolkit production-ready.

Starter materials — Powered by Poly Haven

The plugin includes five curated 2K PBR texture sets from Poly Haven. These source assets are CC0-1.0, separately from the toolkit code. They may be used commercially and redistributed in a sold product under Poly Haven's asset license. The photographs/textures are Poly Haven artists' work, not exclusive toolkit artwork.

Physical repeats start from the API's dimensions in millimetres. Brick is calibrated to 1.5 m for the starter architecture (the source metadata is 3 m). Adjust TileSizeMeters in a material instance to suit the architecture.

Enable Show Plugin Content in the Content Browser, then open UltimateBuildingToolkit/Materials. The seven building slots are Wall, Floor, Roof, Frame, Glass, Door and Trim. New buildings use the packaged palette. The default Roof slot resolves to concrete on flat roofs and clay tiles on pitched roofs. Empty legacy or preset slots fall back to that palette; explicit custom material assignments and imported mesh materials remain intact.

PolyHaven/MI_PH_* supplies an instance for each source set. Duplicate an instance to make a project-specific finish. M_Surface exposes BaseColor, Normal, ARM, Height, DepthCm, Tint, TileSizeMeters and RoughnessMultiplier. Albedo uses sRGB; DirectX normals use normal-map compression without flipping green; ARM is linear mask data: red AO, green roughness, blue metalness. Height is linear single-channel BC4 data. Lossless normal/mask/height source maps and JPEG albedo are bundled at 2K. Glass is a separate opaque reflective starter surface; it is not transparent architectural glazing.

Surface relief and displacement

Editable procedural buildings use parallax occlusion mapping: 12–32 height samples, fading between 8 and 18 metres. It adds visible mortar recesses without adding geometry. It does not change silhouettes, cast displaced shadows or alter collision. Brick defaults to 1.2 cm depth, tiles 2 cm and wood 0.25 cm; plaster and concrete default to zero. DepthCm is clamped to 0–5 cm. Height and normal maps work together.

Bake Nanite mesh (displacement) produces a separate Nanite-enabled Static Mesh. The material switches off parallax on Nanite and uses height-driven tessellation. Enable r.Nanite.AllowTessellation=1 and r.Nanite.Tessellation=1 in the project's renderer configuration; the validation project includes these settings. Place the baked building at unit scale to retain centimetre depth. The editable actor is retained; replace or hide one when placing the bake to avoid overlapping geometry.

Epic describes Nanite tessellation as experimental. Displacement does not update physics; hard-normal boundaries and UV seams can split. The starter displaces inward from its original surface to keep brick peaks against trims. This is a development option requiring target-platform profiling and seam inspection, not a production performance guarantee.

Editable, baked and newly generated PCG building surfaces share continuous UVs, defaulting to one repeat per metre. Pitched roof V follows the downhill direction, with U along the eaves. Mesh kit profiles can override the generated wall material and physical repeat size. Native modules preserve their source UVs. Recreate older PCG graphs to replace scaled canonical primitives with the shared surface builder.

SourceArt/PolyHaven/manifest.json records the original URLs, artists, dimensions, resolution, sizes and MD5 checksums. Materials and source textures are bundled for offline use; no download script or runtime API request is needed.

Roof equipment mounts

Upright mesh items on pitched roofs now default to Generate Roof Mount: a level plate and four supports sampled against the roof. The mesh retains its dimensions and orientation. Mounts are ordinary generated parts, included in preview, PCG and baking. Their material is the building's Trim slot. Surface-aligned items and flat roofs do not receive these mounts. Disable the option when a custom asset already includes suitable supports. Logical bounds, orientation and scale determine the mounting footprint. An anchor whose mount extends beyond the roof is retained with a warning rather than creating unsupported geometry.