nss_v1_update (#11)

- Update for NSS v1 (72afdb859e1e1b400cdca9b913417626ea9e8123)

README.md

@@ -12,9 +12,22 @@ language:
 
 # Neural Super Sampling (NSS)
 
-Neural Super Sampling (NSS) is an innovative, efficient network for temporal super sampling on mobile devices. Content rendered at 540p can be upscaled to 1080p, resulting in up to 50% GPU savings. With our retraining tools content creators and game studios can build derivatives of the model suited to artwork style and performance requirements.
-
-### 🎥 Neural Super Sampling Demo
+<table>
+<tr>
+<td style="padding:12px">
+<strong>⚡ NSS v1 is now available</strong><br>
+• New architecture and trained weights.<br>
+• Higher image quality compared to NSS v0.1, with comparable runtime performance.<br>
+• Three quality modes (High, Mid, and Low) let you balance image quality and performance.<br>
+• Updated example scenarios using fragment shaders.
+</td>
+</tr>
+</table>
+Neural Super Sampling (NSS) is an innovative, efficient network for temporal super sampling on mobile devices. Content rendered at a low resolution can be upscaled to a higher resolution, resulting in up to 50% GPU savings.
+
+With our [retraining tools](https://github.com/arm/neural-graphics-model-gym) content creators and game studios can build derivatives of the model suited to artwork style and performance requirements.
+
+## 🎥 Neural Super Sampling Demo
 
 <video controls width="100%">
   <source src="https://huggingface.co/Arm/neural-super-sampling/resolve/main/resources/Enchanted_Castle_NSS_Demo.mp4" type="video/mp4">
@@ -25,53 +38,57 @@ Neural Super Sampling (NSS) is an innovative, efficient network for temporal sup
 
 Neural Super Sampling (NSS) is a parameter prediction model for real-time temporal super sampling developed by Arm, optimized for execution on Neural Accelerators (NX) in mobile GPUs. It enables high-resolution rendering at a lower compute cost by reconstructing high-quality output frames from low-resolution temporal inputs. NSS is particularly suited for mobile gaming, XR, and other power-constrained graphics use cases.
 
-- **Developed by:** Arm Limited
-- **Model type:** Temporal image super sampling
-- **License:** Other
-- **Repository:** [Neural Graphics Model Gym](https://github.com/arm/neural-graphics-model-gym)
-- **Blog:** [How Neural Super Sampling Works](https://community.arm.com/arm-community-blogs/b/mobile-graphics-and-gaming-blog/posts/how-arm-neural-super-sampling-works)
-- **Paper:** [Mobile Neural Super Sampling](https://huggingface.co/Arm/neural-super-sampling/blob/main/2025-neural-super-sampling.pdf)
-- **Quickstart with ML extensions for Vulkan®**: [ML extensions for Vulkan® Quickstart Guide](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/vulkan-ml-sample/)
-- **Quickstart with Unreal**: [Neural Super Sampling Quickstart Guide](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/nss-unreal/) for NSS integration into Unreal Engine
+NSS v1 provides three quality modes that allow you to balance image quality and runtime performance:
+* `high`: highest runtime cost but best-quality option. Checks the current frame and depth/motion detail more thoroughly, uses a larger image filter for clean-up, and samples previous frames more accurately.
+* `low`: lowest runtime cost but lowest-quality option. Uses lighter current-frame and depth/motion checks, and samples previous frames less accurately. May show more flicker or motion artifacts around fine detail and moving objects.
+* `mid`: balanced option. Similar to `low` but samples previous frames more accurately, like `high`.
 
-NSS is under active development with regular updates planned. As we increase the size and diversity of the training dataset we expect to see significant quality improvements. Follow Arm to stay up to date on the latest releases.
+For a more detailed explanation of these quality modes, refer to the [Neural Graphics Model Gym documentation](https://github.com/arm/neural-graphics-model-gym/blob/main/docs/nss/nss_configuration.md).
 
-The model is released under Arm's [AI Model Community License](https://huggingface.co/Arm/neural-super-sampling/blob/main/Arm_AI_Model_Community_License_v1_0_PRE-1154.pdf) which allows NSS to be retrained on datasets captured from your own content. Future releases of the [Neural Graphics Model Gym](https://github.com/arm/neural-graphics-model-gym) will provide the tools to capture and convert content for use in (re)retraining.
+<table>
+<tr><td><strong>Developed By</strong></td><td>Arm Limited</td></tr>
+<tr><td><strong>Model Type</strong></td><td>Temporal image super sampling</td></tr>
+<tr><td><strong>License</strong></td><td>Other</td></tr>
+<tr><td><strong>Repository</strong></td><td><a href="https://github.com/arm/neural-graphics-model-gym">Neural Graphics Model Gym</a></td></tr>
+<tr><td><strong>Blog</strong></td><td><a href="https://community.arm.com/arm-community-blogs/b/mobile-graphics-and-gaming-blog/posts/how-arm-neural-super-sampling-works">How Neural Super Sampling Works</a></td></tr>
+<tr><td><strong>Paper</strong></td><td><a href="https://huggingface.co/Arm/neural-super-sampling/blob/main/2025-neural-super-sampling.pdf">Mobile Neural Super Sampling</a></td></tr>
+<tr><td><strong>Quickstart with ML Extensions for Vulkan®</strong></td><td><a href="https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/vulkan-ml-sample/">ML Extensions for Vulkan® Learning Path</a></td></tr>
+<tr><td><strong>Quickstart with Unreal®</strong></td><td><a href="https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/nss-unreal/">NSS integration into Unreal® Engine Learning Path</a></td></tr>
+</table>
 
-## Uses
+NSS is under active development with regular updates planned. As we increase the size and diversity of the training dataset we expect to see significant quality improvements. Follow Arm to stay up to date on the latest releases.
 
-NSS can be directly integrated into graphics pipelines using ML extensions for Vulkan®. See included ML SDK for Vulkan [scenario](https://huggingface.co/Arm/neural-super-sampling/tree/main/scenario) for the simplest way to evaluate the model. The scenario includes the necessary pre- and post-processing compute shaders along with a single frame worth of input data.
+The model is released under Arm's permissive [AI Model Community License](https://huggingface.co/Arm/neural-super-sampling/blob/main/Arm_AI_Model_Community_License_v1_0_PRE-1154.pdf), designed to foster innovation in the graphics industry and provide differentiation to content creators. It allows NSS to be retrained on datasets captured from your own content.
 
-The recommended way of integrating the model into a graphics pipeline is by using the [VGF Library](https://github.com/arm/ai-ml-sdk-vgf-library/tree/main) from the ML SDK for Vulkan.
+A [plugin](https://github.com/arm/neural-graphics-data-capture-for-unreal) for capturing data in Unreal Engine is available to capture your own content for use in (re)training or evaluation in the [Neural Graphics Model Gym](https://github.com/arm/neural-graphics-model-gym).
 
-NSS is released under a [permissive license](https://huggingface.co/Arm/neural-super-sampling/blob/main/Arm_AI_Model_Community_License_v1_0_PRE-1154.pdf) designed to foster innovation in the graphics industry and provide differentiation to content creators.
+------------------------------------------------------------------------
 
-### Direct Use
+## Integration
 
-NSS has been integrated into Unreal Engine via the [NSS Plugin for Unreal Engine](https://github.com/arm/neural-graphics-for-unreal/). See our [quick start guide](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/nss-unreal/) for step-by-step instructions on how to use NSS in Unreal® Engine.
+NSS can be directly integrated into graphics pipelines using ML Extensions for Vulkan.
 
-### Out-of-Scope Use
+The recommended way of integrating the model into a graphics pipeline is by using the [VGF Library](https://github.com/arm/ai-ml-sdk-vgf-library/tree/main) from the ML SDK for Vulkan.
 
-- Not suited for non-temporal tasks such as a standalone image upsampling
+### Integration in Game Engines
 
-## Bias, Risks, and Limitations
+NSS has been integrated into Unreal Engine via the [NSS Plugin for Unreal Engine](https://github.com/arm/neural-graphics-for-unreal/). See the [Learning Path](https://learn.arm.com/learning-paths/mobile-graphics-and-gaming/nss-unreal/) for step-by-step instructions on how to use NSS in Unreal Engine.
 
-- Requires accurate motion vectors and frame history for stable output
-- May underperform in extremely low framerate scenarios (<10 FPS) with fast camera movement
-- Padding of the input is needed if input dimensions are not divisible by 8
+It is also available to use as part of the [Neural Graphics SDK for Game Engines](https://github.com/arm/neural-graphics-sdk-for-game-engines). This is designed to help integrate NSS across a wide variety of game engines.
 
-### Recommendations
+------------------------------------------------------------------------
 
-For ultra-low-FPS use cases, reduce the camera speed, acceleration, or both so that the relative motion between frames mimics the
-application running at a higher frame rate.
+## Getting Started
+
+This repository contains pre-trained weights and compiled NSS models in VGF format, ready for integration with Vulkan applications. These VGF models are unshaped, so will require developers to shape-specialize them before use. An example of how to do this can be seen in the [Neural Graphics SDK for Game Engines](https://github.com/arm/neural-graphics-sdk-for-game-engines/blob/f8df12935ef5743d7c7979751cef0c9a9c2f4e9d/sdk/src/backends/vk/ffx_vk.cpp#L137).
 
-## How to Get Started with the Model
+See the included ML SDK for Vulkan [scenarios](https://huggingface.co/Arm/neural-super-sampling/tree/main/scenario) for the simplest way to evaluate the model. The scenarios include the necessary pre- and post-processing fragment shaders along with a single frame worth of input data.
 
-This repository contains pre-trained weights and a compiled NSS model in VGF format, ready for integration with Vulkan applications.
+They demonstrate full execution of NSS on a Vulkan compute-capable system. The Emulation Layer can be used to implement ML Extensions for Vulkan where it is not supported by the native Vulkan driver.
 
-The included Scenario demonstrates full execution of the model on a Vulkan compute-capable system. An Emulation Layer is provided to implement ML Extensions for Vulkan where it is not supported by the native Vulkan driver.
+Three different scenarios for high, mid, and low quality modes of NSS are provided. For demonstration purposes these work on a fixed size input, performing upsampling from 540p to 1080p.
 
-### Download and Prepare the Scenario
+### 1. Clone the Repository
 
 These instructions will work on both Windows and Linux. On Windows, we strongly recommend the use of PowerShell over `cmd.exe` ("Command Prompt").
 
@@ -84,7 +101,7 @@ cd neural-super-sampling
 git lfs pull
 ```
 
-### Install the Scenario Runner and Emulation Layers
+### 2. Install the Scenario Runner and Emulation Layers
 
 1. Follow the steps in the Python documentation's ["Create a new virtual environment"](https://packaging.python.org/en/latest/guides/installing-using-pip-and-virtual-environments/#create-a-new-virtual-environment) guide. We will assume below that you installed this environment into a `.venv` subdirectory.
 
@@ -97,48 +114,69 @@ git lfs pull
    pip install ai-ml-sdk-scenario-runner ai-ml-emulation-layer-for-vulkan
    ```
 
-4. The Emulation Layer's documentation explains how its environment variables should be configured on [Linux](https://github.com/arm/ai-ml-emulation-layer-for-vulkan/blob/main/README.md#usage-on-linux) and on [Windows](https://github.com/arm/ai-ml-emulation-layer-for-vulkan/blob/main/README.md#usage-on-windows). The following is a simplified summary, assuming that you are at the root of the NSS model repository.
+4. The Emulation Layer package provides a helper, that prints the commands to set environment variables for your current platform and virtual environment:
+
+   * Enter the following command:
+   ```bash
+   emulation_layer --help
+   ```
+
+   Copy and run the commands it prints in the same shell you will use for scenario-runner.
 
-   * On Linux, enter these commands into Bash:
-     ```bash
-     EMULATION_LAYER_DIR=$(find $PWD/.venv -name emulation_layer -type d)
-     export LD_LIBRARY_PATH="$EMULATION_LAYER_DIR/deploy/lib:$LD_LIBRARY_PATH"
-     export VK_LAYER_PATH="$EMULATION_LAYER_DIR/deploy/share/vulkan/explicit_layer.d:$VK_LAYER_PATH"
-     export VK_INSTANCE_LAYERS="VK_LAYER_ML_Graph_Emulation:VK_LAYER_ML_Tensor_Emulation"
-     ```
+   On Linux this will set LD_LIBRARY_PATH, VK_LAYER_PATH, and VK_INSTANCE_LAYERS. On Windows it will set the equivalent PowerShell $env:VK_LAYER_PATH and $env:VK_INSTANCE_LAYERS variables.
 
-    * On Windows, enter these commands into PowerShell (`cmd.exe` requires a different syntax):
-    ```powershell
-    $env:VK_LAYER_PATH="$pwd\.venv\Lib\site-packages\emulation_layer\deploy\bin;$env:VK_LAYER_PATH"
-    $env:VK_INSTANCE_LAYERS="VK_LAYER_ML_Graph_Emulation;VK_LAYER_ML_Tensor_Emulation"
-    ```
+   For more help, the Emulation Layer's documentation explains how its environment variables should be configured on [Linux](https://github.com/arm/ai-ml-emulation-layer-for-vulkan/blob/main/README.md#usage-on-linux) and on [Windows](https://github.com/arm/ai-ml-emulation-layer-for-vulkan/blob/main/README.md#usage-on-windows).
 
-### Run the Scenario
+### 3. Run the Scenario
 
-- Execute the Scenario Runner:
+1. Change your working directory to the `scenario` folder:
 
    ```bash
-   scenario-runner --scenario scenario/scenario.json --output out
+   cd scenario
    ```
 
-- Output images are encoded as `B10G11R11_UFLOAT`. This format is common for framebuffers but not widely supported by image viewers. Use [RenderDoc](https://renderdoc.org/) to view these images.
+2. Execute the Scenario Runner with your scenario of choice:
+
+   ```bash
+   scenario-runner --scenario configs/960x540_1920x1080_high_fragment.json --output out_high
+   scenario-runner --scenario configs/960x540_1920x1080_mid_fragment.json --output out_mid
+   scenario-runner --scenario configs/960x540_1920x1080_low_fragment.json --output out_low
+   ```
+
+3. Use [RenderDoc](https://renderdoc.org/) to view these images.
+Output images are encoded as `B10G11R11_UFLOAT`. This format is common for framebuffers but not widely supported by image viewers.
+
+------------------------------------------------------------------------
 
 ## Training and Evaluation
 
 For background on NSS architecture and training read our blog: [How Neural Super Sampling Works](https://community.arm.com/arm-community-blogs/b/mobile-graphics-and-gaming-blog/posts/how-arm-neural-super-sampling-works)
 
-Training and evaluation details, including model architecture code, training pipeline, and test configurations, are available at:
+Training and evaluation details, including model architecture code, training pipeline, test configurations and dataset capture plugins, are available at:
 
 - Model training code: <https://github.com/arm/neural-graphics-model-gym>
 - Examples and tutorials: <https://github.com/arm/neural-graphics-model-gym-examples>
 - Sample dataset: <https://huggingface.co/datasets/Arm/neural-graphics-dataset>
+- Dataset capture plugin: <https://github.com/arm/neural-graphics-data-capture-for-unreal>
 
-### 🔎 Model Explorer VGF extension
+## 🔎 Model Explorer VGF Extension
 
-The [VGF extension to Model Explorer](https://github.com/arm/vgf-adapter-model-explorer) provides a simple interface to visualize model and analyse VGF composition.
+The [VGF extension to Model Explorer](https://github.com/arm/vgf-adapter-model-explorer) provides a simple interface to visualize and analyse the NSS model and any other VGF model.
 
 ![Model Explorer screenshot](resources/model-explorer-screenshot.png)
 
+## Biases, Risks, Limitations and Out-of-Scope Use
+
+- Not suited for non-temporal tasks such as a standalone image upsampling
+- Requires accurate motion vectors and frame history for stable output
+- May underperform in extremely low framerate scenarios (<10 FPS) with fast camera movement
+- Padding of the input is needed if input dimensions are not divisible by 8
+
+### Recommendations
+
+For ultra-low-FPS use cases, reduce the camera speed, acceleration, or both so that the relative motion between frames mimics the
+application running at a higher frame rate.
+
 ## License
 
 - The license for the model source code can be found [here](https://github.com/arm/neural-graphics-model-gym/blob/main/LICENSES/Apache-2.0.txt).
@@ -148,13 +186,16 @@ The [VGF extension to Model Explorer](https://github.com/arm/vgf-adapter-model-e
 
 🧑‍🔬 More technical details about the model can be found in the [NSS Guide](https://developer.arm.com/documentation/111009/latest/).
 
-👩🏽‍💻 Our [Neural Graphics Development Kit](https://developer.arm.com/mobile-graphics-and-gaming/neural-graphics) contains engine plugins, model training tools, code examples and extensive developer documentation.
+👩🏽‍💻 Our [Neural Graphics Development Kit](https://developer.arm.com/mobile-graphics-and-gaming/neural-technology) contains engine plugins, model training tools, code examples and extensive developer documentation.
 
 🙋🏻‍♀️ For questions or feedback please [start a discussion](https://huggingface.co/Arm/neural-super-sampling/discussions)
 
-## Trademark notice
+------------------------------------------------------------------------
+
+## Trademark Notice
 
 * Arm® is a registered trademark of Arm Limited (or its subsidiaries) in the US and/or elsewhere.
 * Python® is a registered trademark of the Python Software Foundation.
-* Vulkan® is a registered trademark of the [Khronos® Group](https://www.khronos.org/legal/trademarks).
+* Unreal® is a trademark or registered trademark of Epic Games, Inc. in the United States of America and elsewhere.
+* Vulkan and the Vulkan logo are registered trademarks of the [Khronos Group Inc.](https://www.khronos.org/legal/trademarks).
 * Windows® is a trademark of the Microsoft group of companies.

v1/nss_v1_mid_low_fp32.pt → nss_v1_high_int8.vgf

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:2cc70c7d12ba1a2461d91f1b6d1150aa4b59012affef4666963b782323e9fe9a
-size 580519
+oid sha256:0aee36b193b5417c94f230e6a6d2abc78c1c293b689c34a9ceee7f59f9da6a42
+size 164608

nss_v1_high_int8_metadata.json

@@ -0,0 +1,36 @@
+{
+    "inputs": {
+        "_PreprocessTensor": {
+            "SINT": {
+                "scale": 0.003912401385605335,
+                "zero_point": -128
+            },
+            "SNORM": {
+                "scale": 0.4968749759718776,
+                "zero_point": -1.0078740157480315
+            }
+        }
+    },
+    "outputs": {
+        "_KpnCoefficients": {
+            "SINT": {
+                "scale": 0.003937007859349251,
+                "zero_point": -127
+            },
+            "SNORM": {
+                "scale": 0.49999999813735485,
+                "zero_point": -1.0
+            }
+        },
+        "_TemporalTensor": {
+            "SINT": {
+                "scale": 0.003937007859349251,
+                "zero_point": -127
+            },
+            "SNORM": {
+                "scale": 0.49999999813735485,
+                "zero_point": -1.0
+            }
+        }
+    }
+}

v1/nss_v1_mid_low_int8.pt → nss_v1_mid_low_int8.pt

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1a0400453b70fb4a10bd6db18a37e7786071aa475305469ae66794bc597971be
-size 660665
+oid sha256:a313f05d4444ff318a495d16709f4f85c3bddec309d9e4ad591edb2a7570ac9e
+size 662393

nss_v1_mid_low_int8.vgf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1fab7a42b08f40ed859275106ddcd84a85855ae400ab5e6bf18ec7ec0eed5308
+size 158800

nss_v1_mid_low_int8_metadata.json

@@ -0,0 +1,36 @@
+{
+    "inputs": {
+        "_PreprocessTensor": {
+            "SINT": {
+                "scale": 0.003919049631804228,
+                "zero_point": -128
+            },
+            "SNORM": {
+                "scale": 0.49771930323913693,
+                "zero_point": -1.0078740157480315
+            }
+        }
+    },
+    "outputs": {
+        "_KpnCoefficients": {
+            "SINT": {
+                "scale": 0.003937007859349251,
+                "zero_point": -127
+            },
+            "SNORM": {
+                "scale": 0.49999999813735485,
+                "zero_point": -1.0
+            }
+        },
+        "_TemporalTensor": {
+            "SINT": {
+                "scale": 0.003937007859349251,
+                "zero_point": -127
+            },
+            "SNORM": {
+                "scale": 0.49999999813735485,
+                "zero_point": -1.0
+            }
+        }
+    }
+}

scenario/0_depth_scatter.comp

@@ -0,0 +1,234 @@
+//
+// -----------------------------------------------------------------------------
+// The proprietary software and information contained in this file is
+// confidential and may only be used by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+//
+// Copyright (C) 2026 Arm Limited or its affiliates. All rights reserved.
+//
+// This entire notice must be reproduced on all copies of this file and
+// copies of this file may only be made by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+// -----------------------------------------------------------------------------
+//
+
+#version 460
+#extension GL_EXT_shader_16bit_storage : require
+#extension GL_EXT_shader_explicit_arithmetic_types : require
+#extension GL_EXT_shader_explicit_arithmetic_types_float16 : require
+#extension GL_EXT_shader_explicit_arithmetic_types_float32 : require
+#extension GL_GOOGLE_include_directive : enable
+
+#include "typedefs.h"
+// NSS v1 depth scatter shader.
+
+#ifndef NSS_DEPTH_SCATTER_QUARTER_RES_INPUT
+    #define NSS_DEPTH_SCATTER_QUARTER_RES_INPUT 0
+#endif // !NSS_DEPTH_SCATTER_QUARTER_RES_INPUT
+
+//-----------------------------------------------------------------------------
+// Resources
+//-----------------------------------------------------------------------------
+// Inputs are low-resolution frame-space textures.
+// Output stores reconstructed previous-frame depth in uint format so we can
+// use imageAtomics to merge multiple scatter contributions safely.
+layout (set=0, binding=0) uniform mediump sampler2D _MotionTex; // 540p->1080p HQ/Low/Mid: 960x540 | R16G16_SFLOAT 32bpp | 1.978 MiB
+layout (set=0, binding=1) uniform highp   sampler2D _DepthTex;  // 540p->1080p HQ/Low/Mid: 960x540 | R32_SFLOAT 32bpp | 1.978 MiB
+
+layout (set=1, binding=0, r32ui) uniform uimage2D _OutDepth;    // 540p->1080p HQ: 480x270 | R32_UINT 32bpp | imageAtomicMin target | 0.494 MiB ; Low/Mid: 240x135 | 0.124 MiB
+
+//-----------------------------------------------------------------------------
+// Push constants
+//-----------------------------------------------------------------------------
+// Mirrors the Slang struct layout exactly. `_RenderDims` is present for parity
+// with Slang even though this GLSL path does not consume it directly.
+layout(push_constant, std430) uniform PushConstants {
+    // ───────────────  8-byte aligned ───────────────
+    // Source depth/motion extent divided by output depth-scatter extent.
+    layout(offset =  0) float2  _Scale;         //   8 B
+    // Inverse of `_Scale`.
+    layout(offset =  8) float2  _InvScale;      //   8 B
+    // Previous-depth output dimensions.
+    layout(offset = 16) int32_t2 _OutputDims;   //   8 B
+    // Render-resolution dimensions kept for parity with the Slang path.
+    layout(offset = 24) float2  _RenderDims;    //   8 B
+    // Inverse of `_OutputDims`.
+    layout(offset = 32) float2  _InvOutputDims; //   8 B
+                                               // Total: **40 bytes**
+};
+
+struct BilinearSamplingData {
+    int32_t2 iOffsets[4];
+    float fWeights[4];
+    int32_t2 iBasePos;
+};
+
+const float kMotionThreshold = 0.1;
+const float kBilinearWeightThreshold = 0.1;
+const float kDepthIntScale = 2147483647.0;
+// 0 = original 4-tap bilinear scatter, 1 = fast single-tap scatter.
+#define NSS_DEPTH_SCATTER_MODE 0
+
+//-----------------------------------------------------------------------------
+// Helpers
+//-----------------------------------------------------------------------------
+bool IsOnScreen(int32_t2 pos, int32_t2 size)
+{
+    return all(lessThan(pos, size)) && all(greaterThanEqual(pos, int32_t2(0)));
+}
+
+BilinearSamplingData GetBilinearSamplingData(float2 uv, int32_t2 size)
+{
+    BilinearSamplingData data;
+    float2 px = uv * float2(size) - float2(0.5);
+    data.iBasePos = int32_t2(floor(px));
+    float2 frac_px = fract(px);
+
+    data.iOffsets[0] = int32_t2(0, 0);
+    data.iOffsets[1] = int32_t2(1, 0);
+    data.iOffsets[2] = int32_t2(0, 1);
+    data.iOffsets[3] = int32_t2(1, 1);
+
+    data.fWeights[0] = (1.0 - frac_px.x) * (1.0 - frac_px.y);
+    data.fWeights[1] = frac_px.x * (1.0 - frac_px.y);
+    data.fWeights[2] = (1.0 - frac_px.x) * frac_px.y;
+    data.fWeights[3] = frac_px.x * frac_px.y;
+    return data;
+}
+
+void StoreReconstructedDepth(int32_t2 pixel, float depth)
+{
+    // Lower depth wins for normal (non-inverted) depth.
+    // Keep integer encoding consistent with Slang's InterlockedMin path.
+    uint32_t i_depth = uint32_t(clamp(depth, 0.0, 1.0) * kDepthIntScale);
+    imageAtomicMin(_OutDepth, pixel, i_depth);
+}
+
+void ReconstructPrevDepth(float depth, float2 reprojected_uv)
+{
+    int32_t2 out_size = _OutputDims;
+#if (NSS_DEPTH_SCATTER_MODE == 1)
+    // Fast mode: single nearest tap (fewer atomics, lower LS pressure).
+    float2 px = reprojected_uv * float2(out_size) - float2(0.5);
+    int32_t2 base = int32_t2(floor(px));
+    float2 frac_px = fract(px);
+    int32_t2 nearest = base + int32_t2(int32_t(frac_px.x >= 0.5), int32_t(frac_px.y >= 0.5));
+    if (IsOnScreen(nearest, out_size)) {
+        StoreReconstructedDepth(nearest, depth);
+    }
+#else
+    // Scatter one reprojected depth sample into up to 4 bilinear neighbors.
+    // This lets the later depth-clip stage read a denser previous-depth map.
+    BilinearSamplingData bilinear = GetBilinearSamplingData(reprojected_uv, out_size);
+
+    for (int32_t i = 0; i < 4; ++i) {
+        float w = bilinear.fWeights[i];
+        if (w > kBilinearWeightThreshold) {
+            int32_t2 store_pos = bilinear.iBasePos + bilinear.iOffsets[i];
+            if (IsOnScreen(store_pos, out_size)) {
+                StoreReconstructedDepth(store_pos, depth);
+            }
+        }
+    }
+#endif // (NSS_DEPTH_SCATTER_MODE == 1)
+}
+
+layout(local_size_x = 8, local_size_y = 8) in;
+
+void main()
+{
+    //-------------------------------------------------------------------------
+    // 1) Dispatch guard and UV setup
+    //-------------------------------------------------------------------------
+    int32_t2 pixel = int32_t2(gl_GlobalInvocationID.xy);
+    if (any(greaterThanEqual(pixel, _OutputDims))) {
+        return;
+    }
+
+    float2 uv = (float2(pixel) + float2(0.5)) * _InvOutputDims;
+
+    //-------------------------------------------------------------------------
+    // 2) Select the nearest source sample inside the source footprint
+    //-------------------------------------------------------------------------
+#if NSS_DEPTH_SCATTER_QUARTER_RES_INPUT
+    int32_t2 src_size = int32_t2(round(float2(_OutputDims) * _Scale));
+    int32_t2 src_base = int32_t2(float2(pixel) * _Scale);
+    float2 inv_src_size = _InvOutputDims * _InvScale;
+
+    // Use 4 gathers to cover the quarter-res 4x4 input footprint:
+    // q00: (0,0) (1,0) (0,1) (1,1)
+    // q10: (2,0) (3,0) (2,1) (3,1)
+    // q01: (0,2) (1,2) (0,3) (1,3)
+    // q11: (2,2) (3,2) (2,3) (3,3)
+    float4 d00 = textureGather(_DepthTex, (float2(src_base + int32_t2(0, 0)) + float2(0.5)) * inv_src_size, 0).wzxy;
+    float4 x00 = textureGather(_MotionTex, (float2(src_base + int32_t2(0, 0)) + float2(0.5)) * inv_src_size, 0).wzxy;
+    float4 y00 = textureGather(_MotionTex, (float2(src_base + int32_t2(0, 0)) + float2(0.5)) * inv_src_size, 1).wzxy;
+    float4 d10 = textureGather(_DepthTex, (float2(src_base + int32_t2(2, 0)) + float2(0.5)) * inv_src_size, 0).wzxy;
+    float4 x10 = textureGather(_MotionTex, (float2(src_base + int32_t2(2, 0)) + float2(0.5)) * inv_src_size, 0).wzxy;
+    float4 y10 = textureGather(_MotionTex, (float2(src_base + int32_t2(2, 0)) + float2(0.5)) * inv_src_size, 1).wzxy;
+    float4 d01 = textureGather(_DepthTex, (float2(src_base + int32_t2(0, 2)) + float2(0.5)) * inv_src_size, 0).wzxy;
+    float4 x01 = textureGather(_MotionTex, (float2(src_base + int32_t2(0, 2)) + float2(0.5)) * inv_src_size, 0).wzxy;
+    float4 y01 = textureGather(_MotionTex, (float2(src_base + int32_t2(0, 2)) + float2(0.5)) * inv_src_size, 1).wzxy;
+    float4 d11 = textureGather(_DepthTex, (float2(src_base + int32_t2(2, 2)) + float2(0.5)) * inv_src_size, 0).wzxy;
+    float4 x11 = textureGather(_MotionTex, (float2(src_base + int32_t2(2, 2)) + float2(0.5)) * inv_src_size, 0).wzxy;
+    float4 y11 = textureGather(_MotionTex, (float2(src_base + int32_t2(2, 2)) + float2(0.5)) * inv_src_size, 1).wzxy;
+
+    float3 result = float3(x00.x, y00.x, d00.x);
+
+    #define NSS_UPDATE_NEAREST_STEP(OFF_X, OFF_Y, DEPTH, MOTION_X, MOTION_Y)                               \
+        {                                                                                                   \
+            int32_t2 _src = src_base + int32_t2((OFF_X), (OFF_Y));                                         \
+            float _d = (DEPTH);                                                                             \
+            float _take = float(IsOnScreen(_src, src_size)) * step(_d, result.z);                          \
+            result = mix(result, float3((MOTION_X), (MOTION_Y), _d), _take);                               \
+        }
+
+    NSS_UPDATE_NEAREST_STEP(1, 0, d00.y, x00.y, y00.y);
+    NSS_UPDATE_NEAREST_STEP(0, 1, d00.z, x00.z, y00.z);
+    NSS_UPDATE_NEAREST_STEP(1, 1, d00.w, x00.w, y00.w);
+    NSS_UPDATE_NEAREST_STEP(2, 0, d10.x, x10.x, y10.x);
+    NSS_UPDATE_NEAREST_STEP(3, 0, d10.y, x10.y, y10.y);
+    NSS_UPDATE_NEAREST_STEP(2, 1, d10.z, x10.z, y10.z);
+    NSS_UPDATE_NEAREST_STEP(3, 1, d10.w, x10.w, y10.w);
+    NSS_UPDATE_NEAREST_STEP(0, 2, d01.x, x01.x, y01.x);
+    NSS_UPDATE_NEAREST_STEP(1, 2, d01.y, x01.y, y01.y);
+    NSS_UPDATE_NEAREST_STEP(0, 3, d01.z, x01.z, y01.z);
+    NSS_UPDATE_NEAREST_STEP(1, 3, d01.w, x01.w, y01.w);
+    NSS_UPDATE_NEAREST_STEP(2, 2, d11.x, x11.x, y11.x);
+    NSS_UPDATE_NEAREST_STEP(3, 2, d11.y, x11.y, y11.y);
+    NSS_UPDATE_NEAREST_STEP(2, 3, d11.z, x11.z, y11.z);
+    NSS_UPDATE_NEAREST_STEP(3, 3, d11.w, x11.w, y11.w);
+
+    #undef NSS_UPDATE_NEAREST_STEP
+#else
+    // Match Slang gather ordering by swizzling GLSL `textureGather` result.
+    // The target order is TL, TR, BL, BR.
+    float4 dquad = textureGather(_DepthTex, uv, 0).wzxy;
+    float4 xquad = textureGather(_MotionTex, uv, 0).wzxy;
+    float4 yquad = textureGather(_MotionTex, uv, 1).wzxy;
+
+    // Choose the motion/depth sample corresponding to nearest depth.
+    float3 result = float3(xquad.x, yquad.x, dquad.x);
+    result = mix(result, float3(xquad.y, yquad.y, dquad.y), step(dquad.y, result.z));
+    result = mix(result, float3(xquad.z, yquad.z, dquad.z), step(dquad.z, result.z));
+    result = mix(result, float3(xquad.w, yquad.w, dquad.w), step(dquad.w, result.z));
+#endif // NSS_DEPTH_SCATTER_QUARTER_RES_INPUT
+
+    //-------------------------------------------------------------------------
+    // 3) Motion conditioning and reprojection
+    //-------------------------------------------------------------------------
+    float depth_dilated = result.z;
+    float2 motion = result.xy * _InvScale;
+#if NSS_DEPTH_SCATTER_QUARTER_RES_INPUT
+    motion *= float(length(result.xy) > kMotionThreshold); // suppress tiny vectors before 135p scaling
+#else
+    motion *= float(length(motion) > kMotionThreshold); // suppress tiny vectors
+#endif // NSS_DEPTH_SCATTER_QUARTER_RES_INPUT
+    motion *= _InvOutputDims;                          // px -> uv
+
+    //-------------------------------------------------------------------------
+    // 4) Scatter reconstructed previous depth
+    //-------------------------------------------------------------------------
+    float2 reproj_uv = uv - motion;
+    ReconstructPrevDepth(depth_dilated, reproj_uv);
+}

scenario/0_depth_scatter_init.comp

@@ -0,0 +1,43 @@
+//
+// -----------------------------------------------------------------------------
+// The proprietary software and information contained in this file is
+// confidential and may only be used by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+//
+// Copyright (C) 2026 Arm Limited or its affiliates. All rights reserved.
+//
+// This entire notice must be reproduced on all copies of this file and
+// copies of this file may only be made by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+// -----------------------------------------------------------------------------
+//
+
+#version 460
+#extension GL_EXT_shader_explicit_arithmetic_types : require
+#extension GL_GOOGLE_include_directive : enable
+
+#include "typedefs.h"
+
+layout(set=0, binding=0, r32ui) uniform uimage2D _OutDepth; // 540p->1080p HQ: 480x270 | R32_UINT 32bpp | depth-scatter clear target | 0.494 MiB ; Low/Mid: 240x135 | 0.124 MiB
+
+layout(push_constant, std430) uniform PushConstants {
+    // ─────────────── 16-byte ABI prefix reused from depth scatter ───────────────
+    // Offsets [0, 15] belong to the full depth-scatter push-constant blob and
+    // are intentionally ignored by this clear pass.
+
+    // ───────────────  8-byte aligned ───────────────
+    // Previous-depth output dimensions used for the clear-pass dispatch guard.
+    layout(offset = 16) int32_t2 _OutputDims; //   8 B
+                                              // Total accessed range: **24 bytes** (shared ABI blob is 40 bytes)
+};
+
+layout(local_size_x = 8, local_size_y = 8) in;
+
+void main()
+{
+    int32_t2 pixel = int32_t2(gl_GlobalInvocationID.xy);
+    if (any(greaterThanEqual(pixel, _OutputDims))) {
+        return;
+    }
+    imageStore(_OutDepth, pixel, uvec4(uint(0x7fffffff), 0u, 0u, 0u));
+}

scenario/0_disocclusion_mask_lq.frag

@@ -0,0 +1,30 @@
+//
+// -----------------------------------------------------------------------------
+// The proprietary software and information contained in this file is
+// confidential and may only be used by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+//
+// Copyright (C) 2026 Arm Limited or its affiliates. All rights reserved.
+//
+// This entire notice must be reproduced on all copies of this file and
+// copies of this file may only be made by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+// -----------------------------------------------------------------------------
+//
+
+#version 460
+#extension GL_EXT_shader_explicit_arithmetic_types : require
+#extension GL_EXT_shader_explicit_arithmetic_types_float32 : require
+#extension GL_GOOGLE_include_directive : enable
+
+#include "0_disocclusion_mask_lq_shared.h"
+
+layout(location = 0) out mediump float _OutDisocclusionMask;
+
+void main()
+{
+    int32_t2 pixel = int32_t2(gl_FragCoord.xy);
+    int32_t2 depth_size = textureSize(_DepthTm1Tex, 0);
+
+    _OutDisocclusionMask = LqDisocclusionComputeMask(pixel, depth_size);
+}

scenario/0_disocclusion_mask_lq_shared.h

@@ -0,0 +1,167 @@
+//
+// -----------------------------------------------------------------------------
+// The proprietary software and information contained in this file is
+// confidential and may only be used by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+//
+// Copyright (C) 2026 Arm Limited or its affiliates. All rights reserved.
+//
+// This entire notice must be reproduced on all copies of this file and
+// copies of this file may only be made by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+// -----------------------------------------------------------------------------
+//
+
+#ifndef NSS_V1_DISOCCLUSION_MASK_LQ_SHARED_H
+#define NSS_V1_DISOCCLUSION_MASK_LQ_SHARED_H
+
+#include "typedefs.h"
+#include "common.h"
+
+layout (set=0, binding=0) uniform mediump sampler2D _MotionTex;
+layout (set=0, binding=1) uniform highp   sampler2D _DepthTex;
+layout (set=0, binding=2) uniform highp   usampler2D _DepthTm1Tex;
+
+layout(push_constant, std430) uniform PushConstants {
+    layout(offset =   0) float4  _DeviceToViewDepth;
+    layout(offset =  16) float4  _JitterOffset;
+    layout(offset =  32) float4  _JitterOffsetTm1;
+    layout(offset =  48) float2  _Scale;
+    layout(offset =  56) float2  _InvScale;
+    layout(offset =  64) int32_t2 _OutputDims;
+    layout(offset =  72) int32_t2 _InputDims;
+    layout(offset =  80) int32_t2 _PaddedDims;
+    layout(offset =  88) float2  _InvOutputDims;
+    layout(offset =  96) float2  _InvInputDims;
+    layout(offset = 104) float2  _InvPaddedDims;
+    layout(offset = 112) float2  _InvDepthTm1Dims;
+    layout(offset = 120) float2  _RenderSize;
+    layout(offset = 128) float2  _Exposure;
+    layout(offset = 136) float _DepthClipRequiredSepScale;
+    layout(offset = 140) float _DepthClipPower;
+};
+
+const float kLqDisocclusionEps = 1e-7;
+const float kLqDisocclusionDepthScale = 2147483647.0;
+const float kLqDisocclusionInvDepthScale = 1.0 / kLqDisocclusionDepthScale;
+const float kLqDisocclusionMotionThreshold = 0.1;
+
+#ifndef NSS_LQ_DISOCCLUSION_DEPTH_GRADIENT_TOLERANCE_SCALE
+#define NSS_LQ_DISOCCLUSION_DEPTH_GRADIENT_TOLERANCE_SCALE 1.0
+#endif
+
+bool LqDisocclusionIsOnScreen(int32_t2 pos, int32_t2 size)
+{
+    return all(lessThan(pos, size)) && all(greaterThanEqual(pos, int32_t2(0)));
+}
+
+float LqDisocclusionGetViewSpaceDepth(float depth, float4 device_to_view)
+{
+    return device_to_view.y / (depth - device_to_view.x);
+}
+
+void LqDisocclusionFindClosestDepthMotion4x4(
+    int32_t2 dst_pos,
+    int32_t2 dst_size,
+    out float closest_depth,
+    out float2 closest_motion,
+    out float local_view_depth_range)
+{
+    int32_t2 src_base = int32_t2(float2(dst_pos) * (float2(_InputDims) / float2(dst_size)));
+    int32_t2 src_pos = clamp(src_base, int32_t2(0), _InputDims - int32_t2(1));
+
+    closest_depth = texelFetch(_DepthTex, src_pos, 0).r;
+    closest_motion = texelFetch(_MotionTex, src_pos, 0).xy;
+    // Grazing planes can span a large view-depth range inside one LQ footprint.
+    float src_view_depth = LqDisocclusionGetViewSpaceDepth(closest_depth, _DeviceToViewDepth);
+    float min_view_depth = src_view_depth;
+    float max_view_depth = src_view_depth;
+
+    for (int y = 0; y < 4; ++y) {
+        for (int x = 0; x < 4; ++x) {
+            int32_t2 sample_pos = src_base + int32_t2(x, y);
+            if (LqDisocclusionIsOnScreen(sample_pos, _InputDims)) {
+                float sample_depth = texelFetch(_DepthTex, sample_pos, 0).r;
+                float sample_view_depth = LqDisocclusionGetViewSpaceDepth(sample_depth, _DeviceToViewDepth);
+                min_view_depth = min(min_view_depth, sample_view_depth);
+                max_view_depth = max(max_view_depth, sample_view_depth);
+                if (sample_depth < closest_depth) {
+                    closest_depth = sample_depth;
+                    closest_motion = texelFetch(_MotionTex, sample_pos, 0).xy;
+                }
+            }
+        }
+    }
+
+    local_view_depth_range = max_view_depth - min_view_depth;
+}
+
+float LqDisocclusionComputeDepthClipInt(
+    float2 uv,
+    float current_depth,
+    float local_view_depth_range,
+    int32_t2 depth_size)
+{
+    const float bilinear_weight_threshold = 0.1;
+    float current_view_depth = LqDisocclusionGetViewSpaceDepth(current_depth, _DeviceToViewDepth);
+    // Allow same-surface 4x4 depth slope before treating the min-depth envelope as a disocclusion.
+    float local_depth_tolerance = local_view_depth_range * NSS_LQ_DISOCCLUSION_DEPTH_GRADIENT_TOLERANCE_SCALE;
+    float2 sample_px = (uv * float2(depth_size)) - float2(0.5);
+    int32_t2 sample_base = int32_t2(floor(sample_px));
+    float2 sample_frac = fract(sample_px);
+
+    float w00 = (1.0 - sample_frac.x) * (1.0 - sample_frac.y);
+    float w10 = sample_frac.x * (1.0 - sample_frac.y);
+    float w01 = (1.0 - sample_frac.x) * sample_frac.y;
+    float w11 = sample_frac.x * sample_frac.y;
+
+    float f_depth = 0.0;
+    float f_weight_sum = 0.0;
+
+#define NSS_LQ_DISOCCLUSION_DEPTH_CLIP_SAMPLE_BLOCK(SAMPLE_POS, SAMPLE_WEIGHT)                      \
+    {                                                                                               \
+        int32_t2 sample_pos = (SAMPLE_POS);                                                         \
+        float weight = (SAMPLE_WEIGHT);                                                             \
+        bool onscreen = LqDisocclusionIsOnScreen(sample_pos, depth_size);                           \
+        f_weight_sum += onscreen ? 0.0 : weight;                                                    \
+        if (onscreen && weight > bilinear_weight_threshold) {                                       \
+            float prev_depth = float(texelFetch(_DepthTm1Tex, sample_pos, 0).r) * kLqDisocclusionInvDepthScale; \
+            float prev_view_depth = LqDisocclusionGetViewSpaceDepth(prev_depth, _DeviceToViewDepth); \
+            float depth_diff = current_view_depth - prev_view_depth;                                \
+            if (depth_diff > 0.0) {                                                                 \
+                float depth_threshold = max(current_view_depth, prev_view_depth);                   \
+                float required_sep = (_DepthClipRequiredSepScale * depth_threshold) + local_depth_tolerance; \
+                float sep_ratio = saturate(required_sep / max(depth_diff, kLqDisocclusionEps));    \
+                f_depth += pow(sep_ratio, _DepthClipPower) * weight;                                \
+                f_weight_sum += weight;                                                             \
+            }                                                                                       \
+        }                                                                                           \
+    }
+
+    NSS_LQ_DISOCCLUSION_DEPTH_CLIP_SAMPLE_BLOCK(sample_base + int32_t2(0, 0), w00);
+    NSS_LQ_DISOCCLUSION_DEPTH_CLIP_SAMPLE_BLOCK(sample_base + int32_t2(1, 0), w10);
+    NSS_LQ_DISOCCLUSION_DEPTH_CLIP_SAMPLE_BLOCK(sample_base + int32_t2(0, 1), w01);
+    NSS_LQ_DISOCCLUSION_DEPTH_CLIP_SAMPLE_BLOCK(sample_base + int32_t2(1, 1), w11);
+
+#undef NSS_LQ_DISOCCLUSION_DEPTH_CLIP_SAMPLE_BLOCK
+
+    return f_weight_sum > 0.0 ? saturate(1.0 - f_depth / f_weight_sum) : 0.0;
+}
+
+float LqDisocclusionComputeMask(int32_t2 pixel, int32_t2 depth_size)
+{
+    float current_depth = 0.0;
+    float2 motion = float2(0.0);
+    float local_view_depth_range = 0.0;
+    LqDisocclusionFindClosestDepthMotion4x4(pixel, depth_size, current_depth, motion, local_view_depth_range);
+
+    float2 inv_depth_size = rcp(float2(depth_size));
+    float2 uv = (float2(pixel) + float2(0.5)) * inv_depth_size;
+    float2 motion_depth_pixels = motion * (float2(depth_size) / float2(_InputDims));
+    motion_depth_pixels *= float(length(motion) > kLqDisocclusionMotionThreshold);
+    float2 reproj_uv = uv - (motion_depth_pixels * inv_depth_size);
+
+    return LqDisocclusionComputeDepthClipInt(reproj_uv, current_depth, local_view_depth_range, depth_size);
+}
+
+#endif // NSS_V1_DISOCCLUSION_MASK_LQ_SHARED_H

scenario/1_pre_process.frag

@@ -0,0 +1,88 @@
+//
+// -----------------------------------------------------------------------------
+// The proprietary software and information contained in this file is
+// confidential and may only be used by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+//
+// Copyright (C) 2026 Arm Limited or its affiliates. All rights reserved.
+//
+// This entire notice must be reproduced on all copies of this file and
+// copies of this file may only be made by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+// -----------------------------------------------------------------------------
+//
+
+#version 460
+#extension GL_EXT_shader_8bit_storage : require
+#extension GL_EXT_shader_16bit_storage : require
+#extension GL_EXT_shader_explicit_arithmetic_types : require
+#extension GL_EXT_shader_explicit_arithmetic_types_int8 : require
+#extension GL_EXT_shader_explicit_arithmetic_types_float16 : require
+#extension GL_EXT_shader_explicit_arithmetic_types_float32 : require
+#extension GL_GOOGLE_include_directive : enable
+
+#include "typedefs.h"
+#include "common.h"
+
+#ifndef NSS_INPUT_LAYOUT
+    #define NSS_INPUT_LAYOUT 0
+#endif // !NSS_INPUT_LAYOUT
+#ifndef NSS_V1_FULL_RES_LUMA_DERIVATIVE
+    #define NSS_V1_FULL_RES_LUMA_DERIVATIVE (NSS_INPUT_LAYOUT == 0)
+#endif // !NSS_V1_FULL_RES_LUMA_DERIVATIVE
+#ifndef NSS_V1_HALF_RES_LUMA_DERIVATIVE
+    #define NSS_V1_HALF_RES_LUMA_DERIVATIVE (NSS_INPUT_LAYOUT == 1)
+#endif // !NSS_V1_HALF_RES_LUMA_DERIVATIVE
+#ifndef NSS_YCOCG_LUMA_DERIVATIVE
+    #define NSS_YCOCG_LUMA_DERIVATIVE (NSS_V1_FULL_RES_LUMA_DERIVATIVE || NSS_V1_HALF_RES_LUMA_DERIVATIVE)
+#endif // !NSS_YCOCG_LUMA_DERIVATIVE
+
+layout(location = 0) in vec2 vUV;
+
+//-----------------------------------------------------------------------------
+// Resources
+//-----------------------------------------------------------------------------
+layout (set=0, binding=0) uniform mediump sampler2D _ColourTex;       // 540p->1080p HQ/Low/Mid: 960x540 | R11G11B10 32bpp | 1.978 MiB
+layout (set=0, binding=1) uniform highp   sampler2D _DepthTex;        // 540p->1080p HQ/Low/Mid: 960x540 | R32_SFLOAT 32bpp | 1.978 MiB
+layout (set=0, binding=2) uniform mediump sampler2D _MotionVectorTex; // 540p->1080p HQ/Low/Mid: 960x540 | R16G16_SFLOAT 32bpp | 1.978 MiB
+layout (set=0, binding=3) uniform mediump sampler2D _HistoryTex;      // 540p->1080p HQ/Low/Mid: 1920x1080 | R11G11B10 32bpp | 7.910 MiB
+layout (set=0, binding=4) uniform lowp    sampler2D _FeedbackTensor;  // 540p->1080p HQ: 960x544 | R8G8B8A8_SNORM 32bpp | Tensor->Texture Alias (Linear) | 1.992 MiB ; Low/Mid: 480x272 | 0.498 MiB
+layout (set=0, binding=5) uniform highp   usampler2D _DepthTm1Tex;    // 540p->1080p HQ: 480x270 | R32_UINT 32bpp | previous-depth scatter result | 0.494 MiB ; Low/Mid: 240x135 | 0.124 MiB
+layout (set=0, binding=6) uniform lowp    sampler2D _LumaDerivTm1Tex; // 540p->1080p HQ: 960x544 | R8G8B8A8_SNORM 32bpp | derivative history | 1.992 MiB ; Low/Mid: 480x272 | 0.498 MiB
+#if NSS_INPUT_LAYOUT == 1
+layout (set=0, binding=7) uniform highp   sampler2D _DisocclusionMaskLQTex; // Low/Mid 135p depth-domain disocclusion mask
+#endif // NSS_INPUT_LAYOUT == 1
+
+layout (set=1, binding=0, std430) buffer InputTensorBuffer {
+    int8_t4 data[];
+} _InputTensorBuffer; // 540p->1080p HQ: 960x544x12 | int8 NHWC std430 buffer alias | 5.977 MiB ; Low/Mid: 480x272x12 | 1.494 MiB
+
+layout(location = 0) out mediump vec4 _LumaDerivOut;          // 540p->1080p HQ: 960x544 | R8G8B8A8_SNORM 32bpp render target | 1.992 MiB ; Low/Mid: 480x272 | 0.498 MiB
+layout(location = 1) out mediump vec4 _NearestDepthOffsetOut; // 540p->1080p HQ: 960x544 | R8_UNORM 8bpp render target | 0.498 MiB ; Low/Mid: 480x272 | R8G8_UNORM 16bpp | 0.249 MiB
+
+#include "1_pre_process_shared.h"
+
+void WriteInputTensorPacked(int32_t2 coord, int8_t4 t_vec0, int8_t4 t_vec1, int8_t4 t_vec2)
+{
+    uint32_t base = (uint32_t(coord.y) * uint32_t(_PaddedDims.x) + uint32_t(coord.x)) * 3u;
+    _InputTensorBuffer.data[base + 0u] = t_vec0;
+    _InputTensorBuffer.data[base + 1u] = t_vec1;
+    _InputTensorBuffer.data[base + 2u] = t_vec2;
+}
+
+void WriteLumaDerivativeOut(int32_t2 coord, half4 luma)
+{
+    _LumaDerivOut = vec4(float4(luma));
+}
+
+void WriteNearestOffsetOut(int32_t2 coord, float4 encoded_nearest_offset)
+{
+    _NearestDepthOffsetOut = vec4(encoded_nearest_offset);
+}
+
+void main()
+{
+    _LumaDerivOut = vec4(float4(EmptyDerivativeStateForStorage()));
+    _NearestDepthOffsetOut = vec4(0.0, 0.0, 0.0, 1.0);
+    PreProcessMain(int32_t2(gl_FragCoord.xy));
+}

scenario/1_pre_process_shared.h

@@ -0,0 +1,910 @@
+//
+// -----------------------------------------------------------------------------
+// The proprietary software and information contained in this file is
+// confidential and may only be used by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+//
+// Copyright (C) 2026 Arm Limited or its affiliates. All rights reserved.
+//
+// This entire notice must be reproduced on all copies of this file and
+// copies of this file may only be made by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+// -----------------------------------------------------------------------------
+//
+
+#ifndef NSS_V1_PRE_PROCESS_SHARED_H
+#define NSS_V1_PRE_PROCESS_SHARED_H
+
+#ifndef NSS_INPUT_LAYOUT
+    // 0: full-resolution preprocess outputs, 1: half-resolution outputs with packed nearest-depth offsets.
+    #define NSS_INPUT_LAYOUT 0
+#endif // !NSS_INPUT_LAYOUT
+#ifndef NSS_V1_FULL_RES_LUMA_DERIVATIVE
+    #define NSS_V1_FULL_RES_LUMA_DERIVATIVE (NSS_INPUT_LAYOUT == 0)
+#endif // !NSS_V1_FULL_RES_LUMA_DERIVATIVE
+#ifndef NSS_V1_HALF_RES_LUMA_DERIVATIVE
+    #define NSS_V1_HALF_RES_LUMA_DERIVATIVE (NSS_INPUT_LAYOUT == 1)
+#endif // !NSS_V1_HALF_RES_LUMA_DERIVATIVE
+#ifndef NSS_YCOCG_LUMA_DERIVATIVE
+    #define NSS_YCOCG_LUMA_DERIVATIVE (NSS_V1_FULL_RES_LUMA_DERIVATIVE || NSS_V1_HALF_RES_LUMA_DERIVATIVE)
+#endif // !NSS_YCOCG_LUMA_DERIVATIVE
+
+// Layout mirrors Slang's `PushConsts` exactly to preserve parity and avoid
+// driver-dependent packing surprises.
+layout(push_constant, std430) uniform PushConstants {
+    // ─────────────── 16-byte aligned ───────────────
+    // Projection params used to reconstruct view-space depth/position.
+    layout(offset =   0) float4  _DeviceToViewDepth;      //  16 B
+    // Current-frame jitter as (x, y, x/input_w, y/input_h).
+    layout(offset =  16) float4  _JitterOffset;           //  16 B
+    // Previous-frame jitter in the same packed layout as `_JitterOffset`.
+    layout(offset =  32) float4  _JitterOffsetTm1;        //  16 B
+
+    // ───────────────  8-byte aligned ───────────────
+    // Logical preprocess extent divided by low-res input extent.
+    layout(offset =  48) float2  _Scale;                  //   8 B
+    // Inverse of `_Scale`.
+    layout(offset =  56) float2  _InvScale;               //   8 B
+    // Logical pre-process output dimensions.
+    layout(offset =  64) int32_t2 _OutputDims;            //   8 B
+    // Low-resolution input dimensions.
+    layout(offset =  72) int32_t2 _InputDims;             //   8 B
+    // Padded graph/input-tensor dimensions.
+    layout(offset =  80) int32_t2 _PaddedDims;            //   8 B
+    // Inverse of `_OutputDims`.
+    layout(offset =  88) float2  _InvOutputDims;          //   8 B
+    // Inverse of `_InputDims`.
+    layout(offset =  96) float2  _InvInputDims;           //   8 B
+    // Inverse of `_PaddedDims`.
+    layout(offset = 104) float2  _InvPaddedDims;          //   8 B
+    // Inverse dimensions of the previous-depth feedback surface.
+    layout(offset = 112) float2  _InvDepthTm1Dims;        //   8 B
+    // Render-resolution dimensions used by depth-clip shaping.
+    layout(offset = 120) float2  _RenderSize;             //   8 B
+    // Exposure packed as (exposure, 1/exposure).
+    layout(offset = 128) float2  _Exposure;               //   8 B
+
+    // ───────────────  4-byte aligned ───────────────
+    // Depth-clip separation scale precomputed on the host.
+    layout(offset = 136) float _DepthClipRequiredSepScale; //   4 B
+    // Depth-clip power/exponent precomputed on the host.
+    layout(offset = 140) float _DepthClipPower;            //   4 B
+                                                   // Total: **144 bytes**
+};
+
+const float kEps = 1e-7;
+const float kDepthScale = 2147483647.0;
+const float kInvDepthScale = 1.0 / kDepthScale;
+const float kMotionThreshold = 0.1;
+const float kMotionThresholdSq = kMotionThreshold * kMotionThreshold;
+// QAT metadata (`_PreprocessTensor` SINT).
+const half2 kPreprocessQuant = half2(1.0 / 0.003908163867890835, -128.0);
+// Temporal feedback is stored as SNORM alias of the graph int8 output, so
+// convert sampled [-1, 1] values back into the model's [0, 1] domain.
+const half2 kTemporalFeedbackQuant = half2(0.49999999813735485, -1.0);
+
+#if !NSS_YCOCG_LUMA_DERIVATIVE
+    const half kDerivativeDisThresh = 0.01HF;
+    const half kDerivMin = 0.05HF;
+    const half kDerivMax = 0.3HF;
+    const half kDerivAlpha = 0.1HF;
+#endif // !NSS_YCOCG_LUMA_DERIVATIVE
+
+#ifdef INVERTED_DEPTH
+    #define NSS_NEAREST_STEP(curr_depth, cand_depth) step(curr_depth, cand_depth)
+    #define NSS_PLANE_DEPTH(prev_depth, curr_depth) min(prev_depth, curr_depth)
+#else
+    #define NSS_NEAREST_STEP(curr_depth, cand_depth) step(cand_depth, curr_depth)
+    #define NSS_PLANE_DEPTH(prev_depth, curr_depth) max(prev_depth, curr_depth)
+#endif // INVERTED_DEPTH
+
+bool IsOnScreen(int32_t2 pos, int32_t2 size)
+{
+    return all(lessThan(pos, size)) && all(greaterThanEqual(pos, int32_t2(0)));
+}
+
+int32_t ReflectIndex(int32_t coord, int32_t size)
+{
+    return coord < 0 ? -coord - 1 : (coord >= size ? (2 * size - coord - 1) : coord);
+}
+
+int32_t2 ReflectIndex(int32_t2 coord, int32_t2 size)
+{
+    // Matches PyTorch reflect padding used by model-side preprocessing.
+    return int32_t2(ReflectIndex(coord.x, size.x), ReflectIndex(coord.y, size.y));
+}
+
+int32_t2 GetProcessDims()
+{
+    return _OutputDims;
+}
+
+float2 GetDepthTm1DimsF()
+{
+    return rcp(max(_InvDepthTm1Dims, float2(kEps)));
+}
+
+int32_t2 GetDepthTm1DimsI()
+{
+    return int32_t2(round(GetDepthTm1DimsF()));
+}
+
+int32_t2 ProcessCoordToInputCoord(int32_t2 process_coord)
+{
+#if NSS_INPUT_LAYOUT == 1
+    float2 scaled = (float2(process_coord) + float2(0.5)) * _InvScale;
+    return clamp(int32_t2(floor(scaled)), int32_t2(0), _InputDims - int32_t2(1));
+#else
+    return clamp(process_coord, int32_t2(0), _InputDims - int32_t2(1));
+#endif // NSS_INPUT_LAYOUT == 1
+}
+
+int32_t2 InputCoordToDepthCoord(int32_t2 input_coord)
+{
+    int32_t2 depth_size = GetDepthTm1DimsI();
+    float2 scaled = (float2(input_coord) + float2(0.5)) * GetDepthTm1DimsF() * _InvInputDims;
+    return clamp(int32_t2(floor(scaled)), int32_t2(0), depth_size - int32_t2(1));
+}
+
+float2 MotionToPaddedUvDelta(float2 motion)
+{
+#if NSS_INPUT_LAYOUT == 1
+    return motion * _Scale * _InvPaddedDims;
+#else
+    return motion * _InvPaddedDims;
+#endif // NSS_INPUT_LAYOUT == 1
+}
+
+struct BilinearSamplingData {
+    int32_t2 iOffsets[4];
+    float fWeights[4];
+    int32_t2 iBasePos;
+};
+
+BilinearSamplingData GetBilinearSamplingData(float2 uv, int32_t2 size)
+{
+    // Convert uv -> bilinear footprint (base coordinate + 4 weights).
+    BilinearSamplingData data;
+
+    float2 fPxSample = (uv * float2(size)) - float2(0.5);
+    data.iBasePos = int32_t2(floor(fPxSample));
+    float2 fPxFrac = fract(fPxSample);
+
+    data.iOffsets[0] = int32_t2(0, 0);
+    data.iOffsets[1] = int32_t2(1, 0);
+    data.iOffsets[2] = int32_t2(0, 1);
+    data.iOffsets[3] = int32_t2(1, 1);
+
+    data.fWeights[0] = (1.0 - fPxFrac.x) * (1.0 - fPxFrac.y);
+    data.fWeights[1] = fPxFrac.x * (1.0 - fPxFrac.y);
+    data.fWeights[2] = (1.0 - fPxFrac.x) * fPxFrac.y;
+    data.fWeights[3] = fPxFrac.x * fPxFrac.y;
+    return data;
+}
+
+float2 ComputeNdc(float2 pixPos, int32_t2 size)
+{
+    // Vulkan-style viewport mapping with Y flip.
+    return pixPos / float2(size) * float2(2.0, -2.0) + float2(-1.0, 1.0);
+}
+
+float GetViewSpaceDepth(float depth, float4 device_to_view)
+{
+    return device_to_view.y / (depth - device_to_view.x);
+}
+
+float3 GetViewSpacePosition(int32_t2 viewport_pos, int32_t2 viewport_size, float device_depth, float4 device_to_view)
+{
+    // Reconstruct view-space position from depth and projection params.
+    float z = GetViewSpaceDepth(device_depth, device_to_view);
+    float2 ndc = ComputeNdc(float2(viewport_pos), viewport_size);
+    float x = device_to_view.z * ndc.x * z;
+    float y = device_to_view.w * ndc.y * z;
+    return float3(x, y, z);
+}
+
+void FindNearestDepth_4x4_FromPixel(
+    int32_t2 px,
+    int32_t2 size,
+    out float nearest_depth,
+    out int32_t2 nearest_offset)
+{
+    //-------------------------------------------------------------------------
+    // Depth dilation:
+    // Search a 4x4-ish local neighborhood around the current pixel and pick
+    // the sample closest to camera. This stabilizes motion/depth decisions at
+    // geometric edges and thin features.
+    //-------------------------------------------------------------------------
+    float2 inv_size = rcp(float2(size));
+
+    float nearest_depth_local = 0.0;
+    float2 nearest_offset_f = float2(0.0);
+
+#define NSS_UPDATE_NEAREST_STEP(OFF_X, OFF_Y, DEPTH)                                                      \
+    {                                                                                                      \
+        int32_t2 _offset_i = int32_t2((OFF_X), (OFF_Y));                                                  \
+        int32_t2 _pos_i = px + _offset_i;                                                                  \
+        float _on_screen = float(IsOnScreen(_pos_i, size));                                                \
+        float _d = (DEPTH);                                                                                \
+        float _take = _on_screen * NSS_NEAREST_STEP(nearest_depth_local, _d);                             \
+        nearest_depth_local = mix(nearest_depth_local, _d, _take);                                         \
+        nearest_offset_f = mix(nearest_offset_f, float2(_offset_i), _take);                               \
+    }
+
+    // q00 covers offsets: (-1,-1), (0,-1), (-1,0), (0,0)
+    float4 q00 = textureGather(_DepthTex, (float2(px + int32_t2(-1, -1)) + float2(0.5)) * inv_size, 0).wzxy;
+    nearest_depth_local = q00.w; // (0,0)
+    NSS_UPDATE_NEAREST_STEP(-1, +0, q00.z); // (-1,  0)
+    NSS_UPDATE_NEAREST_STEP(+0, -1, q00.y); // ( 0, -1)
+    NSS_UPDATE_NEAREST_STEP(-1, -1, q00.x); // (-1, -1)
+
+    // q10 covers offsets: (1,-1), (2,-1), (1,0), (2,0)
+    float4 q10 = textureGather(_DepthTex, (float2(px + int32_t2(+1, -1)) + float2(0.5)) * inv_size, 0).wzxy;
+    NSS_UPDATE_NEAREST_STEP(+1, +0, q10.z); // ( 1,  0)
+    NSS_UPDATE_NEAREST_STEP(+1, -1, q10.x); // ( 1, -1)
+    NSS_UPDATE_NEAREST_STEP(+2, -1, q10.y); // ( 2, -1)
+    NSS_UPDATE_NEAREST_STEP(+2, +0, q10.w); // ( 2,  0)
+
+    // q01 covers offsets: (-1,1), (0,1), (-1,2), (0,2)
+    float4 q01 = textureGather(_DepthTex, (float2(px + int32_t2(-1, +1)) + float2(0.5)) * inv_size, 0).wzxy;
+    NSS_UPDATE_NEAREST_STEP(+0, +1, q01.y); // ( 0,  1)
+    NSS_UPDATE_NEAREST_STEP(-1, +1, q01.x); // (-1,  1)
+    NSS_UPDATE_NEAREST_STEP(+0, +2, q01.w); // ( 0,  2)
+    NSS_UPDATE_NEAREST_STEP(-1, +2, q01.z); // (-1,  2)
+
+    // q11 covers offsets: (1,1), (2,1), (1,2), (2,2)
+    float4 q11 = textureGather(_DepthTex, (float2(px + int32_t2(+1, +1)) + float2(0.5)) * inv_size, 0).wzxy;
+    NSS_UPDATE_NEAREST_STEP(+1, +1, q11.x); // ( 1,  1)
+    NSS_UPDATE_NEAREST_STEP(+2, +1, q11.y); // ( 2,  1)
+    NSS_UPDATE_NEAREST_STEP(+1, +2, q11.z); // ( 1,  2)
+    NSS_UPDATE_NEAREST_STEP(+2, +2, q11.w); // ( 2,  2)
+
+#undef NSS_UPDATE_NEAREST_STEP
+
+    nearest_depth = nearest_depth_local;
+    nearest_offset = int32_t2(nearest_offset_f);
+}
+
+void FindNearestDepth_4x4(
+    float2 uv,
+    out float nearest_depth,
+    out int32_t2 nearest_offset)
+{
+    int32_t2 px = int32_t2(uv * float2(_InputDims));
+    FindNearestDepth_4x4_FromPixel(px, _InputDims, nearest_depth, nearest_offset);
+}
+
+float ComputeDepthClipInt(
+    float2 uv,
+    float depth_current,
+    float2 render_size,
+    float4 device_to_view)
+{
+    //-------------------------------------------------------------------------
+    // Depth clip (best-effort integer previous-depth variant):
+    // Estimate disocclusion by comparing current depth to reprojected previous
+    // depth neighborhood with FOV/resolution-aware thresholds.
+    //-------------------------------------------------------------------------
+    const float bilinear_weight_threshold = 0.1;
+    int32_t2 depth_tm1_size = GetDepthTm1DimsI();
+    float current_view_depth = GetViewSpaceDepth(depth_current, device_to_view);
+    float2 sample_px = (uv * float2(depth_tm1_size)) - float2(0.5);
+    int32_t2 sample_base = int32_t2(floor(sample_px));
+    float2 sample_frac = fract(sample_px);
+
+    float w00 = (1.0 - sample_frac.x) * (1.0 - sample_frac.y);
+    float w10 = sample_frac.x * (1.0 - sample_frac.y);
+    float w01 = (1.0 - sample_frac.x) * sample_frac.y;
+    float w11 = sample_frac.x * sample_frac.y;
+
+    float required_sep_scale = _DepthClipRequiredSepScale;
+    float depth_clip_power = _DepthClipPower;
+
+    float fDepth = 0.0;
+    float fWeightSum = 0.0;
+
+#define NSS_DEPTH_CLIP_SAMPLE_BLOCK(SAMPLE_POS, SAMPLE_WEIGHT)                                             \
+    {                                                                                                      \
+        int32_t2 sample_pos = (SAMPLE_POS);                                                                \
+        float weight = (SAMPLE_WEIGHT);                                                                    \
+        bool onscreen = IsOnScreen(sample_pos, depth_tm1_size);                                            \
+        fWeightSum += onscreen ? 0.0 : weight;                                                             \
+        if (onscreen && weight > bilinear_weight_threshold) {                                              \
+            float prev_depth = float(texelFetch(_DepthTm1Tex, sample_pos, 0).r) * kInvDepthScale;        \
+            float prev_view_depth = GetViewSpaceDepth(prev_depth, device_to_view);                         \
+            float depth_diff = current_view_depth - prev_view_depth;                                       \
+            if (depth_diff > 0.0) {                                                                        \
+                float depth_threshold = max(current_view_depth, prev_view_depth);                          \
+                float required_sep = required_sep_scale * depth_threshold;                                 \
+                float sep_ratio = saturate(required_sep / max(depth_diff, kEps));                         \
+                fDepth += pow(sep_ratio, depth_clip_power) * weight;                                       \
+                fWeightSum += weight;                                                                      \
+            }                                                                                              \
+        }                                                                                                  \
+    }
+
+    NSS_DEPTH_CLIP_SAMPLE_BLOCK(sample_base + int32_t2(0, 0), w00);
+    NSS_DEPTH_CLIP_SAMPLE_BLOCK(sample_base + int32_t2(1, 0), w10);
+    NSS_DEPTH_CLIP_SAMPLE_BLOCK(sample_base + int32_t2(0, 1), w01);
+    NSS_DEPTH_CLIP_SAMPLE_BLOCK(sample_base + int32_t2(1, 1), w11);
+
+#undef NSS_DEPTH_CLIP_SAMPLE_BLOCK
+
+    return fWeightSum > 0.0 ? saturate(1.0 - fDepth / fWeightSum) : 0.0;
+}
+
+float2 LoadMotion(int32_t2 pixel)
+{
+    pixel = clamp(pixel, int32_t2(0), _InputDims - int32_t2(1));
+    float2 v = texelFetch(_MotionVectorTex, pixel, 0).xy;
+    v *= float(dot(v, v) > kMotionThresholdSq);
+    return v;
+}
+
+half3 LoadColourUnjittered(float2 uv)
+{
+    // Exposure + Karis tonemap keeps network input numerically bounded.
+    return Tonemap(SafeColour(half3(textureLod(_ColourTex, uv, 0.0).rgb) * half3(_Exposure.x)));
+}
+
+half3 LoadColourForDerivativeAtResolvedPixel(int32_t2 sample_coord)
+{
+    half3 c = half3(texelFetch(_ColourTex, sample_coord, 0).rgb);
+    c = max(c * half(_Exposure.x), half3(0.HF));
+    return sqrt(c);
+}
+
+half3 LoadColourForDerivativeAtPixel(int32_t2 pixel)
+{
+    return LoadColourForDerivativeAtResolvedPixel(ReflectIndex(pixel, _InputDims));
+}
+
+half3 WarpHistory(float2 uv)
+{
+    return Tonemap(SafeColour(half3(textureLod(_HistoryTex, uv, 0.0).rgb) * half3(_Exposure.x)));
+}
+
+half4 WarpFeedback(float2 uv, half disocclusion_mask)
+{
+    // Reset temporal features when disoccluded to avoid ghost carry-over.
+    half4 feedback = Dequantize(half4(textureLod(_FeedbackTensor, uv, 0.0)), kTemporalFeedbackQuant);
+    return mix(feedback, half4(0.HF), half(disocclusion_mask > 0.01HF));
+}
+
+half4 LoadDerivativeTm1(float2 uv)
+{
+    return half4(textureLod(_LumaDerivTm1Tex, uv, 0.0));
+}
+
+half CalculateMotionDetector(float2 vector, float2 render_size)
+{
+    // Convert motion magnitude into a bounded [0,1] detector feature.
+    float2 inv_render_size = rcp(render_size);
+    float k_pix_min = length(inv_render_size);
+    float k_pix_max = 200.0 * k_pix_min;
+    float k_pix_denom = rcp(max(k_pix_max - k_pix_min, kEps));
+
+    float2 motion_norm = vector * inv_render_size;
+    float motion_length = length(motion_norm);
+    return half(sqrt((clamp(motion_length, k_pix_min, k_pix_max) - k_pix_min) * k_pix_denom));
+}
+
+#if NSS_YCOCG_LUMA_DERIVATIVE
+
+// Derivative history is persisted through an R8G8B8A8_SNORM image. These
+// constants map between sampled SNORM values and the detector's state:
+// Y=[0, 8], Co/Cg=[-8, 8], instability=[0, 1].
+const half4 kDerivativeStorageDecodeScale = half4(4.HF, 8.HF, 8.HF, 0.5HF);
+const half4 kDerivativeStorageDecodeBias = half4(4.HF, 0.HF, 0.HF, 0.5HF);
+const half4 kDerivativeStorageEncodeScale = half4(0.25HF, 0.125HF, 0.125HF, 2.HF);
+const half4 kDerivativeStorageEncodeBias = half4(-1.HF, 0.HF, 0.HF, -1.HF);
+const half4 kDerivativeStorageZeroState = half4(-1.HF, 0.HF, 0.HF, -1.HF);
+
+half4 RGBToYCoCg(half3 rgb)
+{
+    half co = rgb.r - rgb.b;
+    half t = rgb.b + co * 0.5HF;
+    half cg = rgb.g - t;
+    half y = t + cg * 0.5HF;
+    return half4(y, co, cg, 0.HF);
+}
+
+half ComputeDerivativeDelta(half4 ycocg_a, half4 ycocg_b, half4 delta_weight)
+{
+    half4 delta = ycocg_a - ycocg_b;
+    return sqrt(dot(delta * delta, delta_weight));
+}
+
+half4 DecodeDerivativeStateFromStorage(half4 stored)
+{
+    // Previous derivative state is sampled from the SNORM history image in
+    // [-1, 1]. Decode it back into the detector's YCoCg/instability domain
+    // before comparing it against the current frame.
+    return stored * kDerivativeStorageDecodeScale + kDerivativeStorageDecodeBias;
+}
+
+half4 EncodeDerivativeStateForStorage(half4 state)
+{
+    // The side-output image is R8G8B8A8_SNORM, not a float history buffer.
+    // Encode the HDR-derived YCoCg state into fixed SNORM ranges, while keeping
+    // instability linear so the network-visible derivative preserves precision.
+    return state * kDerivativeStorageEncodeScale + kDerivativeStorageEncodeBias;
+}
+
+half4 EmptyDerivativeStateForStorage()
+{
+    return kDerivativeStorageZeroState;
+}
+
+half4 CalculateLumaDerivative(
+    int32_t2 ref_coord,
+    float2 derivative_uv,
+    float2 derivative_inv_dims,
+    half4 deriv_tm1_h,
+    half disocclusion_mask,
+    out half instability_out)
+{
+    const half derivative_dis_thresh = 0.01HF;
+    const half4 delta_weight = half4(1.HF, 1.5625HF, 1.5625HF, 0.HF);
+    const half recall_floor = 0.065HF;
+    const half recall_ceil = 0.420HF;
+    const half excursion_floor = 0.025HF;
+    const half excursion_ceil = 0.160HF;
+    const half mean_gate_floor = 0.070HF;
+    const half mean_gate_ceil = 0.230HF;
+    const half sustain_cold_floor = 0.177HF;
+    const half sustain_cold_ceil = 0.330HF;
+    const half sustain_hot_floor = 0.157HF;
+    const half sustain_hot_ceil = 0.305HF;
+    const half sustain_hysteresis_floor = 0.110HF;
+    const half sustain_hysteresis_ceil = 0.210HF;
+    const half sustain_support_alpha = 0.30HF;
+    const half hot_hold_floor = 0.180HF;
+    const half hot_hold_ceil = 0.280HF;
+    const half sustain_min_hot_hold = 0.12HF;
+    const half decay_min_hot_gate = 0.50HF;
+    const half sustain_strength = 0.80HF;
+    const half instability_rise_alpha_min = 0.08HF;
+    const half instability_rise_alpha_max = 0.22HF;
+    const half instability_fast_fall_alpha = 0.24HF;
+    const half instability_fall_alpha = 0.05HF;
+    const half spatial_support_scale = 0.75HF;
+    const half spatial_support_blend = 0.30HF;
+#if NSS_V1_HALF_RES_LUMA_DERIVATIVE
+    const half moire_temporal_floor = 0.10HF;
+    const half moire_temporal_ceil = 0.30HF;
+    const half moire_range_floor = 0.99HF;
+    const half moire_range_ceil = 0.999HF;
+    const half moire_range_scale = 0.50HF;
+    const half flat_temporal_floor = 0.015HF;
+    const half flat_temporal_ceil = 0.030HF;
+    const half flat_range_floor = 0.040HF;
+    const half flat_range_ceil = 0.120HF;
+    const half flat_blue_floor = 0.220HF;
+    const half flat_blue_ceil = 0.300HF;
+    const half flat_luma_floor = 0.450HF;
+    const half flat_luma_ceil = 1.050HF;
+    const half flat_rgb_b_floor = 0.800HF;
+    const half flat_rgb_b_ceil = 1.400HF;
+    const half flat_flicker_scale = 0.75HF;
+#endif // NSS_V1_HALF_RES_LUMA_DERIVATIVE
+
+    half4 deriv_tm1 = DecodeDerivativeStateFromStorage(deriv_tm1_h);
+    half raw_zero_state = half(dot(abs(deriv_tm1_h), half4(1.HF)) < 1e-4HF);
+    half decoded_zero_state = half(dot(abs(deriv_tm1), half4(1.HF)) < 1e-4HF);
+    half uninitialized_state = max(raw_zero_state, decoded_zero_state);
+    half4 ycocg_c = RGBToYCoCg(LoadColourForDerivativeAtResolvedPixel(ref_coord));
+    half4 ycocg_n = RGBToYCoCg(LoadColourForDerivativeAtPixel(ref_coord + int32_t2(0, -1)));
+    half4 ycocg_s = RGBToYCoCg(LoadColourForDerivativeAtPixel(ref_coord + int32_t2(0, 1)));
+    half4 ycocg_e = RGBToYCoCg(LoadColourForDerivativeAtPixel(ref_coord + int32_t2(1, 0)));
+    half4 ycocg_w = RGBToYCoCg(LoadColourForDerivativeAtPixel(ref_coord + int32_t2(-1, 0)));
+    half d_center = ComputeDerivativeDelta(ycocg_c, half4(deriv_tm1.xyz, 0.HF), delta_weight);
+    half d_n = ComputeDerivativeDelta(ycocg_c, ycocg_n, delta_weight);
+    half d_s = ComputeDerivativeDelta(ycocg_c, ycocg_s, delta_weight);
+    half d_e = ComputeDerivativeDelta(ycocg_c, ycocg_e, delta_weight);
+    half d_w = ComputeDerivativeDelta(ycocg_c, ycocg_w, delta_weight);
+    half4 spatial_deltas = half4(d_n, d_s, d_e, d_w);
+    half spatial_delta_sum = dot(spatial_deltas, half4(1.HF));
+    half spatial_delta_max = max(max(spatial_deltas.x, spatial_deltas.y), max(spatial_deltas.z, spatial_deltas.w));
+    half prev_instability = deriv_tm1.w;
+
+#if NSS_V1_HALF_RES_LUMA_DERIVATIVE
+    int32_t2 temporal_input_step = max(int32_t2(_InvScale + float2(0.5)), int32_t2(1));
+    int32_t2 moire_input_step = temporal_input_step;
+    float2 moire_derivative_step = derivative_inv_dims;
+    half4 ycocg_tn = RGBToYCoCg(LoadColourForDerivativeAtPixel(ref_coord + int32_t2(0, -moire_input_step.y)));
+    half4 ycocg_ts = RGBToYCoCg(LoadColourForDerivativeAtPixel(ref_coord + int32_t2(0, moire_input_step.y)));
+    half4 ycocg_te = RGBToYCoCg(LoadColourForDerivativeAtPixel(ref_coord + int32_t2(moire_input_step.x, 0)));
+    half4 ycocg_tw = RGBToYCoCg(LoadColourForDerivativeAtPixel(ref_coord + int32_t2(-moire_input_step.x, 0)));
+    half4 deriv_tm1_n = DecodeDerivativeStateFromStorage(
+        LoadDerivativeTm1(derivative_uv + float2(0.0, -moire_derivative_step.y))
+    );
+    half4 deriv_tm1_s = DecodeDerivativeStateFromStorage(
+        LoadDerivativeTm1(derivative_uv + float2(0.0, moire_derivative_step.y))
+    );
+    half4 deriv_tm1_e = DecodeDerivativeStateFromStorage(
+        LoadDerivativeTm1(derivative_uv + float2(moire_derivative_step.x, 0.0))
+    );
+    half4 deriv_tm1_w = DecodeDerivativeStateFromStorage(
+        LoadDerivativeTm1(derivative_uv + float2(-moire_derivative_step.x, 0.0))
+    );
+    half d_tn = ComputeDerivativeDelta(ycocg_tn, half4(deriv_tm1_n.xyz, 0.HF), delta_weight);
+    half d_ts = ComputeDerivativeDelta(ycocg_ts, half4(deriv_tm1_s.xyz, 0.HF), delta_weight);
+    half d_te = ComputeDerivativeDelta(ycocg_te, half4(deriv_tm1_e.xyz, 0.HF), delta_weight);
+    half d_tw = ComputeDerivativeDelta(ycocg_tw, half4(deriv_tm1_w.xyz, 0.HF), delta_weight);
+    half r_tn = ComputeDerivativeDelta(ycocg_c, ycocg_tn, delta_weight);
+    half r_ts = ComputeDerivativeDelta(ycocg_c, ycocg_ts, delta_weight);
+    half r_te = ComputeDerivativeDelta(ycocg_c, ycocg_te, delta_weight);
+    half r_tw = ComputeDerivativeDelta(ycocg_c, ycocg_tw, delta_weight);
+    half temporal_moire_max = max(max(d_center, d_tn), max(max(d_ts, d_te), d_tw));
+    half current_moire_range = max(max(r_tn, r_ts), max(r_te, r_tw));
+    half flat_temporal_min = min(min(d_center, d_tn), min(min(d_ts, d_te), d_tw));
+#endif // NSS_V1_HALF_RES_LUMA_DERIVATIVE
+
+    half spatial_support = max(spatial_delta_sum - spatial_delta_max, 0.HF) * (1.HF / 3.HF);
+    half supported_instability = mix(d_center, spatial_support, spatial_support_blend) * spatial_support_scale;
+#if NSS_V1_HALF_RES_LUMA_DERIVATIVE
+    half moire_temporal_gate = saturate(
+        (temporal_moire_max - moire_temporal_floor) * rcp(moire_temporal_ceil - moire_temporal_floor)
+    );
+    half moire_range_entry = saturate(
+        (current_moire_range - moire_range_floor) * rcp(moire_range_ceil - moire_range_floor)
+    ) * moire_temporal_gate * moire_range_scale;
+    half flat_temporal_gate = saturate(
+        (flat_temporal_min - flat_temporal_floor) * rcp(flat_temporal_ceil - flat_temporal_floor)
+    );
+    half flat_range_gate = 1.HF - saturate(
+        (current_moire_range - flat_range_floor) * rcp(flat_range_ceil - flat_range_floor)
+    );
+    half flat_blue_bias = (-0.75HF * ycocg_c.y) - (0.5HF * ycocg_c.z);
+    half flat_blue_gate = saturate((flat_blue_bias - flat_blue_floor) * rcp(flat_blue_ceil - flat_blue_floor));
+    half flat_luma_gate = saturate((ycocg_c.x - flat_luma_floor) * rcp(0.10HF))
+        * (1.HF - saturate((ycocg_c.x - flat_luma_ceil) * rcp(0.20HF)));
+    half flat_rgb_b = ycocg_c.x - (0.5HF * (ycocg_c.y + ycocg_c.z));
+    half flat_rgb_b_gate = saturate((flat_rgb_b - flat_rgb_b_floor) * rcp(0.10HF))
+        * (1.HF - saturate((flat_rgb_b - flat_rgb_b_ceil) * rcp(0.20HF)));
+    half flat_surface_gate = flat_range_gate * flat_blue_gate * flat_luma_gate * flat_rgb_b_gate;
+    half flat_flicker_entry = flat_temporal_gate * flat_surface_gate * flat_flicker_scale;
+#endif // NSS_V1_HALF_RES_LUMA_DERIVATIVE
+
+    half recall_excursion = max(supported_instability - prev_instability, 0.HF);
+    half recall_score = saturate((supported_instability - recall_floor) * rcp(recall_ceil - recall_floor));
+    half excursion_score = saturate((recall_excursion - excursion_floor) * rcp(excursion_ceil - excursion_floor));
+    half mean_gate = saturate((supported_instability - mean_gate_floor) * rcp(mean_gate_ceil - mean_gate_floor));
+    half raw_entry = sqrt(recall_score) * sqrt(excursion_score) * mean_gate;
+#if NSS_V1_HALF_RES_LUMA_DERIVATIVE
+    raw_entry = max(raw_entry, max(moire_range_entry, flat_flicker_entry));
+#endif // NSS_V1_HALF_RES_LUMA_DERIVATIVE
+
+    half sustain_heat = saturate(
+        (prev_instability - sustain_hysteresis_floor) * rcp(sustain_hysteresis_ceil - sustain_hysteresis_floor)
+    );
+    half sustain_support = mix(prev_instability, supported_instability, sustain_support_alpha);
+    half sustain_floor = mix(sustain_cold_floor, sustain_hot_floor, sustain_heat);
+    half sustain_ceil = mix(sustain_cold_ceil, sustain_hot_ceil, sustain_heat);
+    half sustain_gate = saturate((sustain_support - sustain_floor) * rcp(sustain_ceil - sustain_floor));
+    sustain_gate *= sustain_gate;
+    half hot_hold = saturate((prev_instability - hot_hold_floor) * rcp(hot_hold_ceil - hot_hold_floor));
+    hot_hold *= hot_hold;
+    half hot_hold_gate = hot_hold * sustain_min_hot_hold;
+    half carry_gate = max(sustain_gate, hot_hold_gate);
+    half raw_sustain = prev_instability * carry_gate * sustain_strength;
+    half raw_instability = max(raw_entry, raw_sustain);
+
+    half decay_gate = max(sustain_gate, sustain_heat * sustain_heat * decay_min_hot_gate);
+    half fall_alpha = mix(instability_fast_fall_alpha, instability_fall_alpha, decay_gate);
+    half rise_support = sqrt(recall_score * mean_gate);
+    half rise_alpha = mix(instability_rise_alpha_min, instability_rise_alpha_max, rise_support);
+    half instability_alpha = raw_instability > prev_instability ? rise_alpha : fall_alpha;
+    half filtered_instability = mix(prev_instability, raw_instability, instability_alpha);
+
+    half output_rise_alpha = 0.75HF;
+    half output_fall_alpha = 0.80HF;
+    half output_alpha = filtered_instability > prev_instability ? output_rise_alpha : output_fall_alpha;
+    half visible_instability = mix(prev_instability, filtered_instability, output_alpha);
+#if NSS_V1_HALF_RES_LUMA_DERIVATIVE
+    visible_instability = max(visible_instability, max(moire_range_entry, flat_flicker_entry));
+#endif // NSS_V1_HALF_RES_LUMA_DERIVATIVE
+
+    half4 derivative_state = half4(ycocg_c.xyz, filtered_instability);
+    half instability = visible_instability;
+
+    half disocclusion_binary = half(disocclusion_mask > derivative_dis_thresh);
+    half reset_history = max(disocclusion_binary, uninitialized_state);
+    instability *= 1.HF - reset_history;
+
+    half4 reset_state = half4(ycocg_c.xyz, 0.HF);
+    instability_out = instability;
+    return EncodeDerivativeStateForStorage(mix(derivative_state, reset_state, reset_history));
+}
+
+#else
+
+half4 EmptyDerivativeStateForStorage()
+{
+    return half4(0.HF);
+}
+
+half4 CalculateLumaDerivative(
+    half3 unjittered_colour,
+    half4 deriv_tm1,
+    half disocclusion_mask,
+    out half instability)
+{
+    //-------------------------------------------------------------------------
+    // Temporal luma derivative:
+    // 1) compute current |delta luma|
+    // 2) threshold + clip + power curve
+    // 3) accumulate with adaptive alpha
+    // 4) zero derivative in disoccluded regions
+    //-------------------------------------------------------------------------
+    half deriv_max_pow_r = rcp(kDerivMax * sqrt(kDerivMax));
+    half luma_tm1 = deriv_tm1.y;
+    half luma_derivative_tm1 = deriv_tm1.x;
+    half luma_t = Luminance(unjittered_colour);
+
+    half luma_derivative_t = abs(luma_t - luma_tm1);
+    half clipped = min(luma_derivative_t, kDerivMax);
+    clipped *= step(kDerivMin, luma_derivative_t);
+    half curved = clipped * sqrt(clipped) * deriv_max_pow_r;
+
+    half applied_d_alpha = mix(
+        kDerivAlpha,
+        kDerivAlpha * 0.1HF,
+        clamp(luma_derivative_tm1, 0.HF, kDerivMax) * rcp(kDerivMax)
+    );
+    half luma_derivative = mix(luma_derivative_tm1, curved, applied_d_alpha);
+
+    luma_derivative *= step(disocclusion_mask, kDerivativeDisThresh);
+    instability = luma_derivative;
+    return half4(luma_derivative, luma_t, 0.HF, 0.HF);
+}
+
+#endif // NSS_YCOCG_LUMA_DERIVATIVE
+
+float EncodeNearestDepthCoordUNorm(int32_t2 nearest_offset)
+{
+    // Pack [-2,2]^2 into a single R8_UNORM code.
+    int32_t2 clamped = clamp(nearest_offset, int32_t2(-2), int32_t2(2));
+    int32_t code = ((clamped.y + 2) << 3) | (clamped.x + 2);
+    return float(code) / 255.0;
+}
+
+float4 EncodeNearestOffsetQuadUNormRG8(
+    int32_t2 offset_00,
+    int32_t2 offset_10,
+    int32_t2 offset_01,
+    int32_t2 offset_11)
+{
+    // Low-quality packed quad path stores four {-1..2}^2 offsets in RG8:
+    // R = lane00 | lane10<<4, G = lane01 | lane11<<4.
+    int32_t byte_r = int32_t(EncodeNearestDepthCoordNibble(offset_00))
+        | (int32_t(EncodeNearestDepthCoordNibble(offset_10)) << 4);
+    int32_t byte_g = int32_t(EncodeNearestDepthCoordNibble(offset_01))
+        | (int32_t(EncodeNearestDepthCoordNibble(offset_11)) << 4);
+    return float4(float(byte_r), float(byte_g), 0.0, 255.0) / 255.0;
+}
+
+void WriteInputTensorPacked(int32_t2 coord, int8_t4 t_vec0, int8_t4 t_vec1, int8_t4 t_vec2);
+
+void WriteToTensor(
+    int32_t2 coord,
+    half3 history,
+    half3 colour,
+    half motion_detector,
+    half4 feedback,
+    half luma_derivative)
+{
+    // Network input layout (12 channels):
+    // history.rgb | colour.rgb | motion_detector | feedback.rgba | luma_deriv
+    // Stored as int8 for `1_nss` graph input, matching QAT metadata.
+    int8_t4 t_vec0 = Quantize(half4(history.rgb, colour.r), kPreprocessQuant);
+    int8_t4 t_vec1 = Quantize(half4(colour.gb, motion_detector, feedback.r), kPreprocessQuant);
+    int8_t4 t_vec2 = Quantize(half4(feedback.gba, luma_derivative), kPreprocessQuant);
+    WriteInputTensorPacked(coord, t_vec0, t_vec1, t_vec2);
+}
+
+void WriteLumaDerivativeOut(int32_t2 coord, half4 luma);
+void WriteNearestOffsetOut(int32_t2 coord, float4 encoded_nearest_offset);
+
+struct PreProcessLaneData
+{
+    int32_t2 input_coord;
+    int32_t2 nearest_offset;
+    float depth_dilated;
+    float2 motion;
+    float2 uv;
+    float2 reproj_uv;
+};
+
+PreProcessLaneData BuildPreProcessLaneData(int32_t2 input_coord)
+{
+    PreProcessLaneData lane;
+    lane.input_coord = clamp(input_coord, int32_t2(0), _InputDims - int32_t2(1));
+    lane.uv = (float2(lane.input_coord) + float2(0.5)) * _InvInputDims;
+
+    lane.depth_dilated = 0.0;
+    lane.nearest_offset = int32_t2(0);
+    FindNearestDepth_4x4_FromPixel(lane.input_coord, _InputDims, lane.depth_dilated, lane.nearest_offset);
+
+    int32_t2 nearest_input_coord = clamp(
+        lane.input_coord + lane.nearest_offset,
+        int32_t2(0),
+        _InputDims - int32_t2(1)
+    );
+    lane.motion = LoadMotion(nearest_input_coord);
+    lane.reproj_uv = lane.uv - (lane.motion * _InvInputDims);
+    return lane;
+}
+
+half3 AverageWarpedHistory2x2(
+    PreProcessLaneData lane_00,
+    PreProcessLaneData lane_10,
+    PreProcessLaneData lane_01,
+    PreProcessLaneData lane_11)
+{
+    return (
+        WarpHistory(lane_00.reproj_uv) +
+        WarpHistory(lane_10.reproj_uv) +
+        WarpHistory(lane_01.reproj_uv) +
+        WarpHistory(lane_11.reproj_uv)
+    ) * 0.25HF;
+}
+
+int32_t2 HalfResProcessCoordToBaseInputCoord(int32_t2 process_coord)
+{
+    return clamp(process_coord * int32_t2(2), int32_t2(0), _InputDims - int32_t2(1));
+}
+
+void PreProcessMain(int32_t2 padded_coord)
+{
+    //-------------------------------------------------------------------------
+    // 1) Dispatch/padding guard
+    //-------------------------------------------------------------------------
+    if (any(greaterThanEqual(padded_coord, _PaddedDims))) {
+        return;
+    }
+
+    int32_t2 process_dims = GetProcessDims();
+    int32_t2 process_coord = ReflectIndex(padded_coord, process_dims);
+    int32_t2 ref_coord = ProcessCoordToInputCoord(process_coord);
+    float2 uv = (float2(ref_coord) + float2(0.5)) * _InvInputDims;
+    float2 uv_pad = (float2(padded_coord) + float2(0.5)) * _InvPaddedDims;
+
+    //-------------------------------------------------------------------------
+    // 2) Depth dilation and nearest-coordinate selection
+    //-------------------------------------------------------------------------
+    float depth_dilated = 0.0;
+    int32_t2 nearest_offset = int32_t2(0);
+    FindNearestDepth_4x4(uv, depth_dilated, nearest_offset);
+
+    //-------------------------------------------------------------------------
+    // 3) Motion sampling and reprojection setup
+    //-------------------------------------------------------------------------
+    // SHADER_ACCURATE parity: sample motion at nearest-depth-dilated texel.
+    int32_t2 nearest_input_coord = clamp(ref_coord + nearest_offset, int32_t2(0), _InputDims - int32_t2(1));
+    float2 motion = LoadMotion(nearest_input_coord);
+
+    float2 reproj_uv = uv - (motion * _InvInputDims);
+    float2 unjitter_uv = uv - (_JitterOffset.xy * _InvInputDims);
+    int32_t2 depth_coord = InputCoordToDepthCoord(ref_coord);
+    float2 reproj_270p_uv = ((float2(depth_coord) + float2(0.5)) * _InvDepthTm1Dims) - (motion * _InvInputDims);
+    float2 reproj_pad_uv = uv_pad - MotionToPaddedUvDelta(motion);
+
+    //-------------------------------------------------------------------------
+    // 4) Disocclusion
+    //-------------------------------------------------------------------------
+#if NSS_INPUT_LAYOUT == 1
+    float2 disocclusion_uv = (float2(process_coord) + float2(0.5)) * _InvOutputDims;
+    half disocclusion_mask = half(textureLod(_DisocclusionMaskLQTex, disocclusion_uv, 0.0).r);
+#else
+    half disocclusion_mask = half(ComputeDepthClipInt(
+        reproj_270p_uv,
+        depth_dilated,
+        _RenderSize,
+        _DeviceToViewDepth
+    ));
+#endif // NSS_INPUT_LAYOUT == 1
+
+    //-------------------------------------------------------------------------
+    // 5) Feature preparation for network input tensor
+    //-------------------------------------------------------------------------
+    half3 unjittered_colour_h = LoadColourUnjittered(unjitter_uv);
+    half3 lr_warped_history_h;
+#if NSS_INPUT_LAYOUT == 1
+    {
+        int32_t2 history_base_input_coord = HalfResProcessCoordToBaseInputCoord(process_coord);
+        int32_t2 history_lane_input_00 = history_base_input_coord;
+        int32_t2 history_lane_input_10 = min(history_base_input_coord + int32_t2(1, 0), _InputDims - int32_t2(1));
+        int32_t2 history_lane_input_01 = min(history_base_input_coord + int32_t2(0, 1), _InputDims - int32_t2(1));
+        int32_t2 history_lane_input_11 = min(history_base_input_coord + int32_t2(1, 1), _InputDims - int32_t2(1));
+
+        PreProcessLaneData history_lane_00 = BuildPreProcessLaneData(history_lane_input_00);
+        PreProcessLaneData history_lane_10 = BuildPreProcessLaneData(history_lane_input_10);
+        PreProcessLaneData history_lane_01 = BuildPreProcessLaneData(history_lane_input_01);
+        PreProcessLaneData history_lane_11 = BuildPreProcessLaneData(history_lane_input_11);
+        lr_warped_history_h = AverageWarpedHistory2x2(
+            history_lane_00,
+            history_lane_10,
+            history_lane_01,
+            history_lane_11
+        );
+    }
+#else
+    lr_warped_history_h = WarpHistory(reproj_uv);
+#endif // NSS_INPUT_LAYOUT == 1
+    half4 deriv_tm1 = LoadDerivativeTm1(reproj_pad_uv);
+    half instability = 0.HF;
+#if NSS_YCOCG_LUMA_DERIVATIVE
+    float2 derivative_uv = reproj_uv;
+    float2 derivative_inv_dims = _InvInputDims;
+#if NSS_INPUT_LAYOUT == 1
+    derivative_uv = reproj_pad_uv;
+    derivative_inv_dims = _InvPaddedDims;
+#endif // NSS_INPUT_LAYOUT == 1
+    half4 luma = CalculateLumaDerivative(
+        ref_coord,
+        derivative_uv,
+        derivative_inv_dims,
+        deriv_tm1,
+        disocclusion_mask,
+        instability
+    );
+#else
+    half4 luma = CalculateLumaDerivative(unjittered_colour_h, deriv_tm1, disocclusion_mask, instability);
+#endif // NSS_YCOCG_LUMA_DERIVATIVE
+    half4 feedback_h = WarpFeedback(reproj_pad_uv, disocclusion_mask);
+    half motion_detector = CalculateMotionDetector(motion, _RenderSize);
+
+    //-------------------------------------------------------------------------
+    // 6) Write network tensor for padded domain
+    //-------------------------------------------------------------------------
+    WriteToTensor(
+        padded_coord,
+        lr_warped_history_h,
+        unjittered_colour_h,
+        motion_detector,
+        feedback_h,
+        instability
+    );
+
+    //-------------------------------------------------------------------------
+    // 7) Write per-frame auxiliary outputs for non-padded region only
+    //-------------------------------------------------------------------------
+    if (any(greaterThanEqual(padded_coord, process_dims))) {
+        WriteLumaDerivativeOut(padded_coord, EmptyDerivativeStateForStorage());
+        return;
+    }
+    WriteLumaDerivativeOut(padded_coord, luma);
+#if NSS_INPUT_LAYOUT == 1
+    int32_t2 base_input_coord = clamp(process_coord * int32_t2(2), int32_t2(0), _InputDims - int32_t2(1));
+    int32_t2 lane_input_00 = base_input_coord;
+    int32_t2 lane_input_10 = min(base_input_coord + int32_t2(1, 0), _InputDims - int32_t2(1));
+    int32_t2 lane_input_01 = min(base_input_coord + int32_t2(0, 1), _InputDims - int32_t2(1));
+    int32_t2 lane_input_11 = min(base_input_coord + int32_t2(1, 1), _InputDims - int32_t2(1));
+    int32_t2 quad_offset_00 = int32_t2(0);
+    int32_t2 quad_offset_10 = int32_t2(0);
+    int32_t2 quad_offset_01 = int32_t2(0);
+    int32_t2 quad_offset_11 = int32_t2(0);
+    float quad_depth_unused = 0.0;
+    FindNearestDepth_4x4_FromPixel(lane_input_00, _InputDims, quad_depth_unused, quad_offset_00);
+    FindNearestDepth_4x4_FromPixel(lane_input_10, _InputDims, quad_depth_unused, quad_offset_10);
+    FindNearestDepth_4x4_FromPixel(lane_input_01, _InputDims, quad_depth_unused, quad_offset_01);
+    FindNearestDepth_4x4_FromPixel(lane_input_11, _InputDims, quad_depth_unused, quad_offset_11);
+
+    float4 encoded_quad = EncodeNearestOffsetQuadUNormRG8(
+        quad_offset_00,
+        quad_offset_10,
+        quad_offset_01,
+        quad_offset_11
+    );
+    WriteNearestOffsetOut(padded_coord, encoded_quad);
+#else
+    WriteNearestOffsetOut(
+        padded_coord,
+        float4(EncodeNearestDepthCoordUNorm(nearest_offset), 0.0, 0.0, 1.0)
+    );
+#endif // NSS_INPUT_LAYOUT == 1
+}
+
+#endif // NSS_V1_PRE_PROCESS_SHARED_H

scenario/3_post_process.frag

@@ -0,0 +1,69 @@
+//
+// -----------------------------------------------------------------------------
+// The proprietary software and information contained in this file is
+// confidential and may only be used by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+//
+// Copyright (C) 2026 Arm Limited or its affiliates. All rights reserved.
+//
+// This entire notice must be reproduced on all copies of this file and
+// copies of this file may only be made by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+// -----------------------------------------------------------------------------
+//
+
+#version 460
+#extension GL_EXT_shader_8bit_storage : require
+#extension GL_EXT_shader_16bit_storage : require
+#extension GL_EXT_shader_explicit_arithmetic_types : require
+#extension GL_EXT_shader_explicit_arithmetic_types_int8 : require
+#extension GL_EXT_shader_explicit_arithmetic_types_float16 : require
+#extension GL_EXT_shader_explicit_arithmetic_types_float32 : require
+#extension GL_GOOGLE_include_directive : enable
+
+#include "typedefs.h"
+#include "common.h"
+
+// Compile-time option:
+// -DSIMULATE_R11G11B10_BEFORE_WRITE
+
+layout(location = 0) in vec2 vUV;
+
+//-----------------------------------------------------------------------------
+// Resources
+//-----------------------------------------------------------------------------
+layout (set=0, binding=0) uniform mediump sampler2D  _ColourTex;  // 540p->1080p HQ/Low/Mid: 960x540 | R11G11B10 32bpp | 1.978 MiB
+layout (set=0, binding=1) uniform mediump sampler2D  _HistoryTex; // 540p->1080p HQ/Low/Mid: 1920x1080 | R11G11B10 32bpp | 7.910 MiB
+layout (set=0, binding=2, std430) readonly buffer KpnParamsBuffer {
+    int8_t data[];
+} _KpnParamsBuffer; // 540p->1080p HQ: 240x136x36 | int8 NHWC std430 buffer alias | 1.121 MiB ; Low/Mid: 120x68x16 | 0.125 MiB
+layout (set=0, binding=3) uniform lowp    sampler2D  _TemporalTensor; // 540p->1080p HQ: 960x544 | R8G8B8A8_SNORM 32bpp | Tensor->Texture Alias (Linear) | 1.992 MiB ; Low/Mid: 480x272 | 0.498 MiB
+layout (set=0, binding=4) uniform mediump sampler2D  _MotionVectorTex; // 540p->1080p HQ/Low/Mid: 960x540 | R16G16_SFLOAT 32bpp | 1.978 MiB
+layout (set=0, binding=5) uniform lowp    sampler2D  _NearestDepthOffsetTex; // 540p->1080p HQ: 960x544 | R8_UNORM 8bpp | nearest-depth offset render target | 0.498 MiB ; Low/Mid: 480x272 | R8G8_UNORM 16bpp | 0.249 MiB
+#if (NSS_FILTER_MODE == 2) || (NSS_FILTER_MODE == 3)
+layout (set=0, binding=6) uniform highp usampler2D _OffsetLutUint4Tex;
+#endif // (NSS_FILTER_MODE == 2) || (NSS_FILTER_MODE == 3)
+
+layout(location = 0) out mediump vec4 _ColourOut; // 540p->1080p HQ/Low/Mid: 1920x1080 | R11G11B10 32bpp render target | 7.910 MiB
+
+#define NSS_USE_KPN_BASE_X 1
+#include "3_post_process_shared.h"
+
+int8_t ReadKpnParamsInt8FromBase(int32_t kpn_texel_base_x, int32_t kpn_y, int32_t channel)
+{
+    // SSBO path binds tight NHWC int8 tensor memory.
+    int32_t linear_base = ((kpn_y * _KpnDims.x) + kpn_texel_base_x) * kKpnChannels;
+    int8_t qv = _KpnParamsBuffer.data[uint32_t(linear_base + channel)];
+    return int8_t(qv);
+}
+
+void WriteColourOutTarget(int32_t2 coord, half3 out_linear)
+{
+    _ColourOut = vec4(float3(out_linear), 1.0);
+}
+
+void main()
+{
+    _ColourOut = vec4(0.0, 0.0, 0.0, 1.0);
+    PostProcessMain(int32_t2(gl_FragCoord.xy));
+}

scenario/3_post_process_shared.h

@@ -0,0 +1,945 @@
+//
+// -----------------------------------------------------------------------------
+// The proprietary software and information contained in this file is
+// confidential and may only be used by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+//
+// Copyright (C) 2026 Arm Limited or its affiliates. All rights reserved.
+//
+// This entire notice must be reproduced on all copies of this file and
+// copies of this file may only be made by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+// -----------------------------------------------------------------------------
+//
+
+#ifndef NSS_V1_POST_PROCESS_SHARED_H
+#define NSS_V1_POST_PROCESS_SHARED_H
+
+// Post-process build define matrix.
+//
+// This lists the defines consumed by this shared post-process header. Defaults
+// may be omitted by the scenario JSON, but the effective values should match
+// the entries below.
+//
+//   static LUT / exact 2x | high quality:
+//     -DNSS_FILTER_MODE=0
+//     -DNSS_INPUT_LAYOUT=0
+//     -DNSS_USE_HISTORY_CATMULL=1
+//     -DNSS_V1_SHARP_THETA=1
+//
+//   static LUT / exact 2x | mid quality:
+//     -DNSS_FILTER_MODE=1
+//     -DNSS_INPUT_LAYOUT=1
+//     -DNSS_USE_HISTORY_CATMULL=1
+//     -DNSS_V1_SHARP_THETA=1
+//
+//   static LUT / exact 2x | low quality:
+//     -DNSS_FILTER_MODE=1
+//     -DNSS_INPUT_LAYOUT=1
+//     -DNSS_USE_HISTORY_CATMULL=0
+//     -DNSS_V1_SHARP_THETA=1
+//
+//   non-integer dynamic LUT | high quality:
+//     post-process:
+//       -DNSS_FILTER_MODE=2
+//       -DNSS_INPUT_LAYOUT=0
+//       -DNSS_USE_HISTORY_CATMULL=1
+//       -DNSS_V1_SHARP_THETA=1
+//     paired LUT generator:
+//       -DNSS_FILTER_MODE=2
+//
+//   non-integer dynamic LUT | mid quality:
+//     post-process:
+//       -DNSS_FILTER_MODE=3
+//       -DNSS_INPUT_LAYOUT=1
+//       -DNSS_USE_HISTORY_CATMULL=1
+//       -DNSS_V1_SHARP_THETA=1
+//     paired LUT generator:
+//       -DNSS_FILTER_MODE=3
+//
+//   non-integer dynamic LUT | low quality:
+//     post-process:
+//       -DNSS_FILTER_MODE=3
+//       -DNSS_INPUT_LAYOUT=1
+//       -DNSS_USE_HISTORY_CATMULL=0
+//       -DNSS_V1_SHARP_THETA=1
+//     paired LUT generator:
+//       -DNSS_FILTER_MODE=3
+
+#ifndef NSS_USE_HISTORY_CATMULL
+    #define NSS_USE_HISTORY_CATMULL 1
+#endif // !NSS_USE_HISTORY_CATMULL
+#ifndef NSS_FILTER_MODE
+    // 0: static 2x high, 1: static 2x sparse, 2: dynamic dense LUT, 3: dynamic sparse LUT.
+    #define NSS_FILTER_MODE 0
+#endif // !NSS_FILTER_MODE
+#ifndef NSS_INPUT_LAYOUT
+    // 0: full-resolution preprocess outputs, 1: half-resolution outputs with packed nearest-depth offsets.
+    #define NSS_INPUT_LAYOUT 0
+#endif // !NSS_INPUT_LAYOUT
+#ifndef NSS_V1_SHARP_THETA
+    #define NSS_V1_SHARP_THETA 1
+#endif // !NSS_V1_SHARP_THETA
+
+#if (NSS_FILTER_MODE < 0) || (NSS_FILTER_MODE > 3)
+    #error "NSS_FILTER_MODE must be 0 (static 2x high), 1 (static 2x sparse), 2 (dynamic dense LUT), or 3 (dynamic sparse LUT)."
+#endif // filter implementation selection
+
+// Matches Slang layout and includes both geometric scales and temporal controls.
+layout(push_constant, std430) uniform PushConstants {
+    // ───────────────  8-byte aligned ───────────────
+    // High-res output extent divided by low-res input extent.
+    layout(offset =  0) float2  _Scale;          //   8 B
+    // Inverse of `_Scale`.
+    layout(offset =  8) float2  _InvScale;       //   8 B
+    // High-resolution output dimensions.
+    layout(offset = 16) int32_t2 _OutputDims;    //   8 B
+    // Low-resolution input dimensions.
+    layout(offset = 24) int32_t2 _InputDims;     //   8 B
+    // KPN tensor dimensions.
+    layout(offset = 32) int32_t2 _KpnDims;       //   8 B
+    // Inverse of `_OutputDims`.
+    layout(offset = 40) float2  _InvOutputDims;  //   8 B
+    // Inverse of `_InputDims`.
+    layout(offset = 48) float2  _InvInputDims;   //   8 B
+    // Inverse of `_KpnDims`.
+    layout(offset = 56) float2  _InvKpnDims;     //   8 B
+    // UV scale from preprocess space into temporal-feedback space.
+    layout(offset = 64) float2  _PaddedUvScale;  //   8 B
+    // UV scale from temporal-feedback space into KPN space.
+    layout(offset = 72) float2  _KpnScale;       //   8 B
+    // Tile modulo used for offset-LUT pattern selection.
+    layout(offset = 80) int32_t2 _IdxModulo;     //   8 B
+    // Exposure packed as (exposure, 1/exposure).
+    layout(offset = 88) float2  _Exposure;       //   8 B
+
+    // ───────────────  4-byte aligned ───────────────
+    // Temporal reset / history blending gate.
+    layout(offset = 96) float _Reset;            //   4 B
+
+    // ─────────────── padding to next 8-byte member ───────────────
+    // Offsets [100, 103] are implicit pad to preserve Slang parity.
+
+    // ───────────────  8-byte aligned ───────────────
+    // Jitter-dependent tile remap offset inside the modulo lattice.
+    layout(offset = 104) int32_t2 _LutOffset;    //   8 B
+    // Logical preprocess dimensions used to address temporal feedback.
+    layout(offset = 112) int32_t2 _PreprocessDims; //   8 B
+                                                 // Total: **120 bytes**
+};
+
+const float kEps = 1e-7;
+const half kMotionThreshold = 0.1HF;
+const float kMotionThresholdSq = float(kMotionThreshold) * float(kMotionThreshold);
+#if (NSS_FILTER_MODE == 1) || (NSS_FILTER_MODE == 3) || (NSS_INPUT_LAYOUT == 1)
+const int32_t kKpnChannels = 16;
+#else
+const int32_t kKpnChannels = 36;
+#endif // (NSS_FILTER_MODE == 1) || (NSS_FILTER_MODE == 3) || (NSS_INPUT_LAYOUT == 1)
+const int32_t kKpnPackedChannelsPerTexel = 4;
+const int32_t kKpnPackedTexelsPerPixel = kKpnChannels / kKpnPackedChannelsPerTexel;
+const int32_t kKpnPackedChannelShift = 2;
+const int32_t kKpnPackedChannelMask = kKpnPackedChannelsPerTexel - 1;
+const int32_t kKpnLaneX = 0;
+const int32_t kKpnLaneY = 1;
+const int32_t kKpnLaneZ = 2;
+const bool kUseMotionThreshold = false;
+// QAT metadata (`_KpnCoefficients` / `_TemporalTensor` SINT).
+const half2 kKpnQuant = half2(0.003937007859349251, -127.0);
+// Temporal params are sampled from SNORM image alias, so use SNORM dequant.
+const half2 kTemporalQuant = half2(0.49999999813735485, -1.0);
+const int32_t kLutPatternCount = 4;
+
+struct KernelPattern
+{
+    int16_t2 base_offset;
+    int16_t base_channel;
+    int16_t _pad0;
+};
+
+#if NSS_FILTER_MODE == 0
+const int16_t4 kTapDx0 = int16_t4(0, 0, 0, 2);
+const int16_t4 kTapDy0 = int16_t4(0, 2, 4, 0);
+const int16_t4 kTapCh0 = int16_t4(0, 2, 4, 12);
+const int16_t4 kTapDx1 = int16_t4(2, 2, 4, 4);
+const int16_t4 kTapDy1 = int16_t4(2, 4, 0, 2);
+const int16_t4 kTapCh1 = int16_t4(14, 16, 24, 26);
+const int16_t2 kTapD2 = int16_t2(4, 4);
+const int16_t kTapCh2 = int16_t(28);
+
+// 2x scale patterns from generated NSS v1 LUT for jitter in [-0.5, 0.5), with jitter-driven tile remap via _LutOffset.
+const KernelPattern kKernelLut[kLutPatternCount] = KernelPattern[kLutPatternCount](
+    KernelPattern(
+        int16_t2(-1, -1), int16_t(7), int16_t(0)
+    ),
+    KernelPattern(
+        int16_t2(-2, -1), int16_t(1), int16_t(0)
+    ),
+    KernelPattern(
+        int16_t2(-1, -2), int16_t(6), int16_t(0)
+    ),
+    KernelPattern(
+        int16_t2(-2, -2), int16_t(0), int16_t(0)
+    )
+);
+#endif // NSS_FILTER_MODE == 0
+
+#if NSS_FILTER_MODE == 1
+// 2x2 sparse low-quality mode keeps the centered 4x4 subset of the original
+// 6x6 KPN, preserving the generated offset-LUT tap order after pruning.
+const int16_t4 kTap2x2Dx[kLutPatternCount] = int16_t4[kLutPatternCount](
+    int16_t4(-1, -1, +1, +1),
+    int16_t4(+0, +0, +2, +2),
+    int16_t4(-1, +1, -1, +1),
+    int16_t4(+0, +0, +2, +2)
+);
+const int16_t4 kTap2x2Dy[kLutPatternCount] = int16_t4[kLutPatternCount](
+    int16_t4(-1, +1, -1, +1),
+    int16_t4(-1, +1, -1, +1),
+    int16_t4(+0, +0, +2, +2),
+    int16_t4(+0, +2, +0, +2)
+);
+const int16_t4 kTap2x2Ch[kLutPatternCount] = int16_t4[kLutPatternCount](
+    int16_t4(0, 2, 8, 10),
+    int16_t4(4, 6, 12, 14),
+    int16_t4(1, 9, 3, 11),
+    int16_t4(5, 7, 13, 15)
+);
+#endif // NSS_FILTER_MODE == 1
+
+#if (NSS_FILTER_MODE == 2) || (NSS_FILTER_MODE == 3)
+struct OffsetLutTap
+{
+    int32_t2 lr_offset;
+    int32_t tap_channel;
+    bool valid;
+    bool center;
+};
+
+int32_t DecodePackedI8(uint32_t packed, uint32_t shift)
+{
+    return bitfieldExtract(int32_t(packed), int32_t(shift), int32_t(8));
+}
+
+OffsetLutTap DecodePackedOffsetLutTap(uint32_t packed)
+{
+    OffsetLutTap tap;
+    tap.lr_offset = int32_t2(
+        DecodePackedI8(packed, uint32_t(0)),
+        DecodePackedI8(packed, uint32_t(8))
+    );
+    tap.tap_channel = int32_t((packed >> uint32_t(16)) & uint32_t(0x3F));
+    tap.valid = ((packed >> uint32_t(22)) & uint32_t(1)) != uint32_t(0);
+    tap.center = ((packed >> uint32_t(23)) & uint32_t(1)) != uint32_t(0);
+    return tap;
+}
+
+uint32_t4 LoadOffsetLutPacked4(int32_t lut_idx, int32_t group_idx)
+{
+    return texelFetch(_OffsetLutUint4Tex, int32_t2(group_idx, lut_idx), 0);
+}
+#endif // (NSS_FILTER_MODE == 2) || (NSS_FILTER_MODE == 3)
+
+//-----------------------------------------------------------------------------
+// Numeric helpers
+//-----------------------------------------------------------------------------
+half MaxHalf(half x)
+{
+    // Clamp to fp16 max to mimic storage/arith limits used in runtime.
+    return min(x, 65504.HF);
+}
+
+half3 MaxHalf(half3 x)
+{
+    return min(x, half3(65504.HF));
+}
+
+half4 MaxHalf(half4 x)
+{
+    return min(x, half4(65504.HF));
+}
+
+int32_t2 DecodeNearestOffset(int32_t2 pixel)
+{
+    // Decode packed nearest-depth offset from R8_UNORM or low-quality RG8 quad packing.
+    float norm_code = 0.0;
+#if NSS_INPUT_LAYOUT == 1
+    int32_t2 texel = clamp(
+        int32_t2(floor((float2(pixel) + float2(0.5)) * float2(_PreprocessDims) * _InvInputDims)),
+        int32_t2(0),
+        _PreprocessDims - int32_t2(1)
+    );
+    float2 norm_code_pair = texelFetch(_NearestDepthOffsetTex, texel, 0).rg;
+    int32_t lane_idx = (pixel.y & int32_t(1)) * int32_t(2) + (pixel.x & int32_t(1));
+    int32_t packed_byte = lane_idx < int32_t(2)
+        ? int32_t(norm_code_pair.x * 255.0 + 0.5)
+        : int32_t(norm_code_pair.y * 255.0 + 0.5);
+    int32_t packed_nibble = (lane_idx & int32_t(1)) == int32_t(0)
+        ? (packed_byte & 0xF)
+        : ((packed_byte >> 4) & 0xF);
+    return DecodeNearestDepthCoordNibble(packed_nibble);
+#else
+    // Use logical input domain (not physical image extent) so padded fragment
+    // outputs preserve compute-path sampling behaviour.
+    pixel = clamp(pixel, int32_t2(0), _InputDims - int32_t2(1));
+    norm_code = texelFetch(_NearestDepthOffsetTex, pixel, 0).r;
+#endif // NSS_INPUT_LAYOUT == 1
+    int32_t code = int32_t(norm_code * 255.0 + 0.5);
+    int32_t x = (code & 0x7) - 2;
+    int32_t y = ((code >> 3) & 0x7) - 2;
+    return int32_t2(x, y);
+}
+
+half2 LoadMotion(int32_t2 output_coord)
+{
+    // Reproject motion lookup using nearest-depth dilated coordinate.
+    int32_t2 input_coord = int32_t2(float2(output_coord) * _InvScale);
+    int32_t2 dilation_offset = DecodeNearestOffset(input_coord);
+    int32_t2 dilated_coord = clamp(input_coord + dilation_offset, int32_t2(0), _InputDims - int32_t2(1));
+
+    half2 v = half2(texelFetch(_MotionVectorTex, dilated_coord, 0).xy) * half2(_Scale);
+    if (kUseMotionThreshold) {
+        v *= half(dot(float2(v), float2(v)) > kMotionThresholdSq);
+    }
+    return v;
+}
+
+half3 LoadColourTap(int32_t2 lr_tap)
+{
+    return half3(texelFetch(_ColourTex, lr_tap, 0).rgb);
+}
+
+half4 LoadColourTap4(int32_t2 lr_tap)
+{
+    return half4(LoadColourTap(lr_tap), 1.HF);
+}
+
+int8_t ReadKpnParamsInt8(int32_t2 kpn_tap, int32_t channel);
+int8_t ReadKpnParamsInt8FromBase(int32_t kpn_texel_base_x, int32_t kpn_y, int32_t channel);
+
+int32_t KpnCoordFromInputCoord(int32_t input_coord, int32_t input_dim, int32_t kpn_dim)
+{
+    int32_t safe_input_dim = max(input_dim, int32_t(1));
+    return min((input_coord * kpn_dim) / safe_input_dim, kpn_dim - int32_t(1));
+}
+
+int16_t4 KpnCoordFromInputCoord4(int16_t4 input_coord, int32_t input_dim, int32_t kpn_dim)
+{
+    int32_t safe_input_dim = max(input_dim, int32_t(1));
+    int32_t4 scaled = (int32_t4(input_coord) * int32_t4(kpn_dim)) / int32_t4(safe_input_dim);
+    return int16_t4(min(scaled, int32_t4(kpn_dim - int32_t(1))));
+}
+
+int32_t KpnCoordFromScaledTap(int32_t tap_coord, float scale, int32_t kpn_dim)
+{
+    int32_t scaled = int32_t(floor((float(tap_coord) + 0.5 + 1e-3) * scale));
+    return min(scaled, kpn_dim - int32_t(1));
+}
+
+int16_t4 KpnCoordFromScaledTap4(int16_t4 tap_coord, float scale, int32_t kpn_dim)
+{
+    int32_t4 scaled = int32_t4(floor((float4(tap_coord) + float4(0.5 + 1e-3)) * float4(scale)));
+    return int16_t4(min(scaled, int32_t4(kpn_dim - int32_t(1))));
+}
+
+half SampleKpnWeight(int32_t tap_z, int32_t2 kpn_tap)
+{
+    // KPN comes from `1_nss` as an int8 tensor with `kKpnChannels` channels.
+    int8_t q = ReadKpnParamsInt8FromBase(kpn_tap.x, kpn_tap.y, tap_z);
+    return max(Dequantize(half(q), kKpnQuant), EPS);
+}
+
+half4 LoadWarpedHistory(float2 uv)
+{
+    return half4(texture(_HistoryTex, uv).rgb, 1.HF);
+}
+
+#if NSS_USE_HISTORY_CATMULL
+half4 LoadWarpedHistoryCatmull(float2 uv)
+{
+    //------------------------------------------------------------------------------------
+    // 1) Compute Catmull–Rom weights
+    //------------------------------------------------------------------------------------
+    float2 scaledUV = uv * _OutputDims;
+    float2 baseFloor = floor(scaledUV - 0.5) + 0.5;
+
+    half2 f  = half2(scaledUV - baseFloor);
+    half2 f2 = f * f;
+    half2 f3 = f2 * f;
+
+    // Catmull–Rom basis terms used by the 5-tap cross filter.
+    half2 w0 = f2 - 0.5HF * (f3 + f);
+    half2 w3 = 0.5HF * (f3 - f2);
+    half2 w2 = 0.5HF * f + f2 * (2.0HF - 1.5HF * f);
+    half2 w12 = 1.0HF + 0.5HF * f - 0.5HF * f2; // w1 + w2
+
+    // Keep axis-combination math in half2 to improve vector utilization.
+    half2 wx02 = half2(w0.x, w3.x); // left/right X weights
+    half2 wy02 = half2(w0.y, w3.y); // up/down Y weights
+    half2 w_ud = half2(w12.x) * wy02; // up, down
+    half2 w_lr = half2(w12.y) * wx02; // left, right
+    half wCenter = w12.x * w12.y;
+
+    // Fractional offsets for the center sample location.
+    half2 dxy = w2 / max(w12, half2(EPS));
+
+    //------------------------------------------------------------------------------------
+    // 2) Gather the 5 taps
+    //------------------------------------------------------------------------------------
+    float2 base_uv = baseFloor * _InvOutputDims;
+    float2 center_uv = base_uv + float2(dxy) * _InvOutputDims;
+    float left_x = base_uv.x - _InvOutputDims.x;
+    float right_x = base_uv.x + 2.0 * _InvOutputDims.x;
+    float up_y = base_uv.y - _InvOutputDims.y;
+    float down_y = base_uv.y + 2.0 * _InvOutputDims.y;
+
+    half4 left   = half4(texture(_HistoryTex, float2(left_x, center_uv.y)).rgb, 1.HF);
+    half4 up     = half4(texture(_HistoryTex, float2(center_uv.x, up_y)).rgb, 1.HF);
+    half4 center = half4(texture(_HistoryTex, center_uv).rgb, 1.HF);
+    half4 right  = half4(texture(_HistoryTex, float2(right_x, center_uv.y)).rgb, 1.HF);
+    half4 down   = half4(texture(_HistoryTex, float2(center_uv.x, down_y)).rgb, 1.HF);
+
+    //------------------------------------------------------------------------------------
+    // 3) Accumulate and track min/max
+    //------------------------------------------------------------------------------------
+    half4 accum = up    * w_ud.x  +
+                  left  * w_lr.x  +
+                  center* wCenter +
+                  right * w_lr.y  +
+                  down  * w_ud.y;
+    half4 cmin4 = min(up, min(left, min(center, min(right, down))));
+    half4 cmax4 = max(up, max(left, max(center, max(right, down))));
+
+    //------------------------------------------------------------------------------------
+    // 4) Final color
+    //------------------------------------------------------------------------------------
+    half3 color = accum.rgb * rcp(accum.w);
+
+    // dering in the case where we have negative values, we don't do this all the time
+    // as it can impose unnecessary blurring on the output
+    color = any(lessThan(color, half3(0.HF))) ? clamp(color, cmin4.rgb, cmax4.rgb) : color;
+    return half4(color, 1.HF);
+}
+#endif // NSS_USE_HISTORY_CATMULL
+
+half4 SampleKpnWeight4(int16_t4 tap_z, int16_t4 kpn_x, int16_t4 kpn_y)
+{
+    int8_t4 q = int8_t4(
+        ReadKpnParamsInt8FromBase(kpn_x.x, kpn_y.x, tap_z.x),
+        ReadKpnParamsInt8FromBase(kpn_x.y, kpn_y.y, tap_z.y),
+        ReadKpnParamsInt8FromBase(kpn_x.z, kpn_y.z, tap_z.z),
+        ReadKpnParamsInt8FromBase(kpn_x.w, kpn_y.w, tap_z.w)
+    );
+    return max(Dequantize(half4(q), kKpnQuant), half4(EPS));
+}
+
+#define NSS_SQ_MAT(_M)                                                                                   \
+    f16mat4x4(_M[0] * _M[0], _M[1] * _M[1], _M[2] * _M[2], _M[3] * _M[3])
+
+#define NSS_LOAD_TAPS_4(TAP_X, TAP_Y, OUT_MAT)                                                           \
+    {                                                                                                     \
+        OUT_MAT[0] = LoadColourTap4(int32_t2(TAP_X.x, TAP_Y.x));                                         \
+        OUT_MAT[1] = LoadColourTap4(int32_t2(TAP_X.y, TAP_Y.y));                                         \
+        OUT_MAT[2] = LoadColourTap4(int32_t2(TAP_X.z, TAP_Y.z));                                         \
+        OUT_MAT[3] = LoadColourTap4(int32_t2(TAP_X.w, TAP_Y.w));                                         \
+    }
+
+void NormalizeFilterMoments(
+    half4 accum_m1,
+    half4 accum_m2,
+    out half4 m1,
+    out half4 m2)
+{
+    half denom = max(accum_m1.a, EPS);
+    m1 = half4(accum_m1.rgb * rcp(denom), 0.HF);
+    m2 = half4(accum_m2.rgb * rcp(denom), 0.HF);
+}
+
+int32_t2 KpnCoordForDenseFilter(int32_t2 lr_tap, int32_t2 kpn_max)
+{
+#if NSS_INPUT_LAYOUT == 1
+    return clamp(
+        int32_t2(
+            KpnCoordFromInputCoord(lr_tap.x, _InputDims.x, _KpnDims.x),
+            KpnCoordFromInputCoord(lr_tap.y, _InputDims.y, _KpnDims.y)
+        ),
+        int32_t2(0),
+        kpn_max
+    );
+#else
+    return clamp(
+        int32_t2(
+            KpnCoordFromScaledTap(lr_tap.x, _KpnScale.x, _KpnDims.x),
+            KpnCoordFromScaledTap(lr_tap.y, _KpnScale.y, _KpnDims.y)
+        ),
+        int32_t2(0),
+        kpn_max
+    );
+#endif // NSS_INPUT_LAYOUT == 1
+}
+
+void KpnCoordsForDenseFilter4(
+    int16_t4 tap_x,
+    int16_t4 tap_y,
+    int16_t4 zero4,
+    int16_t4 kpn_max_x4,
+    int16_t4 kpn_max_y4,
+    out int16_t4 kpn_x,
+    out int16_t4 kpn_y)
+{
+#if NSS_INPUT_LAYOUT == 1
+    kpn_x = clamp(KpnCoordFromInputCoord4(tap_x, _InputDims.x, _KpnDims.x), zero4, kpn_max_x4);
+    kpn_y = clamp(KpnCoordFromInputCoord4(tap_y, _InputDims.y, _KpnDims.y), zero4, kpn_max_y4);
+#else
+    kpn_x = clamp(KpnCoordFromScaledTap4(tap_x, _KpnScale.x, _KpnDims.x), zero4, kpn_max_x4);
+    kpn_y = clamp(KpnCoordFromScaledTap4(tap_y, _KpnScale.y, _KpnDims.y), zero4, kpn_max_y4);
+#endif // NSS_INPUT_LAYOUT == 1
+}
+
+#if (NSS_FILTER_MODE == 2) || (NSS_FILTER_MODE == 3)
+int32_t2 PackedOffsetLutModulo()
+{
+    return max(int32_t2(_IdxModulo.y, _IdxModulo.x), int32_t2(1));
+}
+
+void AccumulatePackedLrOffsetTap(
+    OffsetLutTap lut_tap,
+    int32_t2 lr_base,
+    int32_t2 colour_max,
+    int32_t2 kpn_max,
+    inout half4 accum_m1,
+    inout half4 accum_m2,
+    inout half4 center_sample)
+{
+    if (!lut_tap.valid && !lut_tap.center) {
+        return;
+    }
+    int32_t2 lr_tap = clamp(lr_base + lut_tap.lr_offset, int32_t2(0), colour_max);
+    half4 tap_col = LoadColourTap4(lr_tap);
+    if (lut_tap.center) {
+        center_sample = tap_col;
+    }
+    if (!lut_tap.valid) {
+        return;
+    }
+    int32_t2 kpn_tap = KpnCoordForDenseFilter(lr_tap, kpn_max);
+    half tap_weight = SampleKpnWeight(lut_tap.tap_channel, kpn_tap);
+    accum_m1 += tap_col * tap_weight;
+    accum_m2 += (tap_col * tap_col) * tap_weight;
+}
+#endif // (NSS_FILTER_MODE == 2) || (NSS_FILTER_MODE == 3)
+
+#if NSS_FILTER_MODE == 2
+void FilterColour(
+    int32_t2 output_px,
+    out half4 m1,
+    out half4 m2,
+    out half4 center_sample)
+{
+    //-------------------------------------------------------------------------
+    // Non-integer fastest path: the LUT stores final LR offsets, tap channel,
+    // valid, and center bits. The LUT is generated on GPU and consumed as three
+    // RGBA32_UINT texels per modulo tile.
+    //-------------------------------------------------------------------------
+    int32_t2 colour_max = _InputDims - int32_t2(1);
+    int32_t2 kpn_max = _KpnDims - int32_t2(1);
+    int32_t2 idx_mod_xy = PackedOffsetLutModulo();
+    int32_t2 tile_idx = output_px % idx_mod_xy;
+    int32_t lut_idx = tile_idx.y * idx_mod_xy.x + tile_idx.x;
+    int32_t2 lr_base = int32_t2(floor(float2(output_px) * _InvScale));
+
+    half4 accum_m1 = half4(0.HF);
+    half4 accum_m2 = half4(0.HF);
+    center_sample = half4(0.HF);
+
+    uint32_t4 packed_taps0 = LoadOffsetLutPacked4(lut_idx, int32_t(0));
+    AccumulatePackedLrOffsetTap(
+        DecodePackedOffsetLutTap(packed_taps0.x), lr_base, colour_max, kpn_max, accum_m1, accum_m2, center_sample
+    );
+    AccumulatePackedLrOffsetTap(
+        DecodePackedOffsetLutTap(packed_taps0.y), lr_base, colour_max, kpn_max, accum_m1, accum_m2, center_sample
+    );
+    AccumulatePackedLrOffsetTap(
+        DecodePackedOffsetLutTap(packed_taps0.z), lr_base, colour_max, kpn_max, accum_m1, accum_m2, center_sample
+    );
+    AccumulatePackedLrOffsetTap(
+        DecodePackedOffsetLutTap(packed_taps0.w), lr_base, colour_max, kpn_max, accum_m1, accum_m2, center_sample
+    );
+
+    uint32_t4 packed_taps1 = LoadOffsetLutPacked4(lut_idx, int32_t(1));
+    AccumulatePackedLrOffsetTap(
+        DecodePackedOffsetLutTap(packed_taps1.x), lr_base, colour_max, kpn_max, accum_m1, accum_m2, center_sample
+    );
+    AccumulatePackedLrOffsetTap(
+        DecodePackedOffsetLutTap(packed_taps1.y), lr_base, colour_max, kpn_max, accum_m1, accum_m2, center_sample
+    );
+    AccumulatePackedLrOffsetTap(
+        DecodePackedOffsetLutTap(packed_taps1.z), lr_base, colour_max, kpn_max, accum_m1, accum_m2, center_sample
+    );
+    AccumulatePackedLrOffsetTap(
+        DecodePackedOffsetLutTap(packed_taps1.w), lr_base, colour_max, kpn_max, accum_m1, accum_m2, center_sample
+    );
+
+    uint32_t4 packed_taps2 = LoadOffsetLutPacked4(lut_idx, int32_t(2));
+    AccumulatePackedLrOffsetTap(
+        DecodePackedOffsetLutTap(packed_taps2.x), lr_base, colour_max, kpn_max, accum_m1, accum_m2, center_sample
+    );
+
+    NormalizeFilterMoments(accum_m1, accum_m2, m1, m2);
+}
+#endif // NSS_FILTER_MODE == 2
+
+#if NSS_FILTER_MODE == 3
+int16_t4 DecodePackedI8x4(uint32_t4 packed, uint32_t shift)
+{
+    return int16_t4(bitfieldExtract(int32_t4(packed), int32_t(shift), int32_t(8)));
+}
+
+int16_t4 DecodePackedTapChannel4(uint32_t4 packed)
+{
+    return int16_t4((packed >> uint32_t4(16)) & uint32_t4(0x3F));
+}
+
+half4 DecodePackedValidMask4(uint32_t4 packed)
+{
+    return half4((packed >> uint32_t4(22)) & uint32_t4(1));
+}
+
+void FilterColour(
+    int32_t2 output_px,
+    out half4 m1,
+    out half4 m2,
+    out half4 center_sample)
+{
+    //-------------------------------------------------------------------------
+    // Non-integer sparse path: one RGBA32_UINT LUT texel stores the 4 selected
+    // 2x2 taps for the modulo tile. The tap payload is identical to the dense
+    // dynamic path, but the generator has already pruned the 4x4 KPN window.
+    //-------------------------------------------------------------------------
+    int32_t2 colour_max = _InputDims - int32_t2(1);
+    int32_t2 kpn_max = _KpnDims - int32_t2(1);
+    int32_t2 idx_mod_xy = PackedOffsetLutModulo();
+    int32_t2 tile_idx = output_px % idx_mod_xy;
+    int32_t lut_idx = tile_idx.y * idx_mod_xy.x + tile_idx.x;
+    int32_t2 lr_base = int32_t2(floor(float2(output_px) * _InvScale));
+
+    half4 accum_m1 = half4(0.HF);
+    half4 accum_m2 = half4(0.HF);
+    center_sample = half4(0.HF);
+
+    uint32_t4 packed_taps = LoadOffsetLutPacked4(lut_idx, int32_t(0));
+    int32_t4 lr_tap_x = clamp(
+        int32_t4(lr_base.x) + int32_t4(DecodePackedI8x4(packed_taps, uint32_t(0))),
+        int32_t4(0),
+        int32_t4(colour_max.x)
+    );
+    int32_t4 lr_tap_y = clamp(
+        int32_t4(lr_base.y) + int32_t4(DecodePackedI8x4(packed_taps, uint32_t(8))),
+        int32_t4(0),
+        int32_t4(colour_max.y)
+    );
+    int16_t4 tap_x = int16_t4(lr_tap_x);
+    int16_t4 tap_y = int16_t4(lr_tap_y);
+    int16_t4 kpn_x;
+    int16_t4 kpn_y;
+    KpnCoordsForDenseFilter4(
+        tap_x,
+        tap_y,
+        int16_t4(0),
+        int16_t4(kpn_max.x),
+        int16_t4(kpn_max.y),
+        kpn_x,
+        kpn_y
+    );
+
+    f16mat4x4 taps;
+    NSS_LOAD_TAPS_4(tap_x, tap_y, taps);
+    half4 weights = SampleKpnWeight4(DecodePackedTapChannel4(packed_taps), kpn_x, kpn_y);
+    weights *= DecodePackedValidMask4(packed_taps);
+
+    uint32_t4 center_bits = (packed_taps >> uint32_t4(23)) & uint32_t4(1);
+    if (center_bits.x != uint32_t(0)) {
+        center_sample = taps[0];
+    } else if (center_bits.y != uint32_t(0)) {
+        center_sample = taps[1];
+    } else if (center_bits.z != uint32_t(0)) {
+        center_sample = taps[2];
+    } else if (center_bits.w != uint32_t(0)) {
+        center_sample = taps[3];
+    }
+    accum_m1 += taps * weights;
+    accum_m2 += NSS_SQ_MAT(taps) * weights;
+
+    NormalizeFilterMoments(accum_m1, accum_m2, m1, m2);
+}
+#endif // NSS_FILTER_MODE == 3
+
+#if NSS_FILTER_MODE == 1
+void FilterColour(
+    int32_t2 output_px,
+    out half4 m1,
+    out half4 m2,
+    out half4 center_sample)
+{
+    //-------------------------------------------------------------------------
+    // Mid-quality path: sparse 2x2 subset of the 6x6 KPN.
+    //-------------------------------------------------------------------------
+    int32_t2 colour_max = _InputDims - int32_t2(1);
+    int32_t2 kpn_max = _KpnDims - int32_t2(1);
+    int16_t4 colour_max_x4 = int16_t4(colour_max.x);
+    int16_t4 colour_max_y4 = int16_t4(colour_max.y);
+    int16_t4 kpn_max_x4 = int16_t4(kpn_max.x);
+    int16_t4 kpn_max_y4 = int16_t4(kpn_max.y);
+    int16_t4 zero4 = int16_t4(0);
+    int16_t2 out_px16 = int16_t2(output_px);
+    int32_t2 tile_idx = (output_px + _LutOffset) & int32_t2(1);
+    int32_t lut_idx = (tile_idx.y << int32_t(1)) + tile_idx.x;
+
+    half4 accum_m1 = half4(0.HF);
+    half4 accum_m2 = half4(0.HF);
+
+    int16_t4 tap_x = clamp((int16_t4(out_px16.x) + kTap2x2Dx[lut_idx]) >> int16_t(1), zero4, colour_max_x4);
+    int16_t4 tap_y = clamp((int16_t4(out_px16.y) + kTap2x2Dy[lut_idx]) >> int16_t(1), zero4, colour_max_y4);
+    int16_t4 kpn_x = clamp(KpnCoordFromInputCoord4(tap_x, _InputDims.x, _KpnDims.x), zero4, kpn_max_x4);
+    int16_t4 kpn_y = clamp(KpnCoordFromInputCoord4(tap_y, _InputDims.y, _KpnDims.y), zero4, kpn_max_y4);
+
+    f16mat4x4 taps;
+    NSS_LOAD_TAPS_4(tap_x, tap_y, taps);
+    half4 weights = SampleKpnWeight4(kTap2x2Ch[lut_idx], kpn_x, kpn_y);
+    center_sample = (lut_idx == int32_t(3)) ? taps[0] : half4(0.HF);
+    accum_m1 += taps * weights;
+    accum_m2 += NSS_SQ_MAT(taps) * weights;
+
+    NormalizeFilterMoments(accum_m1, accum_m2, m1, m2);
+}
+#endif // NSS_FILTER_MODE == 1
+
+#if NSS_FILTER_MODE == 0
+void FilterColour(
+    int32_t2 output_px,
+    out half4 m1,
+    out half4 m2,
+    out half4 center_sample)
+{
+    //-------------------------------------------------------------------------
+    // High-quality 2x path: static generated 6x6 KPN tap pattern.
+    //-------------------------------------------------------------------------
+    int32_t2 colour_max = _InputDims - int32_t2(1);
+    int32_t2 kpn_max = _KpnDims - int32_t2(1);
+    int16_t4 colour_max_x4 = int16_t4(colour_max.x);
+    int16_t4 colour_max_y4 = int16_t4(colour_max.y);
+    int16_t4 kpn_max_x4 = int16_t4(kpn_max.x);
+    int16_t4 kpn_max_y4 = int16_t4(kpn_max.y);
+    int16_t4 zero4 = int16_t4(0);
+    int16_t2 out_px16 = int16_t2(output_px);
+    int32_t2 tile_idx = (output_px + _LutOffset) & int32_t2(1);
+    int32_t lut_idx = (tile_idx.y << int32_t(1)) + tile_idx.x;
+
+    half4 accum_m1 = half4(0.HF);
+    half4 accum_m2 = half4(0.HF);
+    center_sample = half4(0.HF);
+    KernelPattern lut = kKernelLut[lut_idx];
+
+    int16_t4 tap_x0 = clamp((int16_t4(out_px16.x + lut.base_offset.x) + kTapDx0) >> int16_t(1), zero4, colour_max_x4);
+    int16_t4 tap_y0 = clamp((int16_t4(out_px16.y + lut.base_offset.y) + kTapDy0) >> int16_t(1), zero4, colour_max_y4);
+    int16_t4 kpn_x0;
+    int16_t4 kpn_y0;
+    KpnCoordsForDenseFilter4(tap_x0, tap_y0, zero4, kpn_max_x4, kpn_max_y4, kpn_x0, kpn_y0);
+
+    f16mat4x4 taps0;
+    NSS_LOAD_TAPS_4(tap_x0, tap_y0, taps0);
+    half4 w0 = SampleKpnWeight4(kTapCh0 + int16_t4(lut.base_channel), kpn_x0, kpn_y0);
+    accum_m1 += taps0 * w0;
+    accum_m2 += NSS_SQ_MAT(taps0) * w0;
+
+    int16_t4 tap_x1 = clamp((int16_t4(out_px16.x + lut.base_offset.x) + kTapDx1) >> int16_t(1), zero4, colour_max_x4);
+    int16_t4 tap_y1 = clamp((int16_t4(out_px16.y + lut.base_offset.y) + kTapDy1) >> int16_t(1), zero4, colour_max_y4);
+    int16_t4 kpn_x1;
+    int16_t4 kpn_y1;
+    KpnCoordsForDenseFilter4(tap_x1, tap_y1, zero4, kpn_max_x4, kpn_max_y4, kpn_x1, kpn_y1);
+
+    f16mat4x4 taps1;
+    NSS_LOAD_TAPS_4(tap_x1, tap_y1, taps1);
+    half4 w1 = SampleKpnWeight4(kTapCh1 + int16_t4(lut.base_channel), kpn_x1, kpn_y1);
+    center_sample = (lut_idx == int32_t(3)) ? taps1[0] : half4(0.HF);
+    accum_m1 += taps1 * w1;
+    accum_m2 += NSS_SQ_MAT(taps1) * w1;
+
+    int32_t2 tap2 = output_px + int32_t2(lut.base_offset) + int32_t2(kTapD2);
+    int32_t2 lr_tap2 = clamp(tap2 >> int32_t(1), int32_t2(0), colour_max);
+    int32_t2 kpn_tap2 = KpnCoordForDenseFilter(lr_tap2, kpn_max);
+    half4 tap2_col = LoadColourTap4(lr_tap2);
+    half tap2_w = SampleKpnWeight(int32_t(lut.base_channel + kTapCh2), kpn_tap2);
+    accum_m1 += tap2_col * tap2_w;
+    accum_m2 += (tap2_col * tap2_col) * tap2_w;
+
+    NormalizeFilterMoments(accum_m1, accum_m2, m1, m2);
+}
+#endif // NSS_FILTER_MODE == 0
+
+#undef NSS_LOAD_TAPS_4
+#undef NSS_SQ_MAT
+
+void SampleTemporalParams(float2 uv, out half theta, out half alpha, out half gamma)
+{
+    // Temporal params live over the logical preprocess domain and may be backed
+    // by a padded image in the scenario runtime.
+    float2 uv_temporal = uv * _PaddedUvScale;
+    half4 params = Dequantize(half4(textureLod(_TemporalTensor, uv_temporal, 0.0)), kTemporalQuant);
+#if NSS_V1_SHARP_THETA
+    half theta_in = clamp(params.x, 0.HF, 1.HF);
+    half theta_inv = 1.HF - theta_in;
+    half theta_a = theta_in * theta_in;
+    half theta_b = theta_inv * theta_inv;
+    theta = theta_a * rcp(max(theta_a + theta_b, 1e-6HF));
+#else
+    theta = params.x;
+#endif // NSS_V1_SHARP_THETA
+    alpha = params.y * 0.35HF + 0.05HF;
+    gamma = params.z * 2.0HF;
+}
+
+void WarpHistory(
+    int32_t2 output_px,
+    float2 uv,
+    out half4 warped_colour,
+    out half onscreen)
+{
+    // Reproject history with motion; report if sample stayed on-screen.
+    half2 motion = LoadMotion(output_px);
+    float2 reproj_uv = uv - (float2(motion) * _InvOutputDims);
+    onscreen = half(all(greaterThanEqual(reproj_uv, float2(0.0))) && all(lessThanEqual(reproj_uv, float2(1.0))));
+#if NSS_USE_HISTORY_CATMULL
+    warped_colour = LoadWarpedHistoryCatmull(reproj_uv);
+#else
+    warped_colour = LoadWarpedHistory(reproj_uv);
+#endif // NSS_USE_HISTORY_CATMULL
+}
+
+void ClampHistoryToStats(
+    half4 m1,
+    half4 m2,
+    half4 warped_history,
+    half theta,
+    half gamma,
+    half reset,
+    half onscreen,
+    out half4 rectified)
+{
+    //-------------------------------------------------------------------------
+    // Statistical clamp (AABB):
+    // Clamp reprojected history using local filtered moments to reduce ghosts.
+    //-------------------------------------------------------------------------
+    half4 sigma_4 = sqrt(max(abs(m2 - m1 * m1), half4(EPS))) * half4(gamma);
+    sigma_4.a = 0.HF;
+    half4 aabb_min = m1 - sigma_4;
+    half4 aabb_max = m1 + sigma_4;
+    half4 history_clamped = mix(m1, clamp(warped_history, aabb_min, aabb_max), half4(reset));
+    rectified = mix(history_clamped, warped_history, half4(theta * onscreen * reset));
+}
+
+half3 ClampToInvertibleRange(half3 accumulated, half inv_exposure)
+{
+    // Keep value within invertible Karis range, then restore linear domain.
+    half3 clamped_output = clamp(accumulated, half3(0.HF), half3(1.HF - EPS));
+    return SafeColour(MaxHalf(InverseTonemap(clamped_output) * half3(inv_exposure)));
+}
+
+half4 Tonemap4(half4 x)
+{
+    x = clamp(x, half4(0.HF), half4(MAX_FP16));
+    half m = max(max(x.r, x.g), x.b);
+    return x * rcp(half4(1.HF + m));
+}
+
+half3 SimulateR11G11B10Precision(half3 rgb)
+{
+    const float epsilon = 1e-12;
+    const int32_t3 m_bits = int32_t3(6, 6, 5);
+    const int32_t exp_bits = 5;
+    const float3 bias = float3((1 << (exp_bits - 1)) - 1); // 15.0
+    const float3 exp_max = float3((1 << exp_bits) - 1);
+
+    float3 val = max(float3(rgb), float3(epsilon));
+    float3 exp_unclamped = floor(log2(val));
+    float3 exp_clipped = clamp(exp_unclamped, -bias, bias + 1.0);
+    float3 mant = val / exp2(exp_clipped) - 1.0;
+
+    float3 scale = float3(int32_t3(1) << m_bits);
+    float3 rgb_exp = clamp(exp_clipped + bias, float3(0.0), exp_max) - bias;
+    float3 rgb_mant = clamp(round(mant * scale), float3(0.0), scale - 1.0) / scale;
+    float3 rgb_out = (1.0 + rgb_mant) * exp2(rgb_exp);
+    return half3(rgb_out);
+}
+
+void WriteColourOutTarget(int32_t2 coord, half3 out_linear);
+
+void WriteColourOut(int32_t2 coord, half3 out_linear)
+{
+    half3 to_write = SafeColour(out_linear);
+#ifdef SIMULATE_R11G11B10_BEFORE_WRITE
+    to_write = SimulateR11G11B10Precision(to_write);
+#endif // SIMULATE_R11G11B10_BEFORE_WRITE
+    WriteColourOutTarget(coord, to_write);
+}
+
+void PostProcessMain(int32_t2 output_px)
+{
+    //-------------------------------------------------------------------------
+    // 1) Per-pixel setup
+    //-------------------------------------------------------------------------
+    half exposure = half(_Exposure.x);
+    half reset = half(_Reset);
+    float2 uv = (float2(output_px) + float2(0.5)) * _InvOutputDims;
+
+    //-------------------------------------------------------------------------
+    // 2) Spatial filtering (KPN) + local moments
+    //-------------------------------------------------------------------------
+    half4 m1;
+    half4 m2;
+    half4 center_sample;
+    FilterColour(output_px, m1, m2, center_sample);
+
+    //-------------------------------------------------------------------------
+    // 3) Read temporal controls and reproject history
+    //-------------------------------------------------------------------------
+    half theta;
+    half alpha;
+    half gamma;
+    SampleTemporalParams(uv, theta, alpha, gamma);
+
+    half4 warped_colour;
+    half onscreen;
+    WarpHistory(output_px, uv, warped_colour, onscreen);
+
+    //-------------------------------------------------------------------------
+    // 4) Clamp and rectify history
+    //-------------------------------------------------------------------------
+    half4 rectified;
+    ClampHistoryToStats(
+        m1,
+        m2,
+        warped_colour,
+        theta,
+        gamma,
+        reset,
+        onscreen,
+        rectified
+    );
+
+    //-------------------------------------------------------------------------
+    // 5) Tonemapped accumulation
+    //-------------------------------------------------------------------------
+    half4 rectified_tm4 = Tonemap4(MaxHalf(rectified * half4(exposure)));
+    half learnt_masked_alpha = alpha * center_sample.a * reset;
+    half4 colour_to_accum_tm4 = Tonemap4(MaxHalf(center_sample * half4(exposure)));
+    half4 accumulated4 = mix(rectified_tm4, colour_to_accum_tm4, half4(learnt_masked_alpha));
+
+    //-------------------------------------------------------------------------
+    // 6) Convert back to linear and write outputs
+    //-------------------------------------------------------------------------
+    half3 out_linear = ClampToInvertibleRange(accumulated4.rgb, half(_Exposure.y));
+    WriteColourOut(output_px, out_linear);
+}
+
+#endif // NSS_V1_POST_PROCESS_SHARED_H

scenario/assets/960x540_1920x1080/0_depth_scatter_push_consts__960x540_1920x1080_high_fragment.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5af43f7973aabf48a32e0eaa413aec53b80eec0193be3273f49503604a9ec56e
+size 168

scenario/assets/960x540_1920x1080/0_depth_scatter_push_consts__960x540_1920x1080_low_fragment.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bdffbf5e316c94c1d932c88fcb7ed1f99feb8463fedeff8f436c253c9e6080b2
+size 168

scenario/assets/960x540_1920x1080/0_depth_scatter_push_consts__960x540_1920x1080_mid_fragment.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bdffbf5e316c94c1d932c88fcb7ed1f99feb8463fedeff8f436c253c9e6080b2
+size 168

scenario/assets/960x540_1920x1080/1_pre_process_push_consts__960x540_1920x1080_high_fragment.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:54dffde79c845b0b63fc437649b8a9ffbb2ed931aa794d55245c740e745988de
+size 272

scenario/assets/960x540_1920x1080/1_pre_process_push_consts__960x540_1920x1080_low_fragment.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:009d3c0ebc92d895d527c2238fd7a27f34cae91ebc1e27d2f6988f9209a101fb
+size 272

scenario/assets/960x540_1920x1080/1_pre_process_push_consts__960x540_1920x1080_mid_fragment.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:009d3c0ebc92d895d527c2238fd7a27f34cae91ebc1e27d2f6988f9209a101fb
+size 272

scenario/assets/960x540_1920x1080/2_nss-480x270-kpn16-v1_0_1.vgf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:27adc4c836c6f5c872fc5a09ed360a194ff4c5fae1ec395d34bcc1ad29bf5f39
+size 159792

scenario/assets/960x540_1920x1080/2_nss-960x540-v1_0_1.vgf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6c3ac39dd496d28d8b0f3bb54cd8314d73ad95cc78f46c825cd0a19ad179b9f5
+size 165696

scenario/assets/960x540_1920x1080/3_post_process_push_consts__960x540_1920x1080_high_fragment.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:22055216bafa3df6cd1077480c68d446c2a8f2522f3e8c9e78a286a4229bda3d
+size 248

scenario/assets/960x540_1920x1080/3_post_process_push_consts__960x540_1920x1080_low_fragment.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e0d679a75e48023959d6c70f8691dfe5d90687c91cc18d25700b38127a9f957
+size 248

scenario/assets/960x540_1920x1080/3_post_process_push_consts__960x540_1920x1080_mid_fragment.npy

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5e0d679a75e48023959d6c70f8691dfe5d90687c91cc18d25700b38127a9f957
+size 248

scenario/common.h

@@ -4,13 +4,14 @@
 // confidential and may only be used by an authorized person under a valid
 // licensing agreement from Arm Limited or its affiliates.
 //
-// Copyright (C) 2025. Arm Limited or its affiliates. All rights reserved.
+// Copyright (C) 2026 Arm Limited or its affiliates. All rights reserved.
 //
 // This entire notice must be reproduced on all copies of this file and
 // copies of this file may only be made by an authorized person under a valid
 // licensing agreement from Arm Limited or its affiliates.
 // -----------------------------------------------------------------------------
 //
+
 #ifndef NSS_COMMON
 #define NSS_COMMON
 
@@ -19,142 +20,96 @@
 #define MAX_FP16 65504.HF
 #define EPS 1e-7HF
 
-
 // Activation Functions
-// ──────────────────────────────────────────────────────────────────────────────────────────
-
-
-half Sigmoid(half x)
-{
-    return rcp(half(1.0) + exp(-x));
-}
-
-
-half2 Sigmoid(half2 x)
-{
-    return rcp(half2(1.0) + exp(-x));
-}
-
-
-half3 Sigmoid(half3 x)
-{
-    return rcp(half3(1.0) + exp(-x));
-}
-
-
-half4 Sigmoid(half4 x)
-{
-    return rcp(half4(1.0) + exp(-x));
-}
-
-
-// Quantize/Dequantize 
-// ──────────────────────────────────────────────────────────────────────────────────────────
-// all expect .x = scale, .y = zero point, quantize methods expect to receive: .x = rcp(scale)
-
-half Dequantize(half i, half2 quant_params)
-{
-    return (i - quant_params.y) * quant_params.x;
-}
-
-
-half2 Dequantize(half2 i, half2 quant_params)
-{
-    return (i - quant_params.y) * quant_params.x;
-}
-
-
-half3 Dequantize(half3 i, half2 quant_params)
-{
-    return (i - quant_params.y) * quant_params.x;
-}
-
-
-half4 Dequantize(half4 i, half2 quant_params)
-{
-    return (i - quant_params.y) * quant_params.x;
-}
-
+// -----------------------------------------------------------------------------
+half Sigmoid(half x)   { return rcp(half(1.0) + exp(-x)); }
+half2 Sigmoid(half2 x) { return rcp(half2(1.0) + exp(-x)); }
+half3 Sigmoid(half3 x) { return rcp(half3(1.0) + exp(-x)); }
+half4 Sigmoid(half4 x) { return rcp(half4(1.0) + exp(-x)); }
 
-int8_t Quantize(half f, half2 quant_params)
+// Quantize/Dequantize
+// -----------------------------------------------------------------------------
+// all expect .x = scale, .y = zero point
+half Dequantize(half i, half2 quant_params)   { return (i - quant_params.y) * quant_params.x; }
+half2 Dequantize(half2 i, half2 quant_params) { return (i - quant_params.y) * quant_params.x; }
+half3 Dequantize(half3 i, half2 quant_params) { return (i - quant_params.y) * quant_params.x; }
+half4 Dequantize(half4 i, half2 quant_params) { return (i - quant_params.y) * quant_params.x; }
+
+int8_t Quantize(half f, half2 quant_params)   { return int8_t(f * quant_params.x + quant_params.y); }
+int8_t2 Quantize(half2 f, half2 quant_params) { return int8_t2(f * quant_params.x + quant_params.y); }
+int8_t3 Quantize(half3 f, half2 quant_params) { return int8_t3(f * quant_params.x + quant_params.y); }
+int8_t4 Quantize(half4 f, half2 quant_params) { return int8_t4(f * quant_params.x + quant_params.y); }
+
+// Encode/Decode
+// -----------------------------------------------------------------------------
+uint8_t EncodeNearestDepthCoord(int32_t2 o)
 {
-    return int8_t(clamp(round(f * quant_params.x + quant_params.y), -128.HF, 127.HF));
+    // o in {-2, -1, 0, +1, +2}^2
+    o = clamp(o, int32_t2(-2), int32_t2(2));
+    return uint8_t(((o.y + 2) << 3) | (o.x + 2)); // 0-24
 }
 
-
-int8_t2 Quantize(half2 f, half2 quant_params)
+int32_t2 DecodeNearestDepthCoord(int32_t code)
 {
-    return int8_t2(clamp(round(f * quant_params.x + quant_params.y), -128.HF, 127.HF));
+    int32_t x = int32_t(code & 0x7) - 2;        // bits 0-2
+    int32_t y = int32_t((code >> 3) & 0x7) - 2; // bits 3-5
+    return int32_t2(x, y);
 }
 
-
-int8_t3 Quantize(half3 f, half2 quant_params)
+uint8_t EncodeNearestDepthCoordNibble(int32_t2 o)
 {
-    return int8_t3(clamp(round(f * quant_params.x + quant_params.y), -128.HF, 127.HF));
+    // The packed low-quality quad path only emits offsets inside the current
+    // 4x4 search footprint: {-1, 0, +1, +2}^2.
+    o = clamp(o, int32_t2(-1), int32_t2(2));
+    return uint8_t(((o.y + 1) << 2) | (o.x + 1)); // 0-15
 }
 
-
-int8_t4 Quantize(half4 f, half2 quant_params)
+int32_t2 DecodeNearestDepthCoordNibble(int32_t code)
 {
-    return int8_t4(clamp(round(f * quant_params.x + quant_params.y), -128.HF, 127.HF));
+    int32_t x = int32_t(code & 0x3) - 1;        // bits 0-1
+    int32_t y = int32_t((code >> 2) & 0x3) - 1; // bits 2-3
+    return int32_t2(x, y);
 }
 
-
-// Encode/Decode 
-// ─────────────────────────────────────���────────────────────────────────────────────────────
-// Note: both encode/decode methods are currently bound to 3x3 windows, they should be 
-//       expandable in future if needed. The most likely to need this would be the jitter
-//       encoding, where 3x3 may not be enough for larger than 3x3 scale factors.
-
-
-uint8_t EncodeNearestDepthCoord(int32_t2 o)
+uint8_t EncodeJitterOffset(int32_t2 offset)
 {
-    // o ∈ {-1, 0, 1}²
-    o  = clamp(o, ivec2(-1), ivec2( 1));
-    return uint8_t((o.y + 1) << 2 | (o.x + 1));  // 0-15
+    uint8_t col = uint8_t(offset.x + 1);
+    uint8_t row = uint8_t(offset.y + 1);
+    return uint8_t(row * 3 + col + 1); // reserve 0 for holes
 }
 
-
-int32_t2 DecodeNearestDepthCoord(int32_t code)
+int32_t2 DecodeJitterOffset(uint8_t c8)
 {
-    int32_t x = int32_t( code       & 0x3) - 1;  // bits 0-1
-    int32_t y = int32_t((code >> 2) & 0x3) - 1;  // bits 2-3
+    uint8_t c = uint8_t(c8);
+    uint8_t mask = uint8_t(c != 0u);
+    uint8_t idx = (c - uint8_t(1)) * mask;
+    int32_t x = int32_t(idx % 3u) - int32_t(mask);
+    int32_t y = int32_t(idx / 3u) - int32_t(mask);
     return int32_t2(x, y);
 }
 
-
 // Image Operations
-// ──────────────────────────────────────────────────────────────────────────────────────────
-
+// -----------------------------------------------------------------------------
 half Luminance(half3 rgb)
 {
-    // ITU-R BT.709: `0.2126 * R + 0.7152 * G + 0.0722 * B`
     return dot(rgb, half3(0.2126, 0.7152, 0.0722));
 }
 
-
 half3 Tonemap(half3 x)
 {
-    // Karis tonemapper
-    // http://graphicrants.blogspot.com/2013/12/tone-mapping.html
-    x = max(x, half3(0.HF));
+    x = clamp(x, half3(0.HF), half3(MAX_FP16));
     return x * rcp(half3(1.HF) + max(max(x.r, x.g), x.b));
 }
 
-
 half3 InverseTonemap(half3 x)
 {
-    // Karis tonemapper inverse
-    // http://graphicrants.blogspot.com/2013/12/tone-mapping.html
-    x = clamp(x, half3(0.HF), Tonemap(half3(MAX_FP16)));
+    x = clamp(x, half3(0.HF), half3(1.HF - EPS));
     return x * rcp(half3(1.HF) - max(max(x.r, x.g), x.b));
 }
 
-
 half3 SafeColour(half3 x)
 {
     return clamp(x, half3(0.HF), half3(MAX_FP16));
 }
 
-
 #endif // NSS_COMMON

scenario/configs/960x540_1920x1080_high_fragment.json

@@ -0,0 +1,722 @@
+{
+    "commands": [
+        {
+            "dispatch_compute": {
+                "shader_ref": "0_depth_scatter_init",
+                "rangeND": [
+                    60,
+                    34,
+                    1
+                ],
+                "implicit_barrier": false,
+                "bindings": [
+                    {
+                        "set": 0,
+                        "id": 0,
+                        "resource_ref": "out_depth_scatter",
+                        "descriptor_type": "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE"
+                    }
+                ],
+                "push_data_ref": "push_data_0"
+            }
+        },
+        {
+            "dispatch_barrier": {
+                "image_barrier_refs": [
+                    "barrier_depth_init_to_scatter"
+                ],
+                "tensor_barrier_refs": [],
+                "memory_barrier_refs": [],
+                "buffer_barrier_refs": []
+            }
+        },
+        {
+            "dispatch_compute": {
+                "shader_ref": "0_depth_scatter",
+                "rangeND": [
+                    60,
+                    34,
+                    1
+                ],
+                "implicit_barrier": false,
+                "bindings": [
+                    {
+                        "set": 0,
+                        "id": 0,
+                        "resource_ref": "in_motion"
+                    },
+                    {
+                        "set": 0,
+                        "id": 1,
+                        "resource_ref": "in_depth"
+                    },
+                    {
+                        "set": 1,
+                        "id": 0,
+                        "resource_ref": "out_depth_scatter",
+                        "descriptor_type": "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE"
+                    }
+                ],
+                "push_data_ref": "push_data_0"
+            }
+        },
+        {
+            "dispatch_barrier": {
+                "image_barrier_refs": [
+                    "barrier_depth_to_pre"
+                ],
+                "tensor_barrier_refs": [],
+                "memory_barrier_refs": [],
+                "buffer_barrier_refs": []
+            }
+        },
+        {
+            "dispatch_fragment": {
+                "vertex_shader_ref": "fullscreen_triangle_vert",
+                "fragment_shader_ref": "1_pre_process_frag",
+                "bindings": [
+                    {
+                        "set": 0,
+                        "id": 0,
+                        "resource_ref": "in_colour"
+                    },
+                    {
+                        "set": 0,
+                        "id": 1,
+                        "resource_ref": "in_depth"
+                    },
+                    {
+                        "set": 0,
+                        "id": 2,
+                        "resource_ref": "in_motion"
+                    },
+                    {
+                        "set": 0,
+                        "id": 3,
+                        "resource_ref": "in_history"
+                    },
+                    {
+                        "set": 0,
+                        "id": 4,
+                        "resource_ref": "in_temporal_tm1"
+                    },
+                    {
+                        "set": 0,
+                        "id": 5,
+                        "resource_ref": "out_depth_scatter"
+                    },
+                    {
+                        "set": 0,
+                        "id": 6,
+                        "resource_ref": "in_derivative_tm1"
+                    },
+                    {
+                        "set": 1,
+                        "id": 0,
+                        "resource_ref": "out_input_tensor_buffer"
+                    }
+                ],
+                "implicit_barrier": false,
+                "debug_name": "1_pre_process_frag",
+                "color_attachment_refs": [
+                    "out_derivative",
+                    "out_nearest_depth_offset"
+                ],
+                "render_extent": [
+                    960,
+                    544
+                ],
+                "push_data_ref": "push_data_1"
+            }
+        },
+        {
+            "dispatch_barrier": {
+                "image_barrier_refs": [],
+                "tensor_barrier_refs": [],
+                "memory_barrier_refs": [],
+                "buffer_barrier_refs": [
+                    "barrier_pre_to_graph"
+                ]
+            }
+        },
+        {
+            "dispatch_graph": {
+                "graph_ref": "2_nss",
+                "implicit_barrier": false,
+                "bindings": [
+                    {
+                        "set": 0,
+                        "id": 0,
+                        "resource_ref": "out_input_tensor"
+                    },
+                    {
+                        "set": 0,
+                        "id": 1,
+                        "resource_ref": "out_graph_0"
+                    },
+                    {
+                        "set": 0,
+                        "id": 2,
+                        "resource_ref": "out_graph_1"
+                    }
+                ]
+            }
+        },
+        {
+            "dispatch_barrier": {
+                "image_barrier_refs": [
+                    "barrier_offset_to_post",
+                    "barrier_temporal_to_post"
+                ],
+                "tensor_barrier_refs": [],
+                "memory_barrier_refs": [],
+                "buffer_barrier_refs": [
+                    "barrier_graph0_buf_to_post"
+                ]
+            }
+        },
+        {
+            "dispatch_fragment": {
+                "vertex_shader_ref": "fullscreen_triangle_vert",
+                "fragment_shader_ref": "3_post_process_frag",
+                "bindings": [
+                    {
+                        "set": 0,
+                        "id": 0,
+                        "resource_ref": "in_colour"
+                    },
+                    {
+                        "set": 0,
+                        "id": 1,
+                        "resource_ref": "in_history"
+                    },
+                    {
+                        "set": 0,
+                        "id": 2,
+                        "resource_ref": "out_graph_0_buffer"
+                    },
+                    {
+                        "set": 0,
+                        "id": 3,
+                        "resource_ref": "out_temporal"
+                    },
+                    {
+                        "set": 0,
+                        "id": 4,
+                        "resource_ref": "in_motion"
+                    },
+                    {
+                        "set": 0,
+                        "id": 5,
+                        "resource_ref": "out_nearest_depth_offset"
+                    }
+                ],
+                "implicit_barrier": false,
+                "debug_name": "3_post_process_frag",
+                "color_attachment_refs": [
+                    "out_colour"
+                ],
+                "render_extent": [
+                    1920,
+                    1080
+                ],
+                "push_data_ref": "push_data_3"
+            }
+        },
+        {
+            "mark_boundary": {
+                "resources": [
+                    "out_colour",
+                    "out_derivative",
+                    "out_graph_1"
+                ]
+            }
+        }
+    ],
+    "resources": [
+        {
+            "image_barrier": {
+                "uid": "barrier_depth_init_to_scatter",
+                "src_access": "compute_shader_write",
+                "dst_access": "compute_shader_write",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "compute"
+                ],
+                "dst_stage": [
+                    "compute"
+                ],
+                "image_resource": "out_depth_scatter"
+            }
+        },
+        {
+            "image_barrier": {
+                "uid": "barrier_depth_to_pre",
+                "src_access": "compute_shader_write",
+                "dst_access": "compute_shader_read",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "compute"
+                ],
+                "dst_stage": [
+                    "graphics"
+                ],
+                "image_resource": "out_depth_scatter"
+            }
+        },
+        {
+            "buffer_barrier": {
+                "uid": "barrier_pre_to_graph",
+                "src_access": "compute_shader_write",
+                "dst_access": "graph_read",
+                "src_stage": [
+                    "graphics"
+                ],
+                "dst_stage": [
+                    "graph"
+                ],
+                "buffer_resource": "out_input_tensor_buffer",
+                "size": 6266880,
+                "offset": 0
+            }
+        },
+        {
+            "image_barrier": {
+                "uid": "barrier_offset_to_post",
+                "src_access": "compute_shader_write",
+                "dst_access": "compute_shader_read",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "graphics"
+                ],
+                "dst_stage": [
+                    "graphics"
+                ],
+                "image_resource": "out_nearest_depth_offset"
+            }
+        },
+        {
+            "buffer_barrier": {
+                "uid": "barrier_graph0_buf_to_post",
+                "src_access": "graph_write",
+                "dst_access": "compute_shader_read",
+                "src_stage": [
+                    "graph"
+                ],
+                "dst_stage": [
+                    "graphics"
+                ],
+                "buffer_resource": "out_graph_0_buffer",
+                "size": 1175040,
+                "offset": 0
+            }
+        },
+        {
+            "image_barrier": {
+                "uid": "barrier_temporal_to_post",
+                "src_access": "graph_write",
+                "dst_access": "compute_shader_read",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "graph"
+                ],
+                "dst_stage": [
+                    "graphics"
+                ],
+                "image_resource": "out_temporal"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_depth_scatter",
+                "src": "./../assets/960x540_1920x1080/in_depth_scatter_init-480x270__960x540_1920x1080_high_fragment.dds",
+                "dst": "./out_depth_scatter.dds",
+                "dims": [
+                    1,
+                    480,
+                    270,
+                    1
+                ],
+                "format": "VK_FORMAT_R32_UINT",
+                "shader_access": "readwrite",
+                "mips": 1,
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "shader": {
+                "uid": "0_depth_scatter_init",
+                "src": "./../0_depth_scatter_init.comp",
+                "entry": "main",
+                "type": "GLSL",
+                "push_constants_size": 40,
+                "specialization_constants": [],
+                "build_options": "",
+                "include_dirs": [
+                    "./.."
+                ]
+            }
+        },
+        {
+            "raw_data": {
+                "uid": "push_data_0",
+                "src": "./../assets/960x540_1920x1080/0_depth_scatter_push_consts__960x540_1920x1080_high_fragment.npy"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_motion",
+                "src": "./../assets/960x540_1920x1080/in_motion.dds",
+                "dims": [
+                    1,
+                    960,
+                    540,
+                    1
+                ],
+                "format": "VK_FORMAT_R16G16_SFLOAT",
+                "shader_access": "readonly",
+                "mips": 1,
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_depth",
+                "src": "./../assets/960x540_1920x1080/in_depth.dds",
+                "dims": [
+                    1,
+                    960,
+                    540,
+                    1
+                ],
+                "format": "VK_FORMAT_R32_SFLOAT",
+                "shader_access": "readonly",
+                "mips": 1,
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "shader": {
+                "uid": "0_depth_scatter",
+                "src": "./../0_depth_scatter.comp",
+                "entry": "main",
+                "type": "GLSL",
+                "push_constants_size": 40,
+                "specialization_constants": [],
+                "build_options": "",
+                "include_dirs": [
+                    "./.."
+                ]
+            }
+        },
+        {
+            "image": {
+                "uid": "in_colour",
+                "src": "./../assets/960x540_1920x1080/in_colour.dds",
+                "dims": [
+                    1,
+                    960,
+                    540,
+                    1
+                ],
+                "format": "VK_FORMAT_B10G11R11_UFLOAT_PACK32",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_EDGE",
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_history",
+                "src": "./../assets/960x540_1920x1080/in_history.dds",
+                "dims": [
+                    1,
+                    1920,
+                    1080,
+                    1
+                ],
+                "format": "VK_FORMAT_B10G11R11_UFLOAT_PACK32",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_EDGE",
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_temporal_tm1",
+                "src": "./../assets/960x540_1920x1080/in_temporal_tm1-960x544__960x540_1920x1080_high_fragment.dds",
+                "dims": [
+                    1,
+                    960,
+                    544,
+                    1
+                ],
+                "format": "VK_FORMAT_R8G8B8A8_SNORM",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_BORDER",
+                "border_color": "FLOAT_CUSTOM_EXT",
+                "tiling": "LINEAR",
+                "custom_border_color": [
+                    -1.0,
+                    -1.0,
+                    -1.0,
+                    -1.0
+                ]
+            }
+        },
+        {
+            "image": {
+                "uid": "in_derivative_tm1",
+                "src": "./../assets/960x540_1920x1080/in_derivative_tm1-960x544__960x540_1920x1080_high_fragment.dds",
+                "dims": [
+                    1,
+                    960,
+                    544,
+                    1
+                ],
+                "format": "VK_FORMAT_R8G8B8A8_SNORM",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_BORDER",
+                "border_color": "FLOAT_CUSTOM_EXT",
+                "tiling": "OPTIMAL",
+                "custom_border_color": [
+                    -1.0,
+                    0.0,
+                    0.0,
+                    -1.0
+                ]
+            }
+        },
+        {
+            "buffer": {
+                "uid": "out_input_tensor_buffer",
+                "memory_group": {
+                    "id": "mg_input_tensor"
+                },
+                "size": 6266880,
+                "shader_access": "readwrite"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_derivative",
+                "dst": "./out_derivative.dds",
+                "dims": [
+                    1,
+                    960,
+                    544,
+                    1
+                ],
+                "format": "VK_FORMAT_R8G8B8A8_SNORM",
+                "shader_access": "writeonly",
+                "mips": 1,
+                "color_attachment": true,
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_nearest_depth_offset",
+                "dst": "./out_nearest_depth_offset.dds",
+                "dims": [
+                    1,
+                    960,
+                    544,
+                    1
+                ],
+                "format": "VK_FORMAT_R8_UNORM",
+                "shader_access": "readwrite",
+                "mips": 1,
+                "color_attachment": true,
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "shader": {
+                "uid": "fullscreen_triangle_vert",
+                "src": "./../fullscreen_triangle.vert",
+                "entry": "main",
+                "type": "GLSL",
+                "push_constants_size": 0,
+                "specialization_constants": [],
+                "build_options": "",
+                "stage": "vertex",
+                "include_dirs": [
+                    "./.."
+                ]
+            }
+        },
+        {
+            "shader": {
+                "uid": "1_pre_process_frag",
+                "src": "./../1_pre_process.frag",
+                "entry": "main",
+                "type": "GLSL",
+                "push_constants_size": 144,
+                "specialization_constants": [],
+                "build_options": "-DNSS_V1_FULL_RES_LUMA_DERIVATIVE=1 -DNSS_V1_HALF_RES_LUMA_DERIVATIVE=0",
+                "stage": "fragment",
+                "include_dirs": [
+                    "./.."
+                ]
+            }
+        },
+        {
+            "raw_data": {
+                "uid": "push_data_1",
+                "src": "./../assets/960x540_1920x1080/1_pre_process_push_consts__960x540_1920x1080_high_fragment.npy"
+            }
+        },
+        {
+            "tensor": {
+                "uid": "out_input_tensor",
+                "dst": "./out_input_tensor.npy",
+                "memory_group": {
+                    "id": "mg_input_tensor"
+                },
+                "dims": [
+                    1,
+                    544,
+                    960,
+                    12
+                ],
+                "format": "VK_FORMAT_R8_SINT",
+                "shader_access": "readwrite",
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "tensor": {
+                "uid": "out_graph_0",
+                "dst": "./out_graph_0.npy",
+                "memory_group": {
+                    "id": "mg_out_kpn"
+                },
+                "dims": [
+                    1,
+                    136,
+                    240,
+                    36
+                ],
+                "format": "VK_FORMAT_R8_SINT",
+                "shader_access": "readwrite",
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "tensor": {
+                "uid": "out_graph_1",
+                "dst": "./out_graph_1.npy",
+                "memory_group": {
+                    "id": "mg_out_temporal"
+                },
+                "dims": [
+                    1,
+                    544,
+                    960,
+                    4
+                ],
+                "format": "VK_FORMAT_R8_SINT",
+                "shader_access": "readwrite",
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "graph": {
+                "uid": "2_nss",
+                "src": "./../assets/960x540_1920x1080/2_nss-960x540-v1_0_1.vgf"
+            }
+        },
+        {
+            "buffer": {
+                "uid": "out_graph_0_buffer",
+                "memory_group": {
+                    "id": "mg_out_kpn"
+                },
+                "size": 1175040,
+                "shader_access": "readonly"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_temporal",
+                "memory_group": {
+                    "id": "mg_out_temporal"
+                },
+                "dims": [
+                    1,
+                    960,
+                    544,
+                    1
+                ],
+                "format": "VK_FORMAT_R8G8B8A8_SNORM",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_BORDER",
+                "border_color": "FLOAT_TRANSPARENT_BLACK",
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_colour",
+                "dst": "./out_colour.dds",
+                "dims": [
+                    1,
+                    1920,
+                    1080,
+                    1
+                ],
+                "format": "VK_FORMAT_B10G11R11_UFLOAT_PACK32",
+                "shader_access": "writeonly",
+                "mips": 1,
+                "color_attachment": true,
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "shader": {
+                "uid": "3_post_process_frag",
+                "src": "./../3_post_process.frag",
+                "entry": "main",
+                "type": "GLSL",
+                "push_constants_size": 120,
+                "specialization_constants": [],
+                "build_options": "-DNSS_V1_SHARP_THETA=1",
+                "stage": "fragment",
+                "include_dirs": [
+                    "./.."
+                ]
+            }
+        },
+        {
+            "raw_data": {
+                "uid": "push_data_3",
+                "src": "./../assets/960x540_1920x1080/3_post_process_push_consts__960x540_1920x1080_high_fragment.npy"
+            }
+        }
+    ]
+}

scenario/configs/960x540_1920x1080_low_fragment.json

@@ -0,0 +1,838 @@
+{
+    "commands": [
+        {
+            "dispatch_compute": {
+                "shader_ref": "0_depth_scatter_init",
+                "rangeND": [
+                    30,
+                    17,
+                    1
+                ],
+                "implicit_barrier": false,
+                "bindings": [
+                    {
+                        "set": 0,
+                        "id": 0,
+                        "resource_ref": "out_depth_scatter",
+                        "descriptor_type": "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE"
+                    }
+                ],
+                "push_data_ref": "push_data_0"
+            }
+        },
+        {
+            "dispatch_barrier": {
+                "image_barrier_refs": [
+                    "barrier_depth_init_to_scatter"
+                ],
+                "tensor_barrier_refs": [],
+                "memory_barrier_refs": [],
+                "buffer_barrier_refs": []
+            }
+        },
+        {
+            "dispatch_compute": {
+                "shader_ref": "0_depth_scatter",
+                "rangeND": [
+                    30,
+                    17,
+                    1
+                ],
+                "implicit_barrier": false,
+                "bindings": [
+                    {
+                        "set": 0,
+                        "id": 0,
+                        "resource_ref": "in_motion"
+                    },
+                    {
+                        "set": 0,
+                        "id": 1,
+                        "resource_ref": "in_depth"
+                    },
+                    {
+                        "set": 1,
+                        "id": 0,
+                        "resource_ref": "out_depth_scatter",
+                        "descriptor_type": "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE"
+                    }
+                ],
+                "push_data_ref": "push_data_0"
+            }
+        },
+        {
+            "dispatch_barrier": {
+                "image_barrier_refs": [
+                    "barrier_depth_to_lq_disocclusion"
+                ],
+                "tensor_barrier_refs": [],
+                "memory_barrier_refs": [],
+                "buffer_barrier_refs": []
+            }
+        },
+        {
+            "dispatch_fragment": {
+                "vertex_shader_ref": "fullscreen_triangle_vert",
+                "fragment_shader_ref": "0_disocclusion_mask_lq",
+                "bindings": [
+                    {
+                        "set": 0,
+                        "id": 0,
+                        "resource_ref": "in_motion"
+                    },
+                    {
+                        "set": 0,
+                        "id": 1,
+                        "resource_ref": "in_depth"
+                    },
+                    {
+                        "set": 0,
+                        "id": 2,
+                        "resource_ref": "out_depth_scatter"
+                    }
+                ],
+                "implicit_barrier": false,
+                "color_attachment_refs": [
+                    "out_disocclusion_mask_lq"
+                ],
+                "debug_name": "0_disocclusion_mask_lq_frag",
+                "render_extent": [
+                    240,
+                    135
+                ],
+                "push_data_ref": "push_data_1"
+            }
+        },
+        {
+            "dispatch_barrier": {
+                "image_barrier_refs": [
+                    "barrier_depth_to_pre",
+                    "barrier_lq_disocclusion_to_pre"
+                ],
+                "tensor_barrier_refs": [],
+                "memory_barrier_refs": [],
+                "buffer_barrier_refs": []
+            }
+        },
+        {
+            "dispatch_fragment": {
+                "vertex_shader_ref": "fullscreen_triangle_vert",
+                "fragment_shader_ref": "1_pre_process_frag",
+                "bindings": [
+                    {
+                        "set": 0,
+                        "id": 0,
+                        "resource_ref": "in_colour"
+                    },
+                    {
+                        "set": 0,
+                        "id": 1,
+                        "resource_ref": "in_depth"
+                    },
+                    {
+                        "set": 0,
+                        "id": 2,
+                        "resource_ref": "in_motion"
+                    },
+                    {
+                        "set": 0,
+                        "id": 3,
+                        "resource_ref": "in_history"
+                    },
+                    {
+                        "set": 0,
+                        "id": 4,
+                        "resource_ref": "in_temporal_tm1"
+                    },
+                    {
+                        "set": 0,
+                        "id": 5,
+                        "resource_ref": "out_depth_scatter"
+                    },
+                    {
+                        "set": 0,
+                        "id": 6,
+                        "resource_ref": "in_derivative_tm1"
+                    },
+                    {
+                        "set": 0,
+                        "id": 7,
+                        "resource_ref": "out_disocclusion_mask_lq"
+                    },
+                    {
+                        "set": 1,
+                        "id": 0,
+                        "resource_ref": "out_input_tensor_buffer"
+                    }
+                ],
+                "implicit_barrier": false,
+                "color_attachment_refs": [
+                    "out_derivative",
+                    "out_nearest_depth_offset"
+                ],
+                "debug_name": "1_pre_process_frag",
+                "render_extent": [
+                    480,
+                    272
+                ],
+                "push_data_ref": "push_data_1"
+            }
+        },
+        {
+            "dispatch_barrier": {
+                "image_barrier_refs": [],
+                "tensor_barrier_refs": [],
+                "memory_barrier_refs": [],
+                "buffer_barrier_refs": [
+                    "barrier_pre_to_graph"
+                ]
+            }
+        },
+        {
+            "dispatch_graph": {
+                "graph_ref": "2_nss",
+                "implicit_barrier": false,
+                "bindings": [
+                    {
+                        "set": 0,
+                        "id": 0,
+                        "resource_ref": "out_input_tensor"
+                    },
+                    {
+                        "set": 0,
+                        "id": 1,
+                        "resource_ref": "out_graph_0"
+                    },
+                    {
+                        "set": 0,
+                        "id": 2,
+                        "resource_ref": "out_graph_1"
+                    }
+                ]
+            }
+        },
+        {
+            "dispatch_barrier": {
+                "image_barrier_refs": [
+                    "barrier_offset_to_post",
+                    "barrier_temporal_to_post"
+                ],
+                "tensor_barrier_refs": [],
+                "memory_barrier_refs": [],
+                "buffer_barrier_refs": [
+                    "barrier_graph0_buf_to_post"
+                ]
+            }
+        },
+        {
+            "dispatch_fragment": {
+                "vertex_shader_ref": "fullscreen_triangle_vert",
+                "fragment_shader_ref": "3_post_process_frag",
+                "bindings": [
+                    {
+                        "set": 0,
+                        "id": 0,
+                        "resource_ref": "in_colour"
+                    },
+                    {
+                        "set": 0,
+                        "id": 1,
+                        "resource_ref": "in_history"
+                    },
+                    {
+                        "set": 0,
+                        "id": 2,
+                        "resource_ref": "out_graph_0_buffer"
+                    },
+                    {
+                        "set": 0,
+                        "id": 3,
+                        "resource_ref": "out_temporal"
+                    },
+                    {
+                        "set": 0,
+                        "id": 4,
+                        "resource_ref": "in_motion"
+                    },
+                    {
+                        "set": 0,
+                        "id": 5,
+                        "resource_ref": "out_nearest_depth_offset"
+                    }
+                ],
+                "implicit_barrier": false,
+                "color_attachment_refs": [
+                    "out_colour"
+                ],
+                "debug_name": "3_post_process_frag",
+                "render_extent": [
+                    1920,
+                    1080
+                ],
+                "push_data_ref": "push_data_3"
+            }
+        },
+        {
+            "mark_boundary": {
+                "resources": [
+                    "out_colour",
+                    "out_derivative",
+                    "out_graph_1"
+                ]
+            }
+        }
+    ],
+    "resources": [
+        {
+            "image_barrier": {
+                "uid": "barrier_depth_init_to_scatter",
+                "src_access": "compute_shader_write",
+                "dst_access": "compute_shader_write",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "compute"
+                ],
+                "dst_stage": [
+                    "compute"
+                ],
+                "image_resource": "out_depth_scatter"
+            }
+        },
+        {
+            "image_barrier": {
+                "uid": "barrier_depth_to_pre",
+                "src_access": "compute_shader_write",
+                "dst_access": "compute_shader_read",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "compute"
+                ],
+                "dst_stage": [
+                    "graphics"
+                ],
+                "image_resource": "out_depth_scatter"
+            }
+        },
+        {
+            "image_barrier": {
+                "uid": "barrier_depth_to_lq_disocclusion",
+                "src_access": "compute_shader_write",
+                "dst_access": "compute_shader_read",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "compute"
+                ],
+                "dst_stage": [
+                    "graphics"
+                ],
+                "image_resource": "out_depth_scatter"
+            }
+        },
+        {
+            "image_barrier": {
+                "uid": "barrier_lq_disocclusion_to_pre",
+                "src_access": "compute_shader_write",
+                "dst_access": "compute_shader_read",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "graphics"
+                ],
+                "dst_stage": [
+                    "graphics"
+                ],
+                "image_resource": "out_disocclusion_mask_lq"
+            }
+        },
+        {
+            "buffer_barrier": {
+                "uid": "barrier_pre_to_graph",
+                "src_access": "compute_shader_write",
+                "dst_access": "graph_read",
+                "src_stage": [
+                    "graphics"
+                ],
+                "dst_stage": [
+                    "graph"
+                ],
+                "buffer_resource": "out_input_tensor_buffer",
+                "size": 1566720,
+                "offset": 0
+            }
+        },
+        {
+            "image_barrier": {
+                "uid": "barrier_offset_to_post",
+                "src_access": "compute_shader_write",
+                "dst_access": "compute_shader_read",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "graphics"
+                ],
+                "dst_stage": [
+                    "graphics"
+                ],
+                "image_resource": "out_nearest_depth_offset"
+            }
+        },
+        {
+            "buffer_barrier": {
+                "uid": "barrier_graph0_buf_to_post",
+                "src_access": "graph_write",
+                "dst_access": "compute_shader_read",
+                "src_stage": [
+                    "graph"
+                ],
+                "dst_stage": [
+                    "graphics"
+                ],
+                "buffer_resource": "out_graph_0_buffer",
+                "size": 130560,
+                "offset": 0
+            }
+        },
+        {
+            "image_barrier": {
+                "uid": "barrier_temporal_to_post",
+                "src_access": "graph_write",
+                "dst_access": "compute_shader_read",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "graph"
+                ],
+                "dst_stage": [
+                    "graphics"
+                ],
+                "image_resource": "out_temporal"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_depth_scatter",
+                "src": "./../assets/960x540_1920x1080/in_depth_scatter_init-240x135__960x540_1920x1080_low_fragment.dds",
+                "dst": "./out_depth_scatter.dds",
+                "dims": [
+                    1,
+                    240,
+                    135,
+                    1
+                ],
+                "format": "VK_FORMAT_R32_UINT",
+                "shader_access": "readwrite",
+                "mips": 1,
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "shader": {
+                "uid": "0_depth_scatter_init",
+                "src": "./../0_depth_scatter_init.comp",
+                "entry": "main",
+                "type": "GLSL",
+                "push_constants_size": 40,
+                "specialization_constants": [],
+                "build_options": "",
+                "include_dirs": [
+                    "./.."
+                ]
+            }
+        },
+        {
+            "raw_data": {
+                "uid": "push_data_0",
+                "src": "./../assets/960x540_1920x1080/0_depth_scatter_push_consts__960x540_1920x1080_low_fragment.npy"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_motion",
+                "src": "./../assets/960x540_1920x1080/in_motion.dds",
+                "dims": [
+                    1,
+                    960,
+                    540,
+                    1
+                ],
+                "format": "VK_FORMAT_R16G16_SFLOAT",
+                "shader_access": "readonly",
+                "mips": 1,
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_depth",
+                "src": "./../assets/960x540_1920x1080/in_depth.dds",
+                "dims": [
+                    1,
+                    960,
+                    540,
+                    1
+                ],
+                "format": "VK_FORMAT_R32_SFLOAT",
+                "shader_access": "readonly",
+                "mips": 1,
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "shader": {
+                "uid": "0_depth_scatter",
+                "src": "./../0_depth_scatter.comp",
+                "entry": "main",
+                "type": "GLSL",
+                "push_constants_size": 40,
+                "specialization_constants": [],
+                "build_options": "-DNSS_DEPTH_SCATTER_QUARTER_RES_INPUT=1",
+                "include_dirs": [
+                    "./.."
+                ]
+            }
+        },
+        {
+            "image": {
+                "uid": "out_disocclusion_mask_lq",
+                "dst": "./out_disocclusion_mask_lq.dds",
+                "dims": [
+                    1,
+                    240,
+                    135,
+                    1
+                ],
+                "format": "VK_FORMAT_R8_UNORM",
+                "shader_access": "readwrite",
+                "mips": 1,
+                "color_attachment": true,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "shader": {
+                "uid": "fullscreen_triangle_vert",
+                "src": "./../fullscreen_triangle.vert",
+                "entry": "main",
+                "type": "GLSL",
+                "push_constants_size": 0,
+                "specialization_constants": [],
+                "build_options": "",
+                "stage": "vertex",
+                "include_dirs": [
+                    "./.."
+                ]
+            }
+        },
+        {
+            "shader": {
+                "uid": "0_disocclusion_mask_lq",
+                "src": "./../0_disocclusion_mask_lq.frag",
+                "entry": "main",
+                "type": "GLSL",
+                "push_constants_size": 144,
+                "specialization_constants": [],
+                "build_options": "",
+                "stage": "fragment",
+                "include_dirs": [
+                    "./.."
+                ]
+            }
+        },
+        {
+            "raw_data": {
+                "uid": "push_data_1",
+                "src": "./../assets/960x540_1920x1080/1_pre_process_push_consts__960x540_1920x1080_low_fragment.npy"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_colour",
+                "src": "./../assets/960x540_1920x1080/in_colour.dds",
+                "dims": [
+                    1,
+                    960,
+                    540,
+                    1
+                ],
+                "format": "VK_FORMAT_B10G11R11_UFLOAT_PACK32",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_EDGE",
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_history",
+                "src": "./../assets/960x540_1920x1080/in_history.dds",
+                "dims": [
+                    1,
+                    1920,
+                    1080,
+                    1
+                ],
+                "format": "VK_FORMAT_B10G11R11_UFLOAT_PACK32",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_EDGE",
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_temporal_tm1",
+                "src": "./../assets/960x540_1920x1080/in_temporal_tm1-480x272__960x540_1920x1080_low_fragment.dds",
+                "dims": [
+                    1,
+                    480,
+                    272,
+                    1
+                ],
+                "format": "VK_FORMAT_R8G8B8A8_SNORM",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_BORDER",
+                "border_color": "FLOAT_CUSTOM_EXT",
+                "tiling": "LINEAR",
+                "custom_border_color": [
+                    -1.0,
+                    -1.0,
+                    -1.0,
+                    -1.0
+                ]
+            }
+        },
+        {
+            "image": {
+                "uid": "in_derivative_tm1",
+                "src": "./../assets/960x540_1920x1080/in_derivative_tm1-480x272__960x540_1920x1080_low_fragment.dds",
+                "dims": [
+                    1,
+                    480,
+                    272,
+                    1
+                ],
+                "format": "VK_FORMAT_R8G8B8A8_SNORM",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_BORDER",
+                "border_color": "FLOAT_CUSTOM_EXT",
+                "tiling": "OPTIMAL",
+                "custom_border_color": [
+                    -1.0,
+                    0.0,
+                    0.0,
+                    -1.0
+                ]
+            }
+        },
+        {
+            "buffer": {
+                "uid": "out_input_tensor_buffer",
+                "memory_group": {
+                    "id": "mg_input_tensor"
+                },
+                "size": 1566720,
+                "shader_access": "readwrite"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_derivative",
+                "dst": "./out_derivative.dds",
+                "dims": [
+                    1,
+                    480,
+                    272,
+                    1
+                ],
+                "format": "VK_FORMAT_R8G8B8A8_SNORM",
+                "shader_access": "writeonly",
+                "mips": 1,
+                "color_attachment": true,
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_nearest_depth_offset",
+                "dst": "./out_nearest_depth_offset.dds",
+                "dims": [
+                    1,
+                    480,
+                    272,
+                    1
+                ],
+                "format": "VK_FORMAT_R8G8_UNORM",
+                "shader_access": "readwrite",
+                "mips": 1,
+                "color_attachment": true,
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "shader": {
+                "uid": "1_pre_process_frag",
+                "src": "./../1_pre_process.frag",
+                "entry": "main",
+                "type": "GLSL",
+                "push_constants_size": 144,
+                "specialization_constants": [],
+                "build_options": "-DNSS_INPUT_LAYOUT=1 -DNSS_V1_FULL_RES_LUMA_DERIVATIVE=0 -DNSS_V1_HALF_RES_LUMA_DERIVATIVE=1",
+                "stage": "fragment",
+                "include_dirs": [
+                    "./.."
+                ]
+            }
+        },
+        {
+            "tensor": {
+                "uid": "out_input_tensor",
+                "dst": "./out_input_tensor.npy",
+                "memory_group": {
+                    "id": "mg_input_tensor"
+                },
+                "dims": [
+                    1,
+                    272,
+                    480,
+                    12
+                ],
+                "format": "VK_FORMAT_R8_SINT",
+                "shader_access": "readwrite",
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "tensor": {
+                "uid": "out_graph_0",
+                "dst": "./out_graph_0.npy",
+                "memory_group": {
+                    "id": "mg_out_kpn"
+                },
+                "dims": [
+                    1,
+                    68,
+                    120,
+                    16
+                ],
+                "format": "VK_FORMAT_R8_SINT",
+                "shader_access": "readwrite",
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "tensor": {
+                "uid": "out_graph_1",
+                "dst": "./out_graph_1.npy",
+                "memory_group": {
+                    "id": "mg_out_temporal"
+                },
+                "dims": [
+                    1,
+                    272,
+                    480,
+                    4
+                ],
+                "format": "VK_FORMAT_R8_SINT",
+                "shader_access": "readwrite",
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "graph": {
+                "uid": "2_nss",
+                "src": "./../assets/960x540_1920x1080/2_nss-480x270-kpn16-v1_0_1.vgf"
+            }
+        },
+        {
+            "buffer": {
+                "uid": "out_graph_0_buffer",
+                "memory_group": {
+                    "id": "mg_out_kpn"
+                },
+                "size": 130560,
+                "shader_access": "readonly"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_temporal",
+                "memory_group": {
+                    "id": "mg_out_temporal"
+                },
+                "dims": [
+                    1,
+                    480,
+                    272,
+                    1
+                ],
+                "format": "VK_FORMAT_R8G8B8A8_SNORM",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_BORDER",
+                "border_color": "FLOAT_TRANSPARENT_BLACK",
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_colour",
+                "dst": "./out_colour.dds",
+                "dims": [
+                    1,
+                    1920,
+                    1080,
+                    1
+                ],
+                "format": "VK_FORMAT_B10G11R11_UFLOAT_PACK32",
+                "shader_access": "writeonly",
+                "mips": 1,
+                "color_attachment": true,
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "shader": {
+                "uid": "3_post_process_frag",
+                "src": "./../3_post_process.frag",
+                "entry": "main",
+                "type": "GLSL",
+                "push_constants_size": 120,
+                "specialization_constants": [],
+                "build_options": "-DNSS_INPUT_LAYOUT=1 -DNSS_USE_HISTORY_CATMULL=0 -DNSS_V1_SHARP_THETA=1 -DNSS_FILTER_MODE=1",
+                "stage": "fragment",
+                "include_dirs": [
+                    "./.."
+                ]
+            }
+        },
+        {
+            "raw_data": {
+                "uid": "push_data_3",
+                "src": "./../assets/960x540_1920x1080/3_post_process_push_consts__960x540_1920x1080_low_fragment.npy"
+            }
+        }
+    ]
+}

scenario/configs/960x540_1920x1080_mid_fragment.json

@@ -0,0 +1,838 @@
+{
+    "commands": [
+        {
+            "dispatch_compute": {
+                "shader_ref": "0_depth_scatter_init",
+                "rangeND": [
+                    30,
+                    17,
+                    1
+                ],
+                "implicit_barrier": false,
+                "bindings": [
+                    {
+                        "set": 0,
+                        "id": 0,
+                        "resource_ref": "out_depth_scatter",
+                        "descriptor_type": "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE"
+                    }
+                ],
+                "push_data_ref": "push_data_0"
+            }
+        },
+        {
+            "dispatch_barrier": {
+                "image_barrier_refs": [
+                    "barrier_depth_init_to_scatter"
+                ],
+                "tensor_barrier_refs": [],
+                "memory_barrier_refs": [],
+                "buffer_barrier_refs": []
+            }
+        },
+        {
+            "dispatch_compute": {
+                "shader_ref": "0_depth_scatter",
+                "rangeND": [
+                    30,
+                    17,
+                    1
+                ],
+                "implicit_barrier": false,
+                "bindings": [
+                    {
+                        "set": 0,
+                        "id": 0,
+                        "resource_ref": "in_motion"
+                    },
+                    {
+                        "set": 0,
+                        "id": 1,
+                        "resource_ref": "in_depth"
+                    },
+                    {
+                        "set": 1,
+                        "id": 0,
+                        "resource_ref": "out_depth_scatter",
+                        "descriptor_type": "VK_DESCRIPTOR_TYPE_STORAGE_IMAGE"
+                    }
+                ],
+                "push_data_ref": "push_data_0"
+            }
+        },
+        {
+            "dispatch_barrier": {
+                "image_barrier_refs": [
+                    "barrier_depth_to_lq_disocclusion"
+                ],
+                "tensor_barrier_refs": [],
+                "memory_barrier_refs": [],
+                "buffer_barrier_refs": []
+            }
+        },
+        {
+            "dispatch_fragment": {
+                "vertex_shader_ref": "fullscreen_triangle_vert",
+                "fragment_shader_ref": "0_disocclusion_mask_lq",
+                "bindings": [
+                    {
+                        "set": 0,
+                        "id": 0,
+                        "resource_ref": "in_motion"
+                    },
+                    {
+                        "set": 0,
+                        "id": 1,
+                        "resource_ref": "in_depth"
+                    },
+                    {
+                        "set": 0,
+                        "id": 2,
+                        "resource_ref": "out_depth_scatter"
+                    }
+                ],
+                "implicit_barrier": false,
+                "color_attachment_refs": [
+                    "out_disocclusion_mask_lq"
+                ],
+                "debug_name": "0_disocclusion_mask_lq_frag",
+                "render_extent": [
+                    240,
+                    135
+                ],
+                "push_data_ref": "push_data_1"
+            }
+        },
+        {
+            "dispatch_barrier": {
+                "image_barrier_refs": [
+                    "barrier_depth_to_pre",
+                    "barrier_lq_disocclusion_to_pre"
+                ],
+                "tensor_barrier_refs": [],
+                "memory_barrier_refs": [],
+                "buffer_barrier_refs": []
+            }
+        },
+        {
+            "dispatch_fragment": {
+                "vertex_shader_ref": "fullscreen_triangle_vert",
+                "fragment_shader_ref": "1_pre_process_frag",
+                "bindings": [
+                    {
+                        "set": 0,
+                        "id": 0,
+                        "resource_ref": "in_colour"
+                    },
+                    {
+                        "set": 0,
+                        "id": 1,
+                        "resource_ref": "in_depth"
+                    },
+                    {
+                        "set": 0,
+                        "id": 2,
+                        "resource_ref": "in_motion"
+                    },
+                    {
+                        "set": 0,
+                        "id": 3,
+                        "resource_ref": "in_history"
+                    },
+                    {
+                        "set": 0,
+                        "id": 4,
+                        "resource_ref": "in_temporal_tm1"
+                    },
+                    {
+                        "set": 0,
+                        "id": 5,
+                        "resource_ref": "out_depth_scatter"
+                    },
+                    {
+                        "set": 0,
+                        "id": 6,
+                        "resource_ref": "in_derivative_tm1"
+                    },
+                    {
+                        "set": 0,
+                        "id": 7,
+                        "resource_ref": "out_disocclusion_mask_lq"
+                    },
+                    {
+                        "set": 1,
+                        "id": 0,
+                        "resource_ref": "out_input_tensor_buffer"
+                    }
+                ],
+                "implicit_barrier": false,
+                "color_attachment_refs": [
+                    "out_derivative",
+                    "out_nearest_depth_offset"
+                ],
+                "debug_name": "1_pre_process_frag",
+                "render_extent": [
+                    480,
+                    272
+                ],
+                "push_data_ref": "push_data_1"
+            }
+        },
+        {
+            "dispatch_barrier": {
+                "image_barrier_refs": [],
+                "tensor_barrier_refs": [],
+                "memory_barrier_refs": [],
+                "buffer_barrier_refs": [
+                    "barrier_pre_to_graph"
+                ]
+            }
+        },
+        {
+            "dispatch_graph": {
+                "graph_ref": "2_nss",
+                "implicit_barrier": false,
+                "bindings": [
+                    {
+                        "set": 0,
+                        "id": 0,
+                        "resource_ref": "out_input_tensor"
+                    },
+                    {
+                        "set": 0,
+                        "id": 1,
+                        "resource_ref": "out_graph_0"
+                    },
+                    {
+                        "set": 0,
+                        "id": 2,
+                        "resource_ref": "out_graph_1"
+                    }
+                ]
+            }
+        },
+        {
+            "dispatch_barrier": {
+                "image_barrier_refs": [
+                    "barrier_offset_to_post",
+                    "barrier_temporal_to_post"
+                ],
+                "tensor_barrier_refs": [],
+                "memory_barrier_refs": [],
+                "buffer_barrier_refs": [
+                    "barrier_graph0_buf_to_post"
+                ]
+            }
+        },
+        {
+            "dispatch_fragment": {
+                "vertex_shader_ref": "fullscreen_triangle_vert",
+                "fragment_shader_ref": "3_post_process_frag",
+                "bindings": [
+                    {
+                        "set": 0,
+                        "id": 0,
+                        "resource_ref": "in_colour"
+                    },
+                    {
+                        "set": 0,
+                        "id": 1,
+                        "resource_ref": "in_history"
+                    },
+                    {
+                        "set": 0,
+                        "id": 2,
+                        "resource_ref": "out_graph_0_buffer"
+                    },
+                    {
+                        "set": 0,
+                        "id": 3,
+                        "resource_ref": "out_temporal"
+                    },
+                    {
+                        "set": 0,
+                        "id": 4,
+                        "resource_ref": "in_motion"
+                    },
+                    {
+                        "set": 0,
+                        "id": 5,
+                        "resource_ref": "out_nearest_depth_offset"
+                    }
+                ],
+                "implicit_barrier": false,
+                "color_attachment_refs": [
+                    "out_colour"
+                ],
+                "debug_name": "3_post_process_frag",
+                "render_extent": [
+                    1920,
+                    1080
+                ],
+                "push_data_ref": "push_data_3"
+            }
+        },
+        {
+            "mark_boundary": {
+                "resources": [
+                    "out_colour",
+                    "out_derivative",
+                    "out_graph_1"
+                ]
+            }
+        }
+    ],
+    "resources": [
+        {
+            "image_barrier": {
+                "uid": "barrier_depth_init_to_scatter",
+                "src_access": "compute_shader_write",
+                "dst_access": "compute_shader_write",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "compute"
+                ],
+                "dst_stage": [
+                    "compute"
+                ],
+                "image_resource": "out_depth_scatter"
+            }
+        },
+        {
+            "image_barrier": {
+                "uid": "barrier_depth_to_pre",
+                "src_access": "compute_shader_write",
+                "dst_access": "compute_shader_read",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "compute"
+                ],
+                "dst_stage": [
+                    "graphics"
+                ],
+                "image_resource": "out_depth_scatter"
+            }
+        },
+        {
+            "image_barrier": {
+                "uid": "barrier_depth_to_lq_disocclusion",
+                "src_access": "compute_shader_write",
+                "dst_access": "compute_shader_read",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "compute"
+                ],
+                "dst_stage": [
+                    "graphics"
+                ],
+                "image_resource": "out_depth_scatter"
+            }
+        },
+        {
+            "image_barrier": {
+                "uid": "barrier_lq_disocclusion_to_pre",
+                "src_access": "compute_shader_write",
+                "dst_access": "compute_shader_read",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "graphics"
+                ],
+                "dst_stage": [
+                    "graphics"
+                ],
+                "image_resource": "out_disocclusion_mask_lq"
+            }
+        },
+        {
+            "buffer_barrier": {
+                "uid": "barrier_pre_to_graph",
+                "src_access": "compute_shader_write",
+                "dst_access": "graph_read",
+                "src_stage": [
+                    "graphics"
+                ],
+                "dst_stage": [
+                    "graph"
+                ],
+                "buffer_resource": "out_input_tensor_buffer",
+                "size": 1566720,
+                "offset": 0
+            }
+        },
+        {
+            "image_barrier": {
+                "uid": "barrier_offset_to_post",
+                "src_access": "compute_shader_write",
+                "dst_access": "compute_shader_read",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "graphics"
+                ],
+                "dst_stage": [
+                    "graphics"
+                ],
+                "image_resource": "out_nearest_depth_offset"
+            }
+        },
+        {
+            "buffer_barrier": {
+                "uid": "barrier_graph0_buf_to_post",
+                "src_access": "graph_write",
+                "dst_access": "compute_shader_read",
+                "src_stage": [
+                    "graph"
+                ],
+                "dst_stage": [
+                    "graphics"
+                ],
+                "buffer_resource": "out_graph_0_buffer",
+                "size": 130560,
+                "offset": 0
+            }
+        },
+        {
+            "image_barrier": {
+                "uid": "barrier_temporal_to_post",
+                "src_access": "graph_write",
+                "dst_access": "compute_shader_read",
+                "old_layout": "general",
+                "new_layout": "general",
+                "src_stage": [
+                    "graph"
+                ],
+                "dst_stage": [
+                    "graphics"
+                ],
+                "image_resource": "out_temporal"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_depth_scatter",
+                "src": "./../assets/960x540_1920x1080/in_depth_scatter_init-240x135__960x540_1920x1080_mid_fragment.dds",
+                "dst": "./out_depth_scatter.dds",
+                "dims": [
+                    1,
+                    240,
+                    135,
+                    1
+                ],
+                "format": "VK_FORMAT_R32_UINT",
+                "shader_access": "readwrite",
+                "mips": 1,
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "shader": {
+                "uid": "0_depth_scatter_init",
+                "src": "./../0_depth_scatter_init.comp",
+                "entry": "main",
+                "type": "GLSL",
+                "push_constants_size": 40,
+                "specialization_constants": [],
+                "build_options": "",
+                "include_dirs": [
+                    "./.."
+                ]
+            }
+        },
+        {
+            "raw_data": {
+                "uid": "push_data_0",
+                "src": "./../assets/960x540_1920x1080/0_depth_scatter_push_consts__960x540_1920x1080_mid_fragment.npy"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_motion",
+                "src": "./../assets/960x540_1920x1080/in_motion.dds",
+                "dims": [
+                    1,
+                    960,
+                    540,
+                    1
+                ],
+                "format": "VK_FORMAT_R16G16_SFLOAT",
+                "shader_access": "readonly",
+                "mips": 1,
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_depth",
+                "src": "./../assets/960x540_1920x1080/in_depth.dds",
+                "dims": [
+                    1,
+                    960,
+                    540,
+                    1
+                ],
+                "format": "VK_FORMAT_R32_SFLOAT",
+                "shader_access": "readonly",
+                "mips": 1,
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "shader": {
+                "uid": "0_depth_scatter",
+                "src": "./../0_depth_scatter.comp",
+                "entry": "main",
+                "type": "GLSL",
+                "push_constants_size": 40,
+                "specialization_constants": [],
+                "build_options": "-DNSS_DEPTH_SCATTER_QUARTER_RES_INPUT=1",
+                "include_dirs": [
+                    "./.."
+                ]
+            }
+        },
+        {
+            "image": {
+                "uid": "out_disocclusion_mask_lq",
+                "dst": "./out_disocclusion_mask_lq.dds",
+                "dims": [
+                    1,
+                    240,
+                    135,
+                    1
+                ],
+                "format": "VK_FORMAT_R8_UNORM",
+                "shader_access": "readwrite",
+                "mips": 1,
+                "color_attachment": true,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "shader": {
+                "uid": "fullscreen_triangle_vert",
+                "src": "./../fullscreen_triangle.vert",
+                "entry": "main",
+                "type": "GLSL",
+                "push_constants_size": 0,
+                "specialization_constants": [],
+                "build_options": "",
+                "stage": "vertex",
+                "include_dirs": [
+                    "./.."
+                ]
+            }
+        },
+        {
+            "shader": {
+                "uid": "0_disocclusion_mask_lq",
+                "src": "./../0_disocclusion_mask_lq.frag",
+                "entry": "main",
+                "type": "GLSL",
+                "push_constants_size": 144,
+                "specialization_constants": [],
+                "build_options": "",
+                "stage": "fragment",
+                "include_dirs": [
+                    "./.."
+                ]
+            }
+        },
+        {
+            "raw_data": {
+                "uid": "push_data_1",
+                "src": "./../assets/960x540_1920x1080/1_pre_process_push_consts__960x540_1920x1080_mid_fragment.npy"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_colour",
+                "src": "./../assets/960x540_1920x1080/in_colour.dds",
+                "dims": [
+                    1,
+                    960,
+                    540,
+                    1
+                ],
+                "format": "VK_FORMAT_B10G11R11_UFLOAT_PACK32",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_EDGE",
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_history",
+                "src": "./../assets/960x540_1920x1080/in_history.dds",
+                "dims": [
+                    1,
+                    1920,
+                    1080,
+                    1
+                ],
+                "format": "VK_FORMAT_B10G11R11_UFLOAT_PACK32",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_EDGE",
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "image": {
+                "uid": "in_temporal_tm1",
+                "src": "./../assets/960x540_1920x1080/in_temporal_tm1-480x272__960x540_1920x1080_mid_fragment.dds",
+                "dims": [
+                    1,
+                    480,
+                    272,
+                    1
+                ],
+                "format": "VK_FORMAT_R8G8B8A8_SNORM",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_BORDER",
+                "border_color": "FLOAT_CUSTOM_EXT",
+                "tiling": "LINEAR",
+                "custom_border_color": [
+                    -1.0,
+                    -1.0,
+                    -1.0,
+                    -1.0
+                ]
+            }
+        },
+        {
+            "image": {
+                "uid": "in_derivative_tm1",
+                "src": "./../assets/960x540_1920x1080/in_derivative_tm1-480x272__960x540_1920x1080_mid_fragment.dds",
+                "dims": [
+                    1,
+                    480,
+                    272,
+                    1
+                ],
+                "format": "VK_FORMAT_R8G8B8A8_SNORM",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_BORDER",
+                "border_color": "FLOAT_CUSTOM_EXT",
+                "tiling": "OPTIMAL",
+                "custom_border_color": [
+                    -1.0,
+                    0.0,
+                    0.0,
+                    -1.0
+                ]
+            }
+        },
+        {
+            "buffer": {
+                "uid": "out_input_tensor_buffer",
+                "memory_group": {
+                    "id": "mg_input_tensor"
+                },
+                "size": 1566720,
+                "shader_access": "readwrite"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_derivative",
+                "dst": "./out_derivative.dds",
+                "dims": [
+                    1,
+                    480,
+                    272,
+                    1
+                ],
+                "format": "VK_FORMAT_R8G8B8A8_SNORM",
+                "shader_access": "writeonly",
+                "mips": 1,
+                "color_attachment": true,
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_nearest_depth_offset",
+                "dst": "./out_nearest_depth_offset.dds",
+                "dims": [
+                    1,
+                    480,
+                    272,
+                    1
+                ],
+                "format": "VK_FORMAT_R8G8_UNORM",
+                "shader_access": "readwrite",
+                "mips": 1,
+                "color_attachment": true,
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "shader": {
+                "uid": "1_pre_process_frag",
+                "src": "./../1_pre_process.frag",
+                "entry": "main",
+                "type": "GLSL",
+                "push_constants_size": 144,
+                "specialization_constants": [],
+                "build_options": "-DNSS_INPUT_LAYOUT=1 -DNSS_V1_FULL_RES_LUMA_DERIVATIVE=0 -DNSS_V1_HALF_RES_LUMA_DERIVATIVE=1",
+                "stage": "fragment",
+                "include_dirs": [
+                    "./.."
+                ]
+            }
+        },
+        {
+            "tensor": {
+                "uid": "out_input_tensor",
+                "dst": "./out_input_tensor.npy",
+                "memory_group": {
+                    "id": "mg_input_tensor"
+                },
+                "dims": [
+                    1,
+                    272,
+                    480,
+                    12
+                ],
+                "format": "VK_FORMAT_R8_SINT",
+                "shader_access": "readwrite",
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "tensor": {
+                "uid": "out_graph_0",
+                "dst": "./out_graph_0.npy",
+                "memory_group": {
+                    "id": "mg_out_kpn"
+                },
+                "dims": [
+                    1,
+                    68,
+                    120,
+                    16
+                ],
+                "format": "VK_FORMAT_R8_SINT",
+                "shader_access": "readwrite",
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "tensor": {
+                "uid": "out_graph_1",
+                "dst": "./out_graph_1.npy",
+                "memory_group": {
+                    "id": "mg_out_temporal"
+                },
+                "dims": [
+                    1,
+                    272,
+                    480,
+                    4
+                ],
+                "format": "VK_FORMAT_R8_SINT",
+                "shader_access": "readwrite",
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "graph": {
+                "uid": "2_nss",
+                "src": "./../assets/960x540_1920x1080/2_nss-480x270-kpn16-v1_0_1.vgf"
+            }
+        },
+        {
+            "buffer": {
+                "uid": "out_graph_0_buffer",
+                "memory_group": {
+                    "id": "mg_out_kpn"
+                },
+                "size": 130560,
+                "shader_access": "readonly"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_temporal",
+                "memory_group": {
+                    "id": "mg_out_temporal"
+                },
+                "dims": [
+                    1,
+                    480,
+                    272,
+                    1
+                ],
+                "format": "VK_FORMAT_R8G8B8A8_SNORM",
+                "shader_access": "readonly",
+                "mips": 1,
+                "min_filter": "LINEAR",
+                "mag_filter": "LINEAR",
+                "mip_filter": "NEAREST",
+                "border_address_mode": "CLAMP_BORDER",
+                "border_color": "FLOAT_TRANSPARENT_BLACK",
+                "tiling": "LINEAR"
+            }
+        },
+        {
+            "image": {
+                "uid": "out_colour",
+                "dst": "./out_colour.dds",
+                "dims": [
+                    1,
+                    1920,
+                    1080,
+                    1
+                ],
+                "format": "VK_FORMAT_B10G11R11_UFLOAT_PACK32",
+                "shader_access": "writeonly",
+                "mips": 1,
+                "color_attachment": true,
+                "tiling": "OPTIMAL"
+            }
+        },
+        {
+            "shader": {
+                "uid": "3_post_process_frag",
+                "src": "./../3_post_process.frag",
+                "entry": "main",
+                "type": "GLSL",
+                "push_constants_size": 120,
+                "specialization_constants": [],
+                "build_options": "-DNSS_INPUT_LAYOUT=1 -DNSS_V1_SHARP_THETA=1 -DNSS_FILTER_MODE=1",
+                "stage": "fragment",
+                "include_dirs": [
+                    "./.."
+                ]
+            }
+        },
+        {
+            "raw_data": {
+                "uid": "push_data_3",
+                "src": "./../assets/960x540_1920x1080/3_post_process_push_consts__960x540_1920x1080_mid_fragment.npy"
+            }
+        }
+    ]
+}

scenario/fullscreen_triangle.vert

@@ -0,0 +1,24 @@
+//
+// -----------------------------------------------------------------------------
+// The proprietary software and information contained in this file is
+// confidential and may only be used by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+//
+// Copyright (C) 2026 Arm Limited or its affiliates. All rights reserved.
+//
+// This entire notice must be reproduced on all copies of this file and
+// copies of this file may only be made by an authorized person under a valid
+// licensing agreement from Arm Limited or its affiliates.
+// -----------------------------------------------------------------------------
+//
+
+#version 460
+
+layout(location = 0) out vec2 vUV;
+
+void main() {
+    // Fullscreen triangle without vertex buffers
+    vec2 pos = vec2((gl_VertexIndex << 1) & 2, gl_VertexIndex & 2);
+    vUV = vec2(pos.x * 0.5, 1.0 - pos.y * 0.5);
+    gl_Position = vec4(pos * 2.0 - 1.0, 0.0, 1.0);
+}

scenario/typedefs.h

@@ -4,13 +4,14 @@
 // confidential and may only be used by an authorized person under a valid
 // licensing agreement from Arm Limited or its affiliates.
 //
-// Copyright (C) 2025. Arm Limited or its affiliates. All rights reserved.
+// Copyright (C) 2026 Arm Limited or its affiliates. All rights reserved.
 //
 // This entire notice must be reproduced on all copies of this file and
 // copies of this file may only be made by an authorized person under a valid
 // licensing agreement from Arm Limited or its affiliates.
 // -----------------------------------------------------------------------------
 //
+
 #ifndef NSS_TYPEDEFS
 #define NSS_TYPEDEFS
 
@@ -27,7 +28,7 @@
 #define float4 f32vec4
 
 // int8 types
-#define int8_t int8_t
+#define int8_t  int8_t
 #define int8_t2 i8vec2
 #define int8_t3 i8vec3
 #define int8_t4 i8vec4
@@ -60,27 +61,27 @@
 #define lerp mix
 
 // --- RCP functions for float16 types ---
-half rcp(half x)     { return half( 1.HF) / x; }
+half rcp(half x)     { return half(1.HF) / x; }
 half2 rcp(half2 x)   { return half2(1.HF) / x; }
 half3 rcp(half3 x)   { return half3(1.HF) / x; }
 half4 rcp(half4 x)   { return half4(1.HF) / x; }
 
 // --- RCP functions for float32 types ---
-float rcp(float x)   { return float( 1.0f) / x; }
+float rcp(float x)   { return float(1.0f) / x; }
 float2 rcp(float2 x) { return float2(1.0f) / x; }
 float3 rcp(float3 x) { return float3(1.0f) / x; }
 float4 rcp(float4 x) { return float4(1.0f) / x; }
 
 // --- Saturate functions for float16 types ---
-half   saturate(half x)     { return clamp(x, half( 0.HF), half( 1.HF)); }
-half2  saturate(half2 x)    { return clamp(x, half2(0.HF), half2(1.HF)); }
-half3  saturate(half3 x)    { return clamp(x, half3(0.HF), half3(1.HF)); }
-half4  saturate(half4 x)    { return clamp(x, half4(0.HF), half4(1.HF)); }
+half saturate(half x)    { return clamp(x, half(0.HF), half(1.HF)); }
+half2 saturate(half2 x)  { return clamp(x, half2(0.HF), half2(1.HF)); }
+half3 saturate(half3 x)  { return clamp(x, half3(0.HF), half3(1.HF)); }
+half4 saturate(half4 x)  { return clamp(x, half4(0.HF), half4(1.HF)); }
 
 // --- Saturate functions for float32 types ---
-float   saturate(float x)     { return clamp(x, 0.f, 1.f); }
-float2  saturate(float2 x)    { return clamp(x, float2(0.f), float2(1.f)); }
-float3  saturate(float3 x)    { return clamp(x, float3(0.f), float3(1.f)); }
-float4  saturate(float4 x)    { return clamp(x, float4(0.f), float4(1.f)); }
+float saturate(float x)    { return clamp(x, 0.f, 1.f); }
+float2 saturate(float2 x)  { return clamp(x, float2(0.f), float2(1.f)); }
+float3 saturate(float3 x)  { return clamp(x, float3(0.f), float3(1.f)); }
+float4 saturate(float4 x)  { return clamp(x, float4(0.f), float4(1.f)); }
 
 #endif  // NSS_TYPEDEFS