protected unsafe DeviceMemory AllocateMemory(MemoryPropertyFlags memoryProperties, MemoryRequirements memoryRequirements) { var allocateInfo = new MemoryAllocateInfo { StructureType = StructureType.MemoryAllocateInfo, AllocationSize = memoryRequirements.Size, }; PhysicalDeviceMemoryProperties physicalDeviceMemoryProperties; physicalDevice.GetMemoryProperties(out physicalDeviceMemoryProperties); var typeBits = memoryRequirements.MemoryTypeBits; for (uint i = 0; i < physicalDeviceMemoryProperties.MemoryTypeCount; i++) { if ((typeBits & 1) == 1) { // Type is available, does it match user properties? var memoryType = *((MemoryType *)&physicalDeviceMemoryProperties.MemoryTypes + i); if ((memoryType.PropertyFlags & memoryProperties) == memoryProperties) { allocateInfo.MemoryTypeIndex = i; break; } } typeBits >>= 1; } return(device.AllocateMemory(ref allocateInfo)); }
protected unsafe void AllocateMemory(MemoryPropertyFlags memoryProperties, MemoryRequirements memoryRequirements) { if (NativeMemory != DeviceMemory.Null) return; if (memoryRequirements.Size == 0) return; var allocateInfo = new MemoryAllocateInfo { StructureType = StructureType.MemoryAllocateInfo, AllocationSize = memoryRequirements.Size, }; PhysicalDeviceMemoryProperties physicalDeviceMemoryProperties; GraphicsDevice.NativePhysicalDevice.GetMemoryProperties(out physicalDeviceMemoryProperties); var typeBits = memoryRequirements.MemoryTypeBits; for (uint i = 0; i < physicalDeviceMemoryProperties.MemoryTypeCount; i++) { if ((typeBits & 1) == 1) { // Type is available, does it match user properties? var memoryType = *((MemoryType*)&physicalDeviceMemoryProperties.MemoryTypes + i); if ((memoryType.PropertyFlags & memoryProperties) == memoryProperties) { allocateInfo.MemoryTypeIndex = i; break; } } typeBits >>= 1; } NativeMemory = GraphicsDevice.NativeDevice.AllocateMemory(ref allocateInfo); }
public MemoryType ( MemoryPropertyFlags propertyFlags = default, uint heapIndex = default ) { PropertyFlags = propertyFlags; HeapIndex = heapIndex; }
public MemoryAllocation AllocateDeviceMemory( PhysicalDevice physicalDevice, MemoryRequirements requirements, MemoryPropertyFlags flags = 0) { int memoryTypeIndex = FindSuitableMemoryTypeIndex(_api, physicalDevice, requirements.MemoryTypeBits, flags); if (memoryTypeIndex < 0) { return(default);
private void CreateBuffer(ulong size, BufferUsageFlags usage, MemoryPropertyFlags properties, out Buffer buffer, out DeviceMemory bufferMemory) { buffer = device.CreateBuffer(size, usage, SharingMode.Exclusive, null); var memRequirements = buffer.GetMemoryRequirements(); bufferMemory = device.AllocateMemory(memRequirements.Size, FindMemoryType(memRequirements.MemoryTypeBits, properties)); buffer.BindMemory(bufferMemory, 0); }
uint FindMemoryIndex(MemoryPropertyFlags propertyFlags) { for (uint x = 0; x < VulkanConstant.MaxMemoryTypes; x++) { if ((physDeviceMem.MemoryTypes[x].PropertyFlags & propertyFlags) == propertyFlags) { return(x); } } throw new InvalidOperationException(); }
internal uint FindMemoryTypeIndex(uint typeFilter, MemoryPropertyFlags properties) { for (uint i = 0; i < _physicalDeviceMemoryProperties.MemoryTypeCount; i++) { if (((typeFilter & 1) == 1) & ((_physicalDeviceMemoryProperties.MemoryTypes[(int)i].PropertyFlags & properties) == properties)) { return(i); } } throw new MissingMemberException("No compatible memory type found!"); }
protected virtual uint FindMemoryType(uint typeFilter, MemoryPropertyFlags properties) { var memProperties = data.physicalDevice.GetMemoryProperties(); for (uint i = 0; i < memProperties.MemoryTypeCount; i++) { if (((typeFilter >> (int)i) & 1) == 1 && (memProperties.MemoryTypes[i].PropertyFlags & properties) == properties) { return(i); } } throw new Exception("Unable to find suiable memory type"); }
private uint FindMemoryType(uint typeFilter, MemoryPropertyFlags propertyFlags) { _api.Vk.GetPhysicalDeviceMemoryProperties(_api.Device.PhysicalDevice, out var memProperties); for (int i = 0; i != memProperties.MemoryTypeCount; i++) { if ((typeFilter & (1 << i)) != 0 && (memProperties.MemoryTypes[i].PropertyFlags & propertyFlags) == propertyFlags) { return((uint)i); } } throw new Exception($"{nameof(DeviceMemory)}: Unable to find suitable memory type."); }
private uint FindMemoryType(uint typeFilter, MemoryPropertyFlags properties) { var memProperties = vkPhysicalDevice.GetMemoryProperties(); for (var i = 0; i < memProperties.MemoryTypeCount; ++i) { if ((typeFilter & (1 << i)) != 0 && (memProperties.MemoryTypes[i].PropertyFlags & properties) != 0) { return((uint)i); } } throw new InvalidOperationException("Failed to find suitable memory type"); }
private uint FindMemoryType(uint typeFilter, MemoryPropertyFlags flags) { var memoryProperties = this.physicalDevice.GetMemoryProperties(); for (int i = 0; i < memoryProperties.MemoryTypes.Length; i++) { if ((typeFilter & (1u << i)) > 0 && memoryProperties.MemoryTypes[i].PropertyFlags.HasFlag(flags)) { return((uint)i); } } throw new Exception("No compatible memory type."); }
internal static int FindSuitableMemoryTypeIndex(VulkanPhysicalDevice physicalDevice, uint memoryTypeBits, MemoryPropertyFlags flags) { physicalDevice.Api.GetPhysicalDeviceMemoryProperties(physicalDevice.InternalHandle, out var properties); for (var i = 0; i < properties.MemoryTypeCount; i++) { var type = properties.MemoryTypes[i]; if ((memoryTypeBits & (1 << i)) != 0 && type.PropertyFlags.HasFlag(flags)) { return(i); } } return(-1); }
internal uint GetMemoryIndexFromProperty(uint memoryTypeBits, MemoryPropertyFlags deviceLocal) { var memoryProperties = this.GetMemoryProperties();//TODO: call once? bool heapIndexSet = false; var memoryTypes = memoryProperties.MemoryTypes; for (uint i = 0; i < memoryProperties.MemoryTypeCount; i++) { if (((memoryTypeBits >> (int)i) & 1) == 1 && (memoryTypes[i].PropertyFlags & deviceLocal) == deviceLocal) { return(i); } } return(memoryProperties.MemoryTypes[0].HeapIndex); }
public AllocationCreateInfo(AllocationCreateFlags flags = default, AllocationStrategyFlags strategy = default, MemoryUsage usage = default, MemoryPropertyFlags requiredFlags = default, MemoryPropertyFlags preferredFlags = default, uint memoryTypeBits = 0, VulkanMemoryPool?pool = null, object?userData = null) { Flags = flags; Strategy = strategy; Usage = usage; RequiredFlags = requiredFlags; PreferredFlags = preferredFlags; MemoryTypeBits = memoryTypeBits; Pool = pool; UserData = userData; }
public unsafe static DeviceMemory AllocateDeviceMemory( Vk vk, Device device, PhysicalDevice physicalDevice, MemoryRequirements requirements, out long size, MemoryPropertyFlags flags = 0, bool isExternal = false) { _vk = vk; size = 0; int memoryTypeIndex = FindSuitableMemoryTypeIndex(physicalDevice, requirements.MemoryTypeBits, flags); if (memoryTypeIndex < 0) { return(default);
static uint FindMemoryType(PhysicalDevice physicalDevice, uint typeFilter, MemoryPropertyFlags propertyFlags) { var memProperties = physicalDevice.GetMemoryProperties(); uint i = 0; foreach (var memType in memProperties.MemoryTypes) { if ((((typeFilter >> (int)i) & 1) == 1) && ((memType.PropertyFlags & propertyFlags) == propertyFlags)) { return(i); } i++; } MGlobal.displayError("failed to find memory type"); throw new Exception("failed to find memory type"); }
private void CreateBuffer(ulong size, BufferUsageFlags usage, MemoryPropertyFlags properties, out Buffer buffer, out DeviceMemory bufferMemory) { buffer = device.CreateBuffer(new BufferCreateInfo { Size = size, Usage = usage, SharingMode = SharingMode.Exclusive }); var memRequirements = buffer.GetMemoryRequirements(); bufferMemory = device.AllocateMemory(new MemoryAllocateInfo { AllocationSize = memRequirements.Size, MemoryTypeIndex = FindMemoryType(memRequirements.MemoryTypeBits, properties) }); buffer.BindMemory(bufferMemory, 0); }
protected unsafe void AllocateMemory(MemoryPropertyFlags memoryProperties) { MemoryRequirements memoryRequirements; NativeDevice.GetBufferMemoryRequirements(nativeUploadBuffer, out memoryRequirements); if (memoryRequirements.Size == 0) { return; } var allocateInfo = new MemoryAllocateInfo { StructureType = StructureType.MemoryAllocateInfo, AllocationSize = memoryRequirements.Size, }; PhysicalDeviceMemoryProperties physicalDeviceMemoryProperties; NativePhysicalDevice.GetMemoryProperties(out physicalDeviceMemoryProperties); var typeBits = memoryRequirements.MemoryTypeBits; for (uint i = 0; i < physicalDeviceMemoryProperties.MemoryTypeCount; i++) { if ((typeBits & 1) == 1) { // Type is available, does it match user properties? var memoryType = *((MemoryType *)&physicalDeviceMemoryProperties.MemoryTypes + i); if ((memoryType.PropertyFlags & memoryProperties) == memoryProperties) { allocateInfo.MemoryTypeIndex = i; break; } } typeBits >>= 1; } nativeUploadBufferMemory = NativeDevice.AllocateMemory(ref allocateInfo); NativeDevice.BindBufferMemory(nativeUploadBuffer, nativeUploadBufferMemory, 0); }
private uint MemoryTypeFromProperties(uint typeBits, MemoryPropertyFlags memoryProperties) { PhysicalDeviceMemoryProperties physicalDeviceMemoryProperties; physicalDevice.GetMemoryProperties(out physicalDeviceMemoryProperties); for (uint i = 0; i < physicalDeviceMemoryProperties.MemoryTypeCount; i++) { if ((typeBits & 1) == 1) { // Type is available, does it match user properties? var memoryType = *((MemoryType *)&physicalDeviceMemoryProperties.MemoryTypes + i); if ((memoryType.PropertyFlags & memoryProperties) == memoryProperties) { return(i); } } typeBits >>= 1; } throw new InvalidOperationException(); }
public static uint GetMemoryTypeIndex(uint memoryTypeBits, MemoryPropertyFlags desiredMemoryFlags) { uint memoryTypeIndex = 0; PhysicalDeviceMemoryProperties physicalDeviceMemoryProperties = VContext.Instance.physicalDevice.GetMemoryProperties(); for (uint i = 0; i < physicalDeviceMemoryProperties.MemoryTypeCount; i++) { if ((memoryTypeBits & 1) == 1) { MemoryType memoryType = physicalDeviceMemoryProperties.MemoryTypes[i]; if ((memoryType.PropertyFlags & desiredMemoryFlags) == desiredMemoryFlags) { memoryTypeIndex = i; break; } } memoryTypeBits >>= 1; } return(memoryTypeIndex); }
private void CreateBuffer(DeviceSize size, BufferUsageFlags usageFlags, MemoryPropertyFlags properties, out Vulkan.Buffer buffer, out DeviceMemory bufferMemory) { var bufferInfo = new BufferCreateInfo() { Size = size, Usage = usageFlags, SharingMode = SharingMode.Exclusive, }; buffer = vkDevice.CreateBuffer(bufferInfo); var memRequirements = vkDevice.GetBufferMemoryRequirements(buffer); var allocInfo = new MemoryAllocateInfo() { AllocationSize = memRequirements.Size, MemoryTypeIndex = FindMemoryType(memRequirements.MemoryTypeBits, properties), }; bufferMemory = vkDevice.AllocateMemory(allocInfo); vkDevice.BindBufferMemory(buffer, bufferMemory, 0); }
private void CreateImage(uint width, uint height, Format format, ImageTiling imageTiling, ImageUsageFlags usage, MemoryPropertyFlags properties, out Image image, out DeviceMemory imageMemory) { image = this.device.CreateImage(new ImageCreateInfo { ImageType = ImageType.Image2d, Extent = new Extent3D { Width = width, Height = height, Depth = 1 }, ArrayLayers = 1, MipLevels = 1, Format = format, Tiling = imageTiling, InitialLayout = ImageLayout.Preinitialized, Usage = usage, SharingMode = SharingMode.Exclusive, Samples = SampleCountFlags.SampleCount1, Flags = ImageCreateFlags.None }); var memoryRequirements = image.GetMemoryRequirements(); imageMemory = this.device.AllocateMemory(new MemoryAllocateInfo { AllocationSize = memoryRequirements.Size, MemoryTypeIndex = this.FindMemoryType(memoryRequirements.MemoryTypeBits, properties) }); image.BindMemory(imageMemory, 0); }
public unsafe DeviceMemory(Api api, ulong size, uint memoryTypeBits, MemoryAllocateFlags allocateFlags, MemoryPropertyFlags propertyFlags) { _api = api; var flagsInfo = new MemoryAllocateFlagsInfo(); flagsInfo.SType = StructureType.MemoryAllocateFlagsInfo; flagsInfo.PNext = null; flagsInfo.Flags = allocateFlags; var allocInfo = new MemoryAllocateInfo(); allocInfo.SType = StructureType.MemoryAllocateInfo; allocInfo.PNext = &flagsInfo; allocInfo.AllocationSize = size; allocInfo.MemoryTypeIndex = FindMemoryType(memoryTypeBits, propertyFlags); Util.Verify(_api.Vk.AllocateMemory(_api.Device.VkDevice, allocInfo, null, out _vkDeviceMemory), $"{nameof(DeviceMemory)}: Unable to allocate memory."); }
private uint MemoryTypeFromProperties(uint typeBits, MemoryPropertyFlags memoryProperties) { PhysicalDeviceMemoryProperties physicalDeviceMemoryProperties; physicalDevice.GetMemoryProperties(out physicalDeviceMemoryProperties); for (uint i = 0; i < physicalDeviceMemoryProperties.MemoryTypeCount; i++) { if ((typeBits & 1) == 1) { // Type is available, does it match user properties? var memoryType = *((MemoryType*)&physicalDeviceMemoryProperties.MemoryTypes + i); if ((memoryType.PropertyFlags & memoryProperties) == memoryProperties) { return i; } } typeBits >>= 1; } throw new InvalidOperationException(); }
private void CreateImage(uint width, uint height, Format format, ImageTiling imageTiling, ImageUsageFlags usage, MemoryPropertyFlags properties, bool isPreinitialized, out Image image, out DeviceMemory imageMemory, out DeviceSize memoryOffset, out DeviceSize memorySize) { image = this.device.CreateImage(ImageType.Image2d, format, new Extent3D(width, height, 1), 1, 1, SampleCountFlags.SampleCount1, imageTiling, usage, this.queueIndices.Indices.Count() == 1 ? SharingMode.Exclusive : SharingMode.Concurrent, this.queueIndices.Indices.ToArray(), isPreinitialized ? ImageLayout.Preinitialized : ImageLayout.Undefined); var memoryRequirements = image.GetMemoryRequirements(); memorySize = memoryRequirements.Size; imageMemory = this.device.AllocateMemory(memorySize, this.FindMemoryType(memoryRequirements.MemoryTypeBits, properties)); memoryOffset = 0; image.BindMemory(imageMemory, memoryOffset); }
public VulkanBuffer CreateBuffer <T>(int count, BufferUsageFlags usage, MemoryPropertyFlags properties) { return(this.CreateBuffer((uint)(Marshal.SizeOf <T>() * count), usage, properties)); }
public VulkanBuffer CreateBuffer(ulong size, BufferUsageFlags usage, MemoryPropertyFlags properties) { this.CreateBuffer(size, usage, properties, out var buffer, out var _, out DeviceSize _); return(new VulkanBuffer(this, buffer, size)); }
public VulkanImage CreateImage(uint width, uint height, Format format, ImageTiling imageTiling, ImageUsageFlags usage, MemoryPropertyFlags properties, bool isPreinitialized) { this.CreateImage(width, height, format, imageTiling, usage, properties, isPreinitialized, out var image, out var imageMemory, out DeviceSize offset, out DeviceSize size); return(new VulkanImage(this, image, imageMemory, offset, size, format)); }
/// <summary> /// /// </summary> public MemoryType(MemoryPropertyFlags propertyFlags, uint heapIndex) { this.PropertyFlags = propertyFlags; this.HeapIndex = heapIndex; }
public VulkanImage CreateImage(uint width, uint height, Format format, ImageTiling imageTiling, ImageUsageFlags usage, MemoryPropertyFlags properties) { this.CreateImage(width, height, format, imageTiling, usage, properties, out var image, out var memory); return(new VulkanImage(this, image, memory, format)); }