You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Copy file name to clipboardExpand all lines: content/learning-paths/mobile-graphics-and-gaming/get-started-with-arm-asr/01-what-is-arm-asr.md
+6-6Lines changed: 6 additions & 6 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -8,7 +8,7 @@ layout: learningpathall
8
8
9
9
## Introduction
10
10
11
-
[Arm® Accuracy Super Resolution™ (ASR)](https://www.arm.com/developer-hub/mobile-graphics-and-gaming/accuracy-super-resolution) is a mobile-optimized temporal upscaling technique derived from [AMD's Fidelity Super Resolution 2 v2.2.2](https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/blob/main/docs/techniques/super-resolution-temporal.md). Arm ASR extends this technnology with multiple optimizations to make the technique suited for the more resource-constrained environment of mobile gaming.
11
+
[Arm® Accuracy Super Resolution™ (ASR)](https://www.arm.com/developer-hub/mobile-graphics-and-gaming/accuracy-super-resolution) is a mobile-optimized temporal upscaling technique derived from [AMD's Fidelity Super Resolution 2 v2.2.2](https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/blob/main/docs/techniques/super-resolution-temporal.md). Arm ASR extends this technology with multiple optimizations to make the technique suited for the more resource-constrained environment of mobile gaming.
12
12
13
13
With an Unreal Engine plug-in available now, open-source library code to integrate into your customized engines, and Unity and Godot plug-ins coming later in the year, you can easily improve frames per second, enhance visual quality, and prevent thermal throttling for smoother, longer gameplay.
14
14
@@ -29,19 +29,19 @@ You can control a range of different settings for Arm ASR:
29
29
- Use a Robust Contrast Adaptive Sharpening (RCAS) filter to sharpen the output image.
The Arm ASR experience kit is a combination of materials that provide access to the technology, to help you evaluate it and make the best use of it. It includes:
34
+
The [Arm ASR experience kit](https://github.com/arm/accuracy-super-resolution) is a combination of materials that provide access to the technology, to help you evaluate it and make the best use of it. It includes:
35
35
36
36
- The Arm ASR source code so developers can access it fully and even evolve the technology for their needs.
37
37
- Tutorials and sample materials to help developers with the integration of the technology and how to use it.
38
-
-Plugin for Unreal Engine
38
+
-Plugins for multiple game engines
39
39
40
-
[Get Arm ASR on GitHub](https://github.com/arm/accuracy-super-resolution)
40
+
Specific repositories for each game engine integration is also available. The following sections will cover those currently available.
41
41
42
42
## Unreal Engine Plugin
43
43
44
-
We provide an Unreal Engine 5 plugin that you can install into your project in a matter of minutes. Once installed, simply enable temporal upscaling on your project and the plugin will automatically handle the upscaling of all frames.
44
+
The Unreal Engine 5 plugin can be integrated into your project in a matter of minutes. Once installed, simply enable temporal upscaling on your project and the plugin will automatically handle the upscaling of all frames.
For example, you can change the upscaling ratio by modifying the **ScreenPercentage**, via the command option `r.ScreenPercentage`. A value of `50.0` will mean that the plugin upscales frames by a factor of 2.
86
94
87
-
Table: Arm ASR Setting options
95
+
Arm ASR's behavior can be configured via the following plugin-specific console variables:
88
96
89
97
|Console Variable | Default Value | Value Range | Details |
@@ -107,16 +115,5 @@ Table: Arm ASR Setting options
107
115
|`r.ArmASR.ReactiveMaskForceReactiveMaterialValue` | 0 | 0, 1 | Force the reactive mask value for Reactive Shading Model materials, when > 0 this value can be used to override the value supplied in the Material Graph. |
108
116
|`r.ArmASR.ReactiveMaskReactiveShadingModelID` | MSM_NUM | - | Treat the specified shading model as reactive, taking the CustomData0.x value as the reactive value to write into the mask. |
109
117
110
-
There are two ways to configure further settings.
111
-
112
-
Option 1 is using the UI. Go to **Edit > Project Settings > Plugins > Arm ASR**.
113
-
114
-
115
-
116
-
Option 2 is through the console. By typing `r.ArmASR.` into the console window, you can see the configuration options.
For example, you can change the upscaling ratio by modifying the [ScreenPercentage]{.ui}. The upscaling ratio of Arm ASR can be set via `r.ScreenPercentage`. For example, a value of `50.0` will mean that the plugin upscales frames by a factor of 2.
121
118
122
119
You are now ready to use Arm ASR in your Unreal Engine projects. You can use [Arm Performance Studio](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Studio) tools to measure the performance of your game as it runs on a mobile device, allowing you to monitor the effect of Arm ASR.
Copy file name to clipboardExpand all lines: content/learning-paths/mobile-graphics-and-gaming/get-started-with-arm-asr/04-universal-sdk.md
+20-16Lines changed: 20 additions & 16 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -8,7 +8,7 @@ layout: learningpathall
8
8
9
9
## Introduction
10
10
11
-
Use the following steps to implement **Arm Accuracy Super-Resolution** in your own custome engine. Arm ASR is an optimized version of [Fidelity Super Resolution 2](https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/blob/main/docs/techniques/super-resolution-temporal.md) that has been heavily modified to included many mobile-oriented optimizations to make the technique suited for mobile.
11
+
Use the following steps to implement **Arm Accuracy Super-Resolution** in your own custome engine. Arm ASR is an optimized version of [Fidelity Super Resolution 2](https://github.com/GPUOpen-LibrariesAndSDKs/FidelityFX-SDK/blob/main/docs/techniques/super-resolution-temporal.md) that has been heavily modified to include many mobile-oriented optimizations to make the technique suited for mobile.
12
12
13
13
There are two ways you can integrate Arm ASR into your custom engine:
14
14
@@ -24,37 +24,37 @@ To quickly integrate Arm ASR, which means the built-in standalone backend is use
1. For the purposes of this tutorial, we will set a variable to identify the location of the Arm ASR package. This path will be used to refer to files in the repository throughout this learning path.
27
+
2. For the purposes of this tutorial, we will set a variable to identify the location of the Arm ASR package. This path will be used to refer to files in the repository throughout this learning path.
28
28
29
29
```
30
30
export $ARMASR_DIR=$(pwd)
31
31
```
32
32
33
-
1. Copy the **Arm_ASR** directory into your project, and add **Arm_ASR/src/backends/shared/blob_accessors/prebuilt_shaders** in the incude path if you want to use prebuilt shaders.
33
+
3. Copy the **Arm_ASR** directory into your project, and add **Arm_ASR/src/backends/shared/blob_accessors/prebuilt_shaders** in the include path if you want to use prebuilt shaders.
34
+
35
+
4. Include the following header files in your codebase where you wish to interact with the technique:
34
36
35
-
1. Include the following header files in your codebase where you wish to interact with the technique:
- Allocate a Vulkan scratch buffer of the size returned by `$ARMASR_DIR/include/host/backends/vk/ffxm_vk.h#L65`.
42
42
- Create `FfxmDevice` via `$ARMASR_DIR/include/host/backends/vk/ffxm_vk.h#L65`.
43
43
- Create `FfxmInterface` by calling `$ARMASR_DIR/include/host/backends/vk/ffxm_vk.h#L99`.
44
44
45
-
1. Create a context by calling `ffxmFsr2ContextCreate` accessed via `$ARMASR_DIR/include/host/ffxm_fsr2.h#L296`. The parameters structure should be filled out matching the configuration of your application.
45
+
6. Create a context by calling `ffxmFsr2ContextCreate` accessed via `$ARMASR_DIR/include/host/ffxm_fsr2.h#L296`. The parameters structure should be filled out matching the configuration of your application.
46
46
47
-
1. Each frame call `ffxmFsr2ContextDispatch` via `$ARMASR_DIR/include/host/ffxm_fsr2.h#L337' to record/execute the technique's workloads. The parameters structure should be filled out matching the configuration of your application.
47
+
7. Each frame call `ffxmFsr2ContextDispatch` via `$ARMASR_DIR/include/host/ffxm_fsr2.h#L337' to record/execute the technique's workloads. The parameters structure should be filled out matching the configuration of your application.
48
48
49
-
1. When your application is terminating (or you wish to destroy the context for another reason) you should call `ffxmFsr2ContextDestroy` accessed via `$ARMASR_DIR/include/host/ffxm_fsr2.h#L360`. The GPU should be idle before calling this function.
49
+
8. When your application is terminating (or you wish to destroy the context for another reason) you should call `ffxmFsr2ContextDestroy` accessed via `$ARMASR_DIR/include/host/ffxm_fsr2.h#L360`. The GPU should be idle before calling this function.
50
50
51
-
1. Sub-pixel jittering should be applied to your application's projection matrix. This should be done when performing the main rendering of your application. You should use the `ffxmFsr2GetJitterOffset` function accessed via `$ARMASR_DIR/include/host/ffxm_fsr2.h#L504` to compute the precise jitter offsets.
51
+
9. Sub-pixel jittering should be applied to your application's projection matrix. This should be done when performing the main rendering of your application. You should use the `ffxmFsr2GetJitterOffset` function accessed via `$ARMASR_DIR/include/host/ffxm_fsr2.h#L504` to compute the precise jitter offsets.
52
52
53
-
1. A global mip bias should be applied when texturing.
53
+
10. A global mip bias should be applied when texturing.
54
54
55
-
1. For the best upscaling quality it is strongly advised that you populate the Reactive mask according to our guidelines. You can also use `ffxmFsr2ContextGenerateReactiveMask` accessed via `$ARMASR_DIR/include/host/ffxm_fsr2.h#L348` as a starting point.
55
+
11. For the best upscaling quality it is strongly advised that you populate the Reactive mask according to our guidelines. You can also use `ffxmFsr2ContextGenerateReactiveMask` accessed via `$ARMASR_DIR/include/host/ffxm_fsr2.h#L348` as a starting point.
56
56
57
-
1. Finally, link the two built libraries (**Arm_ASR_api** and **Arm_ASR_backend**).
57
+
12. Finally, link the two built libraries (**Arm_ASR_api** and **Arm_ASR_backend**).
58
58
59
59
## Tight integration
60
60
@@ -64,11 +64,11 @@ In this approach the shaders are expected to be built by the engine. Arm ASR's s
64
64
65
65
1. Include the `ffxm_interface.h` header file from `$ARMASR_DIR/include/host/ffxm_interface.h#L1` in your codebase.
66
66
67
-
1. Implement your own functions (assume the names are `xxxGetInterfacexxx`, `xxxGetScratchMemorySizexxx`) and callbacks in `FfxmInterface` accessed via `$ARMASR_DIR/include/host/ffxm_interface.h#L438` to link Arm ASR with the engine's renderer.
67
+
2. Implement your own functions (assume the names are `xxxGetInterfacexxx`, `xxxGetScratchMemorySizexxx`) and callbacks in `FfxmInterface` accessed via `$ARMASR_DIR/include/host/ffxm_interface.h#L438` to link Arm ASR with the engine's renderer.
68
68
69
-
1. Create your own backend by calling `xxxGetInterfacexxx`. A scratch buffer should be allocated of the size returned by calling `xxxGetScratchMemorySizexxx` and the pointer to that buffer passed to `xxxGetInterfacexxx`.
69
+
3. Create your own backend by calling `xxxGetInterfacexxx`. A scratch buffer should be allocated of the size returned by calling `xxxGetScratchMemorySizexxx` and the pointer to that buffer passed to `xxxGetInterfacexxx`.
70
70
71
-
1. Now, you can follow the same steps from quick integration above, starting from step 6, creating a Arm ASR context. In the final step it is only necessary to link the **Arm_ASR_api** library.
71
+
4. Now, you can follow the same steps from quick integration above, starting from step 6, creating a Arm ASR context. In the final step it is only necessary to link the **Arm_ASR_api** library.
72
72
73
73
### HLSL-based workflows
74
74
@@ -81,3 +81,7 @@ In an HLSL-based workflow using DirectX Shader Compiler to cross-compile to SPIR
81
81
```
82
82
83
83
- The extension **VK_KHR_shader_float16_int8** should be used at runtime.
84
+
85
+
(...)
86
+
87
+
You are now ready to use Arm ASR in your game engine projects. Go to the next section to explore more resources on Arm ASR.
Copy file name to clipboardExpand all lines: content/learning-paths/mobile-graphics-and-gaming/get-started-with-arm-asr/_index.md
+22-15Lines changed: 22 additions & 15 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -5,43 +5,50 @@ minutes_to_complete: 20
5
5
6
6
who_is_this_for: Mobile gaming and graphics developers who want to install and configure Arm Accuracy Super Resolution (ASR) in their projects, to improve performance on highly complex game content without compromising on image quality.
7
7
8
-
learning_objectives:
8
+
learning_objectives:
9
9
- Understand Arm Accuracy Super Resolution
10
10
- Integrate Arm ASR into your game project
11
-
- Control how Arm ASR upscales your content
11
+
- Control how Arm ASR upscales your content
12
12
13
13
prerequisites:
14
14
- A game project that uses high-quality rendering features (such as hardware ray tracing) that stretch the performance capabilities of everyday smartphones.
0 commit comments