Merge pull request #2188 from madeline-underwood/godot

Godot_JA to review

Author: jasonrandrews

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

@@ -1,17 +1,13 @@
 ---
-title: Use the Arm Performance Studio Integration extension in Godot
-
-draft: true
-cascade:
-    draft: true
-    
+title: Profile Android game performance in Godot with Arm Performance Studio
+   
 minutes_to_complete: 15
 
-who_is_this_for: This is an introductory topic for Godot developers who are targeting Android devices and want to get more insight into how their game performs on devices with Arm CPUs and GPUs.
+who_is_this_for: This is an introductory topic for Godot developers targeting Android devices who want to optimize game performance on Arm CPUs and Mali GPUs using Arm Performance Studio tools.
 
 learning_objectives: 
     - Install the Arm Performance Studio Integration extension in Godot
-    - Annotate your Godot game with markers that give context to a profile in Arm Performance Studio tools
+    - Annotate your Godot game with performance markers for profiling in Streamline and Performance Advisor
 
 prerequisites:
     - Familiarity with Godot

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

@@ -0,0 +1,43 @@
+---
+title: Annotate Game Events for Profiling in Godot
+weight: 5
+layout: learningpathall
+---
+
+## Use the Performance Studio extension in your project
+
+All annotation features are provided through the `PerformanceStudio` class. To begin, create an instance in your script:
+
+```gdscript
+var performance_studio = PerformanceStudio.new()
+
+
+## Add single markers to highlight key game events
+
+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 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")
+
+
+## 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/arm_mobile_studio_integrations.md

@@ -0,0 +1,43 @@
+---
+title: Create and track custom counters in Godot
+weight: 8
+layout: learningpathall
+---
+## What are counters?
+
+Counters are floating-point values plotted as line charts in Streamline. Each value appears with two decimal places of precision.
+
+There are two types of counters:
+
+- Absolute counters: every value is treated as an independent measurement
+
+- 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)
+```
+
+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/create-counters.md

@@ -0,0 +1,28 @@
+---
+title: Define performance regions in Godot
+weight: 6
+layout: learningpathall
+---
+
+## 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:
+
+```console
+performance_studio.marker("Region Start Times Square")
+# Do work
+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#center](pa_frame_rate_regions.png "Regions in Performance Advisor")
+
+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#center](pa_dedicated_region_charts.png "Dedicated region charts in Performance Advisor")
+
+
+
+
+

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

@@ -0,0 +1,26 @@
+---
+title: Install the Arm Performance Studio extension in Godot
+weight: 4
+layout: learningpathall
+---
+
+## Install the Arm Performance Studio extension in Godot
+
+To profile performance in your Godot game, first install the Arm Performance Studio extension using the Godot Asset Library.
+
+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.
+
+
+
+
+

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

@@ -0,0 +1,35 @@
+---
+title:  Profile your Godot game with Arm Performance Studio
+weight: 3
+
+### FIXED, DO NOT MODIFY
+layout: learningpathall
+---
+
+## Overview
+
+In this Learning Path, you'll learn how to annotate and analyze performance in your Godot game using the Arm Performance Studio extension. You’ll add markers, counters, and timelines to capture game events and visualize them in Streamline and Performance Advisor. These tools help you identify CPU and GPU bottlenecks and optimize performance on Arm-based Android devices.
+
+{{% notice Note %}}
+ This extension is compatible with **Godot 4.3 and later**.
+{{% /notice %}}
+
+## What is Arm Performance Studio?
+
+[Arm Performance Studio](https://developer.arm.com/Tools%20and%20Software/Arm%20Performance%20Studio) is a free suite of analysis tools to profile game performance on mobile devices with Arm CPUs and GPUs. It includes:
+
+- [Streamline](https://developer.arm.com/Tools%20and%20Software/Streamline%20Performance%20Analyzer): a performance analyzer that collects CPU and GPU metrics.
+
+- [Performance Advisor](https://developer.arm.com/Tools%20and%20Software/Performance%20Advisor): a report generator that offers optimization suggestions.
+
+Arm provides a Godot extension from [Godot games](https://godotengine.org/) that integrates with these tools, making it easier to capture performance data directly from your game.
+
+## Add annotations to your Godot project
+
+The Arm Performance Studio extension lets you add custom annotations to your Godot project. These annotations include timeline markers and counters that describe what's happening during gameplay,such as loading a level or spawning enemies.
+
+When you record a capture in Streamline, these annotations appear in the timeline alongside CPU and GPU metrics. This context makes it easier to correlate performance issues with in-game events.
+
+For example, here’s a capture showing a marker for when a wave of enemies spawns:
+
+![Marker annotations in Streamline#center](sl_annotation.png "Marker annotations in Streamline")

content/learning-paths/mobile-graphics-and-gaming/godot_packages/profile-godot-with-aps.md

@@ -0,0 +1,37 @@
+---
+title: Use channels for threaded performance annotations
+weight: 7
+layout: learningpathall
+---
+## Use channels for threaded annotations in Godot
+
+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.
+
+## 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
+
+func _ready() -> void:
+    channel = performance_studio.create_channel("Spawner")
+
+# Annotations can then be inserted into a channel:
+func _on_new_wave_started() -> void:
+    channel.annotate_color("Spawning Wave", Color8(255, 0, 0))
+
+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#center](sl_channel.png "Channel annotations in Streamline")