# data[].attributes.body
Used to understand Terrain Party tool, but also the principle of mountainous heightmaps

# data[].attributes.attachment_link.readable_text
0:00 / 18:54•Watch full video

# data[].attributes.attachment_link.title
UE4: Secrets to Generating FREE Real-World Heightmaps from Terrain Party for UE4

# data[].attributes.attachment_link.readable_text
0:00 / 1:26•Watch full video

# data[].attributes.attachment_link.title
UE4 Heightmap Guide: Everything You Need to Know About Landscape Heightmaps for UE4

# data[].attributes.body
Added assistance with virtual cameras

# data[].attributes.attachment_link.readable_text
A Virtual Camera drives a Cine Camera in Unreal Engine by using a modular component system to manipulate camera data and output the final results to a variety of external output devices. In addition, the Virtual Camera system provides its functionality while in the editor and during Play In Editor (PIE) or Standalone Game mode.

The Virtual Camera Component (VCamComponent) is the base component that enables building custom virtual cameras in Unreal Engine.

With the VCamComponent, a user can drive a Cine Camera inside Unreal Engine by adding custom Modifiers and Output Providers.

The Modifiers manipulate the camera data with custom effects such as filtering, tracking, and auto focus. The Output Providers route the output of the virtual camera to Composure, Media Framework, editor viewports, or any devices running the Unreal Remote app.

In addition, this new architecture includes the following:

Multi-User editing support for all features.

The ability to overlay custom UMG controls over the output and interact with them in the editor or on a device.

Built-in support for input hardware such as controllers and touchscreens.

Provides the functionality to switch to any custom tracking system with Live Link.

An updated Unreal Remote app with a new UI and improved streaming performance.

For further documentation regarding the virtual camera system, please see the page links below which include a Quick Start on how to use the Virtual Camera Component to build a custom camera, and an overview of a built-in virtual camera that comes with the engine.

# data[].attributes.attachment_link.description
Unreal’s Virtual Camera system is used to drive a Cine Camera inside Unreal by using a modular component system to manipulate camera data and output the results to a variety of external output providers.

# data[].attributes.body
Landscape technical guide

# data[].attributes.attachment_link.readable_text
Technical Settings for Landscape.

Choose your operating system:

To get the best performance possible from the Landscape system, there are certain technical restrictions that have to be applied. The following document aims to bring these restrictions to your attention as well as provide you with valuable information so that you can strike the best balance between beauty and performance with your Landscape.

Technical Details

Valid dimensions for Landscape heightmaps are not always immediately obvious when getting started. Being able to determine what dimensions for heightmaps are valid and, beyond that, which are optimal requires a thorough understanding of the underlying architecture of the Landscape. In order to create a system that allows for huge terrains while still being efficient in terms of memory and performance, the architecture implicitly applies restrictions on the dimensions of the heightmap, meaning there are certain dimensions that are valid and others that are not. In previous terrain systems in Unreal Engine, there were either no restrictions (i.e., any dimensions were valid and would work) or the restrictions were fairly simple (i.e., only square power of two heightmaps were allowed). The restrictions on heightmaps for Landscapes are much more complex and rigid.

A Landscape Actor is color coded so that it is easier to tell what each section does. The edges of the Landscape are highlighted in yellow, the edge of each component is in light green, section edges (if set to 2x2 sections) in a medium green, and the individual Landscape quads in a dark green.

Landscape Components

Landscapes are divided into multiple Components, which are Unreal's base unit of rendering, visibility calculation, and collision. Components in a Landscape are all the same size and are always square. The size of the Landscape component is decided when the Landscape is created and the choice depends on the size and detail of the Landscape you wish to create.

Each component's height data is stored in a single texture. Because of this, its size has to be a power-of-two number of vertices. The shared row of vertices along the edge of two neighboring components are duplicated and stored in each component. For this reason, it makes sense to think about the number of quads in each component.

A very simple Landscape is illustrated below (outlined in green) containing four components. Each component is made up of a single quad. One component has been separated to show how the vertices where the components meet are duplicated.

Component Sections

Components can optionally be divided into either 1 or 4 (2x2) subsections. These sections are the base unit of Landscape LOD calculation.

Using the 4 (2x2) subsections option gives you the same size heightmap as using four times as many components with only one subsection each, but using fewer components generally gives better performance.

The size of each section (in number of vertices) must be a power of two (with a maximum of 256x256). This is so that the different LOD levels can be stored in mipmaps of the texture. This will lead to the number of quads in a component in each direction (x or y) either being a power of two minus 1 (if 1 section per component) or a power of two minus 2 (if 4 sections per component).

An individual component is illustrated below (outlined in green) containing four sections. Each section is made up of 9 (3x3) quads. Again, you can see that the vertices where the sections meet are duplicated.

Performance Considerations

The choice of component size vs the total number of components is a performance trade-off. Smaller component sizes allow quicker LOD transitions and also allows for the occlusion of more terrain, but the smaller size necessitates more components.

Each component has a render-thread CPU processing cost and each section is a draw call, so try to keep these numbers to a minimum. For the largest Landscapes, Epic recommends a maximum of 1024 components.

Calculating Heightmap Dimensions

As you can see, the dimensions for a Landscape are based on the number of quads in each section, the number of sections in each component, and the number of components present in the Landscape. Once you determine the number of components and the resolution of each of those components, then calculating the dimensions of the Landscape as a whole becomes a basic calculation.

Here are some example scenarios:

Example 1

If we start with a component comprised of a single section that contains 64x64 vertices, then the component size is 63x63 quads. Say we have a Landscape of 10x10 of these components, then we have 630x630 quads total in our Landscape. Now if we wanted to import the heights for such a Landscape, we would have to have a heightmap of 631x631 vertices, because there is always one more row of vertices than there are quads (think of a 1x1 quad - it needs 4 vertices). So 631x631 is a valid Landscape size.

Example 2

If we have a component divided into 4 subsections, each of which is made up of 64x64 vertices. That leads to 63x63 quads per section and 126x126 quads per component. If we have 32x32 of these components, we get 126 * 32 = 4032 quads total in each direction. So the total Landscape will be 4033x4033 vertices.

These examples focus on square Landscapes. However, you can create Landscapes that are not square. For instance, in the first example the 10x10 is not special. Assuming 63 quads per component, you could have any Landscape of AxB components with total size in vertices of (A*63+1 , B*63+1).

Calculating Heightmap Z Scale

Unreal Engine 4 calculates your heightmap's height by using values between -256 to 255.992 and stored with 16 bit precision. That value is then multiplied by the Z scale value that is input when you import the heightmap data. For example, a Z scale value of 1 results in a maximum height of roughlty 256 centimeters (cm) and a maximum depth of -256cm. Therefore, at the default Z scale value of 100 your height values with be between 256 meters (m) and -256m.

So to calculate a custom height requires the use of a ratio to convert your custom height value into the -256 to 256 range used by Unreal. Since the height range is a total of 512 units (-256 to 0 is 256 units and 0 to 256 is 256 units), the ratio is 1/512 or 0.001953125. We apply this by first converting our measurement to centimeters and then multiplying by the ratio. Here is an example:

You want to represent Mauna Kea, the highest peak in Hawaii at 4207m, in an Unreal level:

1. Start by multiplying 4,207 by 100 to convert the height into centimeters. This equals 420,700cm.

2. Next, mutiply this new value by our ratio: 420,700 multiplied by 0.001953125 equals 821.6796875‬.

3. This gives us a Z scale value of 821.6796875‬ and results in a heightmap that will go roughly go from -210,350cm to 210,350cm.

When importing a heightmap file, changing the value in the Z scale field will adjust the preview of your Landscape in the viewport.

This process will give you the exact height of the moutain with no room for values below sea level. If you would like some additional space in your Landscape's height, adjust your initial height accordingly. To use the example, Mauna Kea also extends 5,761m below sea level. This would give a total height to start with of 9,968m

Recommended Landscape Sizes

In order to make things easier, here are a number of sizes that maximize the area while minimizing the number of Landscape components.

Layer Debug Mode

Layer Debug mode allows the weight of specific layers to be visualized on the Landscape in the viewport. You can enable Layer Debug mode in the viewport's View menu, under Landscape Visualizers. For more information about the viewport's Landscape-related view modes, see the Landscape Visualizers .

When Layer Debug mode is enabled, radio buttons allowing selection of individual color channels are shown with the target layers in the list.

Selecting a channel will apply a shader to the Landscape which shows the area that channel of the selected target layer covers.

# data[].attributes.attachment_link.description
Choose your operating system: To get the best performance possible from the Landscape system, there are certain technical restrictions that have to be applied. The following document aims to bring these restrictions to your attention as well as provide you with valuable information so that you can strike the best balance between beauty and performance with your Landscape.

# data[].attributes.body
Used to get to grips with understanding lighting principles in Unreal.

# data[].attributes.attachment_link.title
Unreal Engine 4 Lighting Fundamentals | Pluralsight

# data[].attributes.attachment_link.description
Video player keyboard shortcuts on this page

# data[].attributes.attachment_link.readable_text
Describes how to bring USD files into Unreal Engine 4 and work with their contents.

Computer graphic productions (films, games, or other forms) typically generate, store, and transmit a great deal of 3D data. That data comes from various sources (animators, lighting or shading artists, modelers, fx artists, and more) who use a wide range of applications (Unreal Engine, Maya, Houdini, Blender) in the pipeline, each of which have historically had their own proprietary form of scene description tailored to the specific needs and workflows of the task or application.

The Universal Scene Description (USD) format was developed by Pixar to address the need to robustly and scalably interchange and augment arbitrary 3D scenes that may be composed of many elemental assets. USD not only provides a rich toolset for reading, writing, editing, and rapidly previewing 3D geometry and shading, but it also provides for the interchange of elemental assets (for example, models) or animations.

Unlike other interchange packages, however, USD also enables assembly and organization of any number of assets into virtual sets, scenes, and shots, which you can then transmit from application to application, and non-destructively edit them (as overrides), with a single, consistent API, in a single scenegraph.

USD in Unreal Engine 4

There are two ways to work with USD files in Unreal Engine:

USD Stage Actor/USD Stage Editor: Instead of converting USD data into native Unreal Engine Assets like Static Meshes and Materials, you can work natively with your USD data using the USD Stage Actor and the USD Stage Editor window. This workflow makes it faster to get your USD data into Unreal, gives you a clearer view of how your USD content was originally structured, and handles live updates as you make changes to the source USD file on disk.

Python USD Import/Export: The bi-directional Python workflow provides the ability to import objects from USD files into Unreal Assets and spawn Actors in the Level. It also has the ability to export objects back out to USD files. Due to the differences between UE4 and USD assets, the conversion will result in loss of quality.

Using the USD Stage Actor/USD Stage Editor workflow provides the following benefits:

Visualize the USD Scenegraph and Layers hierarchy.

Support Static Meshes, Skeletal Meshes, Hierarchical Static Mesh components (HISM), Materials, Lights, Cameras, Variants, Animations, and Blend Shapes.

Support Materials (PreviewSurface and DisplayColor).

Supports Textures in USD Preview Surface.

Enable or disable payloads (to load and unload content).

Support for USD plugins, such as Alembic or Custom Path Resolver.

Although currently in Beta, we recommend this approach for the majority of users who need USD support. The following sections describe how to use this method to interact with your USD content.

Enabling the USD Import Plugin

Before you can work with a USD file in the Unreal Editor, you will need to enable the USD Importer Plugin from the Plugins menu:

When the Editor restarts, you'll see a new USD Stage Editor option listed under the Window menu:

The Place Actors panel also lists some new USD Actors that you can add to your Level:

Live USD Stage Workflow

To work with your USD content inside the editor, follow the steps below:

The panel will be populated with the scene hierarchy read from the USD file you selected.

Depending on the complexity of your USD data, loading times may vary. If you have larger scenes, you can set up a USD Stage Actor to not load any data from the USD file initially, then load only individual payloads as needed. See USD Stage Actor Properties below.

A USD Stage Actor will also be added to your Level if it did not contain one. This Actor is a container for the USD data read from the file, and provides a location for that data in the Level.

The 3D scene objects that are loaded from the USD file and that you see in the viewport are fully compatible with most other Unreal Engine features, and you can treat them exactly like other Actors you'd work with in Unreal Engine. You can also select individual objects from the USD scene in the Viewport and manipulate them, such as moving Actors and assigning new materials.

From the USD Stage Editor, you can switch between any variants defined in the USD file and see the scene reflect those changes immediately:

You can add additional USD prims that can reference the content found in other USD files, including Animated Skeletal Meshes. Animations in the USD file are associated with a Level Sequence, which you can use to scrub or play back the animation.

If you make changes to your USD Stage in the USD Stage Editor, you can write those changes back out to the USD file by saving the USD data by using File > Save.

Accessing and Authoring USD Animations in Unreal Engine 4

Animations stored within a USD file are accessible from a specially-generated Level Sequence spawned by the USD Stage Actor:

Double click on the Level Sequence in the Details panel to open the sequence. USD xform animations are displayed as Transform tracks in Sequencer. Other forms of animation such as floats, boolean, and skeletal bones, are displayed via the Time track. In the image above, you can see the USD animation data represented as a key/value pair at each timecode for the duration of the animation.

Through the USD Stage generated Level Sequence, it is possible to bind to an Actor that is spawned on the USD Stage and add additional animation through a Transform track:

1. Click the Track+, highlight the Actor to Sequence option, and select your Actor from the list.

2. Next, click the Add (+) button to create a Transform track for the Actor.

3. Using keyframes, animate the transform data of your Actor.

USD animation data is baked. When you save the data back to the USD file the xform values will be updated to match. To delete an animation, you can delete either the binding or the new Transform track. This will erase all time varying values from the USD xform transform attribute.

Importing USD Content into Unreal Engine 4

Actors displayed on the USD Stage can be imported into the UE4 Content Browser through any of the following import options:

Using File > Import Into Level. This process will import both assets (static mesh, skeletal mesh, materials, textures, and so on) and Actors.

Using the Add/Import button in the Content Browser. This process will only import assets.

Dragging and dropping the file into the Content Browser. This process will only import assets.

Using Action > Import option in the USD Stage panel. This process will import both assets and Actors. After the import process is complete, assets on the USD stage are replaced with new Actors from the Content Browser.

USD Stage Editor

The USD Stage Editor outlines the scene hierarchy from the USD file and offers you tools to modify the USD data. This includes:

Opening, saving, and reloading USD files.

Toggling visibility and payloads, or selecting variants for primitives.

Creating new layers, opening existing layers, or muting layers.

Add or remove prims and alter their references.

Rows in orange are composition arcs, and you can right-click any prim to add references to it (or clear references from it). Other right-click options include the ability to add or remove prims, and the ability to toggle, load, or unload payloads.

The Details panel in the USD Stage Editor displays information about the current selection, and provides the ability to choose between any defined Variants.

USD Stage Actor Properties

After you create a USD Actor, you can use the properties in the Details panel to control how the Actor accesses and uses the data in its USD file.

Defines what parts of the USD scene to load when starting the Level. Load All loads all data in the stage, Load None refrains from loading any objects in the stage until you load them in the USD Stage Editor window.

Defines which prims to load based on Purposes found in the USD file.

The Level Sequence that is associated with this Actor.

# data[].attributes.attachment_link.description
Computer graphic productions (films, games, or other forms) typically generate, store, and transmit a great deal of 3D data. That data comes from various sources (animators, lighting or shading artists, modelers, fx artists, and more) who use a wide range of applications (Unreal Engine, Maya, Houdini, Blender) in the pipeline, each of which have historically had their own proprietary form of scene description tailored to the specific needs and workflows of the task or application.

# data[].attributes.body
https://www.youtube.com/watch?v=Ddu7TAICAXw

# data[].attributes.attachment_link.title
Animation Workflows Using Unreal Engine and Maya | Webinar

# data[].attributes.attachment_link.title
Creating a Virtual Camera using HTC Vive in Unreal Engine (4.26)

# data[].attributes.attachment_link.title
We Got MetaHuman Maya Source Asset - Full Walkthrough😘

# data[].attributes.attachment_link.readable_text
I've not tried exporting it yet but yeah, thats a bit weird, be nice if that pipeline was clearer. And yeah I was gonna just wrap another rig round the body.

The original press release sounded like it was gonna have a rig " Users will also get the source data in the form of a Maya file, including meshes, skeleton, facial rig, animation controls, and materials."

ta

# data[].attributes.attachment_link.description
I've not tried exporting it yet but yeah, thats a bit weird, be nice if that pipeline was clearer. And yeah I was gonna just wrap another rig round the body. The original press release sounded like it was gonna have a rig " Users will also get the source data in the form of a Maya file, including meshes, skeleton, facial rig, animation controls, and materials."

# data[].attributes.attachment_link.title
New Virtual Camera 2.0 Setup in Unreal Engine using your iOS Device

# data[].attributes.body
Maya 2020
Unreal Engine 4 Version 4.26

(4.25 doesn't support Metahuman)

# data[].attributes.attachment_link.title
Make a 3D Character of YOURSELF (Unreal Engine 5 + Metahuman)

# data[].attributes.body
-Crowd Generation
completely new, something to try, not high priority
-Virutal Production
am aware of the concept, easy to figure out
-Mo Cap with VR
Proof of concept has worked, want to develop
-MetaHuman
-Texturing (Look at substance painter)

# data[].attributes.body
Autodesk Character generator, can have low poly characters, up to crowd resolution.

# data[].attributes.body
Potential ending shot, after shooting the zombie, the camera could come out and see 200 zombies outside.

# data[].attributes.body
More surivors enter the building, where there's a second character that could then become a zombie

# data[].attributes.body
When the zombie charges into the room, the sound massively increases and it goes from something much more quiet to much louder.

# data[].attributes.body
- Character approaches abandoned building in an injured state

- Character enters the hallway holding wound and stumbles further into the building

- Character limps into the kitchen and sits down on the floor while resting his rifle on the table (out of reach)

- Character looks at hand and assesses heavily bleeding wound

- Slight creaking noises can be heard from across the hallway

- Character gets startled and quickly focuses on the direction of the noise

- Zombie appears in the hallway and starts to advance on the character

- Character hastily crawls over to the rifle and aims at zombie charging

- Gunshot noise echo's through the forest (Implying zombie was eliminated)

# data[].attributes.body
Use the HTC Vibe for head tracking, and for minimal body tracking.

# data[].attributes.body
Virutal Production,

Unreal engine have a camera app to use phone/tablet to control camera

VIRTU CAMERA...?

VR headset also. HTC vive gen 1

# data[].attributes.body
Record eachother as reference for the cameras, and proper animation reference

# data[].attributes.body
Lead layout artist
Lead cinematography
Co producer
Co director

# data[].attributes.body
Lead animator
Lead mo cap
Co producer
Co director

# data[].attributes.body
Constantly updating FBX files, always FBX for unreal engine

# data[].attributes.body
Pedram, provided a really god folder structure which is industry standard, could use that.

# data[].attributes.body
Shared onedrive, with a main folder.

Inside will be:
Maya project
Unreal project
Reference material

What other software folder structure.

# data[].attributes.body
Make everything in Maya, save unreal engine for rendering and making everything look pretty.

# data[].attributes.body
Look into maya/ unreal engine compatibility.

# data[].attributes.body
Zombie apolocalypse with a zombie and a survior character.
Potentially 2 characters, one of them turns into a zombie.

# data[].attributes.body
Potentially use metahuman instead of mixamo