Triangle with Silk.NET.Windowing 3.0

Author: Perksey

.gitattributes

@@ -23,6 +23,7 @@
 *.sln       text        eol=lf
 *.targets   text        eol=lf
 *.yml       text        eol=lf
+*.hlsl      text        eof=lf
 
 ###############################################################################
 # Set explicit file behavior to:
@@ -53,6 +54,35 @@
 *.7z binary
 *.ttf binary
 *.stout binary
+*.p7s binary
+*.sample binary
+*.nupkg binary
+*.exe binary
+*.idx binary
+*.pack binary
+*.spv binary
+*.lib binary
+*.dylib binary
+*.so binary
+*.dll binary
+*.xcscheme binary
+*.xcworkspacedata binary
+*.pdf binary
+*.pfx binary
+*.metal binary
+*.jar binary
+*.apk binary
+*.aar binary
+*.aidl binary
+*.flata binary
+*.metallib binary
+*.items binary
+*.stamp binary
+*.icns binary
+*.mdb binary
+*.pdb binary
+*.bmp binary
+*.dat binary
 
 # Verify
 *.verified.txt text eol=lf working-tree-encoding=UTF-8

sources/Core/Core/Abstractions/Version32.cs

@@ -20,7 +20,7 @@ public readonly struct Version32
     /// <param name="minor">The minor value.</param>
     /// <param name="patch">The patch value.</param>
     /// <param name="variant">The variant value.</param>
-    public Version32(uint major, uint minor, uint patch, uint variant = 0) =>
+    public Version32(uint major, uint minor, uint patch = 0, uint variant = 0) =>
         Value = (variant << 29) | (major << 22) | (minor << 12) | patch;
 
     /// <summary>

sources/Core/Core/Pointers/Ptr.cs

@@ -102,6 +102,7 @@ public T[] ToArray<T>(int length)
         [MethodImpl(
             MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization
         )]
+        // TODO analyzer to ensure ptr is on stack or otherwise pinned
         public static bool operator ==(Ref lh, Ptr rh) => (void*)lh == rh.Native;
 
         /// <summary>

sources/Core/Core/Pointers/Ptr.generic.cs

@@ -327,6 +327,7 @@ public unsafe struct Ptr<T>(T* ptr)
         [MethodImpl(
             MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization
         )]
+        // TODO analyzer to ensure ptr is on stack or otherwise pinned
         public static explicit operator Ptr<T>(Ref<T> ptr) => (T*)ptr;
 
         /// <summary>
@@ -338,6 +339,15 @@ public unsafe struct Ptr<T>(T* ptr)
         )]
         public static implicit operator Ptr(Ptr<T> ptr) => new Ptr(ptr.Native);
 
+        /// <summary>
+        /// Creates a <see cref="Ref"/> from a <see cref="Ptr{T}"/>
+        /// </summary>
+        /// <param name="ptr"></param>
+        [MethodImpl(
+            MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization
+        )]
+        public static implicit operator Ref(Ptr<T> ptr) => ptr.Native;
+
         /// <summary>
         /// Creates a <see cref="Ptr{T}"/> from a <see cref="Ptr"/>
         /// </summary>

sources/Core/Core/Pointers/Ptr2D.cs

@@ -353,8 +353,33 @@ public T[][] ToArray<T>(int length, int[] lengths)
         [MethodImpl(
             MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization
         )]
+        // TODO analyzer to ensure ptr is on stack or otherwise pinned
         public static explicit operator Ptr2D(Ref2D ptr) => (void**)ptr;
 
+        /// <summary>
+        /// Expresses this <see cref="Ptr2D" /> as a <see cref="Ref"/>. Note that this does not index the
+        /// <see cref="Ptr2D"/>'s dimensions, and is effectively equivalent to converting a <c>void**</c> to a
+        /// <c>void*</c>.
+        /// </summary>
+        /// <param name="ptr">The <see cref="Ptr2D"/>.</param>
+        /// <returns>The <see cref="Ref"/>.</returns>
+        [MethodImpl(
+            MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization
+        )]
+        public static implicit operator Ref(Ptr2D ptr) => ptr.Native;
+
+        /// <summary>
+        /// Expresses this <see cref="Ptr2D" /> as a <see cref="Ptr"/>. Note that this does not index the
+        /// <see cref="Ptr2D"/>'s dimensions, and is effectively equivalent to converting a <c>void**</c> to a
+        /// <c>void*</c>.
+        /// </summary>
+        /// <param name="ptr">The <see cref="Ptr2D"/>.</param>
+        /// <returns>The <see cref="Ptr"/>.</returns>
+        [MethodImpl(
+            MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization
+        )]
+        public static implicit operator Ptr(Ptr2D ptr) => ptr.Native;
+
         /// <summary>
         /// Creates a null ptr
         /// </summary>

sources/Core/Core/Pointers/Ptr2D.generic.cs

@@ -515,7 +515,8 @@ public T[][] ToArray(int length, int[] lengths) =>
         [MethodImpl(
             MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization
         )]
-        public static implicit operator Ptr2D<T>(Ref2D ptr) => (void**)ptr;
+        // TODO analyzer to ensure ptr is on stack or otherwise pinned
+        public static explicit operator Ptr2D<T>(Ref2D ptr) => (void**)ptr;
 
         /// <summary>
         /// Creates a <see cref="Ref"/> from a <see cref="Ptr2D{T}"/>
@@ -524,7 +525,32 @@ public T[][] ToArray(int length, int[] lengths) =>
         [MethodImpl(
             MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization
         )]
-        public static implicit operator Ptr2D<T>(Ref2D<T> ptr) => (T**)ptr;
+        // TODO analyzer to ensure ptr is on stack or otherwise pinned
+        public static explicit operator Ptr2D<T>(Ref2D<T> ptr) => (T**)ptr;
+
+        /// <summary>
+        /// Expresses this <see cref="Ptr2D{T}" /> as a <see cref="Ref"/>. Note that this does not index the
+        /// <see cref="Ptr2D{T}"/>'s dimensions, and is effectively equivalent to converting a <c>void**</c> to a
+        /// <c>void*</c>.
+        /// </summary>
+        /// <param name="ptr">The <see cref="Ptr2D{T}"/>.</param>
+        /// <returns>The <see cref="Ref"/>.</returns>
+        [MethodImpl(
+            MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization
+        )]
+        public static implicit operator Ref(Ptr2D<T> ptr) => ptr.Native;
+
+        /// <summary>
+        /// Expresses this <see cref="Ptr2D{T}" /> as a <see cref="Ptr"/>. Note that this does not index the
+        /// <see cref="Ptr2D{T}"/>'s dimensions, and is effectively equivalent to converting a <c>void**</c> to a
+        /// <c>void*</c>.
+        /// </summary>
+        /// <param name="ptr">The <see cref="Ptr2D{T}"/>.</param>
+        /// <returns>The <see cref="Ptr"/>.</returns>
+        [MethodImpl(
+            MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization
+        )]
+        public static implicit operator Ptr(Ptr2D<T> ptr) => ptr.Native;
 
         /// <summary>
         /// Creates a <see cref="Ptr"/> from a <see cref="Ptr2D{T}"/>

sources/Core/Core/Pointers/Ptr3D.cs

@@ -370,13 +370,37 @@ ptr.Native is not null && ptr.Native->Native is not null
         public static implicit operator void***(Ptr3D ptr) => (void***)ptr.Native;
 
         /// <summary>
-        /// Creates a <see cref="Ref2D"/> from a <see cref="Ptr3D"/>
+        /// Creates a <see cref="Ref3D"/> from a <see cref="Ptr3D"/>
         /// </summary>
         /// <param name="ptr"></param>
         [MethodImpl(
             MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization
         )]
-        public static implicit operator Ref2D(Ptr3D ptr) => ptr.Native;
+        public static implicit operator Ref3D(Ptr3D ptr) => ptr.Native;
+
+        /// <summary>
+        /// Expresses this <see cref="Ptr3D" /> as a <see cref="Ref"/>. Note that this does not index the
+        /// <see cref="Ptr3D"/>'s dimensions, and is effectively equivalent to converting a <c>void***</c> to a
+        /// <c>void*</c>.
+        /// </summary>
+        /// <param name="ptr">The <see cref="Ptr3D"/>.</param>
+        /// <returns>The <see cref="Ref"/>.</returns>
+        [MethodImpl(
+            MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization
+        )]
+        public static implicit operator Ref(Ptr3D ptr) => ptr.Native;
+
+        /// <summary>
+        /// Expresses this <see cref="Ptr3D" /> as a <see cref="Ptr"/>. Note that this does not index the
+        /// <see cref="Ptr3D"/>'s dimensions, and is effectively equivalent to converting a <c>void***</c> to a
+        /// <c>void*</c>.
+        /// </summary>
+        /// <param name="ptr">The <see cref="Ptr3D"/>.</param>
+        /// <returns>The <see cref="Ptr"/>.</returns>
+        [MethodImpl(
+            MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization
+        )]
+        public static implicit operator Ptr(Ptr3D ptr) => ptr.Native;
 
         /// <summary>
         /// Creates a <see cref="Ptr3D"/> from a <see cref="Ref2D"/>
@@ -385,6 +409,7 @@ ptr.Native is not null && ptr.Native->Native is not null
         [MethodImpl(
             MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization
         )]
+        // TODO analyzer to ensure ptr is on stack or otherwise pinned
         public static explicit operator Ptr3D(Ref2D ptr) => (void**)ptr;
 
         /// <summary>

sources/Core/Core/Pointers/Ptr3D.generic.cs

@@ -534,14 +534,39 @@ ptr.Native is not null && ptr.Native->Native is not null
         )]
         public static implicit operator Ref3D<T>(Ptr3D<T> ptr) => ptr.Native;
 
+        /// <summary>
+        /// Expresses this <see cref="Ptr3D{T}" /> as a <see cref="Ref"/>. Note that this does not index the
+        /// <see cref="Ptr3D{T}"/>'s dimensions, and is effectively equivalent to converting a <c>void***</c> to a
+        /// <c>void*</c>.
+        /// </summary>
+        /// <param name="ptr">The <see cref="Ptr3D{T}"/>.</param>
+        /// <returns>The <see cref="Ref"/>.</returns>
+        [MethodImpl(
+            MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization
+        )]
+        public static implicit operator Ref(Ptr3D<T> ptr) => ptr.Native;
+
+        /// <summary>
+        /// Expresses this <see cref="Ptr3D{T}" /> as a <see cref="Ptr"/>. Note that this does not index the
+        /// <see cref="Ptr3D{T}"/>'s dimensions, and is effectively equivalent to converting a <c>void***</c> to a
+        /// <c>void*</c>.
+        /// </summary>
+        /// <param name="ptr">The <see cref="Ptr3D{T}"/>.</param>
+        /// <returns>The <see cref="Ptr"/>.</returns>
+        [MethodImpl(
+            MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization
+        )]
+        public static implicit operator Ptr(Ptr3D<T> ptr) => ptr.Native;
+
         /// <summary>
         /// Creates a <see cref="Ref"/> from a <see cref="Ptr3D{T}"/>
         /// </summary>
         /// <param name="ptr"></param>
         [MethodImpl(
             MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization
         )]
-        public static implicit operator Ptr3D<T>(Ref3D ptr) => (void***)ptr;
+        // TODO analyzer to ensure ptr is on stack or otherwise pinned
+        public static explicit operator Ptr3D<T>(Ref3D ptr) => (void***)ptr;
 
         /// <summary>
         /// Creates a <see cref="Ref"/> from a <see cref="Ptr3D{T}"/>
@@ -550,7 +575,8 @@ ptr.Native is not null && ptr.Native->Native is not null
         [MethodImpl(
             MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization
         )]
-        public static implicit operator Ptr3D<T>(Ref3D<T> ptr) => (T***)ptr;
+        // TODO analyzer to ensure ptr is on stack or otherwise pinned
+        public static explicit operator Ptr3D<T>(Ref3D<T> ptr) => (T***)ptr;
 
         /// <summary>
         /// Creates a <see cref="Ptr"/> from a <see cref="Ptr3D{T}"/>

sources/Core/Core/Pointers/Ref2D.cs

@@ -210,6 +210,16 @@ public ref Ref this[nuint index]
     public static implicit operator Ref2D(byte[][] array) =>
         SilkMarshal.JaggedArrayToPointerArray<byte>(array);
 
+    /// <summary>
+    /// Expresses this <see cref="Ref2D" /> as a <see cref="Ref"/>. Note that this does not index the
+    /// <see cref="Ref2D"/>'s dimensions, and is effectively equivalent to converting a <c>void**</c> to a
+    /// <c>void*</c>.
+    /// </summary>
+    /// <param name="ptr">The <see cref="Ref2D"/>.</param>
+    /// <returns>The <see cref="Ref"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static implicit operator Ref(Ref2D ptr) => new(ref ptr.InteriorRef);
+
     /// <summary>
     /// creates a <see cref="Ref2D"/> from a reference array
     /// </summary>

sources/Core/Core/Pointers/Ref2D.generic.cs

@@ -230,6 +230,16 @@ public ref Ref<T> this[nuint index]
     public static implicit operator Ref2D<T>(T[][] array) =>
         SilkMarshal.JaggedArrayToPointerArray<T>(array);
 
+    /// <summary>
+    /// Expresses this <see cref="Ref2D{T}" /> as a <see cref="Ref"/>. Note that this does not index the
+    /// <see cref="Ref2D{T}"/>'s dimensions, and is effectively equivalent to converting a <c>void**</c> to a
+    /// <c>void*</c>.
+    /// </summary>
+    /// <param name="ptr">The <see cref="Ref2D{T}"/>.</param>
+    /// <returns>The <see cref="Ref"/>.</returns>
+    [MethodImpl(MethodImplOptions.AggressiveInlining | MethodImplOptions.AggressiveOptimization)]
+    public static implicit operator Ref(Ref2D<T> ptr) => new(ref ptr.InteriorRef);
+
     /// <summary>
     /// creates a <see cref="Ref2D{T}"/> from a reference array
     /// </summary>