public VkResult createBuffer(VkBufferUsageFlagBits usageFlags, VkMemoryPropertyFlagBits memoryPropertyFlags, ulong size, out VkBuffer buffer, out VkDeviceMemory memory, void *data = null)
{
VkBuffer b;
VkDeviceMemory dm;
VkResult result = createBuffer(usageFlags, memoryPropertyFlags, size, &b, &dm, data);
buffer = b;
memory = dm;
return(result);
}
/**
* Create a buffer on the device
*
* @param usageFlags Usage flag bitmask for the buffer (i.e. index, vertex, uniform buffer)
* @param memoryPropertyFlags Memory properties for this buffer (i.e. device local, host visible, coherent)
* @param buffer Pointer to a vk::Vulkan buffer object
* @param size Size of the buffer in byes
* @param data Pointer to the data that should be copied to the buffer after creation (optional, if not set, no data is copied over)
*
* @return Success if buffer handle and memory have been created and (optionally passed) data has been copied
*/
public VkResult createBuffer(VkBufferUsageFlagBits usageFlags, VkMemoryPropertyFlagBits memoryPropertyFlags, vksBuffer buffer, ulong size, void *data = null)
{
buffer.device = _logicalDevice;
// Create the buffer handle
VkBufferCreateInfo bufferCreateInfo = new VkBufferCreateInfo();
bufferCreateInfo.sType = BufferCreateInfo;
bufferCreateInfo.usage = usageFlags;
bufferCreateInfo.size = size;
{
VkBuffer vkBuffer;
vkCreateBuffer(_logicalDevice, &bufferCreateInfo, null, &vkBuffer);
buffer.buffer = vkBuffer;
}
// Create the memory backing up the buffer handle
VkMemoryRequirements memReqs;
VkMemoryAllocateInfo memAlloc = new VkMemoryAllocateInfo();
memAlloc.sType = MemoryAllocateInfo;
vkGetBufferMemoryRequirements(_logicalDevice, buffer.buffer, &memReqs);
memAlloc.allocationSize = memReqs.size;
// Find a memory type index that fits the properties of the buffer
memAlloc.memoryTypeIndex = getMemoryType(memReqs.memoryTypeBits, memoryPropertyFlags);
{
VkDeviceMemory memory;
vkAllocateMemory(_logicalDevice, &memAlloc, null, &memory);
buffer.memory = memory;
}
buffer.alignment = memReqs.alignment;
buffer.size = memAlloc.allocationSize;
buffer.usageFlags = usageFlags;
buffer.memoryPropertyFlags = memoryPropertyFlags;
// If a pointer to the buffer data has been passed, map the buffer and copy over the data
if (data != null)
{
buffer.map();
Unsafe.CopyBlock(buffer.mapped, data, (uint)size);
buffer.unmap();
}
// Initialize a default descriptor that covers the whole buffer size
buffer.setupDescriptor();
// Attach the memory to the buffer object
return(buffer.bind());
}
/**
* Create a buffer on the device
*
* @param usageFlags Usage flag bitmask for the buffer (i.e. index, vertex, uniform buffer)
* @param memoryPropertyFlags Memory properties for this buffer (i.e. device local, host visible, coherent)
* @param size Size of the buffer in byes
* @param buffer Pointer to the buffer handle acquired by the function
* @param memory Pointer to the memory handle acquired by the function
* @param data Pointer to the data that should be copied to the buffer after creation (optional, if not set, no data is copied over)
*
* @return Success if buffer handle and memory have been created and (optionally passed) data has been copied
*/
public VkResult createBuffer(VkBufferUsageFlagBits usageFlags, VkMemoryPropertyFlagBits memoryPropertyFlags, ulong size, VkBuffer *buffer, VkDeviceMemory *memory, void *data = null)
{
// Create the buffer handle
VkBufferCreateInfo bufferCreateInfo = new VkBufferCreateInfo();
bufferCreateInfo.sType = BufferCreateInfo;
bufferCreateInfo.usage = usageFlags;
bufferCreateInfo.size = size;
bufferCreateInfo.sharingMode = VkSharingMode.Exclusive;
vkCreateBuffer(LogicalDevice, &bufferCreateInfo, null, buffer);
// Create the memory backing up the buffer handle
VkMemoryRequirements memReqs;
VkMemoryAllocateInfo memAlloc = new VkMemoryAllocateInfo();
memAlloc.sType = MemoryAllocateInfo;
vkGetBufferMemoryRequirements(LogicalDevice, *buffer, &memReqs);
memAlloc.allocationSize = memReqs.size;
// Find a memory type index that fits the properties of the buffer
memAlloc.memoryTypeIndex = getMemoryType(memReqs.memoryTypeBits, memoryPropertyFlags);
vkAllocateMemory(LogicalDevice, &memAlloc, null, memory);
// If a pointer to the buffer data has been passed, map the buffer and copy over the data
if (data != null)
{
IntPtr mapped;
vkMapMemory(LogicalDevice, *memory, 0, size, 0, &mapped);
Unsafe.CopyBlock(mapped, data, (uint)size);
// If host coherency hasn't been requested, do a manual flush to make writes visible
if ((memoryPropertyFlags & VkMemoryPropertyFlagBits.HostCoherent) == 0)
{
VkMappedMemoryRange mappedRange = new VkMappedMemoryRange();
mappedRange.memory = *memory;
mappedRange.offset = 0;
mappedRange.size = size;
vkFlushMappedMemoryRanges(LogicalDevice, 1, &mappedRange);
}
vkUnmapMemory(LogicalDevice, *memory);
}
// Attach the memory to the buffer object
vkBindBufferMemory(LogicalDevice, *buffer, *memory, 0);
return(VkResult.Success);
}
VkBuffer CreateBuffer(VkPhysicalDevice physicalDevice, VkDevice device, object values, VkBufferUsageFlagBits usageFlags, System.Type type)
{
var array = values as System.Array;
var length = (array != null) ? array.Length : 1;
var size = System.Runtime.InteropServices.Marshal.SizeOf(type) * length;
VkBuffer buffer;
{
UInt32 index = 0;
var info = new VkBufferCreateInfo {
sType = VkStructureType.BufferCreateInfo
};
info.size = (UInt64)size;
info.usage = usageFlags;
info.sharingMode = VkSharingMode.Exclusive;
info.queueFamilyIndices = index;
//VkBuffer buffer = device.CreateBuffer(ref info);
vkAPI.vkCreateBuffer(device, &info, null, &buffer).Check();
info.Free();
}
VkDeviceMemory deviceMemory; // = device.AllocateMemory(ref allocInfo);
VkMemoryRequirements memoryReq;
//VkMemoryRequirements memoryReq = device.GetBufferMemoryRequirements(buffer);
vkAPI.vkGetBufferMemoryRequirements(device, buffer, &memoryReq);
var allocInfo = new VkMemoryAllocateInfo {
sType = VkStructureType.MemoryAllocateInfo
};
{
allocInfo.allocationSize = memoryReq.size;
VkPhysicalDeviceMemoryProperties memoryProperties;
vkAPI.vkGetPhysicalDeviceMemoryProperties(physicalDevice, &memoryProperties);
allocInfo.memoryTypeIndex = GetMemoryTypeIndex(memoryProperties, memoryReq,
VkMemoryPropertyFlagBits.HostVisible | VkMemoryPropertyFlagBits.HostCoherent);
vkAPI.vkAllocateMemory(device, &allocInfo, null, &deviceMemory).Check();
}
{
IntPtr memPtr = IntPtr.Zero;
vkAPI.vkMapMemory(device, deviceMemory, 0, (UInt64)size, 0, &memPtr).Check();
if (type == typeof(float))
{
System.Runtime.InteropServices.Marshal.Copy(values as float[], 0, memPtr, length);
}
else if (type == typeof(short))
{
System.Runtime.InteropServices.Marshal.Copy(values as short[], 0, memPtr, length);
}
else if (type == typeof(AreaUniformBuffer))
{
System.Runtime.InteropServices.Marshal.StructureToPtr(values, memPtr, false);
this.vkBuffer = buffer;
this.vkDeviceMemory = deviceMemory;
this.uniformSize = memoryReq.size;
}
vkAPI.vkUnmapMemory(device, deviceMemory);
}
vkAPI.vkBindBufferMemory(device, buffer, deviceMemory, 0).Check();
return(buffer);
}
public VkResult createBuffer(VkBufferUsageFlagBits usageFlags, VkMemoryPropertyFlagBits memoryPropertyFlags, vksBuffer buffer, ulong size, IntPtr data) => createBuffer(usageFlags, memoryPropertyFlags, buffer, size, data.ToPointer());
