add from giga-device, new branch added

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/Collections/BidirectionalDictionary.cs

@@ -0,0 +1,206 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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/CapacityFixedList.cs

@@ -0,0 +1,191 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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,87 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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 _label="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 _label="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,48 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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,134 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="ListSegment.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.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 int _begin;
+        private int _length;
+        private List<T> _collection;
+
+        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 T this[ int indexValue ]
+        {
+            get
+            {
+                ArgumentOutOfRangeException.ThrowIfLessThan( indexValue, 0 );
+                ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual( indexValue, _length );
+                return _collection[ indexValue + _begin ];
+            }
+        }
+
+        public T this[ Index i ]
+        {
+            get
+            {
+                int offset = i.IsFromEnd ? _length - i.Value : i.Value;
+                ArgumentOutOfRangeException.ThrowIfLessThan( offset, 0 );
+                ArgumentOutOfRangeException.ThrowIfGreaterThanOrEqual( offset, _length );
+                return _collection[ offset + _begin ];
+            }
+        }
+
+        public bool IsReadOnly => true;
+
+        public int Count => _length;
+
+        public bool Contains( T item )
+        {
+            int index = _collection.IndexOf( item );
+            return index >= _begin && index < _length + index;
+        }
+
+        public void CopyTo( T[] array, int arrayIndex )
+        {
+            ArgumentNullException.ThrowIfNull( array );
+            Span<T> span = CollectionsMarshal.AsSpan<T>( _collection ).Slice( _begin, _length );
+            Span<T> 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 ];
+            }
+        }
+
+        void ICollection<T>.Add( T item )
+        {
+            throw new NotSupportedException();
+        }
+
+        void ICollection<T>.Clear()
+        {
+            throw new NotSupportedException();
+        }
+
+        bool ICollection<T>.Remove( T item )
+        {
+            throw new NotSupportedException();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            return GetEnumerator();
+        }
+
+    }
+}

StgSharp.Common/Collections/PartialDictionary.cs

@@ -0,0 +1,180 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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,105 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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/RandomAccessibleStack.cs

@@ -0,0 +1,185 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="RandomAccessibleStack.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.Linq;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Collections
+{
+    public class RandomAccessibleStack<T> : IEnumerable<T>
+    {
+
+        private const int DefaultCapacity = 4;
+
+        private T[] _array;
+        private int _size;
+        private int _version;
+
+        /// <summary>
+        ///   Initializes a new instance of the RandomAccessStack class that is empty and has the
+        ///   default initial capacity.
+        /// </summary>
+        public RandomAccessibleStack()
+        {
+            _array = new T[DefaultCapacity];
+        }
+
+        /// <summary>
+        ///   Initializes a new instance of the RandomAccessStack class that is empty and has the
+        ///   specified initial capacity.
+        /// </summary>
+        public RandomAccessibleStack( int capacity )
+        {
+            if( capacity < 0 ) {
+                throw new ArgumentOutOfRangeException(
+                    nameof( capacity ), "Capacity must be non-negative." );
+            }
+
+            _array = new T[capacity];
+        }
+
+        /// <summary>
+        ///   Gets or sets the element at the specified index in the stack (0 = bottom, Count-1 =
+        ///   top).
+        /// </summary>
+        public T this[ int index ]
+        {
+            get
+            {
+                if( index < 0 || index >= _size ) {
+                    throw new ArgumentOutOfRangeException( nameof( index ) );
+                }
+
+                return _array[ index ];
+            }
+            /*
+            set
+            {
+                if( index < 0 || index >= _size ) {
+                    throw new ArgumentOutOfRangeException( nameof( index ) );
+                }
+                _array[ index ] = value;
+                _version++;
+            }
+            /**/
+        }
+
+        /// <summary>
+        ///   Gets the number of elements contained in the stack.
+        /// </summary>
+        public int Count => _size;
+
+        /// <summary>
+        ///   Removes all objects from the stack.
+        /// </summary>
+        public void Clear()
+        {
+            Array.Clear( _array, 0, _size );
+            _size = 0;
+            _version++;
+        }
+
+        /// <summary>
+        ///   Returns an enumerator that iterates through the stack from top to bottom. Throws if
+        ///   the stack is modified during iteration.
+        /// </summary>
+        public IEnumerator<T> GetEnumerator()
+        {
+            int expectedVersion = _version;
+            for( int i = _size - 1; i >= 0; i-- )
+            {
+                if( expectedVersion != _version ) {
+                    throw new InvalidOperationException(
+                        "Collection was modified during enumeration." );
+                }
+
+                yield return _array[ i ];
+            }
+        }
+
+        /// <summary>
+        ///   Returns the object at the top of the stack without removing it.
+        /// </summary>
+        public T Peek()
+        {
+            if( _size == 0 ) {
+                throw new InvalidOperationException( "Stack is empty." );
+            }
+
+            return _array[ _size - 1 ];
+        }
+
+        /// <summary>
+        ///   Removes and returns the object at the top of the stack.
+        /// </summary>
+        public T Pop()
+        {
+            if( _size == 0 ) {
+                throw new InvalidOperationException( "Stack is empty." );
+            }
+
+            T item = _array[ --_size ];
+            _array[ _size ] = default!;
+            _version++;
+            return item;
+        }
+
+        /// <summary>
+        ///   Adds an item to the top of the stack.
+        /// </summary>
+        public void Push( T item )
+        {
+            if( _size == _array.Length ) {
+                EnsureCapacity( _size + 1 );
+            }
+
+            _array[ _size++ ] = item;
+            _version++;
+        }
+
+        private void EnsureCapacity( int min )
+        {
+            int newCapacity = _array.Length == 0 ? DefaultCapacity : _array.Length * 2;
+            if( newCapacity < min ) {
+                newCapacity = min;
+            }
+
+            Array.Resize( ref _array, newCapacity );
+        }
+
+        IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
+
+    }
+}

StgSharp.Common/Collections/StringHashMultiplexer.cs

@@ -0,0 +1,165 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="StringHashMultiplexer.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,64 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// 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.Mathematics;
+
+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,151 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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,110 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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,59 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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,70 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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,88 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+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,218 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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,45 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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,89 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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,86 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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,91 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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/Counter.cs

@@ -0,0 +1,114 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Counter.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.Numerics;
+
+namespace StgSharp
+{
+    public class Counter<T> where T: unmanaged, INumber<T>
+    {
+
+        internal dynamic _value;
+        internal readonly T _defaultValue;
+        internal readonly T _defualtDecreament;
+
+        internal readonly T _defualtIncreament;
+
+        public Counter(T defaultValue, T defaultIncrement, T defaultDecrement)
+        {
+            _value = defaultValue;
+            _defaultValue = defaultValue;
+            _defualtIncreament = defaultIncrement;
+            _defualtDecreament = defaultDecrement;
+        }
+
+        public T DecrementSpan => _defualtDecreament;
+
+        public T IncrementSpan => _defualtIncreament;
+
+        public T CurrentSpan => _value - _defaultValue;
+
+        public T Value
+        {
+            get => _value;
+            set => _value = value;
+        }
+
+        public void Add(T value)
+        {
+            _value += value;
+        }
+
+        public void QuickAdd()
+        {
+            _value += _defualtIncreament;
+        }
+
+        public void QuickSub()
+        {
+            _value -= _defualtDecreament;
+        }
+
+        public void Reset()
+        {
+            _value = _defaultValue;
+        }
+
+        public void Sub(T value)
+        {
+            _value -= value;
+        }
+
+        public override string ToString() => Value.ToString();
+
+        public static Counter<T> operator --(Counter<T> counter)
+        {
+            counter.QuickSub();
+            return counter;
+        }
+
+        public static Counter<T> operator ++(Counter<T> counter)
+        {
+            counter.QuickAdd();
+            return counter;
+        }
+
+        public static implicit operator T(Counter<T> counter)
+        {
+            return counter switch
+            {
+                null => T.Zero,
+                _ => counter.Value
+            };
+        }
+
+    }
+}

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 World
+    {
+
+        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,142 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// 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.Runtime.CompilerServices;
+using System.Text;
+using System.Xml.Serialization;
+
+namespace StgSharp.Data
+{
+    public unsafe class RandomGenerator
+    {
+
+        private byte[] currentKey;
+        private readonly byte[] originKey;
+
+        public RandomGenerator() : this(DateTime.UtcNow.ToBinary()) { }
+
+        public RandomGenerator(object source)
+        {
+            ArgumentNullException.ThrowIfNull(source);
+            XmlSerializer s = new(source.GetType());
+            using (StringWriter sw = new())
+            {
+                s.Serialize(sw, source);
+                string data = sw.ToString();
+                originKey = Encoding.Unicode.GetBytes(data);
+            }
+            currentKey = [0,0,0,0];
+            fixed (byte* o = originKey, c = currentKey) {
+                *(int*)c = UnsafeCompute.CityHashSimplify((char*)o, 0, originKey.Length / 2);
+            }
+            TotalGeneratedRandom = 0;
+        }
+
+        public int TotalGeneratedRandom
+        {
+[MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get;
+[MethodImpl(MethodImplOptions.AggressiveInlining)]
+            private set;
+        }
+
+        public unsafe int GenRandomInt()
+        {
+            uint source = PrivateRand();
+            TotalGeneratedRandom++;
+            M64 m = new M64();
+            m.Member<uint>(0) = source;
+            m.Member<uint>(1) = source;
+            return (m << (TotalGeneratedRandom % 32)).Member<int>(1);
+        }
+
+        public byte GenRandomInt8()
+        {
+            TotalGeneratedRandom++;
+            if (TotalGeneratedRandom % 4 == 0) {
+                PrivateRand();
+            }
+            return currentKey[TotalGeneratedRandom % 4];
+        }
+
+        public float GenRandomSingle()
+        {
+            TotalGeneratedRandom++;
+
+            while (true)
+            {
+                uint
+                    temp0 = PrivateRand(),
+                    temp1 = PrivateRand();
+
+                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;
+            TotalGeneratedRandom = 0;
+        }
+
+        private unsafe uint PrivateRand()
+        {
+            uint ret;
+            fixed (byte* bptr = currentKey)
+            {
+                *(int*)bptr = UnsafeCompute.CityHashSimplify((char*)bptr, currentKey.Length / 2);
+                ret = *(uint*)bptr;
+            }
+
+            // 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,80 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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( M128* vptr = &data )
+            {
+                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,189 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// 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.Mathematics;
+
+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 = World.ssdSegmentLength * 16)]
+    public unsafe struct SSDSegment : IComparable<int>, IComparable<SSDSegment>
+    {
+
+        [FieldOffset(16)] public fixed byte Data[16 * (World.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 * (World.ssdSegmentLength - 1)) - 1) {
+                    throw new IndexOutOfRangeException();
+                }
+                return Data[index];
+            }
+
+            set
+            {
+                if (index > (16 * (World.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 * World.ssdSegmentLength) {
+                throw new ArgumentException();
+            }
+            SSDSegment ret = new SSDSegment();
+            fixed (byte* bptr = stream)
+            {
+                ret.Head.data = *(M128*)bptr;
+                for (int i = 1; i < World.ssdSegmentLength; i++) {
+                    ret.WriteData<M128>(i - 1, *(M128*)(bptr + (16 * i)));
+                }
+            }
+            return ret;
+        }
+
+        public byte[] GetBytes()
+        {
+            byte[] ret = new byte[16 * World.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 < World.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 < World.ssdSegmentLength; i++) {
+                    ret = (ret + (*vptr).GetHashCode()) * 31;
+                }
+            }
+            return ret;
+        }
+
+        public unsafe T ReadData<T>(int index) where T: unmanaged
+        {
+            fixed (byte* bptr = Data)
+            {
+                T* tptr = (T*)bptr;
+                return *(tptr + index);
+            }
+        }
+
+        public unsafe void WriteData<T>(int index, T value) where T: unmanaged
+        {
+            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,67 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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 TOUGH TO Get Bytes from virtual folders
+        public byte[] GetBytes()
+        {
+            throw new NotImplementedException();
+        }
+
+    }
+}

StgSharp.Common/Data/SSD/SSDraw.cs

@@ -0,0 +1,71 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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,106 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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,94 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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: unmanaged
+        {
+            if (box is not IValueBox<T> genericBox) {
+                return null;
+            }
+            return genericBox;
+        }
+
+        static virtual bool IsGeneric<T>(IValueBox box) where T: unmanaged
+        {
+            return box is IValueBox<T>;
+        }
+
+    }
+
+    public interface IValueBox<T> where T: unmanaged
+    {
+
+        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: unmanaged
+    {
+
+        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,53 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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,92 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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 PlainGeometryCollisionSensor<PlainGeometry, PlainGeometry> _collisionSensor;
+        internal Point _basePoint;
+        internal Point _pos;
+        internal Point _position;
+        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.Mathematics;
+
+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,179 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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 PostError( Exception ex )
+        {
+            CreateDialogueProcessIfNotExist();
+
+            _dw.WriteLine( $"posterror {ex.Message}" );
+
+            _dialogueProcess!.Exited -= DialogueProcessExitCallback;
+        }
+
+        public static void SetReadAndWriteThread( Thread thread )
+        {
+            _readAndWriteThreadId = thread.ManagedThreadId;
+        }
+
+        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();
+        }
+
+        internal static void LoadDialogue()
+        {
+            _dialogueServerPipe = new AnonymousPipeServerStream(
+                PipeDirection.Out, HandleInheritability.Inheritable );
+            _dialogueClientPipe = new AnonymousPipeServerStream(
+                PipeDirection.In, HandleInheritability.Inheritable );
+
+            string route = Assembly.GetAssembly( typeof( World ) ).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}" );
+        }
+
+        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;
+        }
+
+        private static void AssertThread()
+        {
+            if( _readAndWriteThreadId != Environment.CurrentManagedThreadId ) {
+                throw new InvalidOperationException(
+                    "Communication with dialogue can only call from certain thread." );
+            }
+        }
+
+        private static void DialogueProcessExitCallback( object? sender, EventArgs e )
+        {
+            _dialogueProcess = null;
+            _dr.Close();
+            _dw.Close();
+        }
+
+    }
+}

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: World
+//     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 World
+    {
+
+        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 World 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 World
+    {
+
+        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,192 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// 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 System;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace StgSharp
+{
+    internal enum GraphicAPI : byte
+    {
+
+        GL,
+        VK
+
+    }
+
+    public static partial class World
+    {
+
+        /// <summary>
+        ///   Version of current World 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.LoadGlfw();
+            if (InternalIO.glfwInit() == 0) {
+                throw new Exception("Failed to init system graphic environment.");
+            }
+            InternalIO.InternalAppendLog("\n\n\n");
+            InternalIO.InternalWriteLog(
+                $"Program {Assembly.GetEntryAssembly()!.FullName} on {Environment.MachineName} 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(int exitCode)
+        {
+            MainTimeProvider.StopProvidingTime();
+            InternalIO.glfwTerminate();
+            Environment.Exit(exitCode);
+        }
+
+        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 _label="message">
+        ///   A string contains information of how current evironment runs.
+        /// </param>
+        /// <param _label="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 World
+    {
+
+        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.Mathematics;
+
+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,61 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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.Mathematics;
+
+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.Mathematics;
+
+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,68 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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,119 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+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.Mathematics
+{
+    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,59 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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,78 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// 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.Mathematics;
+
+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.reg); } }
+
+        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,55 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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,82 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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.Mathematics;
+
+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,72 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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,76 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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,69 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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,216 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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,89 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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,88 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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;
+
+        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,124 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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,95 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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,73 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// 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.Mathematics;
+
+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].reg = vert0.reg;
+            vertexMat[1].reg = vert1.reg;
+            vertexMat[2].reg = vert2.reg;
+            vertexMat[3].reg = vert3.reg;
+            vertexMat[4].reg = vert4.reg;
+            vertexMat[5].reg = vert5.reg;
+            vertexMat[6].reg = vert6.reg;
+        }
+
+        public override ReadOnlySpan<int> VertexIndices => Indices;
+
+    }
+}

StgSharp.Common/Geometries/PlainGeometry/Rectangle.cs

@@ -0,0 +1,97 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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 _label="tick">
+        ///   CurrentPipeline 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.Mathematics;
+
+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,96 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Mathematics;
+
+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,72 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// 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.Mathematics;
+
+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; }
+        }
+
+    }
+}

StgSharp.Common/Geometries/SpaceGeometry/TriangulatedSurface.cs

@@ -0,0 +1,145 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="TriangulatedSurface.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.Mathematics;
+using StgSharp.Mathematics.HighPrecision;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Runtime.Intrinsics;
+using System.Text;
+
+namespace StgSharp.Geometries
+{
+    public class TriangulatedSurface
+    {
+
+        private HashSet<(int begin,int end)> _sides;
+
+        private List<List<int>> _sideIndices;
+        private List<int> _triangleIndices;
+        private List<Vec3> _vertices;
+
+        public TriangulatedSurface()
+        {
+            _triangleIndices = new List<int>();
+            _vertices = new List<Vec3>();
+            _sides = new HashSet<(int,int)>();
+            _sideIndices = new List<List<int>>();
+        }
+
+        /**/
+        public IEnumerable<List<int>> SideIndicesEnumeratble
+        {
+            get => _sideIndices ;
+        }
+
+        /*
+        public Triangle GetTriangle( int index )
+        {
+            Vec3HP v1,v2,v3;
+            int t = index * 3;
+            v1 = _vertices[ t + 0 ];
+            v2 = _vertices[ t + 1 ];
+            v3 = _vertices[ t + 2 ];
+            return new Triangle( v1, v2, v3 );
+        }
+        /**/
+
+        public Span<Vec3> VertexSpan
+        {
+            get => CollectionsMarshal.AsSpan(_vertices);
+        }
+
+        public Span<int> TriangleIndicesSpan
+        {
+            get => CollectionsMarshal.AsSpan(_triangleIndices);
+        }
+
+        /**/
+        public void AddIndicesByOrder(int v1, int v2, int v3)
+        {
+            _triangleIndices.Add(v1);
+            _triangleIndices.Add(v2);
+            _triangleIndices.Add(v3);
+            if (!(_sides.Remove((v1,v2)) || _sides.Remove((v2, v1)))) {
+                _sides.Add((v1, v2));
+            }
+            if (!(_sides.Remove((v2, v3)) || _sides.Remove((v3, v2)))) {
+                _sides.Add((v2, v3));
+            }
+            if (!(_sides.Remove((v3, v1)) || _sides.Remove((v1, v3)))) {
+                _sides.Add((v3, v1));
+            }
+        }
+
+        public void AddVertexByOrder(Vec3 vertex)
+        {
+            _vertices.Add(vertex);
+        }
+
+        public int TriangleCount()
+        {
+            return _triangleIndices.Count / 3;
+        }
+
+        public void TrimExcess()
+        {
+            _triangleIndices.TrimExcess();
+            _vertices.TrimExcess();
+            Dictionary<int, int> side_dictionary = _sides.ToDictionary(x => x.begin, x => x.end);
+            int begin = side_dictionary.First().Key;
+            List<int> sideLoop = new List<int>(begin);
+            _sideIndices.Add(sideLoop);
+            while (side_dictionary.Count > 0)
+            {
+                if (side_dictionary.Remove(begin, out begin))
+                {
+                    sideLoop.Add(begin);
+                } else
+                {
+                    begin = side_dictionary.First().Key;
+                    sideLoop = new List<int>(begin);
+                    _sideIndices.Add(sideLoop);
+                }
+            }
+            _sideIndices.TrimExcess();
+        }
+
+        public int VertexCount()
+        {
+            return _vertices.Count;
+        }
+
+    }
+}

StgSharp.Common/Global.cs

@@ -0,0 +1,101 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Global.cs"
+//     Project: StepVisualizer
+//     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.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+// 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.ViewBase.IViewResponder`1.Item(StgSharp.Controlling.UsrActivity.ITrigger)" )]
+[assembly: SuppressMessage(
+        "Design",
+        "CA1043:将整型或字符串参数用于索引器",
+        Justification = "<挂起>",
+        Scope = "member",
+        Target = "~P:StgSharp.MVVM.ViewBase.ViewResponder`1.Item(StgSharp.Controlling.UsrActivity.ITrigger)" )]
+[assembly: SuppressMessage(
+        "Performance",
+        "CA1864:首选 \"IDictionary.TryAdd(TKey, TValue)\" 方法",
+        Justification = "<挂起>",
+        Scope = "member",
+        Target = "~P:StgSharp.MVVM.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,86 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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,89 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// 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 BufferHandle 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 _label="index">
+        ///
+        /// </param>
+        /// <returns>
+        ///
+        /// </returns>
+        public GlHandle this[int index] => _bufferHandle[index];
+
+        /// <summary>
+        ///   Bind a BufferHandle instance to OpenGL
+        /// </summary>
+        /// <param _label="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/Image.cs

@@ -0,0 +1,210 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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.Graphics.OpenGL;
+using StgSharp.Internal;
+using StgSharp.Mathematics;
+
+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,162 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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 BufferHandle. 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,86 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// 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.Mathematics;
+
+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 BufferHandle Object in OpenglFunc. Each <see
+    ///   langword="uint" /> value indexed from instance of this class this is the only handle to
+    ///   one Element BufferHandle Object.
+    /// </summary>
+    public sealed unsafe class ElementBuffer : GlBufferObjectBase
+    {
+
+        internal ElementBuffer(int n, glRender binding)
+            : base(binding)
+        {
+            _bufferHandle = GL.GenBuffers(n);
+        }
+
+        public sealed override void Bind(int index)
+        {
+            GL.BindBuffer(BufferType.ElementArrayBuffer, _bufferHandle[index]);
+        }
+
+        public void SetValue<T>(int index, T[] bufferArray, BufferUsage usage)
+            where T: unmanaged, 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: unmanaged, INumber<T>
+        {
+            GL.BindBuffer(BufferType.ElementArrayBuffer, _bufferHandle[index]);
+            GL.SetBufferData<T>(BufferType.ElementArrayBuffer, bufferSpan, usage);
+        }
+
+        protected sealed override void Dispose(bool disposing)
+        {
+            if (disposing) {
+                GL.DeleteBuffers(_bufferHandle);
+            }
+        }
+
+    }
+}

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

@@ -0,0 +1,108 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// 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 BufferHandle object with _label frame BufferHandle to the frame
+        ///   BufferHandle target specified by target. <see langword="FrameBufferTarget.All" /> will
+        ///   be set as default target.
+        /// </summary>
+        /// <param _label="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 BufferHandle object with _label frame BufferHandle to the frame
+        ///   BufferHandle target specified by target. Target of this frame BufferHandle should be
+        ///   set manually.
+        /// </summary>
+        /// <param _label="target">
+        ///   The frame BufferHandle target of the binding operation.
+        /// </param>
+        /// <param _label="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,71 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     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 ) ) {
+                World.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 );
+            }
+        }
+
+    }
+}

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

@@ -0,0 +1,287 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="TextureGL.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.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public sealed unsafe class TextureGL
+    {
+
+        private int currentEditingTextureIndex;
+
+        private OpenGLFunction _gl;
+        internal GlHandle[] _textureHandle;
+
+        internal TextureGL( int count, glRender binding )
+        {
+            //sourceList = new Image[count];
+            this._gl = binding.GL;
+            _textureHandle = _gl.GenTextures( count );
+        }
+
+        public GlHandle this[ int index ]
+        {
+            get => _textureHandle[ index ];
+        }
+
+        public int Count
+        {
+            get => _textureHandle.Length;
+        }
+
+        //internal Image[] sourceList;
+
+        public int IndexOfCurrentTexture
+        {
+            get => currentEditingTextureIndex;
+        }
+
+        internal OpenGLFunction GL => _gl;
+
+        public void ActivateAs( TextureUnit unit )
+        {
+            _gl.ActiveTextureUnit( ( uint )unit );
+        }
+
+        public void Bind2D( int index )
+        {
+            currentEditingTextureIndex = index;
+            _gl.BindTexture( glConst.TEXTURE_2D, _textureHandle[ index ] );
+        }
+
+        /// <summary>
+        ///   Load an <see cref="Image" /> to certain texture.
+        /// </summary>
+        /// <param _label="index">
+        ///
+        /// </param>
+        /// <param _label="i">
+        ///
+        /// </param>
+        public unsafe void LoadTexture( int index, Image i )
+        {
+            byte[] handle = i.PixelBuffer;
+            _gl.TextureImage2d(
+                Texture2DTarget.Texture2D, 0, i.Channel, ( uint )i.Width, ( uint )i.Height,
+                i.Channel, i.PixelLayout, pixels: handle );
+            _gl.GenerateMipmap( Texture2DTarget.Texture2D );
+        }
+
+        #region texture setting
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void Set2dFilterProperty(
+                    int index,
+                    TextureFilter onMinify,
+                    TextureFilter onMagnify )
+        {
+            #if DEBUG
+            if( index != currentEditingTextureIndex )
+            {
+                throw new InvalidOperationException(
+                    "Texture to be editted is not the one being activated." );
+            }
+            #endif
+            _gl.TextureParameter( glConst.TEXTURE_2D, glConst.TEXTURE_MIN_FILTER, ( int )onMinify );
+            _gl.TextureParameter( glConst.TEXTURE_2D, glConst.TEXTURE_MAG_FILTER,
+                                  ( int )onMagnify );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void Set2dWrapProperty(
+                    int index,
+                    TextureWrap onHorizontial,
+                    TextureWrap onVertical )
+        {
+            #if DEBUG
+            if( index != currentEditingTextureIndex )
+            {
+                throw new InvalidOperationException(
+                    "Texture to be editted is not the one being activated." );
+            }
+            #endif
+            _gl.TextureParameter( glConst.TEXTURE_2D, glConst.TEXTURE_WRAP_S,
+                                  ( int )onHorizontial );
+            _gl.TextureParameter( glConst.TEXTURE_2D, glConst.TEXTURE_WRAP_T, ( int )onVertical );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void Set2dProperty( int index, TextureProperty property )
+        {
+            Set2dFilterProperty( index, property.FilterOnMinify, property.FilterOnMagnify );
+            Set2dWrapProperty( index, property.WrapOnHorizontial, property.WrapOnVertical );
+        }
+
+        #endregion texture setting
+    }
+
+    [StructLayout( LayoutKind.Explicit )]
+    public struct TextureProperty
+    {
+
+        [FieldOffset( 0 )] private M128 mask;
+        [FieldOffset( 0 )] private TextureFilter mag;
+        [FieldOffset( 4 )] private TextureFilter min;
+
+        [FieldOffset( 8 )] private  TextureWrap hori;
+        [FieldOffset( 12 )] private TextureWrap vert;
+
+        public TextureProperty(
+               TextureFilter onMagnify,
+               TextureFilter onMinify,
+               TextureWrap onHorizontial,
+               TextureWrap onVertical )
+        {
+            FilterOnMagnify = onMagnify;
+            FilterOnMinify = onMinify;
+            WrapOnHorizontial = onHorizontial;
+            WrapOnVertical = onVertical;
+        }
+
+        public TextureFilter FilterOnMagnify
+        {
+            get => mag;
+            set => mag = value;
+        }
+
+        public TextureFilter FilterOnMinify
+        {
+            get => min;
+            set => min = value;
+        }
+
+        public TextureWrap WrapOnHorizontial
+        {
+            get => hori;
+            set => hori = value;
+        }
+
+        public TextureWrap WrapOnVertical
+        {
+            get => vert;
+            set => vert = value;
+        }
+
+        public override bool Equals( [NotNullWhen( true )] object obj )
+        {
+            return base.Equals( obj );
+        }
+
+        public override int GetHashCode()
+        {
+            return HashCode.Combine(
+                FilterOnMagnify, FilterOnMagnify, WrapOnHorizontial, WrapOnVertical );
+        }
+
+        public override string ToString()
+        {
+            return $"FilterOnMagnify:{FilterOnMagnify}, " + $"FilterOnMagnify:{FilterOnMagnify}, " + $"WrapOnHorizontial:{WrapOnHorizontial}, " + $"WrapOnVertical:{WrapOnVertical}";
+        }
+
+        public static bool operator !=( TextureProperty left, TextureProperty right )
+        {
+            return left.mask != right.mask;
+        }
+
+        public static bool operator ==( TextureProperty left, TextureProperty right )
+        {
+            return left.mask == right.mask;
+        }
+
+        public static implicit operator TextureProperty(
+                                        (
+            TextureFilter onMagnify, TextureFilter onMinify,
+            TextureWrap onHorizontial, TextureWrap onVertical
+            ) propertyValueTuple )
+        {
+            return new TextureProperty(
+                propertyValueTuple.onMagnify, propertyValueTuple.onMinify,
+                propertyValueTuple.onHorizontial, propertyValueTuple.onVertical );
+        }
+
+    }
+
+    #pragma warning disable CA1008
+    public enum TextureFilter
+    #pragma warning restore CA1008
+    {
+
+        Nearest = glConst.NEAREST,
+        Linear = glConst.LINEAR,
+        NearestLinearMipmap = glConst.NEAREST_MIPMAP_LINEAR,
+        LinearLinearMipmap = glConst.LINEAR_MIPMAP_LINEAR,
+        NearestNearestMipmap = glConst.NEAREST_MIPMAP_NEAREST,
+        LinearNearestMipmap = glConst.LINEAR_MIPMAP_NEAREST,
+
+    }
+
+    #pragma warning disable CA1008
+    public enum TextureUnit
+    #pragma warning restore CA1008
+    {
+
+        Unit0 = glConst.TEXTURE0,
+        Unit1 = glConst.TEXTURE1,
+        Unit2 = glConst.TEXTURE2,
+        Unit3 = glConst.TEXTURE3,
+        Unit4 = glConst.TEXTURE4,
+        Unit5 = glConst.TEXTURE5,
+        Unit6 = glConst.TEXTURE6,
+        Unit7 = glConst.TEXTURE7,
+        Unit8 = glConst.TEXTURE8,
+        Unit9 = glConst.TEXTURE9,
+        Unit10 = glConst.TEXTURE10,
+        Unit11 = glConst.TEXTURE11,
+        Unit12 = glConst.TEXTURE12,
+        Unit13 = glConst.TEXTURE13,
+        Unit14 = glConst.TEXTURE14,
+        Unit15 = glConst.TEXTURE15,
+
+    }
+
+    #pragma warning disable CA1008 
+    public enum TextureWrap
+    #pragma warning restore CA1008 
+    {
+
+        Repeat = glConst.REPEAT,
+        MirroredRepeat = glConst.MIRRORED_REPEAT,
+        ClampToEdge = glConst.CLAMP_TO_EDGE,
+        ClampToBorder = glConst.CLAMP_TO_BORDER,
+
+    }
+}

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

@@ -0,0 +1,80 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="VAO.cs"
+//     Project: StepVisualizer
+//     AuthorGroup: Nitload Space
+//     Copyright (c) Nitload Space. All rights reserved.
+//     
+//     Permission is hereby granted, free of charge, to any person 
+//     obtaining a copy of this software and associated documentation 
+//     files (the “Software”), to deal in the Software without restriction, 
+//     including without limitation the rights to use, copy, modify, merge,
+//     publish, distribute, sublicense, and/or sell copies of the Software, 
+//     and to permit persons to whom the Software is furnished to do so, 
+//     subject to the following conditions:
+//     
+//     The above copyright notice and 
+//     this permission notice shall be included in all copies 
+//     or substantial portions of the Software.
+//     
+//     THE SOFTWARE IS PROVIDED “AS IS”, 
+//     WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, 
+//     INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+//     FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+//     IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, 
+//     DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+//     ARISING FROM, OUT OF OR IN CONNECTION WITH 
+//     THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//     
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public sealed unsafe class VertexArray : GlBufferObjectBase
+    {
+
+        internal VertexArray( int n, glRender binding )
+            : base( binding )
+        {
+            _bufferHandle = GL.GenVertexArrays( n );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public override sealed void Bind( int index )
+        {
+            GL.BindVertexArray( _bufferHandle[ index ] );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public static void BindNull()
+        {
+            OpenGLFunction.CurrentGL.BindVertexArray( GlHandle.Zero );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SetVertexAttribute(
+                    uint attributeIndex,
+                    int vertexLength,
+                    TypeCode dataType,
+                    bool isNomalized,
+                    uint stride,
+                    int pointer )
+        {
+            GL.SetVertexAttribute(
+                attributeIndex, vertexLength, dataType, isNomalized, stride, pointer );
+        }
+
+        protected override sealed void Dispose( bool disposing )
+        {
+            if( disposing ) {
+                GL.DeleteVertexArrays( _bufferHandle );
+            }
+        }
+
+    }
+}

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

@@ -0,0 +1,185 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="VBO.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.Mathematics;
+
+using System;
+using System.Collections.Generic;
+using System.Net.Security;
+using System.Numerics;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public sealed unsafe class VertexBuffer : GlBufferObjectBase
+    {
+
+        internal VertexBuffer(int n, glRender binding)
+            : base(binding)
+        {
+            _bufferHandle = GL.GenBuffers(n);
+        }
+
+        public sealed override void Bind(int index)
+        {
+            GL.BindBuffer(BufferType.ArrayBuffer, _bufferHandle[index]);
+        }
+
+        /// <summary>
+        ///
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Unbind()
+        {
+            GL.BindBuffer(BufferType.ArrayBuffer, GlHandle.Zero);
+        }
+
+        /// <summary>
+        ///   Set _data to current vertex BufferHandle object
+        /// </summary>
+        /// <typeparam _label="TItem">
+        ///   Type of bufferData
+        /// </typeparam>
+        /// <param _label="index">
+        ///   Index to find certain VBO in this instance
+        /// </param>
+        /// <param _label="bufferData">
+        ///   Data to write in
+        /// </param>
+        /// <param _label="usage">
+        ///   How OpenGL use these _data, defined by <see cref="BufferUsage" />
+        /// </param>
+        public void WriteMatrixData<T>(int index, T bufferData, BufferUsage usage)
+            where T: unmanaged, IMatrix<T>
+        {
+            GL.BindBuffer(BufferType.ArrayBuffer, _bufferHandle[index]);
+            GL.SetBufferData(BufferType.ArrayBuffer, bufferData, usage);
+        }
+
+        /// <summary>
+        ///   Set _data to current vertex BufferHandle object
+        /// </summary>
+        /// <typeparam _label="TItem">
+        ///   Type of bufferData
+        /// </typeparam>
+        /// <param _label="index">
+        ///   Index to find certain VBO in this instance
+        /// </param>
+        /// <param _label="bufferArray">
+        ///   Data to write in
+        /// </param>
+        /// <param _label="usage">
+        ///   How OpenGL use these _data, defined by <see cref="BufferUsage" />
+        /// </param>
+        public void WriteScalerData<T>(int index, T[] bufferArray, BufferUsage usage)
+            where T: unmanaged, INumber<T>
+        {
+            GL.BindBuffer(BufferType.ArrayBuffer, _bufferHandle[index]);
+            GL.SetBufferData(BufferType.ArrayBuffer, bufferArray, usage);
+        }
+
+        /// <summary>
+        ///   Set _data to current vertex BufferHandle object
+        /// </summary>
+        /// <typeparam _label="TItem">
+        ///   Type of bufferData
+        /// </typeparam>
+        /// <param _label="index">
+        ///   Index to find certain VBO in this instance
+        /// </param>
+        /// <param _label="scalerSpan">
+        ///   A <see cref="Span{T}" /> of _data to write in
+        /// </param>
+        /// <param _label="usage">
+        ///   How OpenGL use these _data, defined by <see cref="BufferUsage" />
+        /// </param>
+        public void WriteScalerData<T>(int index, ReadOnlySpan<T> scalerSpan, BufferUsage usage)
+            where T: unmanaged,INumber<T>
+        {
+            GL.BindBuffer(BufferType.ArrayBuffer, _bufferHandle[index]);
+            GL.SetBufferData(BufferType.ArrayBuffer, scalerSpan, usage);
+        }
+
+        /// <summary>
+        ///   Set data to current vertex BufferHandle object
+        /// </summary>
+        /// <typeparam _label="TItem">
+        ///   Type of bufferData
+        /// </typeparam>
+        /// <param _label="index">
+        ///   Index to find certain VBO in this instance
+        /// </param>
+        /// <param _label="vectorSpan">
+        ///   A <see cref="Span{T}" /> of data to write in
+        /// </param>
+        /// <param _label="usage">
+        ///   How OpenGL use these data, defined by <see cref="BufferUsage" />
+        /// </param>
+        public void WriteVectorData<T>(int index, ReadOnlySpan<T> vectorSpan, BufferUsage usage)
+            where T: unmanaged, IFixedVector<T>
+        {
+            GL.BindBuffer(BufferType.ArrayBuffer, _bufferHandle[index]);
+            GL.SetBufferVectorData(BufferType.ArrayBuffer, vectorSpan, usage);
+        }
+
+        /// <summary>
+        ///   Set _data to current vertex BufferHandle object
+        /// </summary>
+        /// <typeparam _label="TItem">
+        ///   Type of bufferData
+        /// </typeparam>
+        /// <param _label="index">
+        ///   Index to find certain VBO in this instance
+        /// </param>
+        /// <param _label="vectorArray">
+        ///   A array of _data to write in
+        /// </param>
+        /// <param _label="usage">
+        ///   How OpenGL use these _data, defined by <see cref="BufferUsage" />
+        /// </param>
+        public void WriteVectorData<T>(int index, T[] vectorArray, BufferUsage usage)
+            where T: unmanaged, IFixedVector<T>
+        {
+            GL.BindBuffer(BufferType.ArrayBuffer, _bufferHandle[index]);
+            GL.SetBufferVectorData(BufferType.ArrayBuffer, vectorArray, usage);
+        }
+
+        protected sealed override void Dispose(bool disposing)
+        {
+            if (disposing) {
+                GL.DeleteBuffers(_bufferHandle);
+            }
+        }
+
+    }
+}

StgSharp.Common/Graphics/OpenGL/GLfixed.cs

@@ -0,0 +1,49 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="GLfixed.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.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Internal
+{
+    [StructLayout( LayoutKind.Explicit, Size = 8 )]
+    public struct GLfixed
+    {
+
+        [FieldOffset( 0 )] public int All;
+        [FieldOffset( 0 )] public short Decimals;
+        [FieldOffset( 4 )] public short Inertger;
+
+    }
+}

StgSharp.Common/Graphics/OpenGL/ShaderEdit/IglConvertable.cs

@@ -0,0 +1,68 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="IglConvertable.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.ShaderEdit
+{
+    public interface IglConvertable
+    {
+
+        /// <summary>
+        ///
+        /// </summary>
+        public void DisplayGLtypeDefinition();
+
+        /// <summary>
+        ///
+        /// </summary>
+        public void GainAllUniforms( ShaderProgram source, params string[] uniformName );
+
+        /// <summary>
+        ///
+        /// </summary>
+        /// <returns>
+        ///
+        /// </returns>
+        public ShaderStruct GetConvertedGLtype();
+
+        /// <summary>
+        ///
+        /// </summary>
+        public void SetAllUniforms();
+
+    }
+}

StgSharp.Common/Graphics/OpenGL/ShaderEdit/Shader.cs

@@ -0,0 +1,288 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Shader.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;
+using StgSharp.Internal;
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Xml.Linq;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public abstract partial class glRender : RenderStream
+    {
+
+        /// <summary>
+        ///   Create an instance of <see cref="Shader" /> program
+        /// </summary>
+        /// <returns>
+        ///   New instance of <see cref="Shader" /> instance.
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected override sealed ShaderProgram CreateShaderProgram()
+        {
+            return new ShaderProgram(this);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected override sealed Shader CreateShaderSegment(ShaderType type, int count)
+        {
+            return new Shader(GL.CreateShaderSet(count, type), type, this);
+        }
+
+    }
+
+    public class Shader : ISSDSerializable
+    {
+
+        private readonly OpenGLFunction GL;
+        internal readonly GlHandle[] handle;
+        public readonly ShaderType type;
+
+        internal unsafe Shader(GlHandle[] handle, ShaderType usage, glRender stream)
+        {
+            this.handle = handle;
+            GL = stream.GL;
+            type = usage;
+        }
+
+        public SerializableTypeCode SSDTypeCode => SerializableTypeCode.Shader;
+
+        /// <summary>
+        ///   Attach one shader code to a shader program.
+        /// </summary>
+        /// <param _label="target">
+        ///   Shader program to attach
+        /// </param>
+        /// <param _label="index">
+        ///   Index of shader code in current shader code set.
+        /// </param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void AttachTo(int index, [NotNull]ShaderProgram target)
+        {
+            GL.AttachShader(target.handle, handle[index]);
+        }
+
+        public void CheckStatus(int index, ShaderStatus status)
+        {
+            string log = GL.GetShaderStatus(this, index, (int)status);
+            if (!string.IsNullOrEmpty(log)) {
+                throw new InvalidOperationException($"{$"Shader Error \t{status}\n"}{log}");
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void Compile(int index, ReadOnlySpan<byte> codeU8Stream)
+        {
+            GL.LoadShaderSource(handle[index], codeU8Stream);
+            GL.CompileShader(handle[index]);
+            CheckStatus(index, ShaderStatus.CompileStatus);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void Compile(int index, byte[] codeStream)
+        {
+            ArgumentNullException.ThrowIfNull(codeStream);
+            GL.LoadShaderSource(handle[index], codeStream);
+            GL.CompileShader(handle[index]);
+            CheckStatus(index, ShaderStatus.CompileStatus);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void Compile(int index, string codeStream)
+        {
+            ArgumentNullException.ThrowIfNull(codeStream);
+            GL.LoadShaderSource(handle[index], codeStream.AsSpan());
+            GL.CompileShader(handle[index]);
+            CheckStatus(index, ShaderStatus.CompileStatus);
+        }
+
+        public void FromBytes(byte[] stream)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static byte[] FromCodeFile(string fileRoute)
+        {
+            string str = File.ReadAllText(fileRoute);
+            if (string.IsNullOrEmpty(str)) {
+                throw new InvalidOperationException($"Cannot load and GLSL code from {fileRoute}");
+            }
+            return Encoding.UTF8.GetBytes(str);
+        }
+
+        public byte[] GetBytes()
+        {
+            return Array.Empty<byte>();
+        }
+
+        public byte[] GetBytes(out int length)
+        {
+            throw new NotImplementedException();
+        }
+
+        public override string ToString()
+        {
+            return $"This is a {type} shader, its shader handles are {handle.ToString()}.";
+        }
+
+    }
+
+    public enum ShaderStatus : int
+    {
+
+        CompileStatus = glConst.COMPILE_STATUS,
+
+    }
+
+    public class ShaderProgram
+    {
+
+        private readonly OpenGLFunction GL;
+        internal readonly GlHandle handle;
+
+        /// <summary>
+        ///   CustomizeInit a program with no shader attached.
+        /// </summary>
+        internal unsafe ShaderProgram(glRender binding)
+        {
+            GL = binding.GL;
+            handle = GL.CreateProgram();
+        }
+
+        /// <summary>
+        ///   Get a uniform form current shader, the value type of the uniform should be provided.
+        /// </summary>
+        /// <param _label="name">
+        ///   ContextName of the Uniform in shader code
+        /// </param>
+        /// <returns>
+        ///
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe Uniform<T> GetUniform<T>(string name) where T: unmanaged
+        {
+            return new Uniform<T>(GL.GetUniformLocation(this.handle, name));
+        }
+
+        /// <summary>
+        ///   Get a uniform form current shader, the value type of the uniform should be provided.
+        /// </summary>
+        /// <param _label="name">
+        ///   ContextName of the Uniform in shader code
+        /// </param>
+        /// <returns>
+        ///
+        /// </returns>
+        public unsafe Uniform<T, U> GetUniform<T, U>(string name) where T: unmanaged where U: struct
+        {
+            return new Uniform<T, U>(GL.GetUniformLocation(this.handle, name));
+        }
+
+        /// <summary>
+        ///   Get a uniform form current shader, the value type of the uniform should be provided.
+        /// </summary>
+        /// <param _label="name">
+        ///   ContextName of the Uniform in shader code
+        /// </param>
+        /// <returns>
+        ///
+        /// </returns>
+        public unsafe Uniform<T, U, V> GetUniform<T, U, V>(string name) where T: unmanaged
+            where U: struct
+            where V: struct
+        {
+            return new Uniform<T, U, V>(GL.GetUniformLocation(this.handle, name));
+        }
+
+        /// <summary>
+        ///   Get a uniform form current shader, the value type of the uniform should be provided.
+        /// </summary>
+        /// <param _label="name">
+        ///   ContextName of the Uniform in shader code
+        /// </param>
+        /// <returns>
+        ///
+        /// </returns>
+        public unsafe Uniform<T, U, V, W> GetUniform<T, U, V, W>(string name) where T: unmanaged
+            where U: struct
+            where V: struct
+            where W: struct
+        {
+            return new Uniform<T, U, V, W>(GL.GetUniformLocation(this.handle, name));
+        }
+
+        /// <summary>
+        ///   Link the shader to current viewPortDisplay.
+        /// </summary>
+        public unsafe void Link()
+        {
+            if (InternalIO.InternalLinkShaderProgram(
+                (OpenglContext*)this.GL.ContextHandle, handle.Value) ==
+                0)
+            {
+                IntPtr logPtr = InternalIO.InternalReadSSCLog();
+                try
+                {
+                    byte[] logByte = new byte[512];
+                    Marshal.Copy(logPtr, logByte, 0, 512);
+                    string log = Encoding.UTF8.GetString(logByte);
+                    log = log.Replace("\0", string.Empty);
+                    InternalIO.InternalWriteLog(log, LogType.Error);
+                }
+                catch (Exception ex)
+                {
+                    InternalIO.InternalWriteLog(ex.Message, LogType.Error);
+                }
+            }
+        }
+
+        /// <summary>
+        ///   Let the current viewPortDisplay use this shader.
+        /// </summary>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void Use()
+        {
+            GL.UseProgram(handle);
+        }
+
+        ~ShaderProgram()
+        {
+            //handle.Dispose();
+        }
+
+    }
+}

StgSharp.Common/Graphics/OpenGL/ShaderEdit/Uniform.cs

@@ -0,0 +1,205 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="Uniform.cs"
+//     Project: StepVisualizer
+//     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.Mathematics;
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public class Uniform
+    {
+
+        internal GlHandle id;
+
+        public GlHandle Handle
+        {
+            get => id;
+        }
+
+    }
+
+    public sealed class Uniform<T> : Uniform where T:unmanaged
+    {
+
+        internal Uniform() { }
+
+        internal unsafe Uniform( GlHandle id )
+        {
+            this.id = id;
+        }
+
+        internal static Uniform<T> FromHandle( GlHandle handle )
+        {
+            return new Uniform<T>
+            {
+                id = handle
+            };
+        }
+
+    }
+
+    public sealed class Uniform<T, U> : Uniform where T:unmanaged where U: struct
+    {
+
+        internal Uniform() { }
+
+        internal unsafe Uniform( GlHandle id )
+        {
+            this.id = id;
+        }
+
+        internal static Uniform<T, U> FromHandle( GlHandle handle )
+        {
+            return new Uniform<T, U>
+            {
+                id = handle
+            };
+        }
+
+    }
+
+    public sealed class Uniform<T, U, V> : Uniform where T:unmanaged where U: struct where V: struct
+    {
+
+        internal Uniform() { }
+
+        internal unsafe Uniform( GlHandle id )
+        {
+            this.id = id;
+        }
+
+        internal static Uniform<T, U, V> FromHandle( GlHandle handle )
+        {
+            return new Uniform<T, U, V>
+            {
+                id = handle
+            };
+        }
+
+    }
+
+    public sealed class Uniform<T, U, V, W> : Uniform where T:unmanaged where U: struct
+        where V: struct
+        where W: struct
+    {
+
+        internal Uniform() { }
+
+        internal unsafe Uniform( GlHandle id )
+        {
+            this.id = id;
+        }
+
+        internal static Uniform<T, U, V, W> FromHandle( GlHandle handle )
+        {
+            return new Uniform<T, U, V, W>
+            {
+                id = handle
+            };
+        }
+
+    }
+
+    public unsafe partial class OpenGLFunction
+    {
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SetUniformValue( [NotNull] Uniform<Matrix44> uniform, Matrix44 mat )
+        {
+            Matrix44 temp = mat;
+            Context.glUniformMatrix4fv( uniform.id.SignedValue, 1, false, ( float* )&temp );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SetUniformValue(
+                    [NotNull]Uniform<float, float, float, float> uniform,
+                    Vec4 vec )
+        {
+            Vec4 temp = vec;
+            Context.glUniform1fv( uniform.id.SignedValue, 4, &temp.reg );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SetUniformValue( [NotNull]Uniform<Vec4> uniform, Vec4 vec )
+        {
+            Vec4 temp = vec;
+            Context.glUniform1fv( uniform.id.SignedValue, 4, &temp.reg );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SetUniformValue( [NotNull]Uniform<float> uniform, float v0 )
+        {
+            Context.glUniform1f( uniform.id.SignedValue, v0 );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SetUniformValue( [NotNull]Uniform<int> uniform, int i0 )
+        {
+            Context.glUniform1i( uniform.id.SignedValue, i0 );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SetUniformValue( [NotNull] Uniform<float, float> uniform, float v0, float v1 )
+        {
+            Context.glUniform2f( uniform.id.SignedValue, v0, v1 );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SetUniformValue(
+                    [NotNull] Uniform<float, float, float> uniform,
+                    float v0,
+                    float v1,
+                    float v2 )
+        {
+            Context.glUniform3f( uniform.id.SignedValue, v0, v1, v2 );
+        }
+
+        [MethodImpl( MethodImplOptions.AggressiveInlining )]
+        public void SetUniformValue(
+                    [NotNull] Uniform<float, float, float, float> uniform,
+                    float v0,
+                    float v1,
+                    float v2,
+                    float v3 )
+        {
+            Context.glUniform4f( uniform.id.SignedValue, v0, v1, v2, v3 );
+        }
+
+    }
+}

StgSharp.Common/Graphics/OpenGL/glAPICalling.cs

@@ -0,0 +1,44 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="glAPICalling.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.OpenGL
+{
+    [AttributeUsage( AttributeTargets.Method )]
+    public sealed class OpenGLAPICallingAttribute : Attribute
+    {
+
+        public OpenGLAPICallingAttribute() { }
+
+    }
+}

StgSharp.Common/Graphics/OpenGL/glApiManagerConst.cs

@@ -0,0 +1,688 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="glApiManagerConst.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.OpenGL
+{
+    public static partial class glManager
+    {
+
+        #region coreVersion
+
+        private static bool core10 = false;
+        private static bool core11 = false;
+        private static bool core12 = false;
+        private static bool core13 = false;
+        private static bool core14 = false;
+        private static bool core15 = false;
+        private static bool core20 = false;
+        private static bool core21 = false;
+        private static bool core30 = false;
+        private static bool core31 = false;
+        private static bool core32 = false;
+        private static bool core33 = false;
+        private static bool core40 = false;
+        private static bool core41 = false;
+        private static bool core42 = false;
+        private static bool core43 = false;
+        private static bool core44 = false;
+        private static bool core45 = false;
+        private static bool core46 = false;
+
+        #endregion
+
+        #region extension
+
+        private static bool _3DFX_tbuffer;
+        private static bool _3DFX_texture_compression_FXT1;
+        private static bool _4DFX_multisample;
+        private static bool AMD_blend_minmax_factor;
+        private static bool AMD_conservative_depth;
+        private static bool AMD_debug_output;
+        private static bool AMD_depth_clamp_separate;
+        private static bool AMD_draw_buffers_blend;
+        private static bool AMD_framebuffer_multisample_advanced;
+        private static bool AMD_framebuffer_sample_positions;
+        private static bool AMD_gcn_shader;
+        private static bool AMD_gpu_shader_half_float;
+        private static bool AMD_gpu_shader_int16;
+        private static bool AMD_gpu_shader_int64;
+        private static bool AMD_interleaved_elements;
+        private static bool AMD_multi_draw_indirect;
+        private static bool AMD_name_gen_delete;
+        private static bool AMD_occlusion_query_event;
+        private static bool AMD_performance_monitor;
+        private static bool AMD_pinned_memory;
+        private static bool AMD_query_buffer_object;
+        private static bool AMD_sample_positions;
+        private static bool AMD_seamless_cubemap_per_texture;
+        private static bool AMD_shader_atomic_counter_ops;
+        private static bool AMD_shader_ballot;
+        private static bool AMD_shader_explicit_vertex_parameter;
+        private static bool AMD_shader_gpu_shader_half_float_fetch;
+        private static bool AMD_shader_image_load_store_lod;
+        private static bool AMD_shader_stencil_export;
+        private static bool AMD_shader_trinary_minmax;
+        private static bool AMD_sparse_texture;
+        private static bool AMD_stencil_operation_extended;
+        private static bool AMD_texture_gather_bias_lod;
+        private static bool AMD_texture_texture4;
+        private static bool AMD_transform_feedback3_lines_triangles;
+        private static bool AMD_transform_feedback4;
+        private static bool AMD_vertex_shader_layer;
+        private static bool AMD_vertex_shader_tessellator;
+        private static bool AMD_vertex_shader_viewport_index;
+        private static bool APPLE_aux_depth_stencil;
+        private static bool APPLE_client_storage;
+        private static bool APPLE_element_array;
+        private static bool APPLE_fence;
+        private static bool APPLE_float_pixels;
+        private static bool APPLE_flush_buffer_range;
+        private static bool APPLE_object_purgeable;
+        private static bool APPLE_rgb_422;
+        private static bool APPLE_row_bytes;
+        private static bool APPLE_specular_vector;
+        private static bool APPLE_texture_range;
+        private static bool APPLE_transform_hint;
+        private static bool APPLE_vertex_array_object;
+        private static bool APPLE_vertex_array_range;
+        private static bool APPLE_vertex_program_evaluators;
+        private static bool APPLE_ycbcr_422;
+        private static bool ARB_arrays_of_arrays;
+        private static bool ARB_base_instance;
+        private static bool ARB_bindless_texture;
+        private static bool ARB_blend_func_extended;
+        private static bool ARB_buffer_storage;
+        private static bool ARB_cl_event;
+        private static bool ARB_clear_buffer_object;
+        private static bool ARB_clear_texture;
+        private static bool ARB_clip_control;
+        private static bool ARB_color_buffer_float;
+        private static bool ARB_compatibility;
+        private static bool ARB_compressed_texture_pixel_storage;
+        private static bool ARB_compute_shader;
+        private static bool ARB_compute_variable_group_size;
+        private static bool ARB_conditional_render_inverted;
+        private static bool ARB_conservative_depth;
+        private static bool ARB_copy_buffer;
+        private static bool ARB_copy_image;
+        private static bool ARB_cull_distance;
+        private static bool ARB_debug_output;
+        private static bool ARB_depth_buffer_float;
+        private static bool ARB_depth_clamp;
+        private static bool ARB_depth_texture;
+        private static bool ARB_derivative_control;
+        private static bool ARB_direct_state_access;
+        private static bool ARB_draw_buffers;
+        private static bool ARB_draw_buffers_blend;
+        private static bool ARB_draw_elements_base_vertex;
+        private static bool ARB_draw_indirect;
+        private static bool ARB_draw_instanced;
+        private static bool ARB_enhanced_layouts;
+        private static bool ARB_ES2_compatibility;
+        private static bool ARB_ES3_1_compatibility;
+        private static bool ARB_ES3_2_compatibility;
+        private static bool ARB_ES3_compatibility;
+        private static bool ARB_explicit_attrib_location;
+        private static bool ARB_explicit_uniform_location;
+        private static bool ARB_fragment_coord_conventions;
+        private static bool ARB_fragment_layer_viewport;
+        private static bool ARB_fragment_program;
+        private static bool ARB_fragment_program_shadow;
+        private static bool ARB_fragment_shader;
+        private static bool ARB_fragment_shader_interlock;
+        private static bool ARB_framebuffer_no_attachments;
+        private static bool ARB_framebuffer_object;
+        private static bool ARB_framebuffer_sRGB;
+        private static bool ARB_geometry_shader4;
+        private static bool ARB_get_program_binary;
+        private static bool ARB_get_texture_sub_image;
+        private static bool ARB_gl_spirv;
+        private static bool ARB_gpu_shader_fp64;
+        private static bool ARB_gpu_shader_int64;
+        private static bool ARB_gpu_shader5;
+        private static bool ARB_half_float_pixel;
+        private static bool ARB_half_float_vertex;
+        private static bool ARB_imaging;
+        private static bool ARB_indirect_parameters;
+        private static bool ARB_instanced_arrays;
+        private static bool ARB_internalformat_query;
+        private static bool ARB_internalformat_query2;
+        private static bool ARB_invalidate_subdata;
+        private static bool ARB_map_buffer_alignment;
+        private static bool ARB_map_buffer_range;
+        private static bool ARB_matrix_palette;
+        private static bool ARB_multi_bind;
+        private static bool ARB_multi_draw_indirect;
+        private static bool ARB_multisample;
+        private static bool ARB_multitexture;
+        private static bool ARB_occlusion_query;
+        private static bool ARB_occlusion_query2;
+        private static bool ARB_parallel_shader_compile;
+        private static bool ARB_pipeline_statistics_query;
+        private static bool ARB_pixel_buffer_object;
+        private static bool ARB_point_parameters;
+        private static bool ARB_point_sprite;
+        private static bool ARB_polygon_offset_clamp;
+        private static bool ARB_post_depth_coverage;
+        private static bool ARB_program_interface_query;
+        private static bool ARB_provoking_vertex;
+        private static bool ARB_query_buffer_object;
+        private static bool ARB_robust_buffer_access_behavior;
+        private static bool ARB_robustness;
+        private static bool ARB_robustness_isolation;
+        private static bool ARB_sample_locations;
+        private static bool ARB_sample_shading;
+        private static bool ARB_sampler_objects;
+        private static bool ARB_seamless_cube_map;
+        private static bool ARB_seamless_cubemap_per_texture;
+        private static bool ARB_separate_shader_objects;
+        private static bool ARB_shader_atomic_counter_ops;
+        private static bool ARB_shader_atomic_counters;
+        private static bool ARB_shader_ballot;
+        private static bool ARB_shader_bit_encoding;
+        private static bool ARB_shader_clock;
+        private static bool ARB_shader_draw_parameters;
+        private static bool ARB_shader_group_vote;
+        private static bool ARB_shader_image_load_store;
+        private static bool ARB_shader_image_size;
+        private static bool ARB_shader_objects;
+        private static bool ARB_shader_precision;
+        private static bool ARB_shader_stencil_export;
+        private static bool ARB_shader_storage_buffer_object;
+        private static bool ARB_shader_subroutine;
+        private static bool ARB_shader_texture_image_samples;
+        private static bool ARB_shader_texture_lod;
+        private static bool ARB_shader_viewport_layer_array;
+        private static bool ARB_shading_language_100;
+        private static bool ARB_shading_language_420pack;
+        private static bool ARB_shading_language_include;
+        private static bool ARB_shading_language_packing;
+        private static bool ARB_shadow;
+        private static bool ARB_shadow_ambient;
+        private static bool ARB_sparse_buffer;
+        private static bool ARB_sparse_texture;
+        private static bool ARB_sparse_texture_clamp;
+        private static bool ARB_sparse_texture2;
+        private static bool ARB_spirv_extensions;
+        private static bool ARB_stencil_texturing;
+        private static bool ARB_sync;
+        private static bool ARB_tessellation_shader;
+        private static bool ARB_texture_barrier;
+        private static bool ARB_texture_border_clamp;
+        private static bool ARB_texture_buffer_object;
+        private static bool ARB_texture_buffer_object_rgb32;
+        private static bool ARB_texture_buffer_range;
+        private static bool ARB_texture_compression;
+        private static bool ARB_texture_compression_bptc;
+        private static bool ARB_texture_compression_rgtc;
+        private static bool ARB_texture_cube_map;
+        private static bool ARB_texture_cube_map_array;
+        private static bool ARB_texture_env_add;
+        private static bool ARB_texture_env_combine;
+        private static bool ARB_texture_env_crossbar;
+        private static bool ARB_texture_env_dot3;
+        private static bool ARB_texture_filter_anisotropic;
+        private static bool ARB_texture_filter_minmax;
+        private static bool ARB_texture_float;
+        private static bool ARB_texture_gather;
+        private static bool ARB_texture_mirror_clamp_to_edge;
+        private static bool ARB_texture_mirrored_repeat;
+        private static bool ARB_texture_multisample;
+        private static bool ARB_texture_non_power_of_two;
+        private static bool ARB_texture_query_levels;
+        private static bool ARB_texture_query_lod;
+        private static bool ARB_texture_rectangle;
+        private static bool ARB_texture_rg;
+        private static bool ARB_texture_rgb10_a2ui;
+        private static bool ARB_texture_stencil8;
+        private static bool ARB_texture_storage;
+        private static bool ARB_texture_storage_multisample;
+        private static bool ARB_texture_swizzle;
+        private static bool ARB_texture_view;
+        private static bool ARB_timer_query;
+        private static bool ARB_transform_feedback_instanced;
+        private static bool ARB_transform_feedback_overflow_query;
+        private static bool ARB_transform_feedback2;
+        private static bool ARB_transform_feedback3;
+        private static bool ARB_transpose_matrix;
+        private static bool ARB_uniform_buffer_object;
+        private static bool ARB_vertex_array_bgra;
+        private static bool ARB_vertex_array_object;
+        private static bool ARB_vertex_attrib_64bit;
+        private static bool ARB_vertex_attrib_binding;
+        private static bool ARB_vertex_blend;
+        private static bool ARB_vertex_buffer_object;
+        private static bool ARB_vertex_program;
+        private static bool ARB_vertex_shader;
+        private static bool ARB_vertex_type_10f_11f_11f_rev;
+        private static bool ARB_vertex_type_2_10_10_10_rev;
+        private static bool ARB_viewport_array;
+        private static bool ARB_window_pos;
+        private static bool ATI_draw_buffers;
+        private static bool ATI_element_array;
+        private static bool ATI_envmap_bumpmap;
+        private static bool ATI_fragment_shader;
+        private static bool ATI_map_object_buffer;
+        private static bool ATI_meminfo;
+        private static bool ATI_pixel_format_float;
+        private static bool ATI_pn_triangles;
+        private static bool ATI_separate_stencil;
+        private static bool ATI_text_fragment_shader;
+        private static bool ATI_texture_env_combine3;
+        private static bool ATI_texture_float;
+        private static bool ATI_texture_mirror_once;
+        private static bool ATI_vertex_array_object;
+        private static bool ATI_vertex_attrib_array_object;
+        private static bool ATI_vertex_streams;
+        private static bool EXT_422_pixels;
+        private static bool EXT_abgr;
+        private static bool EXT_bgra;
+        private static bool EXT_bindable_uniform;
+        private static bool EXT_blend_color;
+        private static bool EXT_blend_equation_separate;
+        private static bool EXT_blend_func_separate;
+        private static bool EXT_blend_logic_op;
+        private static bool EXT_blend_minmax;
+        private static bool EXT_blend_subtract;
+        private static bool EXT_clip_volume_hint;
+        private static bool EXT_cmyka;
+        private static bool EXT_color_subtable;
+        private static bool EXT_compiled_vertex_array;
+        private static bool EXT_convolution;
+        private static bool EXT_coordinate_frame;
+        private static bool EXT_copy_texture;
+        private static bool EXT_cull_vertex;
+        private static bool EXT_debug_label;
+        private static bool EXT_debug_marker;
+        private static bool EXT_depth_bounds_test;
+        private static bool EXT_direct_state_access;
+        private static bool EXT_draw_buffers2;
+        private static bool EXT_draw_instanced;
+        private static bool EXT_draw_range_elements;
+        private static bool EXT_EGL_image_storage;
+        private static bool EXT_EGL_sync;
+        private static bool EXT_external_buffer;
+        private static bool EXT_fog_coord;
+        private static bool EXT_framebuffer_blit;
+        private static bool EXT_framebuffer_blit_layers;
+        private static bool EXT_framebuffer_multisample;
+        private static bool EXT_framebuffer_multisample_blit_scaled;
+        private static bool EXT_framebuffer_object;
+        private static bool EXT_framebuffer_sRGB;
+        private static bool EXT_geometry_shader4;
+        private static bool EXT_gpu_program_parameters;
+        private static bool EXT_gpu_shader4;
+        private static bool EXT_histogram;
+        private static bool EXT_index_array_formats;
+        private static bool EXT_index_func;
+        private static bool EXT_index_material;
+        private static bool EXT_index_texture;
+        private static bool EXT_light_texture;
+        private static bool EXT_memory_object;
+        private static bool EXT_memory_object_fd;
+        private static bool EXT_memory_object_win32;
+        private static bool EXT_misc_attribute;
+        private static bool EXT_multi_draw_arrays;
+        private static bool EXT_multisample;
+        private static bool EXT_multiview_tessellation_geometry_shader;
+        private static bool EXT_multiview_texture_multisample;
+        private static bool EXT_multiview_timer_query;
+        private static bool EXT_packed_depth_stencil;
+        private static bool EXT_packed_float;
+        private static bool EXT_packed_pixels;
+        private static bool EXT_paletted_texture;
+        private static bool EXT_pixel_buffer_object;
+        private static bool EXT_pixel_transform;
+        private static bool EXT_pixel_transform_color_table;
+        private static bool EXT_point_parameters;
+        private static bool EXT_polygon_offset;
+        private static bool EXT_polygon_offset_clamp;
+        private static bool EXT_post_depth_coverage;
+        private static bool EXT_provoking_vertex;
+        private static bool EXT_raster_multisample;
+        private static bool EXT_rescale_normal;
+        private static bool EXT_secondary_color;
+        private static bool EXT_semaphore;
+        private static bool EXT_semaphore_fd;
+        private static bool EXT_semaphore_win32;
+        private static bool EXT_separate_shader_objects;
+        private static bool EXT_separate_specular_color;
+        private static bool EXT_shader_framebuffer_fetch;
+        private static bool EXT_shader_framebuffer_fetch_non_coherent;
+        private static bool EXT_shader_image_load_formatted;
+        private static bool EXT_shader_image_load_store;
+        private static bool EXT_shader_integer_mix;
+        private static bool EXT_shader_samples_identical;
+        private static bool EXT_shadow_funcs;
+        private static bool EXT_shared_texture_palette;
+        private static bool EXT_sparse_texture2;
+        private static bool EXT_stencil_clear_tag;
+        private static bool EXT_stencil_two_side;
+        private static bool EXT_stencil_wrap;
+        private static bool EXT_subtexture;
+        private static bool EXT_texture;
+        private static bool EXT_texture_array;
+        private static bool EXT_texture_buffer_object;
+        private static bool EXT_texture_compression_latc;
+        private static bool EXT_texture_compression_rgtc;
+        private static bool EXT_texture_compression_s3tc;
+        private static bool EXT_texture_cube_map;
+        private static bool EXT_texture_env_add;
+        private static bool EXT_texture_env_combine;
+        private static bool EXT_texture_env_dot3;
+        private static bool EXT_texture_filter_anisotropic;
+        private static bool EXT_texture_filter_minmax;
+        private static bool EXT_texture_integer;
+        private static bool EXT_texture_lod_bias;
+        private static bool EXT_texture_mirror_clamp;
+        private static bool EXT_texture_object;
+        private static bool EXT_texture_perturb_normal;
+        private static bool EXT_texture_shadow_lod;
+        private static bool EXT_texture_shared_exponent;
+        private static bool EXT_texture_snorm;
+        private static bool EXT_texture_sRGB;
+        private static bool EXT_texture_sRGB_decode;
+        private static bool EXT_texture_sRGB_R8;
+        private static bool EXT_texture_sRGB_RG8;
+        private static bool EXT_texture_storage;
+        private static bool EXT_texture_swizzle;
+        private static bool EXT_texture3D;
+        private static bool EXT_timer_query;
+        private static bool EXT_transform_feedback;
+        private static bool EXT_vertex_array;
+        private static bool EXT_vertex_array_bgra;
+        private static bool EXT_vertex_attrib_64bit;
+        private static bool EXT_vertex_shader;
+        private static bool EXT_vertex_weighting;
+        private static bool EXT_win32_keyed_mutex;
+        private static bool EXT_window_rectangles;
+        private static bool EXT_x11_sync_object;
+        private static bool GREMEDY_frame_terminator;
+        private static bool GREMEDY_string_marker;
+        private static bool HP_convolution_border_modes;
+        private static bool HP_image_transform;
+        private static bool HP_occlusion_test;
+        private static bool HP_texture_lighting;
+        private static bool IBM_cull_vertex;
+        private static bool IBM_multimode_draw_arrays;
+        private static bool IBM_rasterpos_clip;
+        private static bool IBM_static_data;
+        private static bool IBM_texture_mirrored_repeat;
+        private static bool IBM_vertex_array_lists;
+        private static bool INGR_blend_func_separate;
+        private static bool INGR_color_clamp;
+        private static bool INGR_interlace_read;
+        private static bool INTEL_blackhole_render;
+        private static bool INTEL_conservative_rasterization;
+        private static bool INTEL_fragment_shader_ordering;
+        private static bool INTEL_framebuffer_CMAA;
+        private static bool INTEL_map_texture;
+        private static bool INTEL_parallel_arrays;
+        private static bool INTEL_performance_query;
+        private static bool KHR_blend_equation_advanced;
+        private static bool KHR_blend_equation_advanced_coherent;
+        private static bool KHR_context_flush_control;
+        private static bool KHR_debug;
+        private static bool KHR_no_error;
+        private static bool KHR_parallel_shader_compile;
+        private static bool KHR_robust_buffer_access_behavior;
+        private static bool KHR_robustness;
+        private static bool KHR_shader_subgroup;
+        private static bool KHR_texture_compression_astc_hdr;
+        private static bool KHR_texture_compression_astc_ldr;
+        private static bool KHR_texture_compression_astc_sliced_3d;
+        private static bool MESA_framebuffer_flip_x;
+        private static bool MESA_framebuffer_flip_y;
+        private static bool MESA_framebuffer_swap_xy;
+        private static bool MESA_pack_invert;
+        private static bool MESA_program_binary_formats;
+        private static bool MESA_resize_buffers;
+        private static bool MESA_shader_integer_functions;
+        private static bool MESA_tile_raster_order;
+        private static bool MESA_window_pos;
+        private static bool MESA_ycbcr_texture;
+        private static bool MESAX_texture_stack;
+        private static bool NV_alpha_to_coverage_dither_control;
+        private static bool NV_bindless_multi_draw_indirect;
+        private static bool NV_bindless_multi_draw_indirect_count;
+        private static bool NV_bindless_texture;
+        private static bool NV_blend_equation_advanced;
+        private static bool NV_blend_equation_advanced_coherent;
+        private static bool NV_blend_minmax_factor;
+        private static bool NV_blend_square;
+        private static bool NV_clip_space_w_scaling;
+        private static bool NV_command_list;
+        private static bool NV_compute_program5;
+        private static bool NV_compute_shader_derivatives;
+        private static bool NV_conditional_render;
+        private static bool NV_conservative_raster;
+        private static bool NV_conservative_raster_dilate;
+        private static bool NV_conservative_raster_pre_snap;
+        private static bool NV_conservative_raster_pre_snap_triangles;
+        private static bool NV_conservative_raster_underestimation;
+        private static bool NV_copy_depth_to_color;
+        private static bool NV_copy_image;
+        private static bool NV_deep_texture3D;
+        private static bool NV_depth_buffer_float;
+        private static bool NV_depth_clamp;
+        private static bool NV_draw_texture;
+        private static bool NV_draw_vulkan_image;
+        private static bool NV_evaluators;
+        private static bool NV_explicit_multisample;
+        private static bool NV_fence;
+        private static bool NV_fill_rectangle;
+        private static bool NV_float_buffer;
+        private static bool NV_fog_distance;
+        private static bool NV_fragment_coverage_to_color;
+        private static bool NV_fragment_program;
+        private static bool NV_fragment_program_option;
+        private static bool NV_fragment_program2;
+        private static bool NV_fragment_program4;
+        private static bool NV_fragment_shader_barycentric;
+        private static bool NV_fragment_shader_interlock;
+        private static bool NV_framebuffer_mixed_samples;
+        private static bool NV_framebuffer_multisample_coverage;
+        private static bool NV_geometry_program4;
+        private static bool NV_geometry_shader_passthrough;
+        private static bool NV_geometry_shader4;
+        private static bool NV_gpu_multicast;
+        private static bool NV_gpu_program4;
+        private static bool NV_gpu_program5;
+        private static bool NV_gpu_program5_mem_extended;
+        private static bool NV_gpu_shader5;
+        private static bool NV_half_float;
+        private static bool NV_internalformat_sample_query;
+        private static bool NV_light_max_exponent;
+        private static bool NV_memory_attachment;
+        private static bool NV_memory_object_sparse;
+        private static bool NV_mesh_shader;
+        private static bool NV_multisample_coverage;
+        private static bool NV_multisample_filter_hint;
+        private static bool NV_occlusion_query;
+        private static bool NV_packed_depth_stencil;
+        private static bool NV_parameter_buffer_object;
+        private static bool NV_parameter_buffer_object2;
+        private static bool NV_path_rendering;
+        private static bool NV_path_rendering_shared_edge;
+        private static bool NV_pixel_data_range;
+        private static bool NV_point_sprite;
+        private static bool NV_present_video;
+        private static bool NV_primitive_restart;
+        private static bool NV_primitive_shading_rate;
+        private static bool NV_query_resource;
+        private static bool NV_query_resource_tag;
+        private static bool NV_register_combiners;
+        private static bool NV_register_combiners2;
+        private static bool NV_representative_fragment_test;
+        private static bool NV_robustness_video_memory_purge;
+        private static bool NV_sample_locations;
+        private static bool NV_sample_mask_override_coverage;
+        private static bool NV_scissor_exclusive;
+        private static bool NV_shader_atomic_counters;
+        private static bool NV_shader_atomic_float;
+        private static bool NV_shader_atomic_float64;
+        private static bool NV_shader_atomic_fp16_vector;
+        private static bool NV_shader_atomic_int64;
+        private static bool NV_shader_buffer_load;
+        private static bool NV_shader_buffer_store;
+        private static bool NV_shader_storage_buffer_object;
+        private static bool NV_shader_subgroup_partitioned;
+        private static bool NV_shader_texture_footprint;
+        private static bool NV_shader_thread_group;
+        private static bool NV_shader_thread_shuffle;
+        private static bool NV_shading_rate_image;
+        private static bool NV_stereo_view_rendering;
+        private static bool NV_tessellation_program5;
+        private static bool NV_texgen_emboss;
+        private static bool NV_texgen_reflection;
+        private static bool NV_texture_barrier;
+        private static bool NV_texture_compression_vtc;
+        private static bool NV_texture_env_combine4;
+        private static bool NV_texture_expand_normal;
+        private static bool NV_texture_multisample;
+        private static bool NV_texture_rectangle;
+        private static bool NV_texture_rectangle_compressed;
+        private static bool NV_texture_shader;
+        private static bool NV_texture_shader2;
+        private static bool NV_texture_shader3;
+        private static bool NV_timeline_semaphore;
+        private static bool NV_transform_feedback;
+        private static bool NV_transform_feedback2;
+        private static bool NV_uniform_buffer_std430_layout;
+        private static bool NV_uniform_buffer_unified_memory;
+        private static bool NV_vdpau_interop;
+        private static bool NV_vdpau_interop2;
+        private static bool NV_vertex_array_range;
+        private static bool NV_vertex_array_range2;
+        private static bool NV_vertex_attrib_integer_64bit;
+        private static bool NV_vertex_buffer_unified_memory;
+        private static bool NV_vertex_program;
+        private static bool NV_vertex_program1_1;
+        private static bool NV_vertex_program2;
+        private static bool NV_vertex_program2_option;
+        private static bool NV_vertex_program3;
+        private static bool NV_vertex_program4;
+        private static bool NV_video_capture;
+        private static bool NV_viewport_array2;
+        private static bool NV_viewport_swizzle;
+        private static bool NVX_blend_equation_advanced_multi_draw_buffers;
+        private static bool NVX_conditional_render;
+        private static bool NVX_gpu_memory_info;
+        private static bool NVX_gpu_multicast2;
+        private static bool NVX_linked_gpu_multicast;
+        private static bool NVX_progress_fence;
+        private static bool OES_byte_coordinates;
+        private static bool OES_compressed_paletted_texture;
+        private static bool OES_fixed_point;
+        private static bool OES_query_matrix;
+        private static bool OES_read_format;
+        private static bool OES_single_precision;
+        private static bool OML_interlace;
+        private static bool OML_resample;
+        private static bool OML_subsample;
+        private static bool OVR_multiview;
+        private static bool OVR_multiview2;
+        private static bool PGI_misc_hints;
+        private static bool PGI_vertex_hints;
+        private static bool REND_screen_coordinates;
+        private static bool S3_s3tc;
+        private static bool SGI_color_matrix;
+        private static bool SGI_color_table;
+        private static bool SGI_texture_color_table;
+        private static bool SGIS_detail_texture;
+        private static bool SGIS_fog_function;
+        private static bool SGIS_generate_mipmap;
+        private static bool SGIS_multisample;
+        private static bool SGIS_pixel_texture;
+        private static bool SGIS_point_line_texgen;
+        private static bool SGIS_point_parameters;
+        private static bool SGIS_sharpen_texture;
+        private static bool SGIS_texture_border_clamp;
+        private static bool SGIS_texture_color_mask;
+        private static bool SGIS_texture_edge_clamp;
+        private static bool SGIS_texture_filter4;
+        private static bool SGIS_texture_lod;
+        private static bool SGIS_texture_select;
+        private static bool SGIS_texture4D;
+        private static bool SGIX_async;
+        private static bool SGIX_async_histogram;
+        private static bool SGIX_async_pixel;
+        private static bool SGIX_blend_alpha_minmax;
+        private static bool SGIX_calligraphic_fragment;
+        private static bool SGIX_clipmap;
+        private static bool SGIX_convolution_accuracy;
+        private static bool SGIX_depth_pass_instrument;
+        private static bool SGIX_depth_texture;
+        private static bool SGIX_flush_raster;
+        private static bool SGIX_fog_offset;
+        private static bool SGIX_fragment_lighting;
+        private static bool SGIX_framezoom;
+        private static bool SGIX_igloo_interface;
+        private static bool SGIX_instruments;
+        private static bool SGIX_interlace;
+        private static bool SGIX_ir_instrument1;
+        private static bool SGIX_list_priority;
+        private static bool SGIX_pixel_texture;
+        private static bool SGIX_pixel_tiles;
+        private static bool SGIX_polynomial_ffd;
+        private static bool SGIX_reference_plane;
+        private static bool SGIX_resample;
+        private static bool SGIX_scalebias_hint;
+        private static bool SGIX_shadow;
+        private static bool SGIX_shadow_ambient;
+        private static bool SGIX_sprite;
+        private static bool SGIX_subsample;
+        private static bool SGIX_tag_sample_buffer;
+        private static bool SGIX_texture_add_env;
+        private static bool SGIX_texture_coordinate_clamp;
+        private static bool SGIX_texture_lod_bias;
+        private static bool SGIX_texture_multi_buffer;
+        private static bool SGIX_texture_scale_bias;
+        private static bool SGIX_vertex_preclip;
+        private static bool SGIX_ycrcb;
+        private static bool SGIX_ycrcb_subsample;
+        private static bool SGIX_ycrcba;
+        private static bool SUN_convolution_border_modes;
+        private static bool SUN_global_alpha;
+        private static bool SUN_mesh_array;
+        private static bool SUN_slice_accum;
+        private static bool SUN_triangle_list;
+        private static bool SUN_vertex;
+        private static bool SUNX_constant_data;
+        private static bool WIN_phong_shading;
+        private static bool WIN_specular_fog;
+
+        #endregion
+    }
+}

StgSharp.Common/Graphics/OpenGL/glClampf.cs

@@ -0,0 +1,92 @@
+//-----------------------------------------------------------------------
+//-----------------------------------------------------------------------
+//     file="glClampf.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.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Internal
+{
+    /// <summary>
+    ///   OpenGL numeric type. An IEEE-754 floating-point value, clamped to the range [0,1].
+    /// </summary>
+    [StructLayout( LayoutKind.Sequential )]
+    public struct GLclampf
+    {
+
+        public float value;
+
+        public GLclampf( float a )
+        {
+            value = a;
+        }
+
+        public static explicit operator float( GLclampf v )
+        {
+            return v.value;
+        }
+
+        public static explicit operator GLclampf( float v )
+        {
+            return new GLclampf( v );
+        }
+
+    }
+
+    /// <summary>
+    ///   OpenGL numeric type. An IEEE-754 double precision floating-point value, clamped to the
+    ///   range [0,1].
+    /// </summary>
+    [StructLayout( LayoutKind.Sequential )]
+    public struct GLclampd
+    {
+
+        public double value;
+
+        public GLclampd( double a )
+        {
+            value = a;
+        }
+
+        public static explicit operator double( GLclampd v )
+        {
+            return v.value;
+        }
+
+        public static explicit operator GLclampd( double v )
+        {
+            return new GLclampd( v );
+        }
+
+    }
+}