daily update on 20240828 by nitload youmu, autotexture added

源代码/StgSharpDebug/Logic/Blueprint/Blueprint.cs

@@ -29,7 +29,7 @@
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
 using StgSharp;
-using StgSharp.Logic;
+
 
 using System;
 using System.Collections.Generic;
@@ -43,35 +43,72 @@ using System.Threading;
 using System.Threading.Tasks;
 using System.Xml.Serialization;
 
-namespace StgSharp.Logic
+namespace StgSharp.BluePrint
 {
+    /// <summary>
+    /// A sets of complex logic designed for running in multi threads environment.
+    /// Warning: do not run a <see cref="Blueprint"/> instance in multi threads more than once.
+    /// 
+    /// </summary>
     public partial class Blueprint : IConvertableToBlueprintNode
     {
+
         private BeginningNode beginNode;
         private Dictionary<string, BlueprintNode> allNode;
         private EndingNode endNode;
-        private Func<bool> terminate;
 
-        private int currentNodeIndex;
-        private List<Task> allThread;
+        private Func<bool> terminate;
+        private List<BlueprintNode> globalNodeList;
         private List<BlueprintNode> nativeNodeList;
-        private List<BlueprintNode> nodeList;
+
+        private SemaphoreSlim runningStat;
+
+        internal int currentGlobalNodeIndex;
+        internal int currentNativeNodeIndex;
 
         public Blueprint()
         {
             allNode = new Dictionary<string, BlueprintNode>();
-            allThread = new List<Task>();
-            nodeList = new List<BlueprintNode>();
+            globalNodeList = new List<BlueprintNode>();
             nativeNodeList = new List<BlueprintNode>();
-            terminate = () => true;
-            beginNode = new BeginningNode();
-            endNode = new EndingNode();
+            runningStat = new SemaphoreSlim(1, 1);
+            beginNode = new BeginningNode(this);
+            endNode = new EndingNode(this);
         }
 
         public BlueprintNode BeginLayer => beginNode;
         public BlueprintNode EndLayer => endNode;
 
-        public bool IsRunning => allThread.Any(t => t.Status == TaskStatus.Running);
+        public bool IsRunning
+        {
+            get => runningStat.CurrentCount == 0;
+        }
+
+        /**/
+        internal Func<bool> ShouldClose
+        {
+            get => terminate;
+            set => terminate = value;
+        }
+
+        internal SemaphoreSlim RunningStat
+        {
+            get => runningStat;
+        }
+        /**/
+
+        public void AddNode(BlueprintNode node, bool isNative)
+        {
+            _ = node ?? throw new ArgumentNullException(nameof(node));
+            node.IsNative = isNative;
+            allNode.Add(node.Name, node);
+        }
+
+        public void ExecuteMain(in Dictionary<string, BlueprintPipeline> input,
+                    in Dictionary<string, BlueprintPipeline> output)
+        {
+            BlueprintRunner.Run(this, () => true);
+        }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
         public (string name, BlueprintPipelineArgs arg)[] GetOutput()
@@ -79,115 +116,21 @@ namespace StgSharp.Logic
             return endNode.OutputData;
         }
 
-        public void Init(int threadCount)
+        public void Init()
         {
-            if (threadCount > nodeList.Count)
+            foreach (KeyValuePair<string, BlueprintNode> item in allNode)
             {
-                InternalIO.InternalWriteLog(
-                    "Thread setting error: amount of threads of this blueprint is larger than amount of nodes.", LogType.Warning);
-                threadCount = nodeList.Count;
-            }
-            if (threadCount!=0)
-            {
-                foreach (var item in allNode)
+                if (item.Value.IsNative)
                 {
-                    if (item.Value.IsNative)
-                    {
-                        nativeNodeList.Add(item.Value);
-                    }
-                    else
-                    {
-                        nodeList.Add(item.Value);
-                    }
+                    nativeNodeList.Add(item.Value);
                 }
-                nativeNodeList.Sort();
-                PrepareTasks(threadCount);
-            }
-            else
-            {
-                foreach (var item in allNode)
+                else
                 {
-                    nodeList.Add(item.Value);
+                    globalNodeList.Add(item.Value);
                 }
             }
-            nodeList.Sort();
-        }
-
-        public void PrepareTasks(int count)
-        {
-            for (int i = 0; i < count; i++)
-            {
-                allThread.Add(new Task(IndividualTask));
-            }
-        }
-
-        private void IndividualTask()
-        {
-            do
-            {
-                BlueprintNode node;
-                while (RequestNextNode(out node))
-                {
-                    node.Run();
-                }
-            } while (!terminate());
-        }
-
-        /// <summary>
-        /// Run all nodes repeatedly until it is instructed to terminate.
-        /// </summary>
-        /// <param name="terminateInstructor">Instructor to terminate all tasks. Returns <see langword="true"/> if tasks should terminate</param>
-        public void RunRepeatedly(Func<bool> terminateInstructor)
-        {
-            if (allThread.Count != 0)
-            {
-                MultiThreadRun(terminateInstructor);
-                return;
-            }
-            SingleThreadRun(terminateInstructor);
-        }
-
-        private void MultiThreadRun(Func<bool> terminateInstructor)
-        {
-            if (terminate != terminateInstructor)
-            {
-                terminate = terminateInstructor;
-                if (allThread.Count != 0)
-                {
-                    foreach (var t in allThread)
-                    {
-                        t.Start();
-                    }
-                }
-            }
-            beginNode.Run();
-            foreach (var node in nativeNodeList)
-            {
-                node.Run();
-            }
-            EndLayer.Run();
-        }
-
-        private void SingleThreadRun(Func<bool> terminateInstructor)
-        {
-            beginNode.Run();
-            foreach (var item in nodeList)
-            {
-                item.Run();
-            }
-            EndLayer.Run();
-        }
-
-        public void AddNativeNode(BlueprintNode node)
-        {
-            node.IsNative = true;
-            allNode.Add(node.Name, node);
-        }
-
-        public void AddAsyncNode(BlueprintNode node)
-        {
-            node.IsNative = false;
-            allNode.Add(node.Name, node);
+            nativeNodeList.Sort();
+            globalNodeList.Sort();
         }
 
         [MethodImpl(MethodImplOptions.AggressiveInlining)]
@@ -196,59 +139,47 @@ namespace StgSharp.Logic
             beginNode.InputData = parameters;
         }
 
-        private bool RequestNextNode(out BlueprintNode node)
+        public void Terminate()
         {
-            if (currentNodeIndex < nodeList.Count)
+            Interlocked.Exchange(ref currentGlobalNodeIndex, int.MaxValue);
+            Interlocked.Exchange(ref currentNativeNodeIndex, int.MaxValue);
+        }
+
+        internal bool RequestNexGlobalNode(out BlueprintNode node)
+        {
+            if (currentGlobalNodeIndex < globalNodeList.Count)
             {
-                BlueprintNode ret = nodeList[currentNodeIndex];
-                Interlocked.Increment(ref currentNodeIndex);
-                node =  ret;
+                node = globalNodeList[currentGlobalNodeIndex];
+                Interlocked.Increment(ref currentGlobalNodeIndex);
+                return true;
+            }
+            node = default!;
+            return false;
+        }
+
+        internal bool RequestNextNativeNode(out BlueprintNode node)
+        {
+
+            if (currentNativeNodeIndex < nativeNodeList.Count)
+            {
+                node = nativeNodeList[currentNativeNodeIndex];
+                Interlocked.Increment(ref currentNativeNodeIndex);
                 return true;
             }
-            Interlocked.Exchange(ref currentNodeIndex, 0);
             node = default!;
             return false;
         }
 
         string[] IConvertableToBlueprintNode.InputInterfacesName
         {
-            get 
-            {
-                return beginNode.OutputInterfaces.Select(
-                    p => p.Key).ToArray();
-            }
-        }
-
-        BlueprintNodeAction IConvertableToBlueprintNode.MainExecution
-        {
-            get 
-            {
-                return (in Dictionary<string, BlueprintPipeline> input,
-                    in Dictionary<string, BlueprintPipeline> output)
-                    =>
-                {
-                    beginNode.Run();
-                    foreach (var node in nativeNodeList)
-                    {
-                        node.Run();
-                    }
-                    endNode.Run();
-                };
-            }
+            get { return beginNode.OutputInterfaces.Select(p => p.Key).ToArray(); }
         }
 
         string[] IConvertableToBlueprintNode.OutputInterfacesName
         {
-            get
-            {
-                return beginNode.OutputInterfaces.Select(
-                    p => p.Key).ToArray();
-            }
+            get { return beginNode.OutputInterfaces.Select(p => p.Key).ToArray(); }
         }
-    }
-
-    internal class NodeClearException : Exception
-    {
 
     }
+
 }

源代码/StgSharpDebug/Logic/Blueprint/BlueprintActionNode.cs

@@ -1,6 +1,6 @@
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-//     file="Exception.cs"
+//     file="BlueprintActionNode.cs"
 //     Project: StgSharp
 //     AuthorGroup: Nitload Space
 //     Copyright (c) Nitload Space. All rights reserved.
@@ -28,7 +28,7 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Graphics;
+
 
 using System;
 using System.Collections.Generic;
@@ -36,6 +36,28 @@ using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
 
-namespace StgSharp.Logic
+namespace StgSharp.BluePrint
 {
-}
+    public class BlueprintActionNode : IConvertableToBlueprintNode
+    {
+
+        private string[] inPorts;
+        private string[] outPorts;
+        private Action<Dictionary<string, BlueprintPipeline>, Dictionary<string, BlueprintPipeline>> mainAction;
+
+        internal BlueprintActionNode()
+        {
+
+        }
+
+        public string[] InputInterfacesName => inPorts;
+
+        public string[] OutputInterfacesName => outPorts;
+
+        public void ExecuteMain(in Dictionary<string, BlueprintPipeline> input, in Dictionary<string, BlueprintPipeline> output)
+        {
+            mainAction?.Invoke(input, output);
+        }
+
+    }
+}

源代码/StgSharpDebug/Logic/Blueprint/BlueprintNode.cs

@@ -35,18 +35,15 @@ using StgSharp.Entities;
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
 using System.Runtime.Serialization;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace StgSharp.Logic
+namespace StgSharp.BluePrint
 {
-    public delegate void BlueprintNodeAction(
-        in Dictionary<string, BlueprintPipeline> inpput,
-        in Dictionary<string, BlueprintPipeline> output);
-
-
 
     /// <summary>
     /// 
@@ -59,83 +56,62 @@ namespace StgSharp.Logic
     public class BlueprintNode : IComparable<BlueprintNode>
 #pragma warning restore CA1036
     {
-        private BlueprintNodeAction mainOperation;
 
         private protected bool levelAvailable, nativeRequested;
-        private protected int _level;
-        private string name;
-
         private protected Dictionary<string, BlueprintPipeline> _inputInterfaces;
         private protected Dictionary<string, BlueprintPipeline> _outputInterfaces;
-        
+        private protected int _level;
+        private IConvertableToBlueprintNode mainOperation;
+        private string name;
 
         internal BlueprintNode(string name,
-            BlueprintNodeAction operation, bool isNative,
-            string[] inputPorts,
-            string[] outputPorts)
+            IConvertableToBlueprintNode node, bool isNative)
         {
             this.levelAvailable = false;
             this.name = name;
             nativeRequested = isNative;
-            mainOperation = operation;
+            mainOperation = node;
             _inputInterfaces = new Dictionary<string, BlueprintPipeline>();
             _outputInterfaces = new Dictionary<string, BlueprintPipeline>();
-            if (inputPorts.Length == 0 )
+            foreach (string portName in node.InputInterfacesName)
             {
-                throw new ArgumentNullException(nameof(inputPorts));
+                _inputInterfaces.Add(portName, null!);
             }
-            if (outputPorts.Length == 0)
+
+            foreach (string portName in node.OutputInterfacesName)
             {
-                throw new ArgumentNullException(nameof(outputPorts));
-            }
-            foreach (var portName in inputPorts)
-            {
-                _inputInterfaces.Add(portName, null);
-            }
-            foreach (var portName in outputPorts)
-            {
-                _outputInterfaces.Add(portName, null);
+                _outputInterfaces.Add(portName, null!);
             }
         }
 
 
-        public BlueprintNode(string name, IConvertableToBlueprintNode convertable)
-        {
-            this.levelAvailable = false;
-            this.name = name;
-            _inputInterfaces = new Dictionary<string, BlueprintPipeline>();
-            _outputInterfaces = new Dictionary<string, BlueprintPipeline>();
-            mainOperation = convertable.MainExecution;
-            foreach (var soket in convertable.InputInterfacesName)
-            {
-                _inputInterfaces.Add(soket, null);
-            }
-            foreach (var soket in convertable.OutputInterfacesName)
-            {
-                _outputInterfaces.Add(soket, null);
-            }
-        }
-
-        public BlueprintNode(string name,
+#pragma warning disable CS8618
+        internal BlueprintNode(string name, bool isNative,
             string[] inputPorts,
             string[] outputPorts
             )
+#pragma warning restore CS8618
         {
-            this.levelAvailable = false;
+            if ((inputPorts == null) || (inputPorts.Length == 0))
+            {
+                throw new ArgumentNullException(nameof(inputPorts));
+            }
+            if ((outputPorts == null) || (outputPorts.Length == 0))
+            {
+                throw new ArgumentNullException(nameof(outputPorts));
+            }
+            levelAvailable = false;
             this.name = name;
+            IsNative = isNative;
             _inputInterfaces = new Dictionary<string, BlueprintPipeline>();
             _outputInterfaces = new Dictionary<string, BlueprintPipeline>();
-            if (inputPorts.Length * outputPorts.Length == 0)
+            foreach (string portName in inputPorts)
             {
-                throw new Exception();
+                _inputInterfaces.Add(portName, null!);
             }
-            foreach (var portName in inputPorts)
+            foreach (string portName in outputPorts)
             {
-                _inputInterfaces.Add(portName, null);
-            }
-            foreach (var portName in outputPorts)
-            {
-                _outputInterfaces.Add(portName, null);
+                _outputInterfaces.Add(portName, null!);
             }
         }
 
@@ -154,7 +130,7 @@ namespace StgSharp.Logic
                     return _level;
                 }
                 _level = 0;
-                foreach (var item in _inputInterfaces)
+                foreach (KeyValuePair<string, BlueprintPipeline> item in _inputInterfaces)
                 {
                     if (item.Value == null)
                     {
@@ -175,6 +151,11 @@ namespace StgSharp.Logic
         internal Dictionary<string, BlueprintPipeline> InputInterfaces => _inputInterfaces;
         internal Dictionary<string, BlueprintPipeline> OutputInterfaces => _outputInterfaces;
 
+        internal IConvertableToBlueprintNode Value
+        {
+            get => mainOperation;
+        }
+
 
         public void AddAfter(
             BlueprintNode former,
@@ -213,21 +194,6 @@ namespace StgSharp.Logic
             SetCertainOutputPort(thisOutputPortName, pipeline);
         }
 
-
-        public void Run()
-        {
-            try
-            {
-                //Console.WriteLine(name);
-                BlueprintPipeline.WaitAll(_inputInterfaces);
-                mainOperation(in _inputInterfaces, in _outputInterfaces);
-            }
-            catch (Exception)
-            {
-                throw;
-            }
-        }
-
         public int CompareTo(BlueprintNode other)
         {
 #pragma warning disable CA1062
@@ -235,12 +201,30 @@ namespace StgSharp.Logic
 #pragma warning restore CA1062
         }
 
+
+        public virtual void Run()
+        {
+            try
+            {
+                //Console.WriteLine(name);
+                BlueprintPipeline.WaitAll(_inputInterfaces);
+                if (mainOperation != null)
+                {
+                    mainOperation.ExecuteMain(in _inputInterfaces, in _outputInterfaces);
+                }
+            }
+            catch (Exception)
+            {
+                throw;
+            }
+        }
+
         #region port operation
 
         public BlueprintPipeline GetCertainInputPort(string name)
         {
             BlueprintPipeline ret;
-            if (!_inputInterfaces.TryGetValue(name,out ret))
+            if (!_inputInterfaces.TryGetValue(name, out ret))
             {
                 throw new Exception($"Cannot find the interface named {name} in node {Name}.");
             }
@@ -281,17 +265,15 @@ namespace StgSharp.Logic
 
     }//--------------------------------- end of class -----------------------------------
 
-    public interface IConvertableToBlueprintNode
-    {
 
-        public string[] InputInterfacesName { get; }
-        public BlueprintNodeAction MainExecution { get; }
-        public string[] OutputInterfacesName { get; }
-
-    }
 
     public class BlueprintNodeRunException : Exception
     {
+
+        protected BlueprintNodeRunException(SerializationInfo info, StreamingContext context) : base(info, context)
+        {
+        }
+
         public BlueprintNodeRunException()
         {
         }
@@ -308,9 +290,6 @@ namespace StgSharp.Logic
         {
         }
 
-        protected BlueprintNodeRunException(SerializationInfo info, StreamingContext context) : base(info, context)
-        {
-        }
     }
 
 }

源代码/StgSharpDebug/Logic/Blueprint/BlueprintRunner.cs

@@ -0,0 +1,234 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="BlueprintRunner.cs"
+//     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 System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Data;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+using StgSharp.Threading;
+
+namespace StgSharp.BluePrint
+{
+    public static class BlueprintRunner
+    {
+
+        private static NodeRunner[] allAvailableTask = new NodeRunner[1];
+        private static CancellationTokenSource cts = new CancellationTokenSource();
+        private static ConcurrentStack<Blueprint> blueprintInWaiting = new ConcurrentStack<Blueprint>();
+        private static int _callingThread;
+        private static SemaphoreSlim bpLock = new SemaphoreSlim(0, 1);
+
+        internal static bool IsValidCalling
+        {
+            get
+            {
+                if ((NodeRunner.CurrentBlueprint == null) || //no bp running at all
+                    ((blueprintInWaiting.Count == 0) && (NodeRunner.CurrentBlueprint.IsRunning == false)))  // a bp is quiting
+                {
+                    //in case no bp is running
+                    return true;
+                }
+                int? id = Task.CurrentId;
+                if (id is null)
+                {
+                    // in case calling from main thread and current running bp
+                    //Console.WriteLine($"\t{_callingThread}");
+                    //Console.WriteLine($"\t{Thread.CurrentThread.ManagedThreadId}");
+                    return _callingThread == Thread.CurrentThread.ManagedThreadId;
+                }
+                foreach (NodeRunner item in allAvailableTask)
+                {
+                    if (item.Id == id)
+                    {
+                        //if calling from any bp running task
+                        return true;
+                    }
+                }
+                return false;
+            }
+        }
+
+        public static void Run(Blueprint blueprint, Func<bool> terminateInstructor)
+        {
+            //Console.WriteLine();
+            if (blueprint == null)
+            {
+                return;
+            }
+
+            if (terminateInstructor == null)
+            {
+                throw new ArgumentNullException(nameof(terminateInstructor));
+            }
+            if (blueprint.IsRunning)
+            {
+                throw new InvalidOperationException("Attempt to run a blueprint instance twice.");
+            }
+            blueprint.ShouldClose = terminateInstructor;
+            if (IsValidCalling)
+            {
+                //Console.WriteLine("valid and run");
+                if (InterruptAndRunNewBp(blueprint))
+                {
+                    do { } while (InterruptAndRunNewBp(NodeRunner.CurrentBlueprint));
+                }
+            }
+            else
+            {
+                bpLock.Wait();
+                if (InterruptAndRunNewBp(blueprint))
+                {
+                    do { } while (InterruptAndRunNewBp(NodeRunner.CurrentBlueprint));
+                }
+
+                bpLock.Release();
+            }
+            Interlocked.Exchange(ref _callingThread, -1);
+        }
+
+
+        public static void SetMaxTaskCount(int size)
+        {
+            if (size < 1)
+            {
+                size = 1;
+            }
+            if (allAvailableTask.Length >= size)
+            {
+                for (int i = size; i < allAvailableTask.Length; i++)
+                {
+                    if (allAvailableTask[i] != null)
+                    {
+                        allAvailableTask[i].Cancel();
+                    }
+                }
+            }
+            Array.Resize(ref allAvailableTask, size);
+        }
+
+        public static void Terminate()
+        {
+            cts.Cancel();
+            NodeRunner.CurrentBlueprint.Terminate();
+            foreach (NodeRunner task in allAvailableTask)
+            {
+                task.Cts.Cancel();
+            }
+            foreach (Blueprint bp in blueprintInWaiting)
+            {
+                bp.Terminate();
+            }
+            blueprintInWaiting.Clear();
+        }
+
+        internal static bool InterruptAndRunNewBp(Blueprint newBp)
+        {
+            Debug.Assert(newBp != null);
+            if ((newBp != NodeRunner.CurrentBlueprint) && (NodeRunner.CurrentBlueprint != null))
+            {
+                //if a running bp exists
+                blueprintInWaiting.Push(NodeRunner.CurrentBlueprint);
+            }
+            //load new bp to current bp
+            Interlocked.Exchange(ref NodeRunner.CurrentBlueprint!, newBp);
+            Interlocked.Exchange(ref _callingThread, Thread.CurrentThread.ManagedThreadId);
+            //run beginning node to init it first.
+            if (!NodeRunner.CurrentBlueprint.IsRunning)
+            {
+                (NodeRunner.CurrentBlueprint.BeginLayer as BeginningNode)!.Run();
+            }
+            //refresh all tasks
+            for (int i = 0; i < allAvailableTask.Length; i++)
+            {
+                NodeRunner item = allAvailableTask[i];
+                if ((item is null) || item.IsCompleted)
+                {
+                    allAvailableTask[i] = NodeRunner.Run();
+                }
+            }
+            BlueprintNode node;
+            while (!cts.Token.IsCancellationRequested
+                && NodeRunner.CurrentBlueprint.RequestNextNativeNode(out node))
+            {
+                node.Run();
+                if (!NodeRunner.CurrentBlueprint.IsRunning)
+                {
+                    break;
+                }
+            }
+            (NodeRunner.CurrentBlueprint.EndLayer as EndingNode)!.Run();
+            return blueprintInWaiting.TryPeek(out NodeRunner.CurrentBlueprint);
+        }
+
+    }
+
+    internal class NodeRunner : CancellableTask
+    {
+
+        private static Blueprint _current;
+
+        internal NodeRunner() : base()
+        {
+            _startup = InternalRun;
+        }
+
+        internal static ref Blueprint CurrentBlueprint
+        {
+            get => ref _current;
+        }
+
+        internal static NodeRunner Run()
+        {
+            NodeRunner ret = new NodeRunner { _startup = InternalRun };
+            ret.taskInternal = Task.Run(ret.InternalAction);
+            return ret;
+        }
+
+        private static void InternalRun(CancellationToken token)
+        {
+            //Console.WriteLine("Task Begin");
+            BlueprintNode item;
+            while ((CurrentBlueprint != null) && CurrentBlueprint.IsRunning && !token.IsCancellationRequested
+                && CurrentBlueprint.RequestNexGlobalNode(out item))
+            {
+                //Console.WriteLine($"Get node of {item.Name}, going to run.");
+                item.Run();
+            }
+            //Console.WriteLine("Task Completed");
+        }
+
+    }//------------------------------------- End of Class ------------------------------------------
+}

源代码/StgSharpDebug/Logic/Blueprint/BpNodeActionAttribute.cs

@@ -0,0 +1,72 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="BpNodeActionAttribute.cs"
+//     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 System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.BluePrint
+{
+
+    [AttributeUsage(AttributeTargets.Method)]
+    public sealed class BpNodeActionAttribute : Attribute
+    {
+
+        private string[] _input;
+        private string[] _output;
+        private int _operationSpan;
+
+        public BpNodeActionAttribute(int operationSpan)
+        {
+            _input = Array.Empty<string>();
+            _output = Array.Empty<string>();
+            _operationSpan = operationSpan;
+        }
+
+        public BpNodeActionAttribute(string[] inputPort, string[] outputPort)
+        {
+            _input = inputPort;
+            _output = outputPort;
+            this._operationSpan = 1;
+        }
+
+        public BpNodeActionAttribute(string[] inputPort, string[] outputPort, int operationSpan)
+        {
+            _input = inputPort;
+            _output = outputPort;
+            this._operationSpan = operationSpan;
+        }
+
+        public string[] InputPort => _input;
+        public string[] OutputPort => _output;
+        public int OperationSpan => _operationSpan;
+
+    }
+}

源代码/StgSharpDebug/Logic/Blueprint/BpNodeBuilder.cs

@@ -0,0 +1,71 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="BpNodeBuilder.cs"
+//     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 System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.BluePrint
+{
+    public static class BpNodeConverter
+    {
+
+        public static IConvertableToBlueprintNode AsBlueprintNodeMainExecution(this BlueprintNodeOperation startUp)
+        {
+            if (startUp == null)
+            {
+                throw new ArgumentNullException(nameof(startUp));
+            }
+            object[] attributeArray = startUp.Method.GetCustomAttributes(typeof(BpNodeActionAttribute), false);
+            BpNodeActionAttribute attri = (BpNodeActionAttribute)attributeArray[0];
+            if ((attributeArray.Length < 0) || (attri == null))
+            {
+                throw new InvalidCastException($"Delegate {nameof(startUp)} is not marked by {typeof(BpNodeActionAttribute)}");
+            }
+            return new DefaultConvertableToBlueprintNode(startUp, attri.InputPort, attri.OutputPort);
+        }
+
+        public static IConvertableToBlueprintNode AsBlueprintNodeMainExecution(this Action startUp)
+        {
+            if (startUp == null)
+            {
+                throw new ArgumentNullException(nameof(startUp));
+            }
+            object[] attributeArray = startUp.Method.GetCustomAttributes(typeof(BpNodeActionAttribute), false);
+            BpNodeActionAttribute attri = (BpNodeActionAttribute)attributeArray[0];
+            if ((attributeArray.Length < 0) || (attri == null))
+            {
+                throw new InvalidCastException($"Delegate {nameof(startUp)} is not marked by {typeof(BpNodeActionAttribute)}");
+            }
+            return new CrossFrameOperation(startUp, attri.OperationSpan);
+        }
+
+    }
+}

源代码/StgSharpDebug/Logic/Blueprint/CrossCycleProcess.cs

@@ -1,21 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace StgSharp.Logic
-{
-    /*
-    public class CrossCycleProcess:BlueprintNode
-    {
-
-        public CrossCycleProcess(string name, Action operation)
-            :base()
-        {
-            
-        }
-
-    }
-    /**/
-}

源代码/StgSharpDebug/Logic/Blueprint/CrossFrameBlueprintNode.cs

@@ -0,0 +1,83 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="CrossFrameBlueprintNode.cs"
+//     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.BluePrint;
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace StgSharp.BluePrint
+{
+    public class CrossFrameOperation : IConvertableToBlueprintNode
+    {
+
+        private int currentCount;
+
+        private readonly int cycleCount;
+
+        public CrossFrameOperation(Action startup, int cycleCount)
+        {
+            MainExecution = startup;
+            this.cycleCount = (cycleCount > 1) ? cycleCount : throw new ArgumentException(
+                $"{$"The {typeof(CrossFrameOperation).Name} crosses only one cycle, "}{$"please use a {typeof(BlueprintNode).Name} instead."}");
+            this.cycleCount = cycleCount;
+            currentCount = cycleCount;
+        }
+
+        public Action MainExecution { get; private protected set; }
+
+        public static string InputInterfacesName => "TaskIn";
+
+        public static string OutputInterfacesName => "TaskOut";
+
+        public void ExecuteMain(in Dictionary<string, BlueprintPipeline> input, in Dictionary<string, BlueprintPipeline> output)
+        {
+            if (currentCount < cycleCount)
+            {
+                Interlocked.Increment(ref currentCount);
+            }
+            else
+            {
+                Interlocked.Exchange(ref currentCount, 0);
+                Task.Run(MainExecution);
+            }
+            //Console.WriteLine(currentCount);
+            BlueprintPipeline.SkipAll(output);
+        }
+
+        string[] IConvertableToBlueprintNode.InputInterfacesName => [InputInterfacesName];
+
+        string[] IConvertableToBlueprintNode.OutputInterfacesName => [OutputInterfacesName];
+
+    }
+}

源代码/StgSharpDebug/Logic/Blueprint/IConvertableToBlueprintNode.cs

@@ -0,0 +1,84 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="IConvertableToBlueprintNode.cs"
+//     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 System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace StgSharp.BluePrint
+{
+
+    public delegate void BlueprintNodeOperation(in Dictionary<string, BlueprintPipeline> input, in Dictionary<string, BlueprintPipeline> output);
+
+    public interface IConvertableToBlueprintNode
+    {
+
+#pragma warning disable CA1819 
+        public string[] InputInterfacesName { get; }
+#pragma warning restore CA1819 
+
+#pragma warning disable CA1819
+        public string[] OutputInterfacesName { get; }
+#pragma warning restore CA1819
+
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ExecuteMain(
+        in Dictionary<string, BlueprintPipeline> input,
+        in Dictionary<string, BlueprintPipeline> output);
+
+    }
+
+    internal class DefaultConvertableToBlueprintNode : IConvertableToBlueprintNode
+    {
+
+        private string[] _input;
+        private string[] _output;
+        private BlueprintNodeOperation _execution;
+
+        public DefaultConvertableToBlueprintNode(BlueprintNodeOperation execution, string[] input, string[] output)
+        {
+            _input = input;
+            _output = output;
+            _execution = execution;
+        }
+
+        void IConvertableToBlueprintNode.ExecuteMain(in Dictionary<string, BlueprintPipeline> input, in Dictionary<string, BlueprintPipeline> output)
+        {
+            _execution(in input, in output);
+        }
+
+        string[] IConvertableToBlueprintNode.InputInterfacesName => _input;
+
+        string[] IConvertableToBlueprintNode.OutputInterfacesName => _output;
+
+    }
+}

源代码/StgSharpDebug/Logic/Blueprint/PipeLine.cs

@@ -32,12 +32,13 @@ using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Numerics;
+using System.Runtime.CompilerServices;
 using System.Security.Authentication.ExtendedProtection;
 using System.Text;
 using System.Threading;
 using System.Threading.Tasks;
 
-namespace StgSharp.Logic
+namespace StgSharp.BluePrint
 {
 
     public class BlueprintPipeline
@@ -59,26 +60,13 @@ namespace StgSharp.Logic
 
         public BlueprintNode Former => former;
 
-        public int Level => former.Level;
-
         public BlueprintPipelineArgs Args
         {
             get => args;
             set => args = value;
         }
 
-        public void CompleteAndSkip()
-        {
-            //Console.WriteLine($"Complete\t{former.ContextName}\t->\t{after.ContextName}");
-            formerCompleteSemaphore.Release();
-        }
-
-        public void CompleteAndWriteData(BlueprintPipelineArgs args)
-        {
-            this.args = args;
-            //Console.WriteLine($"Complete\t{former.ContextName}\t->\t{after.ContextName}");
-            formerCompleteSemaphore.Release();
-        }
+        public int Level => former.Level;
 
         public static void SkipAll(Dictionary<string, BlueprintPipeline> ports)
         {
@@ -86,9 +74,9 @@ namespace StgSharp.Logic
             {
                 throw new ArgumentNullException(nameof(ports));
             }
-            foreach (var item in ports)
+            foreach (KeyValuePair<string, BlueprintPipeline> item in ports)
             {
-                if (item.Value!=null)
+                if (item.Value != null)
                 {
                     item.Value.CompleteAndSkip();
                 }
@@ -101,9 +89,9 @@ namespace StgSharp.Logic
             {
                 throw new ArgumentNullException(nameof(ports));
             }
-            foreach (var item in ports)
+            foreach (KeyValuePair<string, BlueprintPipeline> item in ports)
             {
-                if (item.Value!=null)
+                if (item.Value != null)
                 {
                     item.Value.WaitForStart();
                 }
@@ -116,10 +104,36 @@ namespace StgSharp.Logic
             formerCompleteSemaphore.Wait();
         }
 
+        ~BlueprintPipeline()
+        {
+            formerCompleteSemaphore.Dispose();
+        }
+
+        #region pipline op
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CompleteAndSkip()
+        {
+            //Console.WriteLine($"Complete\t{former.Name}\t->\t{after.Name}");
+            formerCompleteSemaphore.Release();
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CompleteAndWriteData(BlueprintPipelineArgs args)
+        {
+            this.args = args;
+            CompleteAndSkip();
+        }
+
+        #endregion
+
+
+
     }
 
     public abstract class BlueprintPipelineArgs
     {
+
         public object? Value { get; set; }
 
     }

源代码/StgSharpDebug/Logic/Blueprint/RouteSwitch.cs

@@ -35,14 +35,15 @@ using System.Reflection.Emit;
 using System.Security.Cryptography.X509Certificates;
 using System.Text;
 
-namespace StgSharp.Logic
+namespace StgSharp.BluePrint
 {
     public class RouteSwitch : BlueprintNode
     {
+
         private protected Dictionary<string, (BlueprintPipeline pipeline, Func<bool> openingRule)> outputDictionary;
 
-        public RouteSwitch(string name, string inputPorts) :
-            base(name, [inputPorts], [string.Empty])
+        public RouteSwitch(string name, bool isNative, string inputPorts) :
+            base(name, isNative, [inputPorts], [string.Empty])
         {
             outputDictionary = new Dictionary<string, (BlueprintPipeline pipeline, Func<bool> openingRule)>();
         }
@@ -111,72 +112,4 @@ namespace StgSharp.Logic
 
     }
 
-
-    public sealed class RouteHub : BlueprintNode
-    {
-
-        private Dictionary<string, (BlueprintPipeline pipeline, Func<bool> controllingFunc)> inputDictionary;
-
-        public RouteHub(string name, string[] inputPorts, string[] outputPorts) : base(name, inputPorts, outputPorts)
-        {
-            inputDictionary = new Dictionary<string, (BlueprintPipeline pipeline, Func<bool> controllingFunc)>();
-        }
-
-
-        public new int Level
-        {
-            get
-            {
-                if (levelAvailable)
-                {
-                    return _level;
-                }
-                _level = 0;
-                foreach (KeyValuePair<string, BlueprintPipeline> item in _inputInterfaces)
-                {
-                    if (item.Value == null)
-                    {
-                        continue;
-                    }
-                    if (_level <= item.Value.Level)
-                    {
-                        _level = item.Value.Level;
-                    }
-                }
-                return _level;
-            }
-        }
-
-        public void PrependNode(BlueprintNode node, string portName, Func<bool> usingRule)
-        {
-            if (node == null)
-            {
-                throw new ArgumentNullException(nameof(node));
-            }
-            string indexName = $"{node.Name}.{portName}";
-            BlueprintPipeline p = new BlueprintPipeline(this, node);
-            node.InputInterfaces[portName] = p;
-            inputDictionary.Add(indexName, (p, usingRule));
-        }
-
-        public new void Run()
-        {
-            try
-            {
-                foreach (KeyValuePair<string, (BlueprintPipeline pipeline, Func<bool> controllingFunc)> item in inputDictionary)
-                {
-                    item.Value.pipeline.WaitForStart();
-                    if (item.Value.controllingFunc())
-                    {
-                        _outputInterfaces.First().Value.CompleteAndWriteData(item.Value.pipeline.Args);
-                    }
-                }
-            }
-            catch (Exception)
-            {
-                throw;
-            }
-        }
-
-    }
 }

源代码/StgSharpDebug/Logic/Blueprint/SideNode.cs

@@ -1,20 +1,55 @@
-using StgSharp.Logic;
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="SideNode.cs"
+//     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 System;
 using System.Collections.Generic;
 using System.Globalization;
 using System.Linq;
 using System.Text;
+using System.Threading;
 using System.Threading.Tasks;
 
-namespace StgSharp.Logic
+namespace StgSharp.BluePrint
 {
     internal sealed class BeginningNode : BlueprintNode
     {
-        public BeginningNode() : base(name: "BeginningNode", null,
-            true, ["default"], ["default"]
+
+        private Blueprint _bp;
+
+        public BeginningNode(Blueprint bp) : base(name: "BeginningNode", true, ["default"], ["default"]
             )
-        { }
+        {
+            _bp = bp;
+        }
 
         internal (string name, BlueprintPipelineArgs arg)[] InputData
         {
@@ -24,13 +59,19 @@ namespace StgSharp.Logic
                 {
                     return;
                 }
-                foreach (var parameter in value)
+                foreach ((string name, BlueprintPipelineArgs arg) parameter in value)
                 {
                     OutputInterfaces[parameter.name].Args = parameter.arg;
                 }
             }
         }
 
+        public override void Run()
+        {
+            _bp.RunningStat.Wait();
+            BlueprintPipeline.SkipAll(_outputInterfaces);
+        }
+
         public new void SetCertainOutputPort(string name, BlueprintPipeline pipeline)
         {
             if (_outputInterfaces.ContainsKey(name))
@@ -40,33 +81,30 @@ namespace StgSharp.Logic
             _outputInterfaces.Add(name, pipeline);
         }
 
-        public new void Run()
-        {
-            BlueprintPipeline.SkipAll(_outputInterfaces);
-        }
     }
 
     internal sealed class EndingNode : BlueprintNode
     {
-        public EndingNode() : base(name: "EndingNode",
-            operation: (
-                in Dictionary<string, BlueprintPipeline> input,
-                in Dictionary<string, BlueprintPipeline> output
-                ) =>
-            {
-            },
-            true, ["default"], ["default"]
+
+        private Blueprint _bp;
+
+        public EndingNode(Blueprint bp) : base(name: "EndingNode", true, ["default"], ["default"]
             )
-        { }
+        {
+            _bp = bp;
+        }
 
         internal (string name, BlueprintPipelineArgs arg)[] OutputData
         {
-            get
-            {
-                return InputInterfaces.Select(
-                key => (key.Key, key.Value.Args)).
-                ToArray();
-            }
+            get { return InputInterfaces.Select(key => (key.Key, key.Value.Args)).ToArray(); }
+        }
+
+        public override void Run()
+        {
+            BlueprintPipeline.WaitAll(_inputInterfaces);
+            Interlocked.Exchange(ref _bp.currentGlobalNodeIndex, 0);
+            Interlocked.Exchange(ref _bp.currentNativeNodeIndex, 0);
+            _bp.RunningStat.Release();
         }
 
         public new void SetCertainInputPort(string name, BlueprintPipeline pipeline)
@@ -78,9 +116,5 @@ namespace StgSharp.Logic
             _inputInterfaces.Add(name, pipeline);
         }
 
-        public new void Run()
-        {
-            BlueprintPipeline.WaitAll(_inputInterfaces);
-        }
     }
 }

源代码/StgSharpDebug/Logic/CancellableTask.cs

@@ -0,0 +1,111 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="CancellableTask.cs"
+//     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 System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace StgSharp.Threading
+{
+    internal class CancellableTask
+    {
+
+        private protected Action<CancellationToken> _startup;
+        private protected Task taskInternal;
+        private CancellationTokenSource cts;
+
+        private protected CancellableTask()
+        {
+            cts = new CancellationTokenSource();
+        }
+
+        private protected CancellableTask(Action<CancellationToken> action)
+        {
+            taskInternal = new Task(InternalAction);
+            cts = new CancellationTokenSource();
+        }
+
+        public bool IsCompleted
+        {
+            get => taskInternal.IsCompleted;
+        }
+
+        public CancellationTokenSource Cts
+        {
+            get => cts;
+        }
+
+        public int Id
+        {
+            get => taskInternal.Id;
+        }
+
+        public void Cancel()
+        {
+            Cts.Cancel();
+        }
+
+        public static CancellableTask Run(Action<CancellationToken> startup)
+        {
+            CancellableTask ret = new CancellableTask { _startup = startup };
+            ret.taskInternal = Task.Run(ret.InternalAction);
+            return ret;
+        }
+
+        public static void WaitAll(IEnumerable<CancellableTask> tasks)
+        {
+            IEnumerable<Task> convertedTasks = tasks.Select<CancellableTask, Task>
+                (ct => ct.taskInternal);
+            Task.WaitAll(convertedTasks.ToArray());
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal void InternalAction()
+        {
+            //Console.WriteLine($"Task {Task.CurrentId} is running.");
+            _startup(Cts.Token);
+        }
+
+        public static implicit operator Task(CancellableTask task)
+        {
+            return task.taskInternal;
+        }
+
+        ~CancellableTask()
+        {
+            Cts.Dispose();
+        }
+
+    }
+}

源代码/StgSharpDebug/Logic/Collections/BidirectionalDictionary.cs

@@ -0,0 +1,213 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="BidirectionalDictionary.cs"
+//     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 System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+
+namespace StgSharp.Collections
+{
+    public sealed class BidirectionalDictionary<TFirst, TSecond> : IBidirectionalDictionary<TFirst, TSecond>
+    {
+
+        private readonly Dictionary<TFirst, TSecond> _forward;
+        private readonly Dictionary<TSecond, TFirst> _reverse;
+
+        public BidirectionalDictionary()
+        {
+            _forward = new Dictionary<TFirst, TSecond>();
+            _reverse = new Dictionary<TSecond, TFirst>();
+        }
+
+        public TFirst this[TSecond key]
+        {
+            get
+            {
+                if (_reverse.TryGetValue(key,out TFirst value))
+                {
+                    return value;
+                }
+                throw new ArgumentException($"Cannot find key {key!.ToString()} in dictionary.");
+            }
+            set
+            {
+                if (_reverse.TryGetValue(key,out TFirst origin))
+                {
+                    _reverse[key] = value;
+                    _forward.Remove(origin);
+                }
+                else
+                {
+                    _reverse.Add(key, value);
+                }
+                _forward.Add(value, key);
+            }
+        }
+
+        public TSecond this[TFirst key]
+        {
+            get
+            {
+                if (_forward.TryGetValue(key, out TSecond value))
+                {
+                    return value;
+                }
+                throw new ArgumentException($"Cannot find key {key!.ToString()} in dictionary.");
+            }
+            set
+            {
+                if (_forward.TryGetValue(key, out TSecond origin))
+                {
+                    _forward[key] = value;
+                    _reverse.Remove(origin);
+                }
+                else
+                {
+                    _forward.Add(key, value);
+                }
+                _reverse.Add(value, key);
+            }
+        }
+
+        public bool IsReadOnly => false;
+
+        public ICollection<TFirst> FirstIndex => _forward.Keys;
+
+        public ICollection<TSecond> SecondIndex => _reverse.Keys;
+
+        public int Count => _forward.Count;
+
+        public IReadOnlyDictionary<TFirst, TSecond> Forward => new ReadOnlyDictionary<TFirst,TSecond>(_forward);
+
+        public IReadOnlyDictionary<TSecond, TFirst> Reverse => new ReadOnlyDictionary<TSecond,TFirst>(_reverse);
+
+        public void Add( KeyValuePair<TFirst, TSecond> item )
+        {
+            if (_forward.ContainsKey(item.Key) || _reverse.ContainsKey(item.Value))
+            {
+                throw new ArgumentException("Duplicate key or value.");
+            }
+            _forward.Add(item.Key,item.Value);
+            _reverse.Add(item.Value, item.Key);
+        }
+
+        public void Add( TFirst key, TSecond value ) 
+        {
+            if (_forward.ContainsKey(key) || _reverse.ContainsKey(value))
+            {
+                throw new ArgumentException("Duplicate key or value.");
+            }
+            _forward.Add(key, value);
+            _reverse.Add(value, key);
+        }
+
+        public void Clear()
+        {
+            _forward.Clear();
+            _reverse.Clear();
+        }
+
+        public bool Contains( KeyValuePair<TFirst, TSecond> item )
+        {
+            return _forward.Contains(item) && _reverse.TryGetValue(item.Value, out TFirst var) && var!.Equals(item.Key) ;
+        }
+
+        public bool Contains(TSecond key)
+        {
+            return _reverse.ContainsKey(key);
+        }
+
+        public bool Contains(TFirst key)
+        {
+            return _forward.ContainsKey(key);
+        }
+
+        public void CopyTo( KeyValuePair<TFirst, TSecond>[] array, int arrayIndex )
+        {
+            if (array == null)
+            {
+                throw new ArgumentNullException(nameof(array));
+            }
+            if (arrayIndex < 0 || arrayIndex > array.Length)
+            {
+                throw new ArgumentOutOfRangeException(nameof(arrayIndex));
+            }
+            if (array.Length - arrayIndex < _forward.Count)
+            {
+                throw new ArgumentException("The array is too small to copy the elements.");
+            }
+
+            foreach (var pair in _forward)
+            {
+                array[arrayIndex ++] = pair;
+            }
+        }
+
+        public IEnumerator<KeyValuePair<TFirst, TSecond>> GetEnumerator()
+        {
+            foreach (var pair in _forward)
+            {
+                yield return pair;
+            }
+        }
+
+        public bool Remove( TFirst key ) { throw new NotImplementedException(); }
+
+        public bool Remove( KeyValuePair<TFirst, TSecond> item )
+        {
+            if (_forward.Remove(item.Key))
+            {
+                return _reverse.Remove(item.Value);
+            }
+            return false;
+
+        }
+
+        public bool TryGetValue( TFirst key, out TSecond value )
+        {
+            return _forward.TryGetValue(key, out value);
+        }
+
+        public bool TryGetValue(TSecond key, out TFirst value)
+        {
+            return _reverse.TryGetValue(key, out value);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() 
+        {
+            return GetEnumerator();
+        }
+
+    }
+
+}

源代码/StgSharpDebug/Logic/Collections/IBidrirectionalDictionary.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+
+namespace StgSharp.Collections
+{
+    public interface IBidirectionalDictionary<TFirst, TSecond> : 
+        IDictionary<TFirst, TSecond>
+    {
+#pragma warning disable CA1033 
+        ICollection<TFirst> IDictionary<TFirst, TSecond>.Keys => FirstIndex;
+        ICollection<TSecond> IDictionary<TFirst, TSecond>.Values => SecondIndex;
+        bool IDictionary<TFirst, TSecond>.ContainsKey(TFirst key) => Contains(key);
+#pragma warning restore CA1033 
+
+        public IReadOnlyDictionary<TFirst, TSecond> Forward { get; }
+        public IReadOnlyDictionary<TSecond, TFirst> Reverse { get; }
+
+        public ICollection<TFirst> FirstIndex { get;}
+
+        public ICollection<TSecond> SecondIndex { get; }
+
+        public TFirst this[TSecond key] { get;set; }
+
+        /// <summary>
+        /// Determines whether the <see cref="IBidirectionalDictionary{TFirst, TSecond}" /> contains the
+        /// specified key.
+        /// </summary>
+        /// <param name="key"> The value to locate in the <see cref="IBidirectionalDictionary{TFirst, TSecond}" />. </param>
+        /// <returns>
+        /// true if the <see cref="IBidirectionalDictionary{TFirst, TSecond}" /> contains an element with the
+        /// specified key; otherwise, false.
+        /// </returns>
+        public bool Contains(TSecond key);
+
+        /// <summary>
+        /// Determines whether the <see cref="IBidirectionalDictionary{TFirst, TSecond}" /> contains the
+        /// specified key.
+        /// </summary>
+        /// <param name="key"> The value to locate in the <see cref="IBidirectionalDictionary{TFirst, TSecond}" />. </param>
+        /// <returns>
+        /// true if the <see cref="IBidirectionalDictionary{TFirst, TSecond}"/> contains an element with the
+        /// specified key; otherwise, false.
+        /// </returns>
+        public bool Contains(TFirst key);
+
+        public bool TryGetValue(TSecond key, out TFirst value);
+    }
+}

源代码/StgSharpDebug/Logic/Collections/SizeFixedList.cs

@@ -0,0 +1,174 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="SizeFixedList.cs"
+//     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 System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Reflection;
+using System.Text;
+
+namespace StgSharp.Collections
+{
+    internal class SizeFixedList<T> : IList<T>
+    {
+
+        private T[] values;
+        private int capacity, _index;
+
+        public SizeFixedList(int size)
+        {
+            values = new T[size];
+        }
+
+        public T this[int index]
+        {
+            get => (index < _index) ? values[index] : throw new ArgumentOutOfRangeException(nameof(index));
+            set
+            {
+                if (index < _index)
+                {
+                    values[index] = value;
+                }
+                else
+                {
+                    throw new ArgumentOutOfRangeException(nameof(index));
+                }
+            }
+        }
+
+        public bool IsReadOnly => false;
+
+        public int Count => _index + 1;
+
+        public void Add(T item)
+        {
+            if (_index < capacity - 1)
+            {
+                _index++;
+                this[_index] = item;
+            }
+        }
+
+        public void Clear()
+        {
+            values = new T[capacity];
+            _index = 0;
+        }
+
+        public bool Contains(T item)
+        {
+            for (int i = 0; i <= _index; i++)
+            {
+                if (item.Equals(values[i]))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public void CopyTo(T[] array, int arrayIndex)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            for (int i = 0; i <= _index; i++)
+            {
+                yield return values[i];
+            }
+        }
+
+        public int IndexOf(T item)
+        {
+            for (int i = 0; i <= _index; i++)
+            {
+                if (values[i].Equals(item))
+                {
+                    return i;
+                }
+            }
+            return -1;
+        }
+
+        void IList<T>.Insert(int index, T item)
+        {
+            throw new NotSupportedException();
+        }
+    
+        public bool Remove(T item)
+        {
+
+            for (int i = 0; i <= _index; i++)
+            {
+                if (values[i].Equals(item))
+                {
+                    values[i] = values[_index];
+                    _index--;
+                    return true;
+                }
+            }
+            return false;
+        }
+
+        public void RemoveAll(Predicate<T> predicate)
+        {
+            for (int i = _index; i > 0; i--)
+            {
+                if (predicate(values[i]))
+                {
+                    values[i] = values[_index];
+                    _index--;
+                }
+            }
+        }
+
+        public void RemoveAt(int index)
+        {
+            if (index <= _index)
+            {
+                values[index] = values[_index];
+                _index--;
+            }
+        }
+
+        public void Resize(int newSize)
+        {
+            Array.Resize(ref values, newSize);
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            yield return GetEnumerator();
+        }
+
+    }//------------------------------------- End of Class ------------------------------------------
+}

源代码/StgSharpDebug/Logic/Counter.cs

@@ -35,17 +35,21 @@ namespace StgSharp
 {
 
     public class Counter<T> where T : struct, IConvertible, IFormattable, IComparable
+#if NET8_OR_GREATER
+        ,INumber
+#endif
+
     {
 
+        internal dynamic _value;
+
         internal readonly T _defualtAddValue;
         internal readonly T _defualtSubValue;
         internal readonly T _defualtValue;
 
-        internal dynamic _value;
-
         public Counter(T defualtValue, T defualtAddValue, T defualtSubValue)
         {
-            var type = Type.GetTypeCode(defualtValue.GetType());
+            TypeCode type = Type.GetTypeCode(defualtValue.GetType());
             switch (type)
             {
                 case TypeCode.Byte:

源代码/StgSharpDebug/Logic/Sensor.cs

@@ -39,24 +39,24 @@ namespace StgSharp
     {
 
         internal PlainGeometry _boarder;
-        internal SensorRuleHandler _rule;
         internal PlainGeometry _target;
+        internal SensorRuleHandler _rule;
 
 
         public PlainGeometry boarder => _boarder;
 
-        public SensorRuleHandler Rule
-        {
-            get => _rule;
-            set => _rule = value;
-        }
-
         public PlainGeometry target
         {
             get => _target;
             set => _target = value;
         }
 
+        public SensorRuleHandler Rule
+        {
+            get => _rule;
+            set => _rule = value;
+        }
+
         public static Sensor<T> operator -(Sensor<T> sensor, SensorRuleHandler rule)
         {
             sensor._rule -= rule;

源代码/StgSharpDebug/Logic/Timing/TimeFunction.cs

@@ -32,7 +32,7 @@ using System;
 using System.Collections.Generic;
 using System.Text;
 
-namespace StgSharp
+namespace StgSharp.Timing
 {
     public class TimeFunction
     {
@@ -63,17 +63,17 @@ namespace StgSharp
             get => _timeProvider.CurrentSecond > _ending;
         }
 
-        public static TimeFunction One
-        {
-            get => new TimeFunctionOne();
-        }
-
         public Func<float, float> TimeRelatedCalculation
         {
             get { return _timeRelatedCalculation; }
             set { _timeRelatedCalculation = value; }
         }
 
+        public static TimeFunction One
+        {
+            get => new TimeFunctionOne();
+        }
+
         public TimeSpanProvider TimeSpanProvider
         {
             get { return _timeProvider; }
@@ -113,6 +113,12 @@ namespace StgSharp
             _ending = _beginning + range;
         }
 
+        public virtual TimeFunction Reverse()
+        {
+            float range = _ending - _beginning;
+            return new TimeFunction(_timeProvider, p => _timeRelatedCalculation(range - p), range);
+        }
+
     }
 
 
@@ -147,7 +153,7 @@ namespace StgSharp
         public new void Reset()
 #pragma warning restore CA1822 
         {
-            
+
         }
 
     }

源代码/StgSharpDebug/Logic/Timing/TimeSourceProvider.cs

@@ -34,17 +34,17 @@ using System;
 using System.Linq;
 using System.Threading;
 
-namespace StgSharp.Logic
+namespace StgSharp.Timing
 {
-
-
     public abstract class TimeSourceProviderBase
     {
 
         private SemaphoreSlim _addSubscriberSemaphore = new SemaphoreSlim(1, 1);
 
         protected SemaphoreSlim CheckSubscriberSemaphore
-=> _addSubscriberSemaphore;
+        {
+            get => _addSubscriberSemaphore;
+        }
 
         public void AddSubscriber(TimeSpanProvider subscriber)
         {
@@ -81,6 +81,8 @@ namespace StgSharp.Logic
         }
 
         public abstract void StartProvidingTime();
+        public abstract void StopProvidingTime();
+
 
         protected abstract void AddSubscriberUnsynced(TimeSpanProvider subscriber);
         protected abstract void RemoveSubscriberUnsynced(TimeSpanProvider subscriber);

源代码/StgSharpDebug/Logic/Timing/TimeSpanProvider.cs

@@ -28,13 +28,13 @@
 //     
 //-----------------------------------------------------------------------
 //-----------------------------------------------------------------------
-using StgSharp.Logic;
+
 
 using System;
 using System.Linq;
 using System.Threading;
 
-namespace StgSharp
+namespace StgSharp.Timing
 {
 
     /// <summary>
@@ -53,7 +53,7 @@ namespace StgSharp
         private SemaphoreSlim _refreshSemaphore = new SemaphoreSlim(0, 1);
         private readonly TimeSourceProviderBase _timeSource;
 
-        
+
 
         /// <summary>
         /// Create a new <see cref="TimeSpanProvider"/> and define the length of time span. Length of a single time span is defined in microseconds.
@@ -115,37 +115,6 @@ namespace StgSharp
             _subscribed = true;
         }
 
-        public int CurrentSpan
-        {
-            get => timeSpanCount.Value;
-        }
-
-        public float CurrentSecond
-        {
-            get => timeSpanCount.Value * SpanLengthLowPrecession;
-        }
-
-        /// <summary>
-        /// Time source provider provided in <see cref="StgSharp"/> internal framework.
-        /// </summary>
-        public static TimeSourceProviderBase DefaultProvider => StgSharpTime.OnlyInstance;
-
-        public Action FrameUpdateMissCallback
-        {
-            get => _frameUpdateMissCallback;
-            set => _frameUpdateMissCallback = value;
-        }
-
-        public double SpanLength
-        {
-            get => (_spanLength * 1.0) / (1000L * 1000L);
-        }
-
-        public float SpanLengthLowPrecession
-        {
-            get => (_spanLength * 1.0f) / (1000 * 1000);
-        }
-
         /// <summary>
         /// The method this <see cref="TimeSpanProvider"/> will call every time a new time span started.
         /// </summary>
@@ -155,6 +124,31 @@ namespace StgSharp
             set => _refreshCallback = value;
         }
 
+        public double SpanLength
+        {
+            get => (_spanLength * 1.0) / (1000L * 1000L);
+        }
+
+        public float CurrentSecond
+        {
+            get => timeSpanCount.Value * SpanLengthLowPrecession;
+        }
+
+        public float SpanLengthLowPrecession
+        {
+            get => (_spanLength * 1.0f) / (1000 * 1000);
+        }
+
+        public int CurrentSpan
+        {
+            get => timeSpanCount.Value;
+        }
+
+        /// <summary>
+        /// Time source provider provided in <see cref="StgSharp"/> internal framework.
+        /// </summary>
+        public static TimeSourceProviderBase DefaultProvider => StgSharpTime.OnlyInstance;
+
         public void SubscribeToTimeSource(TimeSourceProviderBase serviceHandler)
         {
             if (serviceHandler == null)
@@ -169,6 +163,11 @@ namespace StgSharp
             serviceHandler.AddSubscriber(this);
         }
 
+        public int ToInt32()
+        {
+            return timeSpanCount.Value;
+        }
+
         public void WaitNextSpan()
         {
             _refreshSemaphore.Wait();
@@ -176,18 +175,20 @@ namespace StgSharp
 
         internal bool CheckTime(long microseconds)
         {
+            //Console.Write("1 ");
             if (microseconds - _spanBegin < _spanLength)
             {
                 return true;
             }
-
+            //Console.Write("2 ");
             _spanBegin = microseconds;
             timeSpanCount++;
-
+            //Console.Write("3 ");
             if (_refreshCallback != null)
             {
                 _refreshCallback();
             }
+            //Console.Write("4 ");
             if (_refreshSemaphore.CurrentCount == 0)
             {
                 _refreshSemaphore.Release();
@@ -199,16 +200,18 @@ namespace StgSharp
                     _frameUpdateMissCallback();
                 }
             }
-            if (timeSpanCount > _maxSpanCount)
-            {
-                return false;
-            }
-            return true;
+            //Console.Write("5 ");
+            //Console.WriteLine( $"{timeSpanCount}\n" );
+            return timeSpanCount < _maxSpanCount;
         }
 
         public static implicit operator int(TimeSpanProvider provider)
         {
-            return provider.timeSpanCount.Value;
+            if (provider == null)
+            {
+                return 0;
+            }
+            return provider.ToInt32();
         }
 
     }

源代码/StgSharpDebug/Logic/ViewModel/ShowViewPort.cs

@@ -1,54 +0,0 @@
-using StgSharp.Graphics;
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-using System.Threading;
-
-namespace StgSharp.Logic
-{
-    public abstract partial class ViewModelBase
-    {
-        public void ShowViewPort()
-        {
-
-        }
-
-        private Blueprint renderLogic;
-
-        public Blueprint RenderLogic
-        {
-            get => renderLogic;
-            set => renderLogic = value;
-        }
-
-        /// <summary>
-        /// Init this form and render it on screen, and respond with operation
-        /// </summary>
-        public unsafe void Show()
-        {
-            while(0 == InternalIO.glfwWindowShouldClose(this.context.ViewPortID))
-            {
-                renderLogic.RunRepeatedly(() => ShouldClose);
-                frameTimeProvider.WaitNextSpan();
-                Interlocked.Add(ref _frameCount, 1);
-            }
-        }
-
-        public T BuildNewRenderStream<T>(View arg, (int x, int y, int z) unitCubeSize) where T : RenderStream
-        {
-            if (arg.ContextName == this.Name)
-            {
-
-            }
-            T? ret = Activator.CreateInstance(typeof(T), arg) as T;
-            if (ret == null)
-            {
-                throw new InvalidOperationException("Failed in building a new RenderStream when calling AsMainStreamOf");
-            }
-            ret!.InternalInit();
-            ret.timeProvider = this.frameTimeProvider;
-            return ret;
-        }
-    }
-}

源代码/StgSharpDebug/Logic/ViewModel/ViewManage.cs

@@ -1,32 +0,0 @@
-using StgSharp.Graphics;
-using StgSharp.Graphics.GL;
-
-using System;
-using System.Collections.Generic;
-using System.Text;
-
-namespace StgSharp.Logic
-{
-    public partial class ViewModelBase
-    {
-        private List<View> allView;
-
-        public View BuildNewView(
-            ViewPortDesigner designer,  (int x, int y, int z) unitCubeSize
-            )
-        {
-            View ret = new View(this.context, designer,unitCubeSize);
-            allView.Add(ret);
-            return ret;
-        }
-        
-        public T BuildRenderStream<T>(View v, (int, int, int) cube) where T : RenderStream
-        {
-            T ret = Activator.CreateInstance(typeof(T), v.Port, cube) as T ??
-                throw new InvalidOperationException("Cannot build new render stream.");
-            ret.timeProvider = this.frameTimeProvider;
-            ret.InternalInit();
-            return ret;
-        }
-    }
-}

源代码/StgSharpDebug/Logic/ViewModel/ViewModel.cs

@@ -1,249 +0,0 @@
-//-----------------------------------------------------------------------
-//-----------------------------------------------------------------------
-//     file="ViewModel.cs"
-//     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.Graphics;
-using StgSharp.Math;
-
-using System;
-using System.Collections.Generic;
-using System.Diagnostics;
-using System.Numerics;
-using System.Runtime.CompilerServices;
-using System.Runtime.InteropServices;
-using System.Text;
-using System.Threading;
-
-namespace StgSharp.Logic
-{
-    public abstract partial class ViewModelBase
-    {
-
-        private int _frameCount;
-        private int _frameSpeed;
-        private ViewPort context;
-
-        internal IntPtr monitor;
-
-        internal TimeSpanProvider fpsCountProvider;
-        internal TimeSpanProvider frameTimeProvider;
-        internal Vector4 backgroundColor;
-
-        protected ViewModelBase(int frameSpeed)
-        {
-            context = new ViewPort();
-            allView = new List<View>();
-            fpsCountProvider = new TimeSpanProvider(1.0, TimeSpanProvider.DefaultProvider);
-            _frameSpeed = 0;
-            _frameCount = 0;
-            fpsCountProvider.SpanRefreshCallback =
-                () =>
-                {
-                    Interlocked.Exchange(ref _frameSpeed, _frameCount);
-                    Interlocked.Exchange(ref _frameCount, 0);
-                };
-            long frameLength = (FrameSpeed > 0) ? ((1000L * 1000L) / FrameSpeed) : 0;
-            frameTimeProvider = new TimeSpanProvider(
-                frameLength, TimeSpanProvider.DefaultProvider
-                );
-            frameTimeProvider.SpanRefreshCallback =
-                () =>
-                {
-                };
-        }
-
-        public ViewModelBase(ViewPort vbinding, int framespeed)
-        {
-            context = vbinding;
-            allView = new List<View>();
-            fpsCountProvider = new TimeSpanProvider(1.0, TimeSpanProvider.DefaultProvider);
-            _frameSpeed = 0;
-            _frameCount = 0;
-            fpsCountProvider.SpanRefreshCallback =
-                () =>
-                {
-                    Interlocked.Exchange(ref _frameSpeed, _frameCount);
-                    Interlocked.Exchange(ref _frameCount, 0);
-                };
-            long frameLength = (FrameSpeed > 0) ? ((1000L * 1000L) / FrameSpeed) : 0;
-            frameTimeProvider = new TimeSpanProvider(
-                frameLength, TimeSpanProvider.DefaultProvider
-                );
-            frameTimeProvider.SpanRefreshCallback =
-                () =>
-                {
-                };
-        }
-
-        public int CurrentFrameCount => frameTimeProvider.CurrentSpan;
-
-        public int FrameSpeed => _frameSpeed;
-
-        /// <summary>
-        /// Height of this form, represent in <see cref="int"/>
-        /// </summary>
-        public int Height
-        {
-            get => context.Height;
-            set { context.Height = value; }
-        }
-
-        public string Name
-        {
-            get => context.Name;
-        }
-
-        public bool ShouldClose
-        {
-            get => InternalIO.glfwWindowShouldClose(context.ViewPortID) != 0;
-            set => InternalIO.glfwSetWindowShouldClose(context.ViewPortID, value ? 1 : 0);
-        }
-
-        /// <summary>
-        /// Width of this form, represent in <see cref="int"/>
-        /// </summary>
-        public vec2d Size
-        {
-            get => new vec2d(Width, Height);
-            set
-            {
-                Width = (int)value.X;
-                Height = (int)value.Y;
-                if (WindowID != IntPtr.Zero)
-                {
-                    InternalIO.glfwSetWindowSize(context.ViewPortID, Width, Height);
-                }
-            }
-        }
-
-        /// <summary>
-        /// Width of this form, represent in <see cref="int"/>
-        /// </summary>
-        public int Width
-        {
-            get => context.Width;
-            set
-            {
-                context.Width = value;
-                if (WindowID != IntPtr.Zero)
-                {
-                    InternalIO.glfwSetWindowSize(context.ViewPortID, Width, Height);
-                }
-            }
-        }
-
-        public unsafe IntPtr WindowID
-        {
-            get => context.ViewPortID;
-        }
-
-
-#pragma warning disable CA1044
-        protected FrameBufferSizeHandler FrameSizeCallback
-        {
-            set
-            {
-                IntPtr handlerPtr = Marshal.GetFunctionPointerForDelegate(value);
-                InternalIO.glfwSetFramebufferSizeCallback(context.ViewPortID, handlerPtr);
-            }
-        }
-#pragma warning restore CA1044
-
-
-        /// <summary>
-        /// Resize the current form
-        /// </summary>
-        /// <param name="size">
-        /// A <see cref="vec2d"/> (width,height) representing the new size of current form
-        /// </param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetSize(vec2d size)
-        {
-            this.Size = size;
-            InternalIO.glfwSetWindowSize(this.context.ViewPortID, (int)size.X, (int)size.Y);
-        }
-
-
-        /// <summary>
-        /// Set the size limit of current form
-        /// </summary>
-        /// <param name="minSize">
-        /// Minimum size of current form. In form of a <see cref="vec2d"/> of (width,height)
-        /// </param>
-        /// <param name="maxSize">
-        /// Maximum size of current form. In form of a <see cref="vec2d"/> of (width,height)
-        /// </param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetSizeLimit(vec2d minSize, vec2d maxSize)
-        {
-            InternalIO.glfwSetWindowSizeLimits(
-                this.context.ViewPortID,
-                (int)minSize.X,
-                (int)minSize.Y,
-                (int)maxSize.X,
-                (int)maxSize.Y);
-        }
-
-        /// <summary>
-        /// Set the size limit of current form
-        /// </summary>
-        /// <param name="minWidth">Minimum width of current form</param>
-        /// <param name="minHeight">Minimum height of current form</param>
-        /// <param name="maxWidth">Maximum width of current form</param>
-        /// <param name="maxHeight">Maximum height of current form</param>
-        [MethodImpl(MethodImplOptions.AggressiveInlining)]
-        public void SetSizeLimit(int minWidth, int minHeight, int maxWidth, int maxHeight)
-        {
-            //TODO 重做form的尺寸极限控制
-            InternalIO.glfwSetWindowSizeLimits(this.context.ViewPortID, minWidth, minHeight, maxWidth, maxHeight);
-        }
-
-        #region Key Control
-
-        protected KeyStatus CheckKey(KeyboardKey key)
-        {
-            return InternalIO.glfwGetKey(this.WindowID, (int)key);
-        }
-
-        protected KeyStatus CheckKey(Mouse key)
-        {
-            return InternalIO.glfwGetKey(this.WindowID, (int)key);
-        }
-
-        protected KeyStatus CheckKey(Joystick key)
-        {
-            return InternalIO.glfwGetKey(this.WindowID, (int)key);
-        }
-
-        #endregion
-
-
-    }
-
-}