Revised sections

Author: madeline-underwood

content/learning-paths/mobile-graphics-and-gaming/godot_packages/add-markers.md

@@ -4,32 +4,40 @@ weight: 5
 layout: learningpathall
 ---
 
-## Using the extension
+## Use the Performance Studio extension in your project
 
-All functionality in the extension is provided by the PerformanceStudio class, so first create an instance of it:
+All annotation features are provided through the `PerformanceStudio` class. To begin, create an instance in your script:
 
-```console
+```gdscript
 var performance_studio = PerformanceStudio.new()
-```
-## Add single markers to highlight key game events
 
-All functionality in the extension is provided by the `PerformanceStudio` class. First, create an instance:
 
-```gdscript
-var performance_studio = PerformanceStudio.new()
-```
+## Add single markers to highlight key game events
 
-The simplest annotations are single markers, which can have a name and a color. For example:
+The simplest annotations are single markers. These appear in the Streamline timeline and help you correlate game behavior with performance data.
+
+To emit a basic marker, use the `marker()` method with a descriptive label:
 
 ```gdscript
 performance_studio.marker("Game Started")
 ```
 
-This will emit a timestamped marker labeled "Game Started." When you capture a profile in Streamline, you’ll see this marker at the point the game starts.
+This creates a timestamped marker labeled **Game Started**. When you capture a profile in Streamline, you’ll see this marker at the point the game starts.
+
+![Marker annotation in Streamline#center](sl_marker.png "Marker annotation in Streamline")
 
-![Marker annotation in Streamline](sl_marker.png "Figure 4. Marker annotation in Streamline")
 
-To assign a color:
+## Assign a custom color
+
+You can assign a color to the marker using the `marker_color()` method:
 
 ```gdscript
 performance_studio.marker_color("Game Started", Color8(0, 255, 0))
+```
+
+This example displays the Game Started marker in green. Use different colors to visually distinguish important game events.
+
+
+
+
+

content/learning-paths/mobile-graphics-and-gaming/godot_packages/create-counters.md

@@ -3,23 +3,41 @@ title: Create and track custom counters in Godot
 weight: 8
 layout: learningpathall
 ---
-### Creating counters
+## What are counters?
 
-Counters are numerical data points that can be plotted as a chart in the Streamline timeline view. Counters can be created as either absolute counters, where every value is an absolute value, or as a delta counter, where values are the number of instances of an event since the last value was emitted. All values are floats and will be presented to 2 decimal places.
+Counters are floating-point values plotted as line charts in Streamline. Each value appears with two decimal places of precision.
 
-When charts are first defined, you can specify a title and series name. The title names the chart, the series names the data series.
+There are two types of counters:
 
-Multiple counter series can use the same title, which means that they will be plotted on the same chart in the Streamline timeline.
+- Absolute counters: every value is treated as an independent measurement
 
-To create a counter:
+- Delta counters: each value represents the change since the last measurement (for example, the number of enemy spawns since the last update)
+
+## Define your counter chart
+
+When charts are first defined, you can specify:
+
+- A title: this names the chart in Streamline
+
+- A series name: this labels the specific data stream within the chart
+
+You can group multiple counter series under the same title to plot them on the same chart.
+
+## Create and update a counter
+
+Use the `create_counter()` method to define a counter in your script. For example:
 
 ```console
 var counter = performance_studio.create_counter("Title", "Series", false)
 ```
 
-Counter values are set easily as shown below:
+The third parameter sets whether the counter is a delta counter `(true)` or absolute counter `(false)`.
+
+To update the counter value, use:
 
 ```console
 counter.setValue(42.2)
 ```
 
+This value will appear in the timeline alongside other profiling data during a Streamline capture.
+

content/learning-paths/mobile-graphics-and-gaming/godot_packages/define-regions.md

@@ -4,9 +4,9 @@ weight: 6
 layout: learningpathall
 ---
 
-## Defining regions in a Godot project
+## Defining regions in your Godot project
 
-To define regions of interest within the game, you can specify a pair of markers prefixed with “Region Start” and “Region End”, for example:
+To define regions of interest within the game, you can specify a pair of markers prefixed with **Region Start** and **Region End**, for example:
 
 ```console
 performance_studio.marker("Region Start Times Square")
@@ -16,11 +16,11 @@ performance_studio.marker("Region End Times Square")
 
 These regions are shown on the frame rate analysis chart in the Performance Advisor report.
 
-![Regions in Performance Advisor](pa_frame_rate_regions.png "Figure 5. Regions in Performance Advisor")
+![Regions in Performance Advisor#center](pa_frame_rate_regions.png "Regions in Performance Advisor")
 
-Also, dedicated charts for each region are appended to the end of the report, so you can analyze each region independently.
+Performance Advisor also includes dedicated charts for each region at the end of the report, allowing you to analyze them independently.
 
-![Dedicated region charts in Performance Advisor](pa_dedicated_region_charts.png "Figure 6. Dedicated region charts in Performance Advisor")
+![Dedicated region charts in Performance Advisor#center](pa_dedicated_region_charts.png "Dedicated region charts in Performance Advisor")
 
 
 

content/learning-paths/mobile-graphics-and-gaming/godot_packages/install-extension.md

@@ -10,10 +10,17 @@ To profile performance in your Godot game, first install the Arm Performance Stu
 
 Start by opening your project in Godot,  then select **AssetLib** from the top menu to browse available extensions.
 
+Search for **Arm Performance Studio Integration**, then double-click the result to open its details.
+
+In the extension dialog that appears, select **Download** to begin the installation.
+
+![Extension download dialog in Godot#center](godot_install_performance_studio_extension.png "Download dialog for the Arm Performance Studio Integration extension in Godot")
+
+When prompted, you can change the install folder if needed. To complete the setup, select **Install**.
+
+The extension will now be added to your project and ready to use for adding markers and counters.
+
+
 
-2. Find the **Arm Performance Studio Integration** extension, then double-click to open the extension.
-3. The extension opens in a dialog box. Click **Download**.
 
-![Installing the Arm Performance Studio Integration extension in Godot](godot_install_performance_studio_extension.png "Figure 2. Installing the Arm Performance Studio Integration extension in Godot")
 
-4. A new dialog box opens where you can change the install folder if required. Click **Install**.

content/learning-paths/mobile-graphics-and-gaming/godot_packages/use-channels.md

@@ -3,11 +3,13 @@ title: Use channels for threaded performance annotations
 weight: 7
 layout: learningpathall
 ---
-### Using channels in a Godot project
+## Use channels for threaded annotations in Godot
 
-Channels are custom event timelines associated with a software thread. You can create channels and place annotations within them. A channel annotation has a text label and a color but, unlike markers, they span a range of time.
+Channels are custom event timelines associated with a specific software thread. Unlike single-point markers, channel annotations span a duration and include a label and optional color. You can use them to trace task execution or track long-running operations, such as asset loading or enemy spawning.
 
-To create a channel called "Spawner" and insert an annotation called "Spawning Wave", with the color red:
+## Create and annotate a channel
+
+To define a new channel named **Spawner** and insert an annotation labeled **Spawning Wave**, use the following approach:
 
 ```console
 var channel : PerformanceStudio_Channel
@@ -22,7 +24,14 @@ func _on_new_wave_started() -> void:
 func _on_wave_completed() -> void:
     channel.end()
 ```
+In this example:
+
+- The `annotate_color()` method begins a red-colored annotation labeled Spawning Wave
+
+- The end() method marks when the annotation finishes
+
+## View channels in Streamline
 
 To see channels in Streamline, select the **Core Map** view, and expand the **VkThread** thread:
 
-![Channel annotations in Streamline](sl_channel.png "Figure 7. Channel annotations in Streamline")
+![Channel annotations in Streamline#center](sl_channel.png "Channel annotations in Streamline")

content/learning-paths/mobile-graphics-and-gaming/godot_packages/use-custom-activity-maps.md

@@ -1,16 +1,20 @@
 ---
-title: Use Custom Activity Maps in Godot profiling
+title: Use custom activity maps in Godot profiling
 weight: 9
 layout: learningpathall
 ---
 
-### Custom Activity Maps
+## Use custom activity maps to organize game profiling
 
-[Custom Activity Map (CAM)](https://developer.arm.com/documentation/101816/latest/Annotate-your-code/User-space-annotations/Custom-Activity-Map-annotations) views allow execution information to be plotted on a hierarchical set of timelines. Like channel annotations, CAM views plot jobs on tracks, but unlike channel annotations, CAM views are not associated with a specific thread. Each CAM view contains one or more tracks and each track contains one or more jobs.
+[Custom Activity Map (CAM)](https://developer.arm.com/documentation/101816/latest/Annotate-your-code/User-space-annotations/Custom-Activity-Map-annotations) views allow execution information to be plotted on a hierarchical set of timelines. 
 
-![Custom activity maps in Streamline](sl_cam.png "Figure 8. Custom activity maps in Streamline")
+Like channel annotations, CAM views plot jobs on tracks, but unlike channel annotations, CAM views are not associated with a specific thread. Each CAM view contains one or more tracks and each track contains one or more jobs.
 
-To create a custom activity map and add tracks to it:
+![Custom activity maps in Streamline#center](sl_cam.png "Custom activity maps in Streamline")
+
+## Create a CAM and add tracks
+
+To define a custom activity map and add tracks for different systems:
 
 ```console
 var game_cam : PerformanceStudio_CAM
@@ -26,7 +30,9 @@ func _ready() -> void:
     ui_track = game_cam.create_track("UI Activity")
 ```
 
-To create a job within a track:
+## Add jobs to tracks
+
+You can use jobs to represent specific time-bound tasks on a track. Here’s how to create and stop a job:
 
 ```console
 var wave_job : PerformanceStudio_CAMJob
@@ -38,4 +44,8 @@ func _on_wave_completed() -> void:
     wave_job.stop()
 ```
 
-You can now annotate your Godot game and analyze the performance with markers that give context to a profile in Arm Performance Studio tools.
+## Analyze custom activity maps in Streamline
+
+Once you capture a profiling session, you can view your CAM data in Streamline under the Custom Activity Map section. Each job appears on its assigned track, enabling you to inspect how long each task ran and when overlapping operations occurred.
+
+Use CAMs to structure your profiling data around gameplay concepts, not just threads, making your performance analysis more intuitive and actionable.