Chapter 3. Content Pipeline

Getting your existing scenes and content into UE4 is likely one of the first things you want to do after the Editor is running. It might also be your first major roadblock, especially if you’re looking to convert large, existing ray-traced visualization scenes over to UE4. By understanding what you need to do to prepare your content for UE4, you can save a huge amount of time by doing it the “Unreal way” the first time and get the quality and performance you and your clients expect from Unreal Engine 4.

After your image or animation is rendered, you then load your image(s) into a post-editing application to add effects and titles, edit footage, and add audio. When it’s complete, a final version is rendered to a video or image file and shared with your audience or client (see Figure 3.1).

UE4 is a standalone application and doesn’t integrate directly into any 3D application. Instead, you use 2D and 3D applications to produce 3D models and textures that you must export to an exchange format (FBX, TGA, and so on) and import into UE4 (see Figure 3.2).

After import into UE4, you build your worlds within the UE4 Editor: adding lighting, materials, and interactivity. There is no Render button; the Viewport renders everything in real time, producing final-quality images including post-processing effects like motion blur, depth of field, and color grading.

To add interactivity, you use Blueprints, C++, and Unreal Motion Graphics (UMG) to create user interfaces and other onscreen titling. Sequencer allows you to create Hollywood-quality cinematics using a non-linear editor, physically based cameras, and camera rigs.

After the project is complete, you can deliver your application on any number of platforms: Mac, Windows, VR, mobile, and so on. You can also render high-quality stills and animations.

The UE4 workflow uses a lot more artist time than raytracing. Why? Remember those insanely fast render times (.016–.033 seconds per frame discussed in Chapter 1) One of the best ways of making things render faster is to do the processing work ahead of time and store it in various ways. Baking in lighting, recording details using normal maps, or even the lowly act of assigning UVW coordinates all free up processing resources.

The upside is that your downtime during the UE4 workflow is almost zero. Exporting, importing, and processing data in UE4 is very fast. The only processes that take extended periods of time are typically threaded and can run in parallel with the Editor, allowing you to continue working in-Editor while you bake lighting or compile the project to run on a different platform.

You’ll also not be spending huge portions of your day waiting for renders. The Viewports in Max and Maya are notoriously terrible for conveying what the lit, rendered scene will look like, often failing to even show materials and textures properly. This forces you to render your scene to preview each of your changes, taking minutes, sometimes hours to get a good idea of how your final image will look.

UE4 is also fast at loading content. The Content Browser opens assets and previews them in real time, and the various editors open quickly even with complex content. Massive levels save and open in seconds, not minutes. The result is an interactive workflow that means you can do more in less time, and if you follow some simple guidelines, a lot of the work will be taken care of for you through automation and other magic.

You must start by organizing your source art files (your Max, Maya, and Photoshop files). Organization is the name of the game and taking the time now to get it right is important.

Changing names, scale, vertex count, pivot points, and so on are all very easy to do in Digital Content Creation (DCC) apps—just click, rename, move, and scale. These apps were made to modify Meshes and bitmaps and are good at it, and you’re probably good at using them to do that. Doing these things is much more involved (if they are even possible) after you have your content into UE4.

A few ways exist to alleviate this issue. The FBX exporter enables you to apply a scale to Meshes while exporting, and UE4 offers an import scale (and rotation) setting for Meshes. These options might or might not work depending on your content and isn’t recommended if you can help it. Instead, try to find a way to rescale your content prior to export.

Max also offers the option to set Display Units. This option does nothing to the data or scene. It is simply a conversion from the scene unit scale to the visual elements in the UI. This lets you keep your content in centimeters and continue to work with familiar units.

Many 3D applications have two-sided rendering enabled by default, showing both sides of objects. This can give you an incorrect view of the geometry because UE4 culls back-facing triangles by default. You can set individual materials and material instances in UE4 to be two-sided, but it’s not an efficient fix and isn’t intended to fix bad content, but is a feature to render specific surfaces such as foliage.

You should turn off two-sided rendering in your 3D applications to ensure you are looking at the same model that you will see in UE4. Fix any face and vertex normal issues in your 3D application before exporting to UE4.

You will usually keep a 1:1 relationship between the objects in your source art, your Content folder, and your UE4 Level. (For example, you’ll have one SM_Wall01 in each in the exact same place.)

You export these objects in place, import them, and place them into the scene at 0,0,0 (or another defined origin point). Keeping your UE4 content in sync with your scene using this method is easy because you can import or reimport Meshes or entire scenes without needing to reposition them.

Having multiple Props reference a single asset reduces memory overhead and makes updating and iterating on content easy.

You will undoubtedly come up with your own standards and system to accommodate your specific data pipelines, but it helps to be on the same page as the rest of the Unreal Engine 4 community as you will likely use and share content with them.

Prefix_AssetName_Suffix

If you looked through any of the content included with UE4, you have already seen this convention.

There are dozens of content types and variations in UE4, each with a different possible naming scheme. You can go to www.TomShannon3D.com/UnrealForViz for a direct link to a community-driven list of all the suggested prefixes and suffixes.

Although this list is exhaustive, none of these naming rules are enforced in anyway. What’s most important is consistency. Develop a system and stick to it.

UVW coordinates are used for a litany of features and effects; from the obvious such as applying texturing to surfaces to the less obvious but equally important things such as Lightmap coordinates.

All of your 3D assets will need quality, consistent UVW coordinates. For simple geometry, this can be as easy as applying a UVW Map modifier to your geometry; more complicated geometry will be a more involved, manual process. Don’t fear; most of the time you can get good results easily. Just keep an eye on your UV coordinates when you are working with UE4. If you have rendering issues that are difficult to diagnose, check your UV coordinates.

If your scenes are already mapped to real-world scale, you should scale your UV coordinates using a modifier (Scale UVW in Max) or manually scale the UV verticies in a UV Editor.

It’s important to note that if you are planning to use pre-calculated lighting with Lightmass, you still need to provide good, explicit Lightmap UV coordinates, even when using world-projection mapping. This is because the Lightmass stores the lighting information in texture maps that need unique UC space to render correctly.

Unique UV coordinates are defined by having no coordinates outside 0–1 and each face occupies a unique area in the UV map space without overlaps. This is useful when you are “baking” information into the texture map, because each pixel can correspond to a specific location on the surface of the model (see Figure 3.3).

Common examples of baking data into textures are normal maps generated from high-polygon models using reprojection or, in UE4, using Lightmass to record lighting and Global Illumination (GI) information into texture maps called Lightmaps.

3D applications can often have trouble visualizing multiple UV channels in the Viewport, and the workflow is typically clunky and often left unused in favor of using larger, more detailed textures. This isn’t an option; massive textures can consume huge amounts of VRAM and make scenes bog down.

Instead, make use of multiple UV channels and layered UV coordinates in your materials to add detail to large objects.

If your project uses dynamic lighting exclusively, you probably don’t need to worry about Lightmapping coordinates at all!

Coordinates need to be unique and not overlap or tile. If faces overlap, Lightmass can’t decide what face’s lighting information to record into the pixel, creating terrible-looking errors.

A space must exist between UV charts (groups of attached faces in the UV Editor). This is called padding and ensures that pixels from one triangle don’t bleed into adjacent triangles.

The last major rule is twofold: Avoid splitting your Lightmap UVs across smooth faces because this can cause an unsightly seam and split your coordinates along Smoothing Group boundaries to avoid light bleeding across Smoothing Groups.

In a broad sense, the Auto Generate Lightmap UVs system is simply a repack and normalization operation that takes a source channel and packs the existing UV charts into the 0–1 UV space as efficiently as possible. It also adds the correct amount of pixel padding between the charts based on the intended Lightmap resolution as set by the Source Lightmap Index. (Lower resolution Lightmaps have larger pixels requiring larger spaces between charts; higher resolution inversely has smaller pixels requiring smaller spaces.)

This only requires that the coordinates in your base UV channel follow the rules about being split along Smoothing Groups and don’t have stretching. They can be any scale, be overlapped, and more, if they are cleanly mapped to begin with.

If you are developing content for mobile or VR, LOD and model optimization are incredibly important. Even if you’re running on high-end hardware, consider creating LOD models for your high-polygon props. For Meshes like vehicles, people, trees, and other vegetation that are used hundreds of times each in a large scene, having efficient LOD models will mean you can keep more assets on-screen, creating a more detailed simulation.

UE4 fully supports LOD chains from applications that support exporting these to FBX. That means you can author your LODs in your favorite 3D package and import them all at once into UE4. You can also manually import LODs by exporting several FBX files and importing them from the Editor.

To generate LOD Meshes in the Editor, simply assign an LOD Group in either the Static Mesh Editor or by assigning an LOD Group at import. I recommend taking a look at it for your higher-density Meshes, especially if you are targeting mobile or VR platforms.

Several third-party plugins, such as Simplygon (https://www.simplygon.com) and InstaLOD (http://www.instalod.io/), can further automate the entire LOD generation process and have more powerful reduction abilities than UE4’s built-in solution.

If you regularly deal with heavily tessellated Meshes, I recommend considering integrating these plugins into your UE4 pipeline, because they are far more robust than the optimization systems in most 3D applications, and the time saved using automatic LOD generation can be significant, not to mention the obvious performance benefits of reducing the total number of vertices being transformed and rendered each frame.

Fortunately, because most visualization does not require complex physics interactions between warring factions, you can use a simplified approach to collision preparation.

You might opt to generate your own, low-polygon proxy Collision Meshes¹ in a 3D package, or in the UE4 Editor using manually placed primitives (boxes, spheres, capsules). You should also take a look at the automatic collision generation options the Editor provides.

Do not confuse convex decomposition with the option to automatically generate collision during the import process. That system is a legacy system from UE3 and is unusable for most visualization purposes because it doesn’t handle large, irregular, or elongated shapes well.

Convex Decomposition is not enabled on import because it can be very slow for large Meshes or Meshes with lots of triangles. For these, you should author a traditional collision shell in your 3D application and import it with your model.

You can find more information about generating collisions in the official documentation and at www.TomShannon3d.com/UnrealForViz.

You might wonder why in the world you would want to override your object’s pivot point, but doing can be a huge time saver. By using a common pivot point, you can place all Architecture Meshes in your scene easily and reliably by putting them into the Level and setting the position to 0,0,0; they will all line up perfectly.

This works because you don’t typically move your Architecture Meshes around, so where they rotate and scale from is irrelevant. What’s important is their accurate position in 3D space.

Prop Meshes are the opposite. As you place props in your scenes, the pivot point is essential for moving, rotating, and scaling them into place.

To get the pivot point in UE4 to match your 3D application, you have a couple options. You can model all your props at 0,0,0, or move them each as you export. Newer versions of UE4 (4.13 and up) allow you to override the default import behavior and use the Meshes’ authored pivot point as well. This is usually the best bet to ensure your pivot points match.

UE4 uses FBX extensively for both Mesh and animation data so knowing what Unreal Engine 4 expects from your exported geometry is important.

If your scene is in a scale other than centimeters, you can easily rescale all of your assets as you export by explicitly setting Scene units to converted to: to Centimeters.

I’m not a huge fan of this method. Several issues can make this workflow clunky and sometimes unstable.

A common issue is that you need to export the exact same set of Meshes each time you update any single one. This task is very hard to maintain, and failing to so can cause crashes and other issues.

Keep an eye on this feature as the engine improves over time. Try to apply it to your data. It could make exchanging data between your 3D application and UE4 much easier.

UE4 can quickly import entire folder structures of FBX files. With this workflow, if you need to update a single asset or a group of assets, you can easily and reliably replace their FBX files and reimport into UE4. This fine-grained approach gives you a great deal of control, and it is the least risky and least technically complicated of the options.

To enable this feature, open Editor Preferences, and define a folder to watch and a corresponding folder in your Content folder (see Figure 3.6).

UE4 allows you to import materials with your Meshes, but the options for import are limited and require your source Materials to be authored in a very specific manner.

This is not to say that importing materials into UE4 is not worth your time—it can be a huge time saver for prototyping and assigning well-authored UE4 Materials. Don’t spend too much time working on your materials in your 3D application, however. A simple diffuse map or color will suffice (and is about all that will come in!).

Most of the rules are technical limitations imposed upon Unreal Engine 4 by the hardware and software UE4 runs on. The Graphical Processing Units (GPU) on graphics cards are specific about how textures are stored, accessed, and rendered, and UE4 is beholden to these limitations.

.bmp

.float

.pcx

.png

.psd

.tga

.jpg

.exr

.dds

.hdr

The most commonly used are BMP, TGA, and PNG.

TGA files are the game-industry standard for 8-bit images. This is due to the explicit control artists have over the content of the image on a per-channel basis. UE4 accepts 24-bit (RGB) and 32-bit (RGBA) TGA files.²

PNG files are most widely used for UI elements because they use a pre-multiplied alpha that lets them blend properly. This alpha, however, isn’t typically suitable for other textures.

I recommend using TGA or BMP for all textures being used in materials.

Textures can be non-square, but should still be a power of two on each dimension; for example, 128 x 1024 is fine.

You can import textures that are non-power of two, but they will not produce Mip-Maps, which introduces various visual artifacts in the project. You should almost always take the time to scale your textures to an appropriate size before importing.

Another option is to include an alpha channel as a separate texture. This can help when you need to share alpha info between different textures or want to have a lower resolution alpha map than the other channels.

You can override compression on a per-texture basis, but you should only do this as required. Uncompressed textures can be up to eight times the size in memory.

Drag-and-drop assets from your file browser into the Content Browser. You can drag multiple files, even entire directories into the Content Browser to import.

Right-click in the Content Browser and select Import.

Use the prominent Import button in the Content Browser.

Auto import assets by defining a folder to watch and a destination directory in your project.

Depending on what type of file you are importing, UE4 presents you with a different set of import options.

You should make your own collision (either in your 3D application or in the Editor by placing Primitives), rely on per-polygon collision (slow on high-poly Meshes), or use the Convex Decomposition Collision generation in the Editor.

If you’re not careful, however, this option can cause a huge mess. To avoid this, you should ensure your materials are well-assigned in your 3D application before exporting. You can also use the Material Instance assignment system to create Material Instances rather than Materials. This is fantastic for those with established UE4 workflows and Material systems, but can be too complex for beginners.

After importing, open the Texture Editor by double-clicking a Texture asset in the Content Browser. The following settings are of the most importance:

Texture Group: Most of your textures can simply be left in the World Group. Normal Maps, HDR Images, UI Images, and other specialty textures like LUTs and vector maps should be set to their appropriate groups. This sets many internal flags to ensure these textures are read and display correctly.

Compression Settings: Setting the Texture Group will often correctly set the Compression Settings; often it won’t. Most textures use the Default setting. Normal maps should always use the normal map setting. UI textures should be set to the User Interface setting to allow proper alpha blending and scaling.

sRGB: The sRGB flag should be true for almost all textures that contain color information. This tells the rendering engine to gamma adjust this texture to display accurately in the scene (UE4 uses a linear rendering pipeline and requires textures to be gamma corrected to match the linear colorspace). Textures used as masks or other “data” maps like normal maps and vector maps should be set to false to ensure the data is read accurately without having a gamma curve applied to it.

UE4 offers an amazing cinematics and animation system with Sequencer, but learning an entirely new system can be daunting and unnecessary. UE4 offers a robust suite of tools to import and export cameras to and from your application and the Editor, allowing you to iterate easily using familiar tools.

Simply select your Camera object in your 3D application and export it as an FBX. You might need to bake out the animation if your camera is attached to a spline or uses any other non-standard transforms (being attached to other objects, using Look-at controllers or modifiers, or being part of a rig, for example).

In UE4, create a new Level sequence by clicking the Cinematic button of the Editor toolbar and selecting Add Level Sequence and select a location to save the Sequence asset (see Figure 3.8).

After the new sequence opens in Sequencer, right-click the dynamically spawned Camera Actor in the Sequencer window and select Import.

Your animation is brought in and applied to the camera. I have experienced some inconsistencies with camera types other than the application defaults such as rotated pivot points or incorrect positioning. You might have to rework your cameras or convert them to standard types to fully utilize this feature.

You can also export the camera’s animation from Sequencer back to an FBX file and import into your 3D application or even a post-editing suite like Nuke to complete a shot rendered in UE4.

1. Low-polygon primitives exported with your Meshes that follow a specific naming convention. For more information, see the Static Mesh documentation at https://docs.unrealengine.com/latest/INT/Engine/Content/FBX/StaticMeshes/index.html#collision.

2. Image formats can be confusing. A 32-bit TGA file consists of four 8-bit channels (RGBA), rather than a 32-bit image format like HDR or EXR that represents 32 bits per channel.