Better module loading.

StgSharp.Common/Collections/SwissTable.cs

@@ -1,91 +1,81 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
-// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
-// file="SwissTable"
+// file="SwissTable"
-// Project: StgSharp
+// Project: StgSharp
-// AuthorGroup: Nitload
+// AuthorGroup: Nitload Space
-// Copyright (c) Nitload. All rights reserved.
+// Copyright (c) Nitload Space. All rights reserved.
-//     
+//     
-// Permission is hereby granted, free of charge, to any person obtaining a copy
+// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
+// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
+// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
+// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
+// furnished to do so, subject to the following conditions:
-//
+//
-// The above copyright notice and this permission notice shall be included in all
+// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
+// copies or substantial portions of the Software.
-//
+//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
+// SOFTWARE.
-//     
+//     
-// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
-// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
-using System;
+using System;
-using System.Numerics;
+using System.Numerics;
-using System.Runtime.CompilerServices;
+using System.Runtime.CompilerServices;
-using System.Runtime.Intrinsics.Arm;
+using System.Runtime.InteropServices;
-using System.Runtime.Intrinsics.X86;
+using System.Runtime.Intrinsics.Arm;
-
+using System.Runtime.Intrinsics.X86;
-namespace StgSharp.Collections
+
+namespace StgSharp.Collections
 {
-    /// <summary>
+    /// <summary>
-    ///
+    ///
     /// </summary>
-    public unsafe partial class SwissTable
+    public sealed unsafe partial class SwissTable
-    {
+    {
-
+
-        private const int BucketCount = 1 << EntryMaskWidth;
+        private const int BucketCount = 1 << EntryMaskWidth;
-        private const int BucketSize = 256;
+        private const int BucketSize = 256;
-        private const int EntryMaskWidth = 10; // 1024 entries total, 256 per bucket
+        private const int EntryMaskWidth = 10; // 1024 entries total, 256 per bucket
         public const int MaxCapacity = 1024 * BucketSize;   // 256 entries per bucket, 1024 buckets
 
-        private readonly Entry* _entries;
+        private readonly Entry* _entries;
-
+
-        private SwissTable(
+        private SwissTable(Entry* buffer)
-                Entry* buffer
+        {
-        )
+            _entries = buffer;
-        {
+            for (int i = 0; i < BucketCount; i++)
-            _entries = buffer;
+            {
-            for (int i = 0; i < BucketCount; i++)
+                // Set all control bytes to 0xFF (empty)
-            {
+                Unsafe.InitBlock(&_entries[i].Bucket.Control, 0xFF, BucketSize);
-                // Set all control bytes to 0xFF (empty)
+            }
-                Unsafe.InitBlock(&_entries[i].Bucket.Control, 0xFF, BucketSize);
+        }
-            }
+
-        }
+        public static SwissTable Create()
-
+        {
-        public bool TryAddOrSet(
+            Entry* buffer = (Entry*)NativeMemory.AlignedAlloc((nuint)Marshal.SizeOf<Entry>(), 16);
-                    nint key,
+            return new SwissTable(buffer);
-                    nint value
+        }
-        )
+
-        {
+        public bool TryAddOrSet(nint key, nint value, out bool isNewKey)
-            throw new NotImplementedException();
+        {
-        }
+            uint hash = BitOperations.Crc32C(0xffff9961, (ulong)key);
-
+            short entry = (short)(hash & ((1 << 11) - 1));
-        public bool TryAddOrSet(
+            Bucket* bucket = &_entries[entry].Bucket;
-                    nint key,
+            return IBucketScanner.Current.TrySet(key, hash, bucket, value, out isNewKey);
-                    ref nint value,
+        }
-                    out bool isNewKey
+
-        )
+        public bool TryGet(nint key, out nint value)
-        {
+        {
-            uint hash = BitOperations.Crc32C(0xffff9961, (ulong)key);
+            uint hash = BitOperations.Crc32C(0xffff9961, (ulong)key);
-            short entry = (short)(hash & ((1 << 11) - 1));
+            short entry = (short)(hash & ((1 << 11) - 1));
-            Bucket* bucket = &_entries[entry].Bucket;
+            Bucket* bucket = &_entries[entry].Bucket;
-            return IBucketScanner.Current.TrySet(key, hash, bucket, value, out isNewKey);
-        }
-
-        public bool TryGet(
-                    nint key,
-                    out nint value
-        )
-        {
-            uint hash = BitOperations.Crc32C(0xffff9961, (ulong)key);
-            short entry = (short)(hash & ((1 << 11) - 1));
-            Bucket* bucket = &_entries[entry].Bucket;
             return IBucketScanner.Current.TryFind(key, hash, bucket, out value);
             /*
             * hash = CRC32 of key
@@ -93,103 +83,89 @@ namespace StgSharp.Collections
             * ctrl  = 8-15 of hash
             * index = rest of hash
             * find value of hash
-            */
+            */
-        }
+        }
-
+
-        public bool TryRemove(
+        public bool TryRemove(nint key, out nint value)
-                    nint key,
+        {
-                    out nint value
+            uint hash = BitOperations.Crc32C(0xffff9961, (ulong)key);
-        )
+            short entry = (short)(hash & ((1 << 11) - 1));
-        {
+            Bucket* bucket = &_entries[entry].Bucket;
-            uint hash = BitOperations.Crc32C(0xffff9961, (ulong)key);
+            return IBucketScanner.Current.TryRemove(key, hash, bucket, out value);
-            short entry = (short)(hash & ((1 << 11) - 1));
+        }
-            Bucket* bucket = &_entries[entry].Bucket;
+
-            return IBucketScanner.Current.TryRemove(key, hash, bucket, out value);
+        ~SwissTable()
-        }
+        {
-
+            NativeMemory.AlignedFree(_entries);
-        [InlineArray(BucketCount)]
+        }
-        private struct Entry
+
-        {
+        [InlineArray(BucketCount)]
-
+        private struct Entry
-            public Bucket Bucket;
+        {
-
+
-        }
+            public Bucket Bucket;
-
+
-        private unsafe struct Bucket
+        }
-        {
+
-
+        private unsafe struct Bucket
-            public BucketControl Control;
+        {
-            public BucketKeyStorage Keys;
+
-            public BucketValueStorage Values;
+            public BucketControl Control;
-
+            public BucketKeyStorage Keys;
-        }
+            public BucketValueStorage Values;
-
+
-        private interface IBucketScanner
+        }
-        {
+
-
+        private interface IBucketScanner
-            static IBucketScanner Current { get; } = Create();
+        {
-
+
-            bool TryFind(
+            static IBucketScanner Current { get; } = Create();
-                 nint key,
+
-                 uint Hash,
+            bool TryFind(nint key, uint Hash, Bucket* bucket, out nint value);
-                 Bucket* bucket,
+
-                 out nint value
+            unsafe bool TryRemove(nint key, uint hash, Bucket* bucket, out nint value);
-            );
+
-
+            bool TrySet(nint key, uint hash, Bucket* bucket, nint value, out bool isNewKey);
-            unsafe bool TryRemove(
+
-                        nint key,
+            private static IBucketScanner Create()
-                        uint hash,
+            {
-                        Bucket* bucket,
+                if (X86Base.IsSupported)
-                        out nint value
+                {
-            );
+                    return new BucketScannerX86();
-
+                } else if (ArmBase.IsSupported)
-            bool TrySet(
+                {
-                 nint key,
+                    throw new NotSupportedException("ARM architecture is currently not supported for bucket scanning. Please use an x86 platform.");
-                 uint hash,
+                } else
-                 Bucket* bucket,
+                {
-                 nint value,
+                    throw new NotSupportedException("No suitable bucket scanner implementation found for the current platform.");
-                 out bool isNewKey
+                }
-            );
+            }
-
+
-            private static IBucketScanner Create()
+        }
-            {
+
-                if (X86Base.IsSupported)
+        [InlineArray(BucketSize)]
-                {
+        private struct BucketControl
-                    return new BucketScannerX86();
+        {
-                } else if (ArmBase.IsSupported)
+
-                {
+            public byte Control;
-                    throw new NotSupportedException("ARM architecture is currently not supported for bucket scanning. Please use an x86 platform.");
+
-                } else
+        }
-                {
+
-                    throw new NotSupportedException("No suitable bucket scanner implementation found for the current platform.");
+        [InlineArray(BucketSize)]
-                }
+        private struct BucketKeyStorage
-            }
+        {
-
+
-        }
+            public nint value;
-
+
-        [InlineArray(BucketSize)]
+        }
-        private struct BucketControl
+
-        {
+        [InlineArray(BucketSize)]
-
+        private struct BucketValueStorage
-            public byte Control;
+        {
-
+
-        }
+            public nint value;
-
+
-        [InlineArray(BucketSize)]
+        }
-        private struct BucketKeyStorage
+
-        {
+    }
-
-            public nint value;
-
-        }
-
-        [InlineArray(BucketSize)]
-        private struct BucketValueStorage
-        {
-
-            public nint value;
-
-        }
-
-    }
 }

StgSharp.Common/Environment/GlobalSetting.cs

@@ -1,27 +1,30 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
-// file="GlobalSetting"
+// file="GlobalSetting.cs"
 // Project: StgSharp
-// AuthorGroup: Nitload
+// AuthorGroup: Nitload Space
-// Copyright (c) Nitload. All rights reserved.
+// Copyright (c) Nitload Space. All rights reserved.
 //     
-// Permission is hereby granted, free of charge, to any person obtaining a copy
+// Permission is hereby granted, free of charge, to any person 
-// of this software and associated documentation files (the "Software"), to deal
+// obtaining a copy of this software and associated documentation 
-// in the Software without restriction, including without limitation the rights
+// files (the “Software”), to deal in the Software without restriction, 
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// including without limitation the rights to use, copy, modify, merge,
-// copies of the Software, and to permit persons to whom the Software is
+// publish, distribute, sublicense, and/or sell copies of the Software, 
-// furnished to do so, subject to the following conditions:
+// 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 above copyright notice and 
-//
+// this permission notice shall be included in all copies 
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// or substantial portions of the Software.
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//     
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// THE SOFTWARE IS PROVIDED “AS IS”, 
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-// SOFTWARE.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+// ARISING FROM, OUT OF OR IN CONNECTION WITH 
+// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //     
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
@@ -74,21 +77,6 @@ namespace StgSharp
 
         private static int _mainThreadID { get; set; } = -1;
 
-        /// <summary>
-        ///   CustomizeInit an instance of OpenGL program, This method should be called before any
-        ///   other World api.
-        /// </summary>
-        public static void InitGL(int majorVersion, int minorVersion)
-        {
-            if (API == default) {
-                API = GraphicAPI.GL;
-            }
-            if (API != GraphicAPI.GL) {
-                return;
-            }
-            GraphicFramework.InternalInitGL(majorVersion, minorVersion);
-        }
-
         public static class GlobalSetting
         {
 
@@ -99,7 +87,7 @@ namespace StgSharp
                 get => vsyncActivated;
                 set
                 {
-                    GraphicFramework.glfwSwapInterval(value ? 1 : 0);
+                    // GraphicFramework.glfwSwapInterval(value ? 1 : 0);
                     vsyncActivated = value;
                 }
             }

StgSharp.Common/Environment/IStaticModule.cs

@@ -2,8 +2,8 @@
 // -----------------------------------------------------------------------
 // file="IStaticModule"
 // Project: StgSharp
-// AuthorGroup: Nitload
+// AuthorGroup: Nitload Space
-// Copyright (c) Nitload. All rights reserved.
+// Copyright (c) Nitload Space. All rights reserved.
 //     
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -31,56 +31,254 @@ using System.Collections.Generic;
 
 namespace StgSharp
 {
+    /// <summary>
+    ///   Represents a statically activated module that can be registered and initialized as part of
+    ///   the application startup sequence, and gracefully torn down on shutdown.
+    /// </summary>
     public interface IStaticModule
     {
 
+        /// <summary>
+        ///   Gets the display name of this module, used for logging and diagnostics.
+        /// </summary>
         string ModuleName { get; }
 
-        void InitializeModule();
+        /// <summary>
+        ///   Performs all initialization work for this module using the provided profile.
+        /// </summary>
+        /// <param name="profile">
+        ///   The configuration profile supplied at registration time. Use <see
+        ///   cref="IModuleInitializeProfile.Empty" /> if no configuration is required.
+        /// </param>
+        void InitializeModule(IModuleInitializeProfile profile);
+
+        /// <summary>
+        ///   Releases all resources acquired during <see cref="InitializeModule" />. Implementations should
+        ///   be idempotent: calling this method more than once must not throw.
+        /// </summary>
+        void UninitializeModule();
 
     }
 
+    /// <summary>
+    ///   Marker interface for module initialization configuration. Implementations are plain data
+    ///   carriers; no static factory is required.
+    /// </summary>
+    public interface IModuleInitializeProfile
+    {
+
+        /// <summary>
+        ///   A shared, allocation-free empty profile for modules that require no configuration.
+        /// </summary>
+        static readonly IModuleInitializeProfile Empty = EmptyModuleInitializeProfile.Instance;
+
+        private sealed class EmptyModuleInitializeProfile : IModuleInitializeProfile
+        {
+
+            public static readonly EmptyModuleInitializeProfile Instance = new();
+
+            private EmptyModuleInitializeProfile() { }
+
+        }
+
+    }
+
+    /// <summary>
+    ///   Pairs an <see cref="IStaticModule" /> with its <see cref="IModuleInitializeProfile" />,
+    ///   ensuring the two are never stored or iterated independently.
+    /// </summary>
+    /// <remarks>
+    ///   Using a <see langword="readonly struct" /> avoids the boxing overhead that would occur if
+    ///   the pair were stored as two parallel lists of reference types.
+    /// </remarks>
+    public readonly struct ModuleDescriptor
+    {
+
+        /// <summary>
+        ///   Initializes a new <see cref="ModuleDescriptor" /> using <see
+        ///   cref="IModuleInitializeProfile.Empty" /> as the profile.
+        /// </summary>
+        public ModuleDescriptor(IStaticModule module) : this(module, IModuleInitializeProfile.Empty) { }
+
+        /// <summary>
+        ///   Initializes a new <see cref="ModuleDescriptor" /> with an explicit profile.
+        /// </summary>
+        public ModuleDescriptor(IStaticModule module, IModuleInitializeProfile profile)
+        {
+            Module = module;
+            Profile = profile;
+        }
+
+        /// <summary>
+        ///   Gets the configuration profile associated with the module.
+        /// </summary>
+        public IModuleInitializeProfile Profile { get; }
+
+        /// <summary>
+        ///   Gets the module to be initialized.
+        /// </summary>
+        public IStaticModule Module { get; }
+
+        /// <summary>
+        ///   Calls <see cref="IStaticModule.InitializeModule" /> with the stored profile.
+        /// </summary>
+        public void Initialize()
+        {
+            Module.InitializeModule(Profile);
+        }
+
+        /// <summary>
+        ///   Calls <see cref="IStaticModule.UninitializeModule" /> on the stored module.
+        /// </summary>
+        public void Uninitialize()
+        {
+            Module.UninitializeModule();
+        }
+
+    }
+
+    /// <summary>
+    ///   An ordered collection of modules to be initialized during application startup and
+    ///   uninitialized on shutdown. Supports three registration strategies so that the <c>new()</c>
+    ///   generic constraint is never a hard requirement.
+    /// </summary>
     public sealed class ModuleToInitializeCollection : IEnumerable<IStaticModule>, IStaticModule
     {
 
-        private readonly List<IStaticModule> _modules = [];
+        private readonly List<ModuleDescriptor> _descriptors = [];
 
-        internal ModuleToInitializeCollection(
+        internal ModuleToInitializeCollection(World.Initializer i)
-                 World.Initializer i
-        )
         {
-            _modules.Add(i);
+            _descriptors.Add(new ModuleDescriptor(i));
         }
 
+        // ── IEnumerable<IStaticModule> ───────────────────────────────────────────
+
+        /// <inheritdoc />
         public IEnumerator<IStaticModule> GetEnumerator()
         {
-            return ((IEnumerable<IStaticModule>)_modules).GetEnumerator();
+            foreach (ModuleDescriptor d in _descriptors) {
-        }
+                yield return d.Module;
-
-        public void InitializeModule()
-        {
-            foreach (IStaticModule module in _modules) {
-                module.InitializeModule();
             }
         }
 
-        public ModuleToInitializeCollection UseModule<T>() where T : IStaticModule, new()
+        // ── Initialization / Uninitialization ────────────────────────────────────
+
+        /// <summary>
+        ///   Initializes all registered modules in the order they were registered. Each module
+        ///   receives the profile that was supplied at registration time.
+        /// </summary>
+        public void InitializeModule()
         {
-            _modules.Add(new T());
+            for (int i = 0; i < _descriptors.Count; i++) {
+                _descriptors[i].Initialize();
+            }
+        }
+
+        /// <summary>
+        ///   Uninitializes all registered modules in <b> reverse </b> registration order, mirroring
+        ///   the typical LIFO teardown convention (e.g., GLFW must be unloaded after all subsystems
+        ///   that depend on it).
+        /// </summary>
+        public void UninitializeModule()
+        {
+            for (int i = _descriptors.Count - 1; i >= 0; i--) {
+                _descriptors[i].Uninitialize();
+            }
+        }
+
+        // ── Registration API ─────────────────────────────────────────────────────
+
+        /// <summary>
+        ///   Registers a module of type <typeparamref name="T" /> using its default constructor.
+        ///   This is the most concise overload for simple modules that expose a public
+        ///   parameterless constructor.
+        /// </summary>
+        /// <typeparam name="T">
+        ///   A concrete module type that implements <see cref="IStaticModule" /> and exposes a
+        ///   public parameterless constructor.
+        /// </typeparam>
+        /// <param name="profile">
+        ///   Optional initialization profile. Defaults to <see
+        ///   cref="IModuleInitializeProfile.Empty" /> when <see langword="null" />.
+        /// </param>
+        public ModuleToInitializeCollection UseModule<T>(IModuleInitializeProfile? profile = null)
+            where T: IStaticModule, new()
+        {
+            return UseModule(static() => new T(), profile);
+        }
+
+        /// <summary>
+        ///   Registers a module produced by a factory delegate. This overload imposes no generic
+        ///   constraints and supports any construction strategy, including dependency injection and
+        ///   parameterized constructors.
+        /// </summary>
+        /// <param name="factory">
+        ///   A delegate that constructs and returns the module instance. The delegate is invoked
+        ///   once, immediately at registration time. If <paramref name="factory" /> is <see
+        ///   langword="null" /> or returns <see langword="null" />, the call is silently ignored
+        ///   and the collection is returned unchanged.
+        /// </param>
+        /// <param name="profile">
+        ///   Optional initialization profile. Defaults to <see
+        ///   cref="IModuleInitializeProfile.Empty" /> when <see langword="null" />.
+        /// </param>
+        public ModuleToInitializeCollection UseModule(
+                                            Func<IStaticModule> factory,
+                                            IModuleInitializeProfile? profile = null)
+        {
+            if (factory is null) {
+                return this;
+            }
+            IStaticModule? mod = factory();
+            if (mod is null) {
+                return this;
+            }
+            _descriptors.Add(new ModuleDescriptor(
+                mod,
+                profile ?? IModuleInitializeProfile.Empty));
             return this;
         }
 
+        /// <summary>
+        ///   Registers a pre-existing module instance. Use this overload when the module is
+        ///   provided externally, such as from a DI container, an object pool, or a singleton.
+        /// </summary>
+        /// <param name="module">
+        ///   The module instance to register.
+        /// </param>
+        /// <param name="profile">
+        ///   Optional initialization profile. Defaults to <see
+        ///   cref="IModuleInitializeProfile.Empty" /> when <see langword="null" />.
+        /// </param>
+        public ModuleToInitializeCollection UseModule(IStaticModule module, IModuleInitializeProfile? profile = null)
+        {
+            _descriptors.Add(new ModuleDescriptor(
+                module,
+                profile ?? IModuleInitializeProfile.Empty));
+            return this;
+        }
+
+        /// <inheritdoc />
         IEnumerator IEnumerable.GetEnumerator()
         {
-            return ((IEnumerable)_modules).GetEnumerator();
+            return GetEnumerator();
         }
 
-        void IStaticModule.InitializeModule()
+        // ── IStaticModule explicit implementation ────────────────────────────────
+
+        /// <summary>
+        ///   Explicit <see cref="IStaticModule" /> implementation. Delegates to <see
+        ///   cref="InitializeModule()" />, ignoring the supplied profile because each contained module uses
+        ///   its own registered profile.
+        /// </summary>
+        void IStaticModule.InitializeModule(IModuleInitializeProfile profile)
         {
-            throw new NotImplementedException();
+            InitializeModule();
         }
 
+        /// <inheritdoc />
         string IStaticModule.ModuleName => "Module Initializer";
 
     }
-}
+}

StgSharp.Common/Environment/Platform.cs

@@ -58,29 +58,6 @@ namespace StgSharp
         private static uint markCount = 0;
         internal static GraphicAPI API = default;
 
-        public static unsafe int DefaultSIMDAlignment
-        {
-            get
-            {
-                SIMDID id = NativeIntrinsic.IntrinsicMask;
-                switch (id.MaskByte[0] & 0b_00001111)
-                {
-                    case 1:
-                        return id.MaskByte[1] switch
-                        {
-                            1 => 16,
-                            2 => 32,
-                            3 => 64,
-                            4 => 64,
-                            5 => 64,
-                            _ => 8,
-                        };
-                    default:
-                        return 8;
-                }
-            }
-        }
-
         public static ModuleToInitializeCollection Initialize()
         {
             return new ModuleToInitializeCollection(new Initializer());
@@ -122,7 +99,8 @@ namespace StgSharp
         public static void Terminate(int exitCode)
         {
             MainTimeProvider.StopProvidingTime();
-            GraphicFramework.glfwTerminate();
+
+            // GraphicFramework.glfwTerminate();
             Environment.Exit(exitCode);
         }
 
@@ -204,10 +182,6 @@ namespace StgSharp
         {
             // Initialize time provider and start providing time
             MainTimeProvider.StartProvidingTime();
-            GraphicFramework.LoadGlfw();
-            if (GraphicFramework.glfwInit() == 0) {
-                throw new Exception("Failed to init system graphic environment.");
-            }
             DefaultLog.InternalAppendLog("\n\n\n");
             DefaultLog.InternalWriteLog(
                 $"Program {Assembly.GetEntryAssembly()!.FullName} on {Environment.MachineName} Started.", LogType.Info);

StgSharp.Common/PipeLine/PipelineScheduler.cs

@@ -1,9 +1,9 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 // file="PipelineScheduler"
 // Project: StgSharp
-// AuthorGroup: Nitload
+// AuthorGroup: Nitload Space
-// Copyright (c) Nitload. All rights reserved.
+// Copyright (c) Nitload Space. All rights reserved.
 //     
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -25,8 +25,6 @@
 //     
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
-using StgSharp.Stg;
-
 using System;
 using System.Collections.Generic;
 using System.Diagnostics.CodeAnalysis;

StgSharp.Graphics/Environment/Monitor.cs

@@ -1,9 +1,9 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
-// file="Monitors"
+// file="Monitor"
 // Project: StgSharp
-// AuthorGroup: Nitload
+// AuthorGroup: Nitload Space
-// Copyright (c) Nitload. All rights reserved.
+// Copyright (c) Nitload Space. All rights reserved.
 //     
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -26,32 +26,34 @@
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 using System;
+using System.Collections.Generic;
+using System.Linq;
 using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
 
-namespace StgSharp
+namespace StgSharp.Graphics
 {
-    public static partial class World
+    public static class GraphicsEnvironment
     {
 
-        public static unsafe IntPtr[] MonitorsHandleArray
+        private static IntPtr[] _monitorsHandleArray;
+
+        public static unsafe ReadOnlySpan<IntPtr> MonitorsHandleArray
         {
             get
             {
-                if (MonitorsArray == null)
+                if (_monitorsHandleArray == null)
                 {
                     int count = 0;
                     IntPtr* arrayHandle = GraphicFramework.glfwGetMonitors(&count);
-                    MonitorsArray = new IntPtr[count];
+                    _monitorsHandleArray = new IntPtr[count];
-                    Marshal.Copy((IntPtr)arrayHandle, MonitorsArray, 0, count);
+                    Marshal.Copy((IntPtr)arrayHandle, _monitorsHandleArray, 0, count);
                     Marshal.FreeHGlobal((IntPtr)arrayHandle);
                 }
-                return MonitorsArray;
+                return _monitorsHandleArray;
             }
         }
 
-        public static nint[] MonitorsArray { get; set; } = [];
-
-        public static IntPtr DefaultMonitor => MonitorsHandleArray[0];
-
     }
 }

StgSharp.Graphics/GraphicInitializer.cs

@@ -0,0 +1,58 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="GraphicInitializer"
+// Project: StgSharp
+// AuthorGroup: Nitload Space
+// Copyright (c) Nitload Space. All rights reserved.
+//     
+// 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
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+
+using StgSharp;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics
+{
+    public class GraphicModuel : IStaticModule
+    {
+
+        public string ModuleName => "Graphics";
+
+        public void InitializeModule(IModuleInitializeProfile profile)
+        {
+            GraphicFramework.LoadGlfw();
+            if (GraphicFramework.glfwInit() == 0) {
+                throw new Exception("Failed to init system graphic environment.");
+            }
+        }
+
+        public void UninitializeModule()
+        {
+            GraphicFramework.glfwTerminate();
+        }
+
+    }
+}

StgSharp.Mathematics/Internal/MatrixPanel.cs

@@ -26,6 +26,7 @@
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 using StgSharp.Internal;
+using StgSharp.Mathematics.Internal;
 using System;
 using System.Numerics;
 using System.Runtime.CompilerServices;
@@ -92,7 +93,7 @@ namespace StgSharp.Mathematics
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         internal static int KernelSideCount<T>() where T: unmanaged, INumber<T>
         {
-            SIMDID id = NativeIntrinsic.IntrinsicMask;
+            SIMDID id = MathematicsModule.IntrinsicMask;
             switch (id.MaskByte[0] & 0b_00001111)
             {
                 case 1:
@@ -147,7 +148,7 @@ namespace StgSharp.Mathematics
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         private static int PanelSideLength<T>() where T: unmanaged, INumber<T>
         {
-            SIMDID id = NativeIntrinsic.IntrinsicMask;
+            SIMDID id = MathematicsModule.IntrinsicMask;
             switch (id.MaskByte[0] & 0b_00001111)
             {
                 case 1:

StgSharp.Mathematics/Internal/UnsafeCompute.cs

@@ -1,30 +1,27 @@
 //-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
-// file="UnsafeCompute.cs"
+// file="UnsafeCompute"
 // Project: StgSharp
 // AuthorGroup: Nitload Space
 // Copyright (c) Nitload Space. All rights reserved.
 //     
-// Permission is hereby granted, free of charge, to any person 
+// Permission is hereby granted, free of charge, to any person obtaining a copy
-// obtaining a copy of this software and associated documentation 
+// of this software and associated documentation files (the "Software"), to deal
-// files (the “Software”), to deal in the Software without restriction, 
+// in the Software without restriction, including without limitation the rights
-// including without limitation the rights to use, copy, modify, merge,
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// publish, distribute, sublicense, and/or sell copies of the Software, 
+// copies of the Software, and to permit persons to whom the Software is
-// and to permit persons to whom the Software is furnished to do so, 
+// furnished to do so, subject to the following conditions:
-// subject to the following conditions:
+//
-//     
+// The above copyright notice and this permission notice shall be included in all
-// The above copyright notice and 
+// copies or substantial portions of the Software.
-// 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,
-// THE SOFTWARE IS PROVIDED “AS IS”, 
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+// SOFTWARE.
-// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-// ARISING FROM, OUT OF OR IN CONNECTION WITH 
-// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //     
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
@@ -38,19 +35,19 @@ namespace StgSharp.Mathematics.Internal
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe int CityHashSimplify(char* span, int length)
         {
-            return NativeIntrinsic.Context.city_hash_simplify(span, length);
+            return MathematicsModule.GlobalContext.city_hash_simplify(span, length);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe int CityHashSimplify(char* span, int begin, int length)
         {
-            return NativeIntrinsic.Context.city_hash_simplify(span + begin, length);
+            return MathematicsModule.GlobalContext.city_hash_simplify(span + begin, length);
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public static unsafe int IndexOfCharPair(char* source, int pairValue, int length)
         {
-            return NativeIntrinsic.Context.index_pair(source, pairValue, length);
+            return MathematicsModule.GlobalContext.index_pair(source, pairValue, length);
         }
 
     }

StgSharp.Mathematics/Moduel.cs

@@ -1,6 +1,6 @@
 //-----------------------------------------------------------------------
 // -----------------------------------------------------------------------
-// file="intrinsicContextProvider"
+// file="Moduel"
 // Project: StgSharp
 // AuthorGroup: Nitload Space
 // Copyright (c) Nitload Space. All rights reserved.
@@ -25,55 +25,56 @@
 //     
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
-using StgSharp.Mathematics.Internal;
+using StgSharp.Mathematics.Internal;
-
 using System;
-using System.Reflection;
+using System.Collections.Generic;
+using System.Linq;
 using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
 
-namespace StgSharp.Mathematics.Internal
+namespace StgSharp.Mathematics
 {
-    internal static unsafe partial class NativeIntrinsic
+    public class MathematicsModule : IStaticModule
     {
 
-        private static readonly IntrinsicContext _intrinsicContext = new();
+        public static unsafe int DefaultSIMDAlignment
+        {
+            get
+            {
+                SIMDID id = GlobalIntrinsicMask;
+                switch (id.MaskByte[0] & 0b_00001111)
+                {
+                    case 1:
+                        return id.MaskByte[1] switch
+                        {
+                            1 => 16,
+                            2 => 32,
+                            3 => 64,
+                            4 => 64,
+                            5 => 64,
+                            _ => 8,
+                        };
+                    default:
+                        return 8;
+                }
+            }
+        }
 
-        public static SIMDID IntrinsicMask { get; set; }
+        public string ModuleName => "Mathematics";
 
-        internal static IntrinsicContext Context
+        internal static IntrinsicContext GlobalContext
         {
             [MethodImpl(MethodImplOptions.AggressiveInlining)]
-            get => _intrinsicContext;
+            get;
-        }
+        } = new();
-
+
-        /*
+        internal static SIMDID GlobalIntrinsicMask { get; set; }
-        internal static void InitIntrinsicContext()
+
-        {
+        public void InitializeModule()
-            ulong statCode = 0;
+        {
-
+            throw new NotImplementedException();
-            fixed (IntrinsicContext* cPtr = &_intrinsicContext) {
+        }
-                statCode = LoadIntrinsicFunction(cPtr);
+
-            }
-            SIMDID id = new()
-            {
-                Mask = statCode
-            };
-            switch (id.MaskByte[1])
-            {
-                case 0:
-                    Dialogue.PostError(new PlatformNotSupportedException("No SIMD instructions supported on current hardware platform"));
-                    Environment.Exit(-1);
-                    break;
-                default:
-                    break;
-            }
-            IntrinsicMask = id;
-        }
-
-        [LibraryImport(Native.LibName, EntryPoint = "load_intrinsic_function")]
-        [UnmanagedCallConv(CallConvs = [typeof(CallConvCdecl)])]
-        private static partial void LoadIntrinsicFunction(IntrinsicContext* context, ulong id);
-        /**/
     }
-}
+}

StgSharp.Mathematics/Numeric/Graphics/Matrix44.cs

@@ -167,7 +167,7 @@ namespace StgSharp.Mathematics.Graphics
         {
             const int f32 = 0;
             fixed (MatrixKernel<float>* source = &this.kernel, target = &transpose.kernel) {
-                NativeIntrinsic.Context.mat[f32].buffer_transpose(source, target);
+                MathematicsModule.GlobalContext.mat[f32].buffer_transpose(source, target);
             }
         }
 
@@ -176,7 +176,7 @@ namespace StgSharp.Mathematics.Graphics
         {
             Matrix44 ret = new();
             const int f32 = 0;
-            NativeIntrinsic.Context.mat[f32].buffer_sub(&left, &right, &ret, 1);
+            MathematicsModule.GlobalContext.mat[f32].buffer_sub(&left, &right, &ret, 1);
             return ret;
         }
 
@@ -197,7 +197,7 @@ namespace StgSharp.Mathematics.Graphics
         {
             Matrix44 ret = new();
             int f32 = (int)MatrixElementType.F32;
-            NativeIntrinsic.Context.mat[f32].kernel_fma(&left, &right, &ret);
+            MathematicsModule.GlobalContext.mat[f32].kernel_fma(&left, &right, &ret);
             return ret;
         }
 
@@ -206,7 +206,7 @@ namespace StgSharp.Mathematics.Graphics
         {
             Matrix44 ret = new();
             const int f32 = 0;
-            NativeIntrinsic.Context.mat[f32].buffer_add(&left, &right, &ret, 1);
+            MathematicsModule.GlobalContext.mat[f32].buffer_add(&left, &right, &ret, 1);
             return ret;
         }
 

StgSharp.Mathematics/Numeric/MatrixCompute.Factorize.cs

@@ -2,8 +2,8 @@
 // -----------------------------------------------------------------------
 // file="MatrixCompute.Factorize"
 // Project: StgSharp
-// AuthorGroup: Nitload
+// AuthorGroup: Nitload Space
-// Copyright (c) Nitload. All rights reserved.
+// Copyright (c) Nitload Space. All rights reserved.
 //     
 // Permission is hereby granted, free of charge, to any person obtaining a copy
 // of this software and associated documentation files (the "Software"), to deal
@@ -41,8 +41,7 @@ namespace StgSharp.Mathematics.Numeric
                                   Matrix<float> matrix,
                                   Span<int> pivot,
                                   Matrix<float> lower,
-                                  Matrix<float> upper
+                                  Matrix<float> upper)
-        )
         {
             if (matrix.ColumnLength != matrix.RowLength) {
                 throw new InvalidOperationException("Matrix must be square.");
@@ -54,14 +53,10 @@ namespace StgSharp.Mathematics.Numeric
             if (pivot.Length < n) {
                 throw new ArgumentException("Pivot span length is insufficient.", nameof(pivot));
             }
-            if (lower.RowLength != n ||
+            if (lower.RowLength != n || lower.ColumnLength != n || lower.Layout != MatrixLayout.UpperTriangle) {
-                lower.ColumnLength != n ||
-                lower.Layout != MatrixLayout.UpperTriangle) {
                 throw new ArgumentException("Lower matrix must be lower-triangular with same dimensions as input.", nameof(lower));
             }
-            if (upper.RowLength != n ||
+            if (upper.RowLength != n || upper.ColumnLength != n || upper.Layout != MatrixLayout.UpperTriangle) {
-                upper.ColumnLength != n ||
-                upper.Layout != MatrixLayout.UpperTriangle) {
                 throw new ArgumentException("Upper matrix must be upper-triangular with same dimensions as input.", nameof(upper));
             }
 
@@ -77,9 +72,8 @@ namespace StgSharp.Mathematics.Numeric
                 ulong* pivots = stackalloc ulong[4];
                 for (int kBlock = 0; kBlock < n; kBlock += 4)
                 {
-                    NativeIntrinsic.Context
+                    MathematicsModule.GlobalContext
-                                   .mat[(int)MatrixElementType.F32].pivot(matrix.Buffer,
+                                   .mat[(int)MatrixElementType.F32].pivot(matrix.Buffer, (ulong)(kBlock >> 2),
-                                                                          (ulong)(kBlock >> 2),
                                                                           (ulong)(matrix.KernelRowLength - (kBlock >> 2)),
                                                                           (ulong)pivots);
                     int colsInBlock = Math.Min(4, n - kBlock);

StgSharp.Mathematics/Numeric/MatrixCompute.Float.cs

@@ -57,7 +57,7 @@ namespace StgSharp.Mathematics.Numeric
                 MatrixKernel<float>* leftPtr = left.Buffer;
                 MatrixKernel<float>* rightPtr = right.Buffer;
                 MatrixKernel<float>* ansPtr = ans.Buffer;
-                NativeIntrinsic.Context.mat[f32].buffer_add(leftPtr, rightPtr, ansPtr, count);
+                MathematicsModule.GlobalContext.mat[f32].buffer_add(leftPtr, rightPtr, ansPtr, count);
 
                 return;
             } else if (count <= 1024)
@@ -67,7 +67,7 @@ namespace StgSharp.Mathematics.Numeric
                 MatrixKernel<float>* leftPtr = left.Buffer;
                 MatrixKernel<float>* rightPtr = right.Buffer;
                 MatrixKernel<float>* ansPtr = ans.Buffer;
-                NativeIntrinsic.Context.mat[f32].buffer_add(leftPtr, rightPtr, ansPtr, count);
+                MathematicsModule.GlobalContext.mat[f32].buffer_add(leftPtr, rightPtr, ansPtr, count);
 
                 MatrixParallel.ReturnParallelResources(ref pool);
                 return;
@@ -80,7 +80,7 @@ namespace StgSharp.Mathematics.Numeric
             package->PrimCount = ans.KernelColumnLength;
             package->SecCount = ans.KernelRowLength;
             package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.LEFT_RIGHT_ANS_PARAM);
-            package->ComputeHandle = (IntPtr)NativeIntrinsic.Context.mat[f32].buffer_add;
+            package->ComputeHandle = (IntPtr)MathematicsModule.GlobalContext.mat[f32].buffer_add;
             MatrixParallelWrap taskGroup = MatrixParallel.ScheduleTask(package);
 
             taskGroup.LaunchParallel(SleepMode.DeepSleep);
@@ -96,12 +96,12 @@ namespace StgSharp.Mathematics.Numeric
             scalar->Data<float>(0) = value;
             if (count <= 256)
             {
-                NativeIntrinsic.Context.mat[f32].buffer_fill(ans.Buffer, scalar, count);
+                MathematicsModule.GlobalContext.mat[f32].buffer_fill(ans.Buffer, scalar, count);
                 return;
             } else if (count <= 1024)
             {
                 MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1);
-                NativeIntrinsic.Context.mat[f32].buffer_fill(ans.Buffer, scalar, count);
+                MathematicsModule.GlobalContext.mat[f32].buffer_fill(ans.Buffer, scalar, count);
                 MatrixParallel.ReturnParallelResources(ref pool);
                 return;
             }
@@ -111,7 +111,7 @@ namespace StgSharp.Mathematics.Numeric
             package->PrimCount = ans.KernelColumnLength;
             package->SecCount = ans.KernelRowLength;
             package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.ANS_SCALAR_PARAM);
-            package->ComputeHandle = (IntPtr)NativeIntrinsic.Context.mat[f32].buffer_fill;
+            package->ComputeHandle = (IntPtr)MathematicsModule.GlobalContext.mat[f32].buffer_fill;
             package->Scalar = scalar;
             MatrixParallelWrap taskGroup = MatrixParallel.ScheduleTask(package);
             taskGroup.LaunchParallel(SleepMode.DeepSleep);
@@ -154,7 +154,7 @@ namespace StgSharp.Mathematics.Numeric
                         enumeration->Member<int>(0) = i;
                         enumeration->Member<int>(1) = j;
 
-                        NativeIntrinsic.Context
+                        MathematicsModule.GlobalContext
                                            .mat[f32].kernel_tile_fma((MatrixKernel*)left.Buffer,
                                                                      (MatrixKernel*)right.Buffer,
                                                                      (MatrixKernel*)ans.Buffer, enumeration);
@@ -200,7 +200,7 @@ namespace StgSharp.Mathematics.Numeric
             {
                 MatrixKernel<float>* leftPtr = left.Buffer;
                 MatrixKernel<float>* ansPtr = ans.Buffer;
-                NativeIntrinsic.Context.mat[f32].buffer_scalar_mul(leftPtr, ansPtr, scalar, count);
+                MathematicsModule.GlobalContext.mat[f32].buffer_scalar_mul(leftPtr, ansPtr, scalar, count);
 
                 return;
             } else if (count <= 1024)
@@ -209,7 +209,7 @@ namespace StgSharp.Mathematics.Numeric
 
                 MatrixKernel<float>* leftPtr = left.Buffer;
                 MatrixKernel<float>* ansPtr = ans.Buffer;
-                NativeIntrinsic.Context.mat[f32].buffer_scalar_mul(leftPtr, ansPtr, scalar, count);
+                MathematicsModule.GlobalContext.mat[f32].buffer_scalar_mul(leftPtr, ansPtr, scalar, count);
 
                 MatrixParallel.ReturnParallelResources(ref pool);
                 return;
@@ -222,7 +222,7 @@ namespace StgSharp.Mathematics.Numeric
             package->SecCount = left.KernelRowLength;
             package->Scalar = scalar;
             package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.RIGHT_ANS_SCALAR_PARAM);
-            package->ComputeHandle = (IntPtr)NativeIntrinsic.Context.mat[f32].buffer_scalar_mul;
+            package->ComputeHandle = (IntPtr)MathematicsModule.GlobalContext.mat[f32].buffer_scalar_mul;
             MatrixParallelWrap taskGroup = MatrixParallel.ScheduleTask(package);
 
             taskGroup.LaunchParallel(SleepMode.DeepSleep);
@@ -251,7 +251,7 @@ namespace StgSharp.Mathematics.Numeric
                 MatrixKernel<float>* leftPtr = left.Buffer;
                 MatrixKernel<float>* rightPtr = right.Buffer;
                 MatrixKernel<float>* ansPtr = ans.Buffer;
-                NativeIntrinsic.Context.mat[f32].buffer_sub(leftPtr, rightPtr, ansPtr, count);
+                MathematicsModule.GlobalContext.mat[f32].buffer_sub(leftPtr, rightPtr, ansPtr, count);
 
                 return;
             } else if (count <= 1024)
@@ -261,7 +261,7 @@ namespace StgSharp.Mathematics.Numeric
                 MatrixKernel<float>* leftPtr = left.Buffer;
                 MatrixKernel<float>* rightPtr = right.Buffer;
                 MatrixKernel<float>* ansPtr = ans.Buffer;
-                NativeIntrinsic.Context.mat[f32].buffer_sub(leftPtr, rightPtr, ansPtr, count);
+                MathematicsModule.GlobalContext.mat[f32].buffer_sub(leftPtr, rightPtr, ansPtr, count);
 
                 MatrixParallel.ReturnParallelResources(ref pool);
                 return;
@@ -274,7 +274,7 @@ namespace StgSharp.Mathematics.Numeric
             package->PrimCount = left.KernelColumnLength;
             package->SecCount = left.KernelRowLength;
             package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.LEFT_RIGHT_ANS_PARAM);
-            package->ComputeHandle = (IntPtr)NativeIntrinsic.Context.mat[f32].buffer_sub;
+            package->ComputeHandle = (IntPtr)MathematicsModule.GlobalContext.mat[f32].buffer_sub;
             MatrixParallelWrap taskGroup = MatrixParallel.ScheduleTask(package);
 
             taskGroup.LaunchParallel(SleepMode.DeepSleep);

StgSharp.Mathematics/Numeric/MatrixCompute.double.cs

@@ -53,7 +53,7 @@ namespace StgSharp.Mathematics.Numeric
                 MatrixKernel<double>* leftPtr = left.Buffer;
                 MatrixKernel<double>* rightPtr = right.Buffer;
                 MatrixKernel<double>* ansPtr = ans.Buffer;
-                NativeIntrinsic.Context.mat[f64].buffer_add(leftPtr, rightPtr, ansPtr, count);
+                MathematicsModule.GlobalContext.mat[f64].buffer_add(leftPtr, rightPtr, ansPtr, count);
 
                 return;
             } else if (count <= 1024)
@@ -63,7 +63,7 @@ namespace StgSharp.Mathematics.Numeric
                 MatrixKernel<double>* leftPtr = left.Buffer;
                 MatrixKernel<double>* rightPtr = right.Buffer;
                 MatrixKernel<double>* ansPtr = ans.Buffer;
-                NativeIntrinsic.Context.mat[f64].buffer_add(leftPtr, rightPtr, ansPtr, count);
+                MathematicsModule.GlobalContext.mat[f64].buffer_add(leftPtr, rightPtr, ansPtr, count);
 
                 MatrixParallel.ReturnParallelResources(ref pool);
                 return;
@@ -76,7 +76,7 @@ namespace StgSharp.Mathematics.Numeric
             package->PrimCount = ans.KernelColumnLength;
             package->SecCount = ans.KernelRowLength;
             package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.LEFT_RIGHT_ANS_PARAM);
-            package->ComputeHandle = (IntPtr)NativeIntrinsic.Context.mat[f64].buffer_add;
+            package->ComputeHandle = (IntPtr)MathematicsModule.GlobalContext.mat[f64].buffer_add;
             MatrixParallelWrap taskGroup = MatrixParallel.ScheduleTask(package);
 
             taskGroup.LaunchParallel(SleepMode.DeepSleep);
@@ -92,12 +92,12 @@ namespace StgSharp.Mathematics.Numeric
             scalar->Data<double>(0) = value;
             if (count <= 256)
             {
-                NativeIntrinsic.Context.mat[f64].buffer_fill(ans.Buffer, scalar, count);
+                MathematicsModule.GlobalContext.mat[f64].buffer_fill(ans.Buffer, scalar, count);
                 return;
             } else if (count <= 1024)
             {
                 MatrixParallelThread[] pool = MatrixParallel.LeadParallel(1);
-                NativeIntrinsic.Context.mat[f64].buffer_fill(ans.Buffer, scalar, count);
+                MathematicsModule.GlobalContext.mat[f64].buffer_fill(ans.Buffer, scalar, count);
                 MatrixParallel.ReturnParallelResources(ref pool);
                 return;
             }
@@ -107,7 +107,7 @@ namespace StgSharp.Mathematics.Numeric
             package->PrimCount = ans.KernelColumnLength;
             package->SecCount = ans.KernelRowLength;
             package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.ANS_SCALAR_PARAM);
-            package->ComputeHandle = (IntPtr)NativeIntrinsic.Context.mat[f64].buffer_fill;
+            package->ComputeHandle = (IntPtr)MathematicsModule.GlobalContext.mat[f64].buffer_fill;
             package->Scalar = scalar;
             MatrixParallelWrap taskGroup = MatrixParallel.ScheduleTask(package);
             taskGroup.LaunchParallel(SleepMode.DeepSleep);
@@ -144,7 +144,7 @@ namespace StgSharp.Mathematics.Numeric
                         enumeration->Member<int>(0) = i;
                         enumeration->Member<int>(1) = j;
 
-                        NativeIntrinsic.Context
+                        MathematicsModule.GlobalContext
                                            .mat[f64].kernel_tile_fma((MatrixKernel*)left.Buffer,
                                                                      (MatrixKernel*)right.Buffer,
                                                                      (MatrixKernel*)ans.Buffer, enumeration);
@@ -189,7 +189,7 @@ namespace StgSharp.Mathematics.Numeric
             {
                 MatrixKernel<double>* leftPtr = left.Buffer;
                 MatrixKernel<double>* ansPtr = ans.Buffer;
-                NativeIntrinsic.Context.mat[f64].buffer_scalar_mul(leftPtr, ansPtr, scalar, count);
+                MathematicsModule.GlobalContext.mat[f64].buffer_scalar_mul(leftPtr, ansPtr, scalar, count);
 
                 return;
             } else if (count <= 1024)
@@ -198,7 +198,7 @@ namespace StgSharp.Mathematics.Numeric
 
                 MatrixKernel<double>* leftPtr = left.Buffer;
                 MatrixKernel<double>* ansPtr = ans.Buffer;
-                NativeIntrinsic.Context.mat[f64].buffer_scalar_mul(leftPtr, ansPtr, scalar, count);
+                MathematicsModule.GlobalContext.mat[f64].buffer_scalar_mul(leftPtr, ansPtr, scalar, count);
 
                 MatrixParallel.ReturnParallelResources(ref pool);
                 return;
@@ -211,7 +211,7 @@ namespace StgSharp.Mathematics.Numeric
             package->SecCount = left.KernelRowLength;
             package->Scalar = scalar;
             package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.RIGHT_ANS_SCALAR_PARAM);
-            package->ComputeHandle = (IntPtr)NativeIntrinsic.Context.mat[f64].buffer_scalar_mul;
+            package->ComputeHandle = (IntPtr)MathematicsModule.GlobalContext.mat[f64].buffer_scalar_mul;
             MatrixParallelWrap taskGroup = MatrixParallel.ScheduleTask(package);
 
             taskGroup.LaunchParallel(SleepMode.DeepSleep);
@@ -240,7 +240,7 @@ namespace StgSharp.Mathematics.Numeric
                 MatrixKernel<double>* leftPtr = left.Buffer;
                 MatrixKernel<double>* rightPtr = right.Buffer;
                 MatrixKernel<double>* ansPtr = ans.Buffer;
-                NativeIntrinsic.Context.mat[f64].buffer_sub(leftPtr, rightPtr, ansPtr, count);
+                MathematicsModule.GlobalContext.mat[f64].buffer_sub(leftPtr, rightPtr, ansPtr, count);
 
                 return;
             } else if (count <= 1024)
@@ -250,7 +250,7 @@ namespace StgSharp.Mathematics.Numeric
                 MatrixKernel<double>* leftPtr = left.Buffer;
                 MatrixKernel<double>* rightPtr = right.Buffer;
                 MatrixKernel<double>* ansPtr = ans.Buffer;
-                NativeIntrinsic.Context.mat[f64].buffer_sub(leftPtr, rightPtr, ansPtr, count);
+                MathematicsModule.GlobalContext.mat[f64].buffer_sub(leftPtr, rightPtr, ansPtr, count);
 
                 MatrixParallel.ReturnParallelResources(ref pool);
                 return;
@@ -263,7 +263,7 @@ namespace StgSharp.Mathematics.Numeric
             package->PrimCount = left.KernelColumnLength;
             package->SecCount = left.KernelRowLength;
             package->ComputeMode = new MatrixOpMode(MatrixIndexStyle.BUFFER_INDEX, MatrixOperationParam.LEFT_RIGHT_ANS_PARAM);
-            package->ComputeHandle = (IntPtr)NativeIntrinsic.Context.mat[f64].buffer_sub;
+            package->ComputeHandle = (IntPtr)MathematicsModule.GlobalContext.mat[f64].buffer_sub;
             MatrixParallelWrap taskGroup = MatrixParallel.ScheduleTask(package);
 
             taskGroup.LaunchParallel(SleepMode.DeepSleep);

StgSharp.Mathematics/Numeric/Runtime/MatrixParallelThread.Fma.cs

@@ -62,7 +62,8 @@ namespace StgSharp.Mathematics.Numeric
                 int j = (int)(c % ansHeight);
                 enumeration->Member<int>(0) = i;
                 enumeration->Member<int>(1) = j;
-                NativeIntrinsic.Context.mat[f32].kernel_tile_fma(leftBuffer, rightBuffer, ansBuffer, enumeration);
+                MathematicsModule.GlobalContext.mat[f32].kernel_tile_fma(leftBuffer, rightBuffer, ansBuffer,
+                                                                         enumeration);
             }
         }
 
@@ -91,7 +92,8 @@ namespace StgSharp.Mathematics.Numeric
                 int j = (int)(c % ansHeight);
                 enumeration->Member<int>(0) = i;
                 enumeration->Member<int>(1) = j;
-                NativeIntrinsic.Context.mat[f64].kernel_tile_fma(leftBuffer, rightBuffer, ansBuffer, enumeration);
+                MathematicsModule.GlobalContext.mat[f64].kernel_tile_fma(leftBuffer, rightBuffer, ansBuffer,
+                                                                         enumeration);
             }
         }
 

StgSharp.Mathematics/Numeric/Scalar/Factorial.cs

@@ -1,68 +1,67 @@
-//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
-// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
-// file="Factorial"
+// file="Factorial"
-// Project: StgSharp
+// Project: StgSharp
-// AuthorGroup: Nitload
+// AuthorGroup: Nitload Space
-// Copyright (c) Nitload. All rights reserved.
+// Copyright (c) Nitload Space. All rights reserved.
-//     
+//     
-// Permission is hereby granted, free of charge, to any person obtaining a copy
+// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
+// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
+// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
+// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
+// furnished to do so, subject to the following conditions:
-//
+//
-// The above copyright notice and this permission notice shall be included in all
+// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
+// copies or substantial portions of the Software.
-//
+//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
+// SOFTWARE.
-//     
+//     
-// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
-// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
-using System;
+using System;
-
+
-namespace StgSharp.Mathematics
+namespace StgSharp.Mathematics
-{
+{
-    public static partial class Scalar
+    public static partial class Scalar
-    {
+    {
-
+
-        private static readonly uint[] factorialResult = [
+        private static readonly uint[] factorialResult = [
-            1,
+            1,
-            1,
+            1,
-            2,
+            2,
-            6,
+            6,
-            24,
+            24,
-            120,
+            120,
-            720,
+            720,
-            5040,
+            5040,
-            40320,
+            40320,
-            362880,
+            362880,
-            3628800,
+            3628800,
-            39916800,
+            39916800,
-            479001600
+            479001600];
-        ];
+
-
+        public static unsafe ulong Factorial(int n)
-        public static unsafe ulong Factorial(int n)
+        {
-        {
+            ArgumentOutOfRangeException.ThrowIfLessThan(n, 0);
-            ArgumentOutOfRangeException.ThrowIfLessThan(n, 0);
+            if (n < 13) {
-            if (n < 13) {
+                return factorialResult[n];
-                return factorialResult[n];
+            }
-            }
+            if (n < 30) {
-            if (n < 30) {
+                return MathematicsModule.GlobalContext.factorial_simd(n);
-                return NativeIntrinsic.Context.factorial_simd(n);
+            }
-            }
             double 
                 dn = n,
                 stir = Sqrt(2 * PiDouble * dn) * Pow(dn / EDouble, dn),
-                correction = Exp(1 / (12 * dn));
+                correction = Exp(1 / (12 * dn));
-            return (ulong)(stir * correction);
+            return (ulong)(stir * correction);
-        }
+        }
-
+
-    }
+    }
 }

StgSharp.Native/sn-src/check.ps1

@@ -1,25 +0,0 @@
-# 1. 版本 — 已确认 18.1.8
-clang-format --version
-
-# 2. 不可见字符扫描 — 用完整路径
-$file = Join-Path $PWD "simdid.x86.c"
-$bytes = [System.IO.File]::ReadAllBytes($file)
-
-for ($i = 0; $i -lt $bytes.Length - 2; $i++) {
-    if ($bytes[$i] -eq 0xEF -and $bytes[$i+1] -eq 0xBB -and $bytes[$i+2] -eq 0xBF) {
-        Write-Host "BOM found at offset $i"
-    }
-    if ($bytes[$i] -eq 0xC2 -and $bytes[$i+1] -eq 0xA0) {
-        Write-Host "NBSP at offset $i"
-    }
-    if ($bytes[$i] -eq 0xE2 -and $bytes[$i+1] -eq 0x80 -and
-        ($bytes[$i+2] -eq 0x8B -or $bytes[$i+2] -eq 0x8C -or $bytes[$i+2] -eq 0x8D)) {
-        Write-Host "Zero-width char at offset $i"
-    }
-}
-
-Write-Host "Scan complete. File size: $($bytes.Length) bytes"
-
-# 3. 格式化对比 — 用 fc.exe 避免 PowerShell 的 Format-Custom 歧义
-clang-format -assume-filename=test.c $file > formatted.c
-fc.exe $file formatted.c

StgSharpDebug/Program.cs

@@ -26,6 +26,7 @@
 // -----------------------------------------------------------------------
 // -----------------------------------------------------------------------
 using StgSharp.Common.Timing;
+using StgSharp.Graphics;
 using StgSharp.Internal;
 using StgSharp.Mathematics;
 using StgSharp.Mathematics.Memory;
@@ -48,8 +49,9 @@ namespace StgSharp
                 // TestRegexAnalyse.Run();
 
                 // HlsfStressTest.Run();
+                TestSwiss();
 
-                TestMatrix();
+                // TestMatrix();
 
 
                 /*

StgSharpDebug/StgSharpDebug.csproj

@@ -11,6 +11,7 @@
 
     <ItemGroup>
       <ProjectReference Include="..\StgSharp.Common\StgSharp.Common.csproj" />
+      <ProjectReference Include="..\StgSharp.Graphics\StgSharp.Graphics.csproj" />
       <ProjectReference Include="..\StgSharp.Mathematics\StgSharp.Mathematics.csproj" />
       <ProjectReference Include="..\StgSharp.Model\StgSharp.Model.csproj" />
       <ProjectReference Include="..\StgSharp.RegularAnalysis\StgSharp.RegularAnalysis.csproj" />

StgSharpDebug/TestRender.cs

@@ -1,37 +1,35 @@
-//-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-//     file="TestRender.cs"
+// -----------------------------------------------------------------------
-//     Project: StgSharp
+// file="TestRender.cs"
-//     AuthorGroup: Nitload Space
+// Project: StgSharp
-//     Copyright (c) Nitload Space. All rights reserved.
+// AuthorGroup: Nitload Space
+// Copyright (c) Nitload Space. All rights reserved.
 //     
-//     Permission is hereby granted, free of charge, to any person 
+// Permission is hereby granted, free of charge, to any person 
-//     obtaining a copy of this software and associated documentation 
+// obtaining a copy of this software and associated documentation 
-//     files (the “Software”), to deal in the Software without restriction, 
+// files (the “Software”), to deal in the Software without restriction, 
-//     including without limitation the rights to use, copy, modify, merge,
+// including without limitation the rights to use, copy, modify, merge,
-//     publish, distribute, sublicense, and/or sell copies of the Software, 
+// publish, distribute, sublicense, and/or sell copies of the Software, 
-//     and to permit persons to whom the Software is furnished to do so, 
+// and to permit persons to whom the Software is furnished to do so, 
-//     subject to the following conditions:
+// subject to the following conditions:
 //     
-//     The above copyright notice and 
+// The above copyright notice and 
-//     this permission notice shall be included in all copies 
+// this permission notice shall be included in all copies 
-//     or substantial portions of the Software.
+// or substantial portions of the Software.
 //     
-//     THE SOFTWARE IS PROVIDED “AS IS”, 
+// THE SOFTWARE IS PROVIDED “AS IS”, 
-//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+// WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
-//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+// INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
-//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
-//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
-//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
-//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+// ARISING FROM, OUT OF OR IN CONNECTION WITH 
-//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+// THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 //     
-//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
-//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
 using StgSharp.Collections;
-using StgSharp.MVVM;
+using StgSharp.Graphics;
-using StgSharp.MVVM.ViewModel;
-
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -45,19 +43,19 @@ namespace StgSharp
 
         public static void TestRender()
         {
-            World.InitGL( 4, 6 );
+            // World.InitGL(4, 6);
             World.GlobalSetting.VSyncActivated = false;
 
-            ViewPort vp = new ViewPort( 800, 600, "Hello StgSharp!", IntPtr.Zero );
+            ViewPort vp = new ViewPort(800, 600, "Hello StgSharp!", IntPtr.Zero);
 
-            //throw new NotImplementedException();
+            // throw new NotImplementedException();
+            /*
+            ViewModelBase mainModel = new ViewModelMain(vp);
+            mainModel.CreateAndBindView<ViewMain>("MainView", (1, 1, 1));
 
-            ViewModelBase mainModel = new ViewModelMain( vp );
+            mainModel.UseViewModel("MainView");
-            mainModel.CreateAndBindView<ViewMain>( "MainView", (1, 1, 1) );
+            /**/
-
+            World.Terminate(0);
-            mainModel.UseViewModel( "MainView" );
-
-            World.Terminate( 0 );
         }
 
     }

StgSharpDebug/TestSwiss.cs

@@ -0,0 +1,64 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="TestSwiss"
+// Project: StgSharp
+// AuthorGroup: Nitload Space
+// Copyright (c) Nitload Space. All rights reserved.
+//     
+// 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
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using StgSharp.Collections;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Security.Cryptography.X509Certificates;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp
+{
+    internal static partial class Program
+    {
+
+        public static void TestSwiss()
+        {
+            SwissTable swiss = SwissTable.Create();
+            for (int i = 0; i < 10000; i++)
+            {
+                _ = swiss.TryAddOrSet(i, i * 2, out _);
+                Console.WriteLine($"Set a kvp of ({i},{i * 2})");
+            }
+            Random rand = new Random();
+            for (int i = 0; i < 10000; i++)
+            {
+                int key = rand.Next(0, 10000);
+                if (swiss.TryGet(key, out nint value))
+                {
+                    Console.WriteLine($"Get a kvp of ({key},{value})");
+                } else
+                {
+                    Console.WriteLine($"Failed to get a kvp of ({key},?)");
+                }
+            }
+        }
+
+    }
+}