The Mountain Monster Material was designed for background mountains that utilize splat maps/RGB masks and it can layer up to 6 textures. It supports 34 maps, has 190 attributes for a highly customized look, speeds-up iteration, and automatically optimizes the material based on which parameters are enabled/disabled. Additionally, the Color Bleed AO uniformly affects material AO, SSAO, and RTAO. It not only mixes how much local, reflected color blends with AO, but there are Photoshop-like color adjustment/global color parameters to modify the AO's look. The tech demo below shows how both tools work.

UE4 PBR MATERIAL OPTIONS FOR MAYA (developed in Python 2.7 with a MEL-based GUI)
The UE4 PBR Material Options tool was developed in Python/MEL for Maya and selection-based use. It allows artists to iterate faster on PBR content in Maya for a seamless integration into the UE4 environment. This tool can name/assign/create materials and delete unused ones without needing to open the Hypershade, import textures with a material auto-setup process, live/selection-based texture reloading, export meshes/textures into organized subdirectories for auto-reimporting into UE4, check/notify the user if the tool is being used in unsupported ways, and to calculate lightmap densities based on UE4’s Ideal Density value.
Below is a tech demo and sample Python/MEL code for the UE4 PBR Material Options tool. In addition, you can click and drag the box's lower, right-hand corner to expand it.

  # Imported modules.
  import maya.cmds
  import maya.mel as mel
  from sys import exit
  from glob import glob
  from os import path, remove, rename
  from shutil import copy2
  from math import sqrt

  for object in _meshSelection:

      # Gets the polygonal surface area in cm/world space.
      _surfaceArea = (cmds.polyEvaluate(object, worldArea=True))

      # Gets the square root of the surface area to convert it to a squared resolution.
      _sqrtSurfaceArea = (sqrt(_surfaceArea))

      # Converts the cm squared resolution to a m squared resolution.
      _meterStandard = (_sqrtSurfaceArea / _cmToM)

      # Gets the UE4 Ideal Lmap Density value for the mesh based off the polygonal surface area.
      _ue4IdealdLmapSurfaceAreaDen = (_meterStandard * (_idealLmapDenRatio * _userDensity))

      # Gets the names of all the UV sets for the current object.
      _uvSetNames = cmds.polyUVSet(object, query=True, allUVSets=True)

      # If the user chooses an UV set index value that's greater than what the current object contains, the object is skipped.
      if _userUvIndex > (len(_uvSetNames) - 1):

UE4 CUSTOM VIEW MODES (developed in UE 4.22)
The UE4 custom view modes below help artists visually problem-solve different aspects of their materials and lighting. Some of the debug overlays are for out-of-range PBR values, nit/false color/roughness complexity heatmaps, Rec.709 broadcast legal levels, AO coloring, a zebra pattern function, film grain, and luminance visualizers for base color/focal point control.

These PBR utility nodes were designed to work within UE4's PBR range. Three of them use physically-based data for dielectric, metallic, and specular presets. Another validates whether your dielectric/metallic albedo values are within/outside UE4's PBR range, while the final PBR utility node can adjust out-of-range base colors.

The neutral lighting environment below uses all dynamic effects, like LPVs, DFAO, SSR, SSAO, RTDF, volumetric lighting, Convolution Bloom, bokeh lens flares, utilization of real-world data, etc., for quick material/asset testing without the need to bake lighting. The scene includes varying, physically-approximated TODs, tools, and PBR materials for visual reference. 


​Total emitted light.
Cd/m² or Nit
(cd = candela) Light source intensity per square meter.
Reflected surface illuminance. Also, 1 lux = 1 lm/m² = 1 cd*sr/m².
Video exposure unit.
Inverse Square Falloff
Describes physical light falloff. Also, intensity (cd) ∝ 1 / square of the distance.
Energy Conservation
Reflected light is never brighter than its cast light.
Bidirectional Reflectance Distribution Function
(BRDF) Defines reflected light.
Direct Light
Light source light.
Indirect Light
Bounce light.
Ambient Light
Surrounding environment light.
Diffuse Light
Reflected surface light.
Key Light
Primary light source.
Fill/Helper Light
​Supplementary light used to brighten shadows/content and/or to simulate bounce light.
Rim Light 
​Light contouring subjects for background separation, thus implying depth.
Motivated Light
Light that simulates physical light sources, like a light bulb or window.
Unmotivated Light
Support light that doesn't have a physical representation.
High-Key Lighting
Bright, low-contrast lighting.
Low-Key Lighting
Dark, high-contrast lighting.
Horizontal angle of the sun’s position.
Vertical angle of the sun’s altitude.
Rayleigh Scattering
Light/smaller particle (air molecules) interactions. This makes the sky blue.
Mie Scattering
Light/larger particle (aerosols like dust, pollution, etc.) interactions.
Area in full shadow.
Diffuse shadow area along the umbra's edges.

​Brightest Sunlight
​​120,000 lux
Sunlight Range
30,000 - 120,000 lux
Bright Sunlight​​
111,000 lux
White Paper at Sunny Noon
25,000 cd/m²
Clear, Midday Shade
​20,000 lux
​Fluorescent Lights
12,000 cd/m²
Brightest, White Clouds
​​10,000 cd/m²
Average, Clear Sky
​​5,000 - 7,000 cd/m²
Midday Overcast
​1,000 - 2,000 lux
HDR10 LCD Monitor
​1,000 cd/m²
Clear Sunrise/Sunset ​​​
400​​​ lux
​LCD Monitor Peak Luminance
250 cd/m²
Thickest, Midday ​Storm Clouds ​​
​< 200​ lux
sRGB Reference Monitor White​
80 cd/m²
Sunrise/Sunset Overcast
40 lux
Floodlit Buildings
​​2 cd/m²
Thickest Sunrise/Sunset Storm Clouds ​​​​
< 1​​​​​​​​ lux
Clear Night with Full Moon
0.26 lux
Clear Night with Quarter Moon
​0.01​ lux
Clear, Moonless Night with Airglow
0.002​​ lux
Clear, Moonless Night
0.0002​​ lux
Moonless Night Overcast
0.0001 lux
Note: Generally, daytime lighting has a ~4:1 sun/sky (direct light vs shade) intensity ratio, sunrise/sunset is ~3:1, and overcast is ~2:1. However, since lighting conditions vary by location, time of day, weather, pollution/atmosphere, season, etc., the values listed above should only be used as a guide.

​Color temperature (K) is defined by the temperature of a blackbody emitting light with a particular color. Blackbodies also absorb all light casted onto them.

 Below are color temperature examples with values listed in sRGB first with corresponding sRGB color swatches. 
Clear, Blue Sky
sRGB = cfdaff
​Linear RGB = 9fb3ff
sRGB = (207, 218, 255)
​Linear RGB = (159, 179, 255)
sRGB = (0.812, 0.855, 1)
​Linear RGB = (0.624, 0.702, 1)
Hazy Sky
sRGB = e5e9ff
​Linear RGB = c8d0ff
sRGB = (229, 233, 255)
Linear RGB = (200, 208, 255)​
sRGB = (0.898, 0.914, 1)
​Linear RGB = (0.784, 0.816, 1)
​Outdoor Shade
7,000 - 8,000
sRGB = f7f5ff - e5e9ff
​Linear RGB = eee9ff - c8d0ff
sRGB = (247, 245, 255) -
​(229, 233, 255)
Linear RGB = (238, 233, 255) - (200, 208, 255)
sRGB = (0.969, 0.961, 1) - (0.898, 0.914, 1)
​Linear RGB = (0.933, 0.914, 1) - (0.784, 0.816, 1)
Daytime Overcast
6,000 - 7,000
sRGB = fff4ed - f7f5ff
​Linear RGB = ffe7d8 - eee9ff
sRGB = (255, 244, 237) -
​(247, 245, 255)
​Linear RGB = (255, 231, 216) - (238, 233, 255)
sRGB = (1, 0.957, 0.929) - (0.969, 0.961, 1)
​Linear RGB = (1, 0.906, 0.847) - (0.933, 0.914, 1)
LCD Monitor
sRGB = fff9fb
​Linear RGB = fff2f6
sRGB = (255, 249, 251)
​Linear RGB = (255, 242, 246)
sRGB = (1, 0.976, 0.984)
​Linear RGB = (1, 0.949, 0.965)
​Noon and Camera/Studio Flash
sRGB = ffeede
​Linear RGB = ffdaba
sRGB = (255, 238, 222)
​Linear RGB = (255, 218, 186)
sRGB = (1, 0.933, 0.871)
​Linear RGB = (1, 0.855, 0.729)
​Early Morning/Evening - Afternoon
3,500 - 5,000
sRGB = ffc987 - ffe7cc
​Linear RGB = ff953e - ffcc9a
sRGB = (255, 201, 135) -
​(255, 231, 204)
​Linear RGB = (255, 149, 62) - (255, 204, 154)
sRGB = (1, 0.788, 0.529) -
​(1, 0.906, 0.8)
​Linear RGB = (1, 0.584, 0.241) - (1, 0.8, 0.604)
Fluorescent Lights 
sRGB = ffd5a1
​Linear RGB = ffaa5b
sRGB = (255, 213, 161)
​Linear RGB = (255, 170, 91)
sRGB = (1, 0.835, 0.631)
​Linear RGB = (1, 0.667, 0.357)
1-hour After Sunrise/Before Sunset
3,500 - 3,600
sRGB = ffc987 - ffcb8d
​Linear RGB = ff953e - ff9844
sRGB = (255, 201, 135) -
(255, 203, 141)
​Linear RGB = (255, 149, 62) - (255, 152, 68)
sRGB = (1, 0.788, 0.529) -
(1, 0.796, 0.553)
Linear RGB = (1, 0.584, 0.243) ​- (1, 0.596, 0.267)
​Studio/Photoflood Lamps and Tungsten Lights
sRGB = ffc076
​Linear RGB = ff862e
sRGB = (255, 192, 118)
​Linear RGB = (255, 134, 46)
sRGB = (1, 0.753, 0.463)
Linear RGB = (1, 0.525, 0.18)​
1,850 - 3,100
sRGB = ff8500 - ffbd6f
​Linear RGB = ff3c00 - ff8228
sRGB = (255, 133, 0) -
(255, 189, 111)
​Linear RGB = (255, 60, 0) - (255, 130, 40)
sRGB = (1, 0.522, 0) -
(1, 0.741, 0.435)
Linear RGB = (1, 0.235, 0) -
​(1, 0.51, 0.157)
​Halogen Lights
sRGB = ffb969
​Linear RGB = ff7c24
sRGB = (1, 185, 105)
​Linear RGB = (255, 124, 36)
sRGB = (1, 0.725, 0.412)
​Linear RGB = (1, 0.486, 0.141)
​Incandescent Lights
2,400 2,800
sRGB = ffa23c - ffb25b
​Linear RGB = ff5c0b - ff711a
sRGB = (255, 162, 60) -
(255, 178, 91)
Linear RGB = (255, 92, 11) - (255, 113, 26)​
sRGB = (1, 0.635, 0.235) -
(1, 0.698, 0.357)
​Linear RGB = (1, 0.361, 0.043) - (1, 0.443, 0.102)
High-Pressure Sodium Lights
sRGB = ff9829
​Linear RGB = ff5005
sRGB = (255, 152, 41)
​Linear RGB = (255, 80, 5)
sRGB = (1, 0.596, 0.161)
​Linear RGB = (1, 0.314, 0.02)
Candle Flame
sRGB = ff8500
​Linear RGB = ff3c00
sRGB = (255, 133, 0)
​Linear RGB = (255, 60, 0)
sRGB = (1, 0.522, 0)
​Linear RGB = (1, 0.235, 0)
Match Flame
1,700 - 1,800
sRGB = ff7c00 - ff8200
​Linear RGB = ff3300 - ff3900
sRGB = (255, 124, 0) -
(255, 130, 0)
​Linear RGB = (255, 51, 0) - (255, 57, 0)
sRGB = (1, 0.486, 0) -
(1, 0.51, 0)
Linear RGB = (1, 0.2, 0) -
​(1, 0.224, 0)
Low-Pressure Sodium Lights
sRGB = ff7c00
​Linear RGB = ff3300
sRGB = (255, 124, 0)
Linear RGB = (255, 51, 0)
sRGB = (1, 0.486, 0)
​Linear RGB = (1, 0.2, 0)

The combination of the aperture, shutter speed, and ISO define the exposure value. Below is an EV100 (also called ISO 100) formula and guide.
Note: ​Shutter Speed = (1 / Time) = Fraction of a Second
EV100 = (log2 (Aperture² / (Shutter Speed) * 100 / ISO))
​Bright Sunlight on Sand/Snow (distinct shadows)
​Clear, Bright Sunlight (Sunny 16 Rule/distinct shadows)
​15 = shutter speed: 1/100, ISO: 100, and aperture: 15.
Hazy Sunlight (soft shadows)
​Before Sunset
Bright and Cloudy (no shadows)
​Overcast and Shade with Clear Sunlight
After Sunset
​Neon/Bright Signs
​Sport Events and Stage Shows
​Bright Streets, Window Displays, and Office Spaces
​Fairs and Amusement Parks
​Home Interiors
​Night Traffic
Christmas Lights
Floodlit Buildings
​Street Lamps and Candle Close-ups
​Distant, Lit Skylines

​The Sunny 16 Rule, which can be viewed in the guide below, approximates correct daylight exposures without a light meter. The camera's ISO and shutter speed share a reciprocal relationship. 
SUNNY - f/22
SUNNY - f/16
​(strong shadows​)
(soft shadows)
CLOUDY - f/8
(faint shadows)
CLOUDY - f/5.6
(no shadows)
SUNSET - f/4
(long shadows)​
1/100 or 1/125
1/100 or 1/125
1/100 or 1/125
1/100 or 1/125
1/100 or 1/125
1/100 or 1/125
1/200 or 1/250
1/200 or 1/250
1/200 or 1/250
1/200 or 1/250
1/200 or 1/250
1/200 or 1/250
1/400 or 1/500
1/400 or 1/500
1/400 or 1/500
1/400 or 1/500
1/400 or 1/500
1/400 or 1/500
1/800 or 1/1,000
1/800 or 1/1,000
1/800 or 1/1,000
1/800 or 1/1,000
1/800 or 1/1,000
1/800 or 1/1,000

UE4 PBR LIGHTING GUIDE (requires UE 4.26)
Section Links​: Lights | Fog | Exposure | Materials | Tonemapper | UE4 Real-time Ray Tracing Guide | ​The Matted, White Paper Test | UE4 Cubemap Orientation Guide

Note: UE4 Real-time Ray Tracing Guide section links can be found in the beginning of that guide.


  Directional Light: Represents the sun (It can also be used for the moon.), uses lux values, and has an angular diameter of 0.5357°. (The moon has an angular diameter of 0.545°.) You can apply Light Values Guide and Color Temperature Guide data to Directional Light Intensity/Temperature parameters.
Note: It is possible to align a Directional Light's location to a sun in a skybox texture. This can be achieved by creating a chrome ball with a “perfect mirror” surface, and either by enabling Ray Trace Reflections or by using an ambient cubemap captured by a Skylight, to view the skybox’s reflection on the chrome ball. You can then rotate the Directional Light to see where its specular lobe falls on the chrome ball, as you attempt to match its location to the skybox’s sun placement in the reflection. Techniques for skybox setup can be found in either The Matted, White Paper Test or the UE4 Cubemap Orientation Guide sections.
  Sky Light: Uses cd/m²​, or nit, values. The sky luminance is determined by the HDRI's pixel intensity values multiplied against the Sky Light's Intensity parameter. The HDR (Eye Adaptation) view mode (Level Viewport > Show > Visualize > HDR (Eye Adaptation)) can measure sky intensity values. You can apply Light Values Guide data to sky intensity values, and the Exposure section has more information on the HDR (Eye Adaptation) view mode.

To set/measure the sky's average luminance in cd/m², or nits, sample sky intensity values from midtone areas via the HDR (Eye Adaptation) view mode. Since reading individual pixels can vary, it’s best to average large portions of pixel values first for easier sky analysis. This can be achieved by loading the sky texture into the Texture Properties Editor, lowering its resolution or by increasing its mip level, saving it, and then analyzing the lower-resolution sky in the Level Viewport.
​Below is an example of an adjusted sky texture’s mip level. The one on the left has a resolution of 4,096 x 2,048 (mip level: 0), and the one on the right has a resolution of 32 x 16. (mip level: 7) It's important to note that each lower mip map level is half the resolution as its previous one.
NoteSky Lights capture scenes in a cubemap format for ambient lighting and reflection contributions. (The lowest mip map level of a cubemap is used for ambient lighting, while the higher levels are for reflections/roughness textures.) You can add color to the lower hemisphere of your environment light by enabling the Lower Hemisphere is Solid Color option and adjusting the Sky Light’s Lower Hemisphere Color parameter. This can be used to simulate the average, reflected ground light/color. You can also leave the color black to only have ambient light cast from the upper hemisphere. (Sky color controls exterior shadow color.) This method allows baked bounce light to be more accurate for local, reflected ground light/color.
Note: When the Sky Light Real-time Capture feature is enabled, it can capture real-time, ambient light/reflections when the Sky Light is set to either "Stationary" or "Movable." (The Sun and Sky actor can use this property.) It can also capture Volumetric Cloud, Exponential Height Fog, and Sky Atmosphere actors, as well as opaque meshes with assigned, unlit material(s) that have their "IsSky" flag enabled.
  Spot/Point/Rect Lights: Uses unitless, candela, or lumen values. (The light must have its Inverse Squared Falloff enabled to specify the light unit. When it’s disabled, and if needed, you can minimize undesired hot spots near light sources by adjusting their Light Falloff Exponent parameter for softer falloffs.) You can apply Light Values Guide and Color Temperature Guide data to lights' Intensity/Temperature parameters.

Note: The default light unit can be set in the Project Settings. (
Edit > Project Settings > Engine > Rendering > Light Units) However, this can be overridden on a per-light level in the Details panel. Also, when using candelas units, cone angle does not affect the light's intensity. The opposite is true when using lumen values. (The smaller the cone angle, the stronger the surface illuminance intensity.)
Below defines the relationships between light types and physical light unit formulas used in UE4.​
​General Units
Note: sr = Steradians
1 cd = 625 Unitless Values
​1 cd = 1 lm/sr
Point Lights
Solid Angle = (4π sr)
Illuminance (1 lm) ≈ (49.7 * Illuminance (1 Unitless Value))
​Illuminance (1 cd) ≈ (12.6 * Illuminance (1 lm))
Spot Lights
Solid Angle = (2π*(1-cos(θ))) and θ = Light Cone Half Angle
​Illuminance (1 lm) ≈ (99.5/(1-cos(θ)) * Illuminance (1 Unitless Value))
​Default Spot Light Cone
Solid Angle ≈ 1.76 sr and θ = 44°
Illuminance (1 lm) ≈ (354 * Illuminance (1 Unitless Value) for a Default Spot Light)
​Illuminance (1 cd) ≈ (1.76 * Illuminance (1 lm) for a Default Spot Light)
Rect Lights
Solid Angle = (2p sr)
Illuminance (1 lm) ≈ (199 * Illuminance (1 Unitless Value))
​Illuminance (1 cd) ≈ (3.14 * Illuminance (1 lm))
Note: Using the r.Shadow.FilterMethod console variable with a value of 1, enables PCSS Shadows. This shadow type uses shadow maps but it does not utilize the default PCF filter. While PCSS Shadows are not physically-correct, they soften with distance from the shadow caster.

  IES Light Profiles: Uses physical values, like brightness, falloff, reflective surfaces, light bulb shape, and lens effects, to define light distribution of a particular light source. Their photometric data can be visualized via their Content Browser texture icons or by selecting a light with an assigned IES Light Profile. Point, Spot, and Rect lights support IES Light Profiles.
Note: In the Texture Editor, the Brightness attribute is in candela units, which is determined by the IES Light Profile. This value can be applied when a light's Use IES Intensity attribute is enabled in the Details panel.
  The Sun and Sky actor renders physical sun/sky effects by using atmospheric scattering/absorption, which react to geographically-accurate sun location, time of day, and the date. The Sun and Sky Actor uses several preexisting components, including dynamic, ray trace-enabled Directional/Sky Lights, as well as a moveable Sky Atmosphere actor. This tool can be enabled from the Plugins menu. (Edit > Plugins > Misc > Sun Position Calculator > check the Enabled checkbox > click the Restart Now button) Once it’s activated and UE4 has restarted, the Sun and Sky actor lives in the Modes Panel’s Lights section.

Note: It is recommended to enable the Extend default luminance range in the Auto Exposure settings attribute to properly view the Sun and Sky actor values. Moreover, extra Directional Light, Sky Light, and/or Sky Atmosphere actors in the scene should be deleted when using the Sun and Sky actor.
Below are Sun and Sky actor attributes and their descriptions.
Positive values are east of the prime meridian, while negative ones are west of it.
Positive values are north of the equator, while negative ones are south of it.
Time Zone
Offsets the hour for GMT.
North Offset
Defines north.
​Date and Time
Sets the time of day/year. Options for this include month, day, daylight-saving time parameters, and solar time.
Note: The Environment Light Mixer (Window > Env. Light Mixer) allows easy access/creation of a scene’s Directional/Sky Lights (up to 2 Directional Lights) and Volumetric Cloud/Sky Atmosphere components.
  HDRI Backdrop: Uses cd/m2, or nit, values, but physically correct units are not required. This tool projects a HDRI texture (latitude/longitude format) onto a backdrop (with Size, Intensity, and Projection Center parameters) for dynamic sky light/reflections, as well as an included ground plane for shadows. It can be enabled from the Plugins menu. (Edit > Plugins > Rendering > HDRI Backdrop > check the Enabled checkbox > click the Restart Now button) Once it’s activated and UE4 has restarted, the HDRI Backdrop lives in the Modes Panel’s Lights section.
Note: In the Texture Editor, you may need to adjust the HDRI’s (the one used for the HDRI Backdrop tool) Maximum Texture Size to match the source file’s resolution, set the Mip Gen Settings to "NoMipmaps," and make sure sRGB is disabled. You can include additional light sources, like a directional light, with the HDRI Backdrop. For greater ambient cubemap reflection quality, adjust the HDRI Backdrop’s inherited Skylight's Cubemap Resolution parameter. Raising the Cubemap Resolution’s value can also help with sharper Skylight shadows when using high-contrast HDRIs, like ones with a sunny sky and no clouds.
Note: The HDRI Backdrop’s inherited Skylight actor has a default Sky Distance Threshold value of "1." This may need to be increased for a proper ambient cubemap capture.

  Emissive materials: Uses cd/m2 for pixel luminance. (The HDR (Eye Adaptation) view mode can measure emissive intensity values.) This is utilized by emissive materials (Materials set to Unlit in the Material Editor.) applied to static meshes with their Use Emissive for Static Lighting setting enabled. The Emissive Boost property scales the static light intensity emitted from the emissive material. This can also be achieved by multiplying an emissive texture against a value in the Material Editor. You can apply Light Values Guide and Color Temperature Guide data to emissive values.


  Volumetric Fog can be used by adding an Exponential Height Fog to your scene and enabling its Volumetric Fog option. It’s recommended whenever you are roughing in your scene’s lighting, always start with sun, sky, and fog elements due to their relationship to one another.

Note: The Exponential Height Fog supports a secondary layer of fog parameters (it also works with volumetric fog), which includes Density, Height Falloff, and Height Offset.
​For lights to interact with Volumetric Fog, you need to enable/adjust their Volumetric Scatter Intensity and Cast Volumetric Shadow parameters. Movable/stationary lights yield higher-resolution results with Volumetric Fog than static lights/volumetric lightmaps.
Note: Atmospheric Fog simulates scattered light through the atmosphere. It can be layered with Volumetric Fog (close-up fog) and used for fog fx near the horizon.

  Sky Atmosphere is a physically-based sky/atmosphere for approximated light scattering/absorption exterior effects. It can be used to create different TODs (even dynamically), custom, exotic atmospheres, and ground-to-outer space, atmospheric transitions with planetary curvature. While using the Sky Atmosphere and adjusting the sun's azimuth/zenith angles, the sky color can update via simulated Rayleigh/Mie scattering, atmospheric absorption, and multiscattering of light. (Its Multiscattering attribute should be set to "1," while its Ground Albedo value (if simulating Earth) needs to be "0.4.")

Note: You need at least one directional light (can have up to 2) with its Atmosphere / Fog Sun Light property enabled in order to use the Sky Atmosphere. Moreover, a Sky Light can then be used to capture the atmosphere for ambient lighting.
Note: The Sky Atmosphere can be transformed based on its Transform Mode setting and it can cast planetary atmosphere shadows. Also, from space, per-pixel light transmittance values aid with physical planetary surface brightness.
The Sky Atmosphere debug view (Level Viewport > Show > Visualize > Sky Atmosphere) displays real-time changes made to Sky Atmosphere settings. In the image below, the Hemisphere View (left) renders a thumbnail of it. The Time-of-Day Preview (bottom-center) displays various TODs for the current, atmospheric settings. The Graph View (right) shows atmospheric contribution amounts based on the atmosphere’s height. 
Rayleigh scattering is light/smaller particle (air molecules) interactions. This gives the sky its blue color due to less scattering/dense atmosphere.
Mie scattering is light/larger particle (aerosols like dust, pollution, etc.) interactions. With Mie scattering, absorbed light can cause a hazy sky and scatter light in a more forward direction, creating halos around light sources. (i.e. a sun disk)
Note: Mie scattering can be used as a height fog. Once it's enabled (Edit > Project Settings > Engine > Rendering > Shader Permutation Reduction > Support Sky Atmosphere Affecting Height Fog), it's additive to preexisting fog and is controlled by the Sky Atmosphere's Height Fog Contribution parameter. Further, the Exponential Height Fog can work in conjunction with the Sky Atmosphere. Keep in mind the Exponential Height Fog's Directional Inscattering Color, Fog Inscattering Color, and Albedo properties are additive in color to this setup. Therefore, it is recommended to set these properties' color to black, so the Exponential Height Fog's color can be solely driven by the Sky Atmosphere.


  For manual control over physical camera attributes, you can use the Post Process Volume’s camera parameters. (Post Process Volume > Lens > Exposure > Metering Mode: Manual) These attributes include Shutter Speed, ISO, Aperture, etc. It’s advised to leave the tonemapper alone unless you're trying to mimic a specific film stock. Further, you can apply Sunny 16 Rule Guide and  EV100 Guide data to the Manual Metering Mode.

Note: The Apply Physical Camera Exposure option only affects the Manual setting and needs to be enabled for physical camera exposure (EV100). If it’s disabled, exposure values work linearly with this formula: Exposure = 1/(2^ (EV100 + Exposure Compensation)).
Below are physical camera properties and their descriptions.
 Controls the amount of light that enters the camera via its opening size; it also affects depth of field.
​Shutter Speed
T​he length of time film is exposed to light, which determines motion blur intensity.
The camera sensor's sensitivity to light.
  Auto-exposure targets an average scene luminance equal to middle gray, or 18%-gray. Since there are different eye adaptation versions, the following information covers a few options related to them.
In the Post Process Volume, you can switch the Metering Mode to Auto Exposure Basic (Post Process Volume > Lens > Exposure > Metering Mode: Auto Exposure Basic) and still take advantage of UE4's PBR lighting system. For scenes that contain much higher luminance ranges, it’s recommended to instead use Min/Max EV100 settings (Edit > Project Settings > Engine > Rendering > Default Settings > Extend default luminance range in Auto Exposure settings) for physically-based auto-adjustments. (Min/Max EV100 and Histogram Min/Max EV100 replace the Min/Max Brightness and Histogram Log Min/Max options in the Post Process Volume.) You can apply EV100 Guide data to Min/Max EV100 values. Below are common exposure properties these two methods share.
​Exposure Compensation
Adds stops (2 ^ ExpComp) to the set exposure.
Min/Max Brightness
​The clamped range the camera auto-adjusts within. By default, it uses cd/m², unless Min/Max EV100 is enabled.
Speed Up
Dark-to-light exposure adaption (should be a faster transition) in f-stops per second.
​Speed Down
Light-to-dark exposure adaption (should be a slower transition) in f-stops per second.
Note: When Min Brightness = Max Brightness, auto-exposure is disabled. By increasing or decreasing the exposure by 1-stop, the brightness will either be doubled or halved. Moreover, sunny scenes typically work better with larger exposure ranges, while cloudy environments use smaller ones due to more evenly diffuse lighting/less overall contrast. 
  The HDR Histogram is expressed in EV100, works exponentially, is in 64-bit, and works with the auto-exposure to adapt the camera to the scene's luminance range. (Level Viewport > Show > Visualize > HDR (Eye Adaptation)) Below is an image of the HDR (Eye Adaptation) view mode and a corresponding guide describing its properties.
Exposure/curve value list.
Focal point meter with nit/lux/EV100 values.
Histogram chart. X-axis = Average Scene EV100. Y-axis = Exposure Compensation (Curve).
Histogram Chart Blue Line
Target EV100 and average scene exposure.
Histogram Chart Purple Line
Current EV100 exposure that moves toward the target exposure.
Histogram Chart White Line
Final EV100 exposure after Exposure Compensation and is offset from the current exposure.
Histogram Chart Left/Right Edges
Auto-exposure range controlled by Histogram Min/Max settings.
  The Histogram Debug Visualization Mode color-codes bright/dark pixels that are not evaluated (via a Post Process Volume’s Advanced Exposure settings) for auto-exposure. Displayed blue pixels are above the auto-exposure adaption range, while red pixels are below it. To enable it, the HDR (Eye Adaptation) view mode needs to be active, followed by using this command: r.EyeAdaptation.VisualizeDebugType 1.
  The Exposure Compensation Curve tool gives artists greater control over the Post Process Volume's Exposure Compensation with feedback from the HDR (Eye Adaptation) view mode. Custom curves can be created (Content Browser > click the Add New button > Miscellaneous > Curve > CurveFloat > click the Select button) and added to the Post Process Volume's Exposure Compensation Curve parameter (Post Process Volume > Lens > Exposure > Exposure Compensation Curve).
The following HDR (Eye Adaptation) view mode attributes in the guide below correspond to the Exposure Compensation Curve's values.
Exposure Compensation (Settings)
The Exposure Compensation value.
Exposure Compensation (Curve)
The Exposure Compensation Curve's Y-axis value.
Exposure Compensation (All)
The Exposure Compensation sum of Exposure Compensation (Settings) and Exposure Compensation (Curve) values.
  The Exposure Metering Mask (Post Process Volumes > Lens > Exposure > Exposure Metering Mask) lets artists fine-tune the auto-exposure by having it weighted against a custom texture mask. Giving priority to center screen pixels and less along borders, where bright objects may appear, steadies auto-exposure results.
  If Pre-exposure (Project Setting > Engine > Rendering > Apply Pre-exposure before writing to the scene color) is enabled, previous frame scene exposure is applied to shaders. This is beneficial for bright lights and increases Auto Exposure Basic quality.
  The Level Viewport offers a quick, physically-based camera exposure previewer, EV100 editor overrides, which is located in the Level Viewport's Lit menu. If you choose to use it, uncheck the Game Settings checkbox first. You can apply EV100 Guide data to EV100 editor override values.

Note: An EV100 editor override value of 0 = shutter speed: 1, ISO: 100, and aperture: 1.


Since light calculations occur in linear color space, it’s advised to sometimes view sRGB albedo textures in this format to better understand how base colors impact lighting. (Typically, linear values are darker than sRGB ones.) For example, linear albedo values that appear too dark may not bounce enough light due to its high-absorption properties, thus potentially flattening baked lighting results. Inversely, linear albedo values that are very bright may reflect too much indirect light, creating a scene that could be hard to balance. (Most dielectric albedo colors exist in the sRGB midtones, while a majority of metallic albedo colors reside in the 218-255 sRGB range.) Finally, albedo values that are too saturated may scatter overly-colored bounce light, rendering a potentially undesirable look. You can visit the Albedo Luminance Range section for more information on suggested PBR base color value ranges. Below are other material properties to consider regarding light interactivity.
Low-absorption and no scattering.
Low-absorption and high-scattering.
High-absorption or reflectance and low-scattering.


UE4 uses the ACES Filmic Tonemapper to help map HDR values and wide color gamuts to LDR displays, and to future-proof content. While using the tone mapping function, visuals obtain higher-quality and more realistic results. For instance, as colors become more desaturated the brighter it gets, there's a reduction of flattened highlights, a greater use of contrast range, and shading/color is better preserved. (For comparative purposes, you can enable/disable the ACES Tonemapper by going to the Level Viewport > Show > Post Processing > Tonemapper.) In addition, the Rec.709 color profile is UE4’s default viewing space for LDR displays so that it can match broadcast standards used by console games.

UE4 real-time ray tracing supports shadows, reflections, translucency, ambient occlusion, and global illumination with a hybrid rendering approach (ray tracing/rasterization mix).

Section Links​: System Requirements | RT Components | Path Tracer | Post Process Volume RT Options | RT Shadow Attributes | General Optimization Tips and Tricks | Console Variables | Denoisers | SSGI | GPU Lightmass


  Windows 10, Build 1809+
  DXR-compatible GPU
  UE 4.22+
In the UE4 Project Settings, the following attributes need to be enabled:
  Platforms > Windows > Default RHI > DirectX 12
  Engine > Rendering > Ray Tracing (Support Compute Skincache must also be enabled.)


  The guide below outlines each of the real-time ray tracing (RTRT) components.
Global Illumination (RTGI)
Diffuse component of bounce light.
Reflections (RTR)
Specular component of bounce light for whole-scene/inter-reflections.
Translucency (RTT)
Reflection, absorption, and refraction properties for transparent surfaces.
Ambient Occlusion (RTAO)
Blocked indirect light.
Soft area shadows. Light size/source angle increases shadow softening over distance.
From left to right are images of RTGI increasing in bounce amount.

Note: When RTGI is enabled, its settings and Denoiser, override the RTAO parameters. In addition, increased RT bounces cost more on performance.
From left to right, are images of RTR increasing in bounce amount.
  Final Gather offers an alternative, 2-pass RTGI solution for better performance but with some drawbacks, like a 1-bounce limit and previous frame ghosting. For this method to work, 16 shading point samples of history is collected in screen space and then a 2nd-pass tries to merge them. You can enable Final Gather from within the Post Process Volume's Ray Tracing Global Illumination settings and changing the Type to "Final Gather."
It is recommended to set the Max. Bounces to "1" and Samples Per Pixel to "16." SPP value increases should be done by powers of 2. The image below compares 2 RTGI methods: Brute Force and Final Gather.
The guide below lists Final Gather console variables.
r.RayTracingGlobalIllumination [2]
Enables Final Gather.
r.RayTracing.GlobalIllumination.FinalGatherDistance [0-N]
Suppresses temporal ghosting artifacts.


For quicker iteration time, the built-in path tracer renders unbaised, progressive, physically-based ground truth reference to compare/validate the real-time, ray traced results. It can be enabled via the Level Viewport > Lit > Path Tracing.


The Post Process Volume contains many high-level parameters to control RT. (Post Process Volume > Details > Rendering Features) You can add more Post Process Volumes to a scene and determine which RT features are important for specific areas, like interior vs exterior spaces. The image below displays the various Post Process Volume RT attributes.
The guide below outlines the Post Process Volume RT attributes. 
Samples Per Pixel
Number of samples per pixel.
RTGI/RTR/Path Tracer
Max Bounces
Maximum number of bounces for light/inter-reflections.
Determines if RT or SSR/rasterized translucency is used.
Max Roughness
Roughness threshold for RT/rasterized methods.
Sets reflected shadows to be hard, soft, or disabled.
RTAO intensity in indirect light.
RTAO spread in UE4 units.
Enables/disables RTGI.
Max Refraction Rays
Maximum number of refraction rays.
Toggles RT Translucency. If disabled, rays will not scatter.


RT Shadow attributes are controlled by light sources.
The guide below lists the RT Shadow attributes.
All Lights
Cast Raytraced Shadow
Sets the light to use RT Shadows or shadow maps.
All Lights
Samples Per Pixel
Number of samples per pixel for RT Shadows.
Source Angle
Angular diameter. Smaller angles = sharper shadows. Larger angles = softer shadows.
Source Radius
Smaller radius = sharper shadows. Larger radius = softer shadows.
Source Width/Height
Smaller values = sharper shadows. Larger values = softer shadows.
Barn Door Angle/Length
Shapes/softens shadows.
Note: Unless specified, RT Shadows can be drawn from an infinite distance. And, the larger the light's source angle/radius/size, the more expensive RT Shadows become.


  From cheapest to most expensive RT components: shadows, RTAO, RTR, and then RTGI. (Secondary/additional bounces can be more expensive than the first one due to more surface variance interactions.)

  Specific UE4 Stat commands (GPU, FPS, and Unit) can help you understand the hardware impact of a scene’s RT setup. These tools can be found in the Level Viewport > top, left-hand corner dropdown arrow > Stat > Advanced/Engine options.

  For optimization, both RT and lightmap/rasterization techniques can be combined.

  Lights offer RT component overrides for RT Shadows, RTR, and RTGI. These overrides work when RT is globally enabled, and the corresponding RT components are activated via (except for RT Shadows) a Post Process Volume.
  Material complexity, as well as opacity masks, can impact RT performance. With the Material Editor's RayTracingQualitySwitch node (It supports RTR, RTT, and RTGI.), simplified/optimized representations of material graphs can be used for RT hit shaders. In addition, actors have a Visible in Ray Tracing option (Actor > Details > Rendering > Visible in Ray Tracing) to determine whether it gets calculated for RT or not.
  Using master materials with a few instances is cheaper on RT than having many shader permutations. (The fewer the shaders, the cheaper real-time RT becomes.)

  RTGI can be more expensive for interiors (More indoor bounces can occur, while outdoor rays discontinue once they exit the scene toward the sky. Not to mention directly lit areas render faster than indirect spaces, and larger scenes work better for RT than rasterized techniques.) than exteriors. Detailed geometry, or small holes/spaces (Vegetation or fences, for example.), can affect performance. Larger, geometric shapes work better.

  RTR is best suited for glossy reflections for accuracy and its cost can vary greatly based on roughness values. Fully-rough materials are the cheapest (They do not bounce reflection rays. Instead, they rely on cheaper, rasterized reflection techniques.), followed by fully-glossy surfaces (When rays bounce in the same direction, via ray coherency or a lack of ray variance, they become cheaper to calculate.), then near fully-glossy, and finally, roughness values around 0.5 to near fully-rough, being the most expensive. (The more ray traversal variance/noise, the more expensive. Also, rougher surfaces need a large number of rays to properly converge.)

Note: No assigned roughness map/value is more expensive than setting it to a value of 1. By default, UE4 treats the roughness material property with a value of 0.5. And for optimal performance, either fully-rough or fully-glossy values work best for RTR. Additionally, controlling RTR's Max Roughness (Post Process Volume > Details > Rendering Features > Ray Tracing Reflections > Max Roughness) can reduce RTR noise on rougher surfaces and help optimize a scene.

  Shadowing is usually the most expensive reflection component, followed by direct light, and then indirect light/emissive surfaces.

  Like roughness textures, normal maps can impact RT costs due to bounce variance from differing normal pixel values. The more intense/complex/high-frequency the normal map, the more random the light bounces and more expensive RT becomes. In addition, reducing normal map noise can not only help RT performance but it can also decrease flickering RTR. If normal maps are an issue, a RayTracingQualitySwitch node can be used to prevent them from being calculated by RT.

  Minimize RT inter-reflections, as they require multiple bounces. You can use reflection captures to fill in black areas that are beyond the RTR max bounce/reflection distance thresholds. The following cvar can enable/disable this effect: r.RayTracing.Reflections.ReflectionCaptures [0|1].

  If you’re needing sharper RTR, disable the RTR Denoiser since it can soften RTR. The following cvar can enable/disable the RTR Denoiser: r.Reflections.Denoiser [0|1]. If you disable the Denoiser, you may need to increase RTR’s Samples Per Pixel (Post Process Volume > Details > Rendering Features > Ray Tracing Reflections > Samples Per Pixel) to clean up RTR noise. Keep in mind this will impact performance.
  RT Shadows can perform better than cascaded/dynamic shadow maps (This is due to RT being less sensitive to polycounts than rasterized techniques.), especially for outdoor environments. (Bounding volume hierarchies are used to minimize ray intersection tests.)


The guide below is not designed to be a comprehensive list of all the RT console variables. Instead, it provides a collection of some features to help optimize and control a scene. High-level parameters available in the UI (Post Process Volume, light sources, actors, etc.) are not listed.

Note: [0|1] values are used for each console variable unless stated otherwise.
Toggles materials for RT and to test material cost.
r.RayTracing.Reflections.ScreenPercentage [50|100]
Changes RTR resolution by a %.
r.RayTracing.GlobalIllumination.ScreenPercentage [25|50|100]
Changes RTGI resolution by a %.
Toggles sky light RTGI.
r.RayTracing.Reflections.MinRayDistance [0-N]
Min RTR distance. (scene units) Rays that terminate before surface contact sample the sky.
r.RayTracing.Reflections.MaxRayDistance [0-N]
Max RTR distance. (scene units) Rays that terminate before surface contact sample the sky.
r.RayTracing.GlobalIllumination.MaxRayDistance [0-N]
Max RTGI distance. (scene units) Rays that terminate before surface contact do not contribute.
Toggles Height Fog visibility in RTR.
Toggles two-sided geo for RT Shadows.
Toggles two-sided geo for RTAO.
Toggles two-sided geo for Sky Lights.
Toggles alpha masking.
Sorts RTR rays based on material coherence. There is an overhead cost, so performance may vary.
Toggles RT.
Note: Console variables can be implemented into the scene's Level Blueprint (Or via .ini files.) so they don’t have to be manually set up from the console. In the Level Blueprint, console variables can be added to Execute Console Command nodes.


From left to right are examples of the Denoiser and TAA filtering RT samples.
Currently, the Denoiser supports only 1 spp. (Though, RTR offers multi-ssp support.) While this process leads to some information loss, the results are comparable to non-denoised, multiple ssp, like in the images below.


Screen Space Global Illumination (SSGI) is dynamic indirect lighting from the camera's view. Performance cost is moderate and it supports emissive materials. SSGI is designed to be supplemental bounce for baked lighting. However, if it's used as the only GI solution, typical screen space artifacts can become more pronounced.

The comparison below illustrates the limitations of SSGI. In the first image (left), SSGI can be observed in the shadows. Once the camera is rotated, like in the second image (right), parts of surfaces from the first image are not visible anymore. In effect, most SSGI is lost in the shadows.
Note: RTGI does not have to be enabled for this feature, but SSGI needs to be turned on in order to use it. (Edit > Project Settings > Engine > Rendering > Lighting > Screen Space Global Illumination (Beta)) If RTGI is active, SSGI is disabled.

A Post Process Volume's Indirect Lighting Color/Intensity parameters can be used to modify SSGI. When using SSGI, a Post Process Volume's SSAO settings are disabled. However, SSGI includes SSAO.
The guide below lists SSGI console variables.

Note: [0|1] values are used for each console variable unless stated otherwise.
Toggles on/off SSGI.
r.SSGI.Quality [0|1|2|3|4]
Modifies SSGI quality.
0: Turns off SSGI.
1: Ray Steps = 8. Ray Count = 4.
2: Ray Steps = 8. Ray Count = 8.
3: Ray Steps = 8. Ray Count = 16.
4: Ray Steps = 12. Ray Count = 32.
Toggles on/off half-resolution SSGI.
Toggles on/off previous frame color use for higher-quality SSGI.
From left to right are examples of increasing SSGI quality settings.

This progressive GPU lightmapper is a hardware ray tracer based on path tracing and utilizes DirectX 12/DXR to reduce bake times. Below lists the required items to utilize it from the Build menu.

  RTRT. (See the RT System Requirements section for details.)
  Enable GPU Lightmass via the Plugins menu. (Edit > Plugins > Editor > GPU Lightmass > check Enabled)
  (optional) Enable virtual texture support and Enable virtual texture lightmaps from the Project Settings (Edit > Project Settings > Rendering > Virtual Textures) for real-time lightmap previewing.

Note: To disable all RT effects and allow more resources for GPU Lightmass, use the following cvar: r.RayTracing.ForceAllRayTracingEffects 0.

THE MATTED, WHITE PAPER TEST ​(developed in UE 4.20)
To confirm the accuracy of UE4’s PBR lighting system without adjusting the Sky Light’s Intensity parameter, I created a simple scene to evaluate it with the Pixel Inspector. This test uses physical values of matted, white paper and real-world data for sun/sky intensities. You can click on the gallery images below to learn more about this process.

UE4 CUBEMAP ORIENTATION GUIDE (for custom skybox cubemaps)
​Cubemap panels need to be arranged in a specific manner for correct orientation in UE4. The guide below represents these panels in a horizontal strip format, ordered from left to right, as you go down the list. 
90° CCW
90° CW
No Rotation
No Rotation
No Rotation
Note: Alternatively, you can import a 32-bit OpenEXR sky texture with an equirectangular, 2:1 aspect ratio, use it within a material, assign it to a sphere covering the whole background, and then capture the results in a cubemap via the Sky Light. Techniques for skybox setup can be found in The Matted, White Paper Test section.


It’s important that textures are interpreted in the correct color space, so below is a guide to help with this process.
Base colors with no lighting/spec/shading data. Most albedo values exist in the midtones.
3 | RGB
Baked, high-res surface detail with vector directionality data for direct light interaction.
3 | RGB
Linear RGB
Blocks ambient light.
1 | Grayscale
Linear RGB
​Micro-ambient occlusion. 
1 | Grayscale
Linear RGB
​Surface elevation information.
1 | Grayscale
Linear RGB
​Determines if a material is a metal, dielectric, or a mix. 
1 | Grayscale
Linear RGB
1 | Grayscale
Linear RGB
​Defines reflective surface properties. 
1 | Grayscale
Linear RGB
​Controls scattered light passing through a surface.
1 | Grayscale
Linear RGB
Note: Channel packing multiple grayscale maps into one texture can save on memory cost.

Proper edge padding can minimize color bleeding artifacts from mip mapping. The guide below displays different texture resolutions with corresponding edge padding values for UV shell spacing and downsizing of textures.
256 x 256
512 x 512
1,024 x 1,024
2,048 x 2,048
4,096 x 4,096
≥ 16px

UE4 PBR MATERIAL GUIDE (requires UE 4.26)
​UE4 supports the metallic/roughness PBR workflow. Some of the values listed below work best in UE4 and may not be suited for other applications. Further, UE4's environment and color picker live in linear color space, but artists typically work in sRGB. In effect, the following values are in sRGB first with corresponding sRGB color swatches. 

Section Links: Albedo Luminance Range | Metallic Range | Roughness Range | Specular Guide | Index of Refraction Guide | Thin Translucent Guide | Clear Coat GuideGrays Guide | Gamma Conversion Guide | Dielectric Albedo Values Guide | Metallic Albedo Values Guide | Albedo L​uminance Guide | Albedo S​aturation % ​Guide

Albedo LUMINANCE range

Dielectric albedo values control reflected color and most exist in the midtone range. Charcoal is the darkest dielectric albedo value that should be used. Insulators don't typically have colored specular reflectivity, but lights affect reflected color.
​​sRGB = ​​2b2b2b
Linear RGB = 
​​sRGB = ​43
Linear RGB = 
​​sRGB = ​0.17
Linear RGB = 
Fresh Snow 
Dielectric albedo values control reflected color and most exist in the midtone range. Fresh snow is the brightest dielectric albedo value that should be used. Insulators don't typically have colored specular reflectivity, but lights affect reflected color.
​​sRGB = ​​e8e8e8​
Linear RGB = cecece
​​sRGB = ​232
Linear RGB = 
​​​sRGB = ​0.91
Linear RGB = 
Unlike dielectric base colors, metallic albedo brightness controls specular intensity, which can contain color. Conductive albedo values fall within this row’s range. 
​sRGB = d9d9d9​ - ffffff
Linear RGB = b1b1b1 - ffffff
​​sRGB = 217 - 255
Linear RGB = 179 - 255
​sRGB = 0.85 - 1
Linear RGB = 0.7 - 1

Metallic Range

On average, most dielectrics have a F0 value of 4% reflectivity and do not require a metallic map. If they are part of an asset that needs one, the non-metal portions should be black. Further, metallic map properties should represent the top layer of the material, like painted metal, which would not be metallic in this case.
​sRGB = 000000
Linear RGB = 000000

​sRGB = 0
Linear RGB = 0

​​sRGB = 0
Linear RGB = 0

This map determines whether the albedo map is treated as reflected color or metallic reflectance values. Most metals have a value of 1, and the metallic map is multiplied against the base color texture. You can have gradient transitions between insulators and conductors. Exceptions, like metalloids, may use values that are neither 0 or 1.
​​sRGB = ffffff
Linear RGB = ffffff

​​sRGB = 255
Linear RGB = 255

​​sRGB = 1
Linear RGB = 1

The images below display ​increasing dielectric-to-conductor metallic properties.

Roughness Range

The roughness map controls size/spread, sharpness, and light direction for rough/smooth reflective surface attributes. Real-world data is not used for its rendering, thus allowing for more artistic interpretation. The images below display increasing rough-to-glossy properties for both dielectric (top row) and metallic materials. (bottom row)
Note: Roughness and normal maps are used to describe micro/macro surface detail. Additionally, Composite Textures can help reduce specular aliasing and shimmering of normals maps by combining them with roughnesss maps, creating brighter, more matted roughness map variants.

Specular GUIDE

UE4’s specularity has a default value of 0.5, or 4% reflectance, to represent common dielectrics. (Metals are not affected by this property since their albedo maps control specular strength.) However, more unique materials, like semiconductors and gemstones, can be higher. Since all surfaces have some level of specular reflectivity, this property should never be set to 0. You can connect cavity maps to it, but they should first be multiplied against the default 0.5 value. This is for consistency with UE4’s average dielectric F0 reflectance value, while removing specularity in baked, micro-occluded areas.

​UE4 remaps the normalized 0 - 1 range to 0 - 0.08 for specular input. This means UE4’s specular component can have a maximum of 8% for its dielectric F0 reflectance value. (F0 is the reflected light intensity at 0° to the view frustum. The “F” component is Fresnel, which describes varying reflected light strength based on viewing angle.) The formulas below calculate the dielectric F0 reflectance value from IOR, followed by applying a conversion for UE4 specular reflectivity use.
​((1 - IOR) / (1 + IOR))² = Dielectric F0 Reflectance Value
ielectric F0 Reflectance Value / 0.08) = UE4 Specular Reflectivity Value
​​sRGB = 818181​
Linear RGB = 
​​sRGB = ​129
Linear RGB = 57
​​sRGB = ​0.506
​Linear RGB = 
sRGB = ​898989
​Linear RGB = 
​​sRGB = ​137
​Linear RGB = 65
​​sRGB = ​0.537
​Linear RGB = 
​​sRGB = ​​8f8f8f
​Linear RGB = 
​​sRGB = ​143
​Linear RGB = 71
​​sRGB = ​0.561
​Linear RGB = 
​​sRGB = ​​9e9e9e​
​Linear RGB = 575757​
​​sRGB = ​158
​Linear RGB = 89
​​sRGB = ​0.62
​Linear RGB = 
​​sRGB = ​​bababa
​Linear RGB = 7d7d7d

​​sRGB = ​186
​Linear RGB = 128
​​sRGB = ​0.73
​Linear RGB = 
​​sRGB = ​​bababa
​Linear RGB = 7d7d7d

​​sRGB = ​186
​Linear RGB = 128
​​sRGB = ​0.73
​Linear RGB = 
​​sRGB = ​c5c5c5​
​Linear RGB = 8e8e8e​
​​sRGB = ​197
​Linear RGB = 145
​​sRGB = ​0.773
​Linear RGB = 
The images below display increasing specular properties.

 Index of Refraction gUIDE

Index of Refraction, or IOR, describes how much light bends through medium to another. The values below are based on real-world, optical measurements.
Linear Value = 1​
Linear Value = 1.31​
​​Linear Value = 1.33​
Common Dielectrics
​​Linear Value = 1.5​
​​Linear Value = 1.52​
Linear Value = 2.42
The images below display increasing index of refraction properties.

The physical Thin Translucent Shading Model renders (in one pass) tinted, transparent materials (i.e. glass) with white, specular highlights and colored surface backgrounds.
The comparison below displays the differences between the standard Translucent Shading Model (left) and the Thin Translucent one. (right)
The guide below covers which material attributes need to be modified/added in order to use the Thin Translucent Shading Model.
Material > Blend Mode
Material > Shading Model
Thin Translucent
Translucency > Lighting Mode
Surface ForwardShading
Thin Translucent Material Expression
Connect a texture/color expression to it.

Clear Coat simulates multilayered materials with dual normal/roughness parameters for a transparent film layer effect on top of dielectric/metallic surfaces. Examples of this kind of material include lacquer, films over car paint/soda cans, and carbon fiber. To use it in UE4, it first needs to be enabled within the Project Settings, followed by changing a material’s Shading Model to Clear Coat. The guide below covers some Clear Coat material properties.
Clear Coat
​Clear Coat layer strength. This should usually be set to 0 or 1. (black or white for a texture map)
​Clear Coat Roughness
Clear Coat layer roughness attribute.
Clear Coat layer normal attribute.
​Bottom layer roughness attribute.
Bottom layer normal attribute. This node needs to be added, with a normal map connected to it, for dual-normal/multidirectional direct light interaction
The images below display increasing Clear Coat properties.


Neutral Gray
Neutral gray can be  used for texturing. 
​sRGB = bababa​
​Linear RGB = 7d7d7d
​sRGB = 186
​Linear RGB = 128
​sRGB = 0.73
​Linear RGB = 0.5

Middle Gray 
18%-gray can be used for lighting tests.
sRGB = 757575​
​Linear RGB = 2d2d2d
​sRGB = 117
​Linear RGB = 46
sRGB = 0.46
​Linear RGB = 0.18 

Gamma Conversion GUIDE

Gamma Correction-to-Linear RGB
(Gamma Correction Value ^ (1/2.2)) = Linear RGB Value
Linear RGB-to-Gamma Correction
(Linear RGB Value ^ 2.2) = Gamma Correction Value
Normalized Gamma Correction-to-Normalized Linear RGB
(Normalized Gamma Correction Value ^ 2.2) = Normalized Linear RGB Value
(Normalized Linear RGB Value * 255) = Linear RGB Channel Value​
Normalized Linear RGB-to-Normalized Gamma Correction
(Normalized Linear RGB Value ^ (1/2.2)) = Normalized Gamma Correction Value
(Normalized Gamma Correction Value * 255) = Gamma Correction Channel Value


Forged Iron
sRGB = ​3a383b
​Linear RGB = ​
sRGB = ​​​(58, 56, 59)
​Linear RGB = ​(10, 9, 10)

Dark Soil
sRGB = ​​553d31​
​Linear RGB = 
sRGB = ​​​(85, 61, 49)
​Linear RGB = ​(23, 11, 7)

Worn Asphalt
sRGB = ​​5b5b5b​
​Linear RGB = ​
sRGB = ​​​(91, 91, 91)
​Linear RGB = ​(26, 26, 26)

Varnished Wood
sRGB = ​​875c3c​
​Linear RGB = ​
sRGB = ​​(135, 92, 60)
Linear RGB = ​(63, 27, 11)
Tree Bark
sRGB = ​​72675b​
​Linear RGB = ​
sRGB = ​​(114, 103, 91)
​Linear RGB = ​(43, 35, 26)

Green Vegetation
sRGB = ​​7b824e
​Linear RGB = ​
sRGB = ​​​(123, 130, 78)
​Linear RGB = ​(51, 58, 19)

Gray Plaster
sRGB = ​​818181​
​Linear RGB = ​
sRGB = ​​​(129, 129, 129)
​Linear RGB = ​(57, 57, 57)

sRGB = ​​947d75​
​Linear RGB = ​
sRGB = (148, 125, 117)
​Linear RGB = ​(77, 53, 46)

Old Concrete
sRGB = ​​878883​
​Linear RGB = ​
sRGB = ​​(135, 136, 131)
​Linear RGB = ​(63, 64, 59)

Gray Paint
sRGB = ​​a3a3a3​
​Linear RGB = ​
sRGB = ​​(163, 163, 163)
Linear RGB = ​(95, 95, 95)
sRGB = ​​b1a784​
​Linear RGB = ​
sRGB = ​​​(177, 167, 132)
​Linear RGB = ​(114, 100, 60)

Clean Cement
sRGB = ​​c0bfbb​
​Linear RGB = ​
sRGB = ​​(192, 191, 187)
Linear RGB = ​(137, 135, 129)
Rough Wood
sRGB = ​​e0c7a8​
​Linear RGB = ​be
sRGB = ​​​(224, 199, 168)
​Linear RGB = ​(192, 148, 102)

Metallic Albedo Values GUIDE

sRGB = ​ffe29b​
​Linear RGB = ​​ffc253
sRGB = ​​(255, 226, 155)
​Linear RGB = ​​
(255, 196, 85)
sRGB = ​c4c7c7
​Linear RGB = ​8d9292
sRGB = ​​​​(196, 199, 199)
​Linear RGB = ​​
(143, 148, 148)
sRGB = ​fad0c0​
​Linear RGB = ​f4a186
sRGB = ​​​​(250, 208, 192)
​Linear RGB = ​​
(244, 163, 137)​
sRGB = ​fcfaf5​
​Linear RGB = ​f9f4e9
sRGB = ​​​​(252, 250, 245)
​Linear RGB = ​​
(248, 244, 234)
sRGB = ​d3d2cf​
​Linear RGB = ​a6a49f
sRGB = ​​​​(211, 210, 207)
​Linear RGB = ​​
(168, 166, 161)​
sRGB = ​f5f6f6​
​Linear RGB = ​e9ebeb
sRGB = ​​​​(245, 246, 246)
​Linear RGB = ​​
(234, 236, 236)
sRGB = ​c1bab1​
​Linear RGB = ​887d70
sRGB = ​​​​(193, 186, 177)
​Linear RGB = ​​
(138, 127, 114)​
sRGB = ​c2c3c3​
​Linear RGB = ​8a8b8b​
sRGB = ​​​​(194, 195, 195)
​Linear RGB = ​​
(140, 142, 141)
sRGB = ​d5d0c8​
​Linear RGB = ​aaa193
sRGB = ​​​​(213, 208, 200)
​Linear RGB = ​​
(172, 163, 149)​
sRGB = ​d3cbbe​
​Linear RGB = ​a69883
sRGB = ​​​​(211, 203, 190)
​Linear RGB = ​​
(168, 154, 133)

((0.3 * Normalized R Channel Value) + (0.59 * Normalized G Channel Value) + (0.11 * Normalized B Channel Value)) = Normalized Y Value
​(Normalized Y Value * 255) = Normalized Y Channel Value
sRGB = fafafa​
Linear RGB = ​​f4f4f4
sRGB = ​​​250
Linear RGB = ​​​244
sRGB = ​​​0.98
Linear RGB = ​0.957
sRGB = ​​f6f6f6
Linear RGB = ​​ebebeb
sRGB = ​​​246
Linear RGB = ​​​235
sRGB = ​​​0.965
Linear RGB = 0.​​922
sRGB = ​​e6e6e6
Linear RGB = ​​cacaca
sRGB = ​​​230​
Linear RGB = ​​202
sRGB = ​​​0.902
Linear RGB = ​​0.792
sRGB = ​​d9d9d9
Linear RGB = ​​b1b1b1
sRGB = ​​​217​
Linear RGB = ​​177
sRGB = ​​​0.851
Linear RGB = ​​0.694
sRGB = ​​d2d2d2
Linear RGB = ​​a4a4a4
sRGB = ​​​210​
Linear RGB = ​​164
sRGB = ​​​0.824
Linear RGB = ​​0.643
sRGB = ​​d0d0d0
Linear RGB = ​​a1a1a1
sRGB = ​​​208​
Linear RGB = ​​161
sRGB = ​​​0.816
Linear RGB = ​​0.631
sRGB = ​​cccccc
Linear RGB = ​​9a9a9a
sRGB = ​​​204​
Linear RGB = ​​154
sRGB = ​​​0.8
Linear RGB = ​​0.604
​Rough Wood
sRGB = ​​cbcbcb
Linear RGB = ​​989898​
sRGB = ​​​203​
Linear RGB = ​​152
sRGB = ​​​0.796
Linear RGB = 0.​​596
sRGB = ​​c6c6c6
Linear RGB = ​​909090​
sRGB = ​​​198​
Linear RGB = ​​144
sRGB = ​​​0.776
Linear RGB = ​​0.565
sRGB = ​​c3c3c3
Linear RGB = ​​8b8b8b
sRGB = ​​​195​
Linear RGB = ​​139
sRGB = ​​​0.765
Linear RGB = ​​0.545
​Clean Cement
sRGB = ​​bfbfbf
Linear RGB = ​​858585​
sRGB = ​​​191​
Linear RGB = ​​133
sRGB = ​​​0.749
Linear RGB = ​​0.522
sRGB = ​​bbbbbb
Linear RGB = ​​7f7f7f
sRGB = ​​​187​
Linear RGB = ​​127
sRGB = ​​​0.733
Linear RGB = ​​0.498
sRGB = ​​a7a7a7
Linear RGB = ​​626262​
sRGB = ​​​167​
Linear RGB = ​​98
sRGB = ​​​0.655
Linear RGB = ​​0.384
​Gray Paint
sRGB = ​​a3a3a3
Linear RGB = 5d5d5d​​
sRGB = ​​​163​
Linear RGB = ​​93
sRGB = ​​​0.639
Linear RGB = ​​0.365
​Old Concrete
sRGB = ​​878787
Linear RGB = ​​3e3e3e
sRGB = ​​​135​
Linear RGB = ​​62
sRGB = ​​​0.529
Linear RGB = ​​0.243
sRGB = ​​828282
Linear RGB = ​​393939​
sRGB = ​​​130​
Linear RGB = ​​57
sRGB = ​​​0.51
Linear RGB = ​​0.224
​Gray Plaster
sRGB = ​​818181
Linear RGB = ​​383838​
sRGB = ​​​129​
Linear RGB = ​​56
sRGB = ​​​0.506
Linear RGB = ​​0.22
​Green Vegetation
sRGB = ​​7e7e7e
Linear RGB = ​​353535​
sRGB = ​​​126​
Linear RGB = ​​
sRGB = ​​​0.494
Linear RGB = ​​0.208
​Tree Bark
sRGB = 686868​​
Linear RGB = ​​232323​
sRGB = ​​​104​
Linear RGB = ​​35
sRGB = ​​​0.408
Linear RGB = ​​0.137
​Varnished Wood
sRGB = ​​666666
Linear RGB = 222222​​​
sRGB = ​​​102​
Linear RGB = ​​34
sRGB = ​​​0.4
Linear RGB = ​​0.133
​Worn Asphalt
sRGB = ​​5a5a5a
Linear RGB = ​​1a1a1a
sRGB = ​​​90​
Linear RGB = ​​26
sRGB = ​​​0.353
Linear RGB = ​​0.102
​Dark Soil
sRGB = ​​424242
Linear RGB = ​​0d0d0d
sRGB = ​​​66​
Linear RGB = ​​13
sRGB = ​​​0.259
Linear RGB = ​​0.051
Forged Iron
sRGB = ​383838
Linear RGB = 0a0a0a​​
sRGB = ​​​56​
Linear RGB = ​​10
sRGB = ​​​0.22
Linear RGB = ​​0.039

(((Max (RGB Channel Value) - Min (RGB Channel Value)) / Max (RGB Channel Value)) * 100) = Saturation %
​​Varnished Wood
sRGB = 56%
​Linear RGB = 82%
​​Dark Soil
sRGB = 42%
​Linear RGB = ​​70%
​Green Vegetation
sRGB = 40%
​Linear RGB = ​67%
sRGB = 39%
​Linear RGB = ​67%
sRGB = 25%
​Linear RGB = ​​47%
Rough Wood
sRGB = 25%
​Linear RGB = ​​​47%
sRGB = 23%
​Linear RGB = ​​​45%
sRGB = 21%
​Linear RGB = ​​40%
​​Tree Bark
sRGB = 20%
​Linear RGB = ​​40%
sRGB = 10%
​Linear RGB = ​21%
sRGB = 8%
​Linear RGB = ​​18%
sRGB = 6%
​Linear RGB = ​​14%
​Forged Iron
sRGB = 5%
​Linear RGB = ​​9%
​Old Concrete
sRGB = 4%
​Linear RGB = ​​8%
sRGB = 3%
​Linear RGB = ​​6%
​​Clean Cement
​sRGB = 3%
​Linear RGB = ​​5%
sRGB = 2%
​Linear RGB = ​​4%
sRGB = 2%
​Linear RGB = ​​3%
sRGB = 1%
​Linear RGB = ​​1%
sRGB = 1%
​Linear RGB = ​​1%
​Worn Asphalt
sRGB = 0%
​Linear RGB = ​​0%
​​Gray Plaster
sRGB = 0%
​Linear RGB = ​​0%
​​Gray Paint
sRGB = 0%
​Linear RGB = ​​0%