AppGpu AppGpuInit(uint id, PhysicalDevice obj)
{
// TODO : Limits
AppGpu gpu = new AppGpu
{
Id = id,
Obj = obj,
Props = obj.GetProperties(),
QueueProps = obj.GetQueueFamilyProperties(),
MemoryProps = obj.GetMemoryProperties(),
Features = obj.GetFeatures(),
Limits = null,
};
gpu.QueueReqs = new DeviceQueueCreateInfo[gpu.QueueProps.Length];
for (uint i = 0; i < gpu.QueueProps.Length; i++)
{
uint queueCount = gpu.QueueProps[i].QueueCount;
DeviceQueueCreateInfo queueReq = new DeviceQueueCreateInfo
{
QueueFamilyIndex = i,
QueueCount = queueCount,
QueuePriorities = new float[queueCount],
};
gpu.QueueReqs[i] = queueReq;
}
gpu.Device = AppDevInit(gpu);
AppDevInitFormats(gpu.Device);
return(gpu);
}
public void CreateDevice()
{
/*
* We create the logical device in this function.
*/
/*
* When creating the device, we also specify what queues it has.
*/
// Store memory properties of the physical device.
PhysicalDeviceMemoryProperties MemoryProperties = physicalDevice.GetMemoryProperties();
PhysicalDeviceFeatures Features = physicalDevice.GetFeatures();
PhysicalDeviceProperties Properties = physicalDevice.GetProperties();
// Create a logical device.
var queueCreateInfos = new DeviceQueueCreateInfo[1];
queueCreateInfos[0] = new DeviceQueueCreateInfo(computeQueueFamilyIndex, 1, 1.0f);
var deviceCreateInfo = new DeviceCreateInfo(
queueCreateInfos,
new[] { Constant.DeviceExtension.NVExternalMemory },
Features);
device = physicalDevice.CreateDevice(deviceCreateInfo);
// Get queue(s).
queue = device.GetQueue(computeQueueFamilyIndex);
// Create command pool(s).
//commandPool = device.CreateCommandPool(new CommandPoolCreateInfo(computeQueueFamilyIndex));
}
private void PickPhysicalDevice()
{
// Currently simply picks the first physical device. We might want a smarter choice here.
PhysicalDevice = Instance.EnumeratePhysicalDevices()[0];
PhysicalDeviceFeatures = PhysicalDevice.GetFeatures();
PhysicalDeviceMemoryProperties = PhysicalDevice.GetMemoryProperties();
AvailableDeviceExtensions = PhysicalDevice.EnumerateExtensionProperties();
}
public void Write(PhysicalDevice physicalDevice)
{
WriteLine("PhysicalDeviceProperties:");
WriteLine("=========================");
var properties = physicalDevice.GetProperties();
_tabs++;
PhysicalDeviceProperties(properties);
WriteLine("PhysicalDeviceLimits:");
WriteLine("---------------------");
var limits = properties.Limits;
_tabs++;
PhysicalDeviceLimits(limits);
_tabs--;
WriteLine("PhysicalDeviceSparseProperties:");
WriteLine("-------------------------------");
var sparse = properties.SparseProperties;
_tabs++;
PhysicalDeviceSparseProperties(sparse);
_tabs = 0;
WriteLine("");
var queueFamilyProperties = physicalDevice.GetQueueFamilyProperties();
for (int x = 0; x < queueFamilyProperties.Length; x++)
{
WriteLine($"QueueFamilyProperties[{x}]:");
WriteLine("==========================");
_tabs++;
QueueFamilyProperties(queueFamilyProperties[x]);
_tabs--;
WriteLine("");
}
_tabs = 0;
WriteLine("PhysicalDeviceMemoryProperties");
WriteLine("==============================");
var physicalDeviceMemoryProperties = physicalDevice.GetMemoryProperties();
_tabs++;
PhysicalDeviceMemoryProperties(physicalDeviceMemoryProperties);
WriteLine("");
_tabs = 0;
WriteLine("PhysicalDeviceFeatures:");
WriteLine("=======================");
var features = physicalDevice.GetFeatures();
_tabs++;
PhysicalDeviceFeatures(features);
Console.WriteLine(_sb.ToString());
}
public PhysicalDeviceInfo(PhysicalDevice physicalDevice)
{
PhysicalDevice = physicalDevice;
Properties = PhysicalDevice.GetProperties();
QueueFamilyProperties = PhysicalDevice.GetQueueFamilyProperties();
MemoryProperties = PhysicalDevice.GetMemoryProperties();
Features = PhysicalDevice.GetFeatures();
GraphicsQFamilies = Array.AsReadOnly(QueueFamiliesWithFlag(QueueFlags.Graphics));
ComputeQFamilies = Array.AsReadOnly(QueueFamiliesWithFlag(QueueFlags.Compute));
TransferQFamilies = Array.AsReadOnly(QueueFamiliesWithFlag(QueueFlags.Transfer));
SparseBindingQFamilies = Array.AsReadOnly(QueueFamiliesWithFlag(QueueFlags.SparseBinding));
}
public static bool SupportsFeatures(this PhysicalDevice @this, PhysicalDeviceFeatures desiredFeatures)
{
var deviceFeatures = @this.GetFeatures().GetEnabledFeatures();
foreach (var desiredFeature in desiredFeatures.GetEnabledFeatures())
{
if (deviceFeatures.Contains(desiredFeature) == false)
{
return(false);
}
}
return(true);
}
internal HostDevice(
PhysicalDevice vulkanPhysicaldevice,
SurfaceType surfaceType,
Logger logger = null)
{
if (vulkanPhysicaldevice == null)
{
throw new ArgumentNullException(nameof(vulkanPhysicaldevice));
}
this.physicalDevice = vulkanPhysicaldevice;
this.surfaceType = surfaceType;
this.logger = logger;
this.properties = vulkanPhysicaldevice.GetProperties();
this.deviceMemoryProperties = vulkanPhysicaldevice.GetMemoryProperties();
this.supportedFeatures = vulkanPhysicaldevice.GetFeatures();
this.availableExtensions = vulkanPhysicaldevice.EnumerateExtensionProperties();
this.queueFamilies = vulkanPhysicaldevice.GetQueueFamilyProperties();
logger?.Log(nameof(HostDevice), $"Found device: {Name}");
logger?.LogList(nameof(HostDevice), $"{Name} available extensions:", availableExtensions);
}
private bool IsDeviceSuitable(PhysicalDevice device)
{
var indices = FindQueueFamilies(device);
var swapcahinAdequate = false;
var features = device.GetFeatures();
var(surfaceCapablities, formats, presentModes) = QuerySwapchainSupport(device);
if (CheckExtensionSupport(device))
{
swapcahinAdequate = formats.Length != 0 && presentModes.Length != 0;
}
if (indices.IsComplete && swapcahinAdequate && features.SamplerAnisotropy)
{
data.queueFamilyIndices = indices;
data.surfaceCapabilities = surfaceCapablities;
data.formats = formats;
data.presentModes = presentModes;
return(true);
}
return(false);
}
public Context(GameWindow window)
{
Window = window;
Instance = ToDispose(VKHelper.CreateInstance());
DebugReportCallback = ToDispose(VKHelper.CreateDebugReportCallback(Instance));
Surface = ToDispose(VKHelper.CreateSurface(Instance, Window.Handle));
foreach (PhysicalDevice physicalDevice in Instance.EnumeratePhysicalDevices())
{
QueueFamilyProperties[] queueFamilyProperties = physicalDevice.GetQueueFamilyProperties();
for (int i = 0; i < queueFamilyProperties.Length; i++)
{
if (queueFamilyProperties[i].QueueFlags.HasFlag(Queues.Graphics))
{
if (GraphicsQueueFamilyIndex == -1)
{
GraphicsQueueFamilyIndex = i;
}
if (ComputeQueueFamilyIndex == -1)
{
ComputeQueueFamilyIndex = i;
}
if (physicalDevice.GetSurfaceSupportKhr(i, Surface) &&
VKHelper.GetPresentationSupport(physicalDevice, i))
{
PresentQueueFamilyIndex = i;
}
if (GraphicsQueueFamilyIndex != -1 &&
ComputeQueueFamilyIndex != -1 &&
PresentQueueFamilyIndex != -1)
{
PhysicalDevice = physicalDevice;
break;
}
}
}
if (PhysicalDevice != null)
{
break;
}
}
if (PhysicalDevice == null)
{
throw new InvalidOperationException("No suitable physical device found.");
}
GenerateDepthStencilFormat();
// Store memory properties of the physical device.
MemoryProperties = PhysicalDevice.GetMemoryProperties();
Features = PhysicalDevice.GetFeatures();
Properties = PhysicalDevice.GetProperties();
// Create a logical device.
bool sameGraphicsAndPresent = GraphicsQueueFamilyIndex == PresentQueueFamilyIndex;
var queueCreateInfos = new DeviceQueueCreateInfo[sameGraphicsAndPresent ? 1 : 2];
queueCreateInfos[0] = new DeviceQueueCreateInfo(GraphicsQueueFamilyIndex, 1, 1.0f);
if (!sameGraphicsAndPresent)
{
queueCreateInfos[1] = new DeviceQueueCreateInfo(PresentQueueFamilyIndex, 1, 1.0f);
}
var deviceCreateInfo = new DeviceCreateInfo(
queueCreateInfos,
new[] { Constant.DeviceExtension.KhrSwapchain, Constant.DeviceExtension.KhrMaintenance1 },
Features);
Device = PhysicalDevice.CreateDevice(deviceCreateInfo);
// Get queue(s).
GraphicsQueue = Device.GetQueue(GraphicsQueueFamilyIndex);
ComputeQueue = ComputeQueueFamilyIndex == GraphicsQueueFamilyIndex
? GraphicsQueue
: Device.GetQueue(ComputeQueueFamilyIndex);
PresentQueue = PresentQueueFamilyIndex == GraphicsQueueFamilyIndex
? GraphicsQueue
: Device.GetQueue(PresentQueueFamilyIndex);
Content = new Content(this);
GraphicsCommandPool = ToDispose(Device.CreateCommandPool(new CommandPoolCreateInfo(GraphicsQueueFamilyIndex, CommandPoolCreateFlags.ResetCommandBuffer)));
ComputeCommandPool = ToDispose(Device.CreateCommandPool(new CommandPoolCreateInfo(ComputeQueueFamilyIndex)));
Graphics = ToDispose(new Graphics(this));
Build();
}
public void GetFeatures()
{
PhysicalDevice.GetFeatures();
}
/// <summary>
/// Get whether a physical device meets requirement features and capabilities
/// </summary>
/// <param name="device"></param>
/// <returns></returns>
private static bool GetDeviceMeetsRequirements(PhysicalDevice device, SurfaceKhr surface)
{
// Argument checks
if (device is null)
{
throw new ArgumentNullException(nameof(device));
}
if (surface is null)
{
throw new ArgumentNullException(nameof(surface));
}
// Check device features
{
var features = device.GetFeatures();
if (!features.SamplerAnisotropy)
{
return(false);
}
var limits = device.GetProperties().Limits;
if (limits.MaxVertexInputAttributes < 16)
{
return(false);
}
if (limits.MaxUniformBufferRange < sizeof(float) * 4 * 254)
{
return(false);
}
if (limits.MaxVertexInputBindings < 2)
{
return(false);
}
if (limits.MaxPointSize <= 1)
{
return(false);
}
}
// Check queue families
{
var families = device.GetQueueFamilyProperties();
// Graphics, compute, transfer
{
if (families.Count(family => QueueFamily.Supports(family, Queues.Graphics)) == 0 ||
families.Count(family => QueueFamily.Supports(family, Queues.Compute)) == 0 ||
families.Count(family => QueueFamily.Supports(family, Queues.Transfer)) == 0)
{
return(false);
}
}
// Present
{
var foundPresent = false;
for (var i = 0; i < families.Length; i++)
{
if (QueueFamily.SupportsPresenting(i, device, surface))
{
foundPresent = true;
break;
}
}
if (!foundPresent)
{
return(false);
}
}
}
return(true);
}
public VulkanContext(Instance instance, SurfaceKhr surface, Platform platform)
{
// Find graphics and presentation capable physical device(s) that support
// the provided surface for platform.
int graphicsQueueFamilyIndex = -1;
int computeQueueFamilyIndex = -1;
int presentQueueFamilyIndex = -1;
foreach (PhysicalDevice physicalDevice in instance.EnumeratePhysicalDevices())
{
QueueFamilyProperties[] queueFamilyProperties = physicalDevice.GetQueueFamilyProperties();
for (int i = 0; i < queueFamilyProperties.Length; i++)
{
if (queueFamilyProperties[i].QueueFlags.HasFlag(Queues.Graphics))
{
if (graphicsQueueFamilyIndex == -1)
{
graphicsQueueFamilyIndex = i;
}
if (computeQueueFamilyIndex == -1)
{
computeQueueFamilyIndex = i;
}
if (physicalDevice.GetSurfaceSupportKhr(i, surface) &&
GetPresentationSupport(physicalDevice, i))
{
presentQueueFamilyIndex = i;
}
if (graphicsQueueFamilyIndex != -1 &&
computeQueueFamilyIndex != -1 &&
presentQueueFamilyIndex != -1)
{
PhysicalDevice = physicalDevice;
break;
}
}
}
if (PhysicalDevice != null)
{
break;
}
}
bool GetPresentationSupport(PhysicalDevice physicalDevice, int queueFamilyIndex)
{
switch (platform)
{
case Platform.Android:
return(true);
case Platform.Win32:
return(physicalDevice.GetWin32PresentationSupportKhr(queueFamilyIndex));
default:
throw new NotImplementedException();
}
}
if (PhysicalDevice == null)
{
throw new InvalidOperationException("No suitable physical device found.");
}
// Store memory properties of the physical device.
MemoryProperties = PhysicalDevice.GetMemoryProperties();
Features = PhysicalDevice.GetFeatures();
Properties = PhysicalDevice.GetProperties();
// Create a logical device.
bool sameGraphicsAndPresent = graphicsQueueFamilyIndex == presentQueueFamilyIndex;
var queueCreateInfos = new DeviceQueueCreateInfo[sameGraphicsAndPresent ? 1 : 2];
queueCreateInfos[0] = new DeviceQueueCreateInfo(graphicsQueueFamilyIndex, 1, 1.0f);
if (!sameGraphicsAndPresent)
{
queueCreateInfos[1] = new DeviceQueueCreateInfo(presentQueueFamilyIndex, 1, 1.0f);
}
var deviceCreateInfo = new DeviceCreateInfo(
queueCreateInfos,
new[] { Constant.DeviceExtension.KhrSwapchain },
Features);
Device = PhysicalDevice.CreateDevice(deviceCreateInfo);
// Get queue(s).
GraphicsQueue = Device.GetQueue(graphicsQueueFamilyIndex);
ComputeQueue = computeQueueFamilyIndex == graphicsQueueFamilyIndex
? GraphicsQueue
: Device.GetQueue(computeQueueFamilyIndex);
PresentQueue = presentQueueFamilyIndex == graphicsQueueFamilyIndex
? GraphicsQueue
: Device.GetQueue(presentQueueFamilyIndex);
// Create command pool(s).
GraphicsCommandPool = Device.CreateCommandPool(new CommandPoolCreateInfo(graphicsQueueFamilyIndex));
ComputeCommandPool = Device.CreateCommandPool(new CommandPoolCreateInfo(computeQueueFamilyIndex));
}
