Better process implementation (#491)

* Initial implementation of KProcess

* Some improvements to the memory manager, implement back guest stack trace printing

* Better GetInfo implementation, improve checking in some places with information from process capabilities

* Allow the cpu to read/write from the correct memory locations for accesses crossing a page boundary

* Change long -> ulong for address/size on memory related methods to avoid unnecessary casts

* Attempt at implementing ldr:ro with new KProcess

* Allow BSS with size 0 on ldr:ro

* Add checking for memory block slab heap usage, return errors if full, exit gracefully

* Use KMemoryBlockSize const from KMemoryManager

* Allow all methods to read from non-contiguous locations

* Fix for TransactParcelAuto

* Address PR feedback, additionally fix some small issues related to the KIP loader and implement SVCs GetProcessId, GetProcessList, GetSystemInfo, CreatePort and ManageNamedPort

* Fix wrong check for source pages count from page list on MapPhysicalMemory

* Fix some issues with UnloadNro on ldr:ro

9 files changed, 185 insertions, 140 deletions

diff --git a/Ryujinx.Graphics/Gal/GalVertexAttrib.cs b/Ryujinx.Graphics/Gal/GalVertexAttrib.cs
index fa9a391f..31b648df 100644
--- a/Ryujinx.Graphics/Gal/GalVertexAttrib.cs
+++ b/Ryujinx.Graphics/Gal/GalVertexAttrib.cs
@@ -1,5 +1,3 @@
-using System;
-
 namespace Ryujinx.Graphics.Gal
 {
     public struct GalVertexAttrib
@@ -7,7 +5,7 @@ namespace Ryujinx.Graphics.Gal
         public int    Index   { get; private set; }
         public bool   IsConst { get; private set; }
         public int    Offset  { get; private set; }
-        public IntPtr Pointer { get; private set; }
+        public byte[] Data    { get; private set; }
 
         public GalVertexAttribSize Size { get; private set; }
         public GalVertexAttribType Type { get; private set; }
@@ -18,14 +16,14 @@ namespace Ryujinx.Graphics.Gal
             int                 Index,
             bool                IsConst,
             int                 Offset,
-            IntPtr              Pointer,
+            byte[]              Data,
             GalVertexAttribSize Size,
             GalVertexAttribType Type,
             bool                IsBgra)
         {
             this.Index   = Index;
             this.IsConst = IsConst;
-            this.Pointer = Pointer;
+            this.Data    = Data;
             this.Offset  = Offset;
             this.Size    = Size;
             this.Type    = Type;
diff --git a/Ryujinx.Graphics/Gal/IGalConstBuffer.cs b/Ryujinx.Graphics/Gal/IGalConstBuffer.cs
index 37545b2a..0cdcc237 100644
--- a/Ryujinx.Graphics/Gal/IGalConstBuffer.cs
+++ b/Ryujinx.Graphics/Gal/IGalConstBuffer.cs
@@ -12,5 +12,6 @@ namespace Ryujinx.Graphics.Gal
         bool IsCached(long Key, long Size);
 
         void SetData(long Key, long Size, IntPtr HostAddress);
+        void SetData(long Key, byte[] Data);
     }
 }
\ No newline at end of file
diff --git a/Ryujinx.Graphics/Gal/IGalRasterizer.cs b/Ryujinx.Graphics/Gal/IGalRasterizer.cs
index 052e3f35..04f7aae5 100644
--- a/Ryujinx.Graphics/Gal/IGalRasterizer.cs
+++ b/Ryujinx.Graphics/Gal/IGalRasterizer.cs
@@ -22,6 +22,7 @@ namespace Ryujinx.Graphics.Gal
         bool IsIboCached(long Key, long DataSize);
 
         void CreateVbo(long Key, int DataSize, IntPtr HostAddress);
+        void CreateVbo(long Key, byte[] Data);
 
         void CreateIbo(long Key, int DataSize, IntPtr HostAddress);
         void CreateIbo(long Key, int DataSize, byte[] Buffer);
diff --git a/Ryujinx.Graphics/Gal/OpenGL/OGLConstBuffer.cs b/Ryujinx.Graphics/Gal/OpenGL/OGLConstBuffer.cs
index e04190e0..a12681c7 100644
--- a/Ryujinx.Graphics/Gal/OpenGL/OGLConstBuffer.cs
+++ b/Ryujinx.Graphics/Gal/OpenGL/OGLConstBuffer.cs
@@ -44,6 +44,14 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             }
         }
 
+        public void SetData(long Key, byte[] Data)
+        {
+            if (Cache.TryGetValue(Key, out OGLStreamBuffer Buffer))
+            {
+                Buffer.SetData(Data);
+            }
+        }
+
         public bool TryGetUbo(long Key, out int UboHandle)
         {
             if (Cache.TryGetValue(Key, out OGLStreamBuffer Buffer))
diff --git a/Ryujinx.Graphics/Gal/OpenGL/OGLPipeline.cs b/Ryujinx.Graphics/Gal/OpenGL/OGLPipeline.cs
index e81cf8a3..ac12314c 100644
--- a/Ryujinx.Graphics/Gal/OpenGL/OGLPipeline.cs
+++ b/Ryujinx.Graphics/Gal/OpenGL/OGLPipeline.cs
@@ -600,122 +600,125 @@ namespace Ryujinx.Graphics.Gal.OpenGL
                 ThrowUnsupportedAttrib(Attrib);
             }
 
-            if (Attrib.Type == GalVertexAttribType.Unorm)
+            fixed (byte* Ptr = Attrib.Data)
             {
-                switch (Attrib.Size)
+                if (Attrib.Type == GalVertexAttribType.Unorm)
                 {
-                    case GalVertexAttribSize._8:
-                    case GalVertexAttribSize._8_8:
-                    case GalVertexAttribSize._8_8_8:
-                    case GalVertexAttribSize._8_8_8_8:
-                        GL.VertexAttrib4N((uint)Attrib.Index, (byte*)Attrib.Pointer);
-                        break;
-
-                    case GalVertexAttribSize._16:
-                    case GalVertexAttribSize._16_16:
-                    case GalVertexAttribSize._16_16_16:
-                    case GalVertexAttribSize._16_16_16_16:
-                        GL.VertexAttrib4N((uint)Attrib.Index, (ushort*)Attrib.Pointer);
-                        break;
-
-                    case GalVertexAttribSize._32:
-                    case GalVertexAttribSize._32_32:
-                    case GalVertexAttribSize._32_32_32:
-                    case GalVertexAttribSize._32_32_32_32:
-                        GL.VertexAttrib4N((uint)Attrib.Index, (uint*)Attrib.Pointer);
-                        break;
+                    switch (Attrib.Size)
+                    {
+                        case GalVertexAttribSize._8:
+                        case GalVertexAttribSize._8_8:
+                        case GalVertexAttribSize._8_8_8:
+                        case GalVertexAttribSize._8_8_8_8:
+                            GL.VertexAttrib4N((uint)Attrib.Index, Ptr);
+                            break;
+
+                        case GalVertexAttribSize._16:
+                        case GalVertexAttribSize._16_16:
+                        case GalVertexAttribSize._16_16_16:
+                        case GalVertexAttribSize._16_16_16_16:
+                            GL.VertexAttrib4N((uint)Attrib.Index, (ushort*)Ptr);
+                            break;
+
+                        case GalVertexAttribSize._32:
+                        case GalVertexAttribSize._32_32:
+                        case GalVertexAttribSize._32_32_32:
+                        case GalVertexAttribSize._32_32_32_32:
+                            GL.VertexAttrib4N((uint)Attrib.Index, (uint*)Ptr);
+                            break;
+                    }
                 }
-            }
-            else if (Attrib.Type == GalVertexAttribType.Snorm)
-            {
-                switch (Attrib.Size)
+                else if (Attrib.Type == GalVertexAttribType.Snorm)
                 {
-                    case GalVertexAttribSize._8:
-                    case GalVertexAttribSize._8_8:
-                    case GalVertexAttribSize._8_8_8:
-                    case GalVertexAttribSize._8_8_8_8:
-                        GL.VertexAttrib4N((uint)Attrib.Index, (sbyte*)Attrib.Pointer);
-                        break;
-
-                    case GalVertexAttribSize._16:
-                    case GalVertexAttribSize._16_16:
-                    case GalVertexAttribSize._16_16_16:
-                    case GalVertexAttribSize._16_16_16_16:
-                        GL.VertexAttrib4N((uint)Attrib.Index, (short*)Attrib.Pointer);
-                        break;
-
-                    case GalVertexAttribSize._32:
-                    case GalVertexAttribSize._32_32:
-                    case GalVertexAttribSize._32_32_32:
-                    case GalVertexAttribSize._32_32_32_32:
-                        GL.VertexAttrib4N((uint)Attrib.Index, (int*)Attrib.Pointer);
-                        break;
+                    switch (Attrib.Size)
+                    {
+                        case GalVertexAttribSize._8:
+                        case GalVertexAttribSize._8_8:
+                        case GalVertexAttribSize._8_8_8:
+                        case GalVertexAttribSize._8_8_8_8:
+                            GL.VertexAttrib4N((uint)Attrib.Index, (sbyte*)Ptr);
+                            break;
+
+                        case GalVertexAttribSize._16:
+                        case GalVertexAttribSize._16_16:
+                        case GalVertexAttribSize._16_16_16:
+                        case GalVertexAttribSize._16_16_16_16:
+                            GL.VertexAttrib4N((uint)Attrib.Index, (short*)Ptr);
+                            break;
+
+                        case GalVertexAttribSize._32:
+                        case GalVertexAttribSize._32_32:
+                        case GalVertexAttribSize._32_32_32:
+                        case GalVertexAttribSize._32_32_32_32:
+                            GL.VertexAttrib4N((uint)Attrib.Index, (int*)Ptr);
+                            break;
+                    }
                 }
-            }
-            else if (Attrib.Type == GalVertexAttribType.Uint)
-            {
-                switch (Attrib.Size)
+                else if (Attrib.Type == GalVertexAttribType.Uint)
                 {
-                    case GalVertexAttribSize._8:
-                    case GalVertexAttribSize._8_8:
-                    case GalVertexAttribSize._8_8_8:
-                    case GalVertexAttribSize._8_8_8_8:
-                        GL.VertexAttribI4((uint)Attrib.Index, (byte*)Attrib.Pointer);
-                        break;
-
-                    case GalVertexAttribSize._16:
-                    case GalVertexAttribSize._16_16:
-                    case GalVertexAttribSize._16_16_16:
-                    case GalVertexAttribSize._16_16_16_16:
-                        GL.VertexAttribI4((uint)Attrib.Index, (ushort*)Attrib.Pointer);
-                        break;
-
-                    case GalVertexAttribSize._32:
-                    case GalVertexAttribSize._32_32:
-                    case GalVertexAttribSize._32_32_32:
-                    case GalVertexAttribSize._32_32_32_32:
-                        GL.VertexAttribI4((uint)Attrib.Index, (uint*)Attrib.Pointer);
-                        break;
+                    switch (Attrib.Size)
+                    {
+                        case GalVertexAttribSize._8:
+                        case GalVertexAttribSize._8_8:
+                        case GalVertexAttribSize._8_8_8:
+                        case GalVertexAttribSize._8_8_8_8:
+                            GL.VertexAttribI4((uint)Attrib.Index, Ptr);
+                            break;
+
+                        case GalVertexAttribSize._16:
+                        case GalVertexAttribSize._16_16:
+                        case GalVertexAttribSize._16_16_16:
+                        case GalVertexAttribSize._16_16_16_16:
+                            GL.VertexAttribI4((uint)Attrib.Index, (ushort*)Ptr);
+                            break;
+
+                        case GalVertexAttribSize._32:
+                        case GalVertexAttribSize._32_32:
+                        case GalVertexAttribSize._32_32_32:
+                        case GalVertexAttribSize._32_32_32_32:
+                            GL.VertexAttribI4((uint)Attrib.Index, (uint*)Ptr);
+                            break;
+                    }
                 }
-            }
-            else if (Attrib.Type == GalVertexAttribType.Sint)
-            {
-                switch (Attrib.Size)
+                else if (Attrib.Type == GalVertexAttribType.Sint)
                 {
-                    case GalVertexAttribSize._8:
-                    case GalVertexAttribSize._8_8:
-                    case GalVertexAttribSize._8_8_8:
-                    case GalVertexAttribSize._8_8_8_8:
-                        GL.VertexAttribI4((uint)Attrib.Index, (sbyte*)Attrib.Pointer);
-                        break;
-
-                    case GalVertexAttribSize._16:
-                    case GalVertexAttribSize._16_16:
-                    case GalVertexAttribSize._16_16_16:
-                    case GalVertexAttribSize._16_16_16_16:
-                        GL.VertexAttribI4((uint)Attrib.Index, (short*)Attrib.Pointer);
-                        break;
-
-                    case GalVertexAttribSize._32:
-                    case GalVertexAttribSize._32_32:
-                    case GalVertexAttribSize._32_32_32:
-                    case GalVertexAttribSize._32_32_32_32:
-                        GL.VertexAttribI4((uint)Attrib.Index, (int*)Attrib.Pointer);
-                        break;
+                    switch (Attrib.Size)
+                    {
+                        case GalVertexAttribSize._8:
+                        case GalVertexAttribSize._8_8:
+                        case GalVertexAttribSize._8_8_8:
+                        case GalVertexAttribSize._8_8_8_8:
+                            GL.VertexAttribI4((uint)Attrib.Index, (sbyte*)Ptr);
+                            break;
+
+                        case GalVertexAttribSize._16:
+                        case GalVertexAttribSize._16_16:
+                        case GalVertexAttribSize._16_16_16:
+                        case GalVertexAttribSize._16_16_16_16:
+                            GL.VertexAttribI4((uint)Attrib.Index, (short*)Ptr);
+                            break;
+
+                        case GalVertexAttribSize._32:
+                        case GalVertexAttribSize._32_32:
+                        case GalVertexAttribSize._32_32_32:
+                        case GalVertexAttribSize._32_32_32_32:
+                            GL.VertexAttribI4((uint)Attrib.Index, (int*)Ptr);
+                            break;
+                    }
                 }
-            }
-            else if (Attrib.Type == GalVertexAttribType.Float)
-            {
-                switch (Attrib.Size)
+                else if (Attrib.Type == GalVertexAttribType.Float)
                 {
-                    case GalVertexAttribSize._32:
-                    case GalVertexAttribSize._32_32:
-                    case GalVertexAttribSize._32_32_32:
-                    case GalVertexAttribSize._32_32_32_32:
-                        GL.VertexAttrib4(Attrib.Index, (float*)Attrib.Pointer);
-                        break;
-
-                    default: ThrowUnsupportedAttrib(Attrib); break;
+                    switch (Attrib.Size)
+                    {
+                        case GalVertexAttribSize._32:
+                        case GalVertexAttribSize._32_32:
+                        case GalVertexAttribSize._32_32_32:
+                        case GalVertexAttribSize._32_32_32_32:
+                            GL.VertexAttrib4(Attrib.Index, (float*)Ptr);
+                            break;
+
+                        default: ThrowUnsupportedAttrib(Attrib); break;
+                    }
                 }
             }
         }
diff --git a/Ryujinx.Graphics/Gal/OpenGL/OGLRasterizer.cs b/Ryujinx.Graphics/Gal/OpenGL/OGLRasterizer.cs
index cd6292f7..c4015d02 100644
--- a/Ryujinx.Graphics/Gal/OpenGL/OGLRasterizer.cs
+++ b/Ryujinx.Graphics/Gal/OpenGL/OGLRasterizer.cs
@@ -92,7 +92,7 @@ namespace Ryujinx.Graphics.Gal.OpenGL
         {
             int Handle = GL.GenBuffer();
 
-            VboCache.AddOrUpdate(Key, Handle, (uint)DataSize);
+            VboCache.AddOrUpdate(Key, Handle, DataSize);
 
             IntPtr Length = new IntPtr(DataSize);
 
@@ -100,6 +100,18 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             GL.BufferData(BufferTarget.ArrayBuffer, Length, HostAddress, BufferUsageHint.StreamDraw);
         }
 
+        public void CreateVbo(long Key, byte[] Data)
+        {
+            int Handle = GL.GenBuffer();
+
+            VboCache.AddOrUpdate(Key, Handle, Data.Length);
+
+            IntPtr Length = new IntPtr(Data.Length);
+
+            GL.BindBuffer(BufferTarget.ArrayBuffer, Handle);
+            GL.BufferData(BufferTarget.ArrayBuffer, Length, Data, BufferUsageHint.StreamDraw);
+        }
+
         public void CreateIbo(long Key, int DataSize, IntPtr HostAddress)
         {
             int Handle = GL.GenBuffer();
@@ -116,7 +128,7 @@ namespace Ryujinx.Graphics.Gal.OpenGL
         {
             int Handle = GL.GenBuffer();
 
-            IboCache.AddOrUpdate(Key, Handle, (uint)DataSize);
+            IboCache.AddOrUpdate(Key, Handle, DataSize);
 
             IntPtr Length = new IntPtr(Buffer.Length);
 
diff --git a/Ryujinx.Graphics/Gal/OpenGL/OGLStreamBuffer.cs b/Ryujinx.Graphics/Gal/OpenGL/OGLStreamBuffer.cs
index 94639405..411d33aa 100644
--- a/Ryujinx.Graphics/Gal/OpenGL/OGLStreamBuffer.cs
+++ b/Ryujinx.Graphics/Gal/OpenGL/OGLStreamBuffer.cs
@@ -30,6 +30,13 @@ namespace Ryujinx.Graphics.Gal.OpenGL
             GL.BufferSubData(Target, IntPtr.Zero, (IntPtr)Size, HostAddress);
         }
 
+        public void SetData(byte[] Data)
+        {
+            GL.BindBuffer(Target, Handle);
+
+            GL.BufferSubData(Target, IntPtr.Zero, (IntPtr)Data.Length, Data);
+        }
+
         public void Dispose()
         {
             Dispose(true);
diff --git a/Ryujinx.Graphics/Memory/NvGpuVmm.cs b/Ryujinx.Graphics/Memory/NvGpuVmm.cs
index ec660bf0..ccb21950 100644
--- a/Ryujinx.Graphics/Memory/NvGpuVmm.cs
+++ b/Ryujinx.Graphics/Memory/NvGpuVmm.cs
@@ -243,9 +243,9 @@ namespace Ryujinx.Graphics.Memory
             return Cache.IsRegionModified(Memory, BufferType, PA, Size);
         }
 
-        public IntPtr GetHostAddress(long Position, long Size)
+        public bool TryGetHostAddress(long Position, long Size, out IntPtr Ptr)
         {
-            return Memory.GetHostAddress(GetPhysicalAddress(Position), Size);
+            return Memory.TryGetHostAddress(GetPhysicalAddress(Position), Size, out Ptr);
         }
 
         public byte ReadByte(long Position)
diff --git a/Ryujinx.Graphics/NvGpuEngine3d.cs b/Ryujinx.Graphics/NvGpuEngine3d.cs
index 4a0310fb..918409e2 100644
--- a/Ryujinx.Graphics/NvGpuEngine3d.cs
+++ b/Ryujinx.Graphics/NvGpuEngine3d.cs
@@ -615,9 +615,14 @@ namespace Ryujinx.Graphics
 
                     if (Gpu.ResourceManager.MemoryRegionModified(Vmm, Key, Cb.Size, NvGpuBufferType.ConstBuffer))
                     {
-                        IntPtr Source = Vmm.GetHostAddress(Cb.Position, Cb.Size);
-
-                        Gpu.Renderer.Buffer.SetData(Key, Cb.Size, Source);
+                        if (Vmm.TryGetHostAddress(Cb.Position, Cb.Size, out IntPtr CbPtr))
+                        {
+                            Gpu.Renderer.Buffer.SetData(Key, Cb.Size, CbPtr);
+                        }
+                        else
+                        {
+                            Gpu.Renderer.Buffer.SetData(Key, Vmm.ReadBytes(Cb.Position, Cb.Size));
+                        }
                     }
 
                     State.ConstBufferKeys[Stage][DeclInfo.Cbuf] = Key;
@@ -660,9 +665,14 @@ namespace Ryujinx.Graphics
                 {
                     if (!UsesLegacyQuads)
                     {
-                        IntPtr DataAddress = Vmm.GetHostAddress(IbPosition, IbSize);
-
-                        Gpu.Renderer.Rasterizer.CreateIbo(IboKey, IbSize, DataAddress);
+                        if (Vmm.TryGetHostAddress(IbPosition, IbSize, out IntPtr IbPtr))
+                        {
+                            Gpu.Renderer.Rasterizer.CreateIbo(IboKey, IbSize, IbPtr);
+                        }
+                        else
+                        {
+                            Gpu.Renderer.Rasterizer.CreateIbo(IboKey, IbSize, Vmm.ReadBytes(IbPosition, IbSize));
+                        }
                     }
                     else
                     {
@@ -711,22 +721,22 @@ namespace Ryujinx.Graphics
                     Attribs[ArrayIndex] = new List<GalVertexAttrib>();
                 }
 
-                long VertexPosition = MakeInt64From2xInt32(NvGpuEngine3dReg.VertexArrayNAddress + ArrayIndex * 4);
+                long VbPosition = MakeInt64From2xInt32(NvGpuEngine3dReg.VertexArrayNAddress + ArrayIndex * 4);
+
+                bool IsConst = ((Packed >> 6) & 1) != 0;
 
                 int Offset = (Packed >> 7) & 0x3fff;
 
+                GalVertexAttribSize Size = (GalVertexAttribSize)((Packed >> 21) & 0x3f);
+                GalVertexAttribType Type = (GalVertexAttribType)((Packed >> 27) & 0x7);
+
+                bool IsRgba = ((Packed >> 31) & 1) != 0;
+
                 //Note: 16 is the maximum size of an attribute,
                 //having a component size of 32-bits with 4 elements (a vec4).
-                IntPtr Pointer = Vmm.GetHostAddress(VertexPosition + Offset, 16);
+                byte[] Data = Vmm.ReadBytes(VbPosition + Offset, 16);
 
-                Attribs[ArrayIndex].Add(new GalVertexAttrib(
-                                           Attr,
-                                         ((Packed >>  6) & 0x1) != 0,
-                                           Offset,
-                                           Pointer,
-                    (GalVertexAttribSize)((Packed >> 21) & 0x3f),
-                    (GalVertexAttribType)((Packed >> 27) & 0x7),
-                                         ((Packed >> 31) & 0x1) != 0));
+                Attribs[ArrayIndex].Add(new GalVertexAttrib(Attr, IsConst, Offset, Data, Size, Type, IsRgba));
             }
 
             State.VertexBindings = new GalVertexBinding[32];
@@ -747,8 +757,8 @@ namespace Ryujinx.Graphics
                     continue;
                 }
 
-                long VertexPosition = MakeInt64From2xInt32(NvGpuEngine3dReg.VertexArrayNAddress + Index * 4);
-                long VertexEndPos   = MakeInt64From2xInt32(NvGpuEngine3dReg.VertexArrayNEndAddr + Index * 2);
+                long VbPosition = MakeInt64From2xInt32(NvGpuEngine3dReg.VertexArrayNAddress + Index * 4);
+                long VbEndPos   = MakeInt64From2xInt32(NvGpuEngine3dReg.VertexArrayNEndAddr + Index * 2);
 
                 int VertexDivisor = ReadRegister(NvGpuEngine3dReg.VertexArrayNDivisor + Index * 4);
 
@@ -758,26 +768,31 @@ namespace Ryujinx.Graphics
 
                 if (Instanced && VertexDivisor != 0)
                 {
-                    VertexPosition += Stride * (CurrentInstance / VertexDivisor);
+                    VbPosition += Stride * (CurrentInstance / VertexDivisor);
                 }
 
-                if (VertexPosition > VertexEndPos)
+                if (VbPosition > VbEndPos)
                 {
                     //Instance is invalid, ignore the draw call
                     continue;
                 }
 
-                long VboKey = Vmm.GetPhysicalAddress(VertexPosition);
+                long VboKey = Vmm.GetPhysicalAddress(VbPosition);
 
-                long VbSize = (VertexEndPos - VertexPosition) + 1;
+                long VbSize = (VbEndPos - VbPosition) + 1;
 
                 bool VboCached = Gpu.Renderer.Rasterizer.IsVboCached(VboKey, VbSize);
 
                 if (!VboCached || Gpu.ResourceManager.MemoryRegionModified(Vmm, VboKey, VbSize, NvGpuBufferType.Vertex))
                 {
-                    IntPtr DataAddress = Vmm.GetHostAddress(VertexPosition, VbSize);
-
-                    Gpu.Renderer.Rasterizer.CreateVbo(VboKey, (int)VbSize, DataAddress);
+                    if (Vmm.TryGetHostAddress(VbPosition, VbSize, out IntPtr VbPtr))
+                    {
+                        Gpu.Renderer.Rasterizer.CreateVbo(VboKey, (int)VbSize, VbPtr);
+                    }
+                    else
+                    {
+                        Gpu.Renderer.Rasterizer.CreateVbo(VboKey, Vmm.ReadBytes(VbPosition, VbSize));
+                    }
                 }
 
                 State.VertexBindings[Index].Enabled   = true;