# Local Fog Volumes render nothing on macOS (Metal SM6, Apple M3 Max) in -game and Movie Render Queue 

**URL:** <https://forums.unrealengine.com/t/local-fog-volumes-render-nothing-on-macos-metal-sm6-apple-m3-max-in-game-and-movie-render-queue/2853052>\
**Category:** Issues and Bug Reporting (Unreal Engine)\
**Tags:** Fog, unreal-engine, volumetric-fog\
**Created:** [November 9, 2026, 9:13pm UTC](https://forums.unrealengine.com/t/local-fog-volumes-render-nothing-on-macos-metal-sm6-apple-m3-max-in-game-and-movie-render-queue/2853052 "2026-11-09T21:13:56Z")\
**Posts on this page:** 1\
**Page:** 1

<div class="post-metadata">

**Author:** ![Mozhna\_Liza](https://d3kjluh73b9h9o.cloudfront.net/original/4X/2/8/5/28502927f1d97ba1051b3b47ccfe17233bf41ef0.png) [@Mozhna\_Liza](https://forums.unrealengine.com/u/Mozhna_Liza)\
**Post date:** [November 9, 2026, 9:13pm UTC](https://forums.unrealengine.com/t/local-fog-volumes-render-nothing-on-macos-metal-sm6-apple-m3-max-in-game-and-movie-render-queue/2853052/1 "2026-11-09T21:13:57Z")

</div>

### Summary

On macOS, Local Fog Volumes have no visible effect at all in a `-game` run or a Movie Render Queue render. The volume is registered with the scene: the debug overlay text reports its start distance. But nothing is drawn, not even the tile debug colours of `r.LocalFogVolume.TileDebug 2`, and that holds with volumetric fog disabled, as the documentation requires for the debug view. Exponential Height Fog, volumetric fog and Volume-domain materials render correctly in the same scene.  
Unreal Engine 5.8.4 (Launcher build, CL 58902052, `++UE5+Release-5.8`)

- macOS 15.6.1 (24G90)
- MacBook Pro Mac15,11, Apple M3 Max (30-core GPU), 36 GB unified memory, Metal 3
- RHI: Metal, shader platform METAL\_SM6; driver internal 329.2
- Project settings default for Local Fog Volumes (`r.SupportLocalFogVolumes` 1). Deferred renderer, Lumen GI and reflections, virtual shadow maps.

### What Type of Bug are you experiencing?

Level Design & Art Tools

### Steps to Reproduce

Empty level containing: a floor, three spot lights, an Exponential Height Fog (density 0.05, volumetric fog on), a post-process volume with manual exposure, and a camera at (-1000, 0, 260) looking down +X.  
2. Add a **Local Fog Volume** at (300, -500, 200), scale 0.6, Radial Fog Extinction 2 to 5, Height Fog Extinction 0, Fog Emissive (4, 0.6, 0.3) or up to (40, 4, 1.5), albedo near white.  
3. Render it with Movie Render Queue (`-game -LevelSequence=... -MoviePipelineConfig=...`), or run the level with `-game` and take `HighResShot`.  
4. Repeat with `r.VolumetricFog 0` and `r.LocalFogVolume.TileDebug 2`.  
voltest.py` (attached) builds the whole test level, sequence and render configs headless (`UnrealEditor-Cmd … -run=pythonscript -script=voltest.py`). The same level also holds a Volume-domain material mesh, which renders correctly.

### Expected Result

A visible emissive or extinguishing sphere of fog at the volume’s location.

- With `TileDebug 2` and volumetric fog off, coloured debug tiles over the volume’s screen area.

### Observed Result

No visible change at the volume’s location in any configuration: the image is identical to a scene without the volume.

- With `TileDebug 2`, only the canvas text appears: “LOCAL FOG VOLUME DEBUG VIEW / Global Start Distance = 1000.0 / Instances Start Distance = 1092.8”. No tile colours are drawn anywhere, with volumetric fog on or off, in `-game` or MRQ.
- These settings changed nothing (MRQ console variables, also set with `-ExecCmds`):
  - `r.LocalFogVolume.RenderIntoVolumetricFog 0`
  - `r.LocalFogVolume.RenderDuringHeightFogPass 1`
  - `r.LocalFogVolume.UseHZB 0` with `r.LocalFogVolume.TileCullingUseAsync 0`
  - `r.LocalFogVolume.GlobalStartDistance 10`
  - `r.LocalFogVolume.MaxDensityIntoVolumetricFog 1.0`

- These volume changes didn’t help: an arbitrarily rotated volume (to rule out the packed rotation reading back as denormals) and very high emissive.
- Adding a Sky Atmosphere and a visible Volumetric Cloud didn’t help either. A forum user on an M3 Max reported that as a workaround (thread linked below).

Notes from reading the 5.8 source

- `ShouldRenderLocalFogVolume` returns true: the debug overlay text is drawn by `RenderLocalFogVolumeVisualization`, which requires it.
- In debug mode 2, `LocalFogVolumeTiledPS` clips only when the contribution equals identity. No tiles appear, so either the tiled culling (`LocalFogVolumeTiledCulling.usf`) produces zero tiles or no indirect draws, or every pixel evaluates to identity in `GetLFVInstanceContribution`.
- The per-instance data goes through a `Buffer<float4>` SRV (`PF_A32B32G32R32F`) with integer bit patterns (half pairs, R11G11B10, RGBA8) and is read back with `asuint`. If Metal flushes denormal floats on typed buffer loads, that data could be corrupted. A rotated volume didn’t change the result, though, so this is unconfirmed.
- Possibly related reports, none with an Epic answer or bug number:
  - Local Fog Volumes show in the viewport but not in final renders (Sep 2025): [Local Fog visible in viewport but not rendered](https://forums.unrealengine.com/t/local-fog-visible-in-viewport-but-not-rendered/2653313)
  - Local fog shows as static noise on Mac in 5.4.4, while the PC build is fine: [Local Fog not working on Mac version of Project](https://forums.unrealengine.com/t/local-fog-not-working-on-mac-version-of-project/2576023)
  - Local fog volume “simply gone” on an M2 Max in 5.4.0: [UE 5.4.0 is much slower than UE 5.3.2 on Mac Metal](https://forums.unrealengine.com/t/ue-5-4-0-is-much-slower-than-ue-5-3-2-on-mac-metal/1807311)
  - Black blocks around local fog on an M3 Max in 5.3.2: [Local Height Fog always comes with black pixels in foreground](https://forums.unrealengine.com/t/local-height-fog-always-comes-with-black-pixels-in-foreground/1805418)

### Affects Versions

5.8

### Platform(s)

Mac

### Upload an image

 ![mrq_volfog_off_tiledebug2.jpeg](https://d3kjluh73b9h9o.cloudfront.net/original/4X/d/f/6/df6a36ab21024214ae62d875ecaa6a17d46027b5.jpeg) ![mrq_volfog_off.jpeg](https://d3kjluh73b9h9o.cloudfront.net/original/4X/4/d/0/4d0e2b64ced70dac2e97c61a545b3d57851913ba.jpeg) ![game_volfog_off_tiledebug2.png](https://d3kjluh73b9h9o.cloudfront.net/original/4X/e/a/b/eab94fc02c5cb9b77bd4589bfd82e169e95d1255.png) ![game_volfog_on_tiledebug2.png](https://d3kjluh73b9h9o.cloudfront.net/original/4X/6/a/e/6aed68d60d250e97eb15fc24959833387ea0d638.png)

### Additional Notes

# A small test level for fog volumes in Movie Render Queue, apart from any film’s level: three ways of putting fog in

# one place, side by side under three spots, in a thin height fog. Left: Local Fog Volume. Middle: a mesh with a Volume

# domain material (voxelized into the volumetric fog). Right: a translucent box raymarching its own fog.

# ue\_run.sh scripts/voltest.py, then voltest.sh base|debug|novox|clamp|hfog|nohzb|near|novf|debugnovf

import unreal

LEVEL = ‘/Game/voltest’  
OUT = ‘/Users/bogdan/av-studio/renders/voltest’  
les = unreal.get\_editor\_subsystem(unreal.LevelEditorSubsystem)  
eas = unreal.get\_editor\_subsystem(unreal.EditorActorSubsystem)  
eal = unreal.EditorAssetLibrary  
mel = unreal.MaterialEditingLibrary  
at = unreal.AssetToolsHelpers.get\_asset\_tools()  
CUBE = unreal.load\_asset(‘/Engine/BasicShapes/Cube’)  
X, Z = 300.0, 200.0  
YS = {‘lfv’: -500.0, ‘vol’: 0.0, ‘ray’: 500.0}  
SIZE = 3.0 # the volumes’ scale: 300 cm across

def fresh(path):  
if eal.does\_asset\_exist(path):  
eal.delete\_asset(path)

def material(name):  
path = ‘/Game/mat/’ + name  
fresh(path)  
return at.create\_asset(name, ‘/Game/mat’, unreal.Material, unreal.MaterialFactoryNew())

def const3(m, v, x, y):  
e = mel.create\_material\_expression(m, unreal.MaterialExpressionConstant3Vector, x, y)  
e.set\_editor\_property(‘constant’, unreal.LinearColor(\*v, 1.0))  
return e

def const1(m, v, x, y):  
e = mel.create\_material\_expression(m, unreal.MaterialExpressionConstant, x, y)  
e.set\_editor\_property(‘r’, v)  
return e

PATCH = ‘’’  
float3 d = (WP - Obj) / R; // -1..1 across the volume’s mesh  
float edge = saturate(1.0 - length(d));  
float3 p = WP \* 0.004 + float3(Time \* 0.05, -Time \* 0.03, Time \* 0.02);  
float n = 0.0, amp = 0.5;  
for (int i = 0; i \< 4; i++) {  
float3 f = frac(p), q = floor(p);  
f = f \* f \* (3.0 - 2.0 \* f);  
float h000 = frac(sin(dot(q, float3(127.1, 311.7, 74.7))) \* 43758.5);  
float h100 = frac(sin(dot(q + float3(1, 0, 0), float3(127.1, 311.7, 74.7))) \* 43758.5);  
float h010 = frac(sin(dot(q + float3(0, 1, 0), float3(127.1, 311.7, 74.7))) \* 43758.5);  
float h110 = frac(sin(dot(q + float3(1, 1, 0), float3(127.1, 311.7, 74.7))) \* 43758.5);  
float h001 = frac(sin(dot(q + float3(0, 0, 1), float3(127.1, 311.7, 74.7))) \* 43758.5);  
float h101 = frac(sin(dot(q + float3(1, 0, 1), float3(127.1, 311.7, 74.7))) \* 43758.5);  
float h011 = frac(sin(dot(q + float3(0, 1, 1), float3(127.1, 311.7, 74.7))) \* 43758.5);  
float h111 = frac(sin(dot(q + float3(1, 1, 1), float3(127.1, 311.7, 74.7))) \* 43758.5);  
n += amp \* lerp(lerp(lerp(h000, h100, f.x), lerp(h010, h110, f.x), f.y), lerp(lerp(h001, h101, f.x), lerp(h011, h111, f.x), f.y), f.z);  
p = p \* 2.03 + 1.7;  
amp \*= 0.5;  
}  
return Ext \* edge \* edge \* saturate((n - 0.3) \* 2.5);  
‘’’

def volume\_domain():  
“”“Fog in one place: a mesh whose Volume material is voxelized into the volumetric fog, so the scene’s lights  
scatter in it (with their shadows). Density: soft-edged inside the mesh, drifting noise; no glow of its own.”“”  
m = material(‘M\_voltest\_volume’)  
m.set\_editor\_property(‘material\_domain’, unreal.MaterialDomain.MD\_VOLUME)  
m.set\_editor\_property(‘blend\_mode’, unreal.BlendMode.BLEND\_ADDITIVE)  
mel.connect\_material\_property(const3(m, (1.0, 0.91, 0.81), -300, 0), ‘’, unreal.MaterialProperty.MP\_BASE\_COLOR)  
c = mel.create\_material\_expression(m, unreal.MaterialExpressionCustom, -500, 300)  
c.set\_editor\_property(‘code’, PATCH)  
c.set\_editor\_property(‘output\_type’, unreal.CustomMaterialOutputType.CMOT\_FLOAT1)  
inputs =   
for n in (‘WP’, ‘Obj’, ‘R’, ‘Time’, ‘Ext’):  
ci = unreal.CustomInput()  
ci.set\_editor\_property(‘input\_name’, n)  
inputs.append(ci)  
c.set\_editor\_property(‘inputs’, inputs)  
src = {‘WP’: mel.create\_material\_expression(m, unreal.MaterialExpressionWorldPosition, -900, 200),  
‘Obj’: mel.create\_material\_expression(m, unreal.MaterialExpressionObjectPositionWS, -900, 300),  
‘R’: const1(m, 50.0 \* SIZE, -900, 400),  
‘Time’: mel.create\_material\_expression(m, unreal.MaterialExpressionTime, -900, 500),  
‘Ext’: const1(m, 6.0, -900, 600)}  
for n, e in src.items():  
mel.connect\_material\_expressions(e, ‘’, c, n)  
# (a Volume material takes its extinction on the Subsurface Color pin, not Opacity)  
mel.connect\_material\_property(c, ‘’, unreal.MaterialProperty.MP\_SUBSURFACE\_COLOR)  
mel.recompile\_material(m)  
eal.save\_loaded\_asset(m)  
return m

RAY = ‘’’  
float3 rd = normalize(WP - Cam);  
float3 ro = Cam - C;  
float3 inv = 1.0 / rd;  
float3 a = (-H - ro) \* inv, b = (H - ro) \* inv;  
float3 lo = min(a, b), hi = max(a, b);  
float t0 = max(max(max(lo.x, lo.y), lo.z), 0.0);  
float t1 = min(min(hi.x, hi.y), hi.z);  
float toSurface = Depth / max(dot(rd, ResolvedView.ViewForward), 0.001);  
t1 = min(t1, toSurface);  
if (t1 \<= t0) return float4(0, 4, 0, 0.5); // (debug: green where the ray misses)  
const int N = 24;  
float dt = (t1 - t0) / N;  
float T = 1.0;  
float3 glow = 0;  
for (int i = 0; i \< N; i++) {  
float3 p = ro + rd \* (t0 + dt \* (i + 0.5));  
float fall = saturate(1.0 - length(p) / H);  
float w = sin(p.x \* 0.021 + 1.0) \* sin(p.y \* 0.017 + 2.0) \* sin(p.z \* 0.023)  
+ 0.5 \* sin(p.x \* 0.053 + p.z \* 0.02) \* sin(p.y \* 0.047 + 4.0) \* sin(p.z \* 0.061 + 1.0);  
float d = Dens \* fall \* fall \* saturate(0.6 + w);  
float aa = 1.0 - exp(-d \* dt);  
glow += T \* aa \* Col \* saturate(0.35 + 0.65 \* (p.z + H) / (2.0 \* H)); // lit from above  
T \*= 1.0 - aa;  
}  
return float4(glow, 1.0 - T);  
‘’’

def raymarch():  
m = material(‘M\_voltest\_ray’)  
m.set\_editor\_property(‘blend\_mode’, unreal.BlendMode.BLEND\_TRANSLUCENT)  
m.set\_editor\_property(‘shading\_model’, unreal.MaterialShadingModel.MSM\_UNLIT)  
m.set\_editor\_property(‘disable\_depth\_test’, True)  
c = mel.create\_material\_expression(m, unreal.MaterialExpressionCustom, -500, 0)  
c.set\_editor\_property(‘code’, RAY)  
c.set\_editor\_property(‘output\_type’, unreal.CustomMaterialOutputType.CMOT\_FLOAT4)  
names = [‘WP’, ‘Cam’, ‘Depth’, ‘C’, ‘H’, ‘Dens’, ‘Col’]  
inputs =   
for n in names:  
ci = unreal.CustomInput()  
ci.set\_editor\_property(‘input\_name’, n)  
inputs.append(ci)  
c.set\_editor\_property(‘inputs’, inputs)  
src = {‘WP’: mel.create\_material\_expression(m, unreal.MaterialExpressionWorldPosition, -900, 0),  
‘Cam’: mel.create\_material\_expression(m, unreal.MaterialExpressionCameraPositionWS, -900, 100),  
‘Depth’: mel.create\_material\_expression(m, unreal.MaterialExpressionSceneDepth, -900, 200),  
‘C’: const3(m, (X, YS[‘ray’], Z), -900, 300),  
‘H’: const1(m, 50.0 \* SIZE, -900, 400),  
‘Dens’: const1(m, 0.02, -900, 500),  
‘Col’: const3(m, (4.0, 3.2, 2.4), -900, 600)}  
for n, e in src.items():  
mel.connect\_material\_expressions(e, ‘’, c, n)  
rgb = mel.create\_material\_expression(m, unreal.MaterialExpressionComponentMask, -200, 0)  
for k, v in zip(‘rgba’, (True, True, True, False)):  
rgb.set\_editor\_property(k, v)  
al = mel.create\_material\_expression(m, unreal.MaterialExpressionComponentMask, -200, 150)  
for k, v in zip(‘rgba’, (False, False, False, True)):  
al.set\_editor\_property(k, v)  
mel.connect\_material\_expressions(c, ‘’, rgb, ‘’)  
mel.connect\_material\_expressions(c, ‘’, al, ‘’)  
mel.connect\_material\_property(rgb, ‘’, unreal.MaterialProperty.MP\_EMISSIVE\_COLOR)  
mel.connect\_material\_property(al, ‘’, unreal.MaterialProperty.MP\_OPACITY)  
mel.recompile\_material(m)  
eal.save\_loaded\_asset(m)  
return m

def box(loc, scale, mat=None):  
a = eas.spawn\_actor\_from\_class(unreal.StaticMeshActor, unreal.Vector(\*loc))  
a.static\_mesh\_component.set\_static\_mesh(CUBE)  
if mat not in (None, M\_GREY):  
a.static\_mesh\_component.set\_cast\_shadow(False)  
a.set\_actor\_scale3d(unreal.Vector(\*scale))  
if mat:  
a.static\_mesh\_component.set\_material(0, mat)  
return a

M\_VOL, M\_RAY = volume\_domain(), raymarch()  
M\_GREY = material(‘M\_voltest\_grey’)  
mel.connect\_material\_property(const3(M\_GREY, (0.15, 0.15, 0.15), -300, 0), ‘’, unreal.MaterialProperty.MP\_BASE\_COLOR)  
mel.recompile\_material(M\_GREY)  
eal.save\_loaded\_asset(M\_GREY)

if eal.does\_asset\_exist(LEVEL): # (a loaded level can’t be replaced: clear it instead)  
les.load\_level(LEVEL)  
for old in eas.get\_all\_level\_actors():  
eas.destroy\_actor(old)  
else:  
les.new\_level(LEVEL)  
box((0, 0, -5), (40, 40, 0.1), M\_GREY)  
box((1000, 0, 400), (0.1, 40, 10), M\_GREY)  
w = eas.spawn\_actor\_from\_class(unreal.RectLight, unreal.Vector(400, 0, 300), unreal.Rotator(0, 0, 0))  
w.rect\_light\_component.set\_editor\_property(‘intensity’, 40.0)  
w.rect\_light\_component.set\_editor\_property(‘source\_width’, 3000.0)  
for key, y in YS.items():  
s = eas.spawn\_actor\_from\_class(unreal.SpotLight, unreal.Vector(X, y, 700), unreal.Rotator(0, -90, 0))  
lc = s.spot\_light\_component  
lc.set\_editor\_property(‘intensity\_units’, unreal.LightUnits.CANDELAS)  
lc.set\_editor\_property(‘intensity’, 8000.0)  
lc.set\_editor\_property(‘attenuation\_radius’, 1500.0)  
lc.set\_editor\_property(‘outer\_cone\_angle’, 22.0)  
lc.set\_editor\_property(‘inner\_cone\_angle’, 12.0)  
lc.set\_editor\_property(‘volumetric\_scattering\_intensity’, 4.0)  
lc.set\_editor\_property(‘mobility’, unreal.ComponentMobility.MOVABLE)

fog = eas.spawn\_actor\_from\_class(unreal.ExponentialHeightFog, unreal.Vector(0, 0, 0))  
fc = fog.component  
fc.set\_editor\_property(‘fog\_density’, 0.05)  
fc.set\_editor\_property(‘fog\_height\_falloff’, 0.001)  
fc.set\_editor\_property(‘fog\_inscattering\_luminance’, unreal.LinearColor(0, 0, 0, 1))  
fc.set\_editor\_property(‘enable\_volumetric\_fog’, True)  
fc.set\_editor\_property(‘volumetric\_fog\_distance’, 6000.0)

pp = eas.spawn\_actor\_from\_class(unreal.PostProcessVolume, unreal.Vector(0, 0, 0))  
pp.set\_editor\_property(‘unbound’, True)  
st = pp.settings  
st.set\_editor\_property(‘override\_auto\_exposure\_method’, True)  
st.set\_editor\_property(‘auto\_exposure\_method’, unreal.AutoExposureMethod.AEM\_MANUAL)  
st.set\_editor\_property(‘override\_auto\_exposure\_apply\_physical\_camera\_exposure’, True)  
st.set\_editor\_property(‘auto\_exposure\_apply\_physical\_camera\_exposure’, False)  
st.set\_editor\_property(‘override\_auto\_exposure\_bias’, True)  
st.set\_editor\_property(‘auto\_exposure\_bias’, -6.0)  
pp.set\_editor\_property(‘settings’, st)

# 1 Local Fog Volume

# (rotated a little on every axis: an unrotated volume’s packed rotation reads back as denormal floats, which Apple

# GPUs flush to zero, and the volume draws nothing)

lf = eas.spawn\_actor\_from\_class(unreal.LocalFogVolume, unreal.Vector(X, YS[‘lfv’], Z), unreal.Rotator(roll=11.0, pitch=7.0, yaw=37.0))  
lf.set\_actor\_scale3d(unreal.Vector(0.6, 0.6, 0.6)) # (its base size is 1000 cm across)  
lfc = lf.get\_component\_by\_class(unreal.LocalFogVolumeComponent)  
lfc.set\_editor\_property(‘radial\_fog\_extinction’, 2.0)  
lfc.set\_editor\_property(‘fog\_albedo’, unreal.LinearColor(1.0, 0.9, 0.8, 1.0))  
lfc.set\_editor\_property(‘height\_fog\_extinction’, 0.0)  
lfc.set\_editor\_property(‘fog\_emissive’, unreal.LinearColor(4.0, 0.6, 0.3, 1.0))  
print(‘LFV mobility’, lfc.get\_editor\_property(‘mobility’), ‘visible’, lfc.is\_visible())

# 2 a mesh with a Volume domain material

box((X, YS[‘vol’], Z), (SIZE, SIZE, SIZE), M\_VOL)

# 3 a box raymarching its own fog

box((X, YS[‘ray’], Z), (SIZE, SIZE, SIZE), M\_RAY)

cam = eas.spawn\_actor\_from\_class(unreal.CineCameraActor, unreal.Vector(-1000, 0, 260), unreal.Rotator(0, -3, 0))  
cam.get\_cine\_camera\_component().set\_editor\_property(‘current\_focal\_length’, 18.0)

# the same view for a plain game run (no Movie Render Queue): the default pawn spawns here

eas.spawn\_actor\_from\_class(unreal.PlayerStart, unreal.Vector(-1000, 0, 200), unreal.Rotator(0, 0, 0))  
les.save\_current\_level()

path = ‘/Game/seq\_voltest’  
fresh(path)  
seq = at.create\_asset(‘seq\_voltest’, ‘/Game’, unreal.LevelSequence, unreal.LevelSequenceFactoryNew())  
seq.set\_display\_rate(unreal.FrameRate(24, 1))  
seq.set\_playback\_start(0)  
seq.set\_playback\_end(3)  
b = seq.add\_possessable(cam)  
cuts = seq.add\_track(unreal.MovieSceneCameraCutTrack)  
cs = cuts.add\_section()  
cs.set\_range(0, 3)  
bid = unreal.MovieSceneObjectBindingID()  
bid.set\_editor\_property(‘guid’, b.get\_id())  
cs.set\_camera\_binding\_id(bid)  
eal.save\_loaded\_asset(seq)

def config(name, cvars):  
p = ‘/Game/mrq/voltest\_’ + name  
fresh(p)  
cfg = at.create\_asset(‘voltest\_’ + name, ‘/Game/mrq’, unreal.MoviePipelinePrimaryConfig,  
unreal.MoviePipelinePrimaryConfigFactory())  
out = cfg.find\_or\_add\_setting\_by\_class(unreal.MoviePipelineOutputSetting)  
out.output\_directory = unreal.DirectoryPath(OUT)  
out.file\_name\_format = name + ‘\_{frame\_number}’  
out.output\_resolution = unreal.IntPoint(1280, 720)  
out.override\_existing\_output = True  
cfg.find\_or\_add\_setting\_by\_class(unreal.MoviePipelineDeferredPassBase)  
cfg.find\_or\_add\_setting\_by\_class(unreal.MoviePipelineImageSequenceOutput\_JPG)  
aa = cfg.find\_or\_add\_setting\_by\_class(unreal.MoviePipelineAntiAliasingSetting)  
aa.override\_anti\_aliasing = True  
aa.anti\_aliasing\_method = unreal.AntiAliasingMethod.AAM\_TSR  
aa.engine\_warm\_up\_count = 24  
aa.render\_warm\_up\_count = 24  
aa.use\_camera\_cut\_for\_warm\_up = False  
cv = cfg.find\_or\_add\_setting\_by\_class(unreal.MoviePipelineConsoleVariableSetting)  
for k, v in cvars:  
cv.add\_or\_update\_console\_variable(k, v)  
eal.save\_loaded\_asset(cfg)

config(‘base’, ())  
config(‘debug’, ((‘r.LocalFogVolume.TileDebug’, 2),))  
config(‘novox’, ((‘r.LocalFogVolume.RenderIntoVolumetricFog’, 0),))  
config(‘clamp’, ((‘r.LocalFogVolume.MaxDensityIntoVolumetricFog’, 1.0),))  
config(‘hfog’, ((‘r.LocalFogVolume.RenderDuringHeightFogPass’, 1),))  
config(‘nohzb’, ((‘r.LocalFogVolume.UseHZB’, 0), (‘r.LocalFogVolume.TileCullingUseAsync’, 0)))  
config(‘near’, ((‘r.LocalFogVolume.GlobalStartDistance’, 10.0), (‘r.LocalFogVolume.RenderIntoVolumetricFog’, 0)))  
config(‘novf’, ((‘r.VolumetricFog’, 0),))  
config(‘debugnovf’, ((‘r.VolumetricFog’, 0), (‘r.LocalFogVolume.TileDebug’, 2)))  
print(‘BUILT voltest’)