Code or not to code

Stride Community Toolkit Preview - Code-Only Feature Basics in C# - Bepu Physics

2025-04-13T00:00:00Z

Discover the Stride Community Toolkit, a powerful collection of extensions and helpers designed for the Stride game engine. In this blog post (Bepu Physics version), we dive into the toolkit's code-only feature, empowering C# and .NET developers to create immersive 2D/3D games and visualizations with ease. Explore how this community-driven, open-source project can simplify your game development journey.

This blog post is part 1 of a 3-part series:

Stride Community Toolkit Preview - Code-Only Feature - Basics (C#)
- Bullet Physics version
- Also available: Condensed F# version of this tutorial
- The Visual Basic version is also possible but I am running out of space here 😅
Stride Community Toolkit Preview - Code-Only Feature - Advanced
Stride Community Toolkit Preview - Code-Only Feature - Refactoring

Table of Contents:

Introduction 🌱 🔗

Welcome to the preview of the Stride Community Toolkit, a collection of extensions and helpers for the Stride C# game engine. This community-driven, open-source project is designed to assist developers in creating 2D/3D games and visualizations using Stride.

Although the toolkit is still in its early stages, it already offers several valuable features. In this post, I will focus on the code-only approach, which I found particularly useful for development.

This article assumes that you have some experience with .NET and C# programming.

The toolkit allows you to create a game using a code-only approach, meaning you can develop a game without relying on the Stride Game Studio. As a C#/.NET developer in my day job, I found this approach very helpful for getting started with the Stride engine and game development, bypassing the need to work directly in the Game Studio.

You can also access the full source code for this post on GitHub to follow along or explore the final implementation directly.

Additional details on the benefits of the code-only approach can be found here in the toolkit documentation.

We will be using a standard .NET 10 Console App to create a simple game by adding some NuGet packages to get started.

Here’s the process I found to be the easiest way to begin with the code-only approach:

Run the minimal code to get the game window running
Add entities/primitives to the scene
Add interaction with the keyboard and mouse
Add output to the console or screen
Play around, be creative and have fun

This post was updated to use the latest version of the Stride Community Toolkit, which now includes the Bepu physics engine as the default physics engine. The previous version used Bullet Physics, which is still available but not recommended for new projects. The Bepu physics engine is a powerful and efficient physics engine that provides advanced simulation capabilities for 3D games and visualizations. Thank you Daryl for your help with this update! 🙏

What You'll Learn 🎯 🔗

By the end of this post, you will have a solid foundation in using the Stride Community Toolkit's code-only feature to create a simple game. You’ll learn how to:

Set up the game window and initialize the core components
Add and manipulate entities within the scene
Implement basic interactivity using the keyboard and mouse
Display text output to the console or directly on the screen for debugging or player feedback

Coding enhances creativity and problem-solving, and we can take that creativity to the next level through visualization, whether it's in games, simulations, or simply experimenting with 3D models in a virtual space.

Whether you’re a seasoned developer or new to game development, this post will guide you through the essential steps to get your first game up and running with Stride. Ready to dive in? Let’s get started! 🚀

Basic Terminology 📚 🔗

Before diving into the steps, it's helpful to understand some key terms that will be used throughout this guide:

Stride: A C# game engine for creating 2D/3D games and visualizations.
Stride Community Toolkit: A collection of extensions and helpers for the Stride engine.
Bepu Physics: The preferred physics engine for Stride, providing advanced Bepu physics simulation capabilities.
Code-Only: A feature of the toolkit that allows you to create a game without using the Game Studio.
Game: In the context of this post, a game refers to any interactive or visual project created using a game engine. This can range from traditional playable games to simulations, visualizations, or any real-time interactive experiences where users can interact with or observe elements within a scene.
Scene: The container for entities, which defines the game world or environment.
Entity: An object in the scene that can represent anything from a 3D model to a camera or light and aggregates multiple EntityComponents.
EntityComponent: A base component that defines the behavior or properties of an entity. Other components inherit from this class.
BodyComponent: A physics component that allows an entity to respond to forces like gravity and collisions.
Graphics Compositor: A component that organizes how scenes are rendered in the Stride engine.
Camera: A camera that allows viewing the scene from different angles.
Camera Controller: A script that enables basic camera movement using keyboard and mouse inputs.
3D Primitive: A basic 3D model, such as a capsule, cube, or sphere.
Collidable: A component that defines the shape of an entity for physical interactions.
Physics Engine: A system that simulates physical interactions between entities in the scene.
Profiler: A tool that monitors performance metrics like frames per second (FPS) and memory usage.
Skybox: A textured 3D model that provides a background for the scene.
Game Loop: The main loop that drives the game, updating the state and rendering the scene.
Update Method: A callback method that is called every frame to update the game state.
Physics-Based Movement: Moving entities using the physics engine to simulate realistic interactions.
Non-Physical Movement: Moving entities by directly changing their position without physics interactions.
Transform: Defines an entity's position, rotation, and scale in the scene.
Impulse: A vector that represents a physical impulse applied to an entity.
Delta Time: The time elapsed between frames, used for frame-independent movement.
Material: A visual property that defines how an entity is rendered, including color, texture, and shading.
Ground Gizmo: A visual representation of the ground plane and axis directions in the scene.
GameTime: A structure that provides time-related information for the game loop.
Vector3: A 3D vector that represents a point or direction in 3D space.
Frame Rate: The number of frames rendered per second, measured in frames per second (FPS).

Prerequisites 🏠 🔗

These prerequisites were tested on a clean Windows 11 installation.

Install the Microsoft Visual C++ v14 Redistributable (x64) (approximately 19MB) and restart your system if prompted.
Install the .NET 10 SDK x64 (around 215MB).
Install the IDE of your choice. I will be using Visual Studio 2026 (the Community version is free), but you can also use:
- Visual Studio Code - Free
- Rider - Free for non-commercial use
- Any other IDE that supports .NET development

How to use the code snippets 📝 🔗

You can copy and paste the code into your Program.cs file and run the application to see the results.

You will be guided to replace some parts of the code with the new code snippets as you progress through the steps or replacing the entire Program.cs file.

Also, the code snippets contain comments which part of the code is new or updated.

Code-Only on Windows 🪟 🔗

The code-only approach is currently available only on Windows. The toolkit provides a set of NuGet packages that you can use to create a game without the need for the Game Studio.

Code-Only on Other Platforms 🐧 🔗

Code-only development isn't fully supported on non-Windows platforms yet, but progress is being made. Thanks to this PR, the build tool Stride.Core.Assets.CompilerApp, which is responsible for building assets, now works on Linux as a cross-platform binary.

However, there are still some limitations. A known workaround for Linux (Ubuntu) is documented here: Code-Only Development on Linux (Ubuntu) Requires Manual File Copying.

While Stride is a cross-platform engine and you can build your game on Windows and run it elsewhere, full support for code-only workflows on platforms like Linux is still evolving.

The Story of the Brave Explorers 📘 🔗

🌍 Welcome, brave explorers of the digital wilderness! Today, we embark on an exciting journey into the heart of the Stride game engine. Our guide? None other than the Stride Community Toolkit.

In the vast expanse of the coding universe, we'll create a new world from nothing but a .NET 10 Console App. Prepare to witness the birth of a game window, a black void of nothingness that will soon teem with life 🫎.

As we venture further, we'll bring light into our world, transforming the empty void into a vibrant blue expanse. But what's a world without inhabitants? We'll conjure a 3D capsule, our first digital lifeform, into existence.

Beware, fellow adventurers! Our capsule is a wild creature, prone to falling into the void. But fear not, for we'll harness the power of a 3D camera 🎥 controller to keep a watchful eye 👁️ on our creation.

As we continue, we'll introduce motion, allowing our entities to interact with their surroundings and respond to player input. From keyboard controls to mouse interactions, our world will come to life with movement and action. 🕹️

Finally, we’ll display messages and feedback with both console output and on-screen text, letting our creation communicate with us through the game window. 📝

So, refresh your mouse agility skills 🖱️, and join us on this exhilarating expedition. Let's dive into the code! 💻

Step 1: Create a New C# .NET 10 Console App - Nothingness ⚫ 🔗

Create a new C# .NET 10 Console App in your IDE or use the command line:
```
dotnet new console --framework net10.0 --name YourProjectName
```

Add the following NuGet package: 📦

dotnet add package Stride.CommunityToolkit.Windows --prerelease

Paste the following code into your Program.cs file: 💻

using Stride.Engine;

// Create an instance of the game
using var game = new Game();

// Start the game loop
// This method initializes the game, begins running the game loop,
// and starts processing events.
game.Run();

Build the project from the command line or use your IDE to build it:
```
dotnet build
```
Run the application.
Behold the black void of nothingness 🙀.

If you're still on Stride 4.2, use --version 1.0.0-preview.61 instead of --prerelease, which targets Stride 4.3. This applies to all NuGet packages mentioned below.

The NuGet package Stride.CommunityToolkit.Windows is used specifically for code-only projects. You should use the Stride.CommunityToolkit NuGet package when referencing from a regular Stride project generated from the Game Studio.

You’ve learned how to set up a Stride game window using the Stride Community Toolkit. Even though it's just a black screen, the game window is running, marking the first step in your journey.

Step 2: Let There Be Light - Or at Least Blue 🌌 🔗

Once upon a time in a galaxy far, far away, you should see a window with a black background. This is the Stride game window. 🖥️ As a black screen is not very exciting, let's add some mystery code to make it more interesting. This time, we use the Stride.CommunityToolkit.Engine namespace so we can reference some of the toolkit helper methods. 🔧✨

Update the Program.cs file to look like this, or simply replace the entire file:

using Stride.CommunityToolkit.Engine; // This was added: Import the toolkit's helper methods
using Stride.Engine;

// Create an instance of the game
using var game = new Game();

// Start the game loop and provide the Start method as a callback
// This method initializes the game, begins running the game loop,
// and starts processing events.
game.Run(start: Start);  // This was updated

// This was added
// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera to the scene to allow viewing from different angles
    game.Add3DCamera();
}

The code above does the following:

Start() method is a callback that is invoked when the game starts. It takes a Scene object as a parameter, representing the root scene of the game.
AddGraphicsCompositor() organizes how scenes are rendered in the Stride engine, enabling extensive customization of the rendering pipeline.
Add3DCamera() adds a 3D camera to the scene, allowing you to view it from various angles.

Run the application again. Now, instead of a black screen, you should see a blue screen. 🌌 While not overly exciting, it’s a step in the right direction. We’re looking through the camera, but there’s nothing to see yet. 👀

You’ve learned that Graphics Compositor is used to handle rendering and 3D Camera is used to view the scene from different angles. There's still nothing to see yet because we haven’t added any objects to the scene. 🤷‍♂️

Step 3: Add Some Shapes - Capsule Time! 🎨 🔗

Firstly, we need to add another NuGet package, Stride.CommunityToolkit.Bepu, which includes the Bepu physics engine. This package is required for the physics engine to work properly. You can add it using the following command:

dotnet add package Stride.CommunityToolkit.Bepu --prerelease

Now let's add something to the scene. 🎨 This time, we will be utilizing the Stride.CommunityToolkit.Rendering.ProceduralModels namespace, which provides helper methods for generating procedural models like capsules, cubes, and spheres. We will add a capsule to the scene.

Update the Program.cs file to look like this, or simply replace the entire file:

using Stride.CommunityToolkit.Bepu; // This was added: Import the Bepu physics engine
using Stride.CommunityToolkit.Engine;
using Stride.CommunityToolkit.Rendering.ProceduralModels;  // This was added: Import procedural model helpers
using Stride.Engine;

// Create an instance of the game
using var game = new Game();

// Start the game loop and provide the Start method as a callback
// This method initializes the game, begins running the game loop,
// and starts processing events.
game.Run(start: Start);

// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera to the scene to allow viewing from different angles
    game.Add3DCamera();

    // Create a 3D primitive capsule and store it in an entity
    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule); // This was added
}

In this step, we added a new line that creates a 3D primitive capsule. 🧊 The Create3DPrimitive() method takes a PrimitiveModelType enum as a parameter and returns an Entity object, with a collider included by default. The PrimitiveModelType enum defines the types of primitive 3D models that can be generated, such as capsules, cubes, and spheres.

Run the application again. Surprise, nothing happened! 😲🤬 We created an entity, but we didn't add it to the scene. This is a typical beginner's mistake 🤦‍♂️. To fix it, update the Start() method to look like this.

You can replace the entire Start() method with the code below:

// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera to the scene to allow viewing from different angles
    game.Add3DCamera();

    // Create a 3D primitive capsule and store it in an entity
    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule);

    // Add the entity to the root scene so it becomes part of the scene graph
    entity.Scene = scene; // This was added
}

Now, run the application again. You should see a capsule in the middle of the screen if you're lucky because it's falling down. Fast! 🚀

You’ve learned how to create and add a 3D capsule to the scene using procedural models. By adding the entity to the root scene, it becomes part of the scene graph. The capsule is falling because it lacks a collider to interact with the ground, which we'll address later.

Step 4: Control the Camera - Look Around! 🖱️ 🔗

Maybe we should at least look around the scene and view the capsule from different angles as it falls into the void 🤔?

Let's add a 3D camera controller using the Add3DCameraController() method. 🎮 This extension adds basic camera functionality, allowing you to interact with the camera through keyboard and mouse inputs. Specifically, it attaches a regular SyncScript to the camera with custom logic to handle camera movement.

In most games, you would implement your own custom camera logic to fit the specific needs of your game. However, for this example, we'll use the default camera controller to get basic camera movement up and running quickly.

Time to refresh those mouse agility skills!

// This was updated: Add a camera controller for basic camera movement
game.Add3DCamera().Add3DCameraController();

Run the application again and use right-click and hold to rotate the camera towards the capsule, or follow the instructions displayed on the screen. 🎥 Feeling a bit more satisfied now? Let’s make the experience even more interesting! 🎨✨

You’ve learned how to add a 3D camera controller to the scene, enabling basic camera movement. Now, you can rotate the camera using the mouse and keyboard, giving you more control over how you view the scene.

Step 5: Reposition the Capsule - More Excitement! 📍 🔗

Let's reposition the capsule to add a bit more excitement and give us a few extra seconds to admire it before it falls. Update the Start() method as shown below, and don't forget to add the Stride.Core.Mathematics namespace for handling the 3D positioning.

Make sure that Stride.Core.Mathematics is used instead of System.Numerics which also contains Vector3.

Update the Program.cs file to look like this, or simply replace the entire file:

using Stride.CommunityToolkit.Bepu;
using Stride.CommunityToolkit.Engine;
using Stride.CommunityToolkit.Rendering.ProceduralModels;
using Stride.Core.Mathematics;  // This was added: Import Vector3 and other math utilities
using Stride.Engine;

// Create an instance of the game
using var game = new Game();

// Start the game loop and provide the Start method as a callback
// This method initializes the game, begins running the game loop,
// and starts processing events.
game.Run(start: Start);

// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera and a controller for basic camera movement
    game.Add3DCamera().Add3DCameraController();

    // Create a 3D primitive capsule and store it in an entity
    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule);

    // Reposition the capsule 8 units above the origin in the scene
    entity.Transform.Position = new Vector3(0, 8, 0); // This was added

    // Add the entity to the root scene so it becomes part of the scene graph
    entity.Scene = scene;
}

entity.Transform.Position sets the position of the entity within the scene. The Vector3 object represents a 3D vector, which in this case, places the capsule at coordinates (0, 8, 0), which is 8 units above the scene's origin.
Stride.Core.Mathematics Stride uses its own implementation of Vector3 and other math utilities, so we need to add this namespace to access those features.

Run the application again. You should see a capsule falling down from the top of the screen. I know, the capsule is black, but don't worry, we'll fix that later. 😉

You’ve learned how to reposition the capsule in the scene using the Transform component's Position property. The capsule is now positioned 8 units above the origin, giving you more time to admire it as it falls into the void.

Step 6: Add a Ground - Catch the Capsule! 🛑 🔗

Now let's catch the capsule by adding some ground to the scene. Update the Start() method to look like this so we can feel more grounded.

You can replace the entire Start() method with the code below:

// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera and a controller for basic camera movement
    game.Add3DCamera().Add3DCameraController();

    // Add a 3D ground plane to catch the capsule
    game.Add3DGround(); // This was added

    // Create a 3D primitive capsule and store it in an entity
    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule);

    // Reposition the capsule 8 units above the origin in the scene
    entity.Transform.Position = new Vector3(0, 8, 0);

    // Add the entity to the root scene so it becomes part of the scene graph
    entity.Scene = scene;
}

Add3DGround() is a toolkit helper method that creates a 3D ground plane in the scene, providing a surface for the capsule to land on.

Run the application again. You should see the capsule falling down and landing on the ground. 🎉 Unfortunately, it's still a black capsule on a black ground 🤦‍♂️. But don't worry, we’ll fix that later! In the meantime, you can move the camera around using the mouse and keyboard (Q or E) to lower or raise the camera and watch the capsule roll around on the ground. 🖱️⌨️

If you're wondering why the ground is invisible from below, it's due to back face culling. This technique prevents the engine from drawing polygons that face away from the camera, improving performance by avoiding unnecessary rendering. The same applies to the cube and other primitives: if the camera is inside the object, the walls won't be visible.

You’ve learned how to add a 3D ground plane to the scene, giving the capsule a surface to land on. Now, the capsule falls and lands on the ground, making the scene feel more dynamic.

Step 7: Illuminate the Scene - Add Light! 💡 🔗

It's time to brighten things up! Adding some light to the scene will help us see our objects more clearly. Thankfully, there's a helper method called AddDirectionalLight() that adds a directional light to the scene. Update the Start() method to look like this:

// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera and a controller for basic camera movement
    game.Add3DCamera().Add3DCameraController();

    // Add a directional light to illuminate the scene
    game.AddDirectionalLight(); // This was added

    // Add a 3D ground plane to catch the capsule
    game.Add3DGround();

    // Create a 3D primitive capsule and store it in an entity
    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule);

    // Reposition the capsule 8 units above the origin in the scene
    entity.Transform.Position = new Vector3(0, 8, 0);

    // Add the entity to the root scene so it becomes part of the scene graph
    entity.Scene = scene;
}

Run the application again. 🌟 You should now see the capsule falling down and landing on the ground, with everything clearly illuminated by the directional light. The capsule and ground are much easier to see, thanks to the added light shining on the scene. 🎉

Finally, no more black-on-black mysteries! 💡

You’ve learned how to add a directional light to the scene, illuminating both the capsule and the ground. The scene is now well-lit, making it much easier to see and interact with the objects.

Step 8: Break 1 - Let's Reflect 😅 🔗

Tedious work, but you just learned the very basics of game setup behind the scenes, which is usually done in the Game Studio for you automatically.

You need a Graphics Compositor to render the scene
You need a Camera to view the scene
You need a Camera Controller to move the camera around. This is a C# script that controls the camera's position and orientation
You need a Light to illuminate the scene

Once the basics are set up, you need to add entities to the scene. In our example, we added:

A 3D Ground, a simple primitive model that provides a surface.
A Capsule, another primitive model, which we’ve repositioned and dropped into the scene.

The toolkit added collidables for the ground and capsule, ensuring that the capsule doesn't fall through the ground but instead interacts realistically with the scene.

You can review the implementation of each Stride toolkit extension, which wraps some boilerplate code, and create your own custom implementation.

Whew! 😅 Take a deep breath, and get ready for the next part of our journey. Up next: performance optimizations and more interactive elements. 🚀

Step 9: Add Profiler - Performance! 📈 🔗

As game developers, we love seeing those sweet FPS numbers! 🎮 The toolkit provides a AddProfiler() method that adds a performance profiler to the game, allowing us to monitor important metrics like frames per second (FPS).

Update the Start() method to look like this:

// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera and a controller for basic camera movement
    game.Add3DCamera().Add3DCameraController();

    // Add a directional light to illuminate the scene
    game.AddDirectionalLight();

    // Add a 3D ground plane to catch the capsule
    game.Add3DGround();

    // Add a performance profiler to monitor FPS and other metrics
    game.AddProfiler(); // This was added

    // Create a 3D primitive capsule and store it in an entity
    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule);

    // Reposition the capsule 8 units above the origin in the scene
    entity.Transform.Position = new Vector3(0, 8, 0);

    // Add the entity to the root scene so it becomes part of the scene graph
    entity.Scene = scene;
}

Run the application again. You should see profiler text output in the top-left corner of the screen, showing the frames per second (FPS) and other performance metrics. 🚀 Press F1 to cycle through different profiler outputs and monitor various aspects of your game's performance. 📊

You’ve learned how to add a performance profiler to the scene, enabling you to monitor FPS and other important metrics. The profiler provides valuable insights into your game's performance, helping you identify areas for optimization.

Step 10: Illuminate the Scene - Add Skybox! 🌇 🔗

As exciting as things are looking, we can make our scene even better by adding a skybox. A skybox will enhance the overall atmosphere and give our scene a more polished, realistic look. 🌇

The toolkit provides a AddSkybox() method that adds a skybox to the scene. First, we need to add another NuGet package, Stride.CommunityToolkit.Skyboxes, which includes assets required for the skybox.

dotnet add package Stride.CommunityToolkit.Skyboxes --prerelease

Then, update the code to look like this:

using Stride.CommunityToolkit.Bepu;
using Stride.CommunityToolkit.Engine;
using Stride.CommunityToolkit.Rendering.ProceduralModels;
using Stride.CommunityToolkit.Skyboxes;  // This was added: Import skybox helpers
using Stride.Core.Mathematics;
using Stride.Engine;

// Create an instance of the game
using var game = new Game();

// Start the game loop and provide the Start method as a callback
// This method initializes the game, begins running the game loop,
// and starts processing events.
game.Run(start: Start);

// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera and a controller for basic camera movement
    game.Add3DCamera().Add3DCameraController();

    // Add a directional light to illuminate the scene
    game.AddDirectionalLight();

    // Add a 3D ground plane to catch the capsule
    game.Add3DGround();

    // Add a performance profiler to monitor FPS and other metrics
    game.AddProfiler();

    // Add a skybox to enhance the scene's visuals
    game.AddSkybox(); // This was added

    // Create a 3D primitive capsule and store it in an entity
    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule);

    // Reposition the capsule 8 units above the origin in the scene
    entity.Transform.Position = new Vector3(0, 8, 0);

    // Add the entity to the root scene so it becomes part of the scene graph
    entity.Scene = scene;
}

Run the application again. 🎮 You should now see a beautiful skybox surrounding the scene, making it look more immersive and realistic. 🌅 The skybox is essentially a large, textured 3D model that wraps around the entire scene, providing a visually appealing background. 🌇

You’ve learned how to add a skybox to the scene, enhancing the visuals and creating a more immersive environment. The skybox provides a realistic backdrop, adding depth and atmosphere to your scene.

Step 11: Add Motion - I like to Move It, Move It! 🕺 🔗

Before we dive into coding, let's take a moment to explore the different ways we can move entities in our scene. In Stride, we can move objects using two main approaches: non-physical movement and physics-based movement. Each method has its strengths and use cases, depending on the type of game or simulation you're creating.

Moving Entities by Changing Their Position Directly (Without Colliders) 🔗

This method involves directly modifying an entity's position in the scene by changing its Transform.Position. It's a straightforward approach that allows you to move objects freely without considering the physics of the environment. Here are some key points to keep in mind:

Simple Movement: This method is ideal for scenarios where you want to move objects in a controlled manner without requiring interaction with other entities.
Non-Physical: The entity doesn't respond to gravity, collisions, or any external forces. This makes it perfect for UI elements, floating objects, or objects that need to follow a predefined path.
No Interaction: By default, the entity won't collide with or interact with other objects in the scene. This can simplify certain game mechanics but also limits realism.

Use cases for non-physical movement include:

Camera Movement: Moving a camera smoothly around the scene without it being affected by the environment.
UI Elements: Moving user interface elements, like menus or health bars, without considering collisions.
Cutscenes or Animations: Predefined animations where objects follow scripted paths.

You can still add custom code or use Stride's CollisionHelper for basic interactions. For example, you can check for conditions like BoxIntersectsBox or calculate distances between objects with DistanceBoxBox.

Moving Entities Using Physics (With Colliders) 🔗

This approach leverages Stride's physics engine to handle movement. By applying forces and impulses to an entity's BodyComponent, we can create realistic interactions that respond to gravity, collisions, and other physical phenomena. Key aspects of this approach include:

Realistic Movement: Entities move according to the laws of physics, making this method suitable for objects that need to interact with the environment.
Collisions: The entity will collide with other objects, allowing for dynamic interactions, such as objects bouncing off surfaces or pushing each other.
Forces: Movement can be influenced by various forces, including gravity, wind, or explosions. This allows for more complex and dynamic gameplay mechanics.
Physics-Driven Gameplay: This method is ideal for games that rely on physics-based mechanics, such as puzzle games, platformers, or simulations.

Use cases for physics-based movement include:

Dynamic Objects: Moving objects that need to interact with other entities, like bouncing balls or rolling barrels.
Character Movement: Characters or vehicles that need to respond to the environment realistically.
Environmental Interaction: Objects that react to player actions, such as crates that can be pushed or destroyed.

You’ve learned about the two main approaches to moving entities in Stride: non-physical movement and physics-based movement. Each method offers unique advantages, depending on whether you need simple control or realistic physics-driven interactions in your game or simulation.

Step 12: Add Motion without Physics - Move the Cube without Colliders 📦 🔗

Let's add a a cube 📦 to the scene! 🎉

We'll start with the first option: moving the cube by directly changing its position. Update the code to look like this or replace the entire file:

using Stride.CommunityToolkit.Bepu;
using Stride.CommunityToolkit.Engine;
using Stride.CommunityToolkit.Rendering.ProceduralModels;
using Stride.CommunityToolkit.Skyboxes;
using Stride.Core.Mathematics;
using Stride.Engine;
using Stride.Games;  // This was added

float movementSpeed = 1f; // This was added
Entity? cube1 = null; // This was added

// Create an instance of the game
using var game = new Game();

// Start the game loop and provide the Start and Update methods as callbacks
// This method initializes the game, begins running the game loop,
// and starts processing events.
game.Run(start: Start, update: Update); // This was updated

// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera and a controller for basic camera movement
    game.Add3DCamera().Add3DCameraController();

    // Add a directional light to illuminate the scene
    game.AddDirectionalLight();

    // Add a 3D ground plane to catch the capsule
    game.Add3DGround();

    // Add a performance profiler to monitor FPS and other metrics
    game.AddProfiler();

    // Add a skybox to enhance the scene's visuals
    game.AddSkybox();

    // Add a ground gizmo to visualize axis directions
    game.AddGroundGizmo(position: new Vector3(-5, 0.1f, -5), showAxisName: true);

    // Create a 3D primitive capsule and store it in an entity
    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule);

    // Reposition the capsule 8 units above the origin in the scene
    entity.Transform.Position = new Vector3(0, 8, 0);

    // Add the entity to the root scene so it becomes part of the scene graph
    entity.Scene = scene;

    // This was added
    // Create a cube with material, disable its collider, and add it to the scene
    // The cube is hanging in the default position Vector(0,0,0) in the air,
    // well intersecting the ground plane as it is not aware of the ground
    cube1 = game.Create3DPrimitive(PrimitiveModelType.Cube, new()
    {
        Material = game.CreateMaterial(Color.Gold),
        IncludeCollider = false // No collider for non-physical movement
    });
    cube1.Scene = scene;
}

// This was added
// Define the Update method, called every frame to update the game state
void Update(Scene scene, GameTime time)
{
    // Calculate the time elapsed since the last frame for consistent movement
    // This is crucial for frame-independent movement, ensuring consistent
    // behaviour regardless of frame rate.
    var deltaTime = (float)time.Elapsed.TotalSeconds;

    if (cube1 != null)
    {
         // Move the cube along the negative X-axis with frame-independent motion
        cube1.Transform.Position -= new Vector3(movementSpeed * deltaTime, 0, 0);
    }
}

movementSpeed determines how fast the cube moves.
cube1 is an Entity object representing the cube in the scene.
game.Run(start: Start, update: Update) now includes the Update method as a callback for updating the game state every frame.
AddGroundGizmo() adds a visual representation of the ground plane and axis directions. Just a visual aid, it doesn't affect the physics of the scene.
CreateMaterial() allows you to color the cube (and even the capsule if you want 😉).
Update() is a callback method that is called every frame to update the game state.

Run the application. 🏃 You should see a box (cube) moving along the X-axis, without interacting with other entities.

You’ve learned how to move a cube without using colliders, applying non-physical movement. The cube moves smoothly along the X-axis, showcasing basic object manipulation and animation.

Step 13: Add Motion with Physics - Move the Cube with Colliders! 🧊 🔗

Now that we've moved the cube without colliders, let's dive into the more realistic option: moving the cube using physics. With this approach, the cube will interact with the environment, responding to forces like gravity and colliding with other entities.

Update the code to include physics-based movement or replace the entire file:

using Stride.BepuPhysics; // This was added
using Stride.CommunityToolkit.Bepu;
using Stride.CommunityToolkit.Engine;
using Stride.CommunityToolkit.Rendering.ProceduralModels;
using Stride.CommunityToolkit.Skyboxes;
using Stride.Core.Mathematics;
using Stride.Engine;
using Stride.Games;

float movementSpeed = 1f;
float force = 3f; // This was added
Entity? cube1 = null;
Entity? cube2 = null; // This was added

// Create an instance of the game
using var game = new Game();

// Start the game loop and provide the Start and Update methods as callbacks
// This method initializes the game, begins running the game loop,
// and starts processing events.
game.Run(start: Start, update: Update);

// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera and a controller for basic camera movement
    game.Add3DCamera().Add3DCameraController();

    // Add a directional light to illuminate the scene
    game.AddDirectionalLight();

    // Add a 3D ground plane to catch the capsule
    game.Add3DGround();

    // Add a performance profiler to monitor FPS and other metrics
    game.AddProfiler();

    // Add a skybox to enhance the scene's visuals
    game.AddSkybox();

    // Add a ground gizmo to visualize axis directions
    game.AddGroundGizmo(position: new Vector3(-5, 0.1f, -5), showAxisName: true);

    // Create a 3D primitive capsule and store it in an entity
    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule);

    // Reposition the capsule 8 units above the origin in the scene
    entity.Transform.Position = new Vector3(0, 8, 0);

    // Add the entity to the root scene so it becomes part of the scene graph
    entity.Scene = scene;

    // Create a cube with material, disable its collider, and add it to the scene
    // The cube is hanging in the default position Vector(0,0,0) in the air,
    // well intersecting the ground plane as it is not aware of the ground
    cube1 = game.Create3DPrimitive(PrimitiveModelType.Cube, new()
    {
        Material = game.CreateMaterial(Color.Gold),
        IncludeCollider = false // No collider for simple movement
    });
    cube1.Scene = scene;

    // This was added
    // Create a second cube with a collider for physics-based interaction
    cube2 = game.Create3DPrimitive(PrimitiveModelType.Cube, new()
    {
        Material = game.CreateMaterial(Color.Orange)
    });
    cube2.Transform.Position = new Vector3(-3, 5, 0);  // Reposition the cube above the ground
    cube2.Scene = scene;
}

// Define the Update method, called every frame to update the game state
void Update(Scene scene, GameTime time)
{
    // Calculate the time elapsed since the last frame for consistent movement
    var deltaTime = (float)time.Elapsed.TotalSeconds;

    if (cube1 != null)
    {
        // Move the first cube along the negative X-axis (non-physical movement)
        cube1.Transform.Position -= new Vector3(movementSpeed * deltaTime, 0, 0);
    }

    // This was added
    // Handle physics-based movement for cube2
    if (cube2 != null)
    {
        // Retrieve the BodyComponent, which handles physics interactions
        var rigidBody = cube2.Get<BodyComponent>();

        // Check if cube2 is stationary by verifying if its linear velocity is effectively zero.
        if (Math.Round(rigidBody.LinearVelocity.Length()) == 0)
        {
            // Apply an impulse to cube2 along the X-axis, initiating movement. Impulse offset is set to zero.
            rigidBody.ApplyImpulse(new Vector3(force, 0, 0), Vector3.Zero);

            // Reverse the direction of the impulse for the next impulse,
            // allowing cube2 to move back and forth along the X-axis.
            force *= -1;
        }
    }
}

Stride.BepuPhysics provides access to physics-related classes and components, including the BodyComponent.
force determines the strength of the impulse applied to the cube.
cube2 is an Entity object representing the cube that will move using physics-based interactions.
BodyComponent handles physics interactions, allowing the entity to respond to forces, gravity, and collisions.
LinearVelocity represents the velocity of the cube. We check if the velocity is near zero (indicating the cube is stationary) before applying the impulse.
ApplyImpulse() applies a force to the entity, causing it to move in the direction of the applied force. In this case, we're applying an impulse to the cube, making it move along the X-axis.

Run the application. 🏃‍♂️ You should now see two cubes in the scene:

Cube 1 moves along the X-axis using non-physical movement, just like in the previous step.
Cube 2 interacts with the environment using physics, responding to forces and collisions.

This step introduces a new level of realism by making the cube react to physical forces, adding depth and complexity to your game. 🎮

The main difference between the two cubes is that Cube 1 moves without interacting with the environment. We directly modify the entity's Transform.Position to move it, resulting in simple, non-physical movement. In contrast, Cube 2 responds to physics, collisions, and forces. Instead of manually changing its position, we control its movement through the BodyComponent, which handles all the physics-based interactions, including gravity, impulses, and collisions with other objects in the scene. This makes Cube 2's movement more realistic and reactive to its surroundings.

You’ve learned how to move a cube using physics-based movement, allowing it to interact with the environment. The cube responds to forces, gravity, and collisions, creating a more dynamic and realistic scene. You now understand the key differences between non-physical and physics-based movement, giving you greater control over how objects interact in your game world.

Step 14: Add Keyboard Interaction - Move the Cube! ⌨️ 🔗

Now it's time to add some interactivity! 🎮 We will update the Update() method to allow the player to move the cubes around using the keyboard. We'll make sure both Cube 1 (non-physical movement) and Cube 2 (physics-based movement) respond to key presses.

Ensure that the using Stride.Input; namespace is included to handle input.

You can replace the existing Update method with the following code:

// Define the Update method, called every frame to update the game state
void Update(Scene scene, GameTime time)
{
    // Calculate the time elapsed since the last frame for consistent movement
    var deltaTime = (float)time.Elapsed.TotalSeconds;

    // This was updated
    // Handle non-physical movement for cube1
    if (cube1 != null)
    {
        // Move the first cube along the negative X-axis when the Z key is held down
        if (game.Input.IsKeyDown(Keys.Z))
        {
            cube1.Transform.Position -= new Vector3(movementSpeed * deltaTime, 0, 0);
        }
        // Move the first cube along the positive X-axis when the X key is held down
        else if (game.Input.IsKeyDown(Keys.X))
        {
            cube1.Transform.Position += new Vector3(movementSpeed * deltaTime, 0, 0);
        }
    }

    // This was updated
    // Handle physics-based movement for cube2
    if (cube2 != null)
    {
        // Retrieve the BodyComponent, which handles physics interactions
        var rigidBody = cube2.Get<BodyComponent>();

        // We use KeyPressed instead of KeyDown to apply impulses only once per key press.
        // This means the player needs to press and release the key to apply an impulse,
        // preventing multiple impulses from being applied while the key is held down.

        // Apply an impulse to the left when the C key is pressed (and released)
        if (game.Input.IsKeyPressed(Keys.C))
        {
            rigidBody.Awake = true; // Wake up the rigid body to ensure it can respond to impulses
            rigidBody.ApplyImpulse(new Vector3(-force, 0, 0), Vector3.Zero);
        }
        // Apply an impulse to the right when the V key is pressed (and released)
        else if (game.Input.IsKeyPressed(Keys.V))
        {
            rigidBody.Awake = true; // Wake up the rigid body to ensure it can respond to impulses
            rigidBody.ApplyImpulse(new Vector3(force, 0, 0), Vector3.Zero);
        }
    }
}

game.Input.IsKeyDown() checks if a key is currently held down. This is useful for continuous actions, like moving an object as long as the key is pressed.
game.Input.IsKeyPressed() checks if a key was pressed and released once. This is ideal for triggering actions that should only occur once per key press, such as applying an impulse to a physics object, to avoid multiple impulses being applied while the key is held down.
rigidBody.Awake = true; gets or sets whether the body is in the active set. Setting this to true will attempt to wake the body; setting it to false will force the body and any constraint-connected bodies asleep. Using an awake mechanism helps by reducing the computational overhead.

Additional Points:

The non-physical movement for Cube 1 allows smooth, continuous movement along the X-axis when holding the Z or X keys.
The physics-based movement for Cube 2 applies an impulse to the cube when the C or V keys are pressed, allowing it to interact with the environment.
The capsule does not collide with Cube 1 because we disabled the collider for that cube but interacts with Cube 2, which has a collider and responds to physics.

Run the application. You should now be able to control Cube 1's position with the Z and X keys, moving it left and right, and apply impulses to Cube 2 with the C and V keys, pushing it back and forth and colliding with the capsule. 🎮

This step introduces basic keyboard controls, adding interactivity to your scene and allowing the player to manipulate objects in real-time. Ready to add even more interaction? Let's move on to mouse controls next! 🖱️

You learned how to add keyboard interaction to the scene, allowing players to move the cubes using the Z, X, C, and V keys. Cube 1 responds to continuous key presses for smooth, non-physical movement, while Cube 2 reacts to single key presses, applying impulses for physics-based movement. These controls enable dynamic interaction and real-time object manipulation within the scene.

Step 15: Add Mouse Interaction - Do something! 🖱️ 🔗

Let's add mouse interaction to the scene! 🐭 In this step, we'll update the Update() method to allow players to interact with the cubes and the capsule using the mouse 🖱️. We'll make sure both Cube 1 (non-physical movement), Cube 2, and the capsule (physics-based movement) respond to mouse input.

The previous comments have been streamlined to keep the code clean and focused🧹. Also, make sure you can see your console output to see the results of the mouse interactions.

You can replace the entire code with the following, or refer to the comments labelled // This was added to see the specific changes.

using Stride.BepuPhysics;
using Stride.CommunityToolkit.Bepu;
using Stride.CommunityToolkit.Engine;
using Stride.CommunityToolkit.Rendering.ProceduralModels;
using Stride.CommunityToolkit.Skyboxes;
using Stride.Core.Mathematics;
using Stride.Engine;
using Stride.Games;
using Stride.Input;

float movementSpeed = 1f;
float force = 3f;
Entity? cube1 = null;
Entity? cube2 = null;

CameraComponent? camera = null; // This was added: Store the camera component
BepuSimulation? simulation = null; // This was added: Store the physics simulation
ModelComponent? cube1Component = null; // This was added: Store the model component of Cube 1

// Create an instance of the game
using var game = new Game();

// Start the game loop and provide the Start and Update methods as callbacks
// This method initializes the game, begins running the game loop,
// and starts processing events.
game.Run(start: Start, update: Update);

// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera and a controller for basic camera movement
    game.Add3DCamera().Add3DCameraController();

    // Add a directional light to illuminate the scene
    game.AddDirectionalLight();

    // Add a 3D ground plane to catch the capsule
    game.Add3DGround();

    // Add a performance profiler to monitor FPS and other metrics
    game.AddProfiler();

    // Add a skybox to enhance the scene's visuals
    game.AddSkybox();

    // Add a ground gizmo to visualize axis directions
    game.AddGroundGizmo(position: new Vector3(-5, 0.1f, -5), showAxisName: true);

    // Create a 3D primitive capsule and store it in an entity
    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule);

    // Reposition the capsule 8 units above the origin in the scene
    entity.Transform.Position = new Vector3(0, 8, 0);

    // Add the entity to the root scene so it becomes part of the scene graph
    entity.Scene = scene;

    // Create a cube with material, disable its collider, and add it to the scene
    // The cube is hanging in the default position Vector(0,0,0) in the air,
    // well intersecting the ground plane as it is not aware of the ground
    cube1 = game.Create3DPrimitive(PrimitiveModelType.Cube, new()
    {
        Material = game.CreateMaterial(Color.Gold),
        IncludeCollider = false // No collider for simple movement
    });
    cube1.Scene = scene;

    // Create a second cube with a collider for physics-based interaction
    cube2 = game.Create3DPrimitive(PrimitiveModelType.Cube, new()
    {
        Material = game.CreateMaterial(Color.Orange)
    });
    cube2.Transform.Position = new Vector3(-3, 5, 0);  // Reposition the cube above the ground
    cube2.Scene = scene;

    // These were added
    // Initialize camera, simulation, and model component for interactions
    camera = scene.GetCamera();
    simulation = camera?.Entity.GetSimulation();
    cube1Component = cube1.Get<ModelComponent>();

    if (simulation != null)
    {
        Console.WriteLine("Simulation Started");
    }
}

// Define the Update method, called every frame to update the game state
void Update(Scene scene, GameTime time)
{
    // Calculate the time elapsed since the last frame for consistent movement
    var deltaTime = (float)time.Elapsed.TotalSeconds;

    // Handle non-physical movement for cube1
    if (cube1 != null)
    {
        // Move the first cube along the negative X-axis when the Z key is held down
        if (game.Input.IsKeyDown(Keys.Z))
        {
            cube1.Transform.Position -= new Vector3(movementSpeed * deltaTime, 0, 0);
        }
        // Move the first cube along the positive X-axis when the X key is held down
        else if (game.Input.IsKeyDown(Keys.X))
        {
            cube1.Transform.Position += new Vector3(movementSpeed * deltaTime, 0, 0);
        }
    }

    // Handle physics-based movement for cube2
    if (cube2 != null)
    {
        // Retrieve the BodyComponent, which handles physics interactions
        var rigidBody = cube2.Get<BodyComponent>();

        // We use KeyPressed instead of KeyDown to apply impulses only once per key press.
        // This means the player needs to press and release the key to apply an impulse,
        // preventing multiple impulses from being applied while the key is held down.

        // Apply an impulse to the left when the C key is pressed (and released)
        if (game.Input.IsKeyPressed(Keys.C))
        {
            rigidBody.Awake = true;
            rigidBody.ApplyImpulse(new Vector3(-force, 0, 0), Vector3.Zero);
        }
        // Apply an impulse to the right when the V key is pressed (and released)
        else if (game.Input.IsKeyPressed(Keys.V))
        {
            rigidBody.Awake = true;
            rigidBody.ApplyImpulse(new Vector3(force, 0, 0), Vector3.Zero);
        }
    }

    // This was added
    // Ensure camera and simulation are initialized before handling mouse input
    if (camera == null || simulation == null || !game.Input.HasMouse) return;

    // This was added
    // Handle mouse input for interactions
    if (game.Input.IsMouseButtonPressed(MouseButton.Left))
    {
        // Check for collisions with physics-based entities using raycasting
        var hitResult = camera.Raycast(game.Input.MousePosition, 100f, out HitInfo hitInfo);

        if (hitResult)
        {
            var message = $"Hit: {hitInfo.Collidable.Entity.Name}";
            Console.WriteLine(message);

            var rigidBody = hitInfo.Collidable.Entity.Get<BodyComponent>();

            if (rigidBody != null)
            {
                var direction = new Vector3(0, 3, 0); // Apply impulse upward
                rigidBody.Awake = true;
                rigidBody.ApplyImpulse(direction, Vector3.Zero);
            }
        }
        else
        {
            Console.WriteLine("No hit detected.");
        }

        // Check for intersections with non-physical entities using ray picking
        var ray = camera.GetPickRay(game.Input.MousePosition);

        if (cube1Component?.BoundingBox.Intersects(ref ray) ?? false)
        {
            Console.WriteLine("Cube 1 hit!");
        }
    }
}

camera stores the camera component for raycasting and ray picking.
simulation stores the physics simulation for handling interactions.
cube1Component stores the model component of Cube 1 for detecting intersections with the mouse ray.
camera.Raycast() detects collisions with physics-based entities using raycasting.
camera.GetPickRay() checks for intersections with non-physical entities using ray picking.

Now, when you click the left mouse button, the application will respond with the following actions depending on where you click:

Clicking Outside the Ground: If you click anywhere in the scene that doesn't intersect with an object or the ground, it will print "No hit detected." This indicates that the mouse ray didn't collide with any entities.
Clicking on Cube 1: Since Cube 1 doesn't have a collider, two things will happen:
- The raycast will pass through Cube 1 and hit the ground beneath it, printing "Hit: Ground."
- Additionally, the ray-picking method will detect that Cube 1 was hit, and it will print "Cube 1 hit!"
Clicking on Cube 2: Cube 2 has a collider, so the raycast will detect the collision and print "Hit: Entity." An impulse will be applied to Cube 2, causing it to move upward in response to the click.
Clicking on the Capsule: Similar to Cube 2, clicking on the capsule will print "Hit: Entity," and an upward impulse will be applied, making the capsule move.
Clicking on the Ground: If you click directly on the ground, the raycast will detect it and print "Hit: Ground." However, the ground will remain stationary because it has a StaticColliderComponent, meaning it's a fixed object in the scene.

Nice job! You’ve now implemented mouse interaction, which adds a whole new level of interactivity to the game. 🚀 You can now click on objects in the scene to trigger different actions, like moving cubes or capsules with physics or detecting hits on non-physical entities. This opens up endless possibilities for gameplay mechanics! 🎮 We rock! 🤘

You've learned how to add mouse interaction to the scene, allowing players to interact with objects using raycasting for physics-based entities and ray picking for non-physical ones. You can now click on objects to apply forces or detect hits, adding a new layer of interactivity to the game.

Step 16: Add Output - Console or Screen! 📺 🔗

In this part, we’ll explore basic output options, both to the console and directly on the screen. You’ve already added simple text output using Console.WriteLine() to display interactions when an entity is hit by the mouse raycast. Now, let's expand on this to better visualize interactions and provide feedback to the player.

Output Options 🔗

We have several options for displaying output:

Console Output: Useful for debugging and logging information. This is great for developers to see real-time feedback and troubleshoot the game
- We can use traditional Console.WriteLine()
- We can also use Stride's GlobalLogger.GetLogger(), or the Log property when used from within a game script
Debug Text Output: Display text directly in the game window, which is useful for quick, in-game debugging
UI Elements: Create UI elements like text labels or buttons to display information to the player within the game world.

Updating the Console Output 🔗

Let’s update the if (hitResult) {} block by adding two lines to include additional output options:

if (hitResult)
{
    var message = $"Hit: {hitInfo.Collidable.Entity.Name}";
    Console.WriteLine(message);
    GlobalLogger.GetLogger("Program.cs").Info(message); // This was added
    game.DebugTextSystem.Print($"Entities: {scene.Entities.Count}", new Int2(50, 50)); // This was added

    var rigidBody = hitInfo.Collidable.Entity.Get<BodyComponent>();

    if (rigidBody != null)
    {
        var direction = new Vector3(0, 3, 0); // Apply impulse upward
        rigidBody.Awake = true;
        rigidBody.ApplyImpulse(direction, Vector3.Zero);
    }
}

Run the application. You should see additional output in the console window when you click around, highlighted in green by GlobalLogger. However, the text in the game window may flash briefly, as it’s being overwritten every frame.

Moving Output to the Screen 🔗

To keep the text on the screen, move the game.DebugTextSystem.Print() call to the beginning of the Update() method:

// Define the Update method, called every frame to update the game state
void Update(Scene scene, GameTime time)
{
    // This was moved
    game.DebugTextSystem.Print($"Entities: {scene.Entities.Count}", new Int2(50, 50));

    // Calculate the time elapsed since the last frame for consistent movement
    var deltaTime = (float)time.Elapsed.TotalSeconds;

    // Handle non-physical movement for cube1
    if (cube1 != null)
    {
        // Move the first cube along the negative X-axis when the Z key is held down
        if (game.Input.IsKeyDown(Keys.Z))
        {
            cube1.Transform.Position -= new Vector3(movementSpeed * deltaTime, 0, 0);
        }
        // Move the first cube along the positive X-axis when the X key is held down
        else if (game.Input.IsKeyDown(Keys.X))
        {
            cube1.Transform.Position += new Vector3(movementSpeed * deltaTime, 0, 0);
        }
    }

    // Handle physics-based movement for cube2
    if (cube2 != null)
    {
        // Retrieve the BodyComponent, which handles physics interactions
        var rigidBody = cube2.Get<BodyComponent>();

        // We use KeyPressed instead of KeyDown to apply impulses only once per key press.
        // This means the player needs to press and release the key to apply an impulse,
        // preventing multiple impulses from being applied while the key is held down.

        // Apply an impulse to the left when the C key is pressed (and released)
        if (game.Input.IsKeyPressed(Keys.C))
        {
            rigidBody.Awake = true;
            rigidBody.ApplyImpulse(new Vector3(-force, 0, 0), Vector3.Zero);
        }
        // Apply an impulse to the right when the V key is pressed (and released)
        else if (game.Input.IsKeyPressed(Keys.V))
        {
            rigidBody.Awake = true;
            rigidBody.ApplyImpulse(new Vector3(force, 0, 0), Vector3.Zero);
        }
    }

    // Ensure camera and simulation are initialized before handling mouse input
    if (camera == null || simulation == null || !game.Input.HasMouse) return;

    // Handle mouse input for interactions
    if (game.Input.IsMouseButtonPressed(MouseButton.Left))
    {
        // Check for collisions with physics-based entities using raycasting
        var hitResult = camera.Raycast(game.Input.MousePosition, 100f, out HitInfo hitInfo);

        if (hitResult)
        {
            var message = $"Hit: {hitInfo.Collidable.Entity.Name}";
            Console.WriteLine(message);
            GlobalLogger.GetLogger("Program.cs").Info(message);

            var rigidBody = hitInfo.Collidable.Entity.Get<BodyComponent>();

            if (rigidBody != null)
            {
                var direction = new Vector3(0, 3, 0); // Apply impulse upward
                rigidBody.Awake = true;
                rigidBody.ApplyImpulse(direction, Vector3.Zero);
            }
        }
        else
        {
            Console.WriteLine("No hit detected.");
        }

        // Check for intersections with non-physical entities using ray picking
        var ray = camera.GetPickRay(game.Input.MousePosition);

        if (cube1Component?.BoundingBox.Intersects(ref ray) ?? false)
        {
            Console.WriteLine("Cube 1 hit!");
        }
    }
}

Now, when you run the application, the text "Entities:" should remain visible on the screen at position (50, 50). This gives us some basic screen output! 📺 But since this output is more suited for debugging, let’s explore adding more polished UI elements.

Seeing a different number of entities than expected on the screen? Debug the Update() and find out why is that 😯.

Adding UI Elements 🔗

Let’s create a simple text block on the canvas to display information to the player.

Replace your current code with this or refer to the comments labelled // This was added to see the specific changes.

using Stride.BepuPhysics;
using Stride.CommunityToolkit.Bepu;
using Stride.CommunityToolkit.Engine;
using Stride.CommunityToolkit.Rendering.Compositing; // This was added
using Stride.CommunityToolkit.Rendering.ProceduralModels;
using Stride.CommunityToolkit.Skyboxes;
using Stride.Core.Diagnostics;
using Stride.Core.Mathematics;
using Stride.Engine;
using Stride.Games;
using Stride.Graphics; // This was added
using Stride.Input;
using Stride.Rendering; // This was added
using Stride.UI; // This was added
using Stride.UI.Controls; // This was added
using Stride.UI.Panels; // This was added

float movementSpeed = 1f;
float force = 3f;
Entity? cube1 = null;
Entity? cube2 = null;

CameraComponent? camera = null; // Store the camera component
BepuSimulation? simulation = null; // Store the physics simulation
ModelComponent? cube1Component = null; // Store the model component of Cube 1

SpriteFont? font = null; // This was added

// Create an instance of the game
using var game = new Game();

// Start the game loop and provide the Start and Update methods as callbacks
// This method initializes the game, begins running the game loop,
// and starts processing events.
game.Run(start: Start, update: Update);

// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering and UI stages
    game.AddGraphicsCompositor().AddCleanUIStage(); // This was updated

    // Add a 3D camera and a controller for basic camera movement
    game.Add3DCamera().Add3DCameraController();

    // Add a directional light to illuminate the scene
    game.AddDirectionalLight();

    // Add a 3D ground plane to catch the capsule
    game.Add3DGround();

    // Add a performance profiler to monitor FPS and other metrics
    game.AddProfiler();

    // Add a skybox to enhance the scene's visuals
    game.AddSkybox();

    // Add a ground gizmo to visualize axis directions
    game.AddGroundGizmo(position: new Vector3(-5, 0.1f, -5), showAxisName: true);

    // Create a 3D primitive capsule and store it in an entity
    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule);

    // Reposition the capsule 8 units above the origin in the scene
    entity.Transform.Position = new Vector3(0, 8, 0);

    // Add the entity to the root scene so it becomes part of the scene graph
    entity.Scene = scene;

    // Create a cube with material, disable its collider, and add it to the scene
    // The cube is hanging in the default position Vector(0,0,0) in the air,
    // well intersecting the ground plane as it is not aware of the ground
    cube1 = game.Create3DPrimitive(PrimitiveModelType.Cube, new()
    {
        Material = game.CreateMaterial(Color.Gold),
        IncludeCollider = false // No collider for simple movement
    });
    cube1.Scene = scene;

    // Create a second cube with a collider for physics-based interaction
    cube2 = game.Create3DPrimitive(PrimitiveModelType.Cube, new()
    {
        Material = game.CreateMaterial(Color.Orange)
    });
    cube2.Transform.Position = new Vector3(-3, 5, 0);  // Reposition the cube above the ground
    cube2.Scene = scene;

    // Initialize camera, simulation, and model component for interactions
    camera = scene.GetCamera();
    simulation = camera?.Entity.GetSimulation();
    cube1Component = cube1.Get<ModelComponent>();

    if (simulation != null)
    {
        Console.WriteLine("Simulation Started");
    }

    // This below was added: Create and display a UI text block
    font = game.Content.Load<SpriteFont>("StrideDefaultFont");
    var canvas = new Canvas
    {
        Width = 300,
        Height = 100,
        BackgroundColor = new Color(248, 177, 149, 100),
        HorizontalAlignment = HorizontalAlignment.Left,
        VerticalAlignment = VerticalAlignment.Bottom,
    };

    canvas.Children.Add(new TextBlock
    {
        Text = "Hello, Stride!",
        TextColor = Color.White,
        Font = font,
        TextSize = 24,
        Margin = new Thickness(3, 3, 3, 0),
    });

    var uiEntity = new Entity
    {
        new UIComponent
        {
            Page = new UIPage { RootElement = canvas },
            RenderGroup = RenderGroup.Group31 // Used to render AddCleanUIStage()
        }
    };

    uiEntity.Scene = scene;
}

// Define the Update method, called every frame to update the game state
void Update(Scene scene, GameTime time)
{
    game.DebugTextSystem.Print($"Entities: {scene.Entities.Count}", new Int2(50, 50));

    // Calculate the time elapsed since the last frame for consistent movement
    var deltaTime = (float)time.Elapsed.TotalSeconds;

    // Handle non-physical movement for cube1
    if (cube1 != null)
    {
        // Move the first cube along the negative X-axis when the Z key is held down
        if (game.Input.IsKeyDown(Keys.Z))
        {
            cube1.Transform.Position -= new Vector3(movementSpeed * deltaTime, 0, 0);
        }
        // Move the first cube along the positive X-axis when the X key is held down
        else if (game.Input.IsKeyDown(Keys.X))
        {
            cube1.Transform.Position += new Vector3(movementSpeed * deltaTime, 0, 0);
        }
    }

    // Handle physics-based movement for cube2
    if (cube2 != null)
    {
        // Retrieve the BodyComponent, which handles physics interactions
        var rigidBody = cube2.Get<BodyComponent>();

        // We use KeyPressed instead of KeyDown to apply impulses only once per key press.
        // This means the player needs to press and release the key to apply an impulse,
        // preventing multiple impulses from being applied while the key is held down.

        // Apply an impulse to the left when the C key is pressed (and released)
        if (game.Input.IsKeyPressed(Keys.C))
        {
            rigidBody.Awake = true;
            rigidBody.ApplyImpulse(new Vector3(-force, 0, 0), Vector3.Zero);
        }
        // Apply an impulse to the right when the V key is pressed (and released)
        else if (game.Input.IsKeyPressed(Keys.V))
        {
            rigidBody.Awake = true;
            rigidBody.ApplyImpulse(new Vector3(force, 0, 0), Vector3.Zero);
        }
    }

    // Ensure camera and simulation are initialized before handling mouse input
    if (camera == null || simulation == null || !game.Input.HasMouse) return;

    // Handle mouse input for interactions
    if (game.Input.IsMouseButtonPressed(MouseButton.Left))
    {
        // Check for collisions with physics-based entities using raycasting
        var hitResult = camera.Raycast(game.Input.MousePosition, 100f, out HitInfo hitInfo);

        if (hitResult)
        {
            var message = $"Hit: {hitInfo.Collidable.Entity.Name}";
            Console.WriteLine(message);
            GlobalLogger.GetLogger("Program.cs").Info(message);

            var rigidBody = hitInfo.Collidable.Entity.Get<BodyComponent>();

            if (rigidBody != null)
            {
                var direction = new Vector3(0, 3, 0); // Apply impulse upward
                rigidBody.Awake = true;
                rigidBody.ApplyImpulse(direction, Vector3.Zero);
            }
        }
        else
        {
            Console.WriteLine("No hit detected.");
        }

        // Check for intersections with non-physical entities using ray picking
        var ray = camera.GetPickRay(game.Input.MousePosition);

        if (cube1Component?.BoundingBox.Intersects(ref ray) ?? false)
        {
            Console.WriteLine("Cube 1 hit!");
        }
    }
}

font stores the SpriteFont used for the UI text block.
AddCleanUIStage() adds a clean UI stage to the graphics compositor, allowing UI elements to be displayed on top of the 3D scene.
game.Content.Load<SpriteFont>() loads the default font for the UI text block.
Canvas is a UI panel that acts as a container for UI elements.
TextBlock is a UI element that displays text on the screen.
UIComponent is a component that manages UI elements in the scene.
UIPage is a UI page that contains the root element of the UI hierarchy.
RenderGroup.Group31 specifies the rendering order of the UI element, ensuring it appears on top of other elements.

Save and run the application. You should now see the text "Hello, Stride!" displayed at the bottom left corner of the screen. 📺

Make sure that you added AddCleanUIStage() .

Congratulations! 🎉 You've successfully added output to the screen, using both simple debugging text and a more polished UI element. This visual feedback enhances the player experience by providing real-time information and interactions. 🚀

You’ve learned how to add various types of output, from basic console logging to real-time in-game text feedback. Using debugging text and polished UI elements, you can enhance both the developer experience and the player experience, providing essential information and interactivity in your game.

Step 17: Break 2 - Let's Reflect 😅 🔗

Time for a quick reflection on what we've achieved in the last few steps. We've significantly expanded our game's functionality and interactivity. Here's a recap:

Performance Monitoring: We added a profiler to monitor key metrics like FPS, helping optimize performance for a smoother experience. You also learned how to toggle through profiler outputs to track different aspects of the game. 🚀
Enhanced Visuals: By adding a skybox, we made the scene more immersive, creating a polished and professional look. 🎨
Understanding Motion: We explored the difference between non-physical and physics-based movement, learning how to decide which method to use based on game mechanics. 🧠
Non-Physical Movement: You learned how to move entities using Transform.Position without interacting with other objects. This approach is great for UI elements or simple animations. 🚶‍♂️
Physics-Based Movement: By applying forces to entities via BodyComponent, we introduced realistic interactions with gravity and collisions, adding depth to the gameplay. ⚙️
Keyboard Controls: We implemented basic keyboard inputs to move entities, adding interactivity and responsiveness to the game. 🎮
Mouse Controls: We extended player interaction by integrating mouse clicks, allowing players to trigger actions like applying forces to entities. 🖱️
Displaying Output: Finally, we explored output options, from console logs to UI elements, enhancing player feedback and communication. 📊
Entities Count: While debugging, you discovered that an entity can be added to the scene without necessarily having a visual representation. You also learned that the camera, light, game profiler, and skybox are all entities as well. 🤯

Step 18: Add More Primitives - Let's go crazy! 🤪 🔗

Two boxes 📦🧊 and a capsule 💊? That's not enough fun! I didn't sign up for just that! Let's crank it up and add more shapes to the scene!

To do this, add the following code inside the Update() method, below the if (cube2 != null) {} block:

if (game.Input.IsKeyDown(Keys.Space))
{
    var entity = game.Create3DPrimitive(PrimitiveModelType.Cube, new()
    {
        Material = game.CreateMaterial(Color.Green),
        Size = new Vector3(0.5f),
    });

    entity.Transform.Position = VectorHelper.RandomVector3(
        xRange: [-3, 3],
        yRange: [10, 13],
        zRange: [-3, 3]
    );
    entity.Scene = scene;
}

Now, run the application, zoom out the camera to view the entire ground, and press the Space key. Watch as new cubes spawn, pushing your FPS to its limits! 🚀 You can still use the left mouse button to apply forces to the cubes and the capsule, but that’s getting a bit old, isn’t it? 🥱

Let's spice things up with more mouse interaction, this time using the middle mouse button. Firstly add this namespace using Stride.CommunityToolkit.Helpers; and then add the following code inside the Update() method, just below the line if (camera == null || simulation == null || !game.Input.HasMouse) return;:

if (game.Input.IsMouseButtonDown(MouseButton.Middle))
{
    var hitResult = camera.Raycast(game.Input.MousePosition, 100f, out HitInfo hitInfo);

    if (hitResult)
    {
        var rigidBody = hitInfo.Collidable.Entity.Get<BodyComponent>();

        if (rigidBody != null)
        {
            var direction = VectorHelper.RandomVector3([-20, 20], [0, 20], [-20, 20]);
            rigidBody.Awake = true;
            rigidBody.ApplyImpulse(direction, new Vector3(0, 0, 0));
        }
    }
}

The final code is also available on GitHub.

Run the application, and now, whenever you click the middle mouse button on an object, it will get a random impulse in a random direction. 🎲 How cool is that?

More cubes = more responsibility! Keep an eye on performance. Once cubes float too far away into the void, consider removing them from the scene to maintain performance. We will cover this in Part 2 of the series.

You've now learned how to create more primitives using keyboard input and apply random forces to objects with the middle mouse button - all in just around 250 lines of code.

Wrapping Up: Your Journey Continues 🎯 🔗

Congratulations, explorer! 🎉 You've navigated through another significant chapter in your game development journey. 🌍 In this part, you delved deeper into interactivity, mastering how to implement mouse and keyboard controls to make your game more dynamic and engaging.

What You've Achieved 🔗

By adding mouse interactions, you’ve empowered players to directly interact with objects in your scene using techniques like raycasting and ray picking. Combined with the keyboard controls you implemented earlier, your game now responds to player inputs, allowing for real-time movement, actions, and feedback. 🖱️⌨️

The Power of Interactivity 🔗

Interactivity is at the heart of game design. By giving players the ability to influence the game world, you create a more immersive and engaging experience. The skills you've developed—handling inputs, moving objects, managing physics, and providing feedback—are foundational to building more complex and polished games. 🌟

If you'd like to explore the final code for this project, you can access it on GitHub. Feel free to check it out and experiment! 💻

Follow-Up Articles 🚶 🔗

In the not-so-distant future, we will cover the following topics:

Stride Community Toolkit Preview - Code-Only Feature - Advanced: Let's get creative and explore more advanced features to take your game to the next level. 🚀
- Maximize the game window
- Setting the Game Window Title
- Hot reload
- Removing entities from the scene
- Entities vs Children vs Components
- Interaction with the UI and from the UI
- Transforming entities
- Advanced physics interactions
- Audio and sound effects
- Particle effects
Stride Community Toolkit Preview - Code-Only Feature - Refactoring: Let's refactor the code to make it more modular, reusable, and maintainable. 🛠️
- Or in other words, let’s clean up the mess we made! 😅

Support Stride Engine 🌟 🔗

Stride is an open-source project that thrives on community contributions and support. By using Stride, sharing your experiences, and contributing to the community, you help make the engine better for everyone. 🚀

Contribute: Share your knowledge, contribute to the engine, or report issues to help improve Stride for all developers.
Join the Community: Engage with fellow developers, ask questions, and showcase your projects on our Discord server or in GitHub Discussions.
Sponsor: Support the continued development of Stride by becoming a sponsor on our Open Collective page.

This content was reviewed and enhanced with the assistance of ChatGPT.

Stride Community Toolkit Preview - Code-Only Feature Basics in C# - Bullet Physics

2024-09-22T00:00:00Z

Discover the Stride Community Toolkit, a powerful collection of extensions and helpers designed for the Stride game engine. In this blog post (Bullet Physics version), we dive into the toolkit's code-only feature, empowering C# and .NET developers to create immersive 2D/3D games and visualizations with ease. Explore how this community-driven, open-source project can simplify your game development journey.

This blog post is part 1 of a 3-part series:

Stride Community Toolkit Preview - Code-Only Feature - Basics (C#)
- Bepu Physics version
- Also available: Condensed F# version of this tutorial
- The Visual Basic version is also possible but I am running out of space here 😅
Stride Community Toolkit Preview - Code-Only Feature - Advanced
Stride Community Toolkit Preview - Code-Only Feature - Refactoring

This blog post targets Bullet Physics. A separate blog post was published (Bepu Physics link above), which is now the preferred physics engine for Stride. Feel free to continue with this tutorial to get familiar with the core concepts, which remain the same.

Table of Contents:

Introduction 🌱 🔗

This article assumes that you have some experience with .NET and C# programming.

You can also access the full source code for this post on GitHub to follow along or explore the final implementation directly.

Additional details on the benefits of the code-only approach can be found here in the toolkit documentation.

We will be using a standard .NET 10 Console App to create a simple game by adding some NuGet packages to get started.

Here’s the process I found to be the easiest way to begin with the code-only approach:

Run the minimal code to get the game window running
Add entities/primitives to the scene
Add interaction with the keyboard and mouse
Add output to the console or screen
Play around, be creative and have fun

What You'll Learn 🎯 🔗

By the end of this post, you will have a solid foundation in using the Stride Community Toolkit's code-only feature to create a simple game. You’ll learn how to:

Set up the game window and initialize the core components
Add and manipulate entities within the scene
Implement basic interactivity using the keyboard and mouse
Display text output to the console or directly on the screen for debugging or player feedback

Basic Terminology 📚 🔗

Before diving into the steps, it's helpful to understand some key terms that will be used throughout this guide:

Stride: A C# game engine for creating 2D/3D games and visualizations.
Stride Community Toolkit: A collection of extensions and helpers for the Stride engine.
Bepu Physics: The preferred physics engine for Stride, providing advanced Bepu physics simulation capabilities.
Bullet Physics: An alternative physics engine for Stride, which is being phased out in favor of Bepu Physics.
Code-Only: A feature of the toolkit that allows you to create a game without using the Game Studio.
Game: In the context of this post, a game refers to any interactive or visual project created using a game engine. This can range from traditional playable games to simulations, visualizations, or any real-time interactive experiences where users can interact with or observe elements within a scene.
Scene: The container for entities, which defines the game world or environment.
Entity: An object in the scene that can represent anything from a 3D model to a camera or light and aggregates multiple EntityComponents.
EntityComponent: A base component that defines the behavior or properties of an entity. Other components inherit from this class.
RigidbodyComponent: A physics component that allows an entity to respond to forces like gravity and collisions.
Graphics Compositor: A component that organizes how scenes are rendered in the Stride engine.
Camera: A camera that allows viewing the scene from different angles.
Camera Controller: A script that enables basic camera movement using keyboard and mouse inputs.
3D Primitive: A basic 3D model, such as a capsule, cube, or sphere.
Collider: A component that defines the shape of an entity for physical interactions.
Physics Engine: A system that simulates physical interactions between entities in the scene.
Profiler: A tool that monitors performance metrics like frames per second (FPS) and memory usage.
Skybox: A textured 3D model that provides a background for the scene.
Game Loop: The main loop that drives the game, updating the state and rendering the scene.
Update Method: A callback method that is called every frame to update the game state.
Physics-Based Movement: Moving entities using the physics engine to simulate realistic interactions.
Non-Physical Movement: Moving entities by directly changing their position without physics interactions.
Transform: Defines an entity's position, rotation, and scale in the scene.
Force: A vector that represents a physical force applied to an entity.
Delta Time: The time elapsed between frames, used for frame-independent movement.
Material: A visual property that defines how an entity is rendered, including color, texture, and shading.
Ground Gizmo: A visual representation of the ground plane and axis directions in the scene.
GameTime: A structure that provides time-related information for the game loop.
Vector3: A 3D vector that represents a point or direction in 3D space.
Frame Rate: The number of frames rendered per second, measured in frames per second (FPS).

Prerequisites 🏠 🔗

These prerequisites were tested on a clean Windows 11 installation.

Install the Microsoft Visual C++ v14 Redistributable (x64) (approximately 19MB) and restart your system if prompted.
Install the .NET 10 SDK x64 (around 215MB).
Install the IDE of your choice. I will be using Visual Studio 2026 (the Community version is free), but you can also use:
- Visual Studio Code - Free
- Rider - Free for non-commercial use
- Any other IDE that supports .NET development

How to use the code snippets 📝 🔗

You can copy and paste the code into your Program.cs file and run the application to see the results.

You will be guided to replace some parts of the code with the new code snippets as you progress through the steps or replacing the entire Program.cs file.

Also, the code snippets contain comments which part of the code is new or updated.

Code-Only on Windows 🪟 🔗

The code-only approach is currently available only on Windows. The toolkit provides a set of NuGet packages that you can use to create a game without the need for the Game Studio.

Code-Only on Other Platforms 🐧 🔗

However, there are still some limitations. A known workaround for Linux (Ubuntu) is documented here: Code-Only Development on Linux (Ubuntu) Requires Manual File Copying.

While Stride is a cross-platform engine and you can build your game on Windows and run it elsewhere, full support for code-only workflows on platforms like Linux is still evolving.

The Story of the Brave Explorers 📘 🔗

🌍 Welcome, brave explorers of the digital wilderness! Today, we embark on an exciting journey into the heart of the Stride game engine. Our guide? None other than the Stride Community Toolkit.

Finally, we’ll display messages and feedback with both console output and on-screen text, letting our creation communicate with us through the game window. 📝

So, refresh your mouse agility skills 🖱️, and join us on this exhilarating expedition. Let's dive into the code! 💻

Step 1: Create a New C# .NET 10 Console App - Nothingness ⚫ 🔗

Create a new C# .NET 10 Console App in your IDE or use the command line:
```
dotnet new console --framework net10.0 --name YourProjectName
```

Add the following NuGet package: 📦

dotnet add package Stride.CommunityToolkit.Windows --prerelease

Paste the following code into your Program.cs file: 💻

using Stride.Engine;

// Create an instance of the game
using var game = new Game();

// Start the game loop
// This method initializes the game, begins running the game loop,
// and starts processing events.
game.Run();

Build the project from the command line or use your IDE to build it:
```
dotnet build
```
Run the application.
Behold the black void of nothingness 🙀.

If you're still on Stride 4.2, use --version 1.0.0-preview.61 instead of --prerelease, which targets Stride 4.3. This applies to all NuGet packages mentioned below.

You’ve learned how to set up a Stride game window using the Stride Community Toolkit. Even though it's just a black screen, the game window is running, marking the first step in your journey.

Step 2: Let There Be Light - Or at Least Blue 🌌 🔗

Update the Program.cs file to look like this, or simply replace the entire file:

using Stride.CommunityToolkit.Engine; // This was added: Import the toolkit's helper methods
using Stride.Engine;

// Create an instance of the game
using var game = new Game();

// Start the game loop and provide the Start method as a callback
// This method initializes the game, begins running the game loop,
// and starts processing events.
game.Run(start: Start);  // This was updated

// This was added
// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera to the scene to allow viewing from different angles
    game.Add3DCamera();
}

The code above does the following:

Start() method is a callback that is invoked when the game starts. It takes a Scene object as a parameter, representing the root scene of the game.
AddGraphicsCompositor() organizes how scenes are rendered in the Stride engine, enabling extensive customization of the rendering pipeline.
Add3DCamera() adds a 3D camera to the scene, allowing you to view it from various angles.

Step 3: Add Some Shapes - Capsule Time! 🎨 🔗

Firstly, we need to add another NuGet package, Stride.CommunityToolkit.Bullet, which includes the Bullet physics engine. This package is required for the physics engine to work properly. You can add it using the following command:

dotnet add package Stride.CommunityToolkit.Bullet --prerelease

Update the Program.cs file to look like this, or simply replace the entire file:

using Stride.CommunityToolkit.Bullet; // This was added: Import the Bullet physics engine
using Stride.CommunityToolkit.Engine;
using Stride.CommunityToolkit.Rendering.ProceduralModels;  // This was added: Import procedural model helpers
using Stride.Engine;

// Create an instance of the game
using var game = new Game();

// Start the game loop and provide the Start method as a callback
// This method initializes the game, begins running the game loop,
// and starts processing events.
game.Run(start: Start);

// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera to the scene to allow viewing from different angles
    game.Add3DCamera();

    // Create a 3D primitive capsule and store it in an entity
    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule); // This was added
}

You can replace the entire Start() method with the code below:

// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera to the scene to allow viewing from different angles
    game.Add3DCamera();

    // Create a 3D primitive capsule and store it in an entity
    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule);

    // Add the entity to the root scene so it becomes part of the scene graph
    entity.Scene = scene; // This was added
}

Now, run the application again. You should see a capsule in the middle of the screen if you're lucky because it's falling down. Fast! 🚀

Step 4: Control the Camera - Look Around! 🖱️ 🔗

Maybe we should at least look around the scene and view the capsule from different angles as it falls into the void 🤔?

Time to refresh those mouse agility skills!

// This was updated: Add a camera controller for basic camera movement
game.Add3DCamera().Add3DCameraController();

Step 5: Reposition the Capsule - More Excitement! 📍 🔗

Make sure that Stride.Core.Mathematics is used instead of System.Numerics which also contains Vector3.

Update the Program.cs file to look like this, or simply replace the entire file:

using Stride.CommunityToolkit.Bullet;
using Stride.CommunityToolkit.Engine;
using Stride.CommunityToolkit.Rendering.ProceduralModels;
using Stride.Core.Mathematics;  // This was added: Import Vector3 and other math utilities
using Stride.Engine;

// Create an instance of the game
using var game = new Game();

// Start the game loop and provide the Start method as a callback
// This method initializes the game, begins running the game loop,
// and starts processing events.
game.Run(start: Start);

// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera and a controller for basic camera movement
    game.Add3DCamera().Add3DCameraController();

    // Create a 3D primitive capsule and store it in an entity
    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule);

    // Reposition the capsule 8 units above the origin in the scene
    entity.Transform.Position = new Vector3(0, 8, 0); // This was added

    // Add the entity to the root scene so it becomes part of the scene graph
    entity.Scene = scene;
}

entity.Transform.Position sets the position of the entity within the scene. The Vector3 object represents a 3D vector, which in this case, places the capsule at coordinates (0, 8, 0), which is 8 units above the scene's origin.
Stride.Core.Mathematics Stride uses its own implementation of Vector3 and other math utilities, so we need to add this namespace to access those features.

Run the application again. You should see a capsule falling down from the top of the screen. I know, the capsule is black, but don't worry, we'll fix that later. 😉

Step 6: Add a Ground - Catch the Capsule! 🛑 🔗

Now let's catch the capsule by adding some ground to the scene. Update the Start() method to look like this so we can feel more grounded.

You can replace the entire Start() method with the code below:

// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera and a controller for basic camera movement
    game.Add3DCamera().Add3DCameraController();

    // Add a 3D ground plane to catch the capsule
    game.Add3DGround(); // This was added

    // Create a 3D primitive capsule and store it in an entity
    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule);

    // Reposition the capsule 8 units above the origin in the scene
    entity.Transform.Position = new Vector3(0, 8, 0);

    // Add the entity to the root scene so it becomes part of the scene graph
    entity.Scene = scene;
}

Add3DGround() is a toolkit helper method that creates a 3D ground plane in the scene, providing a surface for the capsule to land on.

You’ve learned how to add a 3D ground plane to the scene, giving the capsule a surface to land on. Now, the capsule falls and lands on the ground, making the scene feel more dynamic.

Step 7: Illuminate the Scene - Add Light! 💡 🔗

// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera and a controller for basic camera movement
    game.Add3DCamera().Add3DCameraController();

    // Add a directional light to illuminate the scene
    game.AddDirectionalLight(); // This was added

    // Add a 3D ground plane to catch the capsule
    game.Add3DGround();

    // Create a 3D primitive capsule and store it in an entity
    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule);

    // Reposition the capsule 8 units above the origin in the scene
    entity.Transform.Position = new Vector3(0, 8, 0);

    // Add the entity to the root scene so it becomes part of the scene graph
    entity.Scene = scene;
}

Finally, no more black-on-black mysteries! 💡

You’ve learned how to add a directional light to the scene, illuminating both the capsule and the ground. The scene is now well-lit, making it much easier to see and interact with the objects.

Step 8: Break 1 - Let's Reflect 😅 🔗

Tedious work, but you just learned the very basics of game setup behind the scenes, which is usually done in the Game Studio for you automatically.

You need a Graphics Compositor to render the scene
You need a Camera to view the scene
You need a Camera Controller to move the camera around. This is a C# script that controls the camera's position and orientation
You need a Light to illuminate the scene

Once the basics are set up, you need to add entities to the scene. In our example, we added:

A 3D Ground, a simple primitive model that provides a surface.
A Capsule, another primitive model, which we’ve repositioned and dropped into the scene.

The toolkit added colliders for the ground and capsule, ensuring that the capsule doesn't fall through the ground but instead interacts realistically with the scene.

You can review the implementation of each Stride toolkit extension, which wraps some boilerplate code, and create your own custom implementation.

Whew! 😅 Take a deep breath, and get ready for the next part of our journey. Up next: performance optimizations and more interactive elements. 🚀

Step 9: Add Profiler - Performance! 📈 🔗

Update the Start() method to look like this:

// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera and a controller for basic camera movement
    game.Add3DCamera().Add3DCameraController();

    // Add a directional light to illuminate the scene
    game.AddDirectionalLight();

    // Add a 3D ground plane to catch the capsule
    game.Add3DGround();

    // Add a performance profiler to monitor FPS and other metrics
    game.AddProfiler(); // This was added

    // Create a 3D primitive capsule and store it in an entity
    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule);

    // Reposition the capsule 8 units above the origin in the scene
    entity.Transform.Position = new Vector3(0, 8, 0);

    // Add the entity to the root scene so it becomes part of the scene graph
    entity.Scene = scene;
}

Step 10: Illuminate the Scene - Add Skybox! 🌇 🔗

As exciting as things are looking, we can make our scene even better by adding a skybox. A skybox will enhance the overall atmosphere and give our scene a more polished, realistic look. 🌇

dotnet add package Stride.CommunityToolkit.Skyboxes --prerelease

Then, update the code to look like this:

using Stride.CommunityToolkit.Bullet;
using Stride.CommunityToolkit.Engine;
using Stride.CommunityToolkit.Rendering.ProceduralModels;
using Stride.CommunityToolkit.Skyboxes;  // This was added: Import skybox helpers
using Stride.Core.Mathematics;
using Stride.Engine;

// Create an instance of the game
using var game = new Game();

// Start the game loop and provide the Start method as a callback
// This method initializes the game, begins running the game loop,
// and starts processing events.
game.Run(start: Start);

// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera and a controller for basic camera movement
    game.Add3DCamera().Add3DCameraController();

    // Add a directional light to illuminate the scene
    game.AddDirectionalLight();

    // Add a 3D ground plane to catch the capsule
    game.Add3DGround();

    // Add a performance profiler to monitor FPS and other metrics
    game.AddProfiler();

    // Add a skybox to enhance the scene's visuals
    game.AddSkybox(); // This was added

    // Create a 3D primitive capsule and store it in an entity
    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule);

    // Reposition the capsule 8 units above the origin in the scene
    entity.Transform.Position = new Vector3(0, 8, 0);

    // Add the entity to the root scene so it becomes part of the scene graph
    entity.Scene = scene;
}

Step 11: Add Motion - I like to Move It, Move It! 🕺 🔗

Moving Entities by Changing Their Position Directly (Without Colliders) 🔗

Simple Movement: This method is ideal for scenarios where you want to move objects in a controlled manner without requiring interaction with other entities.
Non-Physical: The entity doesn't respond to gravity, collisions, or any external forces. This makes it perfect for UI elements, floating objects, or objects that need to follow a predefined path.
No Interaction: By default, the entity won't collide with or interact with other objects in the scene. This can simplify certain game mechanics but also limits realism.

Use cases for non-physical movement include:

Camera Movement: Moving a camera smoothly around the scene without it being affected by the environment.
UI Elements: Moving user interface elements, like menus or health bars, without considering collisions.
Cutscenes or Animations: Predefined animations where objects follow scripted paths.

Moving Entities Using Physics (With Colliders) 🔗

This approach leverages Stride's Bullet physics engine to handle movement. By applying forces and impulses to an entity's RigidbodyComponent, we can create realistic interactions that respond to gravity, collisions, and other physical phenomena. Key aspects of this approach include:

Realistic Movement: Entities move according to the laws of physics, making this method suitable for objects that need to interact with the environment.
Collisions: The entity will collide with other objects, allowing for dynamic interactions, such as objects bouncing off surfaces or pushing each other.
Forces: Movement can be influenced by various forces, including gravity, wind, or explosions. This allows for more complex and dynamic gameplay mechanics.
Physics-Driven Gameplay: This method is ideal for games that rely on physics-based mechanics, such as puzzle games, platformers, or simulations.

Use cases for physics-based movement include:

Dynamic Objects: Moving objects that need to interact with other entities, like bouncing balls or rolling barrels.
Character Movement: Characters or vehicles that need to respond to the environment realistically.
Environmental Interaction: Objects that react to player actions, such as crates that can be pushed or destroyed.

Step 12: Add Motion without Physics - Move the Cube without Colliders 📦 🔗

Let's add a a cube 📦 to the scene! 🎉

We'll start with the first option: moving the cube by directly changing its position. Update the code to look like this or replace the entire file:

using Stride.CommunityToolkit.Bullet;
using Stride.CommunityToolkit.Engine;
using Stride.CommunityToolkit.Rendering.ProceduralModels;
using Stride.CommunityToolkit.Skyboxes;
using Stride.Core.Mathematics;
using Stride.Engine;
using Stride.Games;  // This was added

float movementSpeed = 1f; // This was added
Entity? cube1 = null; // This was added

// Create an instance of the game
using var game = new Game();

// Start the game loop and provide the Start and Update methods as callbacks
// This method initializes the game, begins running the game loop,
// and starts processing events.
game.Run(start: Start, update: Update); // This was updated

// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera and a controller for basic camera movement
    game.Add3DCamera().Add3DCameraController();

    // Add a directional light to illuminate the scene
    game.AddDirectionalLight();

    // Add a 3D ground plane to catch the capsule
    game.Add3DGround();

    // Add a performance profiler to monitor FPS and other metrics
    game.AddProfiler();

    // Add a skybox to enhance the scene's visuals
    game.AddSkybox();

    // Add a ground gizmo to visualize axis directions
    game.AddGroundGizmo(position: new Vector3(-5, 0.1f, -5), showAxisName: true);

    // Create a 3D primitive capsule and store it in an entity
    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule);

    // Reposition the capsule 8 units above the origin in the scene
    entity.Transform.Position = new Vector3(0, 8, 0);

    // Add the entity to the root scene so it becomes part of the scene graph
    entity.Scene = scene;

    // This was added
    // Create a cube with material, disable its collider, and add it to the scene
    // The cube is hanging in the default position Vector(0,0,0) in the air,
    // well intersecting the ground plane as it is not aware of the ground
    cube1 = game.Create3DPrimitive(PrimitiveModelType.Cube, new()
    {
        Material = game.CreateMaterial(Color.Gold),
        IncludeCollider = false // No collider for non-physical movement
    });
    cube1.Scene = scene;
}

// This was added
// Define the Update method, called every frame to update the game state
void Update(Scene scene, GameTime time)
{
    // Calculate the time elapsed since the last frame for consistent movement
    // This is crucial for frame-independent movement, ensuring consistent
    // behaviour regardless of frame rate.
    var deltaTime = (float)time.Elapsed.TotalSeconds;

    if (cube1 != null)
    {
         // Move the cube along the negative X-axis with frame-independent motion
        cube1.Transform.Position -= new Vector3(movementSpeed * deltaTime, 0, 0);
    }
}

movementSpeed determines how fast the cube moves.
cube1 is an Entity object representing the cube in the scene.
game.Run(start: Start, update: Update) now includes the Update method as a callback for updating the game state every frame.
AddGroundGizmo() adds a visual representation of the ground plane and axis directions. Just a visual aid, it doesn't affect the physics of the scene.
CreateMaterial() allows you to color the cube (and even the capsule if you want 😉).
Update() is a callback method that is called every frame to update the game state.

Run the application. 🏃 You should see a box (cube) moving along the X-axis, without interacting with other entities.

You’ve learned how to move a cube without using colliders, applying non-physical movement. The cube moves smoothly along the X-axis, showcasing basic object manipulation and animation.

Step 13: Add Motion with Physics - Move the Cube with Colliders! 🧊 🔗

Update the code to include physics-based movement or replace the entire file:

using Stride.CommunityToolkit.Bullet;
using Stride.CommunityToolkit.Engine;
using Stride.CommunityToolkit.Rendering.ProceduralModels;
using Stride.CommunityToolkit.Skyboxes;
using Stride.Core.Mathematics;
using Stride.Engine;
using Stride.Games;
using Stride.Physics; // This was added

float movementSpeed = 1f;
float force = 3f; // This was added
Entity? cube1 = null;
Entity? cube2 = null; // This was added

// Create an instance of the game
using var game = new Game();

// Start the game loop and provide the Start and Update methods as callbacks
// This method initializes the game, begins running the game loop,
// and starts processing events.
game.Run(start: Start, update: Update);

// Define the Start method to set up the scene
void Start(Scene scene)
{
    // Add the default graphics compositor to handle rendering
    game.AddGraphicsCompositor();

    // Add a 3D camera and a controller for basic camera movement
    game.Add3DCamera().Add3DCameraController();

    // Add a directional light to illuminate the scene
    game.AddDirectionalLight();

    // Add a 3D ground plane to catch the capsule
    game.Add3DGround();

    // Add a performance profiler to monitor FPS and other metrics
    game.AddProfiler();

    // Add a skybox to enhance the scene's visuals
    game.AddSkybox();

    // Add a ground gizmo to visualize axis directions
    game.AddGroundGizmo(position: new Vector3(-5, 0.1f, -5), showAxisName: true);

    // Create a 3D primitive capsule and store it in an entity
    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule);

    // Reposition the capsule 8 units above the origin in the scene
    entity.Transform.Position = new Vector3(0, 8, 0);

    // Add the entity to the root scene so it becomes part of the scene graph
    entity.Scene = scene;

    // Create a cube with material, disable its collider, and add it to the scene
    // The cube is hanging in the default position Vector(0,0,0) in the air,
    // well intersecting the ground plane as it is not aware of the ground
    cube1 = game.Create3DPrimitive(PrimitiveModelType.Cube, new()
    {
        Material = game.CreateMaterial(Color.Gold),
        IncludeCollider = false // No collider for simple movement
    });
    cube1.Scene = scene;

    // This was added
    // Create a second cube with a collider for physics-based interaction
    cube2 = game.Create3DPrimitive(PrimitiveModelType.Cube, new()
    {
        Material = game.CreateMaterial(Color.Orange)
    });
    cube2.Transform.Position = new Vector3(-3, 5, 0);  // Reposition the cube above the ground
    cube2.Scene = scene;
}

// Define the Update method, called every frame to update the game state
void Update(Scene scene, GameTime time)
{
    // Calculate the time elapsed since the last frame for consistent movement
    var deltaTime = (float)time.Elapsed.TotalSeconds;

    if (cube1 != null)
    {
        // Move the first cube along the negative X-axis (non-physical movement)
        cube1.Transform.Position -= new Vector3(movementSpeed * deltaTime, 0, 0);
    }

    // This was added
    // Handle physics-based movement for cube2
    if (cube2 != null)
    {
        // Retrieve the RigidbodyComponent, which handles physics interactions
        var rigidBody = cube2.Get<RigidbodyComponent>();

        // Check if cube2 is stationary by verifying if its linear velocity is effectively zero.
        if (Math.Round(rigidBody.LinearVelocity.Length()) == 0)
        {
            // Apply an impulse to cube2 along the X-axis, initiating movement.
            rigidBody.ApplyImpulse(new Vector3(force, 0, 0));

            // Reverse the direction of the impulse for the next impulse,
            // allowing cube2 to move back and forth along the X-axis.
            force *= -1;
        }
    }
}

Stride.Physics provides access to physics-related classes and components, including the RigidbodyComponent.
force determines the strength of the impulse applied to the cube.
cube2 is an Entity object representing the cube that will move using physics-based interactions.
RigidbodyComponent handles physics interactions, allowing the entity to respond to forces, gravity, and collisions.
LinearVelocity represents the velocity of the cube. We check if the velocity is near zero (indicating the cube is stationary) before applying the impulse.
ApplyImpulse() applies a force to the entity, causing it to move in the direction of the applied force. In this case, we’re applying an impulse to the cube, making it move along the X-axis.

Run the application. 🏃‍♂️ You should now see two cubes in the scene:

Cube 1 moves along the X-axis using non-physical movement, just like in the previous step.
Cube 2 interacts with the environment using physics, responding to forces and collisions.

This step introduces a new level of realism by making the cube react to physical forces, adding depth and complexity to your game. 🎮

The main difference between the two cubes is that Cube 1 moves without interacting with the environment. We directly modify the entity's Transform.Position to move it, resulting in simple, non-physical movement. In contrast, Cube 2 responds to physics, collisions, and forces. Instead of manually changing its position, we control its movement through the RigidbodyComponent, which handles all the physics-based interactions, including gravity, impulses, and collisions with other objects in the scene. This makes Cube 2's movement more realistic and reactive to its surroundings.

Step 14: Add Keyboard Interaction - Move the Cube! ⌨️ 🔗

Ensure that the using Stride.Input; namespace is included to handle input.

You can replace the existing Update method with the following code:

// Define the Update method, called every frame to update the game state
void Update(Scene scene, GameTime time)
{
    // Calculate the time elapsed since the last frame for consistent movement
    var deltaTime = (float)time.Elapsed.TotalSeconds;

    // This was updated
    // Handle non-physical movement for cube1
    if (cube1 != null)
    {
        // Move the first cube along the negative X-axis when the Z key is held down
        if (game.Input.IsKeyDown(Keys.Z))
        {
            cube1.Transform.Position -= new Vector3(movementSpeed * deltaTime, 0, 0);
        }
        // Move the first cube along the positive X-axis when the X key is held down
        else if (game.Input.IsKeyDown(Keys.X))
        {
            cube1.Transform.Position += new Vector3(movementSpeed * deltaTime, 0, 0);
        }
    }

    // This was updated
    // Handle physics-based movement for cube2
    if (cube2 != null)
    {
        // Retrieve the RigidbodyComponent, which handles physics interactions
        var rigidBody = cube2.Get<RigidbodyComponent>();

        // We use KeyPressed instead of KeyDown to apply impulses only once per key press.
        // This means the player needs to press and release the key to apply an impulse,
        // preventing multiple impulses from being applied while the key is held down.

        // Apply an impulse to the left when the C key is pressed (and released)
        if (game.Input.IsKeyPressed(Keys.C))
        {
            rigidBody.ApplyImpulse(new Vector3(-force, 0, 0));
        }
        // Apply an impulse to the right when the V key is pressed (and released)
        else if (game.Input.IsKeyPressed(Keys.V))
        {
            rigidBody.ApplyImpulse(new Vector3(force, 0, 0));
        }
    }
}

game.Input.IsKeyDown() checks if a key is currently held down. This is useful for continuous actions, like moving an object as long as the key is pressed.
game.Input.IsKeyPressed() checks if a key was pressed and released once. This is ideal for triggering actions that should only occur once per key press, such as applying an impulse to a physics object, to avoid multiple impulses being applied while the key is held down.

Additional Points:

The non-physical movement for Cube 1 allows smooth, continuous movement along the X-axis when holding the Z or X keys.
The physics-based movement for Cube 2 applies an impulse to the cube when the C or V keys are pressed, allowing it to interact with the environment.
The capsule does not collide with Cube 1 because we disabled the collider for that cube but interacts with Cube 2, which has a collider and responds to physics.

Step 15: Add Mouse Interaction - Do something! 🖱️ 🔗

The previous comments have been streamlined to keep the code clean and focused🧹. Also, make sure you can see your console output to see the results of the mouse interactions.

You can replace the entire code with the following, or refer to the comments labelled // This was added to see the specific changes.

using Stride.CommunityToolkit.Bullet;
using Stride.CommunityToolkit.Engine;
using Stride.CommunityToolkit.Rendering.ProceduralModels;
using Stride.CommunityToolkit.Skyboxes;
using Stride.Core.Mathematics;
using Stride.Engine;
using Stride.Games;
using Stride.Input;
using Stride.Physics;

float movementSpeed = 1f;
float force = 3f;
Entity? cube1 = null;
Entity? cube2 = null;

CameraComponent? camera = null; // This was added: Store the camera component
Simulation? simulation = null; // This was added: Store the physics simulation
ModelComponent? cube1Component = null; // This was added: Store the model component of Cube 1

using var game = new Game();

game.Run(start: Start, update: Update);

void Start(Scene scene)
{
    game.AddGraphicsCompositor();
    game.Add3DCamera().Add3DCameraController();
    game.AddDirectionalLight();
    game.Add3DGround();
    game.AddProfiler();
    game.AddSkybox();
    game.AddGroundGizmo(position: new Vector3(-5, 0.1f, -5), showAxisName: true);

    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule);
    entity.Transform.Position = new Vector3(0, 8, 0);
    entity.Scene = scene;

    cube1 = game.Create3DPrimitive(PrimitiveModelType.Cube, new()
    {
        Material = game.CreateMaterial(Color.Gold),
        IncludeCollider = false // No collider for simple movement
    });
    cube1.Scene = scene;

    cube2 = game.Create3DPrimitive(PrimitiveModelType.Cube, new()
    {
        Material = game.CreateMaterial(Color.Orange)
    });
    cube2.Transform.Position = new Vector3(-3, 5, 0);
    cube2.Scene = scene;

    // These were added
    // Initialize camera, simulation, and model component for interactions
    camera = scene.GetCamera();
    simulation = game.SceneSystem.SceneInstance.GetProcessor<PhysicsProcessor>()?.Simulation;
    cube1Component = cube1.Get<ModelComponent>();
}

void Update(Scene scene, GameTime time)
{
    var deltaTime = (float)time.Elapsed.TotalSeconds;

    // Handle non-physical movement for cube1
    if (cube1 != null)
    {
        if (game.Input.IsKeyDown(Keys.Z))
        {
            cube1.Transform.Position -= new Vector3(movementSpeed * deltaTime, 0, 0);
        }
        else if (game.Input.IsKeyDown(Keys.X))
        {
            cube1.Transform.Position += new Vector3(movementSpeed * deltaTime, 0, 0);
        }
    }

    // Handle physics-based movement for cube2
    if (cube2 != null)
    {
        var rigidBody = cube2.Get<RigidbodyComponent>();

        if (game.Input.IsKeyPressed(Keys.C))
        {
            rigidBody.ApplyImpulse(new Vector3(-force, 0, 0));
        }
        else if (game.Input.IsKeyPressed(Keys.V))
        {
            rigidBody.ApplyImpulse(new Vector3(force, 0, 0));
        }
    }

    // This was added
    // Ensure camera and simulation are initialized before handling mouse input
    if (camera == null || simulation == null || !game.Input.HasMouse) return;

    // This was added
    // Handle mouse input for interactions
    if (game.Input.IsMouseButtonPressed(MouseButton.Left))
    {
        // Check for collisions with physics-based entities using raycasting
        var hitResult = camera.RaycastMouse(simulation, game.Input.MousePosition);

        if (hitResult.Succeeded)
        {
            var message = $"Hit: {hitResult.Collider.Entity.Name}";
            Console.WriteLine(message);

            var rigidBody = hitResult.Collider.Entity.Get<RigidbodyComponent>();

            if (rigidBody != null)
            {
                var direction = new Vector3(0, 3, 0); // Apply impulse upward

                rigidBody.ApplyImpulse(direction);
            }
        }
        else
        {
            Console.WriteLine("No hit detected.");
        }

        // Check for intersections with non-physical entities using ray picking
        var ray = camera.GetPickRay(game.Input.MousePosition);

        if (cube1Component?.BoundingBox.Intersects(ref ray) ?? false)
        {
            Console.WriteLine("Cube 1 hit!");
        }
    }
}

camera stores the camera component for raycasting and ray picking.
simulation stores the physics simulation for handling interactions.
cube1Component stores the model component of Cube 1 for detecting intersections with the mouse ray.
camera.RaycastMouse() detects collisions with physics-based entities using raycasting.
camera.GetPickRay() checks for intersections with non-physical entities using ray picking.

Now, when you click the left mouse button, the application will respond with the following actions depending on where you click:

Clicking Outside the Ground: If you click anywhere in the scene that doesn't intersect with an object or the ground, it will print "No hit detected." This indicates that the mouse ray didn't collide with any entities.
Clicking on Cube 1: Since Cube 1 doesn't have a collider, two things will happen:
- The raycast will pass through Cube 1 and hit the ground beneath it, printing "Hit: Ground."
- Additionally, the ray-picking method will detect that Cube 1 was hit, and it will print "Cube 1 hit!"
Clicking on Cube 2: Cube 2 has a collider, so the raycast will detect the collision and print "Hit: Entity." An impulse will be applied to Cube 2, causing it to move upward in response to the click.
Clicking on the Capsule: Similar to Cube 2, clicking on the capsule will print "Hit: Entity," and an upward impulse will be applied, making the capsule move.
Clicking on the Ground: If you click directly on the ground, the raycast will detect it and print "Hit: Ground." However, the ground will remain stationary because it has a StaticColliderComponent, meaning it's a fixed object in the scene.

Step 16: Add Output - Console or Screen! 📺 🔗

Output Options 🔗

We have several options for displaying output:

Console Output: Useful for debugging and logging information. This is great for developers to see real-time feedback and troubleshoot the game
- We can use traditional Console.WriteLine()
- We can also use Stride's GlobalLogger.GetLogger(), or the Log property when used from within a game script
Debug Text Output: Display text directly in the game window, which is useful for quick, in-game debugging
UI Elements: Create UI elements like text labels or buttons to display information to the player within the game world.

Updating the Console Output 🔗

Let’s update the if (hitResult.Succeeded) {} block by adding two lines to include additional output options:

if (hitResult.Succeeded)
{
    var message = $"Hit: {hitResult.Collider.Entity.Name}";
    Console.WriteLine(message);
    GlobalLogger.GetLogger("Program.cs").Info(message); // This was added
    game.DebugTextSystem.Print($"Entities: {scene.Entities.Count}", new Int2(50, 50)); // This was added

    var rigidBody = hitResult.Collider.Entity.Get<RigidbodyComponent>();

    if (rigidBody != null)
    {
        var direction = new Vector3(0, 3, 0); // Apply impulse upward

        rigidBody.ApplyImpulse(direction);
    }
}

Moving Output to the Screen 🔗

To keep the text on the screen, move the game.DebugTextSystem.Print() call to the beginning of the Update() method:

void Update(Scene scene, GameTime time)
{
    // This was moved
    game.DebugTextSystem.Print($"Entities: {scene.Entities.Count}", new Int2(50, 50));

    var deltaTime = (float)time.Elapsed.TotalSeconds;

    // Handle non-physical movement for cube1
    if (cube1 != null)
    {
        if (game.Input.IsKeyDown(Keys.Z))
        {
            cube1.Transform.Position -= new Vector3(movementSpeed * deltaTime, 0, 0);
        }
        else if (game.Input.IsKeyDown(Keys.X))
        {
            cube1.Transform.Position += new Vector3(movementSpeed * deltaTime, 0, 0);
        }
    }

    // Handle physics-based movement for cube2
    if (cube2 != null)
    {
        var rigidBody = cube2.Get<RigidbodyComponent>();

        if (game.Input.IsKeyPressed(Keys.C))
        {
            rigidBody.ApplyImpulse(new Vector3(-force, 0, 0));
        }
        else if (game.Input.IsKeyPressed(Keys.V))
        {
            rigidBody.ApplyImpulse(new Vector3(force, 0, 0));
        }
    }

    if (camera == null || simulation == null || !game.Input.HasMouse) return;

    if (game.Input.IsMouseButtonPressed(MouseButton.Left))
    {
        // Check for collisions with physics-based entities using raycasting
        var hitResult = camera.RaycastMouse(simulation, game.Input.MousePosition);

        if (hitResult.Succeeded)
        {
            var message = $"Hit: {hitResult.Collider.Entity.Name}";
            Console.WriteLine(message);
            GlobalLogger.GetLogger("Program.cs").Info(message);

            var rigidBody = hitResult.Collider.Entity.Get<RigidbodyComponent>();

            if (rigidBody != null)
            {
                var direction = new Vector3(0, 3, 0); // Apply impulse upward

                rigidBody.ApplyImpulse(direction);
            }
        }
        else
        {
            Console.WriteLine("No hit detected.");
        }

        // Check for intersections with non-physical entities using ray picking
        var ray = camera.GetPickRay(game.Input.MousePosition);

        if (cube1Component?.BoundingBox.Intersects(ref ray) ?? false)
        {
            Console.WriteLine("Cube 1 hit!");
        }
    }
}

Seeing a different number of entities than expected on the screen? Debug the Update() and find out why is that 😯.

Adding UI Elements 🔗

Let’s create a simple text block on the canvas to display information to the player.

Replace your current code with this or refer to the comments labelled // This was added to see the specific changes.

using Stride.CommunityToolkit.Bullet;
using Stride.CommunityToolkit.Engine;
using Stride.CommunityToolkit.Rendering.Compositing; // This was added
using Stride.CommunityToolkit.Rendering.ProceduralModels;
using Stride.CommunityToolkit.Skyboxes;
using Stride.Core.Diagnostics;
using Stride.Core.Mathematics;
using Stride.Engine;
using Stride.Games;
using Stride.Graphics; // This was added
using Stride.Input;
using Stride.Physics;
using Stride.Rendering; // This was added
using Stride.UI; // This was added
using Stride.UI.Controls; // This was added
using Stride.UI.Panels; // This was added

float movementSpeed = 1f;
float force = 3f;
Entity? cube1 = null;
Entity? cube2 = null;

CameraComponent? camera = null;
Simulation? simulation = null;
ModelComponent? cube1Component = null;

SpriteFont? font = null; // This was added

using var game = new Game();

game.Run(start: Start, update: Update);

void Start(Scene scene)
{
    game.AddGraphicsCompositor().AddCleanUIStage(); // This was updated
    game.Add3DCamera().Add3DCameraController();
    game.AddDirectionalLight();
    game.Add3DGround();
    game.AddProfiler();
    game.AddSkybox();
    game.AddGroundGizmo(position: new Vector3(-5, 0.1f, -5), showAxisName: true);

    var entity = game.Create3DPrimitive(PrimitiveModelType.Capsule);
    entity.Transform.Position = new Vector3(0, 8, 0);
    entity.Scene = scene;

    cube1 = game.Create3DPrimitive(PrimitiveModelType.Cube, new()
    {
        Material = game.CreateMaterial(Color.Gold),
        IncludeCollider = false // No collider for simple movement
    });
    cube1.Scene = scene;

    cube2 = game.Create3DPrimitive(PrimitiveModelType.Cube, new()
    {
        Material = game.CreateMaterial(Color.Orange)
    });
    cube2.Transform.Position = new Vector3(-3, 5, 0);
    cube2.Scene = scene;

    camera = scene.GetCamera();
    simulation = game.SceneSystem.SceneInstance.GetProcessor<PhysicsProcessor>()?.Simulation;
    cube1Component = cube1.Get<ModelComponent>();

    // This below was added: Create and display a UI text block
    font = game.Content.Load<SpriteFont>("StrideDefaultFont");
    var canvas = new Canvas
    {
        Width = 300,
        Height = 100,
        BackgroundColor = new Color(248, 177, 149, 100),
        HorizontalAlignment = HorizontalAlignment.Left,
        VerticalAlignment = VerticalAlignment.Bottom,
    };

    canvas.Children.Add(new TextBlock
    {
        Text = "Hello, Stride!",
        TextColor = Color.White,
        Font = font,
        TextSize = 24,
        Margin = new Thickness(3, 3, 3, 0),
    });

    var uiEntity = new Entity
    {
        new UIComponent
        {
            Page = new UIPage { RootElement = canvas },
            RenderGroup = RenderGroup.Group31
        }
    };

    uiEntity.Scene = scene;
}

void Update(Scene scene, GameTime time)
{
    game.DebugTextSystem.Print($"Entities: {scene.Entities.Count}", new Int2(50, 50));

    var deltaTime = (float)time.Elapsed.TotalSeconds;

    // Handle non-physical movement for cube1
    if (cube1 != null)
    {
        if (game.Input.IsKeyDown(Keys.Z))
        {
            cube1.Transform.Position -= new Vector3(movementSpeed * deltaTime, 0, 0);
        }
        else if (game.Input.IsKeyDown(Keys.X))
        {
            cube1.Transform.Position += new Vector3(movementSpeed * deltaTime, 0, 0);
        }
    }

    // Handle physics-based movement for cube2
    if (cube2 != null)
    {
        var rigidBody = cube2.Get<RigidbodyComponent>();

        if (game.Input.IsKeyPressed(Keys.C))
        {
            rigidBody.ApplyImpulse(new Vector3(-force, 0, 0));
        }
        else if (game.Input.IsKeyPressed(Keys.V))
        {
            rigidBody.ApplyImpulse(new Vector3(force, 0, 0));
        }
    }

    if (camera == null || simulation == null || !game.Input.HasMouse) return;

    if (game.Input.IsMouseButtonPressed(MouseButton.Left))
    {
        // Check for collisions with physics-based entities using raycasting
        var hitResult = camera.RaycastMouse(simulation, game.Input.MousePosition);

        if (hitResult.Succeeded)
        {
            var message = $"Hit: {hitResult.Collider.Entity.Name}";
            Console.WriteLine(message);
            GlobalLogger.GetLogger("Program.cs").Info(message);

            var rigidBody = hitResult.Collider.Entity.Get<RigidbodyComponent>();

            if (rigidBody != null)
            {
                var direction = new Vector3(0, 3, 0); // Apply impulse upward

                rigidBody.ApplyImpulse(direction);
            }
        }
        else
        {
            Console.WriteLine("No hit detected.");
        }

        // Check for intersections with non-physical entities using ray picking
        var ray = camera.GetPickRay(game.Input.MousePosition);

        if (cube1Component?.BoundingBox.Intersects(ref ray) ?? false)
        {
            Console.WriteLine("Cube 1 hit!");
        }
    }
}

font stores the SpriteFont used for the UI text block.
AddCleanUIStage() adds a clean UI stage to the graphics compositor, allowing UI elements to be displayed on top of the 3D scene.
game.Content.Load<SpriteFont>() loads the default font for the UI text block.
Canvas is a UI panel that acts as a container for UI elements.
TextBlock is a UI element that displays text on the screen.
UIComponent is a component that manages UI elements in the scene.
UIPage is a UI page that contains the root element of the UI hierarchy.
RenderGroup.Group31 specifies the rendering order of the UI element, ensuring it appears on top of other elements.

Save and run the application. You should now see the text "Hello, Stride!" displayed at the bottom left corner of the screen. 📺

Make sure that you added AddCleanUIStage() .

Step 17: Break 2 - Let's Reflect 😅 🔗

Time for a quick reflection on what we've achieved in the last few steps. We've significantly expanded our game's functionality and interactivity. Here's a recap:

Performance Monitoring: We added a profiler to monitor key metrics like FPS, helping optimize performance for a smoother experience. You also learned how to toggle through profiler outputs to track different aspects of the game. 🚀
Enhanced Visuals: By adding a skybox, we made the scene more immersive, creating a polished and professional look. 🎨
Understanding Motion: We explored the difference between non-physical and physics-based movement, learning how to decide which method to use based on game mechanics. 🧠
Non-Physical Movement: You learned how to move entities using Transform.Position without interacting with other objects. This approach is great for UI elements or simple animations. 🚶‍♂️
Physics-Based Movement: By applying forces to entities via RigidbodyComponent, we introduced realistic interactions with gravity and collisions, adding depth to the gameplay. ⚙️
Keyboard Controls: We implemented basic keyboard inputs to move entities, adding interactivity and responsiveness to the game. 🎮
Mouse Controls: We extended player interaction by integrating mouse clicks, allowing players to trigger actions like applying forces to entities. 🖱️
Displaying Output: Finally, we explored output options, from console logs to UI elements, enhancing player feedback and communication. 📊
Entities Count: While debugging, you discovered that an entity can be added to the scene without necessarily having a visual representation. You also learned that the camera, light, game profiler, and skybox are all entities as well. 🤯

Step 18: Add More Primitives - Let's go crazy! 🤪 🔗

Two boxes 📦🧊 and a capsule 💊? That's not enough fun! I didn't sign up for just that! Let's crank it up and add more shapes to the scene!

To do this, add the following code inside the Update() method, below the if (cube2 != null) {} block:

if (game.Input.IsKeyDown(Keys.Space))
{
    var entity = game.Create3DPrimitive(PrimitiveModelType.Cube, new()
    {
        Material = game.CreateMaterial(Color.Green),
        Size = new Vector3(0.5f),
    });

    entity.Transform.Position = VectorHelper.RandomVector3(
        xRange: [-3, 3],
        yRange: [10, 13],
        zRange: [-3, 3]
    );
    entity.Scene = scene;
}

 if (game.Input.IsMouseButtonDown(MouseButton.Middle))
 {
     var hitResult = camera.RaycastMouse(simulation, game.Input.MousePosition);

     if (hitResult.Succeeded)
     {
         var rigidBody = hitResult.Collider.Entity.Get<RigidbodyComponent>();

         if (rigidBody != null)
         {
             var direction = VectorHelper.RandomVector3([-20, 20], [0, 20], [-20, 20]);

             rigidBody.ApplyImpulse(direction);
         }
     }
 }

The final code is also available on GitHub.

Run the application, and now, whenever you click the middle mouse button on an object, it will get a random impulse in a random direction. 🎲 How cool is that?

You've now learned how to create more primitives using keyboard input and apply random forces to objects with the middle mouse button - all in just around 240 lines of code.

Wrapping Up: Your Journey Continues 🎯 🔗

What You've Achieved 🔗

The Power of Interactivity 🔗

If you'd like to explore the final code for this project, you can access it on GitHub. Feel free to check it out and experiment! 💻

Follow-Up Articles 🚶 🔗

In the not-so-distant future, we will cover the following topics in Bepu Physics:

Stride Community Toolkit Preview - Code-Only Feature - Advanced: Let's get creative and explore more advanced features to take your game to the next level. 🚀
- Maximize the game window
- Setting the Game Window Title
- Hot reload
- Removing entities from the scene
- Entities vs Children vs Components
- Interaction with the UI and from the UI
- Transforming entities
- Advanced physics interactions
- Audio and sound effects
- Particle effects
Stride Community Toolkit Preview - Code-Only Feature - Refactoring: Let's refactor the code to make it more modular, reusable, and maintainable. 🛠️
- Or in other words, let’s clean up the mess we made! 😅

Support Stride Engine 🌟 🔗

Contribute: Share your knowledge, contribute to the engine, or report issues to help improve Stride for all developers.
Join the Community: Engage with fellow developers, ask questions, and showcase your projects on our Discord server or in GitHub Discussions.
Sponsor: Support the continued development of Stride by becoming a sponsor on our Open Collective page.

This content was reviewed and enhanced with the assistance of ChatGPT.

Stride Community Toolkit Preview - Code-Only Feature Basics in F#

2024-09-21T00:00:00Z

Discover how to use the Stride Community Toolkit's code-only feature with F#, showcasing a powerful set of extensions and helpers specifically tailored for game development in the Stride engine. Learn the basics of integrating F# with Stride's game engine to create 3D scenes, handle input, and manage entities, all using functional programming techniques.

Table of Contents:

Introduction 🔗

This article is a condensed version of the original tutorial aimed at C# developers. You can find the original article here.

Though I’m not an F# developer, I wanted to demonstrate how easy it is to use the Stride Community Toolkit with F#. The code provided is a direct translation of the original C# implementation into F#.

Prerequisites 🏠 🔗

To follow this tutorial, you should have a solid understanding of F# and .NET.

These steps were tested on a fresh installation of Windows 11.

Install the Microsoft Visual C++ v14 Redistributable (x64) (approximately 19MB) and restart your system if prompted.
Install the .NET 10 SDK x64 (around 215MB).
Install the IDE of your choice. I will be using Visual Studio 2026 (the Community version is free), but you can also use:
- Visual Studio Code - Free
- Rider - Free for non-commercial use
- Any other IDE that supports .NET development

Getting Started 🚀 🔗

Create a new F# Console App (.NET) project in your IDE.

Add the Stride Community Toolkit NuGet packages to your project.

dotnet add package Stride.CommunityToolkit.Windows --prerelease
dotnet add package Stride.CommunityToolkit.Skyboxes --prerelease
dotnet add package Stride.CommunityToolkit.Bepu --prerelease

Replace the contents of the Program.fs file with the code below.
Run the project and enjoy the scene!

How to Play ⌨️ 🔗

Use the Z and X keys to move the first cube left and right.
Use the C and V keys to apply an impulse to the second cube in the opposite directions.
Press the Space key to create a new cube. You can create multiple cubes this way.
Click the middle mouse button to apply a random impulse to the cube under the cursor.
Click the left mouse button to apply an upward impulse to the cube under the cursor.

open Stride.CommunityToolkit.Bepu
open Stride.CommunityToolkit.Engine
open Stride.CommunityToolkit.Skyboxes
open Stride.CommunityToolkit.Rendering.ProceduralModels
open Stride.Core.Mathematics
open Stride.Engine
open Stride.CommunityToolkit.Rendering.Compositing
open Stride.Games
open Stride.Input
open Stride.CommunityToolkit.Helpers
open System
open Stride.Core.Diagnostics
open Stride.Graphics
open Stride.UI.Panels
open Stride.UI.Controls
open Stride.UI
open Stride.Rendering
open Stride.BepuPhysics

let mutable movementSpeed = 1.0f
let mutable force = 3.0f
let mutable cube1: Entity option = None
let mutable cube2: Entity option = None

let mutable camera: CameraComponent option = None
let mutable simulation: BepuSimulation option = None
let mutable cube1Component: ModelComponent option = None

let mutable font: SpriteFont = null

let game = new Game()

let Start (scene: Scene) =
    game.AddGraphicsCompositor().AddCleanUIStage() |> ignore
    game.Add3DCamera().Add3DCameraController() |> ignore
    game.AddDirectionalLight() |> ignore
    game.Add3DGround() |> ignore
    game.AddProfiler() |> ignore
    game.AddSkybox() |> ignore
    game.AddGroundGizmo(Vector3(-5.0f, 0.1f, -5.0f), showAxisName = true)

    let entity = game.Create3DPrimitive(PrimitiveModelType.Capsule)
    entity.Transform.Position <- new Vector3(0f, 8f, 0f)
    entity.Scene <- scene

    // Create the first cube (no collider)
    let primitive1 = game.Create3DPrimitive(PrimitiveModelType.Cube, new Bepu3DPhysicsOptions(
        Material = game.CreateMaterial(Color.Gold),
        IncludeCollider = false
    ))
    primitive1.Scene <- scene
    cube1 <- Some primitive1

    // Create the second cube (with collider)
    let primitive2 = game.Create3DPrimitive(PrimitiveModelType.Cube, new Bepu3DPhysicsOptions(
        Material = game.CreateMaterial(Color.Orange)
    ))
    primitive2.Transform.Position <- Vector3(-3.0f, 5.0f, 0.0f)
    primitive2.Scene <- scene
    cube2 <- Some primitive2

    // Initialize camera, simulation, and model component for interactions
    camera <- Some (scene.GetCamera())
    simulation <- camera |> Option.map (fun c -> c.Entity.GetSimulation())
    cube1Component <- primitive1.Get<ModelComponent>() |> Option.ofObj

    // Create and display a UI text block
    font <- game.Content.Load<SpriteFont>("StrideDefaultFont")

    let canvas = Canvas(
        Width = 300.0f,
        Height = 100.0f,
        BackgroundColor = Color(byte 248, byte 177, byte 149, byte 100),
        HorizontalAlignment = HorizontalAlignment.Left,
        VerticalAlignment = VerticalAlignment.Bottom)

    // Add a text block to the canvas
    let textBlock = TextBlock(
        Text = "Hello, Stride!",
        TextColor = Color.White,
        Font = font,
        TextSize = 24.0f,
        Margin = Thickness(3.0f, 3.0f, 3.0f, 0.0f))

    canvas.Children.Add(textBlock)

    let uiEntity = new Entity()
    uiEntity.Add(UIComponent(
        Page = new UIPage(RootElement = canvas),
        RenderGroup = RenderGroup.Group31))

    uiEntity.Scene <- scene

// Define the Update method, called every frame to update the game state
let Update (scene: Scene) (time: GameTime) =
    game.DebugTextSystem.Print(sprintf "Entities: %d" scene.Entities.Count, Int2(50, 50))

    // Calculate the time elapsed since the last frame for consistent movement
    // This is crucial for frame-independent movement, ensuring consistent
    // behaviour regardless of frame rate.
    let deltaTime = float32 time.Elapsed.TotalSeconds

    // Handle non-physical movement for cube1
    // Move the first cube along the X-axis (non-physical movement)
    match cube1 with
    | Some cube ->
        let position = cube.Transform.Position
        let newPosition =
            if game.Input.IsKeyDown(Keys.Z) then
                Vector3(position.X - movementSpeed * deltaTime, position.Y, position.Z)
            elif game.Input.IsKeyDown(Keys.X) then
                Vector3(position.X + movementSpeed * deltaTime, position.Y, position.Z)
            else
                position
        cube.Transform.Position <- newPosition
    | None -> ()

    // Handle physics-based movement for cube2
    match cube2 with
    | Some cube ->
        let rigidBody = cube.Get<BodyComponent>()
        if game.Input.IsKeyPressed(Keys.C) then
            rigidBody.Awake <- true
            rigidBody.ApplyImpulse(Vector3(-force, 0.0f, 0.0f), Vector3.Zero)
        elif game.Input.IsKeyPressed(Keys.V) then
            rigidBody.Awake <- true
            rigidBody.ApplyImpulse(Vector3(force, 0.0f, 0.0f), Vector3.Zero)
    | None -> ()

    if game.Input.IsKeyDown(Keys.Space) then
        let entity = game.Create3DPrimitive(PrimitiveModelType.Cube, new Bepu3DPhysicsOptions(
            Material = game.CreateMaterial(Color.Green),
            Size = new Vector3(0.5f)
        ))
        entity.Transform.Position <- VectorHelper.RandomVector3([| -3f; 3f |], [| 10f; 13f |], [| -3f; 3f |])
        entity.Scene <- scene

    // Ensure camera and simulation are initialized before handling mouse input
    if camera.IsNone || simulation.IsNone || not game.Input.HasMouse then
        ()
    else
        if game.Input.IsMouseButtonDown(MouseButton.Middle) then
            let mutable hitInfo = Unchecked.defaultof<HitInfo>
            let hitResult = camera.Value.Raycast(game.Input.MousePosition, 100f, &hitInfo)
            if hitResult then
                let rigidBody = hitInfo.Collidable.Entity.Get<BodyComponent>()
                if rigidBody <> null then
                    let direction = VectorHelper.RandomVector3([| -20.0f; 20.0f |], [| 0.0f; 20.0f |], [| -20.0f; 20.0f |])
                    rigidBody.Awake <- true
                    rigidBody.ApplyImpulse(direction, Vector3.Zero)
            // Return after handling middle mouse input

        // Handle left mouse button input
        if game.Input.IsMouseButtonPressed(MouseButton.Left) then
            let mutable hitInfo = Unchecked.defaultof<HitInfo>
            let hitResult = camera.Value.Raycast(game.Input.MousePosition, 100f, &hitInfo)
            if hitResult then
                let message = sprintf "Hit: %s" hitInfo.Collidable.Entity.Name
                Console.WriteLine(message)
                GlobalLogger.GetLogger("Program.fs").Info(message)

                let rigidBody = hitInfo.Collidable.Entity.Get<BodyComponent>()
                if rigidBody <> null then
                    let direction = Vector3(0.0f, 3.0f, 0.0f) // Apply upward impulse
                    rigidBody.Awake <- true
                    rigidBody.ApplyImpulse(direction, Vector3.Zero)
            else
                Console.WriteLine("No hit detected.")

            // Check for intersections with non-physical entities using ray picking
            let ray = camera.Value.GetPickRay(game.Input.MousePosition)
            if cube1Component.IsSome && cube1Component.Value.BoundingBox.Intersects(&ray) then
                Console.WriteLine("Cube 1 hit!")

[<EntryPoint>]
// Start the game loop and provide the Start and Update methods as callbacks
// This method initializes the game, begins running the game loop,
// and starts processing events.
let main argv =
    game.Run(start = System.Action<Scene>(Start), update = System.Action<Scene, GameTime>(Update))
    0

The video below was recorded for the C# version, but the result is the same for F#.

Conclusion 🔗

In this article, you learned how to use the Stride Community Toolkit's code-only feature with F# for game development in the Stride engine. We explored the basics of integrating F# with Stride to create 3D scenes, handle input, and manage entities—all while leveraging functional programming techniques.

If you'd like to see the full project, you can access it on GitHub. Feel free to check it out and experiment! 💻:

Support Stride Engine 🌟 🔗

Stride is an open-source project that thrives on community contributions and support. By using Stride, sharing your experiences, and contributing to the community, you help improve the engine for everyone. 🚀

Contribute: Share your knowledge, contribute to the engine, or report issues to help enhance Stride for all developers.
Join the Community: Engage with fellow developers, ask questions, and showcase your projects on our Discord server or in GitHub Discussions.
Sponsor: Support the ongoing development of Stride by becoming a sponsor on our Open Collective page.

This content was reviewed and enhanced with the assistance of ChatGPT.

How to reference remote C# code in 11ty

2023-03-15T00:00:00Z

We write blog posts and we want to reference our GitHub project C# code or any code from our projects in 11ty. This is a great way to share and maintain code snippets with the community.

11ty and remote source code 🔗

I am new to 11ty so I asked the 11ty community here at GitHub Discussions and @pehann helped me out.

I have modified the original implementation for this post so it is more generic.

eleventyConfig.addAsyncShortcode("remote_include", async function (urlPath) {

    const sample = await EleventyFetch(url, {
        duration: "1d"
    });

    return sample;
});

Example remote C# code reference in markup.

```csharp
{% remote_include 'https://raw.githubusercontent.com/stride3d/stride/master/samples/Tutorials/CSharpIntermediate/CSharpIntermediate/CSharpIntermediate.Game/01_UI-Basics/UIByEditor.cs' %}
```

Result:

// Copyright (c) .NET Foundation and Contributors (https://dotnetfoundation.org/ & https://stride3d.net)
// Distributed under the MIT license. See the LICENSE.md file in the project root for more information.
using Stride.Engine;
using Stride.Graphics;
using Stride.UI;
using Stride.UI.Controls;
using Stride.UI.Events;

namespace CSharpIntermediate.Code
{
    public class UIByEditor : StartupScript
    {
        public SpriteFont Font;

        private TextBlock textBlock;
        private EditText editText;

        public override void Start()
        {
            // Retrieve the page property from the UI component
            var page = Entity.Get<UIComponent>().Page;

            // Retrieve UI elements by Type and name
            textBlock = page.RootElement.FindVisualChildOfType<TextBlock>("MyTextBlock");
            editText = page.RootElement.FindVisualChildOfType<EditText>("MyEditText");

            // When the text changes, update the textblock
            editText.TextChanged += (s, e) =>
            {
                textBlock.Text = "My name is: " + editText.Text;
            };

            // When the button is clicked, we execute a method that clears the textbox
            var button = page.RootElement.FindVisualChildOfType<Button>("MyButton");
            button.Click += ButtonClicked;
        }

        private void ButtonClicked(object sender, RoutedEventArgs e)
        {
            // Changing the text triggers the TextChanged event again
            editText.Text = "";

            // We also want to reset the text in the textblock
            textBlock.Text = "...";
        }
    }
}

Explore Stride's Minimal API: A Code-Only Approach

2022-05-13T00:00:00Z

With only 12 lines of code, you can kickstart your game development journey in Stride 3D using the Stride Community Toolkit, as illustrated in the example below (plus some usings at the top).

This method is compatible with Stride version 4.1 and later.

Follow the steps outlined in the Stride Community Toolkit to get started.

Check out the related tweet for more insights.

using Stride.CommunityToolkit.Extensions;
using Stride.CommunityToolkit.ProceduralModels;
using Stride.Core.Mathematics;
using Stride.Engine;

using var game = new Game();

game.Run(start: (Scene rootScene) =>
{
    game.SetupBase3DScene();

    var entity = game.CreatePrimitive(PrimitiveModelType.Capsule);

    entity.Transform.Position = new Vector3(0, 8, 0);

    entity.Scene = rootScene;
});

Visual Studio Advance

2021-05-24T00:00:00Z

This post is a quick reference and should help you to familiarise quickly with the key and essential Visual Studio (VS) functionality.

The VS Integrated Development Environment (IDE) might look overwhelming in the beginning but there is no need to know everything. More you work with VS you will start discovering what you need and you will eventually understand the complexity of VS by passive learning.

Initial notes:

You should already be familiar with any coding/development IDE
This is not a tutorial, this is a quick reference on what is the most important or helpful to know when you start working with Visual Studio. Do check any available material to familiarise and learn if you don't understand this guide
If you don't know certain terms just google them

Content 🔗

1. Solution vs Project 🔗

Depends on your circumstances and your team workflow, you might find different (sometimes confusing) folder structure patterns.

VS projects can be in different physical locations on your drive and your VS solution is referencing them wherever the projects are. You can also have multiple solutions *.sln if you need to reference/view projects in different ways. Many projects will be grouped together in their parent folder.

Your solution projects might be independent from each other or some of them might have dependencies. The circular dependencies are not allowed and it is an anti-pattern.

There are many ways to organise your solution. If you work in a team or alone, consistency is important.

See some basic folder structure examples:

Example 1 - Projects in one repository - Mono-repo 🔗

This example is showing independent projects with no project dependencies, which are grouped together in the api-bureau.sln solution. The intention might be to extract a common library which will be used by all projects. All projects are in the same repository to simplify a workflow for the small team who needs to work across all projects.

/api-bureau
/api-bureau/api-bureau.sln
/api-bureau/.gitignore

/api-bureau/src/ApiBureau.CloudCall.Api
/api-bureau/src/ApiBureau.Confluence.Api
/api-bureau/src/ApiBureau.SharePoint.Api

/api-bureau/test/ApiBureau.CloudCall.Api.UnitTests
/api-bureau/test/ApiBureau.Confluence.Api.UnitTests
/api-bureau/test/ApiBureau.SharePoint.Api.UnitTests

Example 2 - Projects in multiple repositories 🔗

This example is showing projects, which are grouped together in the ApiBureau.AllApis.sln solution. The only dependency is that all-apis project is dependent on all other APIs. The teams working mostly independently prefer to have their repos separated.

Note: Visual Studio 2022+ supports managing multiple repositories from one solution.

/api-bureau
/api-bureau/all-apis/.gitignore
/api-bureau/all-apis/ApiBureau.AllApis.sln
/api-bureau/all-api/src/ApiBureau.AllApis.Console

/api-bureau/cloudcall-api/.gitignore
/api-bureau/cloudcall-api/ApiBureau.CloudCall.sln
/api-bureau/cloudcall-api/src/ApiBureau.CloudCall.Api
/api-bureau/cloudcall-api/test/ApiBureau.CloudCall.Api.UnitTests

/api-bureau/confluence-api/.gitignore
/api-bureau/confluence-api/ApiBureau.Confluence.sln
/api-bureau/confluence-api/src/ApiBureau.Confluence.Api
/api-bureau/confluence-api/test/ApiBureau.Confluence.Api.UnitTests

/api-bureau/sharepoint-api/.gitignore
/api-bureau/sharepoint-api/ApiBureau.SharePoint.sln
/api-bureau/sharepoint-api/src/ApiBureau.SharePoint.Api
/api-bureau/sharepoint-api/test/ApiBureau.SharePoint.Api.UnitTests

2. Solution Explorer 🔗

By default your Solution Explorer is showing only the most relevant files. And some files e.g., *.cs will automatically appear in your Solution Explorer when you copy a file to your project folder or create a new C# file.

Some files e.g., .gitignore are hidden in the Solution Explorer so they don't distract you. It is good to familiarise yourself with the project folders and files. You can toggle these files by:

Solution Explorer Toolbar → Click Show All Files

Or you can see all files on your drive through File Explorer:

Solution Explorer → Right click on Solution -> Open Folder in File Explorer

If you don't use Solution Explorer, you can collapse this window to a vertical bar on the side of your screen. This is helpful when you share a screen, to get more visibility of your code.

Solution Explorer → Click the Auto Hide pin icon

To reverse, click the vertical bar, then Solution Explorer and then pin icon again.

4. Default Configuration - AppSettings.cs / appsettings.json 🔗

Application configuration is a huge subject. If you are working with ASP.NET Core, get familiar with appsettings.json and also with AppSettings.cs. IOptions<AppSettings> will let you use your configuration through strongly typed settings and dependency injection.

.NET has lots of helpers and methods which will simplify access to your configuration and you can use them also outside of ASP.NET Core applications, e.g., Console Application.

Very important is the sequence of configuration providers:

appsettings.json
appsettings.{Environment}.json
User secrets
Environment variables
Command-line arguments

Lots of reading on this subject here Application Configuration.

5. Manage User Secrets 🔗

Any passwords, secrets, any information you don't want to share has to be secured and not committed to your source control system like Git. How do you do it in VS? Very easily.

Solution Explorer → Select your project → Right Click → Select Manage User Secrets
- VS might ask to install this NuGet Microsoft.Extensions.Configuration.UserSecrets or it will open file secrets.json.
You can use also .NET CLI to manage this file

File secrets.json is kept outside of your VS projects and solution and it is never pushed to your git repository. Note, that this file is not encrypted. It is a plain text file, still hanging on your computer in this location:

%APPDATA%\Microsoft\UserSecrets\<user_secrets_id>\secrets.json

Read more about Secrets in development subject.

6. editorconfig 🔗

If you work alone or in a team, code consistency is very important in each project.

You can add an EditorConfig file to your project or codebase to enforce consistent coding styles for everyone that works in the codebase. Do ask your colleagues and propose this process if it is not in place. Consistency helps with readability across all projects.

More about this subject here Settings with EditorConfig.

Q&A 🔗

Q: How to change the .NET version? 🔗

A1: Double click on the project file to open the project as XML and edit the <TargetFramework>net5.0</TargetFramework> tag. You can also target multiple frameworks by replacing this tag with <TargetFrameworks>net5.0;net6.0</TargetFrameworks> tag.

Visual Studio Intro

2021-04-03T00:00:00Z

This intro is a quick reference and it should help you to familiarise quickly with the key and essential Visual Studio (VS) functionality.

Initial notes:

You should already be familiar with any coding/development IDE
This is not a tutorial, this is a quick reference on what is the most important or helpful to know when you start working with Visual Studio. Do check any available material to familiarise and learn if you don't understand this guide
If you don't know certain terms just google them

Content 🔗

1. Solution vs Project 🔗

Solution contains 1 or more projects to logically organise your projects together.

2. Opening Solution / Project 🔗

You can open a project by clicking on a file with extension .sln (solution) or .csproj (C# project). If you open a project which is part of a solution, the solution might open instead automatically.

3. Solution Explorer 🔗

Once you open your Solution or Project you want to see your Solution Explorer which contains a logical hierarchy of all folders and files which are needed to build your project. You are going to use this window and navigate through it very frequently. Usually you would have your Solution Explorer on the right or on the left always visible.

Note: If you cannot see it go to Menu → View → Click Solution Explorer (first in the menu)

4. Windows Management 🔗

You might use these options below frequently to arrange your windows. More info about customising layouts.

Vertical Document Group - If you need to see different files next to each other
Horizontal Document Group - If you need to see different files horizontally
Split Window - You can split horizontally the edition of a file through Window → Split. This is especially useful when visualizing or editing two locations in a large file
New Window - Open an instance of the same file in a separate window, Window → New Window

5. F12 is your friend - Go to Definition 🔗

The Go To Definition feature navigates to the source of a type or member, and opens the result in a new tab.

Pressing F12 while your text cursor is somewhere inside the symbol name
Right click mouse on the symbol → Go to Definition
Or ALT+F12 to peek the identifier definition without opening a new tab

6. CTRL+T and CTRL+Q - Search Everywhere 🔗

CTRL+Q - Search everywhere in the code, including menu items
CTRL+T - Search everywhere in the code

7. dotnet command 🔗

It provides commands for working with .NET projects
- e.g. dotnet build builds a project
- e.g. dotnet --info shows detailed information about a .NET installation
It runs .NET applications
- e.g. dotnet myApplication.exe or dotnet myApplication.dll

8. Project story - Viewing csproj in summary 🔗

.NET projects are based on the MSBuild format. Project files, which have extensions like .csproj for C# project are in XML format. The csproj file includes settings related to targeted .NET Frameworks, project folders, NuGet package references etc.

You can edit in 2 ways

Solution Explorer → Select your project → Right Click → Select Edit Project File
Solution Explorer → Double click on the project name

9. Project Packages (nuget) 🔗

An essential tool for any modern development platform is a mechanism through which developers can create, share, and consume useful code. Often such code is bundled into "packages" that contain compiled code (as DLLs) along with other content needed in the projects that consume these packages (source An introduction to Nuget).

For .NET (including .NET Core), the Microsoft-supported mechanism for sharing code is NuGet (essentially a single ZIP file) with the .nupkg extension.

Solution Explorer → Right click on Project→ Manage Nuget Packages
- Browse - Search for new packages
- Installed - See your installed packages
- Updates - See current updates for your installed packages (mind minor vs major updates)

10. Visual Studio Extensions 🔗

Extensions allow you to customize and enhance your experience in Visual Studio by adding new features or integrating existing tools (Amazon, Azure, ..). The main purpose is to increase your productivity and cater to your workflow.

Top Menu → Extensions → Manage Extensions
- Installed - All installed and pre-installed extensions
- Online - Search for new extensions
- Updates - Update extensions, some extensions update automatically
- Roaming Extensions Manager - If you are logged into Visual Studio with your Microsoft account you can sync your extensions to other devices with Visual Studio
Top free extensions for development
- CodeMaid
- Productivity Power Tools 2019/2022 - Installs a few individual extensions for your productivity
- Live Share - Real-time collaborative development in Visual Studio and Visual Studio Code
- Web Essentials 2019/2022 - Installs a few individual extensions for your web development
- AWS Toolkit - If you work/deploy to AWS

11. Visual Studio Settings 🔗

Top Menu → Edit → Advance → Word Wrap
- Very useful so you don't need to move your horizontal bar
Top Menu → Tools→ Options → Projects and Solutions → Track Active Item in Solution Explorer -
- Solution Explorer item is selected automatically when you edit the file in the Editor
Top Menu → Tools→ Options → Productivity Power Tools (Extension) → Power Commands → Remove and Sort Using on save

Q&A 🔗

Q: How to create a new project within the solution? 🔗

A1: Solution Explorer → Right click on Solution → Add → New project or Existing Project

A2: Top Menu → File → Add → New project or Existing Project

Q: How to change the .NET version? 🔗

A1: Double click on the project file to open the project as XML and edit the <TargetFramework>net5.0</TargetFramework> tag.

A2: Solution Explorer → Right Click on the Project → Click Properties → Click Application → Change Target Framework

Jazor experiment

2020-10-31T00:00:00Z

This experiment library helps with very common actions on the website which involve repeating JavaScript code across multiple different projects.

Click a button or a link, do something in the backend and UI. This library takes an approach rather updating whole HTML blocks than granular tags with JSON and JavaScript libraries, so there is no need fiddling and mapping JSON objects to whatever UI you have.

You might find this approach useful in certain project cases if you want to write minimum or no JavaScript. Still, JavaScript knowledge is required in certain scenarios.

There is a crossover with Blazor or rather Jazor is filling a gap between static HTML/Razor pages and Blazor.

When could you possibly use this library and not necessarily Blazor?

You have got many Partial views in Razor pages and views which you would like to reuse e.g.

public IActionResult OnGetNews() =>  Partial("_NewsPartial", 10);

You would like a hybrid of your current website and add simple SPA functionality
Your project doesn't require minimising traffic in between the browser and server

This library is using currently:

TypeScript to handle all common actions workload
ASP.NET Core 5.0 TagHelpers to simplify using data- and a bit help with strongly typed Controllers and Actions
GitHub link https://github.com/VaclavElias/Jazor

Requirements 🔗

Add jazor.js to your Razor page or _Layout.
Add @addTagHelper *, Jazor to your _ViewImports.cshtml

ToDo 🔗

Add more functionality
Make prompts and spinners pluggable

Examples 🔗

I will be using Bootstrap in my examples.

Example 1 🔗

Load multiple delayed HTML / Partial Views.

Load News part
Load Top News part after 1 second
This will load your HTML from your desired url

<div jazor-url="/examples/news">Loading...</div>
<div jazor-url="@((nameof(ExamplesController), nameof(ExamplesController.TopNews), null))" jazor-delay="1">Loading...</div>

Example 2 🔗

Click a button or link to load HTML / Partial Views to your target element.

<button jazor-click="/examples/itnews" jazor-target="content" type="button" class="btn btn-primary">Show .NET News</div>
<button jazor-click="@((nameof(ExamplesController), nameof(ExamplesController.AngularNews), null))" jazor-target="content" type="button" class="btn btn-primary">Show Angular News</button>

<div id="content">The content will be loaded here.</div>

Visual Studio Debugger Enumerable Visualizer

2019-06-11T00:00:00Z

Visual Studio Debugger Enumerable Visualizer without any [Serialize] attribute, using Json was an experiment to get a better experience when debugging IEnumerables.

This is now inbuilt in Visual Studio 2022 from version 17.2.

Read more about my implementation here EnumerableVisualizer.

Configuration experiment in ASP.NET Core – RemoteJsonFile

2019-06-01T00:00:00Z

This is an experiment project to access appsettings.json from Azure Blob or any remote url.

I will use public access to this Azure file considering no user secrets are included in this file. You would need to add additional options to secure your link if any user secrets are transmitted.

Example url: https://your-storage.blob.core.windows.net/your-blob/appsettings.json

services.AddRemoteJsonFile(Configuration, "AppSettings:Url:RemoteUrl", options =>
{
    Configuration = options;
});

Source here CodeCapital.AspNetCore.Extensions.Configuration.Json.