switch root namespace name to NITLOAD

src/Nitload.Mathematics/Geometries/PlainGeometry/Define/GeometryOperation.cs

@@ -0,0 +1,27 @@
+// -----------------------------------------------------------------------------
+// file="GeometryOperation"
+// Project: StgSharp
+// Copyright (c) Nitload.
+// SPDX-License-Identifier: MIT
+// -----------------------------------------------------------------------------
+
+using Nitload.Mathematics;
+using Nitload.Mathematics.Numeric.Graphics;
+
+using System.Runtime.CompilerServices;
+
+namespace Nitload.Geometries
+{
+    public static unsafe class GeometryOperation
+    {
+
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static Vec3 DefaultMotion(
+                           int tick
+        )
+        {
+            return default(Vec3);
+        }
+
+    }
+}

src/Nitload.Mathematics/Geometries/PlainGeometry/Define/IPlainEntity.cs

@@ -0,0 +1,55 @@
+// -----------------------------------------------------------------------------
+// file="IPlainEntity"
+// Project: StgSharp
+// Copyright (c) Nitload.
+// SPDX-License-Identifier: MIT
+// -----------------------------------------------------------------------------
+
+using Nitload.Mathematics;
+using Nitload.Mathematics.Numeric.Graphics;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Nitload.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();
+        }
+
+    }
+}

src/Nitload.Mathematics/Geometries/PlainGeometry/Define/ParticleOnPlain.cs

@@ -0,0 +1,58 @@
+// -----------------------------------------------------------------------------
+// file="ParticleOnPlain"
+// Project: StgSharp
+// Copyright (c) Nitload.
+// SPDX-License-Identifier: MIT
+// -----------------------------------------------------------------------------
+
+using Nitload.Mathematics;
+using Nitload.Mathematics.Numeric.Graphics;
+using Nitload.Mathematics.Numeric.Graphics;
+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 Nitload.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();
+        }
+
+    }
+}

src/Nitload.Mathematics/Geometries/PlainGeometry/Define/PlainGeometry.cs

@@ -0,0 +1,51 @@
+// -----------------------------------------------------------------------------
+// file="PlainGeometry"
+// Project: StgSharp
+// Copyright (c) Nitload.
+// SPDX-License-Identifier: MIT
+// -----------------------------------------------------------------------------
+
+using Nitload;
+using Nitload.Mathematics;
+using Nitload.Mathematics.Numeric.Graphics;
+
+using System;
+using System.ComponentModel;
+
+namespace Nitload.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
+    }
+}

src/Nitload.Mathematics/Geometries/PlainGeometry/Define/PlainInstancingBuffer.cs

@@ -0,0 +1,151 @@
+// -----------------------------------------------------------------------------
+// file="PlainInstancingBuffer"
+// Project: StgSharp
+// Copyright (c) Nitload.
+// SPDX-License-Identifier: MIT
+// -----------------------------------------------------------------------------
+
+using Nitload.Mathematics;
+using Nitload.Mathematics.Numeric.Graphics;
+using Nitload.Mathematics.Numeric.Graphics;
+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 Nitload.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 => instanceList;
+
+        public List<Vec4> CoordAndRotationList => coordList;
+
+        public List<float> ScalingList => scalingList;
+
+        public Span<Vec4> CoordAndRotationSpan => CollectionsMarshal.AsSpan(coordList);
+
+        public Span<float> ScalingSpan => 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
+    }
+}