Merge pull request #1 from stride3d/master

Merging recent updates

BuildDocs.ps1

@@ -83,22 +83,26 @@ function Ask-IncludeAPI {
     Write-Host ""
     Write-Host -ForegroundColor Cyan "Do you want to include API?"
     Write-Host ""
-    Write-Host -ForegroundColor Yellow "  [Y] Yes"
+    Write-Host -ForegroundColor Yellow "  [Y] Yes or ENTER"
     Write-Host -ForegroundColor Yellow "  [N] No"
     Write-Host ""
 
-    return (Read-Host -Prompt "Your choice (Y/N)").ToLower() -eq "y"
+    $answer = Read-Host -Prompt "Your choice [Y, N, or ENTER (default is Y)]"
+
+    return ($answer -ieq "y" -or $answer -eq "")
 }
 
 function Ask-UseExistingAPI {
     Write-Host ""
     Write-Host -ForegroundColor Cyan "Do you want to use already generated API metadata?"
     Write-Host ""
-    Write-Host -ForegroundColor Yellow "  [Y] Yes"
+    Write-Host -ForegroundColor Yellow "  [Y] Yes or ENTER"
     Write-Host -ForegroundColor Yellow "  [N] No"
     Write-Host ""
 
-    return (Read-Host -Prompt "Your choice (Y/N)").ToLower() -eq "y"
+    $answer = Read-Host -Prompt "Your choice [Y, N, or ENTER (default is Y)]"
+
+    return ($answer -ieq "y" -or $answer -eq "")
 }
 
 function Copy-ExtraItems {
@@ -446,8 +450,15 @@ else {
     {
         $API = Ask-IncludeAPI
 
-        if ($API) {
-            $ReuseAPI = Ask-UseExistingAPI
+        if ($API)
+        {
+            # Check for .yml files
+            $ymlFiles = Get-ChildItem -Path "en/api/" -Filter "*.yml"
+
+            if ($ymlFiles.Count -gt 0)
+            {
+                $ReuseAPI = Ask-UseExistingAPI
+            }
         }
 
     } elseif ($isCanceled) {

en/diagnostics/STRDIAG000.md

@@ -0,0 +1,56 @@
+# Diagnostics Warning STRDIAG000
+
+> There is an Attribute Contradiction on '{0}' Member. `[DataMemberIgnore]` Attribute on a `[DataMember]` is not supported.
+> Except if it has also `[DataMemberUpdatable]` Attribute.
+
+## Explanation
+
+Adding @Stride.Core.DataMemberAttribute and @Stride.Core.DataMemberIgnoreAttribute to the same member is not supported. This would be a contradiction.
+It would mean the serializer should serialize the member and ignore it at the same time. The @Stride.Updater.DataMemberUpdatableAttribute  makes the combination valid again as it negates the @Stride.Core.DataMemberIgnoreAttribute for the binary serializer.
+
+## Example: Invalid cases
+
+The following example generates STRDIAG000 on each property:
+
+```csharp
+// STRDIAG000.cs
+using Stride.Core;
+
+public class STRDIAG000
+{
+    [DataMember]
+    [DataMemberIgnore]
+    public int Value { get; set; }
+
+    [DataMember]
+    [DataMemberIgnore]
+    public int Value;
+}
+```
+
+## Example: Special Case `DataMemberUpdatable`
+
+> [!IMPORTANT]
+> There is a special case if the @Stride.Updater.DataMemberUpdatableAttribute is applied.
+> This Attribute negates the @Stride.Core.DataMemberIgnoreAttribute for the binary Serializer, so it becomes valid again.
+
+```csharp
+using Stride.Core;
+
+public class STRDIAG000
+{
+    [DataMember]
+    [DataMemberIgnore]
+    [DataMemberUpdatable]
+    public int Value { get; set; }
+}
+```
+
+## Solution
+
+> To resolve the warning, pick either the @Stride.Core.DataMemberAttribute or the @Stride.Core.DataMemberIgnoreAttribute.
+If the `YamlSerializer` and the Editor should ignore the member but the binary serializer not, then add the @Stride.Core.DataMemberIgnoreAttribute.
+
+## References
+
+- [Serialisation](../manual/scripts/serialization.md)

en/diagnostics/STRDIAG001.md

@@ -0,0 +1,40 @@
+# Diagnostics Warning STRDIAG001
+
+> The `[DataContract]` is not valid for the type '{0}'. Expected is a public/internal Accessor.
+
+## Explanation
+
+The @Stride.Core.DataContractAttribute can only be applied to `public`/`internal` type. Any lower access will cause STRDIAG001 on the target type.
+
+## Example: private inner class
+
+The following example generates STRDIAG001:
+
+```csharp
+using Stride.Core;
+
+public class STRDIAG001
+{
+    [DataContract]
+    private class InnerClass { }
+}
+```
+
+## Example: file scoped class
+
+```csharp
+using Stride.Core;
+
+[DataContract]
+file class STRDIAG001
+{
+}
+```
+
+## Solution
+
+To resolve the warning, increase the accessibility of the type to `public`/`internal` or remove the @Stride.Core.DataContractAttribute.
+
+## References
+
+- [Serialisation](../manual/scripts/serialization.md)

en/diagnostics/STRDIAG002.md

@@ -0,0 +1,30 @@
+# Diagnostics Warning STRDIAG002
+
+> The 'DataMemberMode.Content' is not valid for the member '{0}'.
+> Only mutable reference types are supported for 'DataMemberMode.Content' Mode members.
+
+## Explanation
+
+The [DataMemberMode.Content](xref:Stride.Core.DataMemberMode) mutates the object which is currently in the member.
+As this is not possible with the current serializers, only mutable types are supported for `DataMemberMode.Content`. Immutable types in this context are none reference types and string.
+
+## Example
+
+The following example generates STRDIAG002 on each property:
+
+```csharp
+using Stride.Core;
+
+public class STRDIAG002
+{
+    [DataMember(DataMemberMode.Content)]
+    public int Value { get; set; }
+
+    [DataMember(DataMemberMode.Content)]
+    public string Value;
+}
+```
+
+## Solution
+
+To resolve the warning, pick either a reference type for the member or use `DataMemberMode.Assign` for Immutable types.

en/diagnostics/STRDIAG003.md

@@ -0,0 +1,32 @@
+# Diagnostics Warning STRDIAG003
+
+> The member '{0}' with `[DataMember]` is not accessible to the serializer. Only public/internal/internal > protected visibility is supported, when the `[DataMember]` attribute is applied.
+
+## Explanation
+
+The serialization concept in Stride expects `public`/`internal`/`internal protected` visibility of properties. Other accessibility won't be considered for serialization.
+To count `internal`/`internal protected` as visible to the Editor the @Stride.Core.DataMemberAttribute has to be applied, else it's considered as not visible.
+
+## Example
+
+The following example generates STRDIAG003 on each property:
+
+```csharp
+using Stride.Core;
+
+public class STRDIAG003
+{
+    [DataMember]
+    private int Value { get; set; }
+
+    [DataMember]
+    protected string Value;
+    
+    [DataMember]
+    private protected string Value;
+}
+```
+
+## Solution
+
+To resolve the warning, increase the Accessibility to `public`/`internal`/`internal protected` of the member or remove the @Stride.Core.DataMemberAttribute Attribute.

en/diagnostics/STRDIAG004.md

@@ -0,0 +1,66 @@
+# Diagnostics Warning STRDIAG004
+
+> 1. The property '{0}' with `[DataMember]` does not have a getter which is required for serialization.
+> 2. The property '{0}' with `[DataMember]` does not have an accessible getter which is required for serialization. A public/internal/internal protected getter is expected.
+
+## Explanation
+
+All serializers need a getter on a property to be able to get the content of the property.
+This is required for all serializers in Stride.
+- Non existent getters will result in error message 1.
+- Non visible getters will result in error message 2.
+
+## Example
+
+The following example generates STRDIAG004 on each property:
+
+```csharp
+using Stride.Core;
+
+public class STRDIAG004
+{
+    // throws Diagnostics message 1
+    [DataMember]
+    public int Value { set;}
+
+    // throws Diagnostics message 2
+    [DataMember]
+    public string Value { private get; set; }
+
+    // throws Diagnostics message 2 
+    [DataMember]
+    public string Value { protected get; set; }
+}
+```
+
+> [!WARNING]
+> There is an edge case with `internal`/`internal protected`, it will count as non visible when the @Stride.Core.DataMemberAttribute isn't applied.
+> But when the attribute is applied then the getter counts as visible and therefore is correct.
+
+```csharp
+// STRDIAG000.cs
+using Stride.Core;
+
+public class STRDIAG004
+{
+    // will throw STRDIAG004
+    public int Value { internal get; set; }
+
+    // will throw STRDIAG004
+    public int Value { internal protected get; set; }
+
+    // won't throw STRDIAG004
+    [DataMember]
+    public string Value { internal get; set; }
+    
+    // won't throw STRDIAG004
+    [DataMember]
+    public string Value { internal protected get; set; }
+}
+```
+
+## Solution
+
+To resolve the warning 1, add a getter to the property with a `public`/`internal`/`internal protected` accessibility or remove the @Stride.Core.DataMemberAttribute .
+
+To resolve the warning 2, increase the accessibility of the property getter to `public`/`internal`/`internal protected` accessibility or remove the @Stride.Core.DataMemberAttribute .

en/diagnostics/STRDIAG005.md

@@ -0,0 +1,31 @@
+# Diagnostics Warning STRDIAG005
+
+> The `[DataMember]` Attribute is applied to a read-only member '{0}' with a non supported type. Only mutable reference types are supported for read-only members.
+
+## Explanation
+
+Having no set possibility automatically lets the serializers automatically use the [DataMemberMode.Content](xref:Stride.Core.DataMemberMode).
+For immutable types the `DataMemberMode.Content` is never valid.
+Immutable types in this context are none reference types and string.
+
+## Example
+
+The following example generates STRDIAG005 on each property:
+
+```csharp
+using Stride.Core;
+
+public class STRDIAG005
+{
+    [DataMember]
+    public readonly int Value;
+    [DataMember]
+    public string Value { get; }
+}
+```
+
+## Solution
+
+To resolve the warning for fields, remove the `[DataMember]` attribute or remove the `readonly` modifier.
+
+To resolve the warning for properties, alter the type of the property to a supported type or remove the `[DataMember]` attribute.

en/diagnostics/STRDIAG006.md

@@ -0,0 +1,59 @@
+# Diagnostics Warning STRDIAG006
+
+> Invalid DataMemberMode for the specified `[DataMember]` member '{0}'. A public/internal/internal protected setter is required for 'DataMemberMode.Assign'.
+
+## Explanation
+
+The @Stride.Core.DataMemberMode.Assign let's the serializers create new objects and sets them into the target property. The Property needs an accessible/visible setter.
+
+## Example: Invalid Cases
+
+The following example generates STRDIAG006:
+
+```csharp
+using Stride.Core;
+
+public class STRDIAG006
+{
+    // non existent setters count as non visible
+    [DataMember(DataMemberMode.Assign)]
+    public int Property1 { get; }
+
+    [DataMember(DataMemberMode.Assign)]
+    public int Property2 { get; private set; }
+    
+    [DataMember(DataMemberMode.Assign)]
+    public int Property3 { get; protected set; }
+    
+    [DataMember(DataMemberMode.Assign)]
+    public int Property4 { get; private protected set; }
+}
+```
+
+## Example: Special Case `internal`
+
+> [!IMPORTANT]
+> To explicitly set the `DataMemberMode.Assign` the @Stride.Core.DataMemberAttribute has to be applied.
+> Internal visibility counts then as visible for the serializers and becomes valid.
+
+```csharp
+using Stride.Core;
+
+public class STRDIAG006
+{
+    // non existent setters count as non visible
+    [DataMember(DataMemberMode.Assign)]
+    public int Property1 { get; internal set; }
+
+    [DataMember(DataMemberMode.Assign)]
+    public int Property2 { get; internal protected set; }
+}
+```
+
+## Solution
+
+To resolve the warning, increase the accessibility of the properties set to `public`/`internal`. Or remove the explicit `DataMemberMode.Assign`, this can result in the `DataMemberMode.Content`, if the property is a non valuetype/string type.
+
+## References
+
+- [Serialisation](../manual/scripts/serialization.md)

en/diagnostics/STRDIAG007.md

@@ -0,0 +1,32 @@
+# Diagnostics Warning STRDIAG007
+
+> Invalid `[DataMember]` Attribute on the member '{0}'. A Delegate is not serializable.
+
+## Explanation
+
+Delegates can't be serialized by the serializers in Stride. Therefore, the @Stride.Core.DataMemberAttribute is always invalid when applied to a delegate member in a type.
+
+## Example: Invalid Cases
+
+The following example generates STRDIAG007:
+
+```csharp
+using Stride.Core;
+
+public class STRDIAG007
+{
+    [DataMember]
+    public Action SomeDelegate;
+
+    [DataMember]
+    public Action SomeDelegate2 { get; set; }
+}
+```
+
+## Solution
+
+To resolve the warning, remove the @Stride.Core.DataMemberAttribute.
+
+## References
+
+- [Serialisation](../manual/scripts/serialization.md)

en/diagnostics/STRDIAG008.md

@@ -0,0 +1,29 @@
+# Diagnostics Warning STRDIAG008
+
+> Struct members with the 'fixed' Modifier are not supported as a Serialization target on member '{0}'.
+
+## Explanation
+
+The Stride serializers can't handle `fixed` members in structs. The @Stride.Core.DataMemberAttribute is always invalid on such a member.
+
+## Example: Invalid Cases
+
+The following example generates STRDIAG008:
+
+```csharp
+using Stride.Core;
+
+public unsafe struct STRDIAG008
+{
+    [DataMember]
+    public fixed byte Value[10];
+}
+```
+
+## Solution
+
+To resolve the warning, remove the @Stride.Core.DataMemberAttribute.
+
+## References
+
+- [Serialisation](../manual/scripts/serialization.md)

en/diagnostics/STRDIAG009.md

@@ -0,0 +1,35 @@
+# Diagnostics Warning STRDIAG009
+
+> The member '{0}' implements IDictionary<T,K> with an unsupported type for the key. Only primitive types ( like int,float,.. ) are supported or string or enums as the Dictionary Key in asset serialization. When used in other contexts the warning may not apply and can be suppressed.
+
+## Explanation
+
+By default, Stride serializers only support primitive types and `string` as keys in an `IDictionary`. However, it is possible to extend this support, making the warning not entirely accurate in all cases.
+
+## Example
+
+The following example generates STRDIAG009:
+
+```csharp
+using Stride.Core;
+
+public class STRDIAG009
+{
+    [DataMember]
+    public Dictionary<ClassType, AnyType>
+
+    [DataMember]
+    public Dictionary<StructType, AnyType>
+
+    [DataMember]
+    public Dictionary<InterfaceType, AnyType>
+}
+```
+
+## Solution
+
+To resolve the warning, remove the @Stride.Core.DataMemberAttribute. Or change the key of the `IDictionary` to a supported type. Add a pragma Suppression in the IDE if it is a valid type.
+
+## References
+
+- [Serialisation](../manual/scripts/serialization.md)

en/diagnostics/index.md

@@ -1,6 +1,30 @@
 # Stride diagnostics
 
-Some C# compiler errors have corresponding topics that explain why the error is generated, and, in some cases, how to fix the error. Use one of the following steps to see whether help is available for a particular error message.
+Stride.Core.CompilerServices contains Roslyn code analyzers.
+
+> [!IMPORTANT]
+> Analyzers are offline tools used by the compiler to assist programmers. They are not used to collect telemetry on how Stride is being used. These same analyzers are also utilized by your IDE to generate CSXXXX diagnostics.
+
+They analyze the code for possible issues in your project with the Stride.Core design.
+To avoid unexpected runtime/compile time/editor time behaviour these analyzers try to warn as soon as possible for issues that may occur.
+Each of the following pages contain information about diagnostic codes that can be reported by the Roslyn analyzers, which are built into Stride.Core.CompilerServices.
+
+The information covers:
+
+- When is the diagnostics reported
+- An explanation why it is necessary to report the diagnostic
+- Examples when such a diagnostics occurs
+- Information about how to resolve the diagnostic
+
+If an error is reported it is possible to click in the IDE on the `diagnostic code` in the information box about the diagnostic.
+This will open the corresponding information page about the diagnostic.
+
+The Stride.Core.CompilerServices is linked to Stride.Core, the diagnostic Analysis will only occur if your project references Stride.Core in the PackageReferences, this will automatically add the Stride.Core.CompilerServices to your project.
 
 > [!WARNING]
-> Note that diagnostic feature is experimental and may not work as expected.
+> Note that diagnostic feature is experimental and may not work as expected. Warnings may contain solutions that don't work yet.
+
+## References
+
+- [Rule of Thumb Serialization](../manual/scripts/serialization.md#rule-of-thumb)
+- [Serialisation](../manual/scripts/serialization.md)

en/diagnostics/strd001.md

@@ -1,54 +0,0 @@
-# Diagnostics Warning STRD001
-
-An Array must have a public/internal getter for Serialization.
-
-## Example
-
-The following example generates STRD001:
-
-```csharp
-// STRD001.cs
-// compile with: /W:2
-public class Program
-{
-    public static void Main()
-    {
-        goto lab1;
-        {
-            // The following statements cannot be reached:
-            int i = 9;   // STRD001
-            i++;
-        }
-    lab1:
-        {
-        }
-    }
-}
-
-```
-
-Another common example where this error is generated is as follows:
-
-```csharp
-public static class Class1
-{
-    public static string Method1()
-    {
-        string x = "a";
-        switch (x)
-        {
-            case "a":
-                return "a";
-                break;          // CS0162
-        }
-        return "";
-    }
-}
-```
-
-The `break` statement cannot be reached because it occurs after the `return` statement. The `return` statement ends the enclosing `case` branch.
-
-## See also
-
-- [C# Compiler Options](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-options/)
-- [C# Compiler Errors](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-messages/)

en/diagnostics/strd002.md

@@ -1,54 +0,0 @@
-# Diagnostics Warning STRD002
-
-A collection must have a public/internal getter for Serialization.
-
-## Example
-
-The following example generates STRD001:
-
-```csharp
-// STRD001.cs
-// compile with: /W:2
-public class Program
-{
-    public static void Main()
-    {
-        goto lab1;
-        {
-            // The following statements cannot be reached:
-            int i = 9;   // STRD001
-            i++;
-        }
-    lab1:
-        {
-        }
-    }
-}
-
-```
-
-Another common example where this error is generated is as follows:
-
-```csharp
-public static class Class1
-{
-    public static string Method1()
-    {
-        string x = "a";
-        switch (x)
-        {
-            case "a":
-                return "a";
-                break;          // CS0162
-        }
-        return "";
-    }
-}
-```
-
-The `break` statement cannot be reached because it occurs after the `return` statement. The `return` statement ends the enclosing `case` branch.
-
-## See also
-
-- [C# Compiler Options](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-options/)
-- [C# Compiler Errors](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-messages/)

en/diagnostics/strd003.md

@@ -1,56 +0,0 @@
-# Diagnostics Warning STRD003
-
-- A property must have a public/internal getter.
-- A property must be set during instantiation, then no public setter would be valid.
-- Or it must have a public setter else.
-
-## Example
-
-The following example generates STRD001:
-
-```csharp
-// STRD001.cs
-// compile with: /W:2
-public class Program
-{
-    public static void Main()
-    {
-        goto lab1;
-        {
-            // The following statements cannot be reached:
-            int i = 9;   // STRD001
-            i++;
-        }
-    lab1:
-        {
-        }
-    }
-}
-
-```
-
-Another common example where this error is generated is as follows:
-
-```csharp
-public static class Class1
-{
-    public static string Method1()
-    {
-        string x = "a";
-        switch (x)
-        {
-            case "a":
-                return "a";
-                break;          // CS0162
-        }
-        return "";
-    }
-}
-```
-
-The `break` statement cannot be reached because it occurs after the `return` statement. The `return` statement ends the enclosing `case` branch.
-
-## See also
-
-- [C# Compiler Options](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-options/)
-- [C# Compiler Errors](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-messages/)

en/diagnostics/strd004.md

@@ -1,54 +0,0 @@
-# Diagnostics Warning STRD004
-
-For <see cref="System.Collections.Generic.Dictionary{TKey, TValue}"/> the only valid Keys are primitive Types. All complex types like custom structs, objects are not allowed.
-
-## Example
-
-The following example generates STRD001:
-
-```csharp
-// STRD001.cs
-// compile with: /W:2
-public class Program
-{
-    public static void Main()
-    {
-        goto lab1;
-        {
-            // The following statements cannot be reached:
-            int i = 9;   // STRD001
-            i++;
-        }
-    lab1:
-        {
-        }
-    }
-}
-
-```
-
-Another common example where this error is generated is as follows:
-
-```csharp
-public static class Class1
-{
-    public static string Method1()
-    {
-        string x = "a";
-        switch (x)
-        {
-            case "a":
-                return "a";
-                break;          // CS0162
-        }
-        return "";
-    }
-}
-```
-
-The `break` statement cannot be reached because it occurs after the `return` statement. The `return` statement ends the enclosing `case` branch.
-
-## See also
-
-- [C# Compiler Options](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-options/)
-- [C# Compiler Errors](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-messages/)

en/diagnostics/strd007.md

@@ -1,54 +0,0 @@
-# Diagnostics Warning STRD007
-
-It's invalid to DataMember a private property. Also its invalid to DataMember a property which has DataMemberIgnore.
-
-## Example
-
-The following example generates STRD001:
-
-```csharp
-// STRD001.cs
-// compile with: /W:2
-public class Program
-{
-    public static void Main()
-    {
-        goto lab1;
-        {
-            // The following statements cannot be reached:
-            int i = 9;   // STRD001
-            i++;
-        }
-    lab1:
-        {
-        }
-    }
-}
-
-```
-
-Another common example where this error is generated is as follows:
-
-```csharp
-public static class Class1
-{
-    public static string Method1()
-    {
-        string x = "a";
-        switch (x)
-        {
-            case "a":
-                return "a";
-                break;          // CS0162
-        }
-        return "";
-    }
-}
-```
-
-The `break` statement cannot be reached because it occurs after the `return` statement. The `return` statement ends the enclosing `case` branch.
-
-## See also
-
-- [C# Compiler Options](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-options/)
-- [C# Compiler Errors](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/compiler-messages/)

en/diagnostics/toc.md

@@ -1,7 +1,12 @@
 # [Diagnostics](index.md)
 
-# [STRD001](strd001.md)
-# [STRD002](strd002.md)
-# [STRD003](strd003.md)
-# [STRD004](strd004.md)
-# [STRD007](strd007.md)
+# [STRDIAG000](STRDIAG000.md)
+# [STRDIAG001](STRDIAG001.md)
+# [STRDIAG002](STRDIAG002.md)
+# [STRDIAG003](STRDIAG003.md)
+# [STRDIAG004](STRDIAG004.md)
+# [STRDIAG005](STRDIAG005.md)
+# [STRDIAG006](STRDIAG006.md)
+# [STRDIAG007](STRDIAG007.md)
+# [STRDIAG008](STRDIAG008.md)
+# [STRDIAG009](STRDIAG009.md)

en/manual/engine/entity-component-model/usage.md

@@ -10,16 +10,7 @@ The three parts of **Entity Component System** map to the following classes:
 
 ## Minimal Setup
 
-A component can be defined by deriving a class from `EntityComponent`.
-
-By adding the attribute `DefaultEntityComponentProcessor` to an `EntityComponent`,  
-an `EntityProcessor` can be assigned to it. This will automatically set up and run  
-the `EntityProcessor` if the `EntityComponent` is in the scene.
-
-An `EntityComponent` also needs to indicate that it can be serialized  
-by adding the attribute `DataContract` to it.
-
-A system can be defined by deriving a class from `EntityProcessor`. 
+A component can be defined by deriving a class from `EntityComponent`. By adding the attribute `DefaultEntityComponentProcessor` to an `EntityComponent`, an `EntityProcessor` can be assigned to it. This will automatically set up and run the `EntityProcessor` if the `EntityComponent` is in the scene. An `EntityComponent` also needs to indicate that it can be serialized by adding the attribute `DataContract` to it. A system can be defined by deriving a class from `EntityProcessor`.
 
 
 ### Code
@@ -49,11 +40,8 @@ public class MyProcessor : EntityProcessor<MyComponent>
 ```
 
 ### Additional Note
-An `EntityComponent` can currently not be drag-dropped onto an entity in Game Studio.  
-It has to be added by selecting an entity, and then clicking the "Add component" button  
-in the property grid.
-
-Alternatively, this can also be done in [code via `entity.Add(entityComponent)`](https://doc.stride3d.net/latest/en/api/Stride.Engine.Entity.html#Stride_Engine_Entity_Add_Stride_Engine_EntityComponent_).
+An `EntityComponent` can currently not be drag-dropped onto an entity in Game Studio. It has to be added by selecting an entity, and then clicking the **Add component** button  
+in the **Property grid**. Alternatively, this can also be done in [code via `entity.Add(entityComponent)`](https://doc.stride3d.net/latest/en/api/Stride.Engine.Entity.html#Stride_Engine_Entity_Add_Stride_Engine_EntityComponent_).
 
 
 ## Advanced Features
@@ -67,27 +55,20 @@ By adding the `Display` attribute, a nicer name can be shown in Game Studio.
 ```
 
 #### ComponentCategory
-By default, your components will be listed in the category "Miscellaneous".  
-By adding the `ComponentCategory` attribute, a different category can be chosen.  
-If the chosen name does not exist yet, it will be added to the list in Game Studio.  
+By default, your components will be listed in the category "Miscellaneous". By adding the `ComponentCategory` attribute, a different category can be chosen. If the chosen name does not exist yet, it will be added to the list in Game Studio.
 ```csharp
 [ComponentCategory("My own components")]
 ```
 
 #### ComponentOrder
-By adding the `ComponentOrder` attribute, the order in which  
-components are listed in Game Studio can be changed.  
+By adding the `ComponentOrder` attribute, the order in which components are listed in Game Studio can be changed.
 ```csharp
 [ComponentOrder(2001)]
 ```
 
 
 ### Component Combinations
-By passing the types of other components to the `EntityProcessor` constructor,  
-it will only include entities _that also have those other components_.
-
-For example, the following `EntityProcessor` is for `MyComponent`, but will skip any entity  
-that does not also have both `TransformComponent` and `AnimationComponent` on it.
+By passing the types of other components to the `EntityProcessor` constructor, it will only include entities _that also have those other components_. For example, the following `EntityProcessor` is for `MyComponent`, but will skip any entity that does not also have both `TransformComponent` and `AnimationComponent` on it.
 
 ```csharp
 public class MyProcessor : EntityProcessor<MyComponent>
@@ -100,9 +81,7 @@ public class MyProcessor : EntityProcessor<MyComponent>
 
 
 ### Non-default Processors
-Adding processors for a type of component via the attribute `DefaultEntityComponentProcessor`  
-has been explained above. However, as the name implies, this is for the _default_ processor.  
-Non-default processors can also be added via
+Adding processors for a type of component via the attribute `DefaultEntityComponentProcessor` has been explained above. However, as the name implies, this is for the _default_ processor. Non-default processors can also be added via
 ```csharp
 SceneSystem.SceneInstance.Processors.Add(entityProcessor);
 ```
@@ -110,16 +89,7 @@ SceneSystem.SceneInstance.Processors.Add(entityProcessor);
 
 ### Separation of EntityComponent and Data
 
-`EntityProcessor<TComponent>` is a shortcut for `EntityProcessor<TComponent, TComponent>`.
-
-By explicitly using `EntityProcessor<TComponent, TData>` instead, a different type can be chosen  
-for the actual data. This way, the `EntityComponent` can e.g. have "heavier" startup data and  
-references, while the data object that needs to be processed every frame can be kept small.
-
-This will require overriding a method `GenerateComponentData`, which produces a `TData` instance  
-from a `TComponent` instance.
+`EntityProcessor<TComponent>` is a shortcut for `EntityProcessor<TComponent, TComponent>`. By explicitly using `EntityProcessor<TComponent, TData>` instead, a different type can be chosen for the actual data. This way, the `EntityComponent` can e.g. have "heavier" startup data and references, while the data object that needs to be processed every frame can be kept small. This will require overriding a method `GenerateComponentData`, which produces a `TData` instance from a `TComponent` instance.
 
 ### Overrides
-`EntityProcessor` also provides several methods which can be overridden in order to react to certain events.  
-They are not overly complicated, so that their usage should be clear from their doc comments. 
-
+`EntityProcessor` also provides several methods which can be overridden in order to react to certain events. They are not overly complicated, so that their usage should be clear from their doc comments.

en/manual/game-studio/manage-entities.md

@@ -101,4 +101,3 @@ You can change the snap values for each gizmo in the scene view toolbar. Snap va
 * [Navigate in the Scene Editor](navigate-in-the-scene-editor.md)
 * [Load scenes](load-scenes.md)
 * [Add entities](add-entities.md)
-* [Manage entities](manage-entities.md)

en/manual/index.md

@@ -10,9 +10,9 @@ These pages contain information about how to use Stride, an open-source C# game
 ## Latest documentation
 
 ### Recent updates
-
-- <span class="badge text-bg-success">New</span> [Serialization](scripts/serialization.md) - Serialization explained
-- <span class="badge text-bg-info">Updated</span> [Public properties and fields](scripts/public-properties-and-fields.md) - Content improvements and additions
+- <span class="badge text-bg-info">Updated</span> [Linux - Setup and requirements](platforms/linux/setup-and-requirements.md) - Fedora OS option added
+- <span class="badge text-bg-success">New</span> [Scripts - Serialization](scripts/serialization.md) - Serialization explained
+- <span class="badge text-bg-info">Updated</span> [Scripts - Public properties and fields](scripts/public-properties-and-fields.md) - Content improvements and additions
 - <span class="badge text-bg-info">Updated</span> [Stride for Unity® developers](stride-for-unity-developers/index.md) - Content improvements
 
 ### Previous updates

en/manual/platforms/linux/setup-and-requirements.md

@@ -11,40 +11,67 @@ You will also need a Windows PC to build your projects for Linux using Game Stud
 You need the following packages:
 
 * [FreeType](#freetype)
-
 * [OpenAL](#openal)
-
 * [SDL2](#sdl2)
-
 * either Mono or .NET Core (it's OK to install both)
 
 ## FreeType
 
 To render fonts, we use the [FreeType](https://www.freetype.org/) library. The minimum required version is 2.6 and can be installed via:
 
-```
+### [Ubuntu](#tab/freetype-ubuntu)
+
+```bash
 sudo apt-get install libfreetype6-dev
 ```
 
+### [Fedora](#tab/freetype-fedora)
+
+```bash
+sudo dnf install freetype-devel
+```
+
+---
+
 ## OpenAL
 
 To play sounds and music, we use the [OpenAL](https://www.openal.org/) library. It can be installed via:
 
-```
+### [Ubuntu](#tab/openal-ubuntu)
+
+```bash
 sudo apt-get install libopenal-dev
 ```
 
+### [Fedora](#tab/openal-fedora)
+
+```bash
+sudo dnf install openal-soft-devel
+```
+
+---
+
 ## SDL2
 
 To run games on Linux, we use the [SDL2](https://www.libsdl.org/) library which provides the ability to create windows, handle mouse, keyboard and joystick events. The minimum required version is 2.0.4 and can be installed via:
 
-```
+### [Ubuntu](#tab/sdl2-ubuntu)
+
+```bash
 sudo apt-get install libsdl2-dev
 ```
 
-### .NET Core
+### [Fedora](#tab/sdl2-fedora)
+
+```bash
+sudo dnf install SDL2-devel
+```
+
+---
+
+## .NET Core
 
-For information about how to install .NET Core, see the [.NET Core instructions for Debian/Ubuntu](https://docs.microsoft.com/en-us/dotnet/core/linux-prerequisites?tabs=netcore2x).
+For information about how to install .NET Core, see the [.NET Core instructions for Linux](https://docs.microsoft.com/en-us/dotnet/core/linux-prerequisites).
 
 Make sure version 2.1.300+ and runtime 2.1+ is installed. To check which version you have installed, type:
 
@@ -54,4 +81,4 @@ dotnet --info
 
 ## See also
 
-* * [Create a Linux game](create-a-linux-game.md)
+* [Create a Linux game](create-a-linux-game.md)

en/manual/stride-for-godot-developers/index.md

@@ -2,6 +2,17 @@
 
 ## Editor
 
+The Stride editor is **Game Studio**.
+
+![Godot layout](media/stride-vs-godot-godotlayout.webp)
+
+![Stride Game Studio layout](media/stride-vs-godot-stridelayout.webp)
+
+You can customize the Game Studio layout by dragging tabs, similar to Visual Studio.
+
+For more information about Game Studio, see the [Game Studio](../game-studio/index.md) page.
+
+
 ## Terminology
 
 | Godot | Stride |
@@ -9,7 +20,7 @@
 | Scene | Entity Tree |
 | Inspector | Property Grid |
 | FileSystem | Solution/Asset View |
-|Scene view | Scene Editor |
+| Scene view | Scene Editor |
 | Node | Entity |
 | Node Script | SyncScript, AsyncScript, StartupScript |
 | Export | Serialize/DataMember |

en/manual/stride-for-godot-developers/media/stride-vs-godot-godotlayout.webp

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e660bd6c067274031e9edbaab837e3445ec801e23bda168fcd39676a2ede829f
+size 81446

en/manual/stride-for-godot-developers/media/stride-vs-godot-stridelayout.webp

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:677d511085f09acb48b8cd74a9a05f4f7852ea877be7aad9534ffd80666cb84f
+size 73840

en/manual/stride-for-unity-developers/index.md

@@ -8,9 +8,9 @@ Stride and Unity® both use C# and share many concepts, with a few major differe
 
 The Stride editor is **Game Studio**. This is the equivalent of the Unity® Editor.
 
-![Stride and Unity®  interface comparison](media/stride-vs-unity-interface-comparison.png)
+![Unity® Editor layout](media/stride-vs-unity-unitylayout.webp)
 
-*Unity® screenshot taken from [Calling a web-service from a Unity3D scene](http://through-the-interface.typepad.com/through_the_interface/2012/04/calling-a-web-service-from-a-unity3d-scene.html) by Kean Walmsley.*
+![Stride Game Studio layout](media/stride-vs-unity-stridelayout.webp)
 
 You can customize the Game Studio layout by dragging tabs, similar to Visual Studio.
 
@@ -20,22 +20,22 @@ For more information about Game Studio, see the [Game Studio](../game-studio/ind
 
 Unity® and Stride use mostly common terms, with a few differences:
 
-| Unity®          | Stride                                 |
-|-----------------|----------------------------------------|
-| Hierarchy panel | Entity Tree                            |
-| Inspector       | Property Grid                          |
-| Project browser | Asset View                             |
-| Scene view      | Scene Editor                           |
-| GameObject      | Entity                                 |
-| MonoBehaviour   | SyncScript, AsyncScript, StartupScript |
+| Unity®           | Stride                                       |
+|------------------|----------------------------------------------|
+| Hierarchy Window | Entity Tree                                  |
+| Inspector Window | Property Grid                                |
+| Project Window   | Asset View                                   |
+| Scene View       | Scene Editor                                 |
+| [`GameObject`](https://docs.unity3d.com/ScriptReference/GameObject.html) | [`Entity`](xref:Stride.Engine.Entity) |
+| [`MonoBehaviour`](https://docs.unity3d.com/ScriptReference/MonoBehaviour.html) | [`SyncScript`](xref:Stride.Engine.SyncScript), [`AsyncScript`](xref:Stride.Engine.AsyncScript), [`StartupScript`](xref:Stride.Engine.StartupScript) |
 
 ## Folders and files
 
 Like Unity®, Stride projects are stored in a directory that contains:
 
-* The project ``.sln`` solution file, which you can open with Game Studio or any IDE such as Visual Studio
+* The project `.sln` solution file, which you can open with Game Studio or any IDE such as Visual Studio
 
-* a **MyGame.Game** folder with project source files, dependencies, resources, configurations, and binaries
+* A **MyGame.Game** folder with project source files, dependencies, resources, configurations, and binaries
 
   ![Package folder structure](../files-and-folders/media/folder-structure.png)
 
@@ -45,7 +45,7 @@ Like Unity®, Stride projects are stored in a directory that contains:
 
 * **MyPackage.Game** contains your source code.
 
-*   **MyPackage.Platform** contains additional code for the platforms your project supports. Game Studio creates folders for each platform (e.g. *MyPackage.Windows*, *MyPackage.Linux*, etc.). These folders are usually small and only contain the entry point of the program.
+  * **MyPackage.Platform** contains additional code for the platforms your project supports. Game Studio creates folders for each platform (e.g. *MyPackage.Windows*, *MyPackage.Linux*, etc.). These folders are usually small and only contain the entry point of the program.
 
 * **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.
 
@@ -93,7 +93,7 @@ You can have multiple scenes in your project. The scene that loads up as soon as
 To set the default scene:
 
 1. In the **GameSettings** properties, next to **Default Scene**, click ![Hand icon](~/manual/game-studio/media/hand-icon.png) (**Select an asset**).
-    
+
     ![Set default scene](media/stride-vs-unity-game-settings-default-scene.png)
 
     The **Select an asset** window opens.
@@ -132,6 +132,7 @@ All entities are created with a Transform component by default.
 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.
 
 #### Local Position/Rotation/Scale
+
 Stride uses position, rotation, and scale to refer to the local position, rotation, and scale.
 
 | Unity®                       | Stride                       |
@@ -142,6 +143,7 @@ Stride uses position, rotation, and scale to refer to the local position, rotati
 | `transform.localEulerAngles` | `Transform.RotationEulerXYZ` |
 
 #### World Position/Rotation/Scale
+
 In comparison to Unity, many of the Transform component's properties related to its location in the world have been moved to the [WorldMatrix](xref:Stride.Engine.TransformComponent.WorldMatrix).
 
 | Unity®                                                            | Stride                                                                                                 |
@@ -158,6 +160,7 @@ In comparison to Unity, many of the Transform component's properties related to
 To ensure you're reading the latest position and rotation, you should force the matrix to update by calling `Transform.UpdateWorldMatrix()` before reading from it.
 
 #### Transform Directions
+
 Unlike Unity, Stride provides a Backward, Left, and Down property.
 Note that those are matrix properties, so setting one of those is not enough to properly rotate the matrix.
 
@@ -218,13 +221,13 @@ As soon as you add an asset to your project, you can edit its properties in the
 
 Like Unity®, Stride supports file formats including:
 
-| Asset type                    | Supported 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                         | .wav, .mp3, .ogg, .aac, .aiff, .flac, .m4a, .wma, .mpc       |
-| Fonts                         | .ttf, .otf                                                   |
-| Video                         | .mp4                                                         |
+| Asset type                    | Supported formats                                                                |
+|-------------------------------|----------------------------------------------------------------------------------|
+| Models, animations, skeletons | `.fbx`, `.dae`, `.3ds`, `.obj`, `.blend`, `.x`, `.md2`, `.md3`, `.dxf`           |
+| Sprites, textures, skyboxes   | `.dds`, `.jpg`, `.jpeg`, `.png`, `.gif`, `.bmp`, `.tga`, `.psd`, `.tif`, `.tiff` |
+| Audio                         | `.wav`, `.mp3`, `.ogg`, `.aac`, `.aiff`, `.flac`, `.m4a`, `.wma`, `.mpc`         |
+| Fonts                         | `.ttf`, `.otf`                                                                   |
+| Video                         | `.mp4`                                                                           |
 
 For more information about assets, see [Assets](../game-studio/assets.md).
 
@@ -275,11 +278,12 @@ Stride supports a variety of inputs. The code samples below demonstrate the diff
 For more information about Input in Stride, see [Input](../input/index.md).
 
 #### Unity®
+
 ```cs
 void Update()
 {
     // true for one frame in which the space bar was pressed
-    if(Input.GetKeyDown(KeyCode.Space))
+    if (Input.GetKeyDown(KeyCode.Space))
     {
         // Do something.
     }
@@ -290,17 +294,19 @@ void Update()
         // Do something.
     }
 
-    float Horiz = Input.GetAxis("Horizontal");
-    float Vert = Input.GetAxis("Vertical");
-    //Do something else.
+    float horiz = Input.GetAxis("Horizontal");
+    float vert = Input.GetAxis("Vertical");
+    // Do something else.
 }
 ```
+
 #### Stride
+
 ```cs
 public override void Update()
 {
     // true for one frame in which the space bar was pressed
-    if(Input.IsKeyDown(Keys.Space))
+    if (Input.IsKeyDown(Keys.Space))
     {
         // Do something.
     }
@@ -311,9 +317,9 @@ public override void Update()
         // 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.
+    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.
 }
 ```
 
@@ -342,22 +348,27 @@ They're controlled by scripts in slightly different ways.
 #### Unity®
 
 ```cs
-public Rigidbody rigidBody;
-void Start()
+public class KinematicX : MonoBehaviour
 {
-    rigidBody = GetComponent<Rigidbody>();
-}
+    public Rigidbody rigidBody;
 
-void EnableRagdoll()
-{
-    rigidBody.isKinematic = false;
-    rigidBody.detectCollisions = true;
-}
+    void Start()
+    {
+        // Initialization of the component.
+        rigidBody = GetComponent<Rigidbody>();
+    }
 
-void DisableRagdoll()
-{
-    rigidBody.isKinematic = true;
-    rigidBody.detectCollisions = false;
+    void EnableRagdoll()
+    {
+        rigidBody.isKinematic = false;
+        rigidBody.detectCollisions = true;
+    }
+
+    void DisableRagdoll()
+    {
+        rigidBody.isKinematic = true;
+        rigidBody.detectCollisions = false;
+    }
 }
 ```
 
@@ -366,28 +377,29 @@ void DisableRagdoll()
 ```cs
 public class KinematicX : SyncScript
 {
-    public RigidbodyComponent component;
+    public RigidbodyComponent rigidBody;
 
     public override void Start()
     {
-        // Initialization of the script.
-        component = Entity.Get<RigidbodyComponent>();
+        // Initialization of the component.
+        rigidBody = Entity.Get<RigidbodyComponent>();
     }
 
     public override void Update()
     {
+        // Perform an update every frame.
     }
 
-    public void EnableRagdoll()
+    void EnableRagdoll()
     {
-        component.IsKinematic = false;
-        component.ProcessCollisions = true;
+        rigidBody.IsKinematic = false;
+        rigidBody.ProcessCollisions = true;
     }
 
-    public void DisableRagdoll()
+    void DisableRagdoll()
     {
-        component.IsKinematic = true;
-        component.ProcessCollisions = false;
+        rigidBody.IsKinematic = true;
+        rigidBody.ProcessCollisions = false;
     }
 }
 ```
@@ -449,7 +461,7 @@ For more information about triggers in Stride, see [Triggers](../physics/trigger
 #### Unity®
 
 ```cs
-Collider FindGOCameraIsLookingAt()
+public static Collider FindGOCameraIsLookingAt()
 {
     int distance = 50;
 
@@ -491,6 +503,7 @@ public static bool ScreenPositionToWorldPositionRaycast(Vector2 screenPos, Camer
     return result.Succeeded;
 }
 ```
+
 For more information about Raycasting in Stride, see [Raycasting](../physics/raycasting.md).
 
 ## Scripts
@@ -547,7 +560,7 @@ 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)
+        while (Game.IsRunning)
         {
             // Do stuff every new frame
             await Script.NextFrame();
@@ -589,19 +602,19 @@ To create a script, click the **Add asset** button and select **Scripts**.
 
 ![Create script in Stride](media/stride-vs-unity-create-script.png)
 
-In Unity®, when you create a `MonoBehaviour` script, it has two base functions: `Start()` and `Update()`. Stride has a [SyncScript](xref:Stride.Engine.SyncScript) that works similarly. Like `MonoBehaviour`, [SyncScript](xref:Stride.Engine.SyncScript) has two methods:
+In Unity®, when you create a [`MonoBehaviour`](https://docs.unity3d.com/ScriptReference/MonoBehaviour.html) script, it has two base functions: [`MonoBehaviour.Start()`](https://docs.unity3d.com/ScriptReference/MonoBehaviour.Start.html) and [`MonoBehaviour.Update()`](https://docs.unity3d.com/ScriptReference/MonoBehaviour.Update.html). Stride has a [`SyncScript`](xref:Stride.Engine.SyncScript) that works similarly. Like [`MonoBehaviour`](https://docs.unity3d.com/ScriptReference/MonoBehaviour.html), [`SyncScript`](xref:Stride.Engine.SyncScript) has two methods:
 
-* [Start()](xref:Stride.Engine.StartupScript.Start) is called when it the script is loaded.
+* [`SyncScript.Start()`](xref:Stride.Engine.StartupScript.Start) is called when it the script is loaded.
 
-* [Update()](xref:Stride.Engine.SyncScript.Update) is called every update.
+* [`SyncScript.Update()`](xref:Stride.Engine.SyncScript.Update) is called every update.
 
-Unlike `MonoBehaviour`, you have to use [Update()](xref:Stride.Engine.SyncScript.Update) method in every [SyncScript](xref:Stride.Engine.SyncScript), or your code won't work properly.
+Unlike [`MonoBehaviour`](https://docs.unity3d.com/ScriptReference/MonoBehaviour.html), implementating the [`SyncScript.Update()`](xref:Stride.Engine.SyncScript.Update) method is not optional, and as such, must be implemented in every [`SyncScript`](xref:Stride.Engine.SyncScript).
 
 If you want your script to be a startup or asynchronous, use the corresponding script types:
 
-* [StartupScript](xref:Stride.Engine.StartupScript): this script has a single [Start()](xref:Stride.Engine.StartupScript.Start) method. It initializes the scene and its content at startup.
+* [`StartupScript`](xref:Stride.Engine.StartupScript): this script has a single [`StartupScript.Start()`](xref:Stride.Engine.StartupScript.Start) method. It initializes the scene and its content at startup.
 
-* [AsyncScript](xref:Stride.Engine.AsyncScript): an asynchronous script with a single method [Execute()](xref:Stride.Engine.AsyncScript.Execute) and you can use async/await inside that method. Asynchronous scripts aren't loaded one by one like synchronous scripts. Instead, they're all loaded in parallel.
+* [`AsyncScript`](xref:Stride.Engine.AsyncScript): an asynchronous script with a single method [`AsyncScript.Execute()`](xref:Stride.Engine.AsyncScript.Execute) and you can use async/await inside that method. Asynchronous scripts aren't loaded one by one like synchronous scripts. Instead, they're all loaded in parallel.
 
 ### Reload assemblies
 
@@ -640,8 +653,8 @@ public Quaternion SpawnRotation;
 
 void Start()
 {
-    GameObject NewGO = (GameObject)Instantiate(CarPrefab, SpawnPosition, SpawnRotation);
-    NewGO.name = "NewGameObject1";
+    GameObject newGameObject = (GameObject)Instantiate(CarPrefab, SpawnPosition, SpawnRotation);
+    newGameObject.name = "NewGameObject1";
 }
 ```
 
@@ -674,15 +687,15 @@ Each class in Unity® has certain default values. If you don't override these pr
 
 ```cs
 public int NewProp = 30;
-public Light MyLightComp = null;
+public Light MyLightComponent = null;
 
 void Start()
 {
     // Create the light component if we don't already have one.
-    if (MyLightComp == null)
+    if (MyLightComponent == null)
     {
-        MyLightComp = gameObject.AddComponent<Light>();
-        MyLightComp.intensity = 3;
+        MyLightComponent = gameObject.AddComponent<Light>();
+        MyLightComponent.intensity = 3;
     }
 }
 ```
@@ -739,13 +752,13 @@ LightComponent lightComponent = Entity.Get<LightComponent>();
 #### Unity®
 
 ```cs
-GameObject ParentGO = lightComponent.gameObject;
+GameObject componentGameObject = lightComponent.gameObject;
 ```
 
 #### Stride
 
 ```cs
-Entity ParentEntity = lightComponent.Entity;
+Entity componentEntity = lightComponent.Entity;
 ```
 
 ## Log output
@@ -758,10 +771,10 @@ Game Studio displays in the **Output** tab (at the bottom of Game Studio by defa
 
 ![Output tab](media/output-tab.png)
 
-
 ### Print debug messages
 
 Logging from a ScriptComponent:
+
 ```cs
 public override void Start()
 {
@@ -792,9 +805,9 @@ System.Diagnostics.Debug.WriteLine("hello");
 | `[Tooltip("My tooltip")]` | `/// <userdoc>My tooltip</userdoc>` |
 
 >[!Note]
->You cannot serialize private fields in Stride, if you want to set a field in editor but prevent other scripts from writing to that field, you should use a [init property](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/init)
+>You cannot serialize `private` fields in Stride, if you want to set a field in editor but prevent other scripts from writing to that field, you should use a [init property](https://learn.microsoft.com/en-us/dotnet/csharp/language-reference/keywords/init)
 
-```cs 
+```cs
 public float MyProperty { get; init; }
 ```
 

en/manual/stride-for-unity-developers/media/stride-vs-unity-interface-comparison.png

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:bfce3d618e18e030ab7c191e605c017a11ca84b81bf958d01ab68a03b9f5f141
-size 518009

en/manual/stride-for-unity-developers/media/stride-vs-unity-stridelayout.webp

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:677d511085f09acb48b8cd74a9a05f4f7852ea877be7aad9534ffd80666cb84f
+size 73840

en/manual/stride-for-unity-developers/media/stride-vs-unity-unitylayout.webp

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f2d2c7e64a291e191b7cb7998c36d3ccd5b598206a105c9c7a959a8ebaf4b2a6
+size 78284

en/manual/ui/ui-libraries.md

@@ -50,7 +50,7 @@ public Button CreateButton()
     if (button != null)
     {        
         // attach a delegate to the Click event
-        someButton.Click += delegate
+        button.Click += delegate
         {
             // do something here...
         };
@@ -67,4 +67,4 @@ UI pages have only one root element. UI libraries can have multiple root element
 * [UI pages](ui-pages.md)
 * [UI editor](ui-editor.md)
 * [Add a UI to a scene](add-a-ui-to-a-scene.md)
-* [Layout system](layout-system.md)
+* [Layout system](layout-system.md)

jp/manual/ui/ui-libraries.md

@@ -100,7 +100,7 @@ public Button CreateButton()
     {        
         // Click イベントにデリゲートを登録します。
         // attach a delegate to the Click event
-        someButton.Click += delegate
+        button.Click += delegate
         {
             // ここで何かの作業をします。
             // do something here...