merge main branch

StgSharp.Common/Collections/BidirectionalDictionary.cs

@@ -0,0 +1,194 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="BidirectionalDictionary"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Linq;
+
+namespace StgSharp.Collections
+{
+    public sealed class BidirectionalDictionary<TFirst, TSecond> : IBidirectionalDictionary<TFirst, TSecond>
+        where TFirst: notnull
+        where TSecond: notnull
+    {
+
+        private readonly Dictionary<TFirst, TSecond> _forward;
+        private readonly Dictionary<TSecond, TFirst> _reverse;
+
+        public BidirectionalDictionary()
+        {
+            _forward = [];
+            _reverse = [];
+        }
+
+        public TFirst this[TSecond key]
+        {
+            get => _reverse.TryGetValue(key, out TFirst value) ?
+                   value :
+                   throw new ArgumentException($"Cannot find key {key} 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 => _forward.TryGetValue(key, out TSecond value) ?
+                   value :
+                   throw new ArgumentException($"Cannot find key {key} 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,183 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="CapacityFixedList"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Runtime.CompilerServices;
+
+namespace StgSharp.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,84 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="IBidrirectionalDictionary"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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;
+
+namespace StgSharp.Collections
+{
+    public interface IBidirectionalDictionary<TFirst, TSecond> : IDictionary<TFirst, TSecond>
+    {
+
+        TFirst this[TSecond key] { get; set; }
+
+        ICollection<TFirst> FirstIndex { get; }
+
+        ICollection<TSecond> SecondIndex { get; }
+
+        IReadOnlyDictionary<TFirst, TSecond> Forward { get; }
+
+        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>
+        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>
+        bool Contains(TFirst key);
+
+        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)
+        {
+            return Contains(key);
+        }
+#pragma warning restore CA1033
+    }
+}

StgSharp.Common/Collections/IHashMultiplexer.cs

@@ -0,0 +1,53 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="IHashMultiplexer"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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;
+
+namespace StgSharp.Collections
+{
+    public interface IHashMultiplexer<T> : IEqualityComparer<T>
+    {
+
+        int RemainedMultiplexCount { get; set; }
+
+        /// <summary>
+        ///   Cache hash result for obj with counts.
+        /// </summary>
+        /// <param name="obj">
+        ///
+        /// </param>
+        /// <param name="count">
+        ///
+        /// </param>
+        void CacheHash(T obj, int count);
+
+        void ExtendCache(int count);
+
+        int ForceComputeHash(T count);
+
+    }
+}

StgSharp.Common/Collections/ListSegment.cs

@@ -0,0 +1,131 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="ListSegment"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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/RandomAccessibleStack.cs

@@ -0,0 +1,181 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="RandomAccessibleStack"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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;
+
+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 >= PrimSize ) {
+                    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()
+        {
+            return GetEnumerator();
+        }
+
+    }
+}

StgSharp.Common/Collections/StringHashMultiplexer.cs

@@ -0,0 +1,162 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="StringHashMultiplexer"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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 = NativeIntrinsic.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 = NativeIntrinsic.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,62 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="BattleField"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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 StgSharp.Mathematics.Graphic;
+
+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,149 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="ButtonGroup"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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 StgSharp.Mathematics.Graphic;
+
+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,109 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="CharacterIndexImage"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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 StgSharp.Mathematics.Graphic;
+
+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,56 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="ControllingIntem"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Graphic;
+
+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.Geometries;
+using StgSharp.Graphics;
+using StgSharp.Mathematics.Graphic;
+
+using System;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+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
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            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,83 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="MarkingLable"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics.Graphic;
+using StgSharp.Timing;
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Runtime.CompilerServices;
+using System.Text;
+
+namespace StgSharp.Controls
+{
+    public class MarkingLabel : ControllingItem
+    {
+
+        private PlainGeometryMesh marker;
+
+        private Vec2 _currentPosition, _movementVec;
+
+        public MarkingLabel(PlainGeometryMesh marker)
+        {
+            this.marker = marker;
+        }
+
+        public bool IsEntity => true;
+
+        public ReadOnlySpan<Vec4> TextureBox
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            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)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void MoveTo(Vec2 target)
+        {
+            Move(target - Position);
+        }
+
+    }
+}

StgSharp.Common/Controlling/Controls/TriggerButton.cs

@@ -0,0 +1,213 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="TriggerButton"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics.Graphic;
+
+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,234 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="KeyEnum"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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 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 = FrameworkConstant. JOYSTICK_1,
+        Joystick_2 = FrameworkConstant. JOYSTICK_2,
+        Joystick_3 = FrameworkConstant. JOYSTICK_3,
+        Joystick_4 = FrameworkConstant. JOYSTICK_4,
+        Joystick_5 = FrameworkConstant. JOYSTICK_5,
+        Joystick_6 = FrameworkConstant. JOYSTICK_6,
+        Joystick_7 = FrameworkConstant. JOYSTICK_7,
+        Joystick_8 = FrameworkConstant. JOYSTICK_8,
+        Joystick_9 = FrameworkConstant. JOYSTICK_9,
+        Joystick_10 = FrameworkConstant.JOYSTICK_10,
+        Joystick_11 = FrameworkConstant.JOYSTICK_11,
+        Joystick_12 = FrameworkConstant.JOYSTICK_12,
+        Joystick_13 = FrameworkConstant.JOYSTICK_13,
+        Joystick_14 = FrameworkConstant.JOYSTICK_14,
+        Joystick_15 = FrameworkConstant.JOYSTICK_15,
+        Joystick_16 = FrameworkConstant.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,66 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="KeyEventAttribute"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,42 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="IClickTrigger"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,86 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="JoystickTrigger"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,82 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="KeyTrigger"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,69 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="MouseTrigger"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,88 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="TriggetFactory"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,111 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Counter"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,39 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="root"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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 { }//------------------ end of class ---------------------
+}

StgSharp.Common/Data/RandomGenerator.cs

@@ -0,0 +1,144 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="RandomGenerator"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,44 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Area"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,77 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="DataHead"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,186 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="DataSegment"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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] = Scalar.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,64 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="SSD"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,77 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="SSDVirtualFolder"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,68 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="SSDraw"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,38 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Define"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,103 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="ISSDSerializable"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,91 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="ValueBox"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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/Environment/Dialogue.cs

@@ -0,0 +1,177 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Dialogue"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,44 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="ErrorDefine"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,110 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="GlobalSetting"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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;
+
+        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;
+            internal set => _mainThreadID = value;
+        }
+
+        private static int _mainThreadID { get; set; } = -1;
+
+        /// <summary>
+        ///   CustomizeInit an instance of OpenGL program, This method should be called before any
+        ///   other World api.
+        /// </summary>
+        public static void InitGL(int majorVersion, int minorVersion)
+        {
+            if (API == default) {
+                API = GraphicAPI.GL;
+            }
+            if (API != GraphicAPI.GL) {
+                return;
+            }
+            GraphicFramework.InternalInitGL(majorVersion, minorVersion);
+        }
+
+        public static class GlobalSetting
+        {
+
+            private static bool vSyncActivated;
+
+            public static bool VSyncActivated
+            {
+                get => vsyncActivated;
+                set
+                {
+                    GraphicFramework.glfwSwapInterval(value ? 1 : 0);
+                    vsyncActivated = value;
+                }
+            }
+
+        }
+
+    }//-------------------------------------- End of Class ---------------------------------------//
+}

StgSharp.Common/Environment/Monitors.cs

@@ -0,0 +1,57 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Monitors"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.InteropServices;
+
+namespace StgSharp
+{
+    public static partial class World
+    {
+
+        public static unsafe IntPtr[] MonitorsHandleArray
+        {
+            get
+            {
+                if (MonitorsArray == null)
+                {
+                    int count = 0;
+                    IntPtr* arrayHandle = GraphicFramework.glfwGetMonitors(&count);
+                    MonitorsArray = new IntPtr[count];
+                    Marshal.Copy((IntPtr)arrayHandle, MonitorsArray, 0, count);
+                    Marshal.FreeHGlobal((IntPtr)arrayHandle);
+                }
+                return MonitorsArray;
+            }
+        }
+
+        public static nint[] MonitorsArray { get; set; } = [];
+
+        public static IntPtr DefaultMonitor => MonitorsHandleArray[0];
+
+    }
+}

StgSharp.Common/Environment/Platform.cs

@@ -0,0 +1,223 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Platform"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.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 int DefaultSIMDAlignment => NativeIntrinsic.IntrinsicLevel switch
+        {
+            IntrinsicLevel.SSE => 16,
+            IntrinsicLevel.AVX2 => 32,
+            IntrinsicLevel.AVX512 => 64,
+            IntrinsicLevel.NEON => 16,
+            IntrinsicLevel.Non => 8,
+            _ => 8,
+        };
+
+        public static ModuleToInitializeCollection Initialize()
+        {
+            return new ModuleToInitializeCollection(new Initializer());
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void LogError(Exception ex)
+        {
+            DefaultLog.InternalWriteLog(ex.Message, LogType.Error);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void LogInfo(string log)
+        {
+            DefaultLog.InternalWriteLog(log, LogType.Info);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void LogWarning(string log)
+        {
+            DefaultLog.InternalWriteLog(log, LogType.Warning);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void LogWarning(Exception notVerySeriesException)
+        {
+            DefaultLog.InternalWriteLog(notVerySeriesException.Message, LogType.Warning);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static void Mark(bool needConsole)
+        {
+            markCount++;
+            if (needConsole) {
+                Console.WriteLine(markCount);
+            }
+        }
+
+        public static void Terminate(int exitCode)
+        {
+            MainTimeProvider.StopProvidingTime();
+            GraphicFramework.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
+            {
+                DefaultLog.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)
+        {
+            DefaultLog.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;
+            }
+        }
+
+        internal static unsafe void InternalInitialize()
+        {
+            // Initialize time provider and start providing time
+            MainTimeProvider.StartProvidingTime();
+            GraphicFramework.LoadGlfw();
+            if (GraphicFramework.glfwInit() == 0) {
+                throw new Exception("Failed to init system graphic environment.");
+            }
+            DefaultLog.InternalAppendLog("\n\n\n");
+            DefaultLog.InternalWriteLog(
+                $"Program {Assembly.GetEntryAssembly()!.FullName} on {Environment.MachineName} Started.", LogType.Info);
+            MainThreadID = System.Environment.CurrentManagedThreadId;
+
+
+            Dialogue.LoadDialogue();
+            if (Dialogue.NeedShowWhenStartup) {
+                Dialogue.CreateDialogueProcessIfNotExist();
+            }
+
+            NativeIntrinsic.InitIntrinsicContext();
+        }
+
+        internal class Initializer : IStaticModule
+        {
+
+            public string ModuleName => "StgSharp";
+
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            public void InitializeModule()
+            {
+                World.InternalInitialize();
+            }
+
+        }
+
+    }
+}

StgSharp.Common/Environment/globalKeyStat.cs

@@ -0,0 +1,49 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="globalKeyStat"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,78 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="CoordinationBase"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Graphic;
+
+using System.Runtime.CompilerServices;
+
+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.column[3].XYZ);
+            internal set => coordMat.column[3].XYZ = value.Coord;
+        }
+
+        public virtual Vec3 LocalX
+        {
+            get => coordMat.column[3].XYZ;
+            internal set => coordMat.column[3].XYZ = value;
+        }
+
+        public virtual Vec3 LocalY
+        {
+            get => coordMat.column[3].XYZ;
+            internal set => coordMat.column[3].XYZ = value;
+        }
+
+        public virtual Vec3 LocalZ
+        {
+            get => coordMat.column[3].XYZ;
+            set => coordMat.column[3].XYZ = value;
+        }
+
+        protected ref Matrix44 CoordMat
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => ref coordMat;
+        }
+
+    }
+}

StgSharp.Common/Geometries/Coordination/PlainCoordinate.cs

@@ -0,0 +1,57 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="PlainCoordinate"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics.Graphic;
+
+using System;
+using System.Collections.Generic;
+using System.Net.Http.Headers;
+using System.Text;
+
+namespace StgSharp.Geometries
+{
+    public class PlainCoordinate : CoordinationBase
+    {
+
+        public PlainCoordinate(CoordinationBase local, Point origin, Vec3 xAxis, Vec3 yAxis)
+            : base(local)
+        {
+            CoordMat = Matrix44.Unit;
+
+            CoordMat.column[0] = new Vec4(xAxis, 0);
+            CoordMat.column[1] = new Vec4(yAxis, 0);
+            CoordMat.column[2] = new Vec4(Linear.Normalize(Vec3.Cross(xAxis, yAxis)), 0);
+
+            LocalOrigin = origin;
+        }
+
+        public static PlainCoordinate StandardPlainCoordination { get; } = new(null, new Point(0, 0, 0),
+                                                                               new Vec3(1, 0, 0), new Vec3(0, 1, 0));
+
+    }
+}

StgSharp.Common/Geometries/Coordination/SpaceCoordinate.cs

@@ -0,0 +1,44 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="SpaceCoordinate"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics.Graphic;
+
+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,43 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="StreamLocalCoordinate"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,61 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="GemoryException"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,113 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="GeometryOperation"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Graphic;
+using StgSharp.Timing;
+
+using System;
+using System.Runtime.InteropServices;
+
+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,175 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Angle"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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 / Scalar.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) / Scalar.Pi);
+        }
+
+    }
+}

StgSharp.Common/Geometries/IGeometry.cs

@@ -0,0 +1,57 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="IGeometry"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics.Graphic;
+
+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,37 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="IGeomtryBuffer"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,73 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="IInstancing"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics.Graphic;
+
+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,53 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="IInstancingBuffer"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics.Graphic;
+
+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,78 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Cordinate"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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();
+            Unsafe.SkipInit( out axis.mat );
+            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,45 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="GeometryOperation"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics.Graphic;
+
+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,70 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="IPlainEntity"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics.Graphic;
+
+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,74 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="ParticleOnPlain"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics.Graphic;
+
+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,67 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="PlainGeometry"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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 StgSharp.Mathematics.Graphic;
+
+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,187 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="PlainInstancingBuffer"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics.Graphic;
+using StgSharp.Mathematics.Numeric;
+
+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.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+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 globalCoordinate;
+        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
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => instanceList;
+        }
+
+        public List<Vec4> CoordAndRotationList
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => coordList;
+        }
+
+        public List<float> ScalingList
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => scalingList;
+        }
+
+        public Span<Vec4> CoordAndRotationSpan
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => CollectionsMarshal.AsSpan(coordList);
+        }
+
+        public Span<float> ScalingSpan
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => CollectionsMarshal.AsSpan(scalingList);
+        }
+
+        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[^1];
+            instanceList[instance.BufferId] = temp;
+            temp.BufferId = instance.BufferId;
+
+            coordList[instance.BufferId] = coordList[^1];
+            scalingList[instance.BufferId] = scalingList[^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,78 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Parallelogram"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics.Graphic;
+
+using System;
+
+namespace StgSharp.Geometries
+{
+    public class Parallelogram : Polygon4
+    {
+
+        internal readonly Func<int, Vec3> movCenterOperation = 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)
+            {
+                DefaultLog.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)
+            {
+                DefaultLog.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,86 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Plain"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics.Graphic;
+
+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,121 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Polygon4"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics.Graphic;
+
+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,103 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Polygon5"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics.Graphic;
+
+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,84 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Polygon6"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics.Graphic;
+
+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,87 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Rectangle"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics.Graphic;
+
+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,47 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Square"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,87 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Triangle"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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 StgSharp.Mathematics.Graphic;
+
+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,70 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Point"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics.Graphic;
+
+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/Class1.cs

@@ -0,0 +1,35 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Class1"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Geometries.SpaceGeometry
+{
+    internal class Class1 { }
+}

StgSharp.Common/Geometries/SpaceGeometry/TriangulatedSurface.cs

@@ -0,0 +1,146 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="TriangulatedSurface"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Graphic;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.CompilerServices;
+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
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            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
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => CollectionsMarshal.AsSpan(_vertices);
+        }
+
+        public Span<int> TriangleIndicesSpan
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            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(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,96 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Global"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+global using StgSharp.Internal;
+global using StgSharp.Internal.Intrinsic;
+global 
+
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+[assembly: InternalsVisibleTo("StgSharp.Mathematics")]
+
+[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,40 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="IImageProvider"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,83 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="ImageHelper"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,86 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="BufferObjectBase"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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 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/IGraphicAPIs.cs

@@ -0,0 +1,40 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="IGraphicAPIs"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace StgSharp.Graphics
+{
+    public interface IGraphicAPIs
+    {
+
+        public IntPtr GraphicApiPackageHandle { get; }
+
+    }
+}

StgSharp.Common/Graphics/Image.cs

@@ -0,0 +1,191 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Image"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Runtime.CompilerServices;
+
+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 = [];
+
+            // int length = _rawInfo.width * _rawInfo.height * _rawInfo.channel;
+        }
+
+        public (int width, int height) Size
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            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 => 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) {
+                GraphicFramework.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) {
+                    GraphicFramework.InternalUnloadImage(pptr);
+                }
+                _rawInfo.StreamPtr = IntPtr.Zero;
+            }
+            return _data;
+        }
+
+        public Image ProvideImage()
+        {
+            return 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();
+        }
+
+    }
+}

StgSharp.Common/Graphics/ImageInfo.cs

@@ -0,0 +1,162 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="ImageInfo"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+
+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,160 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="AutoTexture"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using StgSharp.Collections;
+using StgSharp.Graphics;
+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,81 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="EBO"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.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,104 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="FBO"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.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,50 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="GLBufferObjectBase"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,67 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="RBO"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.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,279 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="TextureGL"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.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,77 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="VAO"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.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 sealed override 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 sealed override void Dispose(bool disposing)
+        {
+            if (disposing) {
+                GL.DeleteVertexArrays(_bufferHandle);
+            }
+        }
+
+    }
+}

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

@@ -0,0 +1,183 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="VBO"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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 StgSharp.Mathematics.Numeric;
+
+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, ref IMatrix<T> bufferData, BufferUsage usage)
+            where T: unmanaged, INumber<T>
+        {
+            GL.BindBuffer(BufferType.ArrayBuffer, _bufferHandle[index]);
+            GL.SetBufferData(BufferType.ArrayBuffer, bufferData.AsSpan(), 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, IUnmanagedVector<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, IUnmanagedVector<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/ShaderEdit/IglConvertable.cs

@@ -0,0 +1,65 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="IglConvertable"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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,283 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Shader"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Graphics;
+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 sealed override ShaderProgram CreateShaderProgram()
+        {
+            return new ShaderProgram(this);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected sealed override 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 (GraphicFramework.InternalLinkShaderProgram(
+                (OpenglContext*)this.GL.ContextHandle, handle.Value) == 0)
+            {
+                IntPtr logPtr = GraphicFramework.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);
+                    DefaultLog.InternalWriteLog(log, LogType.Error);
+                }
+                catch (Exception ex)
+                {
+                    DefaultLog.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,184 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Uniform"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Graphic;
+using System.Diagnostics.CodeAnalysis;
+using System.Runtime.CompilerServices;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public class Uniform
+    {
+
+        internal GlHandle id;
+
+        public GlHandle Handle => 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/glEnum.cs

@@ -0,0 +1,224 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="glEnum"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Runtime.CompilerServices;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public enum PixelChannelLayout
+    {
+
+        UByte = glConst.UNSIGNED_BYTE,
+        Byte = glConst.BYTE,
+        UShort = glConst.UNSIGNED_SHORT,
+        Short = glConst.SHORT,
+        UInt = glConst.UNSIGNED_INT,
+        Int = glConst.INT,
+        Float = glConst.FLOAT,
+        UByte332 = glConst.UNSIGNED_BYTE_3_3_2,
+        UByte233Rev = glConst.UNSIGNED_BYTE_2_3_3_REV,
+        UShort565 = glConst.UNSIGNED_SHORT_5_6_5,
+        UShort565Rev = glConst.UNSIGNED_SHORT_5_6_5_REV,
+        UShort4444 = glConst.UNSIGNED_SHORT_4_4_4_4,
+        UShort4444Rev = glConst.UNSIGNED_SHORT_4_4_4_4_REV,
+        UShort5551 = glConst.UNSIGNED_SHORT_5_5_5_1,
+        UShort1555Rev = glConst.UNSIGNED_SHORT_1_5_5_5_REV,
+        UInt8888 = glConst.UNSIGNED_INT_8_8_8_8,
+        UInt8888Rev = glConst.UNSIGNED_INT_8_8_8_8_REV,
+        UInt1010102 = glConst.UNSIGNED_INT_10_10_10_2,
+        UInt2101010Rev = glConst.UNSIGNED_INT_2_10_10_10_REV
+
+    }
+
+    public enum FaceMode
+    {
+
+        Point = glConst.POINT,
+        Line = glConst.LINE,
+        Fill = glConst.FILL
+
+    }
+
+    public enum FrameBufferStatus
+    {
+
+        Complete = glConst.FRAMEBUFFER_COMPLETE, // GL_FRAMEBUFFER_COMPLETE
+        IncompleteAttachment = glConst.FRAMEBUFFER_INCOMPLETE_ATTACHMENT, // GL_FRAMEBUFFER_INCOMPLETE_ATTACHMENT
+        IncompleteMissingAttachment = glConst.FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT, // GL_FRAMEBUFFER_INCOMPLETE_MISSING_ATTACHMENT
+        IncompleteDrawBuffer = glConst.FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER, // GL_FRAMEBUFFER_INCOMPLETE_DRAW_BUFFER
+        IncompleteReadBuffer = glConst.FRAMEBUFFER_INCOMPLETE_READ_BUFFER, // GL_FRAMEBUFFER_INCOMPLETE_READ_BUFFER
+        Unsupported = glConst.FRAMEBUFFER_UNSUPPORTED, // GL_FRAMEBUFFER_UNSUPPORTED
+        IncompleteMultiSample = glConst.FRAMEBUFFER_INCOMPLETE_MULTISAMPLE, // GL_FRAMEBUFFER_INCOMPLETE_MULTISAMPLE
+        IncompleteLayerTargets = glConst.FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS // GL_FRAMEBUFFER_INCOMPLETE_LAYER_TARGETS
+
+    }
+
+    public enum FrameBufferChannel
+    {
+
+        STENCIL_INDEX = glConst.STENCIL_INDEX,
+        DEPTH_COMPONENT = glConst.DEPTH_COMPONENT,
+        DEPTH_STENCIL = glConst.DEPTH_STENCIL,
+        RED = glConst.RED,
+        GREEN = glConst.GREEN,
+        BLUE = glConst.BLUE,
+        RGB = glConst.RGB,
+        BGR = glConst.BGR,
+        RGBA = glConst.RGBA,
+        BGRA = glConst.BGRA
+
+    }
+
+    public enum FrameBufferAttachment
+    {
+
+        Color = glConst.COLOR_ATTACHMENT0,
+        Depth = glConst.DEPTH_ATTACHMENT,
+        Stencil = glConst.STENCIL_ATTACHMENT,
+        DepthAndStencil = glConst.DEPTH_STENCIL_ATTACHMENT,
+
+    }
+
+    public enum Texture2DTarget
+    {
+
+        Texture2D = glConst.TEXTURE_2D,
+        ProxyTexture2D = glConst.PROXY_TEXTURE_2D,
+        Texture1DArray = glConst.TEXTURE_1D_ARRAY,
+        ProxyTexture1DArray = glConst.PROXY_TEXTURE_1D_ARRAY,
+        TextureRectangle = glConst.TEXTURE_RECTANGLE,
+        ProxyTextureRectangle = glConst.PROXY_TEXTURE_RECTANGLE,
+        TextureCubeMapPositiveX = glConst.TEXTURE_CUBE_MAP_POSITIVE_X,
+        TextureCubeMapNegativeX = glConst.TEXTURE_CUBE_MAP_NEGATIVE_X,
+        TextureCubeMapPositiveY = glConst.TEXTURE_CUBE_MAP_POSITIVE_Y,
+        TextureCubeMapNegativeY = glConst.TEXTURE_CUBE_MAP_NEGATIVE_Y,
+        TextureCubeMapPositiveZ = glConst.TEXTURE_CUBE_MAP_POSITIVE_Z,
+        TextureCubeMapNegativeZ = glConst.TEXTURE_CUBE_MAP_NEGATIVE_Z,
+        ProxyTextureCubeMap = glConst.PROXY_TEXTURE_CUBE_MAP
+
+    }
+
+    public enum RenderBufferInternalFormat : uint
+    {
+
+        RGBA8 = glConst.RGBA8,
+        Depth24_Stencil8 = glConst.DEPTH24_STENCIL8,
+
+    }
+
+    public enum glOperation : uint
+    {
+
+        StencilTest = glConst.STENCIL_TEST,
+        DepthTest = glConst.DEPTH_TEST,
+        PolygonOffsetFill = glConst.POLYGON_OFFSET_FILL,
+        PolygonOffsetLine = glConst.POLYGON_OFFSET_LINE,
+        PolygonOffsetPoint = glConst.POLYGON_OFFSET_POINT,
+
+    }
+
+    #pragma warning disable CA1008
+    public enum ShaderType : int
+    #pragma warning restore CA1008
+    {
+
+        Fragment = glConst.FRAGMENT_SHADER,
+        Vertex = glConst.VERTEX_SHADER,
+        Compute = glConst.COMPUTE_SHADER,
+        Geometry = glConst.GEOMETRY_SHADER,
+
+    }
+
+    #pragma warning disable CA1008
+    public enum BufferType : int
+    #pragma warning restore CA1008
+    {
+
+        ArrayBuffer = glConst.ARRAY_BUFFER,
+        ElementArrayBuffer = glConst.ELEMENT_ARRAY_BUFFER,
+        AtomicCounterBuffer = glConst.ATOMIC_COUNTER_BUFFER,
+        CopyHeadBuffer = glConst.COPY_READ_BUFFER,
+        COPY_WRITE_BUFFER = glConst.COPY_WRITE_BUFFER,
+        DISPATCH_INDIRECT_BUFFER = glConst.DISPATCH_INDIRECT_BUFFER,
+        DRAW_INDIRECT_BUFFER = glConst.DRAW_INDIRECT_BUFFER,
+        PIXEL_PACK_BUFFER = glConst.PIXEL_PACK_BUFFER,
+        PIXEL_UNPACK_BUFFER = glConst.PIXEL_UNPACK_BUFFER,
+        QUERY_BUFFER = glConst.QUERY_BUFFER,
+        ShaderStorageBuffer = glConst.SHADER_STORAGE_BUFFER,
+        TEXTURE_BUFFER = glConst.TEXTURE_BUFFER,
+        TRANSFORM_FEEDBACK_BUFFER = glConst.TRANSFORM_FEEDBACK_BUFFER,
+        UNIFORM_BUFFER = glConst.UNIFORM_BUFFER,
+
+    }
+
+    #pragma warning disable CA1008
+    public enum BufferUsage : int
+    #pragma warning restore CA1008
+    {
+
+        StreamDraw = 0x88E0,
+        StreamRead = 0x88E1,
+        StreamCopy = 0x88E2,
+        StaticDraw = 0x88E4,
+        StaticRead = 0x88E5,
+        StaticCopy = 0x88E6,
+        DynamicDraw = 0x88E8,
+        DynamicRead = 0x88E9,
+        DynamicCopy = 0x88EA
+
+    }
+
+    public enum MaskBufferBit
+    {
+
+        COLOR = glConst.COLOR_BUFFER_BIT,
+        DEPTH = glConst.DEPTH_BUFFER_BIT,
+        STENCIL = glConst.STENCIL_BUFFER_BIT,
+
+    }
+
+    public enum GeometryType : uint
+    {
+
+        POINTS = 0x0000,
+        LINES = 0x0001,
+        LINE_LOOP = 0x0002,
+        LINE_STRIP = 0x0003,
+        TRIANGLES = 0x0004,
+        TRIANGLE_STRIP = 0x0005,
+        TRIANGLE_FAN = 0x0006
+
+    }
+
+    public enum TextureFiltering
+    {
+
+        Nearest = 0x2600,
+        Linear = 0x2601
+
+    }
+}

StgSharp.Common/Graphics/OpenGL/glException.cs

@@ -0,0 +1,98 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="glException"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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;
+using System.IO;
+using System.Runtime.CompilerServices;
+using System.Runtime.Serialization;
+using System.Text;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public sealed class GlErrorOverflowException : Exception
+    {
+
+        public GlErrorOverflowException(int errorCount, uint errorCode)
+            : base(
+            "Too many opengl error detected at certain position. " + $"The amount of errors exceeds {errorCount}. " + $"Code of the last error is {errorCode}") { }
+
+    }
+
+    public sealed class GlExecutionException : Exception
+    {
+
+        public GlExecutionException(uint errorCode) : base($"Critical OpenGL error: {errorCode}") { }
+
+    }
+
+    public sealed class GlArrayFormatException : Exception
+    {
+
+        internal GlArrayFormatException(string message) : base(message) { }
+
+        internal GlArrayFormatException(SerializationInfo info, StreamingContext context) : base(info, context) { }
+
+        internal GlArrayFormatException(string message, Exception innerException) : base(message, innerException) { }
+
+        public GlArrayFormatException(PixelChannelLayout layout, string arrayname)
+            : base($"{arrayname} cannot be used as layout of {layout}") { }
+
+    }
+
+    public static partial class GlHelper
+    {
+
+        public static bool CheckArrayFormat(this Array array, PixelChannelLayout layout)
+        {
+            return layout switch
+            {
+                PixelChannelLayout.Byte or PixelChannelLayout.UByte332 or PixelChannelLayout.UByte233Rev => (array is byte[]) ||
+                                                                                                            (array is sbyte[]),
+                PixelChannelLayout.Short => array is short[],
+                PixelChannelLayout.UShort => array is ushort[],
+                PixelChannelLayout.Int => array is int[],
+                PixelChannelLayout.Float => array is float[],
+                PixelChannelLayout.UShort4444 => (array is ushort[]) || (array is byte[]),
+                PixelChannelLayout.UByte => (array is byte[]) || (array is sbyte[]),
+                PixelChannelLayout.UInt => array is uint[],
+                PixelChannelLayout.UShort565 or
+                PixelChannelLayout.UShort565Rev or
+                PixelChannelLayout.UShort4444Rev or
+                PixelChannelLayout.UShort5551 or
+                PixelChannelLayout.UShort1555Rev => array is ushort[],
+                PixelChannelLayout.UInt8888Rev or
+                PixelChannelLayout.UInt1010102 or
+                PixelChannelLayout.UInt2101010Rev => array is int[],
+                PixelChannelLayout.UInt8888 => array is uint[] or byte[],
+                _ => false,
+            };
+        }
+
+    }
+}

StgSharp.Common/Graphics/OpenGL/glFucntionSourceManager.cs

@@ -0,0 +1,92 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="glFucntionSourceManager"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. All rights reserved.
+//     
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+//     
+// -----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+using StgSharp;
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Runtime.CompilerServices;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public partial class OpenGLFunction
+    {
+
+        private readonly int textureUnitCountGetter;
+
+        public int TextureUnitCount
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => textureUnitCountGetter;
+        }
+
+        private ConcurrentQueue<TextureUnit> UnusedTextureImageUint
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get;
+        } = [];
+
+        internal void ReturnAvailableUnit(IEnumerable<TextureUnit> source)
+        {
+            int v = glConst.TEXTURE0 + TextureUnitCount;
+            foreach (TextureUnit unit in source)
+            {
+                if ((int)unit > v) {
+                    throw new InvalidOperationException(
+                        "Source contains texture unit beyond context support.");
+                }
+            }
+        }
+
+        internal int TryGetAvailableTextureUnit(int count, out IEnumerable<TextureUnit> result)
+        {
+            result = new Queue<TextureUnit>();
+            for (int i = 0; i < count; i++)
+            {
+                if (UnusedTextureImageUint.TryDequeue(out TextureUnit unit))
+                {
+                    (result as Queue<TextureUnit>)!.Enqueue(unit);
+                } else
+                {
+                    return i;
+                }
+            }
+            return count;
+        }
+
+        private ConcurrentQueue<TextureUnit> InitializeUnusedTextureImageUint()
+        {
+            ConcurrentQueue<TextureUnit> result = new ConcurrentQueue<TextureUnit>();
+            for (int index = 0; index < TextureUnitCount; index++) {
+                result.Enqueue((TextureUnit)(glConst.TEXTURE0 + index));
+            }
+            return result;
+        }
+
+    }
+}

StgSharp.Common/Graphics/OpenGL/glFunction.cs

@@ -0,0 +1,761 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="glFunction"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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;
+using StgSharp.Internal;
+using StgSharp.Mathematics;
+using StgSharp.Mathematics.Numeric;
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Numerics;
+using System.Runtime.CompilerServices;
+using System.Runtime.ExceptionServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public unsafe partial class OpenGLFunction
+    {
+
+        private static readonly Dictionary<IntPtr, OpenGLFunction> contextToGLMap = [];
+        private static readonly ThreadLocal<OpenGLFunction> _currentGL = new ThreadLocal<OpenGLFunction>();
+        private OpenglContext* _context;
+
+        private Lazy<int> _attachmentColorRange;
+
+        private OpenGLFunction()
+        {
+            textureUnitCountGetter = glConst.MAX_TEXTURE_IMAGE_UNITS;
+            UnusedTextureImageUint = [];
+            _attachmentColorRange = new Lazy<int>(
+                () => { return GetMaskInteger((uint)glConst.MAX_COLOR_ATTACHMENTS); });
+        }
+
+        public int AttachmentColorRange
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => _attachmentColorRange.Value;
+        }
+
+        public static OpenGLFunction CurrentGL
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => _currentGL.Value!;
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            internal set => _currentGL.Value = value;
+        }
+
+        internal IntPtr ContextHandle => (IntPtr)_context;
+
+        protected ref OpenglContext Context
+        {
+            get
+            {
+                #if DEBUG
+                if ((IntPtr)_context == IntPtr.Zero)
+                {
+                    throw new NullReferenceException();
+                }
+                #endif
+                return ref (*_context);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ActiveTextureUnit(uint type)
+        {
+            Context.glActiveTexture(type);
+        }
+
+        [Conditional("DEBUG")]
+        public void Assert(bool shouldReportWhenNormal)
+        {
+            uint code = Context.glGetError();
+            if (code != glConst.NO_ERROR) {
+                throw new GlExecutionException(code);
+            }
+            if (shouldReportWhenNormal) {
+                Console.WriteLine("OpenGL runs normally");
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void AttachShader(GlHandle program, GlHandle shader)
+        {
+            Context.glAttachShader(program.Value, shader.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BindBuffer(BufferType bufferType, GlHandle handle)
+        {
+            Context.glBindBuffer((uint)bufferType, handle.Value);
+        }
+
+        /// <summary>
+        ///   Bind a frame BufferHandle to a frame BufferHandle target Same function as <see ///  
+        ///   href="https://docs._gl/gl3/glBindFramebuffer">glBindFramebuffer</see>.
+        /// </summary>
+        /// <param _label="target">
+        ///   The frame BufferHandle target of the binding operation.
+        /// </param>
+        /// <param _label="handle">
+        ///   The handle of the frame BufferHandle object to bind.
+        /// </param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BindFrameBuffer(FrameBufferTarget target, GlHandle handle)
+        {
+            Context.glBindFramebuffer((uint)target, handle.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BindRenderBuffer(GlHandle handle)
+        {
+            Context.glBindRenderbuffer(glConst.RENDERBUFFER, handle.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BindTexture(uint type, GlHandle texture)
+        {
+            Context.glBindTexture(type, texture.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void BindVertexArray(GlHandle handle)
+        {
+            Context.glBindVertexArray(handle.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public FrameBufferStatus CheckFrameBufferStatus(FrameBufferTarget target)
+        {
+            return (FrameBufferStatus)Context.glCheckFramebufferStatus((uint)target);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Clear(MaskBufferBit mask)
+        {
+            Context.glClear((uint)mask);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void ClearColor(float R, float G, float B, float A)
+        {
+            Context.glClearColor(R, G, B, A);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ClearError()
+        {
+            uint code = 0;
+            for (int i = 0; i < 1024; i++)
+            {
+                code = Context.glGetError();
+                if (code == 0) {
+                    return;
+                }
+
+                // Console.WriteLine(code);
+            }
+            foreach (ProcessThread thread in Process.GetCurrentProcess().Threads) {
+                Debugger.Break();
+            }
+            throw new GlErrorOverflowException(1024, code);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void ClearGraphicError()
+        {
+            while (Context.glGetError() != 0) { }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CombineFrameBufferRenderBuffer(FrameBufferAttachment attachment, GlHandle rboHandle)
+        {
+            Context.glFramebufferRenderbuffer(glConst.FRAMEBUFFER, (uint)attachment, glConst.RENDERBUFFER,
+                                              rboHandle.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void CompileShader(GlHandle shaderhandle)
+        {
+            Context.glCompileShader(shaderhandle.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe GlHandle CreateGraphicProgram()
+        {
+            return GlHandle.Create(Context.glCreateProgram());
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public GlHandle CreateProgram()
+        {
+            return GlHandle.Create(Context.glCreateProgram());
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe GlHandle[] CreateProgram(int count)
+        {
+            GlHandle[] h = new GlHandle[count];
+            for (int i = 0; i < count; i++) {
+                h.SetValue(i, Context.glCreateProgram());
+            }
+            return h;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public GlHandle[] CreateShaderSet(int count, ShaderType type)
+        {
+            GlHandle[] ret = new GlHandle[count];
+            uint t = (uint)type;
+            for (int i = 0; i < count; i++)
+            {
+                uint id = Context.glCreateShader(t);
+                if (id == 0)
+                {
+                    uint error = Context.glGetError();
+                    throw new InvalidOperationException($"Failed in creating shader: {error}");
+                }
+                ret[i] = GlHandle.Create(id);
+            }
+            return ret;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void DeleteBuffer(GlHandle handle)
+        {
+            Context.glDeleteBuffers(1, (uint*)&handle);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void DeleteBuffers(GlHandle[] handle)
+        {
+            if ((handle == null) || (handle.Length == 0)) {
+                throw new ArgumentNullException(nameof(handle));
+            }
+            fixed (GlHandle* hptr = handle)
+            {
+                uint* iptr = (uint*)hptr;
+                for (int i = 0; i < handle.Length; i++) {
+                    Context.glDeleteBuffers(1, iptr + i);
+                }
+            }
+        }
+
+        /// <summary>
+        ///   Delete a render BufferHandle object Very simlilar function as <see ///  
+        ///   href="https://docs.gl/gl3/glDeleteRenderbuffers">glDeleteRenderbuffers</see>. The only
+        ///   deifference is that this mehtod can only delete one renderbuffer at the same time.
+        /// </summary>
+        /// <param _label="bufferHandle">
+        ///   Handle to BufferHandle to delete.
+        /// </param>
+        public unsafe void DeleteRenderBuffer(GlHandle bufferHandle)
+        {
+            Context.glDeleteRenderbuffers(1, &bufferHandle.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void DeleteVertexArrays(GlHandle[] arrays)
+        {
+            fixed (GlHandle* hptr = arrays)
+            {
+                uint* iptr = (uint*)hptr;
+                for (int i = 0; i < arrays.Length; i++) {
+                    Context.glDeleteVertexArrays(1, iptr + i);
+                }
+            }
+        }
+
+        public void DepthMaskAccess(bool isWrite)
+        {
+            Context.glDepthMask(isWrite);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Disable(glOperation operation)
+        {
+            Context.glDisable((uint)operation);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void DrawArrays(GeometryType mode, int first, uint count)
+        {
+            Context.glDrawArrays((uint)mode, first, count);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void DrawElements(GeometryType mode, uint count, TypeCode type, IntPtr ptr)
+        {
+            uint a;
+            a = type switch
+            {
+                TypeCode.UInt32 => glConst.UNSIGNED_INT,
+                TypeCode.UInt16 => glConst.UNSIGNED_SHORT,
+                TypeCode.Byte => glConst.UNSIGNED_BYTE,
+                _ => throw new ArgumentException(
+                    $"{$"{$"Parameter error in parameter {nameof(type)} method DrawElements. "}"}{$"{$"Only {typeof(uint).Name},{typeof(ushort).Name},{typeof(byte).Name} types are supported."}"}")
+            };
+            Context.glDrawElements((uint)mode, count, a, (void*)ptr);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void DrawElementsInstanced(GeometryType mode, uint count, TypeCode type, IntPtr ptr, uint amount)
+        {
+            uint a;
+            switch (type)
+            {
+                case TypeCode.UInt32:
+                    a = glConst.UNSIGNED_INT;
+                    break;
+
+                case TypeCode.UInt16:
+                    a = glConst.UNSIGNED_SHORT;
+                    break;
+
+                case TypeCode.Byte:
+                    a = glConst.UNSIGNED_BYTE;
+                    break;
+                default:
+                    DefaultLog.InternalWriteLog(
+                        $"{$"Parameter error in parameter {nameof(type)} method DrawElements. "}{$"Only {typeof(uint).Name},{typeof(ushort).Name},{typeof(byte).Name} types are supported."}",
+                        LogType.Error);
+                    return;
+            }
+            Context.glDrawElementsInstanced((uint)mode, count, a, (void*)ptr, amount);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Enable(glOperation operation)
+        {
+            Context.glEnable((uint)operation);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void FrameBufferTexture2d(
+                    FrameBufferTarget target,
+                    uint attachment,
+                    Texture2DTarget texTarget,
+                    GlHandle textureHandle,
+                    int level)
+        {
+            Context.glFramebufferTexture2D((uint)target, attachment, (uint)texTarget, textureHandle.Value, level);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe GlHandle[] GenBuffers(int count)
+        {
+            GlHandle[] h = new GlHandle[count];
+            fixed (GlHandle* hptr = h)
+            {
+                for (int i = 0; i < count; i++) {
+                    Context.glGenBuffers(count, ((uint*)hptr) + i);
+                }
+            }
+            return h;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GenerateMipmap(Texture2DTarget target)
+        {
+            Context.glGenerateMipmap((uint)target);
+        }
+
+        public unsafe GlHandle[] GenFrameBuffers(int count)
+        {
+            GlHandle[] h = new GlHandle[count];
+            fixed (GlHandle* hptr = h) {
+                Context.glGenFramebuffers(1, (uint*)hptr);
+            }
+            return h;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe GlHandle[] GenRenderBuffer(int count)
+        {
+            GlHandle[] h = new GlHandle[count];
+            fixed (GlHandle* hptr = h) {
+                Context.glGenRenderbuffers(count, (uint*)hptr);
+            }
+            return h;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe GlHandle[] GenTextures(int count)
+        {
+            GlHandle[] h = new GlHandle[count];
+            fixed (GlHandle* hptr = h) {
+                Context.glGenTextures(count, (uint*)hptr);
+            }
+            return h;
+        }
+
+        public unsafe GlHandle[] GenVertexArrays(int count)
+        {
+            GlHandle[] h = new GlHandle[count];
+            fixed (GlHandle* hptr = h) {
+                Context.glGenVertexArrays(count, (uint*)hptr);
+            }
+            return h;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public uint GetError()
+        {
+            return Context.glGetError();
+        }
+
+        public unsafe int GetMaskInteger(uint statusCode)
+        {
+            int ret = 0;
+            Context.glGetIntegerv(statusCode, &ret);
+            return ret;
+        }
+
+        public string GetShaderStatus(Shader s, int index, int key)
+        {
+            IntPtr sptr = IntPtr.Zero;
+            if (GraphicFramework.glCheckShaderStatus(ref Context, s.handle[index].Value, key, ref sptr) == 0) {
+                return Marshal.PtrToStringAnsi(sptr);
+            }
+            return string.Empty;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void GetTextureImage<T>(
+                           Texture2DTarget target,
+                           int level,
+                           ImageChannel channel,
+                           PixelChannelLayout channelLayout,
+                           T[] dataStream)
+            where T: unmanaged,INumber<T>
+        {
+            fixed (T* tptr = dataStream) {
+                Context.glGetTexImage((uint)target, level, (uint)channel, (uint)channelLayout, tptr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void GetTextureLevelProperty(uint textureTypeMask, int level, uint propertyMask, out int propertyValue)
+        {
+            fixed (int* iptr = &propertyValue) {
+                Context.glGetTexLevelParameteriv(textureTypeMask, level, propertyMask, iptr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe GlHandle GetUniformLocation(GlHandle program, string name)
+        {
+            byte[] code = Encoding.UTF8.GetBytes(name);
+            fixed (byte* ptr = code)
+            {
+                int ret = Context.glGetUniformLocation(program.Value, ptr);
+                #if DEBUG
+                if ((ret == glConst.INVALID_OPERATION) || (ret == glConst.INVALID_VALUE))
+                {
+                    throw new InvalidOperationException();
+                }
+                if (ret == -1) {
+                    throw new UniformEmptyReferenceException(nameof(program), name);
+                }
+                #endif
+                return GlHandle.CreateSigned(ret);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void LoadShaderSource(GlHandle shaderHandle, byte[] codeStream)
+        {
+            fixed (byte* streamPtr = codeStream) {
+                Context.glShaderSource(shaderHandle.Value, 1, &streamPtr, (void*)0);
+            }
+        }
+
+        public unsafe void LoadShaderSource(GlHandle shaderHandle, ReadOnlySpan<char> codeStream)
+        {
+            fixed (char* streamPtr = codeStream)
+            {
+                byte* bptr = (byte*)streamPtr;
+                Context.glShaderSource(shaderHandle.Value, 1, &bptr, (void*)0);
+            }
+        }
+
+        public unsafe void LoadShaderSource(GlHandle shaderHandle, ReadOnlySpan<byte> codeStream)
+        {
+            fixed (byte* streamPtr = codeStream)
+            {
+                byte* bptr = streamPtr;
+                Context.glShaderSource(shaderHandle.Value, 1, &bptr, (void*)0);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PolygonMode(FaceMode mode)
+        {
+            Context.glPolygonMode(glConst.FRONT_AND_BACK, (uint)mode);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void PolygonOffset(float factor, float unit)
+        {
+            Context.glPolygonOffset(factor, unit);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void ReadPixels(
+                    (int X, int Y) beginPosition,
+                    (int width, int height) size,
+                    FrameBufferChannel format,
+                    PixelChannelLayout dataType,
+                    ref byte[] stream)
+        {
+            fixed (byte* bptr = stream) {
+                Context.glReadPixels(beginPosition.X, beginPosition.Y, size.width, size.height, (uint)format,
+                                     (uint)dataType, bptr);
+            }
+        }
+
+        public void RereadImage(
+                    in Image i,
+                    (int X, int Y) beginPosition,
+                    FrameBufferChannel format,
+                    PixelChannelLayout dataType)
+        {
+            byte[] pixels = i.PixelBuffer;
+            if (!pixels.CheckArrayFormat(dataType)) {
+                throw new GlArrayFormatException(dataType, "i.PixelArray");
+            }
+            fixed (byte* bptr = pixels) {
+                Context.glReadPixels(beginPosition.X, beginPosition.Y, i.Width, i.Height, (uint)format, (uint)dataType,
+                                     bptr);
+            }
+            i.PixelUpdateCount++;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void SetBufferData<T>(BufferType bufferType, T bufferData, BufferUsage usage)
+            where T: unmanaged,INumber<T>
+        {
+            int size = Marshal.SizeOf<T>();
+
+            T* p = &bufferData;
+
+            Context.glBufferData((uint)bufferType, (IntPtr)size, (IntPtr)p, (uint)usage);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void SetBufferData<T>(BufferType bufferType, T[] bufferArray, BufferUsage usage)
+            where T: unmanaged,INumber<T>
+        {
+            int size = bufferArray.Length * Marshal.SizeOf(typeof(T));
+            if (bufferArray == null) {
+                return;
+            }
+
+            fixed (void* bufferPtr = bufferArray) {
+                Context.glBufferData((uint)bufferType, (IntPtr)size, (IntPtr)bufferPtr, (uint)usage);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void SetBufferData<T>(BufferType bufferType, ReadOnlySpan<T> bufferSpan, BufferUsage usage)
+            where T: unmanaged,INumber<T>
+        {
+            int size = bufferSpan.Length * Marshal.SizeOf(typeof(T));
+            if (bufferSpan == null) {
+                return;
+            }
+
+            fixed (void* bufferPtr = bufferSpan) {
+                Context.glBufferData((uint)bufferType, (IntPtr)size, (IntPtr)bufferPtr, (uint)usage);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void SetBufferData<T>(BufferType bufferType, Span<T> bufferArray, BufferUsage usage)
+            where T: unmanaged, INumber<T>
+        {
+            int size = bufferArray.Length * Marshal.SizeOf(typeof(T));
+            if (bufferArray == null) {
+                return;
+            }
+
+
+            fixed (void* bufferPtr = bufferArray) {
+                Context.glBufferData((uint)bufferType, (IntPtr)size, (IntPtr)bufferPtr, (uint)usage);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void SetBufferVectorData<T>(BufferType bufferType, ReadOnlySpan<T> bufferSpan, BufferUsage usage)
+            where T: unmanaged, IUnmanagedVector<T>
+        {
+            int size = bufferSpan.Length * Marshal.SizeOf(typeof(T));
+
+            fixed (void* bufferPtr = bufferSpan) {
+                Context.glBufferData((uint)bufferType, (IntPtr)size, (IntPtr)bufferPtr, (uint)usage);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void SetBufferVectorData<T>(BufferType bufferType, T[] bufferArray, BufferUsage usage)
+            where T: unmanaged, IUnmanagedVector<T>
+        {
+            int size = bufferArray.Length * Marshal.SizeOf(typeof(T));
+            if (bufferArray == null) {
+                return;
+            }
+            fixed (void* bufferPtr = bufferArray) {
+                Context.glBufferData((uint)bufferType, (IntPtr)size, (IntPtr)bufferPtr, (uint)usage);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void SetRenderBufferStorage(
+                           RenderBufferInternalFormat internalFormat,
+                           (int width, int height) size)
+        {
+            Context.glRenderbufferStorage(glConst.RENDERBUFFER, (uint)internalFormat, size.width, size.height);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public unsafe void SetRenderBufferStorage(
+                           RenderBufferInternalFormat internalFormat,
+                           (uint width, uint height) size)
+        {
+            Context.glRenderbufferStorage(glConst.RENDERBUFFER, (uint)internalFormat, (int)size.width,
+                                          (int)size.height);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void SetVertexAttribute(uint index, int size, TypeCode t, bool normalized, uint stride, int pointer)
+        {
+            uint type = GraphicFramework.GLtype[(int)t];
+            Context.glVertexAttribPointer(index, size, type, normalized ? 1 : 0, stride, (void*)pointer);
+            Context.glEnableVertexAttribArray(index);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureImage2d<T>(
+                    Texture2DTarget target,
+                    int level,
+                    ImageChannel sourceChannel,
+                    uint width,
+                    uint height,
+                    ImageChannel targetChannel,
+                    PixelChannelLayout type,
+                    T[] pixels)
+            where T: unmanaged, INumber<T>
+        {
+            fixed (T* tptr = pixels)
+            {
+                T* ptr = ((pixels == null) || (pixels.Length == 0)) ? (T*)IntPtr.Zero : tptr;
+                Context.glTexImage2D((uint)target, level, (uint)sourceChannel, width, height, 0, (uint)targetChannel,
+                                     (uint)type, tptr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureImage2d<T>(
+                    Texture2DTarget target,
+                    int level,
+                    ImageChannel sourceChannel,
+                    uint width,
+                    uint height,
+                    ImageChannel targetChannel,
+                    PixelChannelLayout type,
+                    Span<T> pixelSpan)
+            where T: unmanaged, INumber<T>
+        {
+            fixed (T* tPtr = pixelSpan) {
+                Context.glTexImage2D((uint)target, level, (uint)sourceChannel, width, height, 0, (uint)targetChannel,
+                                     (uint)type, tPtr);
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void TextureParameter(int target, uint pname, int param)
+        {
+            Context.glTexParameteri((uint)target, pname, param);
+        }
+
+        public static bool TryGetFunctionPackage(IntPtr handle, out OpenGLFunction functionPackage)
+        {
+            return contextToGLMap.TryGetValue(handle, out functionPackage);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void UseProgram(GlHandle program)
+        {
+            Context.glUseProgram(program.Value);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void VertexAttributeDivisor(uint layoutIndex, uint divisor)
+        {
+            Context.glVertexAttribDivisor(layoutIndex, divisor);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void Viewport(int x, int y, uint width, uint height)
+        {
+            Context.glViewport(x, y, width, height);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public void WaitAccomplishment()
+        {
+            Context.glFinish();
+        }
+
+        internal static OpenGLFunction BuildGlFunctionPackage(IntPtr handle)
+        {
+            if (contextToGLMap.TryGetValue(handle, out OpenGLFunction pack)) {
+                return pack;
+            }
+            pack = new OpenGLFunction
+            {
+                _context = (OpenglContext*)handle
+            };
+            contextToGLMap.Add(handle, pack);
+            return pack;
+        }
+
+        ~OpenGLFunction()
+        {
+            _ = contextToGLMap.Remove(ContextHandle);
+        }
+
+    }
+}
+

StgSharp.Common/Graphics/OpenGL/glHandle.cs

@@ -0,0 +1,84 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="glHandle"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Versioning;
+using System.Security.AccessControl;
+using System.Security.Cryptography;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    [StructLayout(LayoutKind.Explicit, Size = 4)]
+    public struct GlHandle
+    {
+
+        [FieldOffset(0)] internal int SignedValue;
+        [FieldOffset(0)] internal uint Value;
+
+        public GlHandle()
+        {
+            Unsafe.SkipInit(out Value);
+            Unsafe.SkipInit(out SignedValue);
+            Unsafe.SkipInit(out this);
+        }
+
+        public static GlHandle Zero
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => new GlHandle
+            {
+                Value = 0
+            };
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static GlHandle Create(uint value)
+        {
+            return new GlHandle
+            {
+                Value = value
+            };
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static GlHandle CreateSigned(int value)
+        {
+            return new GlHandle
+            {
+                SignedValue = value
+            };
+        }
+
+    }
+}

StgSharp.Common/Graphics/OpenGL/glRenderObjectGenrator.cs

@@ -0,0 +1,120 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="glRenderObjectGenrator"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Runtime.CompilerServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public partial class glRender
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected AutoTextureGL CreateAutoTexture(int count)
+        {
+            return new AutoTextureGL(count, this);
+        }
+
+        /// <summary>
+        ///   Create a set of <see cref="ElementBuffer" />.
+        /// </summary>
+        /// <param _label="count">
+        ///   Amount of EBO to be created.
+        /// </param>
+        /// <returns>
+        ///
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected ElementBuffer CreateElementBuffer(int count)
+        {
+            return new ElementBuffer(count, this);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected FrameBuffer CreateFrameBuffer(int count)
+        {
+            return new FrameBuffer(count, this);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected RenderBuffer CreateRenderBuffer(int count)
+        {
+            return new RenderBuffer(count, this);
+        }
+
+        /// <summary>
+        ///   Create a sets of <see cref="TextureGL" />
+        /// </summary>
+        /// <param _label="count">
+        ///   Amount of textures to be created.
+        /// </param>
+        /// <returns>
+        ///
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected TextureGL CreateTexture(int count)
+        {
+            return new TextureGL(count, this);
+        }
+
+        /// <summary>
+        ///   Create a set of <see cref="VertexArray" />.
+        /// </summary>
+        /// <param _label="count">
+        ///   Amount of VAO to be created.
+        /// </param>
+        /// <returns>
+        ///
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected VertexArray CreateVertexArray(int count)
+        {
+            return new VertexArray(count, this);
+        }
+
+        /// <summary>
+        ///   Create a set of <see cref="VertexBuffer" />.
+        /// </summary>
+        /// <param _label="count">
+        ///   Amount of Object to be created.
+        /// </param>
+        /// <returns>
+        ///
+        /// </returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected VertexBuffer CreateVertexBuffer(int count)
+        {
+            return new VertexBuffer(count, this);
+        }
+
+    }
+}

StgSharp.Common/Graphics/OpenGL/glRenderStream.cs

@@ -0,0 +1,178 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="glRenderStream"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics.Graphic;
+using StgSharp.Threading;
+
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    public abstract partial class glRender : RenderStream
+    {
+
+        private protected static readonly ConcurrentDictionary<glRender, Thread> renderToThread
+            = new ConcurrentDictionary<glRender, Thread>();
+
+        private OpenGLFunction _context;
+
+        protected internal OpenGLFunction GL
+        {
+            get { return _context; }
+        }
+
+        /// <summary>
+        ///   Initialize an opengl context and load all opengl functions.
+        /// </summary>
+        public unsafe void InitializeContext()
+        {
+            if (ContextHandle == default)
+            {
+                ContextHandle = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(OpenglContext)));
+                OpenglContext* contextID = (OpenglContext*)ContextHandle;
+                contextID->glGetString = (delegate*<uint, IntPtr>)IntPtr.Zero;
+            }
+            if (GL == null) {
+                _context = OpenGLFunction.BuildGlFunctionPackage(ContextHandle);
+            }
+        }
+
+        /// <summary>
+        ///   Initialize an OpenGl viewPortDisplay if current form has not been binded to any
+        ///   viewPortDisplay.  and set the viewPortDisplay binded to current form as current OpenGL
+        ///   viewPortDisplay.
+        /// </summary>
+        /// <exception cref="Exception">
+        ///   Something goes wrong and World fails in creating a new OpenGL viewPortDisplay.
+        /// </exception>
+        public unsafe void MakeAsCurrentContext()
+        {
+            GraphicFramework.glfwMakeContextCurrent(CanvasHandle);
+            OpenGLFunction.CurrentGL = this.GL;
+        }
+
+        /// <inheritdoc />
+        public override void RenderEnd()
+        {
+            if (!renderToThread.TryGetValue(this, out Thread t) || t != Thread.CurrentThread) {
+                throw new InvalidOperationException(
+                    $"Current render has had been binded to thread {t!.ManagedThreadId}");
+            }
+            SwapBuffers();
+            renderToThread[this] = ThreadHelper.EmptyThread;
+            GraphicFramework.glfwMakeContextCurrent(IntPtr.Zero);
+            OpenGLFunction.CurrentGL = null;
+        }
+
+        /// <inheritdoc />
+        public override void RenderStart()
+        {
+            Thread current = Thread.CurrentThread;
+            if (!renderToThread.TryGetValue(this, out Thread t) || t == ThreadHelper.EmptyThread)
+            {
+                renderToThread[this] = current;
+                MakeAsCurrentContext();
+                return;
+            }
+            if (t != current) {
+                throw new InvalidOperationException(
+                    $"Current render has had been binded to thread {t!.ManagedThreadId}");
+            }
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public override void SetSizeLimit(int minWidth, int minHeight, int maxWidth, int maxHeight)
+        {
+            GraphicFramework.glfwSetWindowSizeLimits(
+                this.CanvasHandle, minWidth, minHeight, maxWidth, maxHeight);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal sealed override void PlatformSpecifiedInitialize()
+        {
+            InitializeContext();
+            MakeAsCurrentContext();
+            glManager.LoadOpenGLApiTo(BindedViewPortContext.GraphicHandle);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        internal sealed override void Terminate()
+        {
+            CustomizeDeinit();
+        }
+
+        protected sealed override Uniform<Matrix44> NativeCameraUniform(ShaderProgram source, string name)
+        {
+            NativeCamera.GainAllUniforms(source, name);
+            return NativeCamera.convertedUniform;
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected sealed override void NativeCameraViewRange(
+                                       Radius fieldOfRange,
+                                       Vec2 offset,
+                                       (float frontDepth, float backDepth) viewDepth)
+        {
+            NativeCamera.SetViewRange(fieldOfRange, this.Size, offset, viewDepth);
+        }
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        protected sealed override void NativeCameraViewTarget(Vec3 position, Vec3 direction, Vec3 up)
+        {
+            NativeCamera.SetViewDirection(position, direction, up);
+        }
+
+        #region Key Control
+
+        protected KeyStatus CheckKey(KeyboardKey key)
+        {
+            return GraphicFramework.glfwGetKey(this.CanvasHandle, (int)key);
+        }
+
+        protected KeyStatus CheckKey(Mouse key)
+        {
+            return GraphicFramework.glfwGetKey(this.CanvasHandle, (int)key);
+        }
+
+        protected KeyStatus CheckKey(Joystick key)
+        {
+            return GraphicFramework.glfwGetKey(this.CanvasHandle, (int)key);
+        }
+
+        #endregion
+    }
+}

StgSharp.Common/Graphics/OpenGL/glType.cs

@@ -0,0 +1,95 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="glType"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Collections.ObjectModel;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace StgSharp.Graphics.OpenGL
+{
+    internal delegate void GLVULKANPROCNV();
+
+    public unsafe struct glHandleARB(IntPtr value) { }
+
+    /// <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;
+        }
+
+    }
+
+    [StructLayout(LayoutKind.Explicit, Size = 16)]
+    public struct glHalfNv(Half bin)
+    {
+
+        [FieldOffset(0)] public Half binary = bin;
+
+        public float ToSingle()
+        {
+            return (float)binary;
+        }
+
+    }
+
+    [StructLayout(LayoutKind.Explicit, Size = 8)]
+    public struct GlFixed
+    {
+
+        [FieldOffset(0)] public int All;
+        [FieldOffset(0)] public short Decimals;
+        [FieldOffset(4)] public short Integer;
+
+    }
+
+    /// <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;
+        }
+
+    }
+}

StgSharp.Common/Graphics/Pixels.cs

@@ -0,0 +1,83 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="Pixels"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.InteropServices;
+using System.Text;
+
+namespace StgSharp.Graphics
+{
+    public interface IPixel
+    {
+
+        public float Red { get; set; }
+
+        public float Green { get; set; }
+
+        public float Blue { get; set; }
+
+        public float Alpha { get; set; }
+
+        internal int Size { get; }
+
+    }
+
+    [StructLayout(LayoutKind.Explicit, Size = 32)]
+    public unsafe struct Pixel32RGBA : IPixel
+    {
+
+        [FieldOffset(0)] private unsafe fixed byte data[4];
+
+        public int Size => 4;
+
+        float IPixel.Alpha
+        {
+            get => data[3] / 256                    ;
+            set => data[3] = (byte)(value * 256);
+        }
+
+        float IPixel.Blue
+        {
+            get => data[2] / 256                    ;
+            set => data[2] = (byte)(value * 256);
+        }
+
+        float IPixel.Green
+        {
+            get => data[1] / 256                    ;
+            set => data[1] = (byte)(value * 256);
+        }
+
+        float IPixel.Red
+        {
+            get => data[0] / 256                    ;
+            set => data[0] = (byte)(value * 256);
+        }
+
+    }
+}

StgSharp.Common/Graphics/PlainGeometryMesh.cs

@@ -0,0 +1,92 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="PlainGeometryMesh"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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 StgSharp.Mathematics.Graphic;
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Runtime.InteropServices;
+using System.Text;
+
+namespace StgSharp.Graphics
+{
+    public class PlainGeometryMesh
+    {
+
+        private PlainGeometry _shape;
+        private TextureProvider _texture;
+
+        public PlainGeometryMesh([NotNull] PlainGeometry shape, [NotNull] TextureProvider texture)
+        {
+            if (shape.VertexCount > texture.TextureCoordinate.Length) {
+                throw new ArgumentException(
+                    paramName:nameof(texture),
+                    message:"Amount of texture coordination is too less");
+            }
+            _texture = texture;
+            _shape = shape;
+        }
+
+        // private Image _texture;
+
+        public PlainGeometryMesh(PlainGeometry shape, Image texture, Vec2[] texCoord)
+        {
+            ArgumentNullException.ThrowIfNull(shape);
+            ArgumentNullException.ThrowIfNull(texCoord);
+
+            if (shape.VertexCount > texCoord.Length) {
+                throw new ArgumentException(
+                    paramName:nameof(texCoord),
+                    message:"Amount of texture coordination is too less");
+            }
+            _texture = new TextureProvider(texture, texCoord);
+        }
+
+        public Vec4[] VertexArray => _shape.VertexStream;
+
+        public Image TextureImage
+        {
+            get => _texture.ProvideImage();
+            internal set => _texture.ReadImage(value);
+        }
+
+        public ReadOnlySpan<int> MeshIndices => _shape.VertexIndices;
+
+        public ReadOnlySpan<Vec4> TextureCoord => MemoryMarshal.Cast<Vec2, Vec4>(
+            _texture.TextureCoordinate);
+
+        public PlainGeometryMesh Resize(PlainGeometry newShape)
+        {
+            return new PlainGeometryMesh(newShape, _texture);
+        }
+
+    }
+}

StgSharp.Common/Graphics/RenderStream.cs

@@ -0,0 +1,249 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="RenderStream"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics;
+using StgSharp.Mathematics.Graphic;
+using StgSharp.MVVM;
+using StgSharp.Timing;
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Diagnostics.CodeAnalysis;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics
+{
+    public abstract class RenderStream
+    {
+
+        private Camera nativeCamera;
+
+        private protected ViewPort primeArgs;
+        internal TimeSpanProvider _timeProvider;
+
+        public (int width, int height) Size
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => (Width, Height);
+        }
+
+        public abstract bool IsContextSharable { get; }
+
+        public int Height
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => primeArgs.Height;
+        }
+
+        public int Width
+        {
+            get => primeArgs.Width;
+        }
+
+        public IntPtr Monitor
+        {
+            get => primeArgs.Monitor;
+            internal set => primeArgs.Monitor = value;
+        }
+
+        public string Name
+        {
+            get => primeArgs.Name;
+        }
+
+        public ViewPort BindedViewPortContext
+        {
+            get => primeArgs;
+            internal set => primeArgs = value;
+        }
+
+        internal IntPtr CanvasHandle
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => primeArgs.ViewPortHandle;
+        }
+
+        internal IntPtr ContextHandle
+        {
+            get => primeArgs.GraphicHandle;
+            private protected set => primeArgs.GraphicHandle = value;
+        }
+
+        protected internal Camera NativeCamera
+        {
+            get => nativeCamera;
+            internal set => nativeCamera = value;
+        }
+
+        protected float FramePassed
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => _timeProvider.CurrentSpan;
+        }
+
+        protected int PassedFrames
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => _timeProvider.CurrentSpan;
+        }
+
+        protected float TimePassed
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => (float)_timeProvider.CurrentSecond;
+        }
+
+        protected TimeSpanProvider TimeProvider
+        {
+            [MethodImpl(MethodImplOptions.AggressiveInlining)]
+            get => _timeProvider;
+        }
+
+        /// <summary>
+        ///   Set the Size limit of current form
+        /// </summary>
+        /// <param _label="minWidth">
+        ///   Minimum width of current form
+        /// </param>
+        /// <param _label="minHeight">
+        ///   Minimum height of current form
+        /// </param>
+        /// <param _label="maxWidth">
+        ///   Maximum width of current form
+        /// </param>
+        /// <param _label="maxHeight">
+        ///   Maximum height of current form
+        /// </param>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public abstract void SetSizeLimit(int minWidth, int minHeight, int maxWidth, int maxHeight);
+
+        public static TTarget ShareContextFrom<TSource, TTarget>([NotNull]TSource source) where TSource : RenderStream
+            where TTarget : RenderStream, new()
+        {
+            TTarget target = new TTarget();
+            target.Initialize(source.BindedViewPortContext, source._timeProvider);
+            return target;
+        }
+
+        /**/
+        protected internal static void PollEvents()
+        {
+            GraphicFramework.glfwPollEvents();
+        }
+
+        private protected void SwapBuffers()
+        {
+            GraphicFramework.glfwSwapBuffers(CanvasHandle);
+        }
+
+        /**/
+
+        #region native camera operation
+
+        protected abstract void NativeCameraViewRange(
+                                Radius fieldOfRange,
+                                Vec2 offset,
+                                (float frontDepth, float backDepth) viewDepth);
+
+        protected abstract void NativeCameraViewTarget(Vec3 position, Vec3 direction, Vec3 up);
+
+        /// <summary>
+        ///   Get <see cref="Uniform{T}" />(TView is <see cref="Matrix44" />) uniform from a shader.
+        ///   This uniform will be used as projection matrix of this camera. Additionally, for
+        ///   multi- shader rendering, each shader requires a uniform,  so do not ignore return
+        ///   value of this method.
+        /// </summary>
+        /// <param _label="source">
+        ///   Shader using this camera
+        /// </param>
+        /// <param _label="name">
+        ///   ContextName of projection camera named in shader
+        /// </param>
+        /// <returns>
+        ///   <see cref="Uniform{T}" />(TView is <see cref="Matrix44" />) representing  projection
+        ///   matrix in shader program.
+        /// </returns>
+        protected abstract Uniform<Matrix44> NativeCameraUniform(ShaderProgram source, string name);
+
+        #endregion
+
+        #region internal operation
+
+        public void Initialize(ViewPort v, TimeSpanProvider timeProvider)
+        {
+            if (v == null) {
+                throw new ArgumentNullException(nameof(v));
+            }
+            primeArgs = v;
+            this._timeProvider = timeProvider;
+            nativeCamera = new Camera();
+            PlatformSpecifiedInitialize();
+            CustomizeInit();
+            GraphicFramework.glfwMakeContextCurrent(IntPtr.Zero);
+        }
+
+        internal abstract void PlatformSpecifiedInitialize();
+
+        internal abstract void Terminate();
+
+        #endregion
+
+        #region public operation
+
+        protected abstract void CustomizeDeinit();
+
+        protected abstract void CustomizeInit();
+
+        /// <summary>
+        ///   Marking the start of current render operations,  and set this renser context as
+        ///   current.
+        /// </summary>
+        public abstract void RenderStart();
+
+        /// <summary>
+        ///   Marking the end of current render operations,  and release the binding of this renser
+        ///   context to current,  making it available for another thread as current.
+        /// </summary>
+        public abstract void RenderEnd();
+
+        #endregion
+
+        #region public resource generator
+
+        protected abstract Shader CreateShaderSegment(ShaderType type, int count);
+
+        protected abstract ShaderProgram CreateShaderProgram();
+
+    #endregion
+    }
+}

StgSharp.Common/Graphics/ShaderEdit/ShaderGenerator.cs

@@ -0,0 +1,203 @@
+//-----------------------------------------------------------------------
+// -----------------------------------------------------------------------
+// file="ShaderGenerator"
+// Project: StgSharp
+// AuthorGroup: Nitload
+// Copyright (c) Nitload. 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.Mathematics;
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.Serialization;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace StgSharp.Graphics.ShaderEdit
+{
+    public class ShaderGenerator
+    {
+
+        private Dictionary<int, ShaderParameter> uniformDefine;
+        private List<string> codeList;
+        private List<ShaderFunction> usedShaderFunctions;
+
+        public Uniform<T> DefineUniform<T>(string name, int index) where T: unmanaged
+        {
+            ShaderParameter p = new ShaderParameter(name, ShaderParameter.TypeMarshal<T>());
+            uniformDefine.Add(index, p);
+
+            // return new Uniform<TView>();
+            throw new NotImplementedException();
+        }
+
+    }
+
+    public class ShaderFunction
+    {
+
+        private List<string> codeList;
+        private List<ShaderParameter> inputList;
+        private ShaderParameter outPut;
+        private string name;
+
+        public int ParameterCount => inputList.Count;
+
+        public void EmitCall(ShaderFunction function, ShaderParameter outPut, params ShaderParameter[] inputParams)
+        {
+            if (inputParams.Length != function.ParameterCount)
+            {
+                // Param list length not equal
+                throw new ArgumentException(
+                    "Provided parameters does not match function's parameter list.");
+            }
+            if (!ShaderParameter.IsSameType(outPut, function.outPut))
+            {
+                // Type of returning value not equal
+                throw new ArgumentException(
+                    "Provided parameters does not match function's parameter list.");
+            }
+            for (int i = 0; i < inputParams.Length; i++)
+            {
+                if (!ShaderParameter.IsSameType(function.inputList[i], inputParams[i]))
+                {
+                    // Input type not match
+                    throw new InvalidCastException(
+                        "Provided parameters does not match function's parameter list.");
+                }
+            }
+            string codeLine = string.Empty;    // adding a line like " outvalue = Func(input1, input2,...); "
+            if (outPut != ShaderParameter.Void) {
+                codeLine += $"{outPut.name} = ";
+            }
+            codeLine += $"{function.name}(";
+            foreach (ShaderParameter inputParam in inputParams) {
+                codeLine += inputParam.name;
+            }
+            codeLine += ");\n";
+            codeList.Add(codeLine);
+        }
+
+    }
+
+    public class ShaderParameter
+    {
+
+        public static readonly ShaderParameter Void = new ShaderParameter(
+            string.Empty, InternalShaderType.Void);
+        internal readonly bool isReadOnly;
+        internal readonly InternalShaderType type;
+        internal readonly string name;
+
+        public ShaderParameter(string name, InternalShaderType type)
+        {
+            this.name = name;
+            this.type = type;
+            isReadOnly = false;
+        }
+
+        public static bool IsSameType(ShaderParameter param1, ShaderParameter param2)
+        {
+            if (param1.type != InternalShaderType.Struct)
+            {
+                return param1.type == param2.type;
+            } else
+            {
+                throw new Exception("Struct is currently not supported.");
+            }
+        }
+
+        public static InternalShaderType TypeMarshal<T>() where T: unmanaged
+        {
+            switch (Type.GetTypeCode(typeof(T)))
+            {
+                case TypeCode.Single:
+                    return InternalShaderType.Float;
+                case TypeCode.Double:
+                    return InternalShaderType.Double;
+                case TypeCode.Int32:
+                    return InternalShaderType.Int;
+                case TypeCode.UInt32:
+                    return InternalShaderType.UInt;
+                default:
+                    break;
+            }
+            switch (typeof(T).Name)
+            {
+                case "vec4d":
+                    return InternalShaderType.Vector4;
+                case "Matrix2x2":
+                    return InternalShaderType.Matrix2x2;
+                case "Matrix2x3":
+                    return InternalShaderType.Matrix2x3;
+                case "Matrix2x4":
+                    return InternalShaderType.Matrix2x4;
+                case "Matrix3x2":
+                    return InternalShaderType.Matrix3x2;
+                case "Matrix3x3":
+                    return InternalShaderType.Matrix3x3;
+                case "Matrix3x4":
+                    return InternalShaderType.Matrix3x4;
+                case "Matrix4x2":
+                    return InternalShaderType.Matrix4x2;
+                case "Matrix4x3":
+                    return InternalShaderType.Matrix4x3;
+                case "Matrix4x4":
+                    return InternalShaderType.Matrix4x4;
+                default:
+                    throw new ArgumentException("Not supported shader data type.");
+            }
+        }
+
+    }
+
+    public enum InternalShaderType
+    {
+#pragma warning disable CS1591
+        Struct,
+        Void,
+        Int,
+        UInt,
+        Float,
+        Double,
+        Vector2,
+        Vector3,
+        Vector4,
+        VectorD2,
+        VectorD3,
+        VectorD4,
+        Matrix2x2,
+        Matrix2x3,
+        Matrix2x4,
+        Matrix3x2,
+        Matrix3x3,
+        Matrix3x4,
+        Matrix4x2,
+        Matrix4x3,
+        Matrix4x4,
+#pragma warning restore CS1591
+    }
+}