When working on Stopping the Rogue I found out that removing an entity from a scene and adding it as a child to another entity will cause a very nasty physics simulation issue.

The proper way to handle this is to either:

• Detach the entity on one frame and attach it again on another

    entity.Scene = null;
    await Script.NextFrame();
    anotherEntity.AddChild(entity);
  

• Detach the entity, clone it, and attach the clone

    entity.Scene = null;
    var clone = entity.Clone();
    anotherEntity.AddChild(clone);
  

The same goes for doing it the other way (child -> scene) and probably (child -> child), which I didn't do.

This code snippet in the markdown docs is out of date: https://github.com/stride3d/stride-docs/blob/c26b60b968c322ebe91f3e0421b6ff02c2a96381/en/manual/scripts/create-a-model-from-code.md#option-2-create-new-materials-in-code

    // Create a material (eg with red diffuse color).
    var materialDescription = new MaterialDescriptor
    {
        Attributes =
	    {
	        DiffuseModel = new MaterialDiffuseLambertModelFeature(),
	        Diffuse = new MaterialDiffuseMapFeature(new ComputeColor { Key = MaterialKeys.DiffuseValue })
	    }
    };
    var material = Material.New(GraphicsDevice, materialDescription);
    material.Parameters[0].Set(MaterialKeys.DiffuseValue, Color.Red);
    model.Materials.Add(0, material);

The parameters property doesn't exists anymore.

DocFX has an option to generate PDF.

We need to investigate if we could select only e.g. Manual or/and Tutorial. Converting PDF might bloat the website and deployment process. In any case it would be good to know how big is this PDF, as we don't want to bloat the website if it is too big and rarely used.

Also, we need to look at long term maintenance of this feature.

(im working on this, this issue is a tracking issue)

The docs pages show an inheritence tree which places the currently viewed class in context.. with superclasses above, and derived classes below. This is a correctly displayed tree example:

For some reason, sometimes this tree gets broken, and derived classes are not displayed correctly. This is an incorrect display.

The link for the derived class ImageButton should be properly indented, and prefaced by the inheritance arrow, like derived classes are in the correct example above.

This file should be deployed as well, in the en root. It is used by the launcher, Getting Started section

• studio_getting_started_links.txt
• update docs wiki

After spending some time improving the API documentation templates, it's my opinion that the mustache template syntax, in the interest of being overly simple, causes anything more than trivial templates to be over-complicated, and the possible formats you can achieve to be overly limited. ( Details in my blog post )

Therefore, I recommend we look at eventually moving away from mustache template syntax, at least for the API reference.

DocFx supports the very capable Liquid template syntax, so that might be an easy option. (more info on liquid in DocFX)

Here are some other doc gen options.

• Doxygen - NDoc (related)
• Docu
• Lunet-io
• Sandcastle

It would be interesting to use a template system with intellisense in visual studio, though I don't know of a documentation generator built with one. RazorLight is an option. XSLT is also an option, but it tends to be pretty clunky.

We can see only left navigation TOC in the Japanese, but not the content,

Reason: There is some caching issue. When Japanese manual is processed it takes the cached English version, this happens also in local env.

I will do some further tests and push PR, which should take care of caching issue.

Godots view, give copyright from the license, just link to it
https://github.com/godotengine/godot/blob/master/LICENSE.txt

Terminology
Godot Stride
Scene Entity Tree
Inspector Property Grid
FileSystem Solution/Asset View
Scene view Scene Editor
Node Entity
Node Script SyncScript, AsyncScript, StartupScript
Export Serialize/DataMember
GlobalClass DataContract

Folders and files

Assets:
In Godot you can store assets everywhere.
in Stride Assets are in the Assets Folder

Stride and Godot use the Standard C# Solution Structure.
Key difference here is that Stride uses the multi Project architecture which leads to the following Projects

MyPackage.Game contains your source code.
MyPackage.Platform contains additional code for the platforms your project supports. Game Studio creates folders for each platform (eg MyPackage.Windows, MyPackage.Linux, etc). These folders are usually small, and only contain the entry point of the program.
And any other Subprojects. Stride will scan the Subprojects too like the main Project to get DataContract classes and features into the Editor/Game ( it doesnt matter if its in a subproject or not
Bin contains the compiled binaries and data. Stride creates the folder when you build the project, with a subdirectory for each platform.
obj contains cached files. Game Studio creates this folder when you build your project. To force a complete asset and code rebuild, delete this folder and build the project again.
Resources is a suggested location for files such as images and audio files used by your assets, do not confuse them with godot resources, these dont exist in Stride. Stride has in the Scene Folders ( these can be used in any way ) where you can put classes that would be normally Godot Resources

Open the project directory from Game Studio
You can open the project directory from Project > Show in explorer in Game Studio.

Open project directory from Game Studio

Game settings

Godot® saves global settings in the Project Settings https://docs.godotengine.org/cs/stable/classes/class_projectsettings.html
The location is not known to me

Stride saves global settings in a single asset, the Game Settings asset. You can configure:

The default scene
Rendering settings
Editor settings
Texture settings
Physics settings
Overrides
To use the Game Settings asset, in the Asset View, select GameSettings and view its properties in the Property Grid.

Set the default scene
You can have multiple scenes in your project. Stride loads the default scene at runtime.

To set the default scene:

In the GameSettings properties, next to Default Scene, click Hand icon (Select an asset).

The Select an asset window opens.

Select the default scene and click OK.

For more information about scenes, see Scenes.

Entities vs Nodes

Nodes have a "is a" Behaviour. A Node is what the Script attached to it defines, so there is only one script per Node.
Stride uses an Entity Component System which is a "has a" Behaviour.
Entities are carriers for components such as transform components, model components, audio components, and so on.
So you attach multiple Scripts to the Same entity.

Transform component
Each entity in Stride has a Transform component which sets its position, rotation, and scale in the world.

Even empty entities have a Transform component, because every entity in the scene must have a position.
To Access the transform Component on a Stride Script ( SyncScript , StartUpScript , AsynScript ) you can use this.Entity.Transform

In Stride, Transform components contain a LocalMatrix and a WorldMatrix that are updated in every Update frame. If you need to force an update sooner than that you can use TranformComponent.UpdateLocalMatrix(), Transform.UpdateWorldMatrix(), or Transform.UpdateLocalFromWorld() to do so, depending on how you need to update the matrix.
Godot Stride
Position Transform.Position
Rotation Transform.Rotation
Scale Transform.Scale

Directions

Direction Stride Godot
Forward (0, 0, 1) (0, 0, -1)
Backward (0, 0, -1) (0, 0, 1)
Right (1, 0, 0) (1, 0, 0)
Left (-1, 0, 0) (-1, 0, 0)
Up (0, 1, 0) (0, 1, 0)
Down (0, -1, 0) (0, -1, 0)

Assets

They are the same like in Godot.
Each Asset can be edited through double click in the Asset View.
Certain Assets open a dedicated Asset Editor
For certain types of asset, Game Studio also has dedicated editors:

Like these:
prefabs
scenes
sprite sheets
UI pages
UI libraries
scripts
To open the dedicated editor for these types of asset:

double-click the asset, or
right-click the asset and select Edit asset, or
select the asset and type Ctrl + Enter

The new Editor opens a new Tab like in Godot at the top

The Gamestudio will update references like Godot does, if you save a change it will update the references.

Resources

Stride doesn't have Resources like Godot has.
In Stride you can add Folders to your Scene and add there Entities with your Data.
Another approach would be to save your former Resources in a separate Prefab and load it into the scenes that need the Data.

Supported File Formats

Models, animations, skeletons | .dae, .3ds, obj, .blend, .x, .md2, .md3, .dxf, .fbx
Sprites, textures, skyboxes | .dds, .jpg, .jpeg, .png, .gif, .bmp, .tga, .psd, .tif, .tiff
Audio, Sounds | .wav, .mp3, .ogg, .aac, .aiff, .flac, .m4a, .wma, .mpc
Fonts | .ttf, .otf

Prefab Inheritance

The equivalent of Godots inherited Scene would be ArcheTypes.
Archetypes are master assets that control the properties of assets you derive from them. Derived assets are useful when you want to create a "remixed" version of an asset. This is similar to prefabs.

For example, imagine we have three sphere entities that share a material asset named Metal. Now imagine we want to change the color of only one sphere, but keep its other properties the same. We could duplicate the material asset, change its color, and then apply the new asset to only one sphere. But if we later want to change a different property across all the spheres, we have to modify both assets. This is time-consuming and leaves room for mistakes.

The better approach is to derive a new asset from the archetype. The derived asset inherits properties from the archetype and lets you override individual properties where you need them. For example, we can derive the sphere's material asset and override its color. Then, if we change the gloss of the archetype, the gloss of all three spheres changes.

Create derived asset

You can derive an asset from an archetype, then in turn derive another asset from that derived asset. This way you can create different layers of assets to keep your project organized:

Input

In Stride you have the Option to get the Input through Key Strokes like in Godot or through Virtual Buttons, which is similiar to Godots Key Mapping

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

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

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

Physics

In Stride you have 3 Types of Colliders
static colliders
rigidbodies
characters

In Godot you can use Signals to react on a collision.
In Stride you can add methods in the Start() Method to the Delegate that gets executed when triggered.
This Tutorial explains how you can handle collisions in Stride
https://www.youtube.com/watch?v=SIy3pfoXfoQ&ab_channel=Stride

GameStudio Editor

Stride has like Godot an Integrated Code Editor, but for C#.
This Code Editor is not an high Priority Target in being kept up to date, so it's advised to use dedicated IDEs like Visual Studio Code, Rider and Visual Studio Community

Script Types

In Stride there are 3 Types of Scripts.
Unlike in Godot where you inherit from a Class to be able to be that Node.
In Stride you would extend Entitys through Adding Scripts and searching for Entities.
Instead of Inheriting from CharacterBody3D in Godot, in Stride you would attach a CharacterComponent ( don't forget to attach a Collision Shape to it ) to an entity and in the Scripts you can search for these Components.
Which is Delegation over Inheritance principle overall.

1. StartupScript
   This Script has only the Start method which is equivalent to Godots _Ready
   A StartupScript doesn't do much besides that.

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

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

2. SyncScript
   A SyncScript has a Update() Method which is the equivalent to _Process(double delta)
   A Key difference is that you don't have Delta as Parameter.
   this.Game.UpdateTime.Elapses.TotalSeconds
   Any SyncScript has through its Game Property access to Delta

The Stride Community Toolkit has Extension Methods to obtain it easier.
This approach solves the Problem of having to write a float Cast each time when a _Process(double delta) Method is written as you can easier access it through Extension methods

    /// <summary>
    /// Gets the time elapsed since the last game update in seconds as a single-precision floating-point number.
    /// </summary>
    /// <param name="gameTime">The IGame interface providing access to game timing information.</param>
    /// <returns>The time elapsed since the last game update in seconds.</returns>
    public static float DeltaTime(this IGame gameTime)
    {
        return (float)gameTime.UpdateTime.Elapsed.TotalSeconds;
    }

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

3. AsyncScripts
   To run Code Asynchronous to the Engines Update you can use AsyncScripts which work with async/await

public class BasicMethods : AsyncScript
{
    // Declared public member fields and properties that will appear in the game studio
    public override async Task Execute()
    {
        while(Game.IsRunning)
        {
            // Do stuff every new frame
            await Script.NextFrame();
        }
    }

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

Add scripts to entities

In the Entity Tree (on the left by default), or in the scene, select the entity you want to add the script to.

Select an entity

In the Property Grid (on the right by default), click Add component and select the script you want to add.

For more information about adding scripts in Stride, see Use a script.

Instantiate Prefabs

In Stride you can Instantiate like this Entities

// Declared public member fields and properties displayed in the Game Studio Property Grid.
public Prefab CarPrefab;
public Vector3 SpawnPosition;
public Quaternion SpawnRotation;

public override void Start()
{
    // Initialization of the script.
    List<Entity> car = CarPrefab.Instantiate();
    SceneSystem.SceneInstance.RootScene.Entities.AddRange(car);
    car[0].Transform.Position = SpawnPosition;
    car[0].Transform.Rotation = SpawnRotation;
    car[0].Name = "MyNewEntity";
}

Serialization

In Godot you need to Inherit an Engines class to be visible in the Editor.
Also only known Types to the Godot Engine can be Exported.

Stride has the different approach to be closer to C#
The [Stride.Core.DataContract] Attribute enables your class for Serialization in the GameStudio.
Then per default public Members get serialized.
you can explicitly add [DataMember] ( equivalent to [Export] ) to a class member but it doesn't have to be.
to exclude a Member you can add [Stride.Core.DataMemberIgnore] so the Editor will ignore it.

In Godot you have to Export Godot Collections to be visible in the Editor.
Stride Supports ICollection classes and IDictionary ( NOTE: only primitives and enums work as key ) implementations
You can Serialize any class that is a [DataContract] into the Editor.

You can also Serialize Abstract classes or Interfaces.
The Stride Editor will search for types that would fit into these interfaces or abstract classes.

Log Output

In Godot you can GD.Print your message.
Log output
To see the output, in the Game Studio toolbar, under View, enable Output.

Enable output

Game Studio displays in the Output tab (at the bottom of Game Studio by default).
you can then Log in Your Code Messages like so
System.Diagnostics.Debug.WriteLine("hello");

This can be useful, for checking that repo was correctly cloned.

Since we migrated from Stackpath CDN to Azure CDN (generously provided by .NET Foundation), deployment doesn't purge the cache so it takes several hours to propagate changes.
After a quick investigation, it seems we currently don't have enough Azure permissions to generate a token to access Azure REST API. We'll either need to get proper permissions or find some alternative way to trigger this cache purge.

The Stride Docs staging is now running here https://stride-doc-staging.azurewebsites.net/latest/en/

Remaining tasks:

• fix the JP language, even thought we will disable JP
• lock specific docfx version in GitHub Action - to avoid surprises when the latest is used automatically
• add missing lfs to GitHub Actions
• check the search from the Stride website is going to work with new docs
• test staging docs website
• prepare release branch
• release
• test

Additional tasks:

• set up wiki for Stride Docs
• make fast track working

First of all, I might have put the cart before the horse with this one - sorry for that!

I am interested in the ECS powering Stride, but I was unable to find some good documentation about how it works.
Most helpful was actually a forum post from 2018, but that also only discussed part of it.

So after hopping on discord and having a nice chat with some folks, I ended up with the impression "documentation about it is not great at the moment, so anything I find until I get it to work, I can just write down and it will be an improvement".
So I did that, wrote two markdown documents about it.

Then I read the contribution guidelines and the whole process.

So, again, sorry for not following the process there - but hey! Maybe you still want it, because we don't have docs about it yet. I'm gonna create a PR and link it here immediately after finishing writing this.

Notes
A) What added to my impression is a currently existing page about the subject has some outdated code - EntityManager.Entities does not exist in 4.1.0.1898.

B) I added two pages. While one is just a technical description of what there is , the other one is a write-up about ECS in general, explaining the concept aimed at an audience that doesn't know i yet.

C) I also added a quick diagram to make the decision easier for inexperienced users. I just used diagrams.net, didn't know if there's another standard for these or something.

Just something that a user can copy and paste into their own .gitignore to get started using the standard recommended configuration. If they need to customise theirs further they can do so.
Perhaps also submit the example to gitignore.io (https://www.toptal.com/developers/gitignore) to have it there too.

I think it can be useful feature both for our current and new developers. There would be guides on how to create a simple games step by step with explanations. Something like that exist for example in Godot docs.

As I am preparing for the new docs update I discovered issue with the current 404.html page which has broken css and js paths.

The problem was caused by the recent docs update where we decoupled external domain which was hosting css and js files. The styling works across all docs pages, but it broke 404.html page which is located in each version and each language folder (8 files).

The problem is that 404.html needs ideally an absolute path for styling and js but we can't have absolute paths for the remaining pages because of the versioning and languages feature and the individual generated docs are not aware of any language and version. Language and version functionality is happening through the redirects. Also, each version might use different styling and layout.

Ideally, the common assets should be centralised to avoid any future problems.

Current Fix

The fix was applied directly to web.config in the web server by adding 2 rules:

For example it redirects a path https://doc.stride3d.net/4.1/en/ReleaseNotes/styles/docfx.css generated from the relative path styles/docfx.css to https://doc.stride3d.net/4.1/en/styles/docfx.css.

        <!-- Fix Deep Asset Paths for 'latest' -->
        <rule name="Fix Deep Asset Paths for latest" stopProcessing="true">
            <match url="^latest/(en|jp)/.+/(styles|css|scripts)/(.*)" />
            <conditions>
                <add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true" />
            </conditions>
            <action type="Rewrite" url="4.1/{R:1}/{R:2}/{R:3}" />
        </rule>

        <!-- Fix Deep Asset Paths for versions -->
        <rule name="Fix Deep Asset Paths for versions" stopProcessing="true">
            <match url="^(\d+\.\d+)/(en|jp)/.+/(styles|css|scripts)/(.*)" />
            <conditions>
                <add input="{REQUEST_FILENAME}" matchType="IsFile" negate="true" />
            </conditions>
            <action type="Rewrite" url="{R:1}/{R:2}/{R:3}/{R:4}" />
        </rule>

Another solution

I would suggest to centralise 404.html page to one page, which will be in the root folder, available for all languages and versions, and it would have own styling embedded.

There are several benefits for this:

1. Simplicity: You only have one 404 page to maintain and update.
2. Consistency: All users, regardless of the documentation version or language they are browsing, will see the same error page, leading to a consistent user experience.
3. Efficiency: Reduces the overhead of managing styles for error pages across multiple directories.
4. Flexibility: In the future, if you need to change the design or message of the 404 page, you only have to do it in one place.

Ideally, this solution should be implemented before the new docs release.

ToDo

• Create PR to update web.config https://github.com/stride3d/stride-docs/blob/master/build/web.config, we don't need to deploy this file as the file was updated manually on the server already
• Check with xen2 if the centralised 404.html could be implemented

Review and add android setup mentioned in this discussion stride3d/stride#1657 (reply in thread)

@tebjan suggested to add it here https://doc.stride3d.net/4.0/en/manual/platforms/index.html.

Include these below into the Troubleshooting section

Troubleshooting Common Issues

.NET SDK Version Error

Q: When trying to build my project, I receive the following error: "The current .NET SDK does not support targeting .NET 6.0. Either target .NET 5.0 or lower, or use a version of the .NET SDK that supports .NET 6.0."

A: Make sure you have the .NET 6.0 SDK installed. Also, ensure you are using an IDE that supports .NET 6.0, such as Visual Studio 2022.

Note: This question holds true if certain features seem to be misbehaving or commonly crashing. Always make sure the latest .NET 6 SDK version is installed with Stride 4.1

This page about prefabs display a broken markdown table:
https://doc.stride3d.net/latest/en/manual/game-studio/prefabs/use-prefabs.html

Can we separate this to separate pages for better readability and also discoverability?

https://doc.stride3d.net/latest/en/manual/stride-for-unity-developers/index.html

The Fast Track deployment process already optimizes by skipping certain steps, such as artifact creation. However, there are still some repetitive processes that could be skipped in the Super Fast Track deployment, especially if the Stride API hasn't changed. These are:

• Stride checkout - Takes around 47 seconds
• Build Stride API - Takes between 1 and 3 minutes

The Proposal

DocFX generates yml files based on the Stride build. In a Super Fast Track deployment, these yml files could be preserved and reused, further speeding up the deployment process. The main GitHub Actions workflow would overwrite these yml files with the most up-to-date ones as needed.

Manual Process Requirement
Preserving the yml files for this purpose would require a manual process:

1. The yml files would have to be built locally.
2. These locally built files would then have to be pushed to the repository.

Use Case

This approach would be particularly beneficial for scenarios where frequent documentation updates are expected, which are unrelated to changes in the Stride API. The primary goal is to deploy these updates as rapidly as possible.

I had a discussion on this subject with xen2

btw, just a random idea, but do you think it's good to keep stride and stride-docs repo separate?
just wondering since doc is built using code, and sometimes doc examples would be better to fit in main solution (to make sure they get refactored)

I think we should investigate benefits, if it is going to make our life easier in any way.

Check previous old content and update wiki accordingly:

• Anyone is welcome to contribute! Before you start, please take the time to read the guidelines.
  • https://github.com/stride3d/stride-docs/blob/c26b60b968c322ebe91f3e0421b6ff02c2a96381/GUIDELINES.md
  • Japanese: https://github.com/stride3d/stride-docs/blob/c26b60b968c322ebe91f3e0421b6ff02c2a96381/GUIDELINES.jp.md
• You can find basic information about editing the documentation in Getting Started dedicated page.
  • https://github.com/stride3d/stride-docs/blob/c26b60b968c322ebe91f3e0421b6ff02c2a96381/GETTINGSTARTED.md
• Don't forget to change $version in deploy.ps1 when branching before first deployment.
• Each Stride minor version (i.e. 4.0, 4.1, etc.) should have its own branch, named in the fashion master-<version>. The only exception is latest version, which should be master.

Until recently, the code for the editor was closed source. Now that a everything is under MIT, the editor API should be included in the documentation.

Mentioned by OmniOwl on Discord.

In your AsyncWebApi code example from the Intermediate C# template, you have a line that says "Press A to get Api data from..."
However your Input conditional is looking at the "G" key. Not A.

DebugText.Print($"Press A to get Api data from https://opencollective.com/stride3d", new Int2(drawX, drawY));

if (Input.IsKeyPressed(Stride.Input.Keys.G))
{
    await RetrieveStrideRepos();
    await Script.NextFrame();
}

https://hackmd.io/McqTXGtyQuSu1-QJz34xKw?both
-Eideren

Release Type: docs website

Version: latest

Platform(s): N/A

Describe the bug
the getting started --> install stride page is out of date. it says .net 4.7.2 is required: https://doc.stride3d.net/latest/en/manual/get-started/install-stride.html

To Reproduce
Steps to reproduce the behavior: visit https://doc.stride3d.net/latest/en/manual/get-started/install-stride.html

Expected behavior
mention that .net 5 is supported

Additional context
would be more attractive to new users to know that net5 is supported

The mention of Xenko may be confusing for new users and should be replaced with the current engine name.
I'm creating this issue for tracking 😃

• https://doc.stride3d.net/latest/en/manual/get-started/install-stride.html
• https://doc.stride3d.net/latest/en/manual/troubleshooting/stride-doesnt-run.html
• https://doc.stride3d.net/latest/en/manual/stride-launcher/index.html
• https://doc.stride3d.net/latest/en/manual/get-started/index.html
• https://doc.stride3d.net/latest/en/manual/get-started/visual-studio-extension.html
• https://doc.stride3d.net/latest/en/manual/get-started/launch-stride.html
• https://doc.stride3d.net/latest/en/manual/get-started/create-a-project.html

Vaclav: There is lots of Xenko. The easy solution is just to replace the images with the current ones. Please make them .webp.

For some reason, Voxel GI works fine in the editor at Level 10, but then when you try to build and run it, you get

[Game]: Error: Unexpected exception. System.ArgumentOutOfRangeException: Specified argument was out of the range of valid values. (Parameter 'Graphics Profile Level 11 or higher required for Voxelization.')

If this remains the same, then we need to update the documentation to state this requirement.

https://stride-docs-test.azurewebsites.net/latest/en/manual/scripts/public-properties-and-fields.html#adding-property-descriptions

Add this comment so one can understand what it means when generating Stride docs, that this xml tag is not for a docs but for the Stride Studio..

Motivation:

• Getting more content, which grows
• SEO purpose
• Automating content creation
• Once a time, stride-docs would build static content from those discussions
  • Link that Q&A back to GitHub Discussions

https://learn.microsoft.com/en-us/nuget/consume-packages/package-source-mapping

We have removed the dependencies as discussed here stride3d/stride-website#94 for the already published versions. We used this script https://github.com/VaclavElias/stride-docs-next/blob/main/OldDocsFix.ps1

The updates need to be added also to the current branch, so any updates or new version persist the changes made above.

The new modern docs version release date is unknown so we have to still maintain the old version.

Right top corner, icons are merging with some content in this page https://doc.stride3d.net/latest/en/

I'm creating this issue to track the work I'll do to extend https://doc.stride3d.net/latest/en/manual/physics/constraints.html after stride3d/stride#1114 is merged.

Currently quite a few assemblies are not included in the API documentation. Even one of the basics like Xenko.Core.Mathematics which is kind of important. Should probably include some if not all public APIs.

Pointed out in Discord by OmniOwl

It says "update loop". But the SyncScript type is derived from StartupScript and is where the Update function is introduced. So the StartupScript talking about update loops outside of the SyncScript that derives from it and introduces the Update method is a bit confusing I must say.
Because it implies that the StartupScript has an Update method I can't see or a loop that is part of its life-cycle by default that I cannot access or see.

reminder to self or anyone who has time:
minimal: copy info from here: stride3d/stride#741 (comment)
ideally: add more context and explantations

Content from Discord user Hokuin0

https://discord.com/channels/500285081265635328/1171204981433569321/1173618474891882667

We currently have multiple versions of the same media files due to supporting multiple versions and languages. These files are stored in various folders:

/4.1/en [316 MB]
/4.1/jp  [317 MB]
/4.0/en
/4.0/jp
and so on for 3.1, 3.0

While it's beneficial to have media files close to their related documentation, this setup unnecessarily bloats storage and increases deployment time, as these files need to be copied and moved throughout the deployment process.

Proposed Solutions

Ideally, we are looking for a solution that is simple to implement and easy to maintain in the long term.

1. Centralized Storage with Fixed References

In this solution, all files would be stored in a central location, potentially maintaining a similar folder structure as the current setup for easy identification. When new versions or languages are added, they would point to this initial location unless the image has been updated or a language-specific image was created. This approach would require updating all existing media file references to point to the new storage location.

Suggested by @IXLLEGACYIXL: Symlinks could facilitate the re-linking process, and robocopy could be used for efficient file copying.

2. Centralized Storage with Dynamic Loading via Version and Language Tags

In this alternative approach, media files could be tagged with their corresponding version and language. A script would then dynamically load the appropriate media file based on the documentation being viewed. This avoids duplication but might require a more complex loading mechanism.

This second option already suggest more complexity and gears: Image Upload and Tagging, Image Retrieval Based on Tags.

Any other solutions?

I wanna start translate docs on Russian. How I can do it?

Pointed out in Discord by OmniOwl

Okay. Another one here. Writing "Script Component" on the ScriptComponent class as the only thing is not helpful. Should probably explain, or at least point to a URL that shows what a script is in Stride and what is meant by a ScriptComponent.

Because even in the ECS setup, that you seem to at least somewhat follow, that naming convention becomes unclear.

As discussed on Discord server, it seems there's no real low level documentation about the core concepts of the Engine. It should be really useful to document them in order to contribute at the project, or at least as reference. For example concepts regarding the Build system and the Serialization of data in general. And the Big-Picture of Stride Engine (as mentionned @xen2 ).

Some questions in my mind :

• What is the difference between a ContentSerializer and a DataSerializer ?
• How is composed a chunk of serialized data ?
• How the IReference interface works together with the serialization system ?

I am of course reading comments on all classes but I think there are some missing notions which seem to be important for me.

As another user mentionned on Discord, a readme file per csproj should be already a great start.

Thank you.

Let's add some basic instructions about Release Notes, because they are used also in the Launcher.

Do mention ReleaseNotesViewModel.cs which contains the logic and the path.

Context

xen2:

the release note, right now, were duplicated between website and doc
you think it's OK as is, or do you have other ideas?

Vaso:

I would follow Microsoft approach, they create a blog post with some intro text, context, even it is a few sentences, and they might include all updates or they just pick up something. While the Release Notes can be just a summary, the structure like now, all PRs, but not necessarily details. Ideally, we should also create separate blog posts about big features on the top of all this. So it really depends on the man power we have. If there is no one to help. we can just copy Release Notes to the Blog post like in the past but if we do have more time

Remove unnecessary folders:

• Remove folder \en\manual\.vscode\
• Remove folder \jp\manua\.vscode\
• Correct in .gitignore from .vscode/** to **/.vscode/ - to match any level of subdirectories

There might be a conflict in certain situation, which is resolved by increasing the version

public const string PublicVersion = "4.1.0.3";

in StrideVersion class, 00-Config

When you are working with Stride engine source code.

The error is showing something with Stride.Core.Assets.CompilerApp.exe

Can we add this new page or as another section to GETTINGSTARTED.md? Please let me know and also write any suggestions and corrections in the comments.

Thank you.

Title: New Language Workflow

New Language Workflow

As the Contribution Workflow suggests, you should create an issue first, where you can mention your intention and where we can keep a track of conversation on this subject. You can also ping us in our Discord Documentation channel once the issue was created.

Assuming that your request was approved, as an example, let's add a Spanish language. We will use code es.

1. Clone the repo git lfs clone https://github.com/stride3d/stride-docs.git
   • Make sure LFS (Large File Storage) is used
2. Copy \en\manual folder to \es\manaul
3. Copy \en\index.md file to \es\index.md
4. Translate whatever you need in the \es folder
   • make sure you don't change file names
   • make sure that all folders and pages from the \es\manaul folder which are not translated are deleted, this is very important, because the default \en\manual pages will be copied automatically through the ps1 script. This way when we update the en version, it will also automatically update all \es\manual pages which are not translated. The ps1 script then overwrites all en pages with translated es pages
5. Update \build.bat - add && Call ./es-build.bat
6. Update \build_manual_only.bat - add & Call ./es-build.bat
7. Update \web.config - add |es
8. Update \build\web.config - add |es
9. Update \en\template\styles\main.js - add |es
10. Update \en\template\partials\navbar.tmpl.partial - add data-language es
11. Duplicate \jp-build.ps1 to \es-build.ps1
    • Update content jp to es
    • Update 'doc-no-translated' with 'doc-no-translated doc-no-translated-es'
      • Note: We keep also the original doc-no-translated because it is used in the docs generator logic
12. Update \en\template\styles\main.css
    • Duplicate class .doc-no-translated::after, and place the new one below, rename it to .doc-no-translated-es::after
    • Translate the text to es
13. Duplicate \jp-build.bat to \es-build.bat
    • Update content jp to es
14. Duplicate \run_local_website_jp.bat to \run_local_website_es.bat
    • Update content jp to es
15. Test the build with build.bat if you have got also Stride repository, or just build_manual_only.bat, or es-build.bat
16. Run run_local_website.bat. It opens the local version of the doc in your browser

Current Language Contributors

Please notify this contributors if any changes need to be made

• EN language: Anyone in our Discord channel
• RU language: @~FallenParadise~ at Discord channel
• JP language:

Troubleshooting

1. Program 'docfx.exe' failed to run: The specified executable is not a valid application for this OS platform
   • Check the file size. If the repository was cloned without LFS, the files might be just a reference. Clone again with LFS.

(this is a tracking issue for myself... im working on it right now)

Why?

Right now the class pages are very hard to use, because they don't show any of the inherited members. It is pretty standard for API pages to show (most) inherited members, so understanding a class API does not require clicking and paging and control-F searching through 5+ different superclass pages.
For example, the Button docs page...

https://doc.xenko.com/latest/en/api/Stride.UI.Controls.Button.html

Does not have the Click event, because it's inherited from ButtonBase. Which makes it a bit of a confusing mess to figure out how to do the simple task of handling a click. For comparison, see Unity UI.Button, or Microsoft S.W.F.Button

Right now the EventKey page only discusses the non-generic version. If you need to pass data you need to use the Generic Version. I would like to add that information for others looking for how to pass data between scripts.

https://doc.xenko.com/latest/en/manual/scripts/events.html