Daily update 2 on 20240228 by nitload youmu

StgSharp.Common/.nuspec

@@ -0,0 +1,17 @@
+<?xml version="1.0"?>
+<package>
+  <metadata>
+    <id>StgSharp</id>
+    <version>1.0.0</version>
+    <authors>Nitload</authors>
+    <owners>Nitload</owners>
+    <requireLicenseAcceptance>false</requireLicenseAcceptance>
+    <description></description>
+    <tags></tags>
+  </metadata>
+  <files>
+    <file src="netstandard2.1\StgSharp.dll" target="lib\netstandard2.1\StgSharp.dll" />
+    <file src="netstandard2.1\StgSharp.xml" target="lib\netstandard2.1\StgSharp.xml" />
+    <file src="netstandard2.1\StgSharpC.dll" target="lib\netstandard2.1\StgSharpC.dll" />
+  </files>
+</package>

StgSharp.Common/.vs/StgSharp/v17/DocumentLayout.backup.json

@@ -0,0 +1,12 @@
+{
+  "Version": 1,
+  "WorkspaceRootPath": "D:\\NitloadIndustry\\\u7814\u7A76\u9879\u76EE\\1-Flagship\\TH2020\\ProjectFile\\\u5185\u6838\u6E90\u4EE3\u7801\\StgSharp\\",
+  "Documents": [],
+  "DocumentGroupContainers": [
+    {
+      "Orientation": 0,
+      "VerticalTabListWidth": 256,
+      "DocumentGroups": []
+    }
+  ]
+}

StgSharp.Common/.vs/StgSharp/v17/DocumentLayout.json

@@ -0,0 +1,12 @@
+{
+  "Version": 1,
+  "WorkspaceRootPath": "D:\\NitloadIndustry\\\u7814\u7A76\u9879\u76EE\\1-Flagship\\TH2020\\ProjectFile\\\u5185\u6838\u6E90\u4EE3\u7801\\StgSharp\\",
+  "Documents": [],
+  "DocumentGroupContainers": [
+    {
+      "Orientation": 0,
+      "VerticalTabListWidth": 256,
+      "DocumentGroups": []
+    }
+  ]
+}

StgSharp.Common/Collections/BidirectionalDictionary.cs

@@ -0,0 +1,207 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Commom.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( KeyValuePair<TFirst, TSecond> pair in _forward ) {
+                array[ arrayIndex++ ] = pair;
+            }
+        }
+
+        public IEnumerator<KeyValuePair<TFirst, TSecond>> GetEnumerator()
+        {
+            foreach( KeyValuePair<TFirst, TSecond> 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();
+        }
+
+    }
+}

StgSharp.Common/Collections/CachePool.cs

@@ -0,0 +1,63 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="CachePool.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.OpenGL;
+
+using System;
+using System.Collections;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Commom.Collections
+{
+    /*
+    public interface IPoolItem<TSignature>
+    {
+
+        public int ID
+        {
+            get;
+            init;
+        }
+
+    }
+
+    public class CacheIndexPool<TSignature, TItem> : IEnumerable<TItem>
+        where TItem: IPoolItem<TSignature>
+    {
+
+        public CacheIndexPool(
+                       Func<TSignature> 
+ ) { }
+
+    }
+    /**/
+}

StgSharp.Common/Collections/CapacityFixedList.cs

@@ -0,0 +1,178 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="CapacityFixedList.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.Runtime.CompilerServices;
+using System.Text;
+
+namespace StgSharp.Commom.Collections
+{
+    public static class CapacityFixedListBuilder
+    {
+        internal static CapacityFixedList<T> Create<T>(ReadOnlySpan<T> values)
+        {
+            return new CapacityFixedList<T>(values);
+        }
+    }
+
+    [CollectionBuilder(typeof(CapacityFixedListBuilder),nameof(CapacityFixedListBuilder.Create))]
+    public class CapacityFixedList<T> : IList<T>
+    {
+
+        private T[] _values;
+        private int capacity, _index;
+
+        public CapacityFixedList( int size )
+        {
+            _values = new T[size];
+        }
+
+        public CapacityFixedList(ReadOnlySpan<T> values)
+        {
+            _values = values.ToArray();
+        }
+
+        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 )
+        {
+            _values.CopyTo( array, arrayIndex );
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            for( int i = 0; i <= _index; i++ ) {
+                yield return _values[ i ];
+            }
+        }
+
+        public int IndexOf( T item )
+        {
+            T v;
+            for( int i = 0; i <= _index; i++ ) {
+                if( ( v = _values[ i ] ) != null && v.Equals( item ) ) {
+                    return i;
+                }
+            }
+            return -1;
+        }
+
+        public bool Remove( T item )
+        {
+            T v;
+            for( int i = 0; i <= _index; i++ ) {
+                if( ( v = _values[ i ] ) != null && v.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();
+        }
+
+        void IList<T>.Insert( int index, T item )
+        {
+            throw new NotSupportedException();
+        }
+
+    }//------------------------------------- End of Class ------------------------------------------
+}

StgSharp.Common/Collections/IBidrirectionalDictionary.cs

@@ -0,0 +1,100 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="IBidrirectionalDictionary.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.Threading.Tasks;
+
+namespace StgSharp.Commom.Collections
+{
+    public interface IBidirectionalDictionary<TFirst, TSecond> : IDictionary<TFirst, TSecond>
+    {
+
+        public TFirst this[ TSecond key ]
+        {
+            get;
+            set;
+        }
+
+        public ICollection<TFirst> FirstIndex
+        {
+            get;
+        }
+
+        public ICollection<TSecond> SecondIndex
+        {
+            get;
+        }
+
+        public IReadOnlyDictionary<TFirst, TSecond> Forward
+        {
+            get;
+        }
+
+        public IReadOnlyDictionary<TSecond, TFirst> Reverse
+        {
+            get;
+        }
+
+        /// <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 );
+
+        #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 
+    }
+}

StgSharp.Common/Collections/IHashMultiplexer.cs

@@ -0,0 +1,52 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="IHashMultiplexer.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.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+
+namespace StgSharp.Collections
+{
+    public interface IHashMultiplexer<T> : IEqualityComparer<T>
+    {
+
+        int RemainedMultiplexCount
+        {
+            get;
+            set;
+        }
+
+        void CacheHash( T obj, int count );
+
+        void ExtendCache( int count );
+
+        int ForceComputeHash( T count );
+
+    }
+}

StgSharp.Common/Collections/ListSegment.cs

@@ -0,0 +1,90 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+using System.Xml.Serialization;
+
+namespace StgSharp.Collections
+{
+    /// <summary>
+    /// Part of a collection. This contains a direct reference to origin collection,
+    /// so all change to origin collection will be reflected in this object.
+    /// </summary>
+    /// <typeparam name="T"></typeparam>
+    public struct ListSegment<T> : ICollection<T>
+    {
+        private List<T> _collection;
+        private int _begin;
+        private int _length;
+
+
+        public ListSegment(List<T> collection, int begin, int length)
+        {
+            ArgumentNullException.ThrowIfNull(collection);
+            ArgumentOutOfRangeException.ThrowIfLessThan(begin, 0);
+            ArgumentOutOfRangeException.ThrowIfLessThan(length, 0);
+            ArgumentOutOfRangeException.ThrowIfLessThan(begin + length, collection.Count);
+            _collection = collection;
+            _begin = begin;
+            _length = length;
+        }   
+
+        public int Count => _length;
+
+        public bool IsReadOnly => true;
+
+        public T this[int indexValue]
+        {
+            get {
+                ArgumentOutOfRangeException.ThrowIfLessThan(indexValue, 0);
+                ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual(indexValue, _length);
+                return _collection[indexValue + _begin];
+            }
+        }
+
+        void ICollection<T>.Add(T item)
+        {
+            throw new NotSupportedException();
+        }
+
+        void ICollection<T>.Clear()
+        {
+            throw new NotSupportedException();
+        }
+
+        public bool Contains(T item)
+        {
+            var index=  _collection.IndexOf(item);
+            return index >= _begin && index < _length + index;
+        }
+
+        public void CopyTo(T[] array, int arrayIndex)
+        {
+            ArgumentNullException.ThrowIfNull(array);
+            var span = CollectionsMarshal.AsSpan<T>(_collection).Slice(_begin, _length);
+            var target = new Span<T>(array, arrayIndex,_length);
+            span.CopyTo(target);
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            for (int i = _begin; i < _length; i++)
+            {
+                yield return this[i];
+            }
+        }
+
+        bool ICollection<T>.Remove(T item)
+        {
+            throw new NotSupportedException();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+    }
+}

StgSharp.Common/Collections/PartialDictionary.cs

@@ -0,0 +1,184 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="PartialDictionary.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.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Net.Http.Headers;
+using System.Text;
+
+namespace StgSharp.Collections
+{
+    public partial class PartialDictionary<TKey, TValue> : IDictionary<TKey, TValue>
+    {
+        private readonly Dictionary<TKey, TValue> _source;
+        private readonly HashSet<TKey> _keys;
+        private readonly PartialDictionaryValues _values;
+
+        public PartialDictionary(
+                       Dictionary<TKey, TValue> source,
+                       TKey[] index )
+        {
+            _source = source;
+            _keys = new HashSet<TKey>( index );
+            foreach( TKey item in _keys ) {
+                if( !_source.ContainsKey( item ) ) {
+                    _source.Add( item, default! );
+                }
+            }
+            _values = new PartialDictionaryValues( this );
+        }
+
+        public PartialDictionary(
+                       Dictionary<TKey, TValue> source,
+                       HashSet<TKey> keys )
+        {
+            _source = source;
+            _keys = keys;
+            foreach( TKey item in _keys ) {
+                if( !_source.ContainsKey( item ) ) {
+                    _source.Add( item, default! );
+                }
+            }
+            _values = new PartialDictionaryValues( this );
+        }
+
+        public PartialDictionary(
+                Dictionary<TKey, TValue> source,
+                TKey[] index, IHashMultiplexer<TKey> multiplexer
+            )
+        {
+            _source = source;
+            _keys = new HashSet<TKey>(index);
+            foreach (TKey item in _keys)
+            {
+                if (!_source.ContainsKey(item))
+                {
+                    _source.Add(item, default!);
+                }
+            }
+            _values = new PartialDictionaryValues(this);
+        }
+
+        public TValue this[ TKey key ]
+        {
+            get
+            {
+                if( _keys.Contains( key ) ) {
+                    return _source[ key ];
+                }
+                throw new KeyNotFoundException();
+            }
+            set
+            {
+                if( _keys.Contains( key ) ) {
+                    _source[ key ] = value;
+                }
+                throw new KeyNotFoundException();
+            }
+        }
+
+        public ICollection<TKey> Keys => _keys;
+
+        public ICollection<TValue> Values => _values;
+
+        public int Count => _keys.Count;
+
+        public bool Contains( KeyValuePair<TKey, TValue> item )
+        {
+            return _keys.Contains( item.Key ) && _source.Contains( item );
+        }
+
+        public bool ContainsKey( TKey key )
+        {
+            return _keys.Contains( key );
+        }
+
+        public void CopyTo( KeyValuePair<TKey, TValue>[] array, int arrayIndex )
+        {
+            throw new NotImplementedException();
+        }
+
+        public IEnumerator<KeyValuePair<TKey, TValue>> GetEnumerator()
+        {
+            foreach( TKey item in _keys ) {
+                yield return new KeyValuePair<TKey, TValue>(
+                    item, _source[ item ] );
+            }
+        }
+
+        public bool TryGetValue( TKey key, out TValue value )
+        {
+            if( _keys.Contains( key ) ) {
+                value = _source[ key ];
+                return true;
+            }
+            value = default!;
+            return false;
+        }
+
+        void ICollection<KeyValuePair<TKey, TValue>>.Add(
+                                                             KeyValuePair<TKey, TValue> item )
+        {
+            return;
+        }
+
+        void ICollection<KeyValuePair<TKey, TValue>>.Clear()
+        {
+            throw new NotSupportedException();
+        }
+
+        bool ICollection<KeyValuePair<TKey, TValue>>.Remove(
+                                                             KeyValuePair<TKey, TValue> item )
+        {
+            throw new NotSupportedException();
+        }
+
+        bool ICollection<KeyValuePair<TKey, TValue>>.IsReadOnly => true;
+
+        void IDictionary<TKey, TValue>.Add( TKey key, TValue value )
+        {
+            return;
+        }
+
+        bool IDictionary<TKey, TValue>.Remove( TKey key )
+        {
+            throw new NotSupportedException();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+    }
+}

StgSharp.Common/Collections/PartialDictionaryValues.cs

@@ -0,0 +1,104 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="PartialDictionaryValues.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.Text;
+
+namespace StgSharp.Collections
+{
+    public partial class PartialDictionary<TKey, TValue>
+    {
+
+        internal sealed class PartialDictionaryValues : ICollection<TValue>
+        {
+
+            private readonly PartialDictionary<TKey, TValue> _values;
+
+            public PartialDictionaryValues(
+                           PartialDictionary<TKey, TValue> value )
+            {
+                _values = value;
+            }
+
+            public bool IsReadOnly => true;
+
+            public int Count => _values.Count;
+
+            public bool Contains( TValue item )
+            {
+                foreach( KeyValuePair<TKey, TValue> kvp in _values ) {
+                    if( kvp.Value != null && kvp.Value.Equals( item ) ) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+
+            public void CopyTo( TValue[] array, int arrayIndex )
+            {
+                foreach( KeyValuePair<TKey, TValue> kvp in _values ) {
+                    array[ arrayIndex ] = kvp.Value;
+                    arrayIndex++;
+                }
+            }
+
+            public IEnumerator<TValue> GetEnumerator()
+            {
+                foreach( TKey key in _values._keys ) {
+                    yield return _values._source[ key ];
+                }
+            }
+
+            void ICollection<TValue>.Add( TValue item )
+            {
+                return;
+            }
+
+            void ICollection<TValue>.Clear()
+            {
+                return;
+            }
+
+            bool ICollection<TValue>.Remove( TValue item )
+            {
+                throw new NotSupportedException();
+            }
+
+            IEnumerator IEnumerable.GetEnumerator()
+            {
+                return GetEnumerator();
+            }
+
+        }
+
+    }
+}

StgSharp.Common/Collections/StringHashMultiplexer.cs

@@ -0,0 +1,165 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="KeyMultiplexer.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.Diagnostics.CodeAnalysis;
+using System.Globalization;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+
+namespace StgSharp.Collections
+{
+    public sealed class StringHashMultiplexer :  IHashMultiplexer<string>
+    {
+
+        private int _initCount, _remainedCount, _hashCache, _hashLast;
+        private string _source, _sourceLast;
+
+        public int RemainedMultiplexCount
+        {
+            get => _remainedCount;
+            set => _initCount = value;
+        }
+
+        public void CacheHash( string obj, int count )
+        {
+            _hashCache = ForceComputeHash( obj );
+            _initCount = count;
+            _remainedCount = _initCount;
+            _source = obj;
+        }
+
+        public bool Equals( string x, string y )
+        {
+            return x == y;
+        }
+
+        public void ExtendCache( int count )
+        {
+            _initCount += count;
+            _remainedCount += count;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe int ForceComputeHash( [NotNull] string obj )
+        {
+            int hash;
+            fixed( char* cPtr = obj.AsSpan() ) {
+                hash = InternalIO.Intrinsic
+                        .city_hash_simplify( cPtr, obj.Length );
+            }
+            return hash;
+        }
+
+        public int GetHashCode( string obj )
+        {
+            if( _remainedCount > 0 && ReferenceEquals( _source, obj ) ) {
+                _remainedCount--;
+                return _hashCache;
+            }
+            if( ReferenceEquals( _sourceLast, obj ) ) {
+                return _hashLast;
+            }
+            _sourceLast = obj;
+            _hashLast = ForceComputeHash( obj );
+            return _hashLast;
+        }
+
+    }
+
+    public sealed class ConcurrentStringHashMultiplexer : IHashMultiplexer<string>, IDisposable
+    {
+
+        private bool disposedValue;
+        private readonly ThreadLocal<StringHashMultiplexer> _multiplexers = 
+            new( () => new StringHashMultiplexer() );
+
+        public int RemainedMultiplexCount
+        {
+            get => _multiplexers.Value.RemainedMultiplexCount;
+            set => _multiplexers.Value.RemainedMultiplexCount = value;
+        }
+
+        public void CacheHash( string obj, int count )
+        {
+            throw new NotImplementedException();
+        }
+
+        // ~ConcurrentStringHashMultiplexer()
+        // {
+        //     Dispose(disposing: false);
+        // }
+
+        public void Dispose()
+        {
+            Dispose( disposing: true );
+            GC.SuppressFinalize( this );
+        }
+
+        public bool Equals( string x, string y )
+        {
+            return x == y;
+        }
+
+        public void ExtendCache( int count )
+        {
+            _multiplexers.Value.ExtendCache( count );
+        }
+
+        public unsafe int ForceComputeHash( [NotNull] string obj )
+        {
+            int hash;
+            fixed( char* cPtr = obj.AsSpan() ) {
+                hash = InternalIO.Intrinsic
+                        .city_hash_simplify( cPtr, obj.Length );
+            }
+            return hash;
+        }
+
+        public int GetHashCode( string obj )
+        {
+            return _multiplexers.Value.GetHashCode( obj );
+        }
+
+        private void Dispose( bool disposing )
+        {
+            if( !disposedValue ) {
+                if( disposing ) {
+                    _multiplexers.Dispose();
+                }
+
+                disposedValue = true;
+            }
+        }
+
+    }
+}

StgSharp.Common/Controlling/Controls/BattleField.cs

@@ -0,0 +1,72 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="BattleField.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.Geometries;
+using StgSharp.Graphics;
+
+using StgSharp.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+//TODO 这玩意如何加载一个渲染流程以获得各个图元还没搞清楚
+
+namespace StgSharp.Controls
+{
+    public class BattleField : ControllingItem
+    {
+
+        public bool IsEntity => true;
+
+        public ReadOnlySpan<Vec4> TextureBox
+        {
+            get => throw new NotImplementedException();
+        }
+
+        public Rectangle BoundingBox
+        {
+            get;
+            set;
+        }
+
+        public Vec2 Position
+        {
+            get;
+            set;
+        }
+
+        public IEnumerator<PlainGeometryMesh> GetEnumerator()
+        {
+            throw new NotImplementedException();
+        }
+
+    }
+}

StgSharp.Common/Controlling/Controls/ButtonGroup.cs

@@ -0,0 +1,159 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="ButtonGroup.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.Geometries;
+using StgSharp.Graphics;
+using StgSharp.Math;
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Security.Cryptography.X509Certificates;
+using System.Text;
+using System.Transactions;
+
+namespace StgSharp.Controls
+{
+    public abstract class KeyboardButtonGroup : ControllingItem
+    {
+
+        private List<TriggerButton> buttonList;
+        private TriggerButton current;
+
+        public KeyboardButtonGroup()
+        {
+            buttonList = new List<TriggerButton>();
+        }
+
+        public bool IsEntity
+        {
+            get => false;
+        }
+
+        public ReadOnlySpan<Vec4> TextureBox
+        {
+            get => throw new NotSupportedException();
+        }
+
+        public Rectangle BoundingBox
+        {
+            get;
+            set;
+        }
+
+        public TriggerButton CurrentButton
+        {
+            get => current;
+        }
+
+        public Vec2 Position
+        {
+            get;
+            set;
+        }
+
+        protected List<TriggerButton> AllButton
+        {
+            get => buttonList;
+        }
+
+        public void AddButton( TriggerButton button )
+        {
+            buttonList.Add( button );
+        }
+
+        public abstract void Confirm();
+
+        public IEnumerator<PlainGeometryMesh> GetEnumerator()
+        {
+            foreach( TriggerButton item in buttonList ) {
+                yield return item.Single();
+            }
+        }
+
+        public void MoveDown()
+        {
+            TriggerButton button = current;
+            while( ( button.Down != null ) && button.Down.IsDisabled ) {
+                button = button.Right;
+            }
+            if( current == button ) {
+                return;
+            }
+            current.DeHighlight();
+            button.Enable();
+            current = button;
+        }
+
+        public void MoveLeft()
+        {
+            TriggerButton button = current;
+            while( ( button.Left != null ) && button.Left.IsDisabled ) {
+                button = button.Left;
+            }
+            if( current == button ) {
+                return;
+            }
+            current.DeHighlight();
+            button.Enable();
+            current = button;
+        }
+
+        public void MoveRight()
+        {
+            TriggerButton button = current;
+            while( ( button.Right != null ) && button.Right.IsDisabled ) {
+                button = button.Right;
+            }
+            if( current == button ) {
+                return;
+            }
+            current.DeHighlight();
+            button.Enable();
+            current = button;
+        }
+
+        public void MoveUp()
+        {
+            TriggerButton button = current;
+            while( ( button.Up != null ) && button.Up.IsDisabled ) {
+                button = button.Right;
+            }
+            if( current == button ) {
+                return;
+            }
+            current.DeHighlight();
+            button.Enable();
+            current = button;
+        }
+
+    }
+}

StgSharp.Common/Controlling/Controls/CharacterIndexImage.cs

@@ -0,0 +1,111 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="CharacterIndexImage.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.Geometries;
+using StgSharp.Graphics;
+using StgSharp.Math;
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Diagnostics.Contracts;
+using System.Linq;
+using System.Text;
+
+namespace StgSharp.Controls
+{
+    public class CharacterLineIndexImage : ControllingItem
+    {
+
+        private char[] displayIndex;
+        private char defaultChar;
+
+        private Dictionary<char, PlainGeometryMesh> texIndex;
+        private int length;
+        private PlainGeometryMesh _tittleMesh;
+
+        public CharacterLineIndexImage(
+            int length,
+            char defaultChar,
+            PlainGeometryMesh tittleMesh,
+            IEnumerable<(char, PlainGeometryMesh)> indexEnumeration )
+        {
+            this.length = length;
+            displayIndex = new char[length];
+            _tittleMesh = tittleMesh;
+            texIndex = indexEnumeration.ToDictionary(
+                item => item.Item1, item => item.Item2 );
+        }
+
+        public bool IsEntity
+        {
+            get => true;
+        }
+
+        public ReadOnlySpan<Vec4> TextureBox
+        {
+            get => throw new NotSupportedException();
+        }
+
+        public Rectangle BoundingBox
+        {
+            get => throw new NotImplementedException();
+            set => throw new NotImplementedException();
+        }
+
+        public Vec2 Position
+        {
+            get => throw new NotImplementedException();
+            set => throw new NotImplementedException();
+        }
+
+        public void Display( string message )
+        {
+            if( string.IsNullOrEmpty( message ) ) {
+                message = string.Empty;
+            }
+
+            string result = ( message.Length >= length ) ?
+            message.Substring( message.Length - displayIndex.Length ) : message.PadLeft(
+                length, defaultChar );
+
+            displayIndex = result.ToCharArray();
+        }
+
+        public IEnumerator<PlainGeometryMesh> GetEnumerator()
+        {
+            yield return _tittleMesh;
+            foreach( char item in displayIndex ) {
+                yield return texIndex[ item ];
+            }
+        }
+
+    }
+}

StgSharp.Common/Controlling/Controls/ControllingIntem.cs

@@ -0,0 +1,73 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="ControllingIntem.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.Geometries;
+using StgSharp.Graphics;
+using StgSharp.Math;
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Controls
+{
+    public interface ControllingItem : IEnumerable<PlainGeometryMesh>
+    {
+
+        public abstract bool IsEntity
+        {
+            get;
+        }
+
+        public abstract ReadOnlySpan<Vec4> TextureBox
+        {
+            get;
+        }
+
+        public abstract Rectangle BoundingBox
+        {
+            get;
+            set;
+        }
+
+        public abstract Vec2 Position
+        {
+            get;
+            set;
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+    }
+}

StgSharp.Common/Controlling/Controls/DecorationBox.cs

@@ -0,0 +1,78 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="DecorationBox.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.Controls;
+using StgSharp.Geometries;
+using StgSharp.Graphics;
+using StgSharp.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Controls
+{
+    public class DecorationBox : ControllingItem
+    {
+
+        private PlainGeometryMesh renderMesh;
+
+        public DecorationBox( Rectangle bound, Image texture, Vec2[] texCoord )
+        {
+            renderMesh = new PlainGeometryMesh(
+                BoundingBox, new TextureProvider( texture, texCoord ) );
+        }
+
+        public bool IsEntity => true;
+
+        public ReadOnlySpan<Vec4> TextureBox
+        {
+            get => renderMesh.TextureCoord;
+        }
+
+        public Rectangle BoundingBox
+        {
+            get;
+            set;
+        }
+
+        public Vec2 Position
+        {
+            get;
+            set;
+        }
+
+        public IEnumerator<PlainGeometryMesh> GetEnumerator()
+        {
+            yield return renderMesh;
+        }
+
+    }
+}

StgSharp.Common/Controlling/Controls/MarkingLable.cs

@@ -0,0 +1,96 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="MarkingLable.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.Controls;
+using StgSharp.Geometries;
+using StgSharp.Graphics;
+using StgSharp.Math;
+using StgSharp.Timing;
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Text;
+
+namespace StgSharp.Controls
+{
+    public class MarkingLabel : ControllingItem
+    {
+
+        private PlainGeometryMesh marker;
+
+        private TimeFunction _movement;
+
+        private Vec2 _currentPosition, _movementVec;
+
+        public MarkingLabel( PlainGeometryMesh marker, TimeFunction movement )
+        {
+            this.marker = marker;
+            _movement = movement;
+        }
+
+        public bool IsEntity => true;
+
+        public ReadOnlySpan<Vec4> TextureBox
+        {
+            get => marker.TextureCoord;
+        }
+
+        public Rectangle BoundingBox
+        {
+            get;
+            set;
+        }
+
+        public Vec2 Position
+        {
+            get;
+            set;
+        }
+
+        public IEnumerator<PlainGeometryMesh> GetEnumerator()
+        {
+            yield return marker;
+        }
+
+        public void Move( Vec2 movement )
+        {
+            if( !_movement.IsComplete ) {
+                Position = _currentPosition + ( _movement.Calculate() * _movementVec );
+            }
+        }
+
+        public void MoveTo( Vec2 target )
+        {
+            Move( target - Position );
+        }
+
+    }
+}

StgSharp.Common/Controlling/Controls/TriggerButton.cs

@@ -0,0 +1,248 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="TriggerButton.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.Controls;
+using StgSharp.Geometries;
+using StgSharp.Graphics;
+using StgSharp.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace StgSharp.Controls
+{
+    public delegate void RenderButtonTextureCallback(
+        ButtonStatus status,
+        float beginTime,
+        in TextureProvider texture );
+
+    public enum ButtonStatus
+    {
+
+        Error = 0b0,
+        Disable = 0b1,
+        Enable = 0b10,
+        Highlight = 0b100,
+        Confirm = 0b1000,
+
+        DisableToEnable = Disable | Enable,
+        EnableToDisable = -( Enable | DisableToEnable ),
+
+        EnableToHighlight = Enable | Highlight,
+        HighlightToEnable = -( Enable | Highlight ),
+
+        HighlightToDisable = -( Highlight | Disable ),
+
+    }
+
+    public class TriggerButton : ControllingItem
+    {
+
+        private Action? confirmCallback;
+        private Action? disableCallback;
+
+        #nullable enable
+        private Action? enableCallback;
+        private float _statusBeginTime;
+
+        private RenderButtonTextureCallback _renderButton;
+        private TextureProvider _texture;
+
+        #nullable restore
+
+        public TriggerButton()
+        {
+            CurrentStatus = ButtonStatus.Disable;
+        }
+
+        public event Action ConfirmEvent
+        {
+            add { confirmCallback += value; }
+            remove { confirmCallback -= value; }
+        }
+
+        public event Action DisableEvent
+        {
+            add { disableCallback += value; }
+            remove { disableCallback -= value; }
+        }
+
+        public event Action EnableEvent
+        {
+            add { enableCallback += value; }
+            remove { enableCallback -= value; }
+        }
+
+        public event RenderButtonTextureCallback RenderButtonTexture
+        {
+            add
+            {
+                if( _renderButton == null ) {
+                    _renderButton = value;
+                } else {
+                    _renderButton += value;
+                }
+            }
+            remove
+            {
+                if( _renderButton != null ) {
+                    _renderButton -= value;
+                }
+            }
+        }
+
+        public bool IsHighLighted
+        {
+            get;
+            internal set;
+        }
+
+        public bool IsDisabled
+        {
+            get;
+            internal set;
+        }
+
+        public bool IsEntity => true;
+
+        public ReadOnlySpan<Vec4> TextureBox
+        {
+            get => MemoryMarshal.Cast<Vec2, Vec4>( _texture.TextureCoordinate );
+        }
+
+        public Rectangle BoundingBox
+        {
+            get;
+            set;
+        }
+
+        public TriggerButton Left
+        {
+            get;
+            internal set;
+        }
+
+        public TriggerButton Right
+        {
+            get;
+            internal set;
+        }
+
+        public TriggerButton Up
+        {
+            get;
+            internal set;
+        }
+
+        public TriggerButton Down
+        {
+            get;
+            internal set;
+        }
+
+        public Vec2 Position
+        {
+            get;
+            set;
+        }
+
+        internal TextureProvider Texture
+        {
+            get => _texture;
+            set => _texture = value;
+        }
+
+        protected ButtonStatus CurrentStatus
+        {
+            get;
+            set;
+        }
+
+        public void DeHighlight()
+        {
+            if( CurrentStatus == ButtonStatus.Highlight ) {
+                CurrentStatus = ButtonStatus.HighlightToEnable;
+            }
+        }
+
+        public void Disable()
+        {
+            CurrentStatus = CurrentStatus switch
+            {
+                ButtonStatus.Enable => ButtonStatus.EnableToDisable,
+                ButtonStatus.Highlight => ButtonStatus.HighlightToDisable,
+                _ => CurrentStatus,
+            };
+            if( disableCallback != null ) {
+                disableCallback();
+            }
+        }
+
+        public void Enable()
+        {
+            if( CurrentStatus == ButtonStatus.Disable ) {
+                CurrentStatus = ButtonStatus.DisableToEnable;
+            } else {
+                return;
+            }
+            if( enableCallback != null ) {
+                enableCallback();
+            }
+        }
+
+        public IEnumerator<PlainGeometryMesh> GetEnumerator()
+        {
+            _renderButton( CurrentStatus, _statusBeginTime, in _texture );
+            yield return new PlainGeometryMesh( this.BoundingBox, _texture );
+        }
+
+        public void Highlight()
+        {
+            if( CurrentStatus == ButtonStatus.Enable ) {
+                CurrentStatus |= ButtonStatus.EnableToHighlight;
+            } else {
+                return;
+            }
+            if( confirmCallback != null ) {
+                confirmCallback();
+            }
+        }
+
+        internal void Init( ButtonStatus status )
+        {
+            if( CurrentStatus == ButtonStatus.Error ) {
+                CurrentStatus = status;
+            }
+        }
+
+    }//----------------------------------- End of class --------------------------------------------
+}

StgSharp.Common/Controlling/KeyEnum.cs

@@ -0,0 +1,238 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="KeyEnum.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.Graphics.OpenGL;
+using StgSharp.Internal.OpenGL;
+
+using System;
+
+namespace StgSharp
+{
+    public enum KeyboardKey : int
+    {
+
+        UNKNOWN = -1,
+        None = 0,
+        Space = 32,
+        Apostrophe = 39/*'*/,
+        Comma = 44/*,*/,
+        Minus = 45/*-*/,
+        Period = 46/*.*/,
+        Slash = 47/*/*/,
+        Zero = 48,
+        One = 49,
+        Two = 50,
+        Three = 51,
+        Four = 52,
+        Five = 53,
+        Six = 54,
+        Seven = 55,
+        Eight = 56,
+        Nine = 57,
+        Semicolon = 59/*,*/,
+        Equal = 61/*=*/,
+        A = 65,
+        B = 66,
+        C = 67,
+        D = 68,
+        E = 69,
+        F = 70,
+        G = 71,
+        H = 72,
+        I = 73,
+        J = 74,
+        K = 75,
+        L = 76,
+        M = 77,
+        N = 78,
+        O = 79,
+        P = 80,
+        Q = 81,
+        R = 82,
+        S = 83,
+        T = 84,
+        U = 85,
+        V = 86,
+        W = 87,
+        X = 88,
+        Y = 89,
+        Z = 90,
+        LeftBracket = 91/*[*/,
+        BACKSLASH = 92/*\*/,
+        RightBracket = 93/*]*/,
+        GraveAccent = 96/*`*/,
+        World1 = 161/*non-US#1*/,
+        World2 = 162/*non-US#2*/,
+        Esc = 256,
+        Enter = 257,
+        Tab = 258,
+        Backspace = 259,
+        Insert = 260,
+        Delete = 261,
+        Right = 262,
+        Left = 263,
+        Down = 264,
+        Up = 265,
+        PgUp = 266,
+        PgDown = 267,
+        Home = 268,
+        End = 269,
+        CapsLock = 280,
+        ScrollLock = 281,
+        NumLock = 282,
+        PrintScreen = 283,
+        Pause = 284,
+        F1 = 290,
+        F2 = 291,
+        F3 = 292,
+        F4 = 293,
+        F5 = 294,
+        F6 = 295,
+        F7 = 296,
+        F8 = 297,
+        F9 = 298,
+        F10 = 299,
+        F11 = 300,
+        F12 = 301,
+        F13 = 302,
+        F14 = 303,
+        F15 = 304,
+        F16 = 305,
+        F17 = 306,
+        F18 = 307,
+        F19 = 308,
+        F20 = 309,
+        F21 = 310,
+        F22 = 311,
+        F23 = 312,
+        F24 = 313,
+        F25 = 314,
+        NumPad0 = 320,
+        NumPad1 = 321,
+        NumPad2 = 322,
+        NumPad3 = 323,
+        NumPad4 = 324,
+        NumPad5 = 325,
+        NumPad6 = 326,
+        NumPad7 = 327,
+        NumPad8 = 328,
+        NumPad9 = 329,
+        NumPadDec = 330,
+        NumPadDiv = 331,
+        NumPadMul = 332,
+        NumPadSub = 333,
+        NumPadAdd = 334,
+        NumPadAnter = 335,
+        NumPadEqual = 336,
+        LeftShift = 340,
+        LeftControl = 341,
+        LeftAlt = 342,
+        LeftSuper = 343,
+        RightShift = 344,
+        RightControl = 345,
+        RightAlt = 346,
+        RightSuper = 347,
+        Menu = 348,
+        First = Space,
+        Last = Menu,
+
+    }
+
+    #pragma warning disable CA1707
+    #pragma warning disable CA1712
+    #pragma warning disable CA1008
+    #pragma warning disable CA1027
+    public enum Joystick : int
+    #pragma warning restore CA1027
+    {
+
+        Joystick_1 = glConst.GLFW_JOYSTICK_1,
+        Joystick_2 = glConst.GLFW_JOYSTICK_2,
+        Joystick_3 = glConst.GLFW_JOYSTICK_3,
+        Joystick_4 = glConst.GLFW_JOYSTICK_4,
+        Joystick_5 = glConst.GLFW_JOYSTICK_5,
+        Joystick_6 = glConst.GLFW_JOYSTICK_6,
+        Joystick_7 = glConst.GLFW_JOYSTICK_7,
+        Joystick_8 = glConst.GLFW_JOYSTICK_8,
+        Joystick_9 = glConst.GLFW_JOYSTICK_9,
+        Joystick_10 = glConst.GLFW_JOYSTICK_10,
+        Joystick_11 = glConst.GLFW_JOYSTICK_11,
+        Joystick_12 = glConst.GLFW_JOYSTICK_12,
+        Joystick_13 = glConst.GLFW_JOYSTICK_13,
+        Joystick_14 = glConst.GLFW_JOYSTICK_14,
+        Joystick_15 = glConst.GLFW_JOYSTICK_15,
+        Joystick_16 = glConst.GLFW_JOYSTICK_16,
+        First = Joystick_1,
+        Last = Joystick_16
+
+    }
+
+    [System.Flags]
+    public enum Mouse : int
+    {
+
+        Button1 = 0,
+        Button2 = 1,
+        Button3 = 2,
+        Button4 = 3,
+        Button5 = 4,
+        Button6 = 5,
+        Button7 = 6,
+        Button8 = 7,
+        First = Button1,
+        Last = Button8,
+        Left = Button1,
+        Right = Button2,
+        Middle = Button3
+
+    }
+
+    #pragma warning restore CA1707
+    #pragma warning restore CA1712
+    #pragma warning restore CA7008
+
+    internal enum InputEquipment
+    {
+
+        Keyboard,
+        Mouse,
+        Joystick
+
+    }
+
+    public enum KeyStatus : int
+    {
+
+        RELEASE = 0,
+        PRESS = 1
+
+    }
+}

StgSharp.Common/Controlling/KeyEventAttribute.cs

@@ -0,0 +1,69 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="KeyEventAttribute.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.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp
+{
+    [AttributeUsage( AttributeTargets.Method )]
+    public class KeyEventAttribute : Attribute
+    {
+
+        internal int _equipment;
+        internal int _keyStat;
+        internal int _keyTarget;
+
+        public KeyEventAttribute( KeyboardKey key, KeyStatus status )
+        {
+            _equipment = ( int )InputEquipment.Keyboard;
+            _keyTarget = ( int )key;
+            _keyStat = ( int )status;
+        }
+
+        public KeyEventAttribute( Joystick joystick, KeyStatus status )
+        {
+            _equipment = ( int )InputEquipment.Keyboard;
+            _keyTarget = ( int )joystick;
+            _keyStat = ( int )status;
+        }
+
+        public KeyEventAttribute( Mouse mouse, KeyStatus status )
+        {
+            _equipment = ( int )InputEquipment.Keyboard;
+            _keyTarget = ( int )mouse;
+            _keyStat = ( int )status;
+        }
+
+    }
+}

StgSharp.Common/Controlling/UsrActivity/IClickTrigger.cs

@@ -0,0 +1,51 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="IClickTrigger.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.Controlling.UsrActivity
+{
+    public interface IClickTrigger
+    {
+
+        public int TargetKeyOrButtonID
+        {
+            get;
+        }
+
+        public KeyStatus TriggeredStatus
+        {
+            get;
+        }
+
+    }
+}

StgSharp.Common/Controlling/UsrActivity/JoystickTrigger.cs

@@ -0,0 +1,93 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="JoystickTrigger.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.Controlling.UsrActivity
+{
+    public readonly struct JoystickTrigger : IClickTrigger, IEquatable<JoystickTrigger>
+    {
+
+        private readonly Joystick _stick;
+        private readonly KeyStatus _status;
+
+        public JoystickTrigger( Joystick targetKey, KeyStatus status )
+        {
+            this._stick = targetKey;
+            _status = status;
+        }
+
+        public int TargetKeyOrButtonID => ( int )_stick;
+
+        public Joystick Stick
+        {
+            get => _stick;
+        }
+
+        public KeyStatus TriggeredStatus => _status;
+
+        public override bool Equals( object obj )
+        {
+            return base.Equals( obj );
+        }
+
+        public override int GetHashCode()
+        {
+            return ( ( int )_stick ) + ( 17 * ( ( int )_status ) );
+        }
+
+        public override string ToString()
+        {
+            return $"Key {_stick} triggered when {_status}";
+        }
+
+        public static bool operator !=(
+            JoystickTrigger left,
+            JoystickTrigger right )
+        {
+            return !( left == right );
+        }
+
+        public static bool operator ==(
+            JoystickTrigger left,
+            JoystickTrigger right )
+        {
+            return ( left._status == right._status ) && ( left._stick == right._stick );
+        }
+
+        bool IEquatable<JoystickTrigger>.Equals( JoystickTrigger other )
+        {
+            return other == this;
+        }
+
+    }
+}

StgSharp.Common/Controlling/UsrActivity/KeyTrigger.cs

@@ -0,0 +1,85 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="KeyTrigger.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.Data.Common;
+using System.Text;
+
+namespace StgSharp.Controlling.UsrActivity
+{
+    public readonly struct KeyTrigger : IClickTrigger, IEquatable<KeyTrigger>
+    {
+
+        private readonly KeyboardKey _targetKey;
+        private readonly KeyStatus _triggerStat;
+
+        public KeyTrigger( KeyboardKey targetKey, KeyStatus targetStat )
+        {
+            this._targetKey = targetKey;
+            this._triggerStat = targetStat;
+        }
+
+        public int TargetKeyOrButtonID => ( int )_targetKey;
+
+        public KeyStatus TriggeredStatus => _triggerStat;
+
+        public override bool Equals( object obj )
+        {
+            return base.Equals( obj );
+        }
+
+        public override int GetHashCode()
+        {
+            return ( ( int )_targetKey ) + ( 17 * ( ( int )_triggerStat ) );
+        }
+
+        public override string ToString()
+        {
+            return $"Key {_targetKey} triggered when {_triggerStat}";
+        }
+
+        public static bool operator !=( KeyTrigger left, KeyTrigger right )
+        {
+            return !( left == right );
+        }
+
+        public static bool operator ==( KeyTrigger left, KeyTrigger right )
+        {
+            return ( left._triggerStat == right._triggerStat ) && ( left._targetKey == right._targetKey );
+        }
+
+        bool IEquatable<KeyTrigger>.Equals( KeyTrigger other )
+        {
+            return other == this;
+        }
+
+    }
+}

StgSharp.Common/Controlling/UsrActivity/MouseTrigger.cs

@@ -0,0 +1,72 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="MouseTrigger.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.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.SymbolStore;
+using System.Text;
+
+namespace StgSharp.Controlling.UsrActivity
+{
+    public readonly struct MouseTrigger : IClickTrigger, IEquatable<MouseTrigger>
+    {
+
+        private readonly KeyStatus _status;
+        private readonly Mouse _mouse;
+
+        public MouseTrigger( Mouse mouse, KeyStatus status )
+        {
+            _mouse = mouse;
+            _status = status;
+        }
+
+        public int TargetKeyOrButtonID => ( int )_mouse;
+
+        public KeyStatus TriggeredStatus => _status;
+
+        public bool Equals( MouseTrigger other )
+        {
+            return this == other;
+        }
+
+        public static bool operator !=( MouseTrigger left, MouseTrigger right )
+        {
+            return left._mouse != right._mouse || left._status != right._status;
+        }
+
+        public static bool operator ==( MouseTrigger left, MouseTrigger right )
+        {
+            return left._mouse == right._mouse && left._status == right._status;
+        }
+
+    }
+}

StgSharp.Common/Controlling/UsrActivity/TriggetFactory.cs

@@ -0,0 +1,102 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="TriggetFactory.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.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Controlling.UsrActivity
+{
+    public static class TriggetBuilder
+    {
+
+        private const int JoystickMax = ( int )Joystick.Last + 1;
+        private const int JoystickMin = ( int )Joystick.First - 1;
+        private const int KeyboardMax = ( int )KeyboardKey.Last + 1;
+        private const int KeyboardMin = ( int )KeyboardKey.First - 1;
+        private const int MouseMax = ( int )Mouse.Last + 1;
+        private const int MouseMin = ( int )Mouse.First - 1;
+
+        private static KeyTrigger keyboardtemp;
+        private static MouseTrigger mousetemp;
+
+        public static JoystickTrigger BuildJoystickClickTrigger(
+            int keyCode,
+            KeyStatus status )
+        {
+            if( keyCode > MouseMin && keyCode < MouseMax ) {
+                return new JoystickTrigger( ( Joystick )keyCode, status );
+            }
+            throw new InvalidOperationException(
+                "Known key code or key is not on joystick." );
+        }
+
+        public static KeyTrigger BuildKeyboardClickTrigger(
+            int keyCode,
+            KeyStatus status )
+        {
+            if( keyCode > KeyboardMin && keyCode < KeyboardMax ) {
+                return new KeyTrigger( ( KeyboardKey )keyCode, status );
+            }
+            throw new InvalidOperationException(
+                "Known key code or kay is not on keyboard." );
+        }
+
+        public static MouseTrigger BuildMouseClickTrigger(
+            int keyCode,
+            KeyStatus status )
+        {
+            if( keyCode >= MouseMin && keyCode <= MouseMax ) {
+                return new MouseTrigger( ( Mouse )keyCode, status );
+            }
+            throw new InvalidOperationException(
+                "Known key code or key is not on mouse." );
+        }
+
+        public static IClickTrigger BuildTrigger(
+            int keyCode,
+            KeyStatus status )
+        {
+            if( keyCode > KeyboardMin && keyCode < KeyboardMax ) {
+                return new KeyTrigger( ( KeyboardKey )keyCode, status );
+            }
+            if( keyCode > JoystickMin && keyCode < JoystickMax ) {
+                return new JoystickTrigger( ( Joystick )keyCode, status );
+            }
+            if( keyCode >= MouseMin && keyCode <= MouseMax ) {
+                return new MouseTrigger( ( Mouse )keyCode, status );
+            }
+            throw new InvalidOperationException( "Known key code." );
+        }
+
+    }
+}

StgSharp.Common/Data/GlobalData/root.cs

@@ -0,0 +1,56 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="root.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.Internal;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp
+{
+    public static unsafe partial class StgSharp
+    {
+
+        private static byte leastUnusedArea;
+        private static List<Area> root = new List<Area>();
+        private static SSD defaultIdProvider = new SSD();
+
+        public static byte NewArea()
+        {
+            byte ret = leastUnusedArea;
+            leastUnusedArea++;
+            return ret;
+        }
+
+    }//------------------ end of class ---------------------
+}

StgSharp.Common/Data/RandomGenerator.cs

@@ -0,0 +1,169 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="RandomGenerator.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.HighPerformance;
+
+using System;
+using System.IO;
+using System.Security.Cryptography;
+using System.Text;
+using System.Xml.Serialization;
+
+namespace StgSharp.Data
+{
+    public class RandomGenerator
+    {
+
+        private byte[] currentKey;
+
+        private readonly byte[] originKey;
+        private int cycleCount;
+        private SHA512 hash;
+
+        public RandomGenerator() : this( DateTime.UtcNow.ToBinary() ) { }
+
+        public RandomGenerator( object source )
+        {
+            try {
+                if( source == null ) {
+                    throw new ArgumentNullException( nameof( source ) );
+                }
+                XmlSerializer s = new XmlSerializer( source.GetType() );
+                using( StringWriter sw = new StringWriter() ) {
+                    s.Serialize( sw, source );
+                    string data = sw.ToString();
+                    originKey = Encoding.UTF8.GetBytes( data );
+                }
+            }
+            catch( Exception ) {
+                throw;
+            }
+            hash = SHA512.Create();
+            originKey = hash.ComputeHash( originKey );
+            currentKey = originKey;
+            cycleCount = 0;
+        }
+
+        public int TotalGeneratedRandom
+        {
+            get => cycleCount;
+        }
+
+        public unsafe int GenRandomInt()
+        {
+            M128 source = PrivateRand();
+            cycleCount++;
+
+            /*
+            float d0 =  MathF.Sin(1 / source.Read<float>(0));
+            float d1 =  MathF.Sin(1 / source.Read<float>(1));
+            float d2 =  MathF.Sin(1 / source.Read<float>(2));
+            float d3 =  MathF.Sin(1 / source.Read<float>(3));
+
+            source.Write<short>(0, *( short*)&d3);
+            source.Write<short>(2, *((short*)&d2+1));
+            source.Write<short>(4, *( short*)&d1);
+            source.Write<short>(6, *((short*)&d0+1));
+
+            /**/
+
+            return source.Read<int>( cycleCount % 4 );
+        }
+
+        public byte GenRandomInt8()
+        {
+            cycleCount++;
+            if( cycleCount % 64 == 0 ) {
+                PrivateRand();
+            }
+            return currentKey[ cycleCount % 64 ];
+        }
+
+        public float GenRandomSingle()
+        {
+            cycleCount++;
+
+            while( true ) {
+                M128 source = PrivateRand();
+
+                uint
+                    temp0 = source.Read<uint>( 0 ),
+                    temp1 = source.Read<uint>( 2 );
+
+                if( temp0 * temp1 != 0 ) {
+                    float ret = ( ( temp0 % temp1 ) * 1.0f ) / temp1;
+                    if( ret < 0.335f ) {
+                        ret = ret * ( ( ret * ( -0.7811934f ) ) + 1.4489113f );
+                    } else {
+                        ret = ( ret * ( ( ret * ( -0.1158368f ) ) + 1.0580600f ) ) + 0.0590584f;
+                    }
+                    if( ret > 1 ) {
+                        continue;
+                    }
+                    return ret;
+                }
+            }
+        }
+
+        public void Reset()
+        {
+            currentKey = originKey;
+            cycleCount = 0;
+        }
+
+        private unsafe M128 PrivateRand()
+        {
+            currentKey = hash.ComputeHash( currentKey );
+            M128 ret;
+            fixed( byte* bptr = currentKey ) {
+                switch( ( cycleCount % 16 ) / 4 ) {
+                    case 0:
+                        ret = *( ( ( M128* )bptr ) + 0 );
+                        break;
+                    case 1:
+                        ret = *( ( ( M128* )bptr ) + 1 );
+                        break;
+                    case 2:
+                        ret = *( ( ( M128* )bptr ) + 2 );
+                        break;
+                    case 3:
+                        ret = *( ( ( M128* )bptr ) + 3 );
+                        break;
+                    default:
+                        throw new InvalidOperationException();
+                }
+            }
+
+            //Console.WriteLine(ret.ToString(16));
+            return ret;
+        }
+
+    }
+}

StgSharp.Common/Data/SSD/Area.cs

@@ -0,0 +1,47 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Area.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.Internal.FileIO;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Internal
+{
+    /// <summary>
+    /// An independent storage area, used as the only folder type in root folder. Contains several
+    /// <see cref="SSD" /> files reference as virtual disc. Data is actually stored in <see
+    /// cref="SSD" />s in certain RAID mode.
+    /// </summary>
+    public partial class Area { }
+}

StgSharp.Common/Data/SSD/DataHead.cs

@@ -0,0 +1,79 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="DataHead.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.HighPerformance;
+
+using System;
+using System.Numerics;
+using System.Runtime.InteropServices;
+
+namespace StgSharp.Internal
+{
+    [StructLayout( LayoutKind.Explicit, Size = 16 )]
+    public struct SSDSegmentHead
+    {
+
+        [FieldOffset( 12 )] internal byte size;
+
+        [FieldOffset( 0 )] internal M128 data;
+        [FieldOffset( 13 )] public byte selfDefine_1;
+        [FieldOffset( 14 )] public byte selfDefine_2;
+        [FieldOffset( 15 )] public byte selfDefine_3;
+
+        [FieldOffset( 0 )] public int globalID;
+        [FieldOffset( 4 )] public int nextID;
+        [FieldOffset( 8 )] public int previousHash;
+
+        public int Size
+        {
+            get => ( ( int )size ) + 1;
+            set
+            {
+                if( ( value > 256 ) || ( value < 0 ) ) {
+                    throw new ArgumentOutOfRangeException();
+                }
+                size = ( byte )( value - 1 );
+            }
+        }
+
+        public unsafe byte[] GetBytes()
+        {
+            byte[] ret = new byte[16];
+            fixed( Vector4* vptr = &data.Vec ) {
+                byte* bptr = ( byte* )vptr;
+                for( int i = 0; i < 15; i++ ) {
+                    ret[ i ] = *bptr;
+                }
+            }
+            return ret;
+        }
+
+    }
+}

StgSharp.Common/Data/SSD/DataSegment.cs

@@ -0,0 +1,184 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="DataSegment.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.HighPerformance;
+using StgSharp.HighPerformance;
+using StgSharp.Internal.Intrinsic;
+
+using StgSharp.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Internal
+{
+    [StructLayout( LayoutKind.Explicit, Size = StgSharp.ssdSegmentLength * 16 )]
+    public unsafe struct SSDSegment : IComparable<int>, IComparable<SSDSegment>
+    {
+
+        [FieldOffset( 16 )] public fixed byte Data[
+            16 * ( StgSharp.ssdSegmentLength - 1 ) ];
+        [FieldOffset( 12 )] public int DataHash;
+        [FieldOffset( 8 )] public int PreviousHash;
+        [FieldOffset( 0 * 16 )] public SSDSegmentHead Head;
+
+        public SSDSegment( int previousHash )
+        {
+            this.PreviousHash = previousHash;
+        }
+
+        public byte this[ int index ]
+        {
+            get
+            {
+                if( index > ( 16 * ( StgSharp.ssdSegmentLength - 1 ) ) - 1 ) {
+                    throw new IndexOutOfRangeException();
+                }
+                return Data[ index ];
+            }
+
+            set
+            {
+                if( index > ( 16 * ( StgSharp.ssdSegmentLength - 1 ) ) - 1 ) {
+                    throw new IndexOutOfRangeException();
+                }
+                Data[ index ] = value;
+            }
+        }
+
+        public int ID
+        {
+            get { return Head.globalID; }
+            set { Head.globalID = value; }
+        }
+
+        public short Size => Head.size;
+
+        public void FillRandomBytes( int begin )
+        {
+            if( begin > 255 ) {
+                return;
+            }
+            for( int i = begin; i < 255; i++ ) {
+                Data[ i ] = Scaler.Random<byte>();
+            }
+        }
+
+        public static SSDSegment FromStream( byte[] stream )
+        {
+            if( stream.Length != 16 * StgSharp.ssdSegmentLength ) {
+                throw new ArgumentException();
+            }
+            SSDSegment ret = new SSDSegment();
+            fixed( byte* bptr = stream ) {
+                ret.Head.data = *( M128* )bptr;
+                for( int i = 1; i < StgSharp.ssdSegmentLength; i++ ) {
+                    ret.WriteData<M128>(
+                        i - 1, *( M128* )( bptr + ( 16 * i ) ) );
+                }
+            }
+            return ret;
+        }
+
+        public byte[] GetBytes()
+        {
+            byte[] ret = new byte[16 * StgSharp.ssdSegmentLength];
+            fixed( M128* mptr = &Head.data ) {
+                fixed( byte* aptr = ret ) {
+                    Vector4* vsptr = ( Vector4* )mptr;
+                    Vector4* vtptr = ( Vector4* )aptr;
+                    for( int i = 0; i < 18; i++ ) {
+                        *( vtptr + i ) = *( vsptr + i );
+                    }
+                }
+            }
+
+            return ret;
+        }
+
+        public int GetDataHash()
+        {
+            Vector4 v = Vector4.One;
+            fixed( M128* mptr = &Head.data ) {
+                Vector4* vptr = ( Vector4* )mptr;
+                for( int i = 0; i < StgSharp.ssdSegmentLength - 1; i += 1 ) {
+                    v += ( *vptr ) * 31;
+                }
+            }
+            M128 m = new M128( v );
+            DataHash = m.Vec.GetHashCode();
+            return DataHash;
+        }
+
+        public override int GetHashCode()
+        {
+            int ret = 17;
+            fixed( M128* mptr = &Head.data ) {
+                Vector4* vptr = ( Vector4* )mptr;
+                for( int i = 0; i < StgSharp.ssdSegmentLength; i++ ) {
+                    ret = ( ret + ( *vptr ).GetHashCode() ) * 31;
+                }
+            }
+            return ret;
+        }
+
+        public unsafe T ReadData<T>( int index ) where T: struct
+        {
+            fixed( byte* bptr = Data ) {
+                T* tptr = ( T* )bptr;
+                return *( tptr + index );
+            }
+        }
+
+        public unsafe void WriteData<T>( int index, T value ) where T: struct
+        {
+            fixed( byte* bptr = Data ) {
+                T* tptr = ( T* )bptr;
+                *( tptr + index ) = value;
+            }
+        }
+
+        int IComparable<int>.CompareTo( int other )
+        {
+            return ID.CompareTo( other );
+        }
+
+        int IComparable<SSDSegment>.CompareTo( SSDSegment other )
+        {
+            return ID.CompareTo( other.ID );
+        }
+
+    }
+}

StgSharp.Common/Data/SSD/SSD.cs

@@ -0,0 +1,68 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="SSD.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.Internal.FileIO;
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+
+namespace StgSharp.Internal
+{
+    public partial class SSD
+    {
+
+        private Dictionary<string, SSDraw> fileList;
+
+        private FileStream file;
+        private SSDrawHead head;
+
+        public SSD()
+        {
+            fileList = new Dictionary<string, SSDraw>();
+        }
+
+        public SSD( FileStream fileStream )
+        {
+            fileList = new Dictionary<string, SSDraw>();
+            file = fileStream;
+        }
+
+        public static SSD FromFile( string fileRoute )
+        {
+            return new SSD(
+                new FileStream( fileRoute, FileMode.Open, FileAccess.Read ) )
+            {
+            };
+        }
+
+    }
+}

StgSharp.Common/Data/SSD/SSDVirtualFolder.cs

@@ -0,0 +1,80 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="SSDVirtualFolder.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.Internal.FileIO;
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Internal
+{
+    public class SSDFolder : ISSDSerializable
+    {
+
+        internal Dictionary<string, SSDFolder> folders;
+        internal int _folderID;
+        internal string _name;
+
+        internal SSDFolder()
+        {
+            folders = new Dictionary<string, SSDFolder>();
+        }
+
+        internal SSDFolder( string name )
+        {
+            if( name == "root" ) {
+                throw new ArgumentException(
+                    "Name cannot be root," + "it is preserved for root file indexer." );
+            }
+            if( name == "default" ) {
+                throw new ArgumentException(
+                    "Name cannot be default," + "it is preserved for default file id provider." );
+            }
+            _name = name;
+            folders = new Dictionary<string, SSDFolder>();
+        }
+
+        public SerializableTypeCode SSDTypeCode => SerializableTypeCode.VirtualFolder;
+
+        public void FromBytes( byte[] stream )
+        {
+            throw new NotImplementedException();
+        }
+
+        //TODO 虚拟文件夹的GetBytes好难写
+        public byte[] GetBytes()
+        {
+            throw new NotImplementedException();
+        }
+
+    }
+}

StgSharp.Common/Data/SSD/SSDraw.cs

@@ -0,0 +1,79 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="SSDraw.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.ShaderEdit;
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Security.Cryptography;
+using System.Text;
+using System.Xml.Serialization;
+
+namespace StgSharp.Internal.FileIO
+{
+    public class SSDraw
+    {
+
+        private byte[] data;
+
+        public SSDraw( string name, Stream streamSource )
+        {
+            if( ( streamSource == null ) || ( streamSource.Length == 0 ) ) {
+                throw new ArgumentNullException( nameof( streamSource ) );
+            }
+            Name = name;
+            data = new byte[streamSource.Length];
+            streamSource.Read( data.AsSpan() );
+        }
+
+        public SSDrawHead Head
+        {
+            get;
+            set;
+        }
+
+        public string Name
+        {
+            get;
+            set;
+        }
+
+    }
+
+    [StructLayout( LayoutKind.Explicit, Size = 32 * 16 )]
+    public unsafe struct SSDrawHead { }
+}

StgSharp.Common/Data/Serialize/Define.cs

@@ -0,0 +1,41 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Define.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.Internal
+{
+    /// <summary>
+    /// A class contains a sets of methods to serialize several types
+    /// </summary>
+    public static partial class Serializer { }
+}

StgSharp.Common/Data/Serialize/ISSDSerializable.cs

@@ -0,0 +1,109 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="ISSDSerializable.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.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Internal
+{
+    public interface ISSDSerializable
+    {
+
+        public SerializableTypeCode SSDTypeCode
+        {
+            get;
+        }
+
+        public byte[] GetBytes();
+
+        internal void FromBytes( byte[] stream );
+
+    }
+
+    public enum SerializableTypeCode
+    {
+
+        Unknown = 0,
+        IndexTable = 1,
+        PixelImage = 2,
+        VectorImage = 3,
+        Audio = 4,
+        Shader = 5,
+        Text = 6,
+        RawData = 7,
+        VirtualFolder = int.MaxValue,
+
+    }
+
+    public static partial class Serializer
+    {
+
+        public static T Deserialize<T>( byte[] stream )
+            where T: ISSDSerializable
+        {
+            T serializableObject = Activator.CreateInstance<T>();
+            serializableObject.FromBytes( stream );
+            return serializableObject;
+        }
+
+        public static string GetNameTail( SerializableTypeCode typeCode )
+        {
+            switch( typeCode ) {
+                case SerializableTypeCode.IndexTable:
+                    return "_idt";
+                case SerializableTypeCode.PixelImage:
+                    return "_pim";
+                case SerializableTypeCode.VectorImage:
+                    return "_vim";
+                case SerializableTypeCode.Audio:
+                    return "_wav";
+                case SerializableTypeCode.Shader:
+                    return "_gls";
+                case SerializableTypeCode.Text:
+                    return "_txt";
+                case SerializableTypeCode.RawData:
+                    return "_raw";
+                case SerializableTypeCode.VirtualFolder:
+                    return "_fod";
+                default:
+                    throw new ArgumentException( "Unknown file type" );
+            }
+        }
+
+        public static byte[] Serialize( ISSDSerializable serializableObject )
+        {
+            return serializableObject.GetBytes();
+        }
+
+    }
+}

StgSharp.Common/Data/ValueBox.cs

@@ -0,0 +1,101 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="ValueBox.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.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Data
+{
+    public interface IValueBox
+    {
+
+        ref object ValueReference
+        {
+            get;
+        }
+
+        static virtual IValueBox<T> AsGeneric<T>( IValueBox box )
+            where T: struct
+        {
+            if( box is not IValueBox<T> genericBox ) {
+                return null;
+            }
+            return genericBox;
+        }
+
+        static virtual bool IsGeneric<T>( IValueBox box ) where T: struct
+        {
+            return box is IValueBox<T>;
+        }
+
+    }
+
+    public interface IValueBox<T> where T: struct
+    {
+
+        T Value
+        {
+            get;
+            set;
+        }
+
+    }
+
+    /// <summary>
+    /// A class attempt to reduce cost of boxing, though still a bit slower than direct access to
+    /// origin value type instance.
+    /// </summary>
+    /// <typeparam name="T"> Type of instance to be boxed. </typeparam>
+    public class ValueBox<T> : IValueBox, IValueBox<T> where T: struct
+    {
+
+        private T _value;
+
+        public ValueBox( T value )
+        {
+            _value = value;
+        }
+
+        public ref object ValueReference => ref Unsafe.As<T, object>(
+            ref _value );
+
+        public T Value
+        {
+            get => _value;
+            set => _value = value;
+        }
+
+    }
+}

StgSharp.Common/Entities/BehaviorArgs.cs

@@ -0,0 +1,34 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="BehaviorArgs.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.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+namespace StgSharp.Entities
+{
+    public abstract class BehaviorArgs { }
+}

StgSharp.Common/Entities/Enemy.cs

@@ -0,0 +1,66 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Enemy.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.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+
+namespace StgSharp.Entities
+{
+    public class Enemy : IEntity
+    {
+
+        internal Launcher<EntityPartical> _awardLauncher;
+        internal Launcher<EntityPartical> _commonBulletLauncher;
+        internal Launcher<EntityPartical> _dieBulletLauncher;
+        public bool _selectalbe;
+
+        public Launcher<EntityPartical> AwardLauncher
+        {
+            get;
+            set;
+        }
+
+        public Launcher<EntityPartical> CommonBulletLauncher
+        {
+            get;
+            set;
+        }
+
+        public Launcher<EntityPartical> DieBulletLauncher
+        {
+            get;
+            set;
+        }
+
+        public override void OnRenderFrame()
+        {
+            CommonBulletLauncher.Launch();
+        }
+
+    }
+}

StgSharp.Common/Entities/EntityPartical.cs

@@ -0,0 +1,34 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="EntityPartical.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.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+namespace StgSharp.Entities
+{
+    public abstract class EntityPartical : IEntity { }
+}

StgSharp.Common/Entities/IEntity.cs

@@ -0,0 +1,107 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="IEntity.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.Geometries;
+using StgSharp.Math;
+
+using System;
+using System.Collections.Generic;
+
+namespace StgSharp
+{
+    public abstract class IEntity
+    {
+
+        protected uint _bornTick;
+        internal Func<int, Vec3> _movHandler;
+        internal LinkedList<PlainGeometry> _collisionBox;
+        internal Point _basePoint;
+        internal Point _pos;
+        internal Point _position;
+        internal PlainGeometryCollisionSensor<PlainGeometry, PlainGeometry> _collisionSensor;
+        internal string _texture;
+
+        /// <summary>
+        /// X position of an enenmy entity
+        /// </summary>
+        public float X
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// Y position of an enemy entity
+        /// </summary>
+        public float Y
+        {
+            get;
+            set;
+        }
+
+        public LinkedList<PlainGeometry> CollisionBox
+        {
+            get => _collisionBox;
+            set => _collisionBox = value;
+        }
+
+        /// <summary>
+        /// A sensor used for checking out if a bullet hit a player or something else
+        /// </summary>
+        public PlainGeometryCollisionSensor<PlainGeometry, PlainGeometry> CollisionSensor
+        {
+            get => _collisionSensor;
+            set => _collisionSensor = value;
+        }
+
+        public string TextureGL
+        {
+            get;
+            set;
+        }
+
+        /// <summary>
+        /// A 2D vector presenting the position of an enemy entity, position can also be visited by
+        /// X, Y
+        /// </summary>
+        public Vec2 Location
+        {
+            get;
+        }
+
+        public abstract void OnRenderFrame();
+
+        public void SetLocation( Point p )
+        {
+            _pos = p;
+        }
+
+    }
+}

StgSharp.Common/Entities/Launcher.cs

@@ -0,0 +1,58 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Launcher.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.Entities;
+using StgSharp.Math;
+
+namespace StgSharp
+{
+    public class Launcher<T> where T: IEntity
+    {
+
+        internal uint[] launchtick;     //发射子弹的内部计时
+        internal Counter<int> _internalParameter;       //发射器的内部计时器
+
+        internal EntityPartical _bulletSample;        //发射的子弹类型
+        /*
+         *用于发射其他的实体，主要是子弹 和 掉落物
+         */
+
+        internal Vec2 _center;     //发射器的参考位置，运动轨迹的方程应当基于这个参考点构建
+
+        public EntityPartical Bullet
+        {
+            get => _bulletSample;
+            set => _bulletSample = value;
+        }
+
+        internal virtual void Launch() { }
+
+    }
+}

StgSharp.Common/Entities/Partical.cs

@@ -0,0 +1,44 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Partical.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;
+
+namespace StgSharp
+{
+    public class Partical : IEntity
+    {
+
+        public override void OnRenderFrame()
+        {
+            throw new NotImplementedException();
+        }
+
+    }
+}

StgSharp.Common/Entities/Player.cs

@@ -0,0 +1,41 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Player.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.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+namespace StgSharp
+{
+    public abstract class Player : IEntity
+    {
+
+        internal float _velocity;
+
+        public float Velocity => _velocity;
+
+    }
+}

StgSharp.Common/Environment/Dialogue.cs

@@ -0,0 +1,185 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Dialogue.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.Diagnostics;
+using System.IO;
+using System.IO.Pipes;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+
+namespace StgSharp
+{
+    public static class Dialogue
+    {
+
+        private static Process? _dialogueProcess;
+        private static AnonymousPipeServerStream _dialogueClientPipe,_dialogueServerPipe;
+        private static ConcurrentBag<string> msgCache = new ConcurrentBag<string>(
+            );
+        private static int _readAndWriteThreadId;
+        private static ProcessStartInfo _dialogueProcessInfo;
+        private static StreamReader _dr;
+        private static StreamWriter _dw;
+
+        public static bool NeedShowWhenStartup
+        {
+            get;
+            set;
+        }
+
+        public static void SetReadAndWriteThread(Thread thread)
+        {
+            _readAndWriteThreadId = thread.ManagedThreadId;
+        }
+
+        private static void AssertThread()
+        {
+            if (_readAndWriteThreadId != Environment.CurrentManagedThreadId)
+            {
+                throw new InvalidOperationException("Communication with dialogue can only call from certain thread.");
+            }
+        }
+
+        internal static void CreateDialogueProcessIfNotExist()
+        {
+            if( _dialogueProcess != null ) {
+                return;
+            }
+            if (!File.Exists(_dialogueProcessInfo.FileName))
+            {
+
+            }
+            _dialogueProcess = Process.Start( _dialogueProcessInfo );
+
+            _dr = new StreamReader(_dialogueClientPipe);
+            _dw = new StreamWriter(_dialogueServerPipe);
+
+            _dialogueProcess!.Exited += DialogueProcessExitCallback; 
+
+            _dialogueServerPipe.DisposeLocalCopyOfClientHandle();
+            _dialogueClientPipe.DisposeLocalCopyOfClientHandle();
+        }
+
+        private static void DialogueProcessExitCallback(object? sender, EventArgs e)
+        {
+            _dialogueProcess = null;
+            _dr.Close();
+            _dw.Close();
+        }
+
+        internal static void LoadDialogue()
+        {
+            _dialogueServerPipe = new AnonymousPipeServerStream(
+                PipeDirection.Out, HandleInheritability.Inheritable );
+            _dialogueClientPipe = new AnonymousPipeServerStream(
+                PipeDirection.In, HandleInheritability.Inheritable );
+
+            string route = Assembly.GetAssembly( typeof( StgSharp ) ).Location;
+            string path = Path.GetDirectoryName( route );
+
+            string exeName;
+
+            if( RuntimeInformation.IsOSPlatform( OSPlatform.Windows ) ) {
+                exeName = ".exe";
+            } else if( RuntimeInformation.IsOSPlatform( OSPlatform.Linux ) || RuntimeInformation.IsOSPlatform(
+                OSPlatform.OSX ) ) {
+                exeName = string.Empty;
+            } else {
+                throw new PlatformNotSupportedException( "Unknown OS platform" );
+            }
+
+            string consoleRoute = Path.Combine(path, @"StgSharpTerminalDialogue", $@"StgSharpTerminalDialogue{exeName}");
+
+            _dialogueProcessInfo = new ProcessStartInfo
+            {
+                FileName = consoleRoute,
+                Arguments = $"{_dialogueServerPipe.GetClientHandleAsString()} {_dialogueClientPipe.GetClientHandleAsString()}",
+                UseShellExecute = true,
+                RedirectStandardOutput = false,
+            };
+
+        }
+
+        internal static void PostMessage(
+                                 string instruction,
+                                 params string[] operands)
+        {
+            CreateDialogueProcessIfNotExist();
+
+            _dw.WriteLine($"{instruction} {operands}");
+
+        }
+
+        public static void PostError(Exception ex)
+        {
+            CreateDialogueProcessIfNotExist();
+
+            _dw.WriteLine($"posterror {ex.Message}");
+
+            _dialogueProcess!.Exited -= DialogueProcessExitCallback;
+        }
+
+        internal static void UnloadDialogue()
+        {
+            if( _dialogueProcess != null ) {
+                _dialogueProcess.Kill();
+            }
+            _dialogueProcess = null;
+
+            _dialogueServerPipe.Dispose();
+            _dialogueClientPipe.Dispose();
+        }
+
+        internal static string WaitCertainReturn( string target )
+        {
+            if( _dialogueProcess == null ) {
+                return string.Empty;
+            }
+
+            string temp = string .Empty;
+            do {
+                temp = _dr.ReadLine();
+                temp = temp ?? string.Empty;
+                if( !temp!.StartsWith( target ) ) {
+                    break;
+                }
+            } while (true);
+
+            int index = temp.IndexOf( ' ' );
+            return index != -1 ? temp.Substring( index + 1 ) : string.Empty;
+        }
+
+    }
+}

StgSharp.Common/Environment/ErrorDefine.cs

@@ -0,0 +1,47 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="ErrorDefine.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.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp
+{
+    public class UniformEmptyReferenceException : Exception
+    {
+
+        public UniformEmptyReferenceException( string program, string name )
+            : base(
+            $"Location -1 returned when trying to find uniform {name} in shader program {program}" ) { }
+
+    }
+}

StgSharp.Common/Environment/GlobalSetting.cs

@@ -0,0 +1,108 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="GlobalSetting.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.Reflection;
+using System.Runtime.CompilerServices;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp
+{
+    public static unsafe partial class StgSharp
+    {
+
+        internal const int ssdSegmentLength = 16;
+
+        private static byte[] _currentHash;
+
+        private static bool _inited;
+        private static int _mainThreadID = -1;
+
+        public static byte[] CurrentAssemblyHash
+        {
+            get
+            {
+                if( _currentHash == null ) {
+                    string route = Assembly.GetExecutingAssembly().Location;
+                    string time = DateTime.UtcNow.ToString();
+                    using( SHA256 sh = SHA256.Create() ) {
+                        byte[] bytes = Encoding.UTF8.GetBytes( route );
+                        _currentHash = sh.ComputeHash( bytes );
+                    }
+                }
+                return _currentHash;
+            }
+        }
+
+        public static int MainThreadID
+        {
+            get => ( _mainThreadID == -1 ) ?
+            throw new InvalidOperationException(
+                "StgSharp environment is not inited. " + "Main thread id is not available" ) : _mainThreadID;
+        }
+
+        /// <summary>
+        /// CustomizeInit an instance of OpenGL program, This method should be called before any
+        /// other StgSharp api.
+        /// </summary>
+        public static void InitGL( int majorVersion, int minorVersion )
+        {
+            if( API == default ) {
+                API = GraphicAPI.GL;
+            }
+            if( API != GraphicAPI.GL ) {
+                return;
+            }
+            InternalIO.InternalInitGL( majorVersion, minorVersion );
+        }
+
+        public static class GlobalSetting
+        {
+
+            private static bool vSyncActivated;
+
+            public static bool VSyncActivated
+            {
+                get => vsyncActivated;
+                set
+                {
+                    InternalIO.glfwSwapInterval( value ? 1 : 0 );
+                    vsyncActivated = value;
+                }
+            }
+
+        }
+
+    }//-------------------------------------- End of Class ---------------------------------------//
+}

StgSharp.Common/Environment/Monitors.cs

@@ -0,0 +1,69 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Monitors.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 System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp
+{
+    public static partial class StgSharp
+    {
+
+        private static unsafe IntPtr[] monitorsArray;
+
+        public static unsafe IntPtr[] MonitorsHandleArray
+        {
+            get
+            {
+                if( monitorsArray == null ) {
+                    int count = 0;
+                    IntPtr* arrayhandle = InternalIO.glfwGetMonitors( &count );
+                    monitorsArray = new IntPtr[count];
+                    Marshal.Copy(
+                        ( IntPtr )arrayhandle, monitorsArray, 0, count );
+                    Marshal.FreeHGlobal( ( IntPtr )arrayhandle );
+                }
+                return monitorsArray;
+            }
+        }
+
+        public static IntPtr DefaultMonitor
+        {
+            get { return MonitorsHandleArray[ 0 ]; }
+        }
+
+    }
+}

StgSharp.Common/Environment/Platform.cs

@@ -0,0 +1,209 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Platform.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.Envitronment;
+// using StgSharp.Envitronment.Win32;
+// using StgSharp.Graphics;
+// using StgSharp.Math;
+
+using StgSharp.Internal;
+using StgSharp.Internal.Intrinsic;
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+#if Windows
+
+// using Windows.Win32.UI.WindowsAndMessaging;
+// using Windows.Win32;
+// using Windows.Win32.Foundation;
+// using Windows.Win32.Graphics.OpenGL;
+// using Windows.Win32.Graphics.Gdi;
+// using Windows.Win32.UI;
+
+#endif
+
+namespace StgSharp
+{
+    internal enum GraphicAPI : byte
+    {
+
+        GL,
+        DX,
+        VK
+
+    }
+
+    public static partial class StgSharp
+    {
+
+        /// <summary>
+        /// Version of current StgSharp platform. Main version represent in hundred's digit, and sub
+        /// version represent in ten's digit.
+        /// </summary>
+        public const long version = 430;
+
+        private static bool vsyncActivated;
+
+        private static uint markCount = 0;
+        internal static GraphicAPI API = default;
+
+        public static unsafe void Init()
+        {
+            mainTimeProvider = new StgSharpTime();
+            MainTimeProvider.StartProvidingTime();
+            InternalIO.glfwInit();
+            InternalIO.InternalAppendLog( "\n\n\n" );
+            InternalIO.InternalWriteLog(
+                $"Program {Assembly.GetEntryAssembly()!.FullName} Started.",
+                LogType.Info );
+            _mainThreadID = Environment.CurrentManagedThreadId;
+
+
+            Dialogue.LoadDialogue();
+            if (Dialogue.NeedShowWhenStartup)
+            {
+                Dialogue.CreateDialogueProcessIfNotExist();
+            }
+
+            InternalIO.InitIntrinsicContext();
+        }
+
+        public static void LogError( Exception ex )
+        {
+            InternalIO.InternalWriteLog( ex.Message, LogType.Error );
+        }
+
+        public static void LogInfo( string log )
+        {
+            InternalIO.InternalWriteLog( log, LogType.Info );
+        }
+
+        public static void LogWarning( string log )
+        {
+            InternalIO.InternalWriteLog( log, LogType.Warning );
+        }
+
+        public static void LogWarning( Exception notVerySeriesException )
+        {
+            InternalIO.InternalWriteLog(
+                notVerySeriesException.Message, LogType.Warning );
+        }
+
+        public static void Mark( bool needConsole )
+        {
+            markCount++;
+            if( needConsole ) {
+                Console.WriteLine( markCount );
+            }
+        }
+
+        public static void Terminate()
+        {
+            MainTimeProvider.StopProvidingTime();
+            InternalIO.glfwTerminate();
+        }
+
+        public static void Track(
+                               object target,
+                               string message,
+                               bool isConsole,
+                               [CallerFilePath] string filePath = "",
+                               [CallerMemberName] string callerName = "",
+                               [CallerLineNumber] int lineNumber = 0 )
+        {
+            Type t = target.GetType();
+            string log = $"Tracked object: {nameof(target)}\t\tType:{t.Name}\n";
+            FieldInfo[] fieldInfo = t.GetFields(
+                BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance );
+            log += "|\tFieldName\t|\tFieldType\t|\tFieldValue\t|\n";
+            foreach( FieldInfo field in fieldInfo ) {
+                log += $"|{field.Name}\t\t|{field.FieldType}\t\t|{field.GetValue(target)}\t\t|\n";
+            }
+            log += $"Tracking at:\n{filePath}\t{callerName}\tline {lineNumber}\n";
+            log += $"Additional information:\n{message}\n";
+            if( isConsole ) {
+                Console.WriteLine( log );
+            } else {
+                InternalIO.InternalWriteLog( log, LogType.Info );
+            }
+        }
+
+        /// <summary>
+        /// Write a log message to log file, and mark the _level of this message.
+        /// </summary>
+        /// <param _name="message"> A string contains information of how current evironment runs. </param>
+        /// <param _name="logType"> The severity of current message. </param>
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static void WriteLog( string message, LogType logType )
+        {
+            InternalIO.InternalWriteLog( message, logType );
+        }
+
+        internal static TDele ConvertAPI<TDele>( IntPtr funcPtr )
+        {
+            if( funcPtr == IntPtr.Zero ) {
+                throw new InvalidCastException(
+                    "Failed to convert api, the function pointer is zero." );
+            }
+            try {
+                return Marshal.GetDelegateForFunctionPointer<TDele>( funcPtr );
+            }
+            catch( Exception ) {
+                throw;
+            }
+        }
+
+        internal static Delegate ConvertAPI( IntPtr funcPtr, Type T )
+        {
+            if( funcPtr == IntPtr.Zero ) {
+                throw new InvalidCastException(
+                    "Failed to convert api, the function pointer is zero." );
+            }
+            try {
+                return Marshal.GetDelegateForFunctionPointer( funcPtr, T );
+            }
+            catch( Exception ) {
+                throw;
+            }
+        }
+
+    }
+}

StgSharp.Common/Environment/globalKeyStat.cs

@@ -0,0 +1,52 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="globalKeyStat.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.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp
+{
+    public static partial class StgSharp
+    {
+
+        private static ConcurrentDictionary<int, KeyStatus> keyListener
+            = new ConcurrentDictionary<int, KeyStatus>();
+
+        public static KeyStatus CheckKey( KeyboardKey key )
+        {
+            return keyListener.GetOrAdd( ( int )key, KeyStatus.RELEASE );
+        }
+
+    }
+}

StgSharp.Common/Geometries/Coordination/CoordinationBase.cs

@@ -0,0 +1,84 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="CoordinationBase.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.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Geometries
+{
+    public abstract class CoordinationBase
+    {
+
+        private bool globalCoordAvailable;
+        private CoordinationBase localCoordination;
+        private Matrix44 coordMat;
+
+        public CoordinationBase( CoordinationBase localCoordination )
+        {
+            this.localCoordination = localCoordination;
+            coordMat = new Matrix44();
+        }
+
+        public virtual Point LocalOrigin
+        {
+            get => new Point( coordMat.colum3.XYZ );
+            internal set => coordMat.colum3.XYZ = value.Coord;
+        }
+
+        public virtual Vec3 LocalX
+        {
+            get => coordMat.colum0.XYZ;
+            internal set => coordMat.colum0.XYZ = value;
+        }
+
+        public virtual Vec3 LocalY
+        {
+            get => coordMat.colum1.XYZ;
+            internal set => coordMat.colum1.XYZ = value;
+        }
+
+        public virtual Vec3 LocalZ
+        {
+            get => coordMat.colum2.XYZ;
+            set => coordMat.colum2.XYZ = value;
+        }
+
+        protected ref Matrix44 CoordMat
+        {
+            get => ref coordMat;
+        }
+
+    }
+}

StgSharp.Common/Geometries/Coordination/PlainCoordinate.cs

@@ -0,0 +1,67 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="PlainCoordinate.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.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Net.Http.Headers;
+using System.Text;
+
+namespace StgSharp.Geometries
+{
+    public class PlainCoordinate : CoordinationBase
+    {
+
+        private static PlainCoordinate statndardPlainCoordination = new PlainCoordinate(
+            null, new Point( 0, 0, 0 ), new Vec3( 1, 0, 0 ),
+            new Vec3( 0, 1, 0 ) );
+
+        public PlainCoordinate(
+            CoordinationBase local,
+            Point origin,
+            Vec3 xAxis,
+            Vec3 yAxis )
+            : base( local )
+        {
+            CoordMat = Matrix44.Unit;
+
+            CoordMat.colum0 = new Vec4( xAxis, 0 );
+            CoordMat.colum1 = new Vec4( yAxis, 0 );
+            CoordMat.colum2 = new Vec4(
+                Linear.Normalize( Vec3.Cross( xAxis, yAxis ) ), 0 );
+
+            LocalOrigin = origin;
+        }
+
+        public static PlainCoordinate StandardPlainCoordination => statndardPlainCoordination;
+
+    }
+}

StgSharp.Common/Geometries/Coordination/SpaceCoordinate.cs

@@ -0,0 +1,51 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="SpaceCoordinate.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.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Geometries
+{
+    public class SpaceCoordinate : CoordinationBase
+    {
+
+        public SpaceCoordinate(
+            CoordinationBase localCoordination,
+            Point origin,
+            Vec3 xAxis,
+            Vec3 yAxis,
+            Vec3 zAxis )
+            : base( localCoordination ) { }
+
+    }
+}

StgSharp.Common/Geometries/Coordination/StreamLocalCoordinate.cs

@@ -0,0 +1,46 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="StreamLocalCoordinate.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.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Geometries
+{
+    /*
+    public class StreamLocalCoordinate : CoordinationBase
+    {
+    }
+    /**/
+}

StgSharp.Common/Geometries/GemoryException.cs

@@ -0,0 +1,74 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="GemoryException.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.Runtime.Serialization;
+
+namespace StgSharp.Geometries
+{
+    public unsafe class ToUpperDimensionException : Exception
+    {
+
+        protected ToUpperDimensionException(
+            SerializationInfo info,
+            StreamingContext context )
+            : base( info, context ) { }
+
+        public ToUpperDimensionException() { }
+
+        public ToUpperDimensionException( string message ) : base( message ) { }
+
+        public ToUpperDimensionException(
+            string message,
+            Exception innerException )
+            : base( message, innerException ) { }
+
+    }
+
+    /// <summary>
+    /// 当几何体调用了过多的CalcVec方法时，产生UnusedVertexException异常
+    /// </summary>
+    public class UnusedVertexException : Exception
+    {
+
+        protected UnusedVertexException(
+            SerializationInfo info,
+            StreamingContext context )
+            : base( info, context ) { }
+
+        public UnusedVertexException() { }
+
+        public UnusedVertexException( string message ) : base( message ) { }
+
+        public UnusedVertexException( string message, Exception innerException )
+            : base( message, innerException ) { }
+
+    }
+}

StgSharp.Common/Geometries/GeometryOperation/GeometryOperation.cs

@@ -0,0 +1,116 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="GeometryOperation.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.Math;
+using StgSharp.Timing;
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace StgSharp.Geometries
+{
+[UnmanagedFunctionPointer( CallingConvention.Cdecl )]
+    public delegate Vec3 GeometryMotionDelegate(
+        TimeSpanProvider timeSource,
+        out float rotation );
+
+    public class GeometryMotion
+    {
+
+        private bool isIncrementMode;
+        private bool sourceIsStatic;
+        private GeometryMotionDelegate movement;
+        private IntPtr handle;
+        private TimeSpanProvider time;
+
+        public unsafe GeometryMotion(
+            bool isIncreament,
+            TimeSpanProvider timeSource,
+            GeometryMotionDelegate motionDelegate )
+        {
+            isIncrementMode = isIncreament;
+            time = timeSource;
+            if( motionDelegate == null ) {
+                handle = ( IntPtr )( delegate*<TimeSpanProvider, out float, Vec3> )&defaultMotion;
+                movement = defaultMotion;
+            } else if( motionDelegate.Method.IsStatic ) {
+                sourceIsStatic = true;
+                handle = Marshal.GetFunctionPointerForDelegate( motionDelegate );
+                movement = motionDelegate;
+            } else {
+                movement = motionDelegate;
+            }
+
+            //sourceIsStatic = false;
+        }
+
+        public bool IsIncrement
+        {
+            get => isIncrementMode;
+        }
+
+        public static GeometryMotion DefaultMotion
+        {
+            get => new GeometryMotion( true, null, null );
+        }
+
+        public unsafe void RunMotion( ref Vec3 coord, ref float rotation )
+        {
+            float rot;
+            Vec3 vec;
+            if( sourceIsStatic ) {
+                vec = ( ( delegate* unmanaged[Cdecl]<TimeSpanProvider, out float, Vec3> )handle )(
+                    time, out rot );
+            } else {
+                vec = movement( time, out rot );
+            }
+
+            if( isIncrementMode ) {
+                coord += vec;
+                rotation += rot;
+            } else {
+                coord = vec;
+                rotation = rot;
+            }
+        }
+
+        private static Vec3 defaultMotion(
+            TimeSpanProvider provider,
+            out float rotation )
+        {
+            rotation = 0;
+            return Vec3.Zero;
+        }
+
+    }//------------------------------- End of Class -------------------------------
+}

StgSharp.Common/Geometries/GeometryScaler/Angle.cs

@@ -0,0 +1,178 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Angle.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.Tasks;
+
+namespace StgSharp.Math
+{
+    public static partial class GeometryScaler
+    {
+
+        internal const float DegToRad = 180 / Scaler.Pi;
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static float Cos( Radius r )
+        {
+            return MathF.Cos( r._radius );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static float Cos( Degree r )
+        {
+            return MathF.Cos( r._degree / DegToRad );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static float Sin( Radius r )
+        {
+            return MathF.Sin( r._radius );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static float Sin( Degree r )
+        {
+            return MathF.Sin( r._degree / DegToRad );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static float Tan( Radius r )
+        {
+            return MathF.Tan( r._radius );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static float Tan( Degree r )
+        {
+            return MathF.Tan( r._degree / DegToRad );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Degree ToDegree( float value )
+        {
+            return new Degree( value );
+        }
+
+    }
+
+    public struct Degree
+    {
+
+        internal float _degree;
+
+        public Degree( float dgree )
+        {
+            _degree = dgree;
+        }
+
+        public static implicit operator Radius( Degree d )
+        {
+            return new Radius( d._degree / GeometryScaler.DegToRad );
+        }
+
+    }
+
+    public struct Radius
+    {
+
+        internal float _radius;
+
+        [Obsolete( "Unsafe, you may forget this is radius.", true )]
+        public Radius() { }
+
+        public Radius( float radius )
+        {
+            _radius = radius;
+        }
+
+        public static Radius Zero
+        {
+            get => new Radius( 0 );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Radius operator -( Radius r )
+        {
+            return new Radius( -r._radius );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Radius operator -( Radius left, Radius Right )
+        {
+            return new Radius( left._radius - Right._radius );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static bool operator !=( Radius left, Radius right )
+        {
+            return left._radius != right._radius;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Radius operator *( Radius left, float right )
+        {
+            return new Radius( left._radius * right );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Radius operator /( Radius left, float right )
+        {
+            return new Radius( left._radius / right );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static float operator /( Radius left, Radius right )
+        {
+            return left._radius / right._radius;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Radius operator +( Radius left, Radius Right )
+        {
+            return new Radius( left._radius + Right._radius );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static bool operator ==( Radius left, Radius right )
+        {
+            return left._radius == right._radius;
+        }
+
+        public static implicit operator Degree( Radius r )
+        {
+            return new Degree( ( r._radius * 180 ) / Scaler.Pi );
+        }
+
+    }
+}

StgSharp.Common/Geometries/IGeometry.cs

@@ -0,0 +1,74 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="IGeometry.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.Math;
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Geometries
+{
+    public interface IGeometry
+    {
+
+        public Point this[ int index ]
+        {
+            get;
+            set;
+        }
+
+        #pragma warning disable CA1819 
+        public Vec4[] VertexStream
+        #pragma warning restore CA1819 
+        {
+            get;
+        }
+
+        public CoordinationBase Coordination
+        {
+            get;
+        }
+
+        public int VertexCount
+        {
+            get;
+        }
+
+        public ReadOnlySpan<int> VertexIndices
+        {
+            get;
+        }
+
+    }
+}

StgSharp.Common/Geometries/IGeomtryBuffer.cs

@@ -0,0 +1,40 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="IGeomtryBuffer.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.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Geometries
+{
+    public interface IGeomtryBuffer { }
+}

StgSharp.Common/Geometries/IInstancing.cs

@@ -0,0 +1,102 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="IInstancing.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.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using System.Security.Cryptography.X509Certificates;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Geometries
+{
+    public interface IInstancing
+    {
+
+        public float Rotation
+        {
+            get { return GlobalBuffer.CoordAndRotationList[ BufferId ].W; }
+            set
+            {
+                Vec4 temp = GlobalBuffer.CoordAndRotationList[ BufferId ];
+                temp.W = value;
+                GlobalBuffer.CoordAndRotationList[ BufferId ] = temp;
+            }
+        }
+
+        public float Scale
+        {
+            get { return GlobalBuffer.ScalingList[ BufferId ]; }
+            set { GlobalBuffer.ScalingList[ BufferId ] = value; }
+        }
+
+        public GeometryMotion Motion
+        {
+            get;
+            set;
+        }
+
+        public IInstancingBuffer GlobalBuffer
+        {
+            get;
+            internal set;
+        }
+
+        public int BufferId
+        {
+            get;
+            internal set;
+        }
+
+        public Vec3 CenterPositionGlobal
+        {
+            get;
+            internal set;
+        }
+
+        public Vec3 Coord
+        {
+            get { return GlobalBuffer.CoordAndRotationList[ BufferId ].XYZ; }
+            set { GlobalBuffer.CoordAndRotationList[ BufferId ] = new Vec4(
+                      value.vec ); }
+        }
+
+        public void Move()
+        {
+            (Vec3 coord, float rotation) = (Coord, Rotation);
+            Motion.RunMotion( ref coord, ref rotation );
+            (Coord, Rotation) = (coord, rotation);
+        }
+
+    }
+}

StgSharp.Common/Geometries/IInstancingBuffer.cs

@@ -0,0 +1,73 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="IInstancingBuffer.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.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Geometries
+{
+    public interface IInstancingBuffer
+    {
+
+        public Span<Vec4> CoordAndRotationSpan
+        {
+            get;
+        }
+
+        public Span<float> ScalingSpan
+        {
+            get;
+        }
+
+        internal IGeometry TypicalShape
+        {
+            get;
+        }
+
+        internal List<IInstancing> InstanceList
+        {
+            get;
+        }
+
+        internal List<Vec4> CoordAndRotationList
+        {
+            get;
+        }
+
+        internal List<float> ScalingList
+        {
+            get;
+        }
+
+    }
+}

StgSharp.Common/Geometries/PlainGeometry/Cordinate.cs

@@ -0,0 +1,85 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Cordinate.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.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Geometries
+{
+    [StructLayout( LayoutKind.Sequential )]
+    public struct PartialPlainCoordinate
+    {
+
+        internal Matrix32 axis;
+
+        /// <summary>
+        /// The origin of this coordinate.
+        /// </summary>
+        public Vec3 origin;
+
+        public PartialPlainCoordinate(
+            Vec3 origin,
+            Vec3 horiziontial,
+            Vec3 vertical )
+        {
+            this.origin = origin;
+            axis = new Matrix32();
+            #if NET5_0_OR_GREATER
+            Unsafe.SkipInit( out axis.mat );
+            #endif
+            axis.colum0 = horiziontial;
+            axis.colum1 = vertical;
+        }
+
+        /// <summary>
+        /// The horizontial axis of the coordinate. Point to the right direction.
+        /// </summary>
+        public Vec3 axis_H => axis.colum0;
+
+        /// <summary>
+        /// The vertical axis of the coordinate. Point to the top direction.
+        /// </summary>
+        public Vec3 axis_V => axis.colum1;
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public Vec3 GetRealLocate( Vec2 raletiveLocation )
+        {
+            return origin + axis.VerticalVecMultiply( raletiveLocation );
+        }
+
+    }
+}

StgSharp.Common/Geometries/PlainGeometry/Define/GeometryOperation.cs

@@ -0,0 +1,47 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="GeometryOperation.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.Math;
+
+using System.Runtime.CompilerServices;
+
+namespace StgSharp.Geometries
+{
+    public static unsafe class GeometryOperation
+    {
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static Vec3 DefaultMotion( int tick )
+        {
+            return default( Vec3 );
+        }
+
+    }
+}

StgSharp.Common/Geometries/PlainGeometry/Define/IPlainEntity.cs

@@ -0,0 +1,76 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="IPlainEntity.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.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Geometries
+{
+    public interface IPlainEntity
+    {
+
+        public Vec2 CenterPosition
+        {
+            get;
+            set;
+        }
+
+        public bool CollideWith( IPlainEntity entity );
+
+    }
+
+    public class PlainEntity : IPlainEntity
+    {
+
+        private PlainGeometry _shape;
+
+        public PlainEntity( PlainGeometry shape )
+        {
+            _shape = shape;
+        }
+
+        bool IPlainEntity.CollideWith( IPlainEntity entity )
+        {
+            throw new NotImplementedException();
+        }
+
+        Vec2 IPlainEntity.CenterPosition
+        {
+            get => _shape.Coordination.LocalOrigin.Coord.XY;
+            set => throw new InvalidOperationException();
+        }
+
+    }
+}

StgSharp.Common/Geometries/PlainGeometry/Define/ParticleOnPlain.cs

@@ -0,0 +1,92 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="ParticleOnPlain.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.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Numerics;
+using System.Security.Cryptography.X509Certificates;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Geometries
+{
+    public class ParticleOnPlain : IInstancing, IPlainEntity
+    {
+
+        public ParticleOnPlain( PlainInstancingBuffer<ParticleOnPlain> buffer )
+        {
+            if( buffer == null ) {
+                throw new ArgumentNullException( paramName: nameof( buffer ) );
+            }
+            GlobalBuffer = buffer;
+            BufferId = buffer.CreateInstanceID();
+            ( ( IInstancingBuffer )buffer ).InstanceList.Add( this );
+        }
+
+        public GeometryMotion Motion
+        {
+            get;
+            set;
+        }
+
+        public IInstancingBuffer GlobalBuffer
+        {
+            get;
+            set;
+        }
+
+        public int BufferId
+        {
+            get;
+            set;
+        }
+
+        Vec3 IInstancing.CenterPositionGlobal
+        {
+            get;
+            set;
+        }
+
+        bool IPlainEntity.CollideWith( IPlainEntity entity )
+        {
+            throw new NotImplementedException();
+        }
+
+        Vec2 IPlainEntity.CenterPosition
+        {
+            get => GlobalBuffer.CoordAndRotationList[ BufferId ].XY;
+            set => throw new NotImplementedException();
+        }
+
+    }
+}

StgSharp.Common/Geometries/PlainGeometry/Define/PlainGeometry.cs

@@ -0,0 +1,72 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="PlainGeometry.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.ComponentModel;
+
+namespace StgSharp.Geometries
+{
+    /// <summary>
+    /// Plain geometry only contains straight sides.
+    /// </summary>
+    public abstract class PlainGeometry : IGeometry
+    {
+
+        protected Vec4[] vertexMat;
+        internal CoordinationBase coordinate;
+
+        internal PlainGeometry( CoordinationBase coordination )
+        {
+            coordinate = coordination;
+        }
+
+        public Point this[ int index ]
+        {
+            get => new Point( vertexMat[ index ] );
+            set => vertexMat[ index ].vec = value.coordVec;
+        }
+
+        public int VertexCount => this.vertexMat.Length;
+
+        public abstract ReadOnlySpan<int> VertexIndices
+        {
+            get;
+        }
+
+        #pragma warning disable CA1819 
+        public Vec4[] VertexStream => vertexMat;
+
+        public CoordinationBase Coordination => this.coordinate;
+#pragma warning restore CA1819
+    }
+}

StgSharp.Common/Geometries/PlainGeometry/Define/PlainInstancingBuffer.cs

@@ -0,0 +1,217 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="PlainInstancingBuffer.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.Math;
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics.Contracts;
+using System.Linq;
+using System.Numerics;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace StgSharp.Geometries
+{
+    public class PlainInstancingBuffer<T> : IDisposable, IEnumerable<T>, IInstancingBuffer
+        where T: IInstancing
+    {
+
+        private bool disposedValue;
+
+        private CoordinatePlain globalCorrdinnate;
+        private List<Vec4> coordList;
+        private List<IInstancing> instanceList;
+        private List<float> scalingList;
+        private Mutex mutex;
+
+        public PlainInstancingBuffer()
+        {
+            coordList = new List<Vec4>( capacity: 100 );
+            instanceList = new List<IInstancing>( capacity: 100 );
+            scalingList = new List<float>( capacity: 100 );
+            coordArray = Array.Empty<Vec4>();
+            scaleArray = Array.Empty<float>();
+            mutex = new Mutex();
+        }
+
+        public List<IInstancing> InstanceList
+        {
+            get => instanceList;
+        }
+
+        public List<Vec4> CoordAndRotationList
+        {
+            get => coordList;
+        }
+
+        public List<float> ScalingList
+        {
+            get => scalingList;
+        }
+
+        public Span<Vec4> CoordAndRotationSpan
+        {
+            get
+            {
+                if( coordArray.Length != coordList.Capacity ) {
+                    FieldInfo fieldInfo = typeof( List<Vec4> ).
+                        GetField(
+                            "_items",
+                            BindingFlags.NonPublic | BindingFlags.Instance );
+                    if( fieldInfo == null ) {
+                        #pragma warning disable CA1065
+                        #pragma warning disable CA2201
+                        throw new NullReferenceException();
+                        #pragma warning restore CA2201
+                        #pragma warning restore CA1065
+                    }
+                    coordArray = ( Vec4[] )fieldInfo.GetValue( coordList );
+                }
+                return new Span<Vec4>( coordArray, 0, coordList.Count );
+            }
+        }
+
+        public Span<float> ScalingSpan
+        {
+            get
+            {
+                if( scaleArray.Length != coordList.Capacity ) {
+                    FieldInfo fieldInfo = typeof( List<float> ).
+                        GetField(
+                            "_items",
+                            BindingFlags.NonPublic | BindingFlags.Instance );
+                    if( fieldInfo == null ) {
+                        #pragma warning disable CA1065
+                        #pragma warning disable CA2201
+                        throw new NullReferenceException();
+                        #pragma warning restore CA2201
+                        #pragma warning restore CA1065
+                    }
+                    scaleArray = ( float[] )fieldInfo.GetValue( scalingList );
+                }
+                return new Span<float>( scaleArray, 0, coordList.Count );
+            }
+        }
+
+        public int CreateInstanceID()
+        {
+            mutex.WaitOne();
+            int ret = instanceList.Count;
+            coordList.Add( new Vec4() );
+            scalingList.Add( 0 );
+            mutex.ReleaseMutex();
+            return ret;
+        }
+
+        // ~PlainInstancingBuffer()
+        // {
+        //     Dispose(disposing: false);
+        // }
+
+        public void Dispose()
+        {
+            Dispose( disposing: true );
+            GC.SuppressFinalize( this );
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            foreach( IInstancing item in instanceList ) {
+                yield return ( T )item;
+            }
+        }
+
+        public void Remove( T instance )
+        {
+            mutex.WaitOne();
+            if( instance.GlobalBuffer != this ) {
+                throw new ArgumentException(
+                    message: "instance does not belong to current Particle Buffer",
+                    paramName: nameof( instance ) );
+            }
+            int index = instance.BufferId;
+            IInstancing temp = instanceList[ instanceList.Count - 1 ];
+            instanceList[ instance.BufferId ] = temp;
+            temp.BufferId = instance.BufferId;
+
+            coordList[ instance.BufferId ] = coordList[ coordList.Count - 1 ];
+            scalingList[ instance.BufferId ] = scalingList[
+                scalingList.Count - 1 ];
+
+            instanceList.RemoveAt( instanceList.Count - 1 );
+            coordList.RemoveAt( coordList.Count - 1 );
+            scalingList.RemoveAt( scalingList.Count - 1 );
+            mutex.ReleaseMutex();
+        }
+
+        public void UpdateAllParticles()
+        {
+            foreach( IInstancing particle in instanceList ) {
+                particle.Move();
+            }
+        }
+
+        protected virtual void Dispose( bool disposing )
+        {
+            if( !disposedValue ) {
+                if( disposing ) {
+                    mutex.Dispose();
+                }
+
+                coordList.Clear();
+                instanceList.Clear();
+                scalingList.Clear();
+                disposedValue = true;
+            }
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            foreach( IInstancing item in instanceList ) {
+                yield return ( T )item;
+            }
+        }
+
+        IGeometry IInstancingBuffer.TypicalShape => throw new NotImplementedException(
+            );
+
+        #region field of mem opt
+
+        private Vec4[] coordArray;
+        private float[] scaleArray;
+
+    #endregion
+    }
+}

StgSharp.Common/Geometries/PlainGeometry/Parallelogram.cs

@@ -0,0 +1,88 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Parallelogram.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.Math;
+
+using System;
+
+namespace StgSharp.Geometries
+{
+    public class Parallelogram : Polygon4
+    {
+
+        internal readonly Func<int, Vec3> movCenterOperation =
+            new Func<int, Vec3>( GeometryOperation.DefaultMotion );
+
+        internal Point center;
+
+        public Parallelogram(
+            float v0x,
+            float v0y,
+            float v1x,
+            float v1y,
+            float v2x,
+            float v2y,
+            float v3x,
+            float v3y )
+            : base( v0x, v0y, v1x, v1y, v2x, v2y, v3x, v3y )
+        {
+            #if DEBUG
+            if( this[ 0 ].Coord + this[ 2 ].Coord != this[ 1 ].Coord + this[ 3 ].Coord ) {
+                InternalIO.InternalWriteLog(
+                    "Init of geometry item failed, because four vertices cannot form a rectangle.",
+                    LogType.Warning );
+            }
+            #endif
+        }
+
+        public Parallelogram(
+            PlainCoordinate coordination,
+            float v0x,
+            float v0y,
+            float v1x,
+            float v1y,
+            float v2x,
+            float v2y,
+            float v3x,
+            float v3y )
+            : base( coordination, v0x, v0y, v1x, v1y, v2x, v2y, v3x, v3y )
+        {
+            #if DEBUG
+            if( this[ 0 ].Coord + this[ 2 ].Coord != this[ 1 ].Coord + this[ 3 ].Coord ) {
+                InternalIO.InternalWriteLog(
+                    "Init of geometry item failed, because four vertices cannot form a rectangle.",
+                    LogType.Warning );
+            }
+            #endif
+        }
+
+    }
+}

StgSharp.Common/Geometries/PlainGeometry/Plain.cs

@@ -0,0 +1,96 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Plain.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.Math;
+
+using System.Numerics;
+
+namespace StgSharp.Geometries
+{
+    public unsafe class Plain
+    {
+
+        internal readonly float d = -1;
+        internal Vec3 origin;
+
+        internal Vec3 plainParameter;
+        internal Vec3 vec1;
+        internal Vec3 vec2;
+
+        internal Plain( Vector4 origin, Vector4 p1, Vector4 p2 )
+        {
+            this.origin = new Vec3( origin );
+
+            vec1 = new Vec3( p1 - origin );
+            vec2 = new Vec3( p2 - origin );
+        }
+
+        public Plain( Vec3 o, Vec3 v1, Vec3 v2 )
+        {
+            this.origin = o;
+            this.vec1 = v1 - ( v2 * ( v1.Y / v2.Y ) );   //计算平面在xz平面上的方向投影
+            this.vec2 = v2 - ( vec1 * ( v2.X / v1.X ) ); //计算平面在yz平面上的方向投影
+
+            //|origin|-k1*|vec1|-k2*|vec2|计算plainParameter.Z；
+            plainParameter.Z = origin.Z - ( vec1.Z * ( origin.X / vec1.X ) ) - ( vec2.Z * ( origin.Y / vec2.Y ) );
+
+            //根据plainParameter.Z和对应的方向矢量计算plainParameter.X和plainParameter.Y
+            plainParameter.X = vec1.X * ( vec1.Z / plainParameter.Z );
+            plainParameter.Y = vec2.Y * ( vec2.Z / plainParameter.Z );
+
+            plainParameter.X = 1 / plainParameter.X;
+            plainParameter.Y = 1 / plainParameter.Y;
+            plainParameter.Z = 1 / plainParameter.Z;
+        }
+
+        public Plain( Point p1, Point p2, Point p3 )
+        {
+            Vec3 origin = p1.Coord;
+            Vec3 v1 = p2.Coord - origin;
+            Vec3 v2 = p3.Coord - origin;
+
+
+            vec1 = v1 - ( v2 * ( v1.Y / v2.Y ) );   //计算平面在xz平面上的方向投影
+            vec2 = v2 - ( vec1 * ( v2.X / v1.X ) ); //计算平面在yz平面上的方向投影
+
+            //|origin|-k1*|vec1|-k2*|vec2|计算plainParameter.Z；
+            plainParameter.Z = origin.Z - ( vec1.Z * ( origin.X / vec1.X ) ) - ( vec2.Z * ( origin.Y / vec2.Y ) );
+
+            //根据plainParameter.Z和对应的方向矢量计算plainParameter.X和plainParameter.Y
+            plainParameter.X = vec1.X * ( vec1.Z / plainParameter.Z );
+            plainParameter.Y = vec2.Y * ( vec2.Z / plainParameter.Z );
+
+            plainParameter.X = 1 / plainParameter.X;
+            plainParameter.Y = 1 / plainParameter.Y;
+            plainParameter.Z = 1 / plainParameter.Z;
+        }
+
+    }
+}

StgSharp.Common/Geometries/PlainGeometry/Polygon4.cs

@@ -0,0 +1,129 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Polygon4.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.Math;
+
+using System;
+using System.Numerics;
+
+namespace StgSharp.Geometries
+{
+    public class Polygon4 : PlainGeometry
+    {
+
+        protected static int[] Indices = [0, 1, 2, 0, 2, 3];
+
+        internal Polygon4()
+            : base( PlainCoordinate.StandardPlainCoordination )
+        {
+            vertexMat = new Vec4[4];
+        }
+
+        internal Polygon4( Vec4[] rawCoord )
+            : base( PlainCoordinate.StandardPlainCoordination )
+        {
+            if( rawCoord.Length != 4 ) {
+                throw new ArgumentOutOfRangeException( nameof( rawCoord ) );
+            }
+            vertexMat = rawCoord;
+        }
+
+        public Polygon4(
+            Point topLeft,
+            Point topRight,
+            Point bottomRight,
+            Point bottomLeft )
+            : base( PlainCoordinate.StandardPlainCoordination )
+        {
+            this[ 0 ] = topLeft;
+            this[ 1 ] = topRight;
+            this[ 2 ] = bottomRight;
+            this[ 3 ] = bottomLeft;
+        }
+
+        public Polygon4(
+            CoordinationBase coordinate,
+            PlainCoordinate coordination,
+            Point topLeft,
+            Point topRight,
+            Point bottomRight,
+            Point bottomLeft )
+            : base( coordinate )
+        {
+            this[ 0 ] = topLeft;
+            this[ 1 ] = topRight;
+            this[ 2 ] = bottomRight;
+            this[ 3 ] = bottomLeft;
+        }
+
+        public Polygon4(
+            float v0x,
+            float v0y,
+            float v1x,
+            float v1y,
+            float v2x,
+            float v2y,
+            float v3x,
+            float v3y )
+            : base( PlainCoordinate.StandardPlainCoordination )
+        {
+            vertexMat = new Vec4[4];
+
+            this[ 0 ] = new Point( v0x, v0y, 0 );
+            this[ 1 ] = new Point( v1x, v1y, 0 );
+            this[ 2 ] = new Point( v2x, v2y, 0 );
+            this[ 3 ] = new Point( v3x, v3y, 0 );
+        }
+
+        public Polygon4(
+            PlainCoordinate coordination,
+            float v0x,
+            float v0y,
+            float v1x,
+            float v1y,
+            float v2x,
+            float v2y,
+            float v3x,
+            float v3y )
+            : base( coordination )
+        {
+            vertexMat = new Vec4[4];
+
+            this[ 0 ] = new Point( v0x, v0y, 0 );
+            this[ 1 ] = new Point( v1x, v1y, 0 );
+            this[ 2 ] = new Point( v2x, v2y, 0 );
+            this[ 3 ] = new Point( v3x, v3y, 0 );
+        }
+
+        public override ReadOnlySpan<int> VertexIndices => Indices;
+
+    }
+}

StgSharp.Common/Geometries/PlainGeometry/Polygon5.cs

@@ -0,0 +1,96 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Polygon5.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.Math;
+
+using System;
+using System.Numerics;
+
+namespace StgSharp.Geometries
+{
+    public unsafe class Polygon5 : PlainGeometry
+    {
+
+        internal static int[] Indices = [0, 1, 2, 0, 2, 3, 0, 3, 4];
+
+        public unsafe Polygon5()
+            : base( PlainCoordinate.StandardPlainCoordination )
+        {
+            vertexMat = new Vec4[5];
+        }
+
+        public Polygon5(
+            float v0x,
+            float v0y,
+            float v1x,
+            float v1y,
+            float v2x,
+            float v2y,
+            float v3x,
+            float v3y,
+            float v4x,
+            float v4y )
+            : base( PlainCoordinate.StandardPlainCoordination )
+        {
+            vertexMat = new Vec4[5];
+            this[ 0 ] = new Point( v0x, v0y, 0 );
+            this[ 1 ] = new Point( v1x, v1y, 0 );
+            this[ 2 ] = new Point( v2x, v2y, 0 );
+            this[ 3 ] = new Point( v3x, v3y, 0 );
+            this[ 4 ] = new Point( v4x, v4y, 0 );
+        }
+
+        public Polygon5(
+            PlainCoordinate coordination,
+            float v0x,
+            float v0y,
+            float v1x,
+            float v1y,
+            float v2x,
+            float v2y,
+            float v3x,
+            float v3y,
+            float v4x,
+            float v4y )
+            : base( coordination )
+        {
+            vertexMat = new Vec4[5];
+            this[ 0 ] = new Point( v0x, v0y, 0 );
+            this[ 1 ] = new Point( v1x, v1y, 0 );
+            this[ 2 ] = new Point( v2x, v2y, 0 );
+            this[ 3 ] = new Point( v3x, v3y, 0 );
+            this[ 4 ] = new Point( v4x, v4y, 0 );
+        }
+
+        public override ReadOnlySpan<int> VertexIndices => Indices;
+
+    }
+}

StgSharp.Common/Geometries/PlainGeometry/Polygon6.cs

@@ -0,0 +1,74 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Polygon6.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.Math;
+
+using System;
+using System.Numerics;
+
+namespace StgSharp.Geometries
+{
+    public class Polygon6 : PlainGeometry
+    {
+
+        internal static int[] Indices = [0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 5];
+
+        public Polygon6()
+            : base( PlainCoordinate.StandardPlainCoordination )
+        {
+            vertexMat = new Vec4[6];
+        }
+
+        public Polygon6(
+            PlainCoordinate coordination,
+            Vec2 vert0,
+            Vec2 vert1,
+            Vec2 vert2,
+            Vec2 vert3,
+            Vec2 vert4,
+            Vec2 vert5,
+            Vec2 vert6 )
+            : base( coordination )
+        {
+            vertexMat = new Vec4[6];
+            vertexMat[ 0 ].vec = vert0.vec;
+            vertexMat[ 1 ].vec = vert1.vec;
+            vertexMat[ 2 ].vec = vert2.vec;
+            vertexMat[ 3 ].vec = vert3.vec;
+            vertexMat[ 4 ].vec = vert4.vec;
+            vertexMat[ 5 ].vec = vert5.vec;
+            vertexMat[ 6 ].vec = vert6.vec;
+        }
+
+        public override ReadOnlySpan<int> VertexIndices => Indices;
+
+    }
+}

StgSharp.Common/Geometries/PlainGeometry/Rectangle.cs

@@ -0,0 +1,93 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Rectangle.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.Math;
+
+using System;
+using System.Numerics;
+
+namespace StgSharp.Geometries
+{
+    public class Rectangle : Parallelogram
+    {
+
+        public Rectangle(
+            float v0x,
+            float v0y,
+            float v1x,
+            float v1y,
+            float v2x,
+            float v2y,
+            float v3x,
+            float v3y )
+            : base( v0x, v0y, v1x, v1y, v2x, v2y, v3x, v3y )
+        {
+            #if DEBUG
+            Vec2 side0 = ( this[ 0 ].Coord - this[ 1 ].Coord ).XY;
+            Vec2 side1 = ( this[ 2 ].Coord - this[ 1 ].Coord ).XY;
+            if( side0.Cross( side1 ) == 0 ) {
+                throw new ArgumentException();
+            }
+            #endif
+        }
+
+        public Rectangle(
+            PlainCoordinate coordination,
+            float v0x,
+            float v0y,
+            float v1x,
+            float v1y,
+            float v2x,
+            float v2y,
+            float v3x,
+            float v3y )
+            : base( coordination, v0x, v0y, v1x, v1y, v2x, v2y, v3x, v3y )
+        {
+            #if DEBUG
+            Vec2 side0 = ( this[ 0 ].Coord - this[ 1 ].Coord ).XY;
+            Vec2 side1 = ( this[ 2 ].Coord - this[ 1 ].Coord ).XY;
+            if( side0.Cross( side1 ) == 0 ) {
+                throw new ArgumentException();
+            }
+            #endif
+        }
+
+        /// <summary>
+        /// Calculate movement to center
+        /// </summary>
+        /// <param _name="tick"> CurrentBlueprint time tick </param>
+        /// <returns></returns>
+        public virtual Vec3 MovCenter( uint tick )
+        {
+            return default( Vec3 );
+        }
+
+    }
+}

StgSharp.Common/Geometries/PlainGeometry/Square.cs

@@ -0,0 +1,58 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Square.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.Math;
+
+using System.Numerics;
+
+namespace StgSharp.Geometries
+{
+    /// <summary>
+    /// A square
+    /// </summary>
+    public class Square : Rectangle
+    {
+
+        public Square(
+            float v0x,
+            float v0y,
+            float v1x,
+            float v1y,
+            float v2x,
+            float v2y,
+            float v3x,
+            float v3y )
+            : base( v0x, v0y, v1x, v1y, v2x, v2y, v3x, v3y )
+        {
+            if( true ) { }
+        }
+
+    }
+}

StgSharp.Common/Geometries/PlainGeometry/Triangle.cs

@@ -0,0 +1,103 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Triangle.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.Numerics;
+
+namespace StgSharp.Geometries
+{
+    public unsafe class Triangle : PlainGeometry
+    {
+
+        internal static int[] Indices = [0, 1, 2];
+
+        public Triangle()
+            : base( PlainCoordinate.StandardPlainCoordination )
+        {
+            vertexMat = new Vec4[3];
+        }
+
+        public Triangle( Point vertex01, Point vertex02, Point vertex03 )
+            : base( PlainCoordinate.StandardPlainCoordination )
+        {
+            this[ 0 ] = vertex01;
+            this[ 1 ] = vertex02;
+            this[ 2 ] = vertex03;
+        }
+
+        public Triangle(
+            PlainCoordinate coordination,
+            Point vertex01,
+            Point vertex02,
+            Point vertex03 )
+            : base( coordination )
+        {
+            this[ 0 ] = vertex01;
+            this[ 1 ] = vertex02;
+            this[ 2 ] = vertex03;
+        }
+
+        public Triangle(
+            float v0x,
+            float v0y,
+            float v1x,
+            float v1y,
+            float v2x,
+            float v2y )
+            : base( PlainCoordinate.StandardPlainCoordination )
+        {
+            this[ 0 ] = new Point( v0x, v0y, 0 );
+            this[ 1 ] = new Point( v1x, v1y, 0 );
+            this[ 2 ] = new Point( v2x, v2y, 0 );
+        }
+
+        public Triangle(
+            PlainCoordinate coordination,
+            float v0x,
+            float v0y,
+            float v1x,
+            float v1y,
+            float v2x,
+            float v2y )
+            : base( coordination )
+        {
+            this[ 0 ] = new Point( v0x, v0y, 0 );
+            this[ 1 ] = new Point( v1x, v1y, 0 );
+            this[ 2 ] = new Point( v2x, v2y, 0 );
+        }
+
+        public override ReadOnlySpan<int> VertexIndices => Indices;
+
+    }
+}

StgSharp.Common/Geometries/Point.cs

@@ -0,0 +1,76 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Point.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.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace StgSharp.Geometries
+{
+    [StructLayout( LayoutKind.Explicit, Size = 16 )]
+    public struct Point
+    {
+
+        [FieldOffset( 0 )] private Vec3 coord;
+        [FieldOffset( 0 )] internal Vector4 coordVec;
+
+        internal Point( Vec4 vector )
+        {
+            coordVec = vector.vec;
+            coordVec.W = 1;
+        }
+
+        public Point( Vec3 coord )
+        {
+            Coord = coord;
+            coordVec.W = 1;
+        }
+
+        public Point( float x, float y, float z )
+        {
+            coordVec = new Vector4( x, y, z, 1 );
+        }
+
+        public Vec3 Coord
+        {
+            get => coord;
+            set
+            {
+                coord = value;
+                coordVec.W = 1;
+            }
+        }
+
+    }
+}

StgSharp.Common/Geometries/SpaceGeometry/Class1.cs

@@ -0,0 +1,38 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Class1.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.Geometries.SpaceGeometry
+{
+    internal class Class1 { }
+}

StgSharp.Common/Global.cs

@@ -0,0 +1,21 @@
+// This file is used by Code Analysis to maintain SuppressMessage
+// attributes that are applied to this project.
+// Project-level suppressions either have no target or are given
+// a specific target and scoped to a namespace, type, member, etc.
+
+global using StgSharp.Internal;
+global using StgSharp.Internal.Intrinsic;
+global using StgSharp.Internal.OpenGL;
+
+using System.Diagnostics.CodeAnalysis;
+
+[assembly: SuppressMessage("Design", "CA1008:枚举应具有零值", Justification = "<挂起>", Scope = "type", Target = "~T:StgSharp.Graphics.OpenGL.ShaderStatus")]
+[assembly: SuppressMessage("Naming", "CA1715:标识符应具有正确的前缀", Justification = "<挂起>", Scope = "member", Target = "~M:StgSharp.Graphics.OpenGL.ShaderProgram.GetUniform``2(System.String)~StgSharp.Graphics.OpenGL.Uniform{``0,``1}")]
+[assembly: SuppressMessage("Naming", "CA1715:标识符应具有正确的前缀", Justification = "<挂起>", Scope = "member", Target = "~M:StgSharp.Graphics.OpenGL.ShaderProgram.GetUniform``3(System.String)~StgSharp.Graphics.OpenGL.Uniform{``0,``1,``2}")]
+[assembly: SuppressMessage("Naming", "CA1715:标识符应具有正确的前缀", Justification = "<挂起>", Scope = "member", Target = "~M:StgSharp.Graphics.OpenGL.ShaderProgram.GetUniform``4(System.String)~StgSharp.Graphics.OpenGL.Uniform{``0,``1,``2,``3}")]
+[assembly: SuppressMessage("Naming", "CA1715:标识符应具有正确的前缀", Justification = "<挂起>", Scope = "type", Target = "~T:StgSharp.Graphics.OpenGL.Uniform`4")]
+[assembly: SuppressMessage("Design", "CA1043:将整型或字符串参数用于索引器", Justification = "<挂起>", Scope = "member", Target = "~P:StgSharp.MVVM.View.ViewBase.IViewResponder`1.Item(StgSharp.Controlling.UsrActivity.ITrigger)")]
+[assembly: SuppressMessage("Design", "CA1043:将整型或字符串参数用于索引器", Justification = "<挂起>", Scope = "member", Target = "~P:StgSharp.MVVM.View.ViewBase.ViewResponder`1.Item(StgSharp.Controlling.UsrActivity.ITrigger)")]
+[assembly: SuppressMessage("Performance", "CA1864:首选 \"IDictionary.TryAdd(TKey, TValue)\" 方法", Justification = "<挂起>", Scope = "member", Target = "~P:StgSharp.MVVM.View.ViewBase.ViewRender`1.Item(System.String)")]
+[assembly: SuppressMessage("Design", "CA1033:接口方法应可由子类型调用", Justification = "<挂起>", Scope = "member", Target = "~P:StgSharp.Collections.IBidirectionalDictionary`2.System#Collections#Generic#IDictionary<TFirst,TSecond>#Keys")]
+[assembly: SuppressMessage("Design", "CA1033:接口方法应可由子类型调用", Justification = "<挂起>", Scope = "member", Target = "~P:StgSharp.Collections.IBidirectionalDictionary`2.System#Collections#Generic#IDictionary<TFirst,TSecond>#Values")]

StgSharp.Common/Graphics/CPUanimation/IImageProvider.cs

@@ -0,0 +1,43 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="IImageProvider.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.Graphics
+{
+    public interface IImageProvider
+    {
+
+        Image ProvideImage();
+
+    }
+}

StgSharp.Common/Graphics/CPUanimation/ImageHelper.cs

@@ -0,0 +1,89 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="ImageHelper.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.ComponentModel;
+using System.Text;
+
+namespace StgSharp.Graphics
+{
+    public static class ImageHelper
+    {
+
+        public static void Resize(
+            Image i,
+            int width,
+            int height,
+            ImageMovement move )
+        {
+            if( i == null ) {
+                throw new ArgumentNullException( nameof( i ) );
+            }
+            if( i.Size == (width, height) ) {
+                return;
+            }
+            if( !Enum.IsDefined( typeof( ImageMovement ), move ) ) {
+                throw new InvalidEnumArgumentException( nameof( move ) );
+            }
+            byte[] oldData = i.Data;
+            i.Data = new byte[width * height * i.PixelSize];
+            i.Height = height;
+            i.Width = width;
+            i.PixelUpdateCount++;
+            switch( move ) {
+                case ImageMovement.Discard:
+                    break;
+                case ImageMovement.Top:
+                    break;
+                default:
+                    throw new NotImplementedException();
+            }
+        }
+
+    }
+
+    [Flags]
+    public enum ImageMovement
+    {
+#pragma warning disable CA1008 
+        Discard = 0,
+        #pragma warning restore CA1008 
+        Top = 1,
+        Bottom = 2,
+        Left = 4,
+        Right = 8,
+        TopLeft = Top | Left,
+        BottomLeft = Bottom | Left,
+        TopRight = Top | Right,
+        BottomRight = Bottom | Right,
+
+    }
+}

StgSharp.Common/Graphics/Define/BufferObjectBase.cs

@@ -0,0 +1,83 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="BufferObjectBase.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.OpenGL;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics
+{
+    /// <summary>
+    /// Interface of all kinds OpenGL Buffer objects
+    /// </summary>
+    public abstract class BufferObjectBase : IDisposable
+    {
+
+        protected GlHandle[] _bufferHandle;
+        protected RenderStream binding;
+
+        /// <summary>
+        /// Get the only handle to one of the Object instance
+        /// </summary>
+        /// <param _name="index"></param>
+        /// <returns></returns>
+        public GlHandle this[ int index ] => _bufferHandle[ index ];
+
+        /// <summary>
+        /// Bind a Buffer instance to OpenGL
+        /// </summary>
+        /// <param _name="index"> Index of handle of the object in this instance to be bind </param>
+        public abstract void Bind( int index );
+
+        public void Dispose()
+        {
+            Dispose( disposing: true );
+            GC.SuppressFinalize( this );
+        }
+
+        /// <inheritdoc />
+        public override string ToString()
+        {
+            return $"This is a {GetType().FullName}, containing {_bufferHandle.Length} buffer handles: {_bufferHandle.ToString()}.";
+        }
+
+        protected abstract void Dispose( bool disposing );
+
+        ~BufferObjectBase()
+        {
+            Dispose( disposing: false );
+        }
+
+    }
+}

StgSharp.Common/Graphics/IGraphicAPIs.cs

@@ -0,0 +1,46 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="IGraphicAPIs.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.Graphics
+{
+    public interface IGraphicAPIs
+    {
+
+        public IntPtr GraphicApiPackageHandle
+        {
+            get;
+        }
+
+    }
+}

StgSharp.Common/Graphics/Image.cs

@@ -0,0 +1,218 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Image.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.Internal;
+using StgSharp.Graphics.OpenGL;
+using StgSharp.Math;
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics
+{
+    public class Image : ISSDSerializable, IImageProvider
+    {
+
+        private byte[] _data;
+        private ImageInfo _rawInfo;
+        private int _pixelUpdateCount = 0;
+
+        internal unsafe Image()
+        {
+            _rawInfo = new ImageInfo();
+        }
+
+        internal Image( ImageInfo information )
+        {
+            _rawInfo = information;
+            _data = Array.Empty<byte>();
+
+            //int length = _rawInfo.width * _rawInfo.height * _rawInfo.channel;
+        }
+
+        public (int width, int height) Size
+        {
+            get => (_rawInfo.Width, _rawInfo.Height);
+        }
+
+        public byte[] PixelBuffer
+        {
+            get
+            {
+                if( ( _data.Length == 0 ) || ( _data == null ) ) {
+                    GetBytes();
+                    return _data!;
+                }
+                return _data;
+            }
+        }
+
+        public ImageChannel Channel => _rawInfo.Channel;
+
+        /// <summary>
+        /// Hash code of time pixels updated last time.
+        /// </summary>
+        public int PixelUpdateCount
+        {
+            get => _pixelUpdateCount;
+            internal set => _pixelUpdateCount = value;
+        }
+
+        public int ChannelCount => _rawInfo.ChannelCount;
+
+        public int Height
+        {
+            get => _rawInfo.Height;
+            internal set => _rawInfo.Height = value;
+        }
+
+        public int Width
+        {
+            get => _rawInfo.Width;
+            internal set => _rawInfo.Width = value;
+        }
+
+        public int PixelSize => ImageInfo.GetPixelSize(
+            _rawInfo.pixelLayout, _rawInfo.Channel );
+
+        public PixelChannelLayout PixelLayout
+        {
+            get => _rawInfo.pixelLayout;
+            private set => _rawInfo.pixelLayout = value;
+        }
+
+        public SerializableTypeCode SSDTypeCode => SerializableTypeCode.PixelImage;
+
+        internal ref byte[] Data
+        {
+            get => ref _data;
+        }
+
+        public void FromBytes( byte[] stream ) { }
+
+        public static unsafe Image FromFile( string route, ImageLoader loader )
+        {
+            Image ret = new Image();
+            fixed( ImageInfo* iptr = &ret._rawInfo ) {
+                InternalIO.InternalLoadImage( route, iptr, loader );
+            }
+            return ret;
+        }
+
+        public static Image FromMemory(
+            (int width, int height) size,
+            ImageChannel channel,
+            byte[] stream )
+        {
+            ImageInfo _info = new ImageInfo
+            {
+                Height = size.height,
+                Width = size.width,
+                Channel = channel,
+                StreamPtr = IntPtr.Zero
+            };
+            Image ret = new Image( _info );
+            ret.PixelLayout = PixelChannelLayout.Byte;
+            ret._data = stream;
+            return ret;
+        }
+
+        public static Image FromMemory(
+            (int width, int height) size,
+            ImageChannel channel,
+            PixelChannelLayout layout,
+            byte[] stream )
+        {
+            ImageInfo _info = new ImageInfo
+            {
+                Height = size.height,
+                Width = size.width,
+                Channel = channel,
+                StreamPtr = IntPtr.Zero
+            };
+            Image ret = new Image( _info );
+            ret.PixelLayout = layout;
+            ret._data = stream;
+            return ret;
+        }
+
+        public unsafe byte[] GetBytes()
+        {
+            if( _data.Length == 0 ) {
+                int size = Width * Height * ImageInfo.GetPixelSize(
+                    PixelLayout, Channel );
+                _data = new Span<byte>( ( byte* )_rawInfo.StreamPtr,
+                                        size ).ToArray();
+                fixed( ImageInfo* pptr = &_rawInfo ) {
+                    InternalIO.InternalUnloadImage( pptr );
+                }
+                _rawInfo.StreamPtr = IntPtr.Zero;
+            }
+            return _data;
+        }
+
+        public Image ProvideImage() => this;
+
+        internal static Image FromMemory(
+            ImageInfo info,
+            byte[] data,
+            int operationCount )
+        {
+            return new Image
+            {
+                _rawInfo = info,
+                _data = data,
+                _pixelUpdateCount = operationCount
+            };
+        }
+
+        byte[] ISSDSerializable.GetBytes()
+        {
+            throw new NotImplementedException();
+        }
+
+    }
+
+}
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public static partial class GlHelper
+    {
+
+    }
+}

StgSharp.Common/Graphics/ImageInfo.cs

@@ -0,0 +1,141 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Runtime.CompilerServices;
+using StgSharp.Graphics.OpenGL;
+using System.Runtime.InteropServices;
+
+
+namespace StgSharp.Graphics
+{
+    [UnmanagedFunctionPointer(CallingConvention.Cdecl, CharSet = CharSet.Ansi)]
+    public delegate IntPtr ImageLoader(
+                                   string name,
+                                   ref int width,
+                                   ref int height,
+                                   ref int definedChannel,
+                                   int desiredChannel);
+
+
+    [StructLayout(LayoutKind.Sequential)]
+    internal struct ImageInfo
+    {
+
+        private ImageChannel channel;
+        private int height;
+        private int width;
+        private IntPtr pixelPtr;
+        internal PixelChannelLayout pixelLayout;
+
+        public ImageChannel Channel
+        {
+            get => channel;
+            set { channel = value; }
+        }
+
+        public int ChannelCount
+        {
+            get => GetChannelCount(channel);
+        }
+
+        public int Height
+        {
+            get => height;
+            set => height = value;
+        }
+
+        public int StreamSize
+        {
+            get => width * height * GetPixelSize(
+                pixelLayout, channel);
+        }
+
+        public int Width
+        {
+            get => width;
+            set => width = value;
+        }
+
+        public IntPtr StreamPtr
+        {
+            get => pixelPtr;
+            internal set => pixelPtr = value;
+        }
+
+        public override int GetHashCode()
+        {
+            int hash = 17;
+            hash = hash * 17 + width;
+            hash = hash * 17 + height;
+            hash = hash * 17 + (int)channel;
+            return hash;
+        }
+
+        public override string ToString()
+        {
+            return $"{channel}\t{width}\t{height}\t{(ulong)StreamPtr}";
+        }
+
+
+        internal static int GetChannelCount(ImageChannel channel)
+        {
+            return channel switch
+            {
+                ImageChannel.SingleColor => 1,
+                ImageChannel.DoubleColor => 2,
+                ImageChannel.TripleColor => 3,
+                ImageChannel.WithAlphaChannel => 4,
+                _ => throw new InvalidCastException(
+                    "Unknown color channel decoding setting.")
+            };
+        }
+
+        internal static int GetPixelSize(
+            PixelChannelLayout layout,
+            ImageChannel channel)
+        {
+            return layout switch
+            {
+                PixelChannelLayout.UByte => sizeof(byte) * GetChannelCount(
+                    channel),
+                PixelChannelLayout.Byte => sizeof(byte) * GetChannelCount(
+                    channel),
+                PixelChannelLayout.UShort => sizeof(short) * GetChannelCount(
+                    channel),
+                PixelChannelLayout.Short => sizeof(short) * GetChannelCount(
+                    channel),
+                PixelChannelLayout.UInt => sizeof(int) * GetChannelCount(
+                    channel),
+                PixelChannelLayout.Int => sizeof(int) * GetChannelCount(
+                    channel),
+                PixelChannelLayout.Float => sizeof(float) * GetChannelCount(
+                    channel),
+                PixelChannelLayout.UByte332 => sizeof(byte),
+                PixelChannelLayout.UByte233Rev => sizeof(byte),
+                PixelChannelLayout.UShort565 => sizeof(short),
+                PixelChannelLayout.UShort565Rev => sizeof(short),
+                PixelChannelLayout.UShort4444 => sizeof(short),
+                PixelChannelLayout.UShort4444Rev => sizeof(short),
+                PixelChannelLayout.UShort5551 => sizeof(short),
+                PixelChannelLayout.UShort1555Rev => sizeof(short),
+                PixelChannelLayout.UInt8888 => sizeof(int),
+                PixelChannelLayout.UInt8888Rev => sizeof(int),
+                PixelChannelLayout.UInt1010102 => sizeof(int),
+                PixelChannelLayout.UInt2101010Rev => sizeof(int),
+                _ => throw new ArgumentException("Unknown layout type"),
+            };
+        }
+
+    }
+
+    public enum ImageChannel : uint
+    {
+
+        SingleColor = glConst.RED,
+        DoubleColor = glConst.RG,
+        TripleColor = glConst.RGB,
+        WithAlphaChannel = glConst.RGBA,
+
+    }
+
+}

StgSharp.Common/Graphics/OpenGL/Buffer/AutoTexture.cs

@@ -0,0 +1,161 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="AutoTexture.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.Commom.Collections;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    /// <summary>
+    /// A collection of a sets of OpenGL textures. The collection can automatically select one of
+    /// the  texture with minimum costs to upgrade pixels to Buffer. Usually <see
+    /// cref="AutoTextureGL" /> is used for <see cref="IImageProvider" /> loading, but not for
+    /// target of  <see cref="OpenGLFunction.FrameBufferTexture2d(FrameBufferTarget, uint,
+    /// Texture2DTarget, GlHandle, int)" />.
+    /// </summary>
+    public sealed class AutoTextureGL
+    {
+
+        private TextureProperty[] propertyCache;
+        private BidirectionalDictionary<Image, int> imageIndexMap = new BidirectionalDictionary<Image, int>(
+            );
+        private Dictionary<Image, int> imageUpdateIndex = new Dictionary<Image, int>(
+            );
+
+        private int _size, _currentIndex;
+        private LinkedList<int> usedTextureIndex;
+        private Queue<int> unusedTextureUnitIndex;
+        private TextureGL texturePackage;
+
+        private TextureProperty _textureProperty;
+
+        private AutoTextureGL( TextureGL texture )
+        {
+            texturePackage = texture;
+            _size = texture.Count;
+            imageIndexMap = new BidirectionalDictionary<Image, int>();
+            unusedTextureUnitIndex = new Queue<int>(
+                Enumerable.Range( 0, _size ) );
+            usedTextureIndex = new LinkedList<int>();
+            propertyCache = new TextureProperty[_size];
+        }
+
+        public AutoTextureGL( int textureObjectSize, [NotNull]glRender binding )
+        {
+            this._size = textureObjectSize;
+            imageIndexMap = new BidirectionalDictionary<Image, int>();
+            texturePackage = new TextureGL( textureObjectSize, binding );
+            unusedTextureUnitIndex = new Queue<int>(
+                Enumerable.Range( 0, _size ) );
+            usedTextureIndex = new LinkedList<int>();
+            propertyCache = new TextureProperty[_size];
+        }
+
+        public TextureProperty DefaultTextureProperty
+        {
+            get => _textureProperty;
+            set => _textureProperty = value;
+        }
+
+        private OpenGLFunction GL
+        {
+            get => texturePackage.GL;
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SelectTextureAndBind( Image i )
+        {
+            TextureProperty property = _textureProperty;
+
+            SelectTextureAndBind( i, property );
+        }
+
+        public void SelectTextureAndBind(
+            [NotNull]Image i,
+            TextureProperty property )
+        {
+            //usable texture with image match
+            if( imageIndexMap.TryGetValue( i, out int index ) ) {
+                //prop setting match
+                if( propertyCache[ index ] == property ) {
+                    _currentIndex = index;                          //GL.Assert(true);
+                    texturePackage.Bind2D( index );                   //GL.Assert(true);
+                    if( i.PixelUpdateCount != imageUpdateIndex[ i ] ) {
+                        texturePackage.LoadTexture( index, i );       //GL.Assert(true);
+                    }
+                } else {
+                    _currentIndex = index;                          //GL.Assert(true);
+                    texturePackage.Bind2D( index );                   //GL.Assert(true);
+                    texturePackage.Set2dProperty( index, property );  //GL.Assert(true);
+                    if( i.PixelUpdateCount != imageUpdateIndex[ i ] ) {
+                        texturePackage.LoadTexture( index, i );       //GL.Assert(true);
+                    }
+                }
+            } else {
+                if( unusedTextureUnitIndex.TryDequeue( out int newIndex ) ) {
+                    //has extra unused texture object
+                    imageIndexMap.Add( i, index );
+                    texturePackage.Bind2D( index );
+                    texturePackage.Set2dProperty( index, property );
+                    texturePackage.LoadTexture( index, i );
+                    usedTextureIndex.AddLast( newIndex );
+                    propertyCache[ newIndex ] = property;
+                    imageUpdateIndex[ i ] = i.PixelUpdateCount;
+                } else {
+                    //recycle from current
+                    int reusedIndex = usedTextureIndex.First!.Value;
+                    usedTextureIndex.RemoveFirst();
+                    usedTextureIndex.AddLast( reusedIndex );
+                    imageIndexMap[ i ] = reusedIndex;
+                    propertyCache[ newIndex ] = property;
+                    imageUpdateIndex[ i ] = i.PixelUpdateCount;
+                }
+            }
+        }
+
+        public static AutoTextureGL ToAuto( [NotNull]TextureGL texture )
+        {
+            if( texture.IndexOfCurrentTexture != -1 ) {
+                throw new InvalidOperationException(
+                    "Texture to be converted has been editted." );
+            }
+            return new AutoTextureGL( texture );
+        }
+
+    }
+}

StgSharp.Common/Graphics/OpenGL/Buffer/EBO.cs

@@ -0,0 +1,94 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="EBO.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.Graphics.OpenGL;
+using StgSharp.Internal.OpenGL;
+using StgSharp.Math;
+
+using System;
+using System.Collections.Generic;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    /// <summary>
+    /// A collection of handle to Element Buffer Object in OpenglFunc. Each <see langword="uint" />
+    /// value indexed from instance of this class this is the only handle to one Element Buffer
+    /// Object.
+    /// </summary>
+    public sealed unsafe class ElementBuffer : GlBufferObjectBase
+    {
+
+        internal ElementBuffer( int n, glRender binding )
+            : base( binding )
+        {
+            _bufferHandle = GL.GenBuffers( n );
+        }
+
+        public override sealed void Bind( int index )
+        {
+            GL.BindBuffer(
+                BufferType.ElementArrayBuffer, _bufferHandle[ index ] );
+        }
+
+        public void SetValue<T>( int index, T[] bufferArray, BufferUsage usage )
+            where T: struct, INumber<T>
+        {
+            GL.BindBuffer(
+                BufferType.ElementArrayBuffer, _bufferHandle[ index ] );
+            GL.SetBufferData<T>(
+                BufferType.ElementArrayBuffer, bufferArray, usage );
+        }
+
+        public void SetValue<T>(
+            int index,
+            ReadOnlySpan<T> bufferSpan,
+            BufferUsage usage )
+            where T: struct, INumber<T>
+        {
+            GL.BindBuffer(
+                BufferType.ElementArrayBuffer, _bufferHandle[ index ] );
+            GL.SetBufferData<T>( BufferType.ElementArrayBuffer, bufferSpan,
+                              usage );
+        }
+
+        protected override sealed void Dispose( bool disposing )
+        {
+            if( disposing ) {
+                GL.DeleteBuffers( _bufferHandle );
+            }
+        }
+
+    }
+}

StgSharp.Common/Graphics/OpenGL/Buffer/FBO.cs

@@ -0,0 +1,101 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="FBO.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.OpenGL;
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    #pragma warning disable CA1008 
+    #pragma warning disable CA1028 
+    public enum FrameBufferTarget : uint
+    #pragma warning restore CA1028 
+    #pragma warning restore CA1008 
+    {
+
+        Read = glConst.READ_FRAMEBUFFER,
+        All = glConst.FRAMEBUFFER,
+        Draw = glConst.DRAW_FRAMEBUFFER,
+
+    }
+
+    public sealed class FrameBuffer : GlBufferObjectBase
+    {
+
+        internal unsafe FrameBuffer( int count, glRender binding )
+            : base( binding )
+        {
+            _bufferHandle = GL.GenFrameBuffers( count );
+        }
+
+        /// <summary>
+        /// Bind the frame Buffer object with _name frame Buffer to the frame Buffer target specified
+        /// by target. <see langword="FrameBufferTarget.All" /> will be set as default target.
+        /// </summary>
+        /// <param _name="index"> Index of object to be binded in handle set </param>
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public override unsafe void Bind( int index )
+        {
+            GL.BindFrameBuffer( FrameBufferTarget.All, _bufferHandle[ index ] );
+        }
+
+        /// <summary>
+        /// Bind the frame Buffer object with _name frame Buffer to the frame Buffer target specified
+        /// by target. Target of this frame Buffer should be set manually.
+        /// </summary>
+        /// <param _name="target"> The frame Buffer target of the binding operation. </param>
+        /// <param _name="index"> Index of object to be binded in handle set </param>
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public unsafe void Bind( FrameBufferTarget target, int index )
+        {
+            GL.BindFrameBuffer( target, _bufferHandle[ index ] );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static void BindNull()
+        {
+            OpenGLFunction.CurrentGL
+                .BindFrameBuffer( FrameBufferTarget.All, GlHandle.Zero );
+        }
+
+        protected override void Dispose( bool disposing )
+        {
+            throw new NotImplementedException();
+        }
+
+    }
+}

StgSharp.Common/Graphics/OpenGL/Buffer/GLBufferObjectBase.cs

@@ -0,0 +1,53 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="GLBufferObjectBase.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.OpenGL;
+
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public abstract class GlBufferObjectBase : BufferObjectBase
+    {
+
+        private readonly glRender _contextBinding;
+
+        protected GlBufferObjectBase( glRender contextBinding )
+        {
+            binding = contextBinding;
+            _contextBinding = contextBinding;
+        }
+
+        protected OpenGLFunction GL => _contextBinding.GL;
+
+    }
+}

StgSharp.Common/Graphics/OpenGL/Buffer/RBO.cs

@@ -0,0 +1,73 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="RBO.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.OpenGL;
+
+using System;
+using System.Collections.Generic;
+using System.Security.Principal;
+using System.Text;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public sealed class RenderBuffer : GlBufferObjectBase
+    {
+
+        public RenderBuffer( int count, glRender binding )
+            : base( binding )
+        {
+            _bufferHandle = GL.GenRenderBuffer( count );
+        }
+
+        public override void Bind( int index )
+        {
+            GL.BindRenderBuffer( this[ index ] );
+        }
+
+        public void Store(
+            RenderBufferInternalFormat format,
+            (int width, int height) size )
+        {
+            if( ( size.width > binding.Width ) || ( size.height > binding.Height ) ) {
+                StgSharp.LogWarning(
+                    "FrameBuffer is larger than current canvas binding" );
+            }
+        }
+
+        protected override void Dispose( bool disposing )
+        {
+            foreach( GlHandle item in _bufferHandle ) {
+                Console.WriteLine( "removing a render buffer" );
+                GL.DeleteRenderBuffer( item );
+            }
+        }
+
+    }
+}