;------------------------------------------------------------------------------------------------------
; Logging options.
; Comment line or set value to 0 for no logging.
;------------------------------------------------------------------------------------------------------
[Logging]

; Log all API usage
calls=0

; Log Input key actions
input=0

; Super verbose massive log
debug=0

; Unbuffered logging to avoid missing anything at file end
unbuffered=0

; Force the CPU affinity to use only a single CPU for debugging multi-threaded
force_cpu_affinity=0

; Log NVAPI convergence modifications
convergence=0
; Log NVAPI separation modifications
separation=0


; ------------------------------------------------------------------------------------------------------
; Default constants to pass directly to shaders as IniParams
; ------------------------------------------------------------------------------------------------------
[Constants]
; Static HUD depth:
x = 0.6
; x2 is the HUD adjustment mode.
; 0 = Use the static depth in x
; 1 = everything to crosshair depth (recommended for gameplay)
; 2 = try to keep HUD closer than anything else within reason (better for subtitles)
; See KeySwitchHUDMode below.
x2 = 1
; y2 is the minimum allowable absolute depth when using HUD mode 2
y2 = 0.45

; No longer using these - filtering them is possible, but tricky to do without
; breaking certain menus:
; ; Minimap depth:
; y = 0.7
; ; Goals depth & shift:
; z = 0.9
; ; Subtitle depth:
; w = 0.69

[KeySwitchHUDMode]
Key = `
x2 = 2
type = toggle

;------------------------------------------------------------------------------------------------------
; Custom settings override for any of [convergence, separation, x, y, z, w]
;
; Four types are supported - by default the bindings will simply load the
; configured settings, but type=hold can be specified to have a preset
; active while the button is held, type=toggle can be used to make a simple
; on/off toggle, and type=cycle can be used to cycle between several presets.
;
; Delays (type=hold only) and linear or cosine trasition periods (any key type)
; can be used to better synchonrise setting changes to the game's animations,
; or to smoothly adjust UI elements over a short period of time.
;
; Key bindings: For A-Z and 0-9 on the number row, just use that single
; character. For everything else (including mouse buttons), use the virtual key
; name (with or without the VK_ prefix) or hex code from this article:
; http://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx
;
; Keys can also be from XBox controllers using:
;   XB_LEFT_TRIGGER, XB_RIGHT_TRIGGER,
;   XB_LEFT_SHOULDER, XB_RIGHT_SHOULDER,
;   XB_LEFT_THUMB, XB_RIGHT_THUMB,
;   XB_DPAD_UP, XB_DPAD_DOWN, XB_DPAD_LEFT, XB_DPAD_RIGHT,
;   XB_A, XB_B, XB_X, XB_Y, XB_START, XB_BACK, XB_GUIDE
; By default all attached controllers are used - to associate a binding with a
; specific controller add the controller number 1-4 to the prefix, like
; XB2_LEFT_TRIGGER, though this may be more useful for hunting than playing.
;------------------------------------------------------------------------------------------------------

; Example for changing default settings
;[Key1]
;Key = z
;separation = 100.0
;convergence = 4.0
;x = 0.98

; Example to support momentary hold type overrides, like aiming.
;[Key2]
;Key = RBUTTON
;convergence = 0.1
;type = hold

; Example for a toggle override.
;[Key3]
;Key = q
;separation = 0.1
;type = toggle
;y = 0.0

; Example for a momentary hold, but with a delay followed by a smooth
; transition (ms) on hold and release to sync better with the game. Note that
; delay only works with type=hold (for now), while transitions will work with
; all types.
;[Key4]
;Key = XB_LEFT_TRIGGER
;type = hold
;y = 0.25
;delay = 100
;transition = 100
;transition_type = linear
;release_delay = 0
;release_transition = 500
;release_transition_type = cosine

; Example of a cycle transition that might be used to provide several presets
; that set both convergence and UI depth to suit different scenes in a game.
; Cosine transitions are used to smooth the changes over 1/10 of a second.
;[Key5]
;Key = Q
;type = cycle
;convergence = 1.45, 1.13, 0.98
;z           = 0.25,  0.5, 0.75
;transition = 100
;transition_type = cosine

[KeyConvergenceCycle]
key = \
convergence = 0.5, 1.6
type = cycle

; ; HOLD the owl key for 1.4 seconds to activate high convergence
; [KeyOwlConvergence]
; key = z
; convergence = 1.6
; delay = 1400
; transition = 300
; transition_type = cosine
;
; ; TAP the owl key to return to recommended convergence
; [KeyOwlConvergenceLeave]
; key = z
; convergence = 0.5
; transition = 100
; transition_type = cosine

;------------------------------------------------------------------------------------------------------
; Shader hunting options.
; Default setup is to use keyboard similar to Helix presets
;------------------------------------------------------------------------------------------------------
[Hunting]

; 0: Release mode is with shader hunting disabled, optimized for speed.
; 1: Hunting mode enabled
; 2: Hunting mode "soft disabled" - can be turned on via the toggle_hunting key
hunting=0

; Highlight mode of currently selected shader / rendertarget.
; "skip" = skip shader. don't render anything using the currently selected shader.
; "original" = fall back to original shader if the currently selected shader was patched.
; "pink" = make the output hot pink to make it standout.
; "mono" = disable stereo for the selected shader / rendertarget.
; "zero" = shader output is all zero. NOTE: this has a big performance impact.
marking_mode=skip

; Key bindings: For A-Z and 0-9 on the number row, just use that single
; character. For everything else (including mouse buttons), use the virtual key
; name (with or without the VK_ prefix) or hex code from this article:
; http://msdn.microsoft.com/en-us/library/windows/desktop/dd375731(v=vs.85).aspx
;
; XBox controllers are supported using the same bindings as the [Key] sections
; (see above). If the game already uses the first controller you might try
; using the second controller for hunting with e.g. XB2_LEFT_SHOULDER

; rotate through all VISIBLE pixel shaders at the current scene.
previous_pixelshader=VK_NUMPAD1
next_pixelshader=VK_NUMPAD2
mark_pixelshader=VK_NUMPAD3

; rotate through all VISIBLE vertex shaders at the current scene.
previous_vertexshader=VK_NUMPAD4
next_vertexshader=VK_NUMPAD5
mark_vertexshader=VK_NUMPAD6

; rotate through all USED index buffers at the current scene.
previous_indexbuffer=VK_NUMPAD7
next_indexbuffer=VK_NUMPAD8
mark_indexbuffer=VK_NUMPAD9

; rotate through all USED render targets at the current scene.
previous_rendertarget=VK_DIVIDE
next_rendertarget=VK_MULTIPLY
mark_rendertarget=VK_SUBTRACT

; rotate through all VISIBLE geometry shaders at the current scene.
; This is disabled since these keys are commonly pressed while alt+tabbed out
;previous_geometryshader = <
;next_geometryshader = >
;mark_geometryshader = /

; rotate through all VISIBLE domain shaders at the current scene.
; This is disabled since these keys are commonly pressed while alt+tabbed out
;previous_domainshader = [
;next_domainshader = ]
;mark_domainshader = \

; rotate through all VISIBLE hull shaders at the current scene.
; This is disabled only because it is rarely needed
;previous_hullshader = MINUS
;next_hullshader = EQUALS
;mark_hullshader = BACKSPACE

; rotate through all USED compute shaders at the current scene.
; Disabling compute shaders may cause crashes, so these are
; not enabled by default:
;previous_computeshader = PAGE_UP
;next_computeshader = PAGE_DOWN
;mark_computeshader = HOME

; Re-enable shaders once done with hunting:
done_hunting=VK_ADD

; Screenshot as pns
take_screenshot=VK_SNAPSHOT

; reload all fixes from ShaderFixes folder
reload_fixes=VK_F10

; Key to turn hunting itself on/off.  This will also show/hide overlay.
; Hunting must be set to either 1 or 2 to enable this toggle.
toggle_hunting=VK_NUMPAD0

; Key to reload the settings from the the d3dx.ini without restarting. This can
; be the same key as reload_fixes for convenience, or a different key may be
; used to avoid resetting the ini parameters every time the shaders are
; reloaded. Note that not all settings can be reloaded, so if something doesn't
; work as expected you may still have to restart the game:
reload_config=VK_F10

; Hold this key to temporarily disable the fix - useful to quickly check what
; an effect looked like in the original game.
show_original=VK_F9

; tunable parameter to use in modified shaders as variable (StereoParams.Load(int3(1,0,0)).xyzw)
; enabling tuning results in a small performance hit because the parameter texture
;tune_enable=1
;tune_step=0.1
;tune1_up=VK_INSERT
;tune1_down=VK_DELETE
;tune2_up=X
;tune2_down=Z

; Auto-repeat key rate in events per second.
repeat_rate=8

; Dumps out the contents of each render target after every immediate draw call
; for the next frame. Takes up a large amount of space, so disabled by default.
;analyse_frame=VK_F8

; Specifies options for the frame analysis feature. Options can be combined by
; separating them with a space.
;          log: Log draw calls and state changes (one log file per context)
;         hold: Continue analysing subsequent frames while the key is held
;  dump_rt_jps: Dumps out render targets as JPS files. These are the easiest to
;               work with and don't take up as much space as DDS files, but they
;               are not dumped for every render target and are missing some data.
;  dump_rt_dds: Dumps out render targets as DDS files. WARNING: This option may
;               require hundreds of gigabytes and a long time! Only use it if
;               you absolutely need more information than you can get otherwise.
;               Will also dump buffer type render targets & UAVs as .buf files.
;      dump_rt: Dumps render targets as JPS files when possible, or DDS when not.
;     clear_rt: Clears each render target the first time they are used in the
;               frame. Makes it easier to see what is being drawn if the game
;               doesn't clear them, but might cause some effects not to render.
;   dump_depth: Dumps depth/stencil targets as DDS files
; dump_tex_jps: Dumps textures as JPS files
; dump_tex_dds: Dumps textures as DDS files (Same warning as for dump_rt_dds)
;               Will also dump buffer type shader resource views as .buf files.
;     dump_tex: Dumps textures as JPS files when possible, or DDS when not.
;      dump_cb: Dumps constant buffers as binary .buf files
;  dump_cb_txt: Decodes constant buffers as an array of float4s
;      dump_vb: Dumps vertex buffers as binary .buf files
;  dump_vb_txt: Decodes vertex buffers as an array of float4s
;      dump_ib: Dumps index buffers as binary .buf files
;  dump_ib_txt: Decodes index buffers
; filename_reg: Normally the draw number is the first part of the filename so
;               that the files will be sorted in the order they were used in
;               the game. Sometimes it is more desirable to examine how a
;               specific output changed through the frame and this option will
;               place the register number first in the filename to allow that.
;         mono: Dump out mono textures instead of stereo. To dump both, specify
;               'mono stereo'. If neither are specified, defaults to stereo.
; analyse_options can also be specified in [ShaderOverride*] and
; [TextureOverride*] sections to set up triggers to change the options mid-way
; through a frame analysis, either for a single draw call (default), or
; permanently (by adding the 'persist' keyword).
analyse_options = log

[ShaderOverrideFrameAnalysisStopEarly]
; Scenery drawn in reflections starts. Some compute shaders before this which
; may be of interest
hash = eb56a0463908e8e4
[ShaderOverrideFrameAnalysisStart]
; Post processing starts (AO depth?)
hash = 26ef38ff93ebaa31
;analyse_options = dump_rt persist log
[ShaderOverrideSkip1]
hash = bbf6f37a40ef6abb
analyse_options = log
[ShaderOverrideSkip2]
hash = 628ab751d942c016
analyse_options = log

;------------------------------------------------------------------------------------------------------
; Chain load other wrapper DLLs instead of system DLLs.
;------------------------------------------------------------------------------------------------------
[System]

;proxy_d3d9=d3d9_helix.dll
;proxy_d3d11=d3d11_helix.dll

; Options to use hooking instead of wrapping. Used in MGSV. Possible objects to hook include:
;   deferred_contexts
;   immediate_context
;   device
;   all - all of the above
; crash/hang workarounds:
;   except_set_shader_resources - work around crash on Win 7 with evil update
;   except_set_samplers - work around crash on Win 10
;   except_set_rasterizer_state - work around crash on Win 7 without evil update
;   skip_dxgi_factory - hack for MGSV, not recommended for other games as it
;                       may disable core 3DMigoto functionality in some cases
;   recommended - hook supported objects, safe workarounds enabled, skips not enabled
;hook=recommended

;------------------------------------------------------------------------------------------------------
; Settings to force display device to a specific mode.
; Uncomment a value to force the specific setting.
;------------------------------------------------------------------------------------------------------
[Device]

; overrides screen resolution.
;width=1280
;height=720

; overrides refresh rate set by game.
;refresh_rate=60

; filters available video modes to those providing given refresh rates.
; some games don't explicitely set the refresh rate, but use the video mode.
; use this if setting refresh_rate doesn't work.
;filter_refresh_rate=24,59,60

; full_screen=1 forces creation of full screen devices and swap chains.
; use this for 3dtvplay if game won't active stereo mode.
; full_screen=2 will also disable SetWindowPos which might help in some games.
;full_screen=1

; This toggles forcing the full screen mode on and off. It will not take effect
; immediately, but will change what happens the next time the game tries to
; change the fullscreen mode. This is a specific hack to workaround a bug in
; Unity games, which crash when alt+tabbing out from exclusive mode fullscreen.
;
; To switch out of a Unity game without it crashing:
; Enable this option, Press F7, Alt+Enter, Alt+Tab
;toggle_full_screen = VK_F7

; some games explicitely disable stereo, prohibiting any stereo attempts.
; settings this to 1 ignores all stereo disabling calls and also calls NvAPI_Stereo_Enable to force stereo on.
;force_stereo=1

; almost all DX11 games deactivate window message handling.
; setting this to 1 reenables print screen handling, alt-tab key handling etc.
;allow_windowcommands=1

; Indicates where the resolution is obtained for texture hashes. Comment this
; out to never special case hashes that match the resolution or a multiple.
; Possible values are swap_chain and depth_stencil. Recommended to test which
; works for a given game (e.g. CryEngine always creates a swap chain that
; matches the native resolution so has to use depth_stencil).
get_resolution_from = swap_chain


;------------------------------------------------------------------------------------------------------
; Settings for NVidia stereo driver.
;------------------------------------------------------------------------------------------------------
[Stereo]

; games which have their own stereo renderer disable the NVidia automatic
; stereo mode and render themselves into stereo buffers (Crysis 3 for example).
; Setting this to 1 disables the game stereo renderer and enables NVidia auto stereo mechanism.
; This also forces 'false' as a return for any request for NvAPI_Stereo_IsEnabled.
automatic_mode=0

; Some games (CryEngine games, for example) lock the separation to a specific
; value, which can be undesirable. Set this to 1 to ignore these requests from
; the game to unlock the separation:
unlock_separation=0

; games without predefined profiles can't save stereo settings.
; enabling this options automatically creates a profile for unknown games.
create_profile=0

; sets the global surface creation heuristic for NVidia stero driver.
; 0 = NVAPI_STEREO_SURFACECREATEMODE_AUTO - use driver registry profile settings for surface creation mode.
; 1 = NVAPI_STEREO_SURFACECREATEMODE_FORCESTEREO - Always create stereo surfaces.
; 2 = NVAPI_STEREO_SURFACECREATEMODE_FORCEMONO - Always create mono surfaces.
;surface_createmode=1

; overrides surface creation mode for square surfaces.
;surface_square_createmode=1

; Force the NvAPI_Initialize to return an error so that games think stereo and NVidia is unavailable.
force_no_nvapi=0


;------------------------------------------------------------------------------------------------------
; Settings for GPU manipulations.
; Render settings override
;------------------------------------------------------------------------------------------------------
[Rendering]

; GPU program manipulations.
;
; Shaders in game will be replaced by these custom shaders.
override_directory=ShaderFixes

; Automatically patched shaders will be written here if caching is enabled.
cache_directory=ShaderCache

; Shaders that are directly compiled by the game, instead of binary, go here.
storage_directory=ShaderFromGame

; cache all compiled .txt shaders into .bin. this removes loading stalls.
cache_shaders=1

; thread save data structure access. required on multithreaded rendering.
use_criticalsection=1

; Setting this option disables scissor limits
rasterizer_disable_scissor=1

; Tracks copies and updates to textures which may cause their hash to become
; out of sync with their contents - enable if texture hashes seem unreliable:
;track_texture_updates=1

; Registers where the StereoParams and IniParams textures will be assigned -
; change if the game already uses these registers. Newly decompiled shaders
; will use the new registers, but existing shaders will not be updated - best
; workflow is to remove ShaderCache after changing these and run a search and
; replace on all shaders in ShaderFixes. Set to -1 to disable if not required.
stereo_params = 125
ini_params = 120

;------------------------------------------------------------------------------------------------------
; Analyzation options.
;
; save all autofixed shaders as HLSL
export_fixed=0

; save all shaders sent to DX11 as ASM, or as HLSL text files if compiled by game.
export_shaders=0

export_binary=0

; save all shaders seen as HLSL code, autofixed or not. 1= HLSL only, 2=HLSL+OriginalASM, 3=HLSL+OriginalASM+RecompiledASM
export_hlsl=0

; stores a ShaderUsage.txt file on any marking button press.
dump_usage=0

;------------------------------------------------------------------------------------------------------
; Automatic shader fixes. Those settings here apply only on newly read shaders.
; All existing *_replace.txt or *_replace.bin files are not tampered with.
; If you change settings here, the best workflow is to delete all shaders in
; the shader cache directory and let them be fixed again.

; Stereoize all shader parameters with position semantic.
fix_sv_position=0

; Pixel depth evaluation.
;fix_ZRepair_DepthTexture1=SceneDepthTexture.x
;fix_ZRepair_Dependencies1=MinZ_MaxZRatio
;fix_ZRepair_ZPosCalc1=zTex * MinZ_MaxZRatio.z - MinZ_MaxZRatio.w
;fix_ZRepair_DepthTexture2=SceneDepthTexture.x
;fix_ZRepair_Dependencies2=
;fix_ZRepair_ZPosCalc2=zTex
;fix_ZRepair_PositionTexture=PositionTexture
;fix_ZRepair_PositionCalc=1024 * %s

; Inject depth texture if other depth sources are unavailable.
;fix_ZRepair_DepthTextureHash=8a19f087b004598f

; Correct inverse transformations in pixel shaders using evaluated depth.
;fix_InvTransform=ScreenToLight,InverseTranslatedViewProjectionMatrix

; Back projection coordinate fix.
;
; Available variables in expressions:
; stereoParams.x = Separation value in range [0..1] or [-0..-1] dependent on active eye
; stereoParams.y = Convergence value in w coordinates (1/z)
; stereoParams.z = -1/1 for left/right eye
; stereoParams.w = Separation value without eye separation
; stereoTune.x = tune value 1 (default is 1)
; stereoTune.y = tune value 2 (default is 1)
; stereoTune.z = tune value 3 (default is 1)
; stereoTune.w = tune value 4 (default is 1)
; stereoScreenRes.x = Primary swap chain backbuffer horizontal resolution
; stereoScreenRes.y = Primary swap chain backbuffer vertical resolution
; zpos = current pixel z position in pixel shader
; wpos = current pixel w position in pixel shader

; Send inverse transformations from vertex shaders to pixel shaders.
;fix_BackProjectionTransform1=ScreenToTranslatedWorldMatrix._m00,ScreenToTranslatedWorldMatrix._m02,ScreenToTranslatedWorldMatrix._m01
;fix_BackProjectionTransform2=ScreenToWorld._m00,ScreenToWorld._m02,ScreenToWorld._m01

; Position variables to correct in pixel shaders.
;fix_ObjectPosition1=PointPositionAndInverseRadius
;fix_ObjectPosition1Multiplier=1, (stereoScreenRes.x/stereoScreenRes.y)*0.5, -0.5
;fix_ObjectPosition2=SpotPositionAndInverseRadius
;fix_ObjectPosition2Multiplier=1, (stereoScreenRes.x/stereoScreenRes.y)*0.5, -0.5

; Matrix multiplications to correct in pixel shaders.
;fix_MatrixOperand1=TranslatedWorldToShadowMatrix
;fix_MatrixOperand1Multiplier=1, (stereoScreenRes.x/stereoScreenRes.y)*0.5 - viewDirection.z*0.05 + (0.02791946-stereoParams.x/stereoParams.w), 0

; autofix shader option: recompiles all vertex shaders. fixes minor differences in deferred rendering.
;recompile_all_vs=0

;------------------------------------------------------------------------------------------------------
; Shader manipulations without patches + shader filtering.
;------------------------------------------------------------------------------------------------------
;[ShaderOverride1]
;Hash=69732c4f23cb6c48
; Custom stereo separation value while rendering objects using this shader.
;Separation=0
; Custom stereo convergence value while rendering objects using this
; shader (e.g. convergence=0 will move an object to infinity).
;Convergence=0
; don't draw anything using this shader.
;Handling=skip
; advanced option: use this to override only if this shader is used rendering the given index buffer.
;IndexBufferFilter=b3e56ebc
; Use replaced shader only when there is no active depth buffer (for UI filtering)
;depth_filter = depth_inactive
; Use replaced shader only when there *IS* an active depth buffer (for UI filtering)
;depth_filter = depth_active
; Only use replaced shader when it is used in conjunction with a specific shader
; (e.g. to adjust a vertex shader ONLY when it is used with a specific pixel shader)
;partner=af7b880f07630615
; Assignes a dummy render target to o0. Use to fix one-eye rendering issues in
; shaders that only write to a depth target:
;fake_o0=1
; Override a value from [Constants] when this shader is used:
;x=2.0
; Pass the dimensions of the active render target and resolution (obtained with
; get_resolution_from) into the shader:
;x1=rt_width
;y1=rt_height
;z1=res_width
;w1=res_height
; Use t0 from active pixel shader for texture filtering. Will be 0 if no
; [TextureOverride*] section exists for the texture or 1 if one does. For advanced
; filtering, set a value for filter_index in the [TextureOverride] section.
;x2=ps-t0
; Override the shader model to allow using newer features like Texture2DMS:
;model=vs_5_0
; There's also support for copying textures, constant buffers, depth buffers,
; etc. from one shader to another. This is a complex topic - see this page:
;    https://github.com/bo3b/3Dmigoto/wiki/Resource-Copying


;------------------------------------------------------------------------------------------------------
; texture / render target manipulations
;------------------------------------------------------------------------------------------------------
;
; NOTE: If you are trying to match a texture the same size as the resolution (or
; a /2, x2, x4 or x8 multiple), you should confirm that the same hash is used
; on different resolutions, and adjust get_resolution_from if necessary.
;
; NOTE: If you find a texture hash seems to change inconsistently, try enabling
; track_texture_updates in the [Rendering] section.
;
;[TextureOverride1]
;Hash=c3e55ebd
; NVidia stores surface creation mode heuristics in the game profile. setting
; this option overrides the creation mode for a given texture / buffer.
; 0 = NVAPI_STEREO_SURFACECREATEMODE_AUTO - use driver registry profile settings.
; 1 = NVAPI_STEREO_SURFACECREATEMODE_FORCESTEREO - create stereo surface.
; 2 = NVAPI_STEREO_SURFACECREATEMODE_FORCEMONO - create mono surface.
;StereoMode=2

;[TextureOverride2]
;Hash = e27b9d07
; Prevent the game reading from this texture - will give the game a blank
; buffer instead. Used to prevent CryEngine games falsely culling objects. Use
; debug logging and look for Map calls to identify possible hashes.
;deny_cpu_read=1
; Expand the region copied to this texture with CopySubresourceRegion (similar
; issue to rasterizer_disable_scissor). Used to solve issues with transparent
; refraction effects (like glass) in CryEngine games.
;expand_region_copy=1


;------------------------------------------------------------------------------------------------------
; Example of settings override by mouse button configuration
; Mapping of from game provided hard coded convergence values to custom values
; Those are values for L.A. Noir
; Example of settings override by mouse button configuration
;------------------------------------------------------------------------------------------------------
;[ConvergenceMap]

;Map1=from 3e99999a to 0.3
;Map2=from 3f800000 to 1.0
;Map3=from 3f666666 to 0.9


;;;;;;;;;;;;;;;;;;;;;; CROSSHAIR ;;;;;;;;;;;;;;;;;;;
[ResourceDepthBuffer]
max_copies_per_frame = 1
[ResourceCViewportShaderParameterProvider]
max_copies_per_frame = 1

; Depth buffer from environmental shadow shaders. Not always available. Scaling:
; CameraDistances.z / (DepthScale.y * z + DepthScale.x);
; NOTE: recreates cached resource fairly often
;[ShaderOverrideDirectionalLightingLowMediumHigh]
;hash = faba7cafc597dea0
;ResourceDepthBuffer = stereo2mono ps-t0
;ResourceCViewportShaderParameterProvider = ps-cb0
;[ShaderOverrideDirectionalLightingVeryHighUltra]
;hash = 7afaca8dbc8230a4
;ResourceDepthBuffer = stereo2mono ps-t0
;ResourceCViewportShaderParameterProvider = ps-cb0

; Depth buffer from ambient lighting shaders. Scaling:
; abs(z) * CameraDistances.z
; NOTE: recreates cached resource fairly often
[ShaderOverrideAmbientHigh]
hash = 1201619760848612
ResourceDepthBuffer = stereo2mono ps-t8
ResourceCViewportShaderParameterProvider = ps-cb0
[ShaderOverrideAmbientNormalUnconfirmed]
hash = 551a826bfb659595
ResourceDepthBuffer = stereo2mono ps-t6
ResourceCViewportShaderParameterProvider = ps-cb0
[ShaderOverrideAmbientNormal]
hash = c146fc4db7b97968
ResourceDepthBuffer = stereo2mono ps-t6
ResourceCViewportShaderParameterProvider = ps-cb0
[ShaderOverrideAmbientHighUnconfirmed]
hash = ff8ee214288e8819
ResourceDepthBuffer = stereo2mono ps-t8
ResourceCViewportShaderParameterProvider = ps-cb0

[ShaderOverrideCrosshair]
hash = 293a88152f047549
vs-t110 = ResourceDepthBuffer
vs-cb13 = ResourceCViewportShaderParameterProvider
post vs-t110 = null
y1 = ps-t0
analyse_options = mono dump_rt dump_tex dump_vb_txt persist log

[ShaderOverrideHUDTextMap]
hash = e805c8ef7d4c2097
vs-t110 = ResourceDepthBuffer
post vs-t110 = null
y1 = 0
vs-cb13 = ResourceCViewportShaderParameterProvider

[ShaderOverrideHUDMiniMap]
hash = 6a8b6667694bb2d4
vs-t110 = ResourceDepthBuffer
post vs-t110 = null
y1 = 0
vs-cb13 = ResourceCViewportShaderParameterProvider

[ShaderOverrideHUDButtonOutline]
hash = 26af5384eadf8d32
vs-t110 = ResourceDepthBuffer
post vs-t110 = null
y1 = 0
vs-cb13 = ResourceCViewportShaderParameterProvider
[ShaderOverrideHUDMiniMapAreaOfInterest]
hash = 586422f566a51a35
vs-t110 = ResourceDepthBuffer
post vs-t110 = null
y1 = 0
vs-cb13 = ResourceCViewportShaderParameterProvider
[ShaderOverrideHUDProgressCircle]
hash = b9ab5928fe75919c
vs-t110 = ResourceDepthBuffer
post vs-t110 = null
y1 = 0
vs-cb13 = ResourceCViewportShaderParameterProvider
[ShaderOverrideMap]
hash = e1f07e1800d139ab
vs-t110 = ResourceDepthBuffer
post vs-t110 = null
y1 = 0
vs-cb13 = ResourceCViewportShaderParameterProvider

[ShaderOverrideAfterMiniMap]
; This pixel shader does the subtitle backgrounds & other things. It is first
; used after the mini-map has been drawn, so use it as a way to separate the
; two out since they can overlap.
hash = d89a217a97ce3608
x1 = 1
y1 = 0

[ShaderOverrideBinkVideo]
hash = 3d6857f2adbcb1fb
; Disable all HUD adjustments while videos are playing so that subtitles are
; aligned:
z1 = 2

[ShaderOverrideMenuBackground]
hash = 8c392c17c521bdd6
z1 = 1

[TextureOverrideCrosshairPoint]
hash = e3cda42b
filter_index = 2

[TextureOverrideTopLeftGoalsBackground]
hash = 6dd4140c
filter_index = 3

;;;;;;;;;;;;;;; REFLECTION ;;;;;;;;;;;;;;;;;;;
[TextureOverrideReflectionLowMedHighRGB]
; <Register orig_hash=3b1a8d48 type=Texture2D Width=512 Height=512 MipLevels=6 ArraySize=1 RawFormat=9 Format="R16G16B16A16_TYPELESS" SampleDesc.Count=1 SampleDesc.Quality=0 Usage=0 BindFlags=0x28 CPUAccessFlags=0x0 MiscFlags=0x0></Register>
hash = 3b1a8d48
StereoMode = 1
[TextureOverrideReflectionLowMedHighDepth]
; <DepthTarget orig_hash=b05c0230 type=Texture2D Width=512 Height=512 MipLevels=1 ArraySize=1 RawFormat=19 Format="R32G8X24_TYPELESS" SampleDesc.Count=1 SampleDesc.Quality=0 Usage=0 BindFlags=0x48 CPUAccessFlags=0x0 MiscFlags=0x0></DepthTarget>
hash = b05c0230
StereoMode = 1
[TextureOverrideReflectionVeryHighRGB]
; <RenderTarget orig_hash=9af0e839 type=Texture2D Width=1024 Height=1024 MipLevels=6 ArraySize=1 RawFormat=9 Format="R16G16B16A16_TYPELESS" SampleDesc.Count=1 SampleDesc.Quality=0 Usage=0 BindFlags=0x28 CPUAccessFlags=0x0 MiscFlags=0x0></RenderTarget>
hash = 9af0e839
StereoMode = 1
[TextureOverrideReflectionVeryHighDepth]
; <DepthTarget orig_hash=11b66741 type=Texture2D Width=1024 Height=1024 MipLevels=1 ArraySize=1 RawFormat=19 Format="R32G8X24_TYPELESS" SampleDesc.Count=1 SampleDesc.Quality=0 Usage=0 BindFlags=0x48 CPUAccessFlags=0x0 MiscFlags=0x0></DepthTarget>
hash = 11b66741
StereoMode = 1

; In FC4 we had to track down every single vertex shader that draws something
; in the reflection and reverse their position, which was easy to miss them.
; Here we are using a new strategy of using the reverse stereo blit to switch
; eyes. Note that currently the reverse blit only works on the first mip-map
; level, and subsequent mip-maps are only copied for the right eye - this is a
; driver bug (and I may be able to overcome it in 3DMigoto), but for now we are
; limiting the shader to use the first mip-map level instead.
[ShaderOverrideReflection]
hash = 2b06acf00b51d62e
; The reverse stereo blit does not seem to work on mip-maps, which results in
; the right eye being too dark with this approach:
ps-t100 = stereo2mono ps-t16
; Clear after the draw call for safety:
post ps-t100 = null

[ShaderOverride_Reflection_0c1abd00e90f6697]
hash = 0c1abd00e90f6697
ps-t100 = stereo2mono ps-t17
post ps-t100 = null

[ShaderOverride_Reflection_0c950c6abb8a167d]
hash = 0c950c6abb8a167d
ps-t100 = stereo2mono ps-t15
post ps-t100 = null

[ShaderOverride_Reflection_0f1b992a63708da3]
hash = 0f1b992a63708da3
ps-t100 = stereo2mono ps-t13
post ps-t100 = null

[ShaderOverride_Reflection_1169163fcf4bfaa2]
hash = 1169163fcf4bfaa2
ps-t100 = stereo2mono ps-t15
post ps-t100 = null

[ShaderOverride_Reflection_16f7967a631d8d75]
hash = 16f7967a631d8d75
ps-t100 = stereo2mono ps-t16
post ps-t100 = null

[ShaderOverride_Reflection_19bd6d6136ebb2a5]
hash = 19bd6d6136ebb2a5
ps-t100 = stereo2mono ps-t12
post ps-t100 = null

[ShaderOverride_Reflection_1a81f8e0a3eefa3a]
hash = 1a81f8e0a3eefa3a
ps-t100 = stereo2mono ps-t12
post ps-t100 = null

[ShaderOverride_Reflection_1ef244a70dc6acdb]
hash = 1ef244a70dc6acdb
ps-t100 = stereo2mono ps-t14
post ps-t100 = null

[ShaderOverride_Reflection_205ea57660ab8d66]
hash = 205ea57660ab8d66
ps-t100 = stereo2mono ps-t13
post ps-t100 = null

[ShaderOverride_Reflection_21b8081b97502b0d]
hash = 21b8081b97502b0d
ps-t100 = stereo2mono ps-t15
post ps-t100 = null

[ShaderOverride_Reflection_21f9d710ac194ce6]
hash = 21f9d710ac194ce6
ps-t100 = stereo2mono ps-t14
post ps-t100 = null

[ShaderOverride_Reflection_2aff37e26933ddb1]
hash = 2aff37e26933ddb1
ps-t100 = stereo2mono ps-t11
post ps-t100 = null

[ShaderOverride_Reflection_2be97bb3e72e6e56]
hash = 2be97bb3e72e6e56
ps-t100 = stereo2mono ps-t11
post ps-t100 = null

[ShaderOverride_Reflection_3243df3a0b3cd058]
hash = 3243df3a0b3cd058
ps-t100 = stereo2mono ps-t17
post ps-t100 = null

[ShaderOverride_Reflection_33ecc9abc8cf2852]
hash = 33ecc9abc8cf2852
ps-t100 = stereo2mono ps-t11
post ps-t100 = null

[ShaderOverride_Reflection_3542d855e35785f4]
hash = 3542d855e35785f4
ps-t100 = stereo2mono ps-t15
post ps-t100 = null

[ShaderOverride_Reflection_3b5ddb73641f585a]
hash = 3b5ddb73641f585a
ps-t100 = stereo2mono ps-t13
post ps-t100 = null

[ShaderOverride_Reflection_3d942ceee3e70501]
hash = 3d942ceee3e70501
ps-t100 = stereo2mono ps-t12
post ps-t100 = null

[ShaderOverride_Reflection_3f76aa08ac32ec1a]
hash = 3f76aa08ac32ec1a
ps-t100 = stereo2mono ps-t14
post ps-t100 = null

[ShaderOverride_Reflection_40be17666bb0679e]
hash = 40be17666bb0679e
ps-t100 = stereo2mono ps-t14
post ps-t100 = null

[ShaderOverride_Reflection_42b4917dd5c937ad]
hash = 42b4917dd5c937ad
ps-t100 = stereo2mono ps-t14
post ps-t100 = null

[ShaderOverride_Reflection_43ccbee8b6b020be]
hash = 43ccbee8b6b020be
ps-t100 = stereo2mono ps-t13
post ps-t100 = null

[ShaderOverride_Reflection_47a52a5b226192bc]
hash = 47a52a5b226192bc
ps-t100 = stereo2mono ps-t12
post ps-t100 = null

[ShaderOverride_Reflection_4ac8a22763363d66]
hash = 4ac8a22763363d66
ps-t100 = stereo2mono ps-t11
post ps-t100 = null

[ShaderOverride_Reflection_4e61d3c690e53e30]
hash = 4e61d3c690e53e30
ps-t100 = stereo2mono ps-t15
post ps-t100 = null

[ShaderOverride_Reflection_531b43f4dbcc0c5d]
hash = 531b43f4dbcc0c5d
ps-t100 = stereo2mono ps-t15
post ps-t100 = null

[ShaderOverride_Reflection_5418fec1dc2c5ccd]
hash = 5418fec1dc2c5ccd
ps-t100 = stereo2mono ps-t13
post ps-t100 = null

[ShaderOverride_Reflection_556e0fe93706c5de]
hash = 556e0fe93706c5de
ps-t100 = stereo2mono ps-t14
post ps-t100 = null

[ShaderOverride_Reflection_59576fd58bd1abdc]
hash = 59576fd58bd1abdc
ps-t100 = stereo2mono ps-t12
post ps-t100 = null

[ShaderOverride_Reflection_5e907197aaf1a9d8]
hash = 5e907197aaf1a9d8
ps-t100 = stereo2mono ps-t15
post ps-t100 = null

[ShaderOverride_Reflection_65ab4d241d3619a0]
hash = 65ab4d241d3619a0
ps-t100 = stereo2mono ps-t15
post ps-t100 = null

[ShaderOverride_Reflection_69dafde3afd1cd64]
hash = 69dafde3afd1cd64
ps-t100 = stereo2mono ps-t12
post ps-t100 = null

[ShaderOverride_Reflection_6a260a4e55c3fa6f]
hash = 6a260a4e55c3fa6f
ps-t100 = stereo2mono ps-t14
post ps-t100 = null

[ShaderOverride_Reflection_70dace2d026fe228]
hash = 70dace2d026fe228
ps-t100 = stereo2mono ps-t13
post ps-t100 = null

[ShaderOverride_Reflection_710975a9602f6eb7]
hash = 710975a9602f6eb7
ps-t100 = stereo2mono ps-t15
post ps-t100 = null

[ShaderOverride_Reflection_73affd73073c262b]
hash = 73affd73073c262b
ps-t100 = stereo2mono ps-t15
post ps-t100 = null

[ShaderOverride_Reflection_77278cb475490787]
hash = 77278cb475490787
ps-t100 = stereo2mono ps-t14
post ps-t100 = null

[ShaderOverride_Reflection_787460269e259670]
hash = 787460269e259670
ps-t100 = stereo2mono ps-t15
post ps-t100 = null

[ShaderOverride_Reflection_7aea76e5fc1d9b64]
hash = 7aea76e5fc1d9b64
ps-t100 = stereo2mono ps-t13
post ps-t100 = null

[ShaderOverride_Reflection_818ce7d0aaf2b55b]
hash = 818ce7d0aaf2b55b
ps-t100 = stereo2mono ps-t14
post ps-t100 = null

[ShaderOverride_Reflection_865424757f679615]
hash = 865424757f679615
ps-t100 = stereo2mono ps-t15
post ps-t100 = null

[ShaderOverride_Reflection_8783a00c3a6dad18]
hash = 8783a00c3a6dad18
ps-t100 = stereo2mono ps-t14
post ps-t100 = null

[ShaderOverride_Reflection_8944ab2a63ea894f]
hash = 8944ab2a63ea894f
ps-t100 = stereo2mono ps-t14
post ps-t100 = null

[ShaderOverride_Reflection_9ccbcc6f0a03e5a2]
hash = 9ccbcc6f0a03e5a2
ps-t100 = stereo2mono ps-t14
post ps-t100 = null

[ShaderOverride_Reflection_a0f0d90626e50b98]
hash = a0f0d90626e50b98
ps-t100 = stereo2mono ps-t14
post ps-t100 = null

[ShaderOverride_Reflection_a3071d3525b64e04]
hash = a3071d3525b64e04
ps-t100 = stereo2mono ps-t17
post ps-t100 = null

[ShaderOverride_Reflection_a7a598f256ec3151]
hash = a7a598f256ec3151
ps-t100 = stereo2mono ps-t13
post ps-t100 = null

[ShaderOverride_Reflection_a93b6e9adc57af57]
hash = a93b6e9adc57af57
ps-t100 = stereo2mono ps-t16
post ps-t100 = null

[ShaderOverride_Reflection_aa3244df4d8a7233]
hash = aa3244df4d8a7233
ps-t100 = stereo2mono ps-t14
post ps-t100 = null

[ShaderOverride_Reflection_ad105ef4a1c8bc9a]
hash = ad105ef4a1c8bc9a
ps-t100 = stereo2mono ps-t12
post ps-t100 = null

[ShaderOverride_Reflection_aed687f8babafa7e]
hash = aed687f8babafa7e
ps-t100 = stereo2mono ps-t16
post ps-t100 = null

[ShaderOverride_Reflection_b0e2715a92bb431b]
hash = b0e2715a92bb431b
ps-t100 = stereo2mono ps-t13
post ps-t100 = null

[ShaderOverride_Reflection_b13c0661b5449d67]
hash = b13c0661b5449d67
ps-t100 = stereo2mono ps-t12
post ps-t100 = null

[ShaderOverride_Reflection_b40b1cbc26173a5f]
hash = b40b1cbc26173a5f
ps-t100 = stereo2mono ps-t14
post ps-t100 = null

[ShaderOverride_Reflection_b49c2297f4f4f2a1]
hash = b49c2297f4f4f2a1
ps-t100 = stereo2mono ps-t13
post ps-t100 = null

[ShaderOverride_Reflection_b7dba58521a7de23]
hash = b7dba58521a7de23
ps-t100 = stereo2mono ps-t15
post ps-t100 = null

[ShaderOverride_Reflection_ba3e473de89ff675]
hash = ba3e473de89ff675
ps-t100 = stereo2mono ps-t12
post ps-t100 = null

[ShaderOverride_Reflection_bda60b75fb6b966d]
hash = bda60b75fb6b966d
ps-t100 = stereo2mono ps-t15
post ps-t100 = null

[ShaderOverride_Reflection_bed21d9560087fd0]
hash = bed21d9560087fd0
ps-t100 = stereo2mono ps-t13
post ps-t100 = null

[ShaderOverride_Reflection_c14a42a64953cbe6]
hash = c14a42a64953cbe6
ps-t100 = stereo2mono ps-t16
post ps-t100 = null

[ShaderOverride_Reflection_c509714695c77567]
hash = c509714695c77567
ps-t100 = stereo2mono ps-t12
post ps-t100 = null

[ShaderOverride_Reflection_c6187280b5f57956]
hash = c6187280b5f57956
ps-t100 = stereo2mono ps-t16
post ps-t100 = null

[ShaderOverride_Reflection_c6cae0c4049cfaf0]
hash = c6cae0c4049cfaf0
ps-t100 = stereo2mono ps-t15
post ps-t100 = null

[ShaderOverride_Reflection_c9999f0efe46b6cb]
hash = c9999f0efe46b6cb
ps-t100 = stereo2mono ps-t15
post ps-t100 = null

[ShaderOverride_Reflection_cb6fa1af944918ab]
hash = cb6fa1af944918ab
ps-t100 = stereo2mono ps-t13
post ps-t100 = null

[ShaderOverride_Reflection_cc67d12e7520621d]
hash = cc67d12e7520621d
ps-t100 = stereo2mono ps-t16
post ps-t100 = null

[ShaderOverride_Reflection_ccd90a6a5bf188ad]
hash = ccd90a6a5bf188ad
ps-t100 = stereo2mono ps-t12
post ps-t100 = null

[ShaderOverride_Reflection_cd95033ae8a1a31e]
hash = cd95033ae8a1a31e
ps-t100 = stereo2mono ps-t16
post ps-t100 = null

[ShaderOverride_Reflection_d7070720d13b23d6]
hash = d7070720d13b23d6
ps-t100 = stereo2mono ps-t13
post ps-t100 = null

[ShaderOverride_Reflection_d7a53dfada1e057b]
hash = d7a53dfada1e057b
ps-t100 = stereo2mono ps-t16
post ps-t100 = null

[ShaderOverride_Reflection_db9cd44d408588fa]
hash = db9cd44d408588fa
ps-t100 = stereo2mono ps-t14
post ps-t100 = null

[ShaderOverride_Reflection_dd5d531ace9587e9]
hash = dd5d531ace9587e9
ps-t100 = stereo2mono ps-t13
post ps-t100 = null

[ShaderOverride_Reflection_e0091c50d1c4d30c]
hash = e0091c50d1c4d30c
ps-t100 = stereo2mono ps-t12
post ps-t100 = null

[ShaderOverride_Reflection_e05ff76860a574ac]
hash = e05ff76860a574ac
ps-t100 = stereo2mono ps-t13
post ps-t100 = null

[ShaderOverride_Reflection_e6c10cdc2f88f3cb]
hash = e6c10cdc2f88f3cb
ps-t100 = stereo2mono ps-t12
post ps-t100 = null

[ShaderOverride_Reflection_e8a62c2680053524]
hash = e8a62c2680053524
ps-t100 = stereo2mono ps-t15
post ps-t100 = null

[ShaderOverride_Reflection_e8c85706dc3a0601]
hash = e8c85706dc3a0601
ps-t100 = stereo2mono ps-t12
post ps-t100 = null

[ShaderOverride_Reflection_e9cd284fb8d138c4]
hash = e9cd284fb8d138c4
ps-t100 = stereo2mono ps-t13
post ps-t100 = null

[ShaderOverride_Reflection_ec54dd4435692b0e]
hash = ec54dd4435692b0e
ps-t100 = stereo2mono ps-t16
post ps-t100 = null

[ShaderOverride_Reflection_fbb49d328aec3887]
hash = fbb49d328aec3887
ps-t100 = stereo2mono ps-t13
post ps-t100 = null

[ShaderOverride_Reflection_fe247f90a014735d]
hash = fe247f90a014735d
ps-t100 = stereo2mono ps-t16
post ps-t100 = null


;;;;;;;;;;;;;;; DECALS ;;;;;;;;;;;;;;;;
[ShaderOverrideHuntingDecal]
; Used for decals, as well as highlighting other
; objects. Only want to apply adjustment for decals:
hash = 02798ffa3f86e4b8
partner = 57cadcecd4aa9386

;;;;;;;;;;;;;;;; DEBUGGING TRICKS ;;;;;;;;;;;;
;[ResourceDebugVolume]
;[ResourceDebugShadow]
;[ShaderOverrideShadowVolume]
;hash = 8b431e0726c6115e
;analyse_options = dump_tex_dds dump_rt_dds dump_depth dump_cb_txt
;ResourceDebugVolume = ref cs-u0
;;ResourceDebugVolume = ref cs-t1
;ResourceDebugShadow = ref cs-t0
;[ShaderOverrideLightVolume]
;hash = 63156ad276e52990
;ResourceDebugVolume = ref cs-u0
;ResourceDebugShadow = ref cs-t0
;[CustomShaderDebugShadowVolumes]
;vs = ShaderFixes\full_screen.hlsl
;ps = ShaderFixes\debug_volume.hlsl
;blend = ADD ONE INV_SRC_ALPHA
;cull = none
;topology = triangle_strip
;o0 = bb
;ps-t100 = ResourceDebugVolume
;ps-t101 = ResourceDebugShadow
;Draw = 4, 0
;post ps-t100 = null
;post ps-t101 = null
;
;[ResourceDebug2D]
;[ShaderOverridePhysicalLighting]
;hash = 89d9cb3e7678ac50
;ResourceDebug2D = copy_desc cs-u0
;cs-u1 = ResourceDebug2D
;post cs-u1 = null
;analyse_options = dump_rt_dds dump_tex_dds
;[CustomShaderDebug2D]
;vs = ShaderFixes\full_screen.hlsl
;ps = ShaderFixes\debug_2d.hlsl
;blend = disable
;cull = none
;topology = triangle_strip
;o0 = bb
;ps-t100 = ResourceDebug2D
;Draw = 4, 0
;post ps-t100 = null

[Present]
ResourceDepthBuffer = null
x1 = 0
z1 = 0
;run = CustomShaderDebugShadowVolumes
;run = CustomShaderDebug2D
; Uncomment to enable a custom shader that allows the stereo output mode to be
; changed to Side-by-Side or Top-and-Bottom:
;run = CustomShader3DVision2SBS

; The following custom shader can convert 3D Vision to Side-by-Side and
; Top-and-Bottom for use with 3D TVs & projectors - to enable this uncomment
; the 'run = CustomShader3DVision2SBS' in the [Present] section, set 3D Vision
; to output "checkerboard" in the control panel (which will remove the 720p
; limitation) and enable this either via the F11 key, or by setting a default
; for x7 in the [Constants] section.
[Resource3DVision2SBSBackupTexture]
[CustomShader3DVision2SBS]
; Load a custom vertex + pixel shader:
vs = ShaderFixes/3dvision2sbsvs.hlsl
ps = ShaderFixes/3dvision2sbsps.hlsl
; Explicitly unbind other shader types for safety:
hs = null
ds = null
gs = null
; Disable the OM blend stage that could interfere with the shader:
blend = disable
; Disable front/back face culling so the vertices can be in any rotation:
cull = none
; Use a triangle strip topology so we only have to output four vertices:
topology = triangle_strip
; Clear all render + depth targets to avoid compatibility issues:
o1 = null
o2 = null
o3 = null
o4 = null
o5 = null
o6 = null
o7 = null
oD = null
; Bind the back buffer as a render target. set_viewport ensures that the view
; port is the size of the buffer so the draw call will work, and no_view_cache
; is necessary for a few games like Mad Max:
o0 = set_viewport no_view_cache bb
; Back up any textures that were in the ps-t100 slot. The CustomResource
; section will already back up a lot of state, including shaders, render
; targets, depth targets, UAVs, viewports, blend state, rasterizer state,
; primitive topology, etc. but it does not back up textures:
Resource3DVision2SBSBackupTexture = reference ps-t100
; Use the reverse stereo blit to give the shader access to the back buffers of
; both eyes:
ps-t100 = stereo2mono bb
; Draw four vertices. The vertex shader will construct coordinates to cover the
; full screen using the SV_VertexID semantic so we don't need vertex buffers:
draw = 4, 0
; Restore the original texture from the ps-t100 slot:
post ps-t100 = reference Resource3DVision2SBSBackupTexture

[KeyChange3DVision2SBSOutputMode]
key = F11
; 0 = Regular 3D Vision
; 1 = Reversed 3D Vision
; 2 = Side by Side
; 3 = Reversed Side by Side
; 4 = Top and Bottom
; 5 = Reversed Top and Bottom
x7 = 1, 2, 3, 4, 5, 0
type = cycle
