public BufferInfo(IMgThreadPartition partition, MgBufferUsageFlagBits usage, MgMemoryPropertyFlagBits propertyFlags, uint bufferSize) { Debug.Assert(partition != null); mDevice = partition.Device; Debug.Assert(mDevice != null); mUsageFlags = usage; mMemoryPropertyFlags = propertyFlags; var bufferCreateInfo = new MgBufferCreateInfo { Usage = usage, Size = bufferSize, }; IMgBuffer buffer; var device = partition.Device; var result = device.CreateBuffer(bufferCreateInfo, null, out buffer); Debug.Assert(result == Result.SUCCESS); MgMemoryRequirements memReqs; device.GetBufferMemoryRequirements(buffer, out memReqs); mAlignment = memReqs.Alignment; mBufferSize = memReqs.Size; uint memoryTypeIndex; partition.GetMemoryType(memReqs.MemoryTypeBits, mMemoryPropertyFlags, out memoryTypeIndex); var memAlloc = new MgMemoryAllocateInfo { MemoryTypeIndex = memoryTypeIndex, AllocationSize = memReqs.Size, }; IMgDeviceMemory deviceMemory; result = device.AllocateMemory(memAlloc, null, out deviceMemory); Debug.Assert(result == Result.SUCCESS); buffer.BindBufferMemory(device, deviceMemory, 0); mBuffer = buffer; mDeviceMemory = deviceMemory; mDescriptor = new MgDescriptorBufferInfo { Buffer = mBuffer, Offset = 0, Range = mBufferSize, }; }
public MgOptimizedStorage AllocateBlocks(MgStorageBufferInstance[] bufferInstances) { var memoryBlocks = new List <MgOptimizedStorageBlock>(); foreach (var instance in bufferInstances) { var pAllocateInfo = new MgMemoryAllocateInfo { AllocationSize = instance.AllocationSize, MemoryTypeIndex = instance.TypeIndex, }; var err = mConfiguration.Device.AllocateMemory(pAllocateInfo, null, out IMgDeviceMemory pMemory); if (err != Result.SUCCESS) { // START OVER throw new InvalidOperationException(err.ToString());; } var children = new List <uint>(); foreach (var mapping in instance.Mappings) { children.Add(mapping.Index); } var block = new MgOptimizedStorageBlock { Buffer = instance.Buffer, DeviceMemory = pMemory, AllocationSize = instance.AllocationSize, MemoryOffset = 0UL, Usage = instance.Usage, MemoryPropertyFlags = instance.MemoryPropertyFlags, PackingOrder = children.ToArray(), }; block.Buffer.BindBufferMemory( mConfiguration.Device, block.DeviceMemory, block.MemoryOffset); memoryBlocks.Add(block); } return(new MgOptimizedStorage(memoryBlocks.ToArray())); }
public GLDeviceMemory(MgMemoryAllocateInfo pAllocateInfo, IGLErrorHandler errHandler) { mErrHandler = errHandler; mBufferType = (GLMemoryBufferType)pAllocateInfo.MemoryTypeIndex; mIsHostCached = (mBufferType == GLMemoryBufferType.INDIRECT || mBufferType == GLMemoryBufferType.IMAGE); if (pAllocateInfo.AllocationSize > (ulong)int.MaxValue) { throw new ArgumentOutOfRangeException("pAllocateInfo.AllocationSize > int.MaxValue"); } mBufferSize = (int)pAllocateInfo.AllocationSize; if (mBufferType != GLMemoryBufferType.IMAGE) { mBufferTarget = GetBufferTarget(mBufferType); } if (mIsHostCached || pAllocateInfo.MemoryTypeIndex == (uint)GLMemoryBufferType.IMAGE) { mHandle = Marshal.AllocHGlobal(mBufferSize); } else { if (mBufferTarget.HasValue) { var buffers = new uint[1]; // ARB_direct_state_access // Allows buffer objects to be initialised without binding them GL.CreateBuffers(1, buffers); mErrHandler.LogGLError("GL.CreateBuffers"); mBufferId = buffers[0]; // TODO : update flags based on buffer request BufferStorageFlags flags = BufferStorageFlags.MapWriteBit | BufferStorageFlags.MapPersistentBit | BufferStorageFlags.MapCoherentBit; GL.NamedBufferStorage(mBufferId, mBufferSize, IntPtr.Zero, flags); mErrHandler.LogGLError("GL.NamedBufferStorage"); // BufferAccessMask rangeFlags = BufferAccessMask.MapWriteBit | BufferAccessMask.MapPersistentBit | BufferAccessMask.MapCoherentBit; // Handle = GL.MapNamedBufferRange (buffers[0], (IntPtr)0, BufferSize, rangeFlags); } } }
public AmtDeviceMemory(IMTLDevice device, MgMemoryAllocateInfo pAllocateInfo) { if (pAllocateInfo == null) { throw new ArgumentNullException(nameof(pAllocateInfo)); } if (pAllocateInfo.AllocationSize > nuint.MaxValue) { throw new ArgumentOutOfRangeException(nameof(pAllocateInfo.AllocationSize) + " must be <= nuint.MaxValue"); } AllocationSize = (nuint)pAllocateInfo.AllocationSize; var options = MTLResourceOptions.CpuCacheModeDefault; InternalBuffer = device.CreateBuffer(AllocationSize, options); }
void PrepareUniformBuffers() { var structSize = (uint)Marshal.SizeOf(typeof(UniformBufferObject)); MgBufferCreateInfo bufferInfo = new MgBufferCreateInfo { Size = structSize, Usage = MgBufferUsageFlagBits.UNIFORM_BUFFER_BIT, }; var err = mConfiguration.Device.CreateBuffer(bufferInfo, null, out uniformDataVS.buffer); Debug.Assert(err == Result.SUCCESS); mConfiguration.Device.GetBufferMemoryRequirements(uniformDataVS.buffer, out MgMemoryRequirements memReqs); var isValid = mConfiguration.Partition.GetMemoryType(memReqs.MemoryTypeBits, MgMemoryPropertyFlagBits.HOST_VISIBLE_BIT | MgMemoryPropertyFlagBits.HOST_COHERENT_BIT, out uint typeIndex); Debug.Assert(isValid); MgMemoryAllocateInfo allocInfo = new MgMemoryAllocateInfo { AllocationSize = memReqs.Size, MemoryTypeIndex = typeIndex, }; err = mConfiguration.Device.AllocateMemory(allocInfo, null, out uniformDataVS.memory); Debug.Assert(err == Result.SUCCESS); err = uniformDataVS.buffer.BindBufferMemory(mConfiguration.Device, uniformDataVS.memory, 0); Debug.Assert(err == Result.SUCCESS); uniformDataVS.descriptor = new MgDescriptorBufferInfo { Buffer = uniformDataVS.buffer, Offset = 0, Range = structSize, }; UpdateUniformBuffers(); }
public Result AllocateMemory(MgMemoryAllocateInfo pAllocateInfo, IMgAllocationCallbacks allocator, out IMgDeviceMemory pMemory) { pMemory = new AmtDeviceMemory(mDevice, pAllocateInfo); return(Result.SUCCESS); }
public Result AllocateMemory(MgMemoryAllocateInfo pAllocateInfo, IMgAllocationCallbacks allocator, out IMgDeviceMemory pMemory) { throw new NotImplementedException(); }
public Result AllocateMemory(MgMemoryAllocateInfo pAllocateInfo, IMgAllocationCallbacks allocator, out IMgDeviceMemory pMemory) { pMemory = mEntrypoint.DeviceMemory.CreateDeviceMemory(pAllocateInfo); return(Result.SUCCESS); }
void PrepareVertices() { TriangleVertex[] vertexBuffer = { new TriangleVertex { position = new Vector3(1.0f, 1.0f, 0.0f), color = new Vector3(1.0f, 0.0f, 0.0f) }, new TriangleVertex { position = new Vector3(-1.0f, 1.0f, 0.0f), color = new Vector3(0.0f, 1.0f, 0.0f) }, new TriangleVertex { position = new Vector3(0.0f, -1.0f, 0.0f), color = new Vector3(0.0f, 0.0f, 1.0f) }, }; var structSize = Marshal.SizeOf(typeof(TriangleVertex)); var vertexBufferSize = (ulong)(vertexBuffer.Length * structSize); UInt32[] indexBuffer = { 0, 1, 2 }; indices.count = (uint)indexBuffer.Length; var indexBufferSize = indices.count * sizeof(UInt32); var stagingBuffers = new { vertices = new StagingBuffer(), indices = new StagingBuffer(), }; { var vertexBufferInfo = new MgBufferCreateInfo { Size = vertexBufferSize, Usage = MgBufferUsageFlagBits.TRANSFER_SRC_BIT, }; var err = mConfiguration.Device.CreateBuffer(vertexBufferInfo, null, out stagingBuffers.vertices.buffer); Debug.Assert(err == Result.SUCCESS); mConfiguration.Device.GetBufferMemoryRequirements(stagingBuffers.vertices.buffer, out MgMemoryRequirements memReqs); var isValid = mConfiguration.Partition.GetMemoryType(memReqs.MemoryTypeBits, MgMemoryPropertyFlagBits.HOST_VISIBLE_BIT | MgMemoryPropertyFlagBits.HOST_COHERENT_BIT, out uint typeIndex); Debug.Assert(isValid); MgMemoryAllocateInfo memAlloc = new MgMemoryAllocateInfo { AllocationSize = memReqs.Size, MemoryTypeIndex = typeIndex, }; err = mConfiguration.Device.AllocateMemory(memAlloc, null, out stagingBuffers.vertices.memory); Debug.Assert(err == Result.SUCCESS); // Map and copy err = stagingBuffers.vertices.memory.MapMemory(mConfiguration.Device, 0, memAlloc.AllocationSize, 0, out IntPtr data); Debug.Assert(err == Result.SUCCESS); var offset = 0; foreach (var vertex in vertexBuffer) { IntPtr dest = IntPtr.Add(data, offset); Marshal.StructureToPtr(vertex, dest, false); offset += structSize; } stagingBuffers.vertices.memory.UnmapMemory(mConfiguration.Device); stagingBuffers.vertices.buffer.BindBufferMemory(mConfiguration.Device, stagingBuffers.vertices.memory, 0); Debug.Assert(err == Result.SUCCESS); } { var vertexBufferInfo = new MgBufferCreateInfo { Size = vertexBufferSize, Usage = MgBufferUsageFlagBits.VERTEX_BUFFER_BIT | MgBufferUsageFlagBits.TRANSFER_DST_BIT, }; var err = mConfiguration.Device.CreateBuffer(vertexBufferInfo, null, out vertices.buffer); Debug.Assert(err == Result.SUCCESS); mConfiguration.Device.GetBufferMemoryRequirements(vertices.buffer, out MgMemoryRequirements memReqs); var isValid = mConfiguration.Partition.GetMemoryType(memReqs.MemoryTypeBits, MgMemoryPropertyFlagBits.DEVICE_LOCAL_BIT, out uint typeIndex); Debug.Assert(isValid); var memAlloc = new MgMemoryAllocateInfo { AllocationSize = memReqs.Size, MemoryTypeIndex = typeIndex, }; err = mConfiguration.Device.AllocateMemory(memAlloc, null, out vertices.memory); Debug.Assert(err == Result.SUCCESS); err = vertices.buffer.BindBufferMemory(mConfiguration.Device, vertices.memory, 0); Debug.Assert(err == Result.SUCCESS); } { var indexbufferInfo = new MgBufferCreateInfo { Size = indexBufferSize, Usage = MgBufferUsageFlagBits.TRANSFER_SRC_BIT, }; var err = mConfiguration.Device.CreateBuffer(indexbufferInfo, null, out stagingBuffers.indices.buffer); Debug.Assert(err == Result.SUCCESS); mConfiguration.Device.GetBufferMemoryRequirements(stagingBuffers.indices.buffer, out MgMemoryRequirements memReqs); var isValid = mConfiguration.Partition.GetMemoryType(memReqs.MemoryTypeBits, MgMemoryPropertyFlagBits.HOST_VISIBLE_BIT | MgMemoryPropertyFlagBits.HOST_COHERENT_BIT, out uint typeIndex); Debug.Assert(isValid); var memAlloc = new MgMemoryAllocateInfo { AllocationSize = memReqs.Size, MemoryTypeIndex = typeIndex, }; err = mConfiguration.Device.AllocateMemory(memAlloc, null, out stagingBuffers.indices.memory); Debug.Assert(err == Result.SUCCESS); err = stagingBuffers.indices.memory.MapMemory(mConfiguration.Device, 0, indexBufferSize, 0, out IntPtr data); Debug.Assert(err == Result.SUCCESS); var uintBuffer = new byte[indexBufferSize]; var bufferSize = (int)indexBufferSize; Buffer.BlockCopy(indexBuffer, 0, uintBuffer, 0, bufferSize); Marshal.Copy(uintBuffer, 0, data, bufferSize); stagingBuffers.indices.memory.UnmapMemory(mConfiguration.Device); err = stagingBuffers.indices.buffer.BindBufferMemory(mConfiguration.Device, stagingBuffers.indices.memory, 0); Debug.Assert(err == Result.SUCCESS); } { var indexbufferInfo = new MgBufferCreateInfo { Size = indexBufferSize, Usage = MgBufferUsageFlagBits.INDEX_BUFFER_BIT | MgBufferUsageFlagBits.TRANSFER_DST_BIT, }; var err = mConfiguration.Device.CreateBuffer(indexbufferInfo, null, out indices.buffer); Debug.Assert(err == Result.SUCCESS); mConfiguration.Device.GetBufferMemoryRequirements(indices.buffer, out MgMemoryRequirements memReqs); var isValid = mConfiguration.Partition.GetMemoryType(memReqs.MemoryTypeBits, MgMemoryPropertyFlagBits.DEVICE_LOCAL_BIT, out uint typeIndex); Debug.Assert(isValid); var memAlloc = new MgMemoryAllocateInfo { AllocationSize = memReqs.Size, MemoryTypeIndex = typeIndex, }; err = mConfiguration.Device.AllocateMemory(memAlloc, null, out indices.memory); Debug.Assert(err == Result.SUCCESS); err = indices.buffer.BindBufferMemory(mConfiguration.Device, indices.memory, 0); Debug.Assert(err == Result.SUCCESS); } { var cmdBufferBeginInfo = new MgCommandBufferBeginInfo { }; IMgCommandBuffer copyCmd = getCommandBuffer(true); copyCmd.CmdCopyBuffer( stagingBuffers.vertices.buffer, vertices.buffer, new[] { new MgBufferCopy { Size = vertexBufferSize, } } ); copyCmd.CmdCopyBuffer(stagingBuffers.indices.buffer, indices.buffer, new[] { new MgBufferCopy { Size = indexBufferSize, } }); flushCommandBuffer(copyCmd); stagingBuffers.vertices.buffer.DestroyBuffer(mConfiguration.Device, null); stagingBuffers.vertices.memory.FreeMemory(mConfiguration.Device, null); stagingBuffers.indices.buffer.DestroyBuffer(mConfiguration.Device, null); stagingBuffers.indices.memory.FreeMemory(mConfiguration.Device, null); } const uint VERTEX_BUFFER_BIND_ID = 0; vertices.inputBinding = new MgVertexInputBindingDescription { Binding = VERTEX_BUFFER_BIND_ID, Stride = (uint)structSize, InputRate = MgVertexInputRate.VERTEX, }; var vertexSize = (uint)Marshal.SizeOf(typeof(Vector3)); vertices.inputAttributes = new MgVertexInputAttributeDescription[] { new MgVertexInputAttributeDescription { Binding = VERTEX_BUFFER_BIND_ID, Location = 0, Format = MgFormat.R32G32B32_SFLOAT, Offset = 0, }, new MgVertexInputAttributeDescription { Binding = VERTEX_BUFFER_BIND_ID, Location = 1, Format = MgFormat.R32G32B32_SFLOAT, Offset = vertexSize, } }; vertices.inputState = new MgPipelineVertexInputStateCreateInfo { VertexBindingDescriptions = new MgVertexInputBindingDescription[] { vertices.inputBinding, }, VertexAttributeDescriptions = vertices.inputAttributes, }; }
public IGLDeviceMemory CreateDeviceMemory(MgMemoryAllocateInfo createInfo) { return(new GLDeviceMemory(createInfo, mErrHandler)); }
// Allocate one region of memory for the uniform buffer private void InitializeUniforms() { MgBufferCreateInfo pCreateInfo = new MgBufferCreateInfo { Usage = MgBufferUsageFlagBits.UNIFORM_BUFFER_BIT, Size = MaxBytesPerFrame, }; IMgBuffer buffer; var err = mConfiguration.Device.CreateBuffer(pCreateInfo, null, out buffer); Debug.Assert(err == Result.SUCCESS); //dynamicConstantBuffer = device.CreateBuffer(MaxBytesPerFrame, (MTLResourceOptions)0); //dynamicConstantBuffer.Label = "UniformBuffer"; MgMemoryRequirements uniformsMemReqs; mConfiguration.Device.GetBufferMemoryRequirements(buffer, out uniformsMemReqs); const MgMemoryPropertyFlagBits uniformPropertyFlags = MgMemoryPropertyFlagBits.HOST_COHERENT_BIT; uint uniformMemoryTypeIndex; mConfiguration.Partition.GetMemoryType( uniformsMemReqs.MemoryTypeBits, uniformPropertyFlags, out uniformMemoryTypeIndex); var uniformMemAlloc = new MgMemoryAllocateInfo { MemoryTypeIndex = uniformMemoryTypeIndex, AllocationSize = uniformsMemReqs.Size, }; IMgDeviceMemory deviceMemory; var result = mConfiguration.Device.AllocateMemory(uniformMemAlloc, null, out deviceMemory); Debug.Assert(result == Result.SUCCESS); buffer.BindBufferMemory(mConfiguration.Device, deviceMemory, 0); mUniforms = new BufferInfo { Buffer = buffer, DeviceMemory = deviceMemory, Offset = 0, Length = MaxBytesPerFrame, }; IMgDescriptorSetLayout pSetLayout; var dslCreateInfo = new MgDescriptorSetLayoutCreateInfo { Bindings = new MgDescriptorSetLayoutBinding[] { new MgDescriptorSetLayoutBinding { Binding = 0, DescriptorCount = 1, DescriptorType = MgDescriptorType.UNIFORM_BUFFER_DYNAMIC, StageFlags = MgShaderStageFlagBits.VERTEX_BIT, }, }, }; err = mConfiguration.Device.CreateDescriptorSetLayout(dslCreateInfo, null, out pSetLayout); var poolCreateInfo = new Magnesium.MgDescriptorPoolCreateInfo { MaxSets = 1, PoolSizes = new MgDescriptorPoolSize[] { new MgDescriptorPoolSize { DescriptorCount = 1, Type = MgDescriptorType.COMBINED_IMAGE_SAMPLER, }, }, }; err = mConfiguration.Device.CreateDescriptorPool(poolCreateInfo, null, out mDescriptorPool); IMgDescriptorSet[] dSets; MgDescriptorSetAllocateInfo pAllocateInfo = new MgDescriptorSetAllocateInfo { DescriptorPool = mDescriptorPool, DescriptorSetCount = 1, SetLayouts = new IMgDescriptorSetLayout[] { pSetLayout, }, }; mConfiguration.Device.AllocateDescriptorSets(pAllocateInfo, out dSets); mUniformDescriptorSet = dSets[0]; MgWriteDescriptorSet[] writes = new MgWriteDescriptorSet[] { new MgWriteDescriptorSet { DescriptorCount = 1, DescriptorType = MgDescriptorType.UNIFORM_BUFFER_DYNAMIC, DstSet = mUniformDescriptorSet, BufferInfo = new MgDescriptorBufferInfo[] { new MgDescriptorBufferInfo { Buffer = mUniforms.Buffer, Offset = mUniforms.Offset, Range = mUniforms.Length, }, }, DstBinding = 0, } }; mConfiguration.Device.UpdateDescriptorSets(writes, null); mSetLayout = pSetLayout; }
void InitializeMesh() { // Generate meshes // Mg : Buffer var indicesInBytes = (ulong)(sizeof(uint) * indicesVboData.Length); var vertexStride = Marshal.SizeOf(typeof(Vector3)); var verticesInBytes = (ulong)(vertexStride * positionVboData.Length); var bufferSize = indicesInBytes + verticesInBytes; var bufferCreateInfo = new MgBufferCreateInfo { Usage = MgBufferUsageFlagBits.INDEX_BUFFER_BIT | MgBufferUsageFlagBits.VERTEX_BUFFER_BIT, Size = bufferSize, }; var device = mConfiguration.Device; var result = device.CreateBuffer(bufferCreateInfo, null, out mBuffer); Debug.Assert(result == Result.SUCCESS); MgMemoryRequirements memReqs; device.GetBufferMemoryRequirements(mBuffer, out memReqs); const MgMemoryPropertyFlagBits memoryPropertyFlags = MgMemoryPropertyFlagBits.HOST_COHERENT_BIT; uint memoryTypeIndex; mConfiguration.Partition.GetMemoryType( memReqs.MemoryTypeBits, memoryPropertyFlags, out memoryTypeIndex); var memAlloc = new MgMemoryAllocateInfo { MemoryTypeIndex = memoryTypeIndex, AllocationSize = memReqs.Size, }; result = device.AllocateMemory(memAlloc, null, out mDeviceMemory); Debug.Assert(result == Result.SUCCESS); mBuffer.BindBufferMemory(device, mDeviceMemory, 0); // COPY INDEX DATA IntPtr dest; result = mDeviceMemory.MapMemory(device, 0, bufferSize, 0, out dest); Debug.Assert(result == Result.SUCCESS); var tempIndices = new byte[indicesInBytes]; Buffer.BlockCopy(indicesVboData, 0, tempIndices, 0, (int)indicesInBytes); Marshal.Copy(tempIndices, 0, dest, (int)indicesInBytes); // COPY VERTEX DATA var vertexOffset = indicesInBytes; // Copy the struct to unmanaged memory. int offset = (int)vertexOffset; for (int i = 0; i < positionVboData.Length; ++i) { IntPtr localDest = IntPtr.Add(dest, offset); Marshal.StructureToPtr(positionVboData[i], localDest, false); offset += vertexStride; } mDeviceMemory.UnmapMemory(device); mIndices = new BufferInfo { Buffer = mBuffer, DeviceMemory = mDeviceMemory, Offset = 0, Length = indicesInBytes, }; mVertices = new BufferInfo { Buffer = mBuffer, DeviceMemory = mDeviceMemory, Offset = indicesInBytes, Length = verticesInBytes, }; }