[WIP] Convert from SharpDX to Silk.NET.

sources/Directory.Packages.props

@@ -25,6 +25,9 @@
     <PackageVersion Include="SharpDX.MediaFoundation" Version="4.2.0" />
     <PackageVersion Include="SharpDX.RawInput" Version="4.2.0" />
     <PackageVersion Include="SharpDX.XInput" Version="4.2.0" />
+    <PackageVersion Include="Silk.NET.Direct3D11" Version="2.22.0" />
+    <PackageVersion Include="Silk.NET.Direct3D12" Version="2.22.0" />
+    <PackageVersion Include="Silk.NET.Direct3D.Compilers" Version="2.22.0" />
     <PackageVersion Include="Silk.NET.OpenGL" Version="2.22.0" />
     <PackageVersion Include="Silk.NET.OpenGLES" Version="2.22.0" />
     <PackageVersion Include="Silk.NET.OpenGLES.Extensions.EXT" Version="2.22.0" />

sources/core/Stride.Core.Mathematics/Color4.cs

@@ -7,17 +7,17 @@
 // -----------------------------------------------------------------------------
 /*
 * Copyright (c) 2007-2011 SlimDX Group
-* 
+*
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
-* 
+*
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
-* 
+*
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
@@ -34,7 +34,7 @@
 namespace Stride.Core.Mathematics;
 
 /// <summary>
-/// Represents a color in the form of rgba.
+///   A RGBA color value with 32-bit floating-point precision per channel.
 /// </summary>
 [DataContract("Color4")]
 [DataStyle(DataStyle.Compact)]
@@ -44,12 +44,17 @@ public struct Color4 : IEquatable<Color4>, ISpanFormattable
     /// <summary>
     /// The Black color (0, 0, 0, 1).
     /// </summary>
-    public static readonly Color4 Black = new(0.0f, 0.0f, 0.0f);
+    public static readonly Color4 Black = new(red: 0, green: 0, blue: 0);
 
     /// <summary>
     /// The White color (1, 1, 1, 1).
     /// </summary>
-    public static readonly Color4 White = new(1.0f, 1.0f, 1.0f);
+    public static readonly Color4 White = new(red: 1, green: 1, blue: 1);
+
+    /// <summary>
+    /// The transparent black color (0, 0, 0, 0).
+    /// </summary>
+    public static readonly Color4 TransparentBlack = default;
 
     /// <summary>
     /// The red component of the color.

sources/core/Stride.Core/ComponentBase.cs

@@ -4,70 +4,85 @@
 namespace Stride.Core;
 
 /// <summary>
-/// Base class for a framework component.
+///   Base class for a framework Component.
 /// </summary>
+/// <remarks>
+///   <para>
+///     A <strong>Component</strong> is an object that can have a <see cref="Name"/> and other meta-information
+///     (see <see cref="Tags"/>), and that can hold references to other sub-Components that depend on it.
+///   </para>
+///   <para>
+///     Components have reference-counting lifetime management, so calling <see cref="DisposeBase.Dispose"/> does
+///     not immediately releases its underlying resources, but instead decreases an internal reference count.
+///     When that reference count reaches zero, it then calls <see cref="Destroy"/> automatically, where the
+///     underlying resources can then be released safely.
+///   </para>
+///   <para>
+///     When <see cref="Destroy"/> is called, not only the resources associated with the Component itself should
+///     be released, but it cascades the releasing of resources to its contained sub-Components.
+///   </para>
+/// </remarks>
+/// <seealso cref="IComponent"/>
+/// <seealso cref="IReferencable"/>
+/// <seealso cref="ICollectorHolder"/>
 [DataContract]
 public abstract class ComponentBase : DisposeBase, IComponent, ICollectorHolder
 {
     private string name;
     private ObjectCollector collector;
 
+
     /// <summary>
-    /// Initializes a new instance of the <see cref="ComponentBase"/> class.
+    ///   Initializes a new instance of the <see cref="ComponentBase"/> class.
     /// </summary>
-    protected ComponentBase()
-        : this(null)
-    {
-    }
+    protected ComponentBase() : this(name: null) { }
 
     /// <summary>
-    /// Initializes a new instance of the <see cref="ComponentBase"/> class.
+    ///   Initializes a new instance of the <see cref="ComponentBase"/> class.
     /// </summary>
-    /// <param name="name">The name attached to this component</param>
+    /// <param name="name">The name attached to the Component, or <see langword="null"/> to use the type's name.</param>
     protected ComponentBase(string? name)
     {
         collector = new ObjectCollector();
         Tags = new PropertyContainer(this);
-        Name = name ?? GetType().Name;
+        this.name = name ?? GetType().Name;
     }
 
+
     /// <summary>
-    /// Gets the attached properties to this component.
+    ///   The properties attached to the Component.
     /// </summary>
     [DataMemberIgnore] // Do not try to recreate object (preserve Tags.Owner)
     public PropertyContainer Tags;
 
     /// <summary>
-    /// Gets or sets the name of this component.
+    ///   Gets or sets the name of the Component.
     /// </summary>
     /// <value>
-    /// The name.
+    ///   The name that identifies the Component. It can be <see langword="null"/> to denote it has no specific name.
     /// </value>
-    [DataMemberIgnore] // By default don't store it, unless derived class are overriding this member
+    [DataMemberIgnore] // By default, don't store it, unless derived class are overriding this member
     public virtual string Name
     {
-        get
-        {
-            return name;
-        }
+        get => name;
         set
         {
-            if (value == name) return;
+            if (value == name)
+                return;
 
             name = value;
 
             OnNameChanged();
         }
     }
 
-    /// <summary>
-    /// Disposes of object resources.
-    /// </summary>
+    /// <inheritdoc/>
     protected override void Destroy()
     {
         collector.Dispose();
     }
 
+    /// <inheritdoc/>
     ObjectCollector ICollectorHolder.Collector
     {
         get
@@ -78,12 +93,11 @@ ObjectCollector ICollectorHolder.Collector
     }
 
     /// <summary>
-    /// Called when <see cref="Name"/> property was changed.
+    ///   Called when the <see cref="Name"/> property has changed.
     /// </summary>
-    protected virtual void OnNameChanged()
-    {
-    }
+    protected virtual void OnNameChanged() { }
 
+    /// <inheritdoc/>
     public override string ToString()
     {
         return $"{GetType().Name}: {name}";

sources/core/Stride.Core/ComponentBaseExtensions.cs

@@ -1,8 +1,6 @@
 // Copyright (c) .NET Foundation and Contributors (https://dotnetfoundation.org/ & https://stride3d.net) and Silicon Studio Corp. (https://www.siliconstudio.co.jp)
 // Distributed under the MIT license. See the LICENSE.md file in the project root for more information.
 
-using Stride.Core.Annotations;
-
 namespace Stride.Core;
 
 /// <summary>
@@ -11,92 +9,109 @@ namespace Stride.Core;
 public static class ComponentBaseExtensions
 {
     /// <summary>
-    /// Keeps a disposable object alive by adding it to a container.
+    ///   Keeps a disposable object alive by adding it to a container.
     /// </summary>
-    /// <typeparam name="T">A component</typeparam>
-    /// <param name="thisArg">The component to keep alive.</param>
-    /// <param name="container">The container that will keep a reference to the component.</param>
-    /// <returns>The same component instance</returns>
-    public static T? DisposeBy<T>(this T thisArg, ICollectorHolder container)
+    /// <typeparam name="T">The type of the Component.</typeparam>
+    /// <param name="component">The Component to keep alive.</param>
+    /// <param name="container">The container that will keep a reference to the Component.</param>
+    /// <returns>The same Component instance.</returns>
+    public static T? DisposeBy<T>(this T component, ICollectorHolder container)
         where T : IDisposable
     {
-        if (ReferenceEquals(thisArg, null))
+        if (component is null)
             return default;
-        return container.Collector.Add(thisArg);
+
+        return container.Collector.Add(component);
     }
 
     /// <summary>
-    /// Removes a disposable object that was being kept alive from a container.
+    ///   Removes a disposable object from a container that keeping it alive.
     /// </summary>
-    /// <typeparam name="T">A component</typeparam>
-    /// <param name="thisArg">The component to remove.</param>
-    /// <param name="container">The container that kept a reference to the component.</param>
-    public static void RemoveDisposeBy<T>(this T thisArg, ICollectorHolder container)
+    /// <typeparam name="T">The type of the Component.</typeparam>
+    /// <param name="component">The Component to remove.</param>
+    /// <param name="container">The container that kept a reference to the Component.</param>
+    public static void RemoveDisposeBy<T>(this T component, ICollectorHolder container)
         where T : IDisposable
     {
-        if (ReferenceEquals(thisArg, null))
+        if (component is null)
             return;
-        container.Collector.Remove(thisArg);
+
+        container.Collector.Remove(component);
     }
 
     /// <summary>
-    /// Keeps a referencable object alive by adding it to a container.
+    ///   Keeps a referenceable object alive by adding it to a container.
     /// </summary>
-    /// <typeparam name="T">A component</typeparam>
-    /// <param name="thisArg">The component to keep alive.</param>
-    /// <param name="container">The container that will keep a reference to the component.</param>
-    /// <returns>The same component instance</returns>
-    public static T? ReleaseBy<T>(this T thisArg, ICollectorHolder container)
+    /// <typeparam name="T">The type of the Component.</typeparam>
+    /// <param name="component">The Component to keep alive.</param>
+    /// <param name="container">The container that will keep a reference to the Component.</param>
+    /// <returns>The same Component instance.</returns>
+    public static T? ReleaseBy<T>(this T component, ICollectorHolder container)
         where T : IReferencable
     {
-        if (ReferenceEquals(thisArg, null))
+        if (component is null)
             return default;
-        return container.Collector.Add(thisArg);
+
+        return container.Collector.Add(component);
     }
 
     /// <summary>
-    /// Removes a referencable object that was being kept alive from a container.
+    ///   Removes a referenceable object from a container that keeping it alive.
     /// </summary>
-    /// <typeparam name="T">A component</typeparam>
-    /// <param name="thisArg">The component to remove.</param>
-    /// <param name="container">The container that kept a reference to the component.</param>
-    public static void RemoveReleaseBy<T>(this T thisArg, ICollectorHolder container)
+    /// <typeparam name="T">The type of the Component.</typeparam>
+    /// <param name="component">The Component to remove.</param>
+    /// <param name="container">The container that kept a reference to the Component.</param>
+    public static void RemoveReleaseBy<T>(this T component, ICollectorHolder container)
         where T : IReferencable
     {
-        if (ReferenceEquals(thisArg, null))
+        if (component is null)
             return;
-        container.Collector.Remove(thisArg);
+
+        container.Collector.Remove(component);
     }
 
     /// <summary>
-    /// Pins this component as a new reference.
+    ///   Pins this component as a new reference.
     /// </summary>
-    /// <typeparam name="T">A component</typeparam>
-    /// <param name="thisArg">The component to add a reference to.</param>
-    /// <returns>This component.</returns>
-    /// <remarks>This method is equivalent to call <see cref="IReferencable.AddReference"/> and return this instance.</remarks>
-    public static T? KeepReference<T>(this T thisArg)
+    /// <typeparam name="T">The type of the Component.</typeparam>
+    /// <param name="component">The Component to add a reference to.</param>
+    /// <returns>The same Component instance.</returns>
+    /// <remarks>
+    ///   This method is equivalent to calling <see cref="IReferencable.AddReference"/> and returning the
+    ///   same <paramref name="component"/> instance.
+    /// </remarks>
+    public static T? KeepReference<T>(this T component)
         where T : IReferencable
     {
-        if (ReferenceEquals(thisArg, null))
+        if (component is null)
             return default;
-        thisArg.AddReference();
-        return thisArg;
+
+        component.AddReference();
+        return component;
     }
 
     /// <summary>
-    /// Pushes a tag to a component and restore it after using it. See remarks for usage.
+    ///   Sets a tag in a Component and removes it after using it.
     /// </summary>
-    /// <typeparam name="T"></typeparam>
-    /// <param name="component">The component.</param>
-    /// <param name="key">The key.</param>
-    /// <param name="value">The value.</param>
-    /// <returns>PropertyTagRestore&lt;T&gt;.</returns>
+    /// <typeparam name="T">The type of the tag.</typeparam>
+    /// <param name="component">The Component to set a tag for.</param>
+    /// <param name="key">The key to identify the tag to set.</param>
+    /// <param name="value">The value of the tag.</param>
+    /// <returns>
+    ///   A <see cref="PropertyTagRestore{T}"/> structure that can be used with a <see langword="using"/> clause (or
+    ///   manually disposed) to set a tag, perform some action, and remove the tag once finished.
+    /// </returns>
     /// <remarks>
-    /// This method is used to set save a property value from <see cref="ComponentBase.Tags"/>, set a new value
-    /// and restore it after. The returned object must be disposed once the original value must be restored.
+    ///   <para>
+    ///     This method is used to set a property value in <see cref="ComponentBase.Tags"/>, perform some actions, and restore
+    ///     the previous value after finishing.
+    ///   </para>
+    ///   <para>
+    ///     The returned object must be disposed once the original value must be restored. It can be done manually
+    ///     (by calling <see cref="PropertyTagRestore{T}.Dispose"/>) or automatically with a <see langword="using"/> clause.
+    ///   </para>
     /// </remarks>
-    public static PropertyTagRestore<T> PushTagAndRestore<T>(this ComponentBase component, PropertyKey<T> key, T value)
+    public static PropertyTagRestore<T> PushTagAndRestore<T>(this ComponentBase component, PropertyKey<T?> key, T value)
     {
         // TODO: Not fully satisfied with the name and the extension point (on ComponentBase). We need to review this a bit more
         var restorer = new PropertyTagRestore<T>(component, key);
@@ -105,27 +120,38 @@ public static PropertyTagRestore<T> PushTagAndRestore<T>(this ComponentBase comp
     }
 
     /// <summary>
-    /// Struct PropertyTagRestore
+    ///   A structure returned by <see cref="PushTagAndRestore{T}(ComponentBase, PropertyKey{T}, T)"/> that saves the value of a
+    ///   tag property of an object and, once finished, can restore its value to the previous one.
     /// </summary>
-    /// <typeparam name="T"></typeparam>
+    /// <typeparam name="T">The type of the tag.</typeparam>
     public readonly struct PropertyTagRestore<T> : IDisposable
     {
         private readonly ComponentBase container;
 
-        private readonly PropertyKey<T> key;
+        private readonly PropertyKey<T?> key;
 
-        private readonly T previousValue;
+        private readonly T? previousValue;
 
-        public PropertyTagRestore(ComponentBase container, PropertyKey<T> key)
+
+        /// <summary>
+        ///   Initializes a new instance of the <see cref="PropertyTagRestore{T}"/> structure.
+        /// </summary>
+        /// <param name="container">The Component that contains the tag to set and restore.</param>
+        /// <param name="key">The key that identifies the tag to set and restore.</param>
+        /// <exception cref="ArgumentNullException"><paramref name="container"/> is <see langword="null"/>.</exception>
+        /// <exception cref="ArgumentNullException"><paramref name="key"/> is <see langword="null"/>.</exception>
+        public PropertyTagRestore(ComponentBase container, PropertyKey<T?> key)
             : this()
         {
             ArgumentNullException.ThrowIfNull(container);
             ArgumentNullException.ThrowIfNull(key);
+
             this.container = container;
             this.key = key;
             previousValue = container.Tags.Get(key);
         }
 
+        /// <inheritdoc/>
         public readonly void Dispose()
         {
             // Restore the value