Merge pull request #1713 from madeline-underwood/asr

ASR_Andy to check

Author: pareenaverma

content/learning-paths/mobile-graphics-and-gaming/get-started-with-arm-asr/01-what-is-arm-asr.md

@@ -1,5 +1,5 @@
 ---
-title: What is Arm Accuracy Super Resolution (Arm ASR)?
+title: What is Arm Accuracy Super Resolution?
 weight: 2
 
 ### FIXED, DO NOT MODIFY
@@ -8,43 +8,49 @@ layout: learningpathall
 
 ## Introduction
 
-[Arm® Accuracy Super Resolution™ (Arm 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.
+[Arm® Accuracy Super Resolution™ (Arm 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). 
 
-Available as an easy plug-in for Unreal Engine 5.3, 5,4, and 5.5, a Unity plugin coming soon, or as a generic library that you can integrate into other engines, you can easily improve frames per second, enhance visual quality, and prevent thermal throttling for smoother, longer gameplay.
+Arm ASR extends this technology with optimizations suited to the resource-constrained environment of mobile gaming.
+
+Arm ASR is currently available as an easy-to-integrate plug-in for Unreal Engine versions 5.3, 5.4, and 5.5, with a Unity plugin coming soon. It is also available as a generic library that you can integrate into other engines. 
+
+Using ASR, you can improve frames per second (FPS), enhance visual quality, and prevent thermal throttling for smoother and longer gameplay.
 
 ## What is Super Resolution?
 
-Super-resolution techniques render some frames at a lower resolution and use shader upscaling to reconstruct how the frames should look at native resolution. This offers significant performance and battery life improvements for mobile devices.
+Super Resolution techniques render frames at a lower resolution and apply shader-based upscaling to reconstruct how the frames should look at native resolution. This approach significantly improves performance and extends battery life on mobile devices.
 
 Arm ASR outperforms spatial upscalers when reconstructing fine details, such as:
 
-- Thin features
-- Grid-like structures
-- Fast-moving objects
+- Thin features.
+- Grid-like structures.
+- Fast-moving objects.
 
-You can control a range of different settings for Arm ASR:
+You have control over a range of different settings, including:
 
-- The upscaling ratio. For example, a value of 50.0 will mean that the plugin upscales frames by a factor of 2.
-- Use Arm ASR’s own auto-exposure or use the game engine’s auto-exposure value.
-- Use a Robust Contrast Adaptive Sharpening (RCAS) filter to sharpen the output image.
-- The shader quality preset: 1 - Quality, 2 - Balanced, 3 - Performance.
+- **The upscaling ratio**. For example, a value of 50.0 indicates that the plugin upscales frames by a factor of 2.
+- **Auto-exposure**. Use Arm ASR’s own auto-exposure or use your game engine’s auto-exposure value.
+- **Sharpening**. Apply Robust Contrast Adaptive Sharpening (RCAS) filters to enhance output image clarity.
+- **Shader quality presets**. Select from: 1 - Quality, 2 - Balanced, or 3 - Performance presets.
 
 ## Overview of Arm ASR
 
-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:
+The [Arm ASR Experience Kit](https://github.com/arm/accuracy-super-resolution) provides resources to help you evaluate and effectively utilize this technology. 
+
+It includes:
 
-- The Arm ASR source code so developers can access it fully and even evolve the technology for their needs.
-- Tutorials and sample materials to help developers with the integration of the technology and how to use it.
-- Plugin for Unreal Engine.
+- Arm ASR source code, which provides developers with the full access and the flexibility to evolve the technology for their needs.
+- Tutorials and sample materials to simplify integration and usage.
+- Plugin support for Unreal Engine.
 
 ## Unreal Engine Plugin
 
-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.
+The Arm ASR plugin for Unreal Engine 5 integrates into your project within minutes. Once installed, simply enable temporal upscaling, and the plugin automatically handles frame upscaling.
 
-[Using Arm ASR in Unreal Engine](../03-ue)
+See [Using Arm ASR in Unreal Engine](../03-ue).
 
-## Custom engine usage
+## Custom Engine Usage
 
-If you are using your own custom engine, you can still integrate Arm ASR using our generic library.
+If you are using your own custom engine, integrate Arm ASR using our generic library.
 
-[Using Arm ASR in a custom engine](../04-generic_library)
+See [Using Arm ASR in a custom engine](../04-generic_library).

content/learning-paths/mobile-graphics-and-gaming/get-started-with-arm-asr/02-ue.md

@@ -7,87 +7,104 @@ layout: learningpathall
 ---
 
 
-## Introduction
+## Objective
 
-This guide describes how to get started with Arm® Accuracy Super Resolution™ (Arm ASR) through an example project in Unreal Engine. It is for Unreal Engine developers who want to apply upscaling techniques to their projects. You will walk through the processes of installing Arm ASR and some of the common tasks that you might encounter when setting up Arm ASR for the first time.
+This Learning Path describes how to get started with Arm® Accuracy Super Resolution™ (Arm ASR) using an example project in Unreal Engine. 
+
+It is for Unreal Engine developers who want to apply upscaling techniques to their projects. 
+
+You will walk through the processes of installing Arm ASR performing some of the common setup tasks.
 
 ## Before you begin
 
-We recommend using Unreal Engine versions 5.3-5.5 through this tutorial. Please get in contact with us at [email protected] if you have any questions.
+It is recommended that you use Unreal Engine versions 5.3-5.5 through this tutorial. 
+
+If you have any questions, contact us at [email protected].
 
 ## Installing the Arm ASR plugin
 
-The following steps describe how to install the Arm ASR plugin in Unreal Engine:
+Follow these steps to install the Arm ASR plugin in Unreal Engine:
 
-1. Open the Unreal Engine project you intend to use with Arm ASR. The Third Person pack is available as an example.
+1. Open the Unreal Engine project you plan to use with Arm ASR. 
 
-    ![Third person pack](images/third_person_pack.png "Third person pack")
+The Third Person pack is available as an example, see below:
 
-2. Download the plugin by cloning the repository.
+![Third Person pack](images/third_person_pack.png "Third Person pack")
+
+2. Download the Arm ASR plugin by cloning the repository:
 
     ```
     git clone https://github.com/arm/accuracy-super-resolution-for-unreal
     ```
 
-3. Navigate to the `UE` directory in the cloned repository. This contains directories containing the plugin for each supported version of Unreal Engine.
+3. Navigate to the `UE` directory in the cloned repository. 
+
+    This directory contains subfolders with plugins for each supported Unreal Engine version.
 
-4. From the directory for your version of Unreal Engine, copy the Arm ASR plugin into the `Plugins` folder in the game directory.
+4. From the directory for your version of Unreal Engine, copy the Arm ASR plugin into the `Plugins` folder in the game directory. 
 
-    ![Plugin folder](images/plugin_folder.png "Plugin folder")
+    See below:
 
-    ![Copied Arm ASR plugin](images/copied_arm_asr_plugin.png "Copied Arm ASR plugin")
+![Plugin folder](images/plugin_folder.png "Plugin folder")
+
+![Copied Arm ASR plugin](images/copied_arm_asr_plugin.png "Copied Arm ASR plugin")
 
 5. Navigate back to your Unreal Engine project.
 
-6. When the pop-up window opens asking to build Arm ASR, select **Yes**.
+6. When the pop-up window opens prompting you to build Arm ASR, select **Yes**.
 
-    ![Arm ASR pop up window](images/asr_popup.png "Arm ASR pop up window")
+    ![Arm ASR pop-up window](images/asr_popup.png "Arm ASR pop-up window")
 
 ## Enable and configure Arm ASR
 
-After reopening the Unreal Engine project, the Arm ASR plugin should be enabled.
+After reopening the Unreal Engine project, ensure that the Arm ASR plugin is enabled.
 
-1. Go to **Edit > Plugins**, and search for Arm ASR. Make sure Arm ASR is checked.
+1. Go to **Edit > Plugins**, search for **Arm ASR**, and make sure that it is checked.
 
     ![Verify the plugin](images/verify_plugin.png "Verify the plugin")
 
     ![Plugin screen](images/plugin_screen.png "Plugin screen")
 
-1. To enable Arm ASR upscaling, open **Project Settings** and change the Anti-Aliasing Method to **Temporal Anti-Aliasing**.
+2. To enable Arm ASR upscaling, open **Project Settings** and set the **Anti-Aliasing Method** to **Temporal Anti-Aliasing**.
 
-   {{% notice %}}
-   **Mobile Anti-Aliasing Method** is used for the mobile renderer, however this tutorial describes the desktop renderer. You can learn about other available renderers by studying the `README.md` of the `accuracy-super-resolution-for-unreal` repository.
-    {{% /notice %}}
+   {{%notice%}}
+   **Mobile Anti-Aliasing Method** is used for the mobile renderer, however this Learning Path uses the desktop renderer. For information about other available renderers, see the `README.md` in the `accuracy-super-resolution-for-unreal` repository.
+    {{%/notice%}}
 
-    ![Change anti-aliasing method](images/change_anti_aliasing_method.png "Change anti-aliasing method")
+    ![Change Anti-Aliasing Method](images/change_anti_aliasing_method.png "Set the Anti-Aliasing Method")
 
-1. To check that Arm ASR is enabled and working, use the `ShowFlag.VisualizeTemporalUpscaler 1` console command. If Arm ASR is working, you will see Arm ASR listed as the **ThirdParty TemporalUpscaler** in the command window.
+3. To verify that Arm ASR is enabled and active, use the `ShowFlag.VisualizeTemporalUpscaler 1` console command. 
+    
+    {{%notice%}}
+   The debug views produced by this command are generated by Unreal Engine's TAA, not directly by Arm ASR.{{%/notice%}}
 
-   {{% notice %}}
-   When you use the `ShowFlag.VisualizeTemporalUpscaler 1` console command, the debug views are not generated from Arm ASR but from Unreal Engines TAA.
-   {{% /notice %}}
+If Arm ASR is active, you will see Arm ASR listed as the **ThirdParty TemporalUpscaler** in the console window.
 
-    ![Visualize console command](images/visualise_console_command.png "Visualize console command")
+![Visualize console command](images/visualise_console_command.png "Visualize console command")
 
-1. If Arm ASR is not shown here, use the `r.ArmASR.Enable 1` console command to enable upscaling.
+4. If Arm ASR is not shown here, use the `r.ArmASR.Enable 1` console command to enable upscaling.
 
     ![Arm ASR.Enable 1 command](images/arm_asr_enable_command.png "ArmASR.Enable 1 command")
 
-## Further configuration {.section}
+## Further configuration settings
+
+You can configure Arm ASR further in two ways:
 
-There are two ways to configure further settings.
+1. Using the UI:
 
-Option 1 is using the UI. Go to **Edit > Project Settings > Plugins > Arm ASR**.
+* Go to **Edit > Project Settings > Plugins > Arm ASR**.
 
 ![Configure settings using UI](images/ui_settings.png "Configure settings using UI")
 
-Option 2 is through the console. By typing `r.ArmASR.` into the console window, you can see the configuration options.
+2. Through the console:
+
+* Type `r.ArmASR.` into the console window to see configuration options.
 
 ![Configuration options](images/configuration_options.png "Configuration options")
 
-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.
+For example, you can change the upscaling ratio by modifying the **ScreenPercentage**, through the command option `r.ScreenPercentage`. A value of `50.0` means frames are upscaled by a factor of 2.
 
-Arm ASR's behavior can be configured via the following plugin-specific console variables:
+You can configure Arm ASR's behavior through the following plugin-specific console variables:
 
 |Console Variable                                   | Default Value | Value Range | Details                                                                                                |
 |:------------------------------------------------- | :------------ | :---------- | :----------------------------------------------------------------------------------------------------- |
@@ -112,4 +129,6 @@ Arm ASR's behavior can be configured via the following plugin-specific console v
 
 ## Next steps
 
-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.
+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.