Stride

https://github.com/stride3d/stride-docs
Admin
Stride is a free and open-source 2D and 3D game engine with comprehensive documentation covering...
Tokens:402,295
Snippets:3,550
Trust Score:9.4
License:MIT
Update:1 week ago
Show doc for...
Tokens:
Raw
### VideoScript example with StartupScript

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/video/set-up-a-video.md

A complete script class that plays the video in the Start method. The public fields and properties declared in the script are displayed in Game Studio.

```C#
{
    public class VideoScript : StartupScript
    {
        // Game Studio displays the public member fields and properties you declare in this script

        public override void Start()
        {
            // Initialization of the script.
            Entity.Get<VideoComponent>().Instance.Play();
        }
    }
}
```

--------------------------------

### Godot equivalent of StartupScript in C#

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/stride-for-godot-developers/index.md

Godot's _Ready() is equivalent to Stride's Start, and _ExitTree() can be used for cleanup. This example shows the C# version.

```csharp
public class BasicMethods : Node
{
    // This method is equivalent to Stride's Start in StartupScript
    public override void _Ready()
    {
        // Initialization code for the script
    }

    // Godot doesn't have a direct equivalent to Stride's Cancel,
    // but you could use _ExitTree for cleanup
    public override void _ExitTree()
    {
        // Cleanup code for the script
    }
}
```

--------------------------------

### Start development server with npm start

Source: https://github.com/stride3d/stride-docs/blob/master/en/contributors/website/installation.md

Starts the Eleventy development server. The command 'npx @11ty/eleventy --serve' is equivalent. A Windows Security warning may appear on first run; allow access.

```bash
npm start
```

```bash
npx @11ty/eleventy --serve
```

--------------------------------

### Startup script example: inherit from StartupScript and override Start

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/scripts/types-of-script/index.md

Startup scripts run only when added or removed at runtime, typically for initializing game elements (e.g., spawning characters) and destroying them on scene unload. Override the Start method for initialization; the Cancel method is also available.

```csharp
public class Example : StartupScript
{
  public override void Start()
  {
    // Do some stuff during initialization
  }
}
```

--------------------------------

### Install and use the Stride CLI

Source: https://github.com/stride3d/stride-docs/blob/master/en/release-notes/4.4.md

Commands to install the Stride CLI, install the latest Stride version, create a project from a template, and open it in Game Studio.

```bash
dotnet tool install -g stride.cli      # Install Stride CLI
stride sdk install                     # Install the latest version of Stride
stride new topdownrpg && cd TopDownRPG # Create a project from a template
stride studio                          # Open it in Game Studio
```

--------------------------------

### Create and use a virtual button configuration

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/input/virtual-buttons.md

This example shows how to create a VirtualButtonConfigSet, bind multiple physical inputs (M key, GamePad Start button, left mouse button) to a virtual button named 'MyButton', and retrieve its value in the Update method.

```C#
public override void Start()
{
    base.Start();

    // Create a new VirtualButtonConfigSet if none exists. 
    Input.VirtualButtonConfigSet = Input.VirtualButtonConfigSet ?? new VirtualButtonConfigSet();
    
    //Bind "M" key, GamePad "Start" button and left mouse button to a virtual button "MyButton".
    VirtualButtonBinding b1 = new VirtualButtonBinding("MyButton", VirtualButton.Keyboard.M);
    VirtualButtonBinding b2 = new VirtualButtonBinding("MyButton", VirtualButton.GamePad.Start);
    VirtualButtonBinding b3 = new VirtualButtonBinding("MyButton", VirtualButton.Mouse.Left);

    VirtualButtonConfig c = [b1, b2, b3];

    Input.VirtualButtonConfigSet.Add(c);
}

public override void Update() {
    float button = Input.GetVirtualButton(0, "MyButton");
}
```

--------------------------------

### Create and start a game instance in the entry point

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/files-and-folders/project-packages/index.md

Every entry point needs to create a game instance and start it. This code is automatically generated when a platform is added to the project.

```csharp
using Stride.Engine;

using var game = new Game();
game.Run();
```

--------------------------------

### Install Stride SDK with CLI (including betas)

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/platforms/linux/install-the-editor-using-wine.md

Use the Stride CLI to install the latest version of the engine, including beta releases. Run this command in a terminal after installing the engine prerequisites.

```bash
# Install the latest version (including betas)
stride sdk install --prerelease
```

--------------------------------

### SyncScript lifecycle example

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/scripts/types-of-script/sync-script.md

Shows the three overridable methods of a SyncScript: Start, Update, and Cancel. These methods are called during runtime only, not in Game Studio.

```csharp
public class Example : SyncScript
{
    public override void Start()
    {
        // Do stuff for when the script is loaded
    }
    
    public override void Update()
    {
        // Do stuff that needs to be performed every frame
    }
    
    public override void Cancel()
    {
        // Do stuff for when the script is unloaded
    }
}
```

--------------------------------

### Example .csproj metadata configuration

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/files-and-folders/external-packages/publish-a-nuget-package.md

Example configuration for package metadata in the .csproj file. The package id must match the .csproj file's name to avoid complications.

```xml
<PropertyGroup>
  <PackageId>MyGame.MyLibrary</PackageId>
  <Version>1.0.0</Version>
  <Authors>ProfileName1,ProfileName2</Authors>
  <Description>My Description</Description>
</PropertyGroup>
```

--------------------------------

### Install and use dotnet new templates

Source: https://github.com/stride3d/stride-docs/blob/master/en/release-notes/4.4.md

Commands to install Stride.Templates and create a new Stride game project using standard .NET tooling.

```bash
dotnet new install Stride.Templates
dotnet new stride-game -n MyGame
```

--------------------------------

### SyncScript initialization with service

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/scripts/types-of-script/sync-script.md

Shows how to initialize a service in Start and use it in Update. Note the source uses 'public class Start()' and 'public class Update()' which are not valid C# overrides; this is likely a typo in the documentation.

```csharp
public class Example : SyncScript
{
    private MyExampleService service;
    
    // Initialize our script
    public class Start()
    {
        service = Services.GetService<MyExampleService>();
    }
    
    // Perform logic every frame
    public class Update()
    {
        service.DoSomething();
    }
}
```

--------------------------------

### Install dependencies with npm install

Source: https://github.com/stride3d/stride-docs/blob/master/en/contributors/website/installation.md

Installs all project dependencies required for the website.

```bash
npm install
```

--------------------------------

### Example .sdfx file

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/graphics/effects-and-shaders/effect-language.md

An example .sdfx file that defines a BasicEffect, using parameters and mixins to generate a shader permutation.

```cs
using Stride.Effects.Data;

namespace StrideEffects
{
	params MyParameters
	{
		bool EnableSpecular = true;
	};
	
	effect BasicEffect
	{
		using params MaterialParameters;
		using params MyParameters;

		mixin ShaderBase;
		mixin TransformationWAndVP;
		mixin NormalVSStream;
		mixin PositionVSStream;
		mixin BRDFDiffuseBase;
		mixin BRDFSpecularBase;
		mixin LightMultiDirectionalShadingPerPixel<2>;
		mixin TransparentShading;
		mixin DiscardTransparent;

		if (MaterialParameters.AlbedoDiffuse != null)
		{
			mixin compose DiffuseColor = ComputeBRDFDiffuseLambert;
			mixin compose albedoDiffuse = MaterialParameters.AlbedoDiffuse;
		}

		if (MaterialParameters.AlbedoSpecular != null)
		{
			mixin compose SpecularColor = ComputeBRDFColorSpecularBlinnPhong;
			mixin compose albedoSpecular = MaterialParameters.AlbedoSpecular;
		}
	};
}
```

--------------------------------

### Startup Script to Set Window Properties

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/graphics/window-configuration.md

Use a StartupScript in the root scene to change window properties. The example sets IsBorderLess to true, but you can modify the properties in the Start method.

```csharp
using Stride.Engine;

namespace MyGame
{
    public class WindowSetupScript : StartupScript
    {
        public override void Start()
        {
            // Set window properties here
            
            // Example
            Game.Window.IsBorderLess = true;
        }
    }
}
```

--------------------------------

### Install Stride dotnet templates

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/get-started/create-a-project.md

Install the Stride template packages using dotnet new install. The blank stride-game template is installed with Stride.Templates.Games, while other templates, samples, and asset packs are installed separately.

```bash
# Install the blank stride-game template
dotnet new install Stride.Templates.Games
# Install other templates
dotnet new install Stride.Templates.Games.Starters
# Install samples (complete games)
dotnet new install Stride.Templates.Samples
# Install asset packs
dotnet new install Stride.Templates.AssetPacks
```

--------------------------------

### Example script checking texture load with DebugText

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/troubleshooting/debug-text.md

A complete SyncScript that loads a texture in Start and, in Update, prints 'MyTexture not loaded' if the texture is null. This demonstrates using DebugText to report a problem at runtime.

```csharp
using Stride.Core.Mathematics;
using Stride.Engine;
using Stride.Graphics;

namespace MyGame
{
    public class Script : SyncScript
    {
		public Texture myTexture;

        public override void Start()
        {
            // Initialization of the script.
            myTexture = Content.Load<Texture>("MyTexture");
        }

        public override void Update()
        {
			if (myTexture == null)
                DebugText.Print("MyTexture not loaded", new Int2(x: 50, y: 50));
        }
    }
}
```

--------------------------------

### Complete custom triangle example

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/scripts/create-a-model-from-code.md

A complete example that creates a custom triangle mesh with vertex and index buffers, and adds it to the model.

```csharp
var vertices = new VertexPositionTexture[3];
vertices[0].Position = new Vector3(0f,0f,1f);            
vertices[1].Position = new Vector3(0f,1f,0f);
vertices[2].Position = new Vector3(0f,1f,1f);
var vertexBuffer = Stride.Graphics.Buffer.Vertex.New(GraphicsDevice, vertices,
                                                     GraphicsResourceUsage.Dynamic);
int[] indices = { 0, 2, 1 };
var indexBuffer = Stride.Graphics.Buffer.Index.New(GraphicsDevice, indices);

var customMesh = new Stride.Rendering.Mesh
{ 
    Draw = new Stride.Rendering.MeshDraw
    { 
        /* Vertex buffer and index buffer setup */ 
        PrimitiveType = Stride.Graphics.PrimitiveType.TriangleList,
        DrawCount = indices.Length,
        IndexBuffer = new IndexBufferBinding(indexBuffer, true, indices.Length),
        VertexBuffers = new[] { new VertexBufferBinding(vertexBuffer, 
                                  VertexPositionTexture.Layout, vertexBuffer.ElementCount) },
    }
};            
// add the mesh to the model
model.Meshes.Add(customMesh);
```

--------------------------------

### F# example: Render a capsule with Stride Community Toolkit

Source: https://github.com/stride3d/stride-docs/blob/master/en/release-notes/4.2.md

Shows how to set up a basic 3D scene and add a capsule primitive using F#. Requires the Stride Community Toolkit. The example creates a game, sets up the base scene, adds a profiler, and positions a capsule at (0, 2.5, 0).

```fsharp
open Stride.CommunityToolkit.Engine;
open Stride.CommunityToolkit.ProceduralModels;
open Stride.Core.Mathematics;
open Stride.Engine;

let game = new Game()

let Start rootScene =
    game.SetupBase3DScene()
    game.AddProfiler() |> ignore

    let firstBox = game.CreatePrimitive(PrimitiveModelType.Capsule);
    firstBox.Transform.Position <- new Vector3(0f, 2.5f, 0f)
    firstBox.Scene <- rootScene

[<EntryPoint>]
let main argv =
    game.Run(start = Start)
    0
```

--------------------------------

### Install SDL2 on Fedora

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/platforms/linux/setup-and-requirements.md

Installs the SDL2 development library (minimum version 2.0.4) required for window creation and input handling on Fedora systems.

```bash
sudo dnf install SDL2-devel
```

--------------------------------

### Start streaming a texture

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/graphics/textures/streaming.md

Starts streaming the specified texture resource.

```C#
Streaming.StreamResources(myTexture);
```

--------------------------------

### Install OpenAL on Debian/Ubuntu

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/platforms/linux/setup-and-requirements.md

Installs the OpenAL library required for playing sounds and music on Debian/Ubuntu systems.

```bash
sudo apt install libopenal-dev
```

--------------------------------

### Play video with VideoComponent.Instance.Play()

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/video/set-up-a-video.md

Call this method on the VideoComponent instance to start playing the video. Use after setting up the video component and script.

```C#
myVideoComponent.Instance.Play();
```

--------------------------------

### Compositions completion example

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/graphics/effects-and-shaders/shader-development-vscode.md

Demonstrates composition completions, showing all shaders that implement the required interface when declaring a composition.

```cs
shader MyMaterial : MaterialPixelStream
{
    compose ComputeColor diffuseMap;
    //                    ^ Get suggestions for all ComputeColor implementations
}
```

--------------------------------

### Gizmo implementation example for MyScript component

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/scripts/gizmos.md

This is an exhaustive example of implementing a gizmo for a custom component. It includes the component class, the gizmo class with the required constructor, and the implementation of the IEntityGizmo interface. The gizmo creates a sphere model in the editor scene and handles selection and visibility.

```csharp
using Stride.Core;
using Stride.Core.Mathematics;
using Stride.Engine;
using Stride.Engine.Gizmos;
using Stride.Graphics;
using Stride.Graphics.GeometricPrimitives;
using Stride.Rendering;
using Stride.Rendering.Materials;
using Stride.Rendering.Materials.ComputeColors;

// We will be implementing a Gizmo for the following class
public class MyScript : StartupScript
{
    
}

// This attribute specifies to the engine that the following gizmo class is bound to 'MyScript', 
// the game studio will pick that up and spawn an instance of that class for each 'MyScript' in the scene
[GizmoComponent(typeof(MyScript), isMainGizmo:false/*When true, only the first gizmo on an entity with true is visible, false means that it is always visible*/)]
public class Gizmo : IEntityGizmo
{
    private bool _selected, _enabled;
    private MyScript _component;
    private ModelComponent _model;
    private Material _material, _materialOnSelect;

    // This property is set based on whether the gizmo is globally turned on or off in the editor's view settings
    public bool IsEnabled
    {
        get
        {
            return _enabled;
        }
        set
        {
            _enabled = value;
            _model.Enabled = _enabled;
        }
    }

    // The size slider value in the view settings pane
    public float SizeFactor { get; set; }

    // The editor will set this property whenever the entity the component is on is selected
    public bool IsSelected
    {
        get
        {
            return _selected;
        }
        set
        {
            _selected = value;
            _model.Materials[0] = _selected ? _materialOnSelect : _material;
            // The logic below shows gizmos for all components when they are on in the gizmo settings, and when off, only shows the one from the selected entity
            // Removing the line hides gizmos even when selected when the gizmo settings is off
            _model.Enabled = _selected || _enabled;
        }
    }

    // This constructor is called by the editor, 
    // A gizmo class MUST contain a constructor with a single parameter of the component's type
    public Gizmo(MyScript component)
    {
        _component = component;
    }

    public bool HandlesComponentId(OpaqueComponentId pickedComponentId, out Entity? selection)
    {
        // This function is called when scene picking/mouse clicking in the scene on a gizmo
        // The engine calls this function on each gizmos, gizmos in term notify the engine
        // when the given component comes from them by returning true, and provide the editor with the corresponding entity this gizmo represents
        if (pickedComponentId.Match(_model))
        {
            selection = _component.Entity;
            return true;
        }
        selection = null;
        return false;
    }

    public void Initialize(IServiceRegistry services, Scene editorScene)
    {
        // As part of initialization, we create a model in the editor scene to visualize the gizmo
        var graphicsDevice = services.GetSafeServiceAs<IGraphicsDeviceService>().GraphicsDevice;

        // In our case we'll just rely on the GeometricPrimitive API to create a sphere for us
        // You don't have to create one right away, you can delay it until the component is in the appropriate state
        // You can also dynamically create and update one in the Update() function further below
        var sphere = GeometricPrimitive.Sphere.New(graphicsDevice);

        var vertexBuffer = sphere.VertexBuffer;
        var indexBuffer = sphere.IndexBuffer;
        var vertexBufferBinding = new VertexBufferBinding(vertexBuffer, new VertexPositionNormalTexture().GetLayout(), vertexBuffer.ElementCount);
        var indexBufferBinding = new IndexBufferBinding(indexBuffer, sphere.IsIndex32Bits, indexBuffer.ElementCount);

        _material = Material.New(graphicsDevice, new MaterialDescriptor
        {
            Attributes =
            {
                Emissive = new MaterialEmissiveMapFeature(new ComputeColor(new Color4(0.25f,0.75f,0.25f,0.05f).ToColorSpace(graphicsDevice.ColorSpace))) { UseAlpha = true },
                Transparency = new MaterialTransparencyBlendFeature()
            },
        });
        _materialOnSelect = Material.New(graphicsDevice, new MaterialDescriptor
        {
            Attributes =
            {
                Emissive = new MaterialEmissiveMapFeature(new ComputeColor(new Color4(0.25f,0.75f,0.25f,0.5f).ToColorSpace(graphicsDevice.ColorSpace))) { UseAlpha = true },
                Transparency = new MaterialTransparencyBlendFeature()
            },
        });
```

--------------------------------

### Install SDL2 on Debian/Ubuntu

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/platforms/linux/setup-and-requirements.md

Installs the SDL2 development library (minimum version 2.0.4) required for window creation and input handling on Debian/Ubuntu systems.

```bash
sudo apt install libsdl2-dev
```

--------------------------------

### Install OpenAL on Fedora

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/platforms/linux/setup-and-requirements.md

Installs the OpenAL library required for playing sounds and music on Fedora systems.

```bash
sudo dnf install openal-soft-devel
```

--------------------------------

### Install docfx globally with dotnet tool

Source: https://github.com/stride3d/stride-docs/wiki/Installation

Installs the latest version of the docfx static site generator as a global .NET tool. Run this command in a terminal after ensuring .NET SDK 6.0 or higher is installed.

```bash
dotnet tool install -g docfx
```

--------------------------------

### Stride StartupScript initialization

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/stride-for-unity-developers/index.md

Shows a StartupScript with Start and Cancel methods for initialization and cleanup.

```csharp
public class BasicMethods : StartupScript
{
    // Declared public member fields and properties that will appear in the game studio
    public override void Start()
    {
        // Initialization of the script
    }

    public override void Cancel()
    {
        // Cleanup of the script
    }     
}
```

--------------------------------

### Install OpenAL on Arch

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/platforms/linux/setup-and-requirements.md

Installs the OpenAL library required for playing sounds and music on Arch Linux systems.

```bash
sudo pacman -S openal
```

--------------------------------

### Visual Basic example: Render a capsule with Stride Community Toolkit

Source: https://github.com/stride3d/stride-docs/blob/master/en/release-notes/4.2.md

Equivalent Visual Basic example to the F# one, rendering a capsule in a basic 3D scene. Uses the Stride Community Toolkit. The capsule is positioned at (0, 8, 0).

```vb
Imports Stride.CommunityToolkit.Engine
Imports Stride.CommunityToolkit.ProceduralModels
Imports Stride.Core.Mathematics
Imports Stride.Engine

Module Program
    Private game As New Game()

    Sub Main()
        GameExtensions.Run(game, Nothing, AddressOf StartGame)
    End Sub

    Private Sub StartGame(rootScene As Scene)
        game.SetupBase3DScene()
        game.AddProfiler()

        Dim entity = game.CreatePrimitive(PrimitiveModelType.Capsule)
        entity.Transform.Position = New Vector3(0, 8, 0)
        entity.Scene = rootScene
    End Sub
End Module
```

--------------------------------

### Install SDL2 on Arch

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/platforms/linux/setup-and-requirements.md

Installs the SDL2 development library (minimum version 2.0.4) required for window creation and input handling on Arch Linux systems.

```bash
sudo pacman -S sdl2
```

--------------------------------

### Alert include examples

Source: https://github.com/stride3d/stride-docs/blob/master/en/contributors/website/content-shortcodes-and-includes.md

Three examples of the `_alert.html` include: without an icon, with a default icon, and with a custom Font Awesome icon. The `type` parameter determines the color and default icon.

```liquid
# This will render as a green box without the icon
{% include _alert.html type:'success' icon:'' title:'No icon: Stride contributors are proud to announce a new release now running on .NET 6 supporting the latest C# 10.' %}
```

```liquid
# This will render as a green box with a check icon
{% include _alert.html type:'success' title:'No icon: Stride contributors are proud to announce a new release now running on .NET 6 supporting the latest C# 10.' %}
```

```liquid
# This will render as a green box with a custom icon
{% include _alert.html type:'success' icon:'fa-face-smile' title:'No icon: Stride contributors are proud to announce a new release now running on .NET 6 supporting the latest C# 10.' %}
```

--------------------------------

### MouseInputScript example for mouse input handling

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/input/mouse.md

Example SyncScript that checks for mouse button states and mouse movement in the Update method. It demonstrates using Input.IsMouseButtonDown, Input.IsMouseButtonPressed, and Input.MouseDelta.

```C#
public class MouseInputScript : SyncScript
{
	public override void Update()
	{
		//If the left mouse button is pressed in this update, do something.
		if (Input.IsMouseButtonDown(MouseButton.Left))
		{   
		}
		//If the middle mouse button has been pressed since the last update, do something.
		if (Input.IsMouseButtonPressed(MouseButton.Middle))
		{  
		}

		//If the mouse moved more than 0.2 units of the screen size in X direction, do something.
		if (Input.MouseDelta.X > 0.2f)
		{
		}
		
	}
}
```

--------------------------------

### Unity MonoBehaviour basic methods

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/stride-for-unity-developers/index.md

Shows the standard Unity MonoBehaviour with Start, OnDestroy, and Update methods.

```csharp
public class BasicMethods : MonoBehaviour
{
    void Start() { }
    void OnDestroy() { }
    void Update() { }
}
```

--------------------------------

### Example C# unit test file with RunGameTest helper

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/troubleshooting/unit-tests.md

Example C# test class with two xUnit tests: a simple assertion and a game test that adds an entity to the scene. Includes a private RunGameTest helper that runs a game with fixed time step (60fps) and executes the provided async function, then exits.

```cs
using Stride.Engine;

public class Tests
{
    [Fact]
    public void MyBareboneTest()
    {
        Assert.NotEqual(1, 2);
    }
    
    [Fact]
    public void MyGameTest()
    {
        RunGameTest(async (game, scene) =>
        {
            var myEntity = new Entity();
            scene.Entities.Add(myEntity);

            Assert.NotEmpty(scene.Entities);

            await game.Script.NextFrame(); // Wait one frame if you need to

            myEntity.Scene = null;

            Assert.Empty(scene.Entities);
        });
    }

    /// <summary>
    /// Run the given function within a game, providing support for tests requiring ECS, physics simulation, graphics and others.
    /// </summary>
    private static void RunGameTest(Func<Game, Scene, Task> asyncFunction)
    {
        using var game = new Game();
        
        // Fixed time step to reduce framerate discrepancies
        game.IsFixedTimeStep = true;
        game.IsDrawDesynchronized = false;
        game.TargetElapsedTime = TimeSpan.FromTicks(10000000 / 60); // 60hz, 60fps
        
        game.Script.AddTask(async () =>
        {
            await asyncFunction(game, game.SceneSystem.SceneInstance.RootScene);
            game.Exit();
        });
        game.Run();
    }
}
```

--------------------------------

### Excerpt Example

Source: https://github.com/stride3d/stride-docs/blob/master/en/contributors/website/content.md

Example of a blog post front matter and excerpt. The excerpt is the first paragraph separated by three dashes (---) and is used in the blog post list, meta description, and RSS feed.

```yaml
---
title: 'Stride 4.1 is Now Live'
author: aggror
tags: ['Tutorials','Release', 'Graphics']
---

Stride contributors are proud to announce a new release now running on .NET 6 supporting the latest C# 10. That means you can now head to the download page and start developing your games using the latest .NET technologies.

---

Additional content goes here...
```

--------------------------------

### Streams completion example

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/graphics/effects-and-shaders/shader-development-vscode.md

Demonstrates stream completions based on shader stage and declared streams. Type 'streams.' to see available streams.

```cs
shader MyVertexShader : ShaderBase, Transformation
{
    stage void VSMain()
    {
        // Type 'streams.' to see all available streams
        streams.Position = mul(streams.Position, World);
    }
}
```

--------------------------------

### StartupScript with Start() and Cancel() overrides

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/scripts/types-of-script/startup-script.md

Defines a startup script that overrides Start() and Cancel() to run code when the script is added to or removed from a scene. These methods are only called during runtime, not in Game Studio, and may execute multiple times if the entity is re-added or removed.

```csharp
public class Example : StartupScript
{
    public override void Start()
    {
        // Do stuff for when the script is loaded
    }
    
    public override void Cancel()
    {
        // Do stuff for when the script is unloaded
    }
}
```

--------------------------------

### stride sdk install

Source: https://github.com/stride3d/stride-docs/blob/master/en/includes/cli-manage-versions-commands.md

Installs the latest version of the engine or the resolved project's version located in the current directory. Optionally, a specific version can be specified.

```APIDOC
## stride sdk install

### Description
Installs the latest version of the engine or the resolved project's version located in the current directory. Optionally, a specific version can be specified.

### Method
CLI

### Command
`stride sdk install [VERSION]`

### Parameters
- **VERSION** (string) - Optional - Specific version to install. Version patch number is optional (e.g., `4.3`).

### Notes
- The CLI will ignore beta versions of the engine, unless the `--prerelease` flag is passed.

### Example
```bash
stride sdk install
stride sdk install 4.3
```
```

--------------------------------

### Example .sdpkg with template included

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/scripts/custom-assets.md

Shows a complete default game .sdpkg file after adding the template registration. The TemplateFolders section is placed after Bundles and before RootAssets, demonstrating the expected structure.

```yaml
!Package
SerializedVersion: {Assets: 3.1.0.0}
Meta:
    Name: MyGame21
    Version: 1.0.0
    Authors: []
    Owners: []
    Dependencies: null
AssetFolders:
    -   Path: !dir Assets
    -   Path: !dir Effects
ResourceFolders:
    - !dir Resources
OutputGroupDirectories: {}
ExplicitFolders: []
Bundles: []
TemplateFolders:
    - Path: !dir Templates
      Group: Assets
      Files:
        - !file Templates/YOUR_TEMPLATE.sdtpl
RootAssets: []
```

--------------------------------

### Tessellation shader HSMain, HSConstantMain, DSMain example

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/graphics/effects-and-shaders/shading-language/shader-stages.md

An example tessellation shader with hull shader, patch constant function, and domain shader. It uses attributes like domain, partitioning, outputtopology, outputcontrolpoints, patchconstantfunc, and maxtessfactor. Input and Input2 behave like streams. Note: assign output to streams at the end of each stage.

```csharp
[domain("tri")]
[partitioning("fractional_odd")]
[outputtopology("triangle_cw")]
[outputcontrolpoints(3)]
[patchconstantfunc("HSConstantMain")]
[maxtessfactor(48.0)]
void HSMain(InputPatch<Input, 3> input, out Output output, uint uCPID : SV_OutputControlPointID)
{
	...
	output = streams;
}
 
void HSConstantMain(InputPatch<Input, 3> input, const OutputPatch<Input2, 3> output, out Constants constants)
{
	...
	output = streams;
	...
}
 
[domain("tri")]
void DSMain(const OutputPatch<Input, 3> input, out Output output, in Constants constants, float3 f3BarycentricCoords : SV_DomainLocation)
{
	...
	output = streams;
	...
}
```

--------------------------------

### stride sdk list

Source: https://github.com/stride3d/stride-docs/blob/master/en/includes/cli-manage-versions-commands.md

Lists all installed versions of the engine.

```APIDOC
## stride sdk list

### Description
Lists all installed versions of the engine.

### Method
CLI

### Command
`stride sdk list`

### Example
```bash
stride sdk list
```
```

--------------------------------

### Create a new Stride project and run it

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/get-started/stride-cli.md

A workflow to install the latest Stride version, create a new game project named 'ProjectX', enter its directory, build and run the project, and open Game Studio. Each command is a step in the process.

```bash
stride sdk install # Install the latest version
```

```bash
stride new game -n ProjectX && cd ProjectX # Create a new project and enter it's directory
```

```bash
dotnet run --project ProjectX.Windows # Build and run the project
```

```bash
stride studio # Open Game Studio
```

--------------------------------

### Instantiate Entity / GameObject - Unity

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/stride-for-unity-developers/index.md

Unity's Instantiate method creates a copy of a GameObject prefab and adds it to the scene. This example shows the typical usage in a MonoBehaviour Start method.

```cs
public GameObject CarPrefab;
public Vector3 SpawnPosition;
public Quaternion SpawnRotation;

void Start()
{
    GameObject newGameObject = (GameObject)Instantiate(CarPrefab, SpawnPosition, SpawnRotation);
    newGameObject.name = "NewGameObject1";
}
```

--------------------------------

### Stride SyncScript basic methods

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/stride-for-unity-developers/index.md

Shows a Stride SyncScript with overridden Start, Cancel, and Update methods.

```csharp
public class BasicMethods : SyncScript
{
    public override void Start() { }
    public override void Cancel() { }        
    public override void Update() { }
}
```

--------------------------------

### Unity input handling example

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/stride-for-unity-developers/index.md

Shows Unity's input API for keyboard, joystick, and axis input. Use this as a reference when porting input code to Stride.

```cs
void Update()
{
    // true for one frame in which the space bar was pressed
    if (Input.GetKeyDown(KeyCode.Space))
    {
        // Do something.
    }

    // true while this joystick button is down
    if (Input.GetButton("joystick button 0"))
    {
        // Do something.
    }

    float horiz = Input.GetAxis("Horizontal");
    float vert = Input.GetAxis("Vertical");
    // Do something else.
}
```

--------------------------------

### Example script: logging texture load status

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/troubleshooting/logging.md

A complete script that checks if the texture 'MyTexture' is loaded. It logs a debug message when loading starts and when successful, and an error message if loading fails.

```csharp
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Stride.Core.Diagnostics;
using Stride.Core.Mathematics;
using Stride.Input;
using Stride.Engine;
using Stride.Graphics;

namespace MyGame
{
    public class Script : SyncScript
    {
		public Texture myTexture;

        public override void Start()
        {
            // Initialization of the script.
            Log.ActivateLog(LogMessageType.Debug);
            Log.Debug("Start loading MyTexture");

            myTexture = Content.Load<Texture>("MyTexture");
            if (myTexture == null)
            {
                Log.Error("MyTexture not loaded");
            }
            else
            {
                Log.Debug("MyTexture loaded successfully");
            }
        }
    }
}
```

--------------------------------

### Semantic bindings completion example

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/graphics/effects-and-shaders/shader-development-vscode.md

Shows semantic binding completions after typing ':' in shader input/output declarations. Hover over semantics for documentation.

```cs
shader MyShader : ShaderBase
{
    stage stream float4 Position : SV_Position;
    //                              ^ Get completions for all valid semantics

    stage stream float2 TexCoord : TEXCOORD0;
    //                              ^ Hover for documentation
}
```

--------------------------------

### Synchronous script example: inherit from SyncScript and override Update

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/scripts/types-of-script/index.md

Synchronous scripts are initialized, updated every frame, and canceled when removed. Override the Update method to execute code every frame; Start and Cancel methods are also available.

```csharp
public class Example : SyncScript
{        
  public override void Update()
  {
    // Do stuff that needs to be executed every frame
  }
}
```

--------------------------------

### Create class library with dotnet new

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/files-and-folders/project-packages/create-a-package.md

Creates a new project package from the command line using the dotnet CLI. Replace MyGame.MyLibrary with your package name.

```bash
dotnet new classlib --name MyGame.MyLibrary
```

--------------------------------

### Get the actual screen size using IPointerDevice.SurfaceSize

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/input/mouse.md

Use this snippet to retrieve the actual screen size in pixels, which is useful when working with absolute mouse coordinates. The example accesses the SurfaceSize property of the mouse device via the Input manager.

```csharp
var surfaceSize = Input.Mouse.SurfaceSize;
```

--------------------------------

### PlayerInput.cs Camera Property Change from CameraComponent to Entity

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/physics-bullet/fix-physics-jitter.md

In the First Person Shooter template, change the Camera property type from CameraComponent to Entity to support the new smoothing setup. This is part of the example usage for integrating smooth camera movement.

```csharp
public CameraComponent Camera { get; set; }
```

```csharp
public Entity Camera { get; set; }
```

--------------------------------

### Bash: Create new Stride game with parameters

Source: https://github.com/stride3d/stride-docs/blob/master/en/includes/cli-new-project-parameters.md

Example command for creating a new Stride game project named ProjectX with HDR enabled and targeting Windows and Linux platforms. Use the --help flag to list all available parameters.

```bash
stride new game -n ProjectX --HDR true --platform windows\|linux
```

--------------------------------

### Run BuildDocs.ps1 menu

Source: https://github.com/stride3d/stride-docs/wiki/Installation

Starts the PowerShell script BuildDocs.ps1 via run.bat, which presents a menu for building documentation and running the local website.

```text
Please select an option:

  [en] Build English documentation
  [jp] Build Japanese documentation
  [all] Build documentation in all available languages
  [r] Run local website
  [c] Cancel

Your choice:
```

--------------------------------

### Example .sdpkg file for MyGame.Game

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/files-and-folders/project-packages/package-properties.md

Shows the structure of a .sdpkg file with two asset folders and one resource folder. The file includes metadata, asset folders, resource folders, and empty collections for other properties.

```yaml
!Package
SerializedVersion: {Assets: 3.1.0.0}
Meta:
    Name: MyGame.Game
    Version: 1.0.0
    Authors: []
    Owners: []
    Dependencies: null
AssetFolders:
    - Path: !dir Assets
    - Path: !dir Effects
ResourceFolders:
    - !dir Resources
OutputGroupDirectories: {}
ExplicitFolders: []
Bundles: []
TemplateFolders: []
RootAssets: []
```

--------------------------------

### Install Stride CLI via dotnet tool

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/get-started/stride-cli.md

Installs the Stride CLI globally using the .NET tool installer. After installation, you may need to restart your terminal for the 'stride' command to become available.

```bash
dotnet tool install -g stride.cli
```

--------------------------------

### Basic composition example

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/graphics/effects-and-shaders/shading-language/composition.md

Defines a base shader class and two derived shader classes, then composes them in a BaseShader. The composed shaders are used to compute colors.

```cs
shader CompositionBase
{
	float4 Compute()
	{
		return float4(0.0);
	}
};
 
shader CompositionShaderA : CompositionBase
{
	float4 myColor;
 
	override float4 Compute()
	{
		return myColor;
	}
};
 
shader CompositionShaderB : CompositionBase
{
	float4 myColor;

	override float4 Compute()
	{
		return 0.5 * myColor;
	}
};
 
shader BaseShader
{
	CompositionBase Comp0;
	CompositionBase Comp1;
 
	float4 GetColor()
	{
		return Comp0.Compute() + Comp1.Compute();
	}
};
```

--------------------------------

### PowerShell: Create new Stride game with parameters

Source: https://github.com/stride3d/stride-docs/blob/master/en/includes/cli-new-project-parameters.md

Example command for creating a new Stride game project named ProjectX with HDR enabled and targeting Windows and Linux platforms. Use the --help flag to list all available parameters.

```powershell
stride new game -n ProjectX --HDR true --platform windows`|linux
```

--------------------------------

### Custom gizmo model setup and update

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/scripts/gizmos.md

Creates a ModelComponent with a mesh, sets up picking render group for selection, attaches buffers to the entity, and updates the gizmo's transform to follow the target entity. Note that UseTRS is disabled for direct matrix control, and buffers are disposed with the entity.

```csharp
        _model = new ModelComponent
        {
            Model = new Model
            {
                (_selected ? _materialOnSelect : _material),
                new Mesh
                {
                    Draw = new MeshDraw
                    {
                        StartLocation = 0,
                        // You can swap to LineList or LineStrip to show the model in wireframe mode, you'll have to adapt your index buffer to that new type though
                        PrimitiveType = PrimitiveType.TriangleList,
                        VertexBuffers = new[] { vertexBufferBinding },
                        IndexBuffer = indexBufferBinding,
                        DrawCount = indexBuffer.ElementCount,
                    }
                }
            },
            RenderGroup = IEntityGizmo.PickingRenderGroup, // This RenderGroup allows scene picking/selection, use a different one if you don't want selection
            Enabled = _selected || _enabled
        };

        var entity = new Entity($"{nameof(Gizmo)} for {_component.Entity.Name}"){ _model };
        entity.Transform.UseTRS = false; // We're controlling the matrix directly in this case
        entity.Scene = editorScene;

        vertexBuffer.DisposeBy(entity);
        indexBuffer.DisposeBy(entity); // Attach buffers to the entity for manual disposal later
    }

    public void Dispose()
    {
        _model.Entity.Scene = null;
        _model.Entity.Dispose(); // Clear the two buffers we attached above
    }

    public void Update()
    {
        // This is where you'll update how the gizmo looks based on MyScript's state
        // Here we'll just ensure the gizmo follows the entity it is representing whenever that entity moves, 
        // note that UseTRS is disabled above to improve performance and ensure that there are no world space issues
        _model.Entity.Transform.LocalMatrix = _component.Entity.Transform.WorldMatrix;
    }
}
```

--------------------------------

### View Stride upgrade help

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/install-and-update/update-stride.md

Run this command to see all available flags and parameters for the stride upgrade command.

```bash
stride upgrade --help
```

--------------------------------

### Create new C# project for NuGet packages

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/platforms/linux/install-the-editor-using-wine.md

Create a new class library project to help download required NuGet packages into the cache. Run this command in the terminal.

```bash
dotnet new classlib -n StrideProtonFix && cd StrideProtonFix
```

--------------------------------

### stride sdk update

Source: https://github.com/stride3d/stride-docs/blob/master/en/includes/cli-manage-versions-commands.md

Updates all installed versions of the engine to the latest patch. Optionally, a specific installed version can be updated.

```APIDOC
## stride sdk update

### Description
Updates all installed versions of the engine to the latest patch. Optionally, a specific installed version can be updated.

### Method
CLI

### Command
`stride sdk update [VERSION]`

### Parameters
- **VERSION** (string) - Optional - Specific installed version to update. Version patch number is optional (e.g., `4.3`).

### Example
```bash
stride sdk update
stride sdk update 4.3
```
```

--------------------------------

### Enable and disable dynamic navigation from a script

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/navigation/dynamic-navigation.md

C# example showing how to find the DynamicNavigationMeshSystem, enable it, disable automatic rebuilds, and trigger an asynchronous rebuild. The code includes a comment about conditions that should cause a rebuild, such as opening or closing a door.

```csharp
// Find and enable the dynamic navigation mesh system
dynamicNavigationMeshSystem = Game.GameSystems.OfType<DynamicNavigationMeshSystem>().FirstOrDefault();
dynamicNavigationMeshSystem.Enabled = true;

// This stops the dynamic navigation mesh system from automatically rebuilding in the folowing cases:
//  - loading/Unloading scenes
//  - adding/removing static collider components
//  - adding/removing navigation mesh bounding boxes
dynamicNavigationMeshSystem.AutomaticRebuild = false;

// ...

if (/* any condition that should cause the navigation mesh to update (eg open/close door) */)
{
	// Start an asynchronous rebuild of the navigation mesh
	var rebuildTask = dynamicNavigationMeshSystem.Rebuild();
	rebuildTask.ContinueWith((x) =>
	{
		if (x.Result.Success)
		{
			// The navigation mesh is successfully rebuilt
		}
	});
}
```

--------------------------------

### Install FreeType on Fedora

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/platforms/linux/setup-and-requirements.md

Installs the FreeType development library (minimum version 2.6) required for font rendering on Fedora systems.

```bash
sudo dnf install freetype-devel
```

--------------------------------

### Using an EffectInstance to set up pipeline and bind resources

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/graphics/low-level-api/resources.md

Creates an EffectInstance from a loaded effect, sets the effect bytecode and root signature on the pipeline state description, and applies constant buffer updates and resource binding. This is the automatic binding approach.

```cs
// Create a EffectInstance and use it to set up the pipeline
var effectInstance = new EffectInstance(EffectSystem.LoadEffect("MyEffect").WaitForResult());
pipelineStateDescription.EffectBytecode = effectInstance.Effect.Bytecode;
pipelineStateDescription.RootSignature = effectInstance.RootSignature;

// Update constant buffers and bind resources
effectInstance.Apply(context.GraphicsContext);
```

--------------------------------

### Stride input handling example

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/stride-for-unity-developers/index.md

Shows Stride's input API for keyboard, joystick, and axis input. Use this as a reference when porting input code from Unity.

```cs
public override void Update()
{
    // true for one frame in which the space bar was pressed
    if (Input.IsKeyDown(Keys.Space))
    {
        // Do something.
    }

    // true while this joystick button is down
    if (Input.GameControllers[0].IsButtonDown(0))
    {
        // Do something.
    }

    float horiz = (Input.IsKeyDown(Keys.Left) ? -1f : 0) + (Input.IsKeyDown(Keys.Right) ? 1f : 0);
    float vert = (Input.IsKeyDown(Keys.Down) ? -1f : 0) + (Input.IsKeyDown(Keys.Up) ? 1f : 0);
    // Do something else.
}
```

--------------------------------

### Install FreeType on Debian/Ubuntu

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/platforms/linux/setup-and-requirements.md

Installs the FreeType development library (minimum version 2.6) required for font rendering on Debian/Ubuntu systems.

```bash
sudo apt install libfreetype6-dev
```

--------------------------------

### Get orientation as quaternion

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/input/sensors.md

Use Input.Orientation.Quaternion to get the device orientation as a quaternion. The quaternion form is recommended because it avoids gimbal lock.

```C#
var orientation = Input.Orientation.Quaternion;
```

--------------------------------

### Install FreeType on Arch

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/platforms/linux/setup-and-requirements.md

Installs the FreeType development library (minimum version 2.6) required for font rendering on Arch Linux systems.

```bash
sudo pacman -S freetype2
```

--------------------------------

### Compute shader CSMain example

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/graphics/effects-and-shaders/shading-language/shader-stages.md

An example compute shader with numthreads(2, 3, 5). You can inherit from ComputeShaderBase and override the Compute method.

```csharp
[numthreads(2, 3, 5)]
void CSMain()
{
	...
}
```

--------------------------------

### Navigate to the project package directory

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/get-started/create-a-project.md

Changes to the main project package directory, which ends with '.Game'. Replace 'NameOfGame' with the game name.

```bash
cd ./NameOfGame/NameOfGame.Game
```

--------------------------------

### Using parameters in SDFX

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/graphics/effects-and-shaders/effect-language.md

Shows how to use parameter keys in an SDFX file, requiring the 'using params' statement and demonstrating conditional mixin composition.

```cs
using params MaterialParameters;
 
if (MaterialParameters.AlbedoDiffuse != null)
{
	mixin MaterialParameters.AlbedoDiffuse;
}
```

--------------------------------

### Asset bundle configuration in .sdpkg

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/assets/asset-bundles.md

Example YAML configuration defining custom bundles with tag and path selectors. Note that empty custom bundles cause the build to fail.

```yaml
Bundles:
 - Name: CustomBundleA
   Selectors:
    - !TagSelector
      Tags: 
        - MyTag1
        - MyTag2
 - Name: CustomBundleB
   Dependencies:
    - CustomBundleA
   Selectors:
    - !TagSelector
      Tags: 
        - MyTag3
        - MyTag4
    - !PathSelector
      Paths:
        - folder1/
        - /folder2/
        - *.sdtex
        - folder3/*.sdscene
```

--------------------------------

### Invalid example: STRDIAG000.cs with [DataMember] and [DataMemberIgnore]

Source: https://github.com/stride3d/stride-docs/blob/master/en/diagnostics/STRDIAG000.md

This C# code triggers STRDIAG000 on each property because [DataMember] and [DataMemberIgnore] are contradictory. The example includes both a property and a field.

```csharp
// STRDIAG000.cs
using Stride.Core;

public class STRDIAG000
{
    [DataMember]
    [DataMemberIgnore]
    public int Value { get; set; }

    [DataMember]
    [DataMemberIgnore]
    public int Value;
}
```

--------------------------------

### Open a Stride project in Game Studio

Source: https://github.com/stride3d/stride-docs/blob/master/en/manual/get-started/create-a-project.md

Opens the specified project in Game Studio. Replace 'ProjectNameHere' with the project name.

```bash
stride studio ./ProjectNameHere
```

--------------------------------

### Play Sound Before and After Upgrade

Source: https://github.com/stride3d/stride-docs/blob/master/en/release-notes/1.7.md

The way you use Sound and SoundInstance has changed. Before, you called MySound.Play(); after, you create an instance and play it.

```csharp
MySound.Play();
```

```csharp
mySoundInstance = MySound.CreateInstance();
mySoundInstance.Play();
```
Tokens:
Raw