private void pickPhysicalDevice()
{
int deviceCount = 0;
Vulkan.vkEnumeratePhysicalDevices(instance, ref deviceCount, null);
if (deviceCount == 0)
{
throw Program.Throw("failed to find GPUs with Vulkan support!");
}
VkPhysicalDevice[] devices = new VkPhysicalDevice[deviceCount];
Vulkan.vkEnumeratePhysicalDevices(instance, ref deviceCount, devices);
physicalDevice = null;
foreach (var device in devices)
{
if (isDeviceSuitable(device))
{
physicalDevice = device;
break;
}
}
if (physicalDevice == null)
{
throw Program.Throw("failed to find a suitable GPU!");
}
}
private void CreateUniformBuffer(VkDevice device, VkPhysicalDevice physicalDevice)
{
var bufferSize = Marshal.SizeOf <Transform>();
VkMemoryPropertyFlags memoryFlags = VkMemoryPropertyFlags.VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VkMemoryPropertyFlags.VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
SampleHelpers.CreateBuffer(device, physicalDevice, bufferSize, VkBufferUsageFlags.VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT, memoryFlags, out m_uniformBuffer, out m_uniformBufferMemory);
}
private void PickPhysicalDevice()
{
uint deviceCount = 0;
Helpers.CheckErrors(VulkanNative.vkEnumeratePhysicalDevices(instance, &deviceCount, null));
if (deviceCount == 0)
{
throw new Exception("Failed to find GPUs with Vulkan support!");
}
VkPhysicalDevice *devices = stackalloc VkPhysicalDevice[(int)deviceCount];
Helpers.CheckErrors(VulkanNative.vkEnumeratePhysicalDevices(instance, &deviceCount, devices));
for (int i = 0; i < deviceCount; i++)
{
var device = devices[i];
if (this.IsPhysicalDeviceSuitable(device))
{
this.physicalDevice = device;
break;
}
}
if (this.physicalDevice == default)
{
throw new Exception("failed to find a suitable GPU!");
}
}
internal GraphicsDevice(Core core, bool validation)
{
if (!Glfw.VulkanSupported())
{
throw new PlatformNotSupportedException("The Vulkan runtime is not available on this platform");
}
Core = core;
// Create the instance and select the device to use
InitializeVulkanInstance(validation, out VkInstanceInfo, out VkDebugUtils, out VkDeviceInfo, out Features);
VkInstance = VkInstanceInfo.Instance;
VkPhysicalDevice = VkDeviceInfo.PhysicalDevice;
LINFO($"Selected device '{VkDeviceInfo.DeviceName}'");
// Create the device and queue objects
CreateVulkanDevice(VkDeviceInfo, Features, out VkDevice, out var graphicsQueue, out var graphicsQueueIndex);
GraphicsQueue = new(this, graphicsQueue, graphicsQueueIndex);
LINFO("Created Vulkan device instance");
Limits = new(VkDeviceInfo);
// Create the memory manager
Memory = new(this);
// Create the global binding table for the device
BindingTable = new(this);
// Prepare resources
SamplerPool.Initialize(this);
Resources = new(this);
}
static void Main(string[] args)
{
VkInstance inst;
using (VkApplicationInfo ai = new VkApplicationInfo()) {
using (VkInstanceCreateInfo ci = new VkInstanceCreateInfo {
pApplicationInfo = ai
}){
CheckResult(vkCreateInstance(ci, IntPtr.Zero, out inst));
}
}
Vk.LoadInstanceFunctionPointers(inst);
CheckResult(vkEnumeratePhysicalDevices(inst, out uint phyCount, IntPtr.Zero));
VkPhysicalDevice[] phys = new VkPhysicalDevice[phyCount];
CheckResult(vkEnumeratePhysicalDevices(inst, out phyCount, phys.Pin()));
for (int i = 0; i < phys.Length; i++)
{
vkGetPhysicalDeviceProperties(phys[i], out VkPhysicalDeviceProperties props);
Console.WriteLine($"{props.deviceName}");
Console.WriteLine($"\tdeviceType: {props.deviceType,20}");
Console.WriteLine($"\tapiVersion: {(Version)props.apiVersion,20}");
Console.WriteLine($"\tdriverVersion:{props.driverVersion,20}");
Console.WriteLine($"\tvendorID: {props.vendorID,20}");
}
vkDestroyInstance(inst, IntPtr.Zero);
}
static void GetSwapchainFormat(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface)
{
uint formatCount = 0;
vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, &formatCount, null);
VkSurfaceFormatKHR[] formats = new VkSurfaceFormatKHR[formatCount];
fixed(VkSurfaceFormatKHR *ptr = &formats[0])
Assert(vkGetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, &formatCount, ptr));
for (int i = 0; i < formatCount; i++)
{
Console.WriteLine($"Format {formats[i].format} {formats[i].colorSpace} is available.");
for (int k = 0; k < UNORM_FORMATS.Length; k++)
{
if (formats[i].format == UNORM_FORMATS[k])
{
surfaceFormat = formats[i];
return;
}
}
}
surfaceFormat = formats[0];//Fallback
}
public static uint getSupportedDepthFormat(VkPhysicalDevice physicalDevice, VkFormat *depthFormat)
{
// Since all depth formats may be optional, we need to find a suitable depth format to use
// Start with the highest precision packed format
List <VkFormat> depthFormats = new List <VkFormat>()
{
VkFormat.D32SfloatS8Uint,
VkFormat.D32Sfloat,
VkFormat.D24UnormS8Uint,
VkFormat.D16UnormS8Uint,
VkFormat.D16Unorm,
};
foreach (VkFormat format in depthFormats)
{
VkFormatProperties formatProps;
vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &formatProps);
// Format must support depth stencil attachment for optimal tiling
if ((formatProps.optimalTilingFeatures & VkFormatFeatureFlags.DepthStencilAttachment) != 0)
{
*depthFormat = format;
return(True);
}
}
return(False);
}
public unsafe Mesh(VkDevice device, VkPhysicalDevice physicalDevice, T[] vertices, uint[] indices)
{
this.vertices = new FDataBuffer <T>(device, physicalDevice, vertices.Length, VkBufferUsageFlags.VertexBuffer,
VkSharingMode.Exclusive);
this.indices = new FDataBuffer <uint>(device, physicalDevice, indices.Length, VkBufferUsageFlags.IndexBuffer, VkSharingMode.Exclusive);
Span <T> spanv = this.vertices.Map();
T * vptr;
fixed(T *ptr = spanv)
vptr = ptr;
Parallel.For(0, vertices.Length, (i) =>
{
*(vptr + i) = vertices[i];
});
vptr = null;
spanv = this.vertices.UnMap();
Span <uint> spani = this.indices.Map();
uint * iptr;
fixed(uint *ptr = spani)
iptr = ptr;
Parallel.For(0, indices.Length, (i) =>
{
*(iptr + i) = indices[i];
});
iptr = null;
spani = this.indices.UnMap();
}
static (uint graphicsFamily, uint presentFamily) FindQueueFamilies(
VkPhysicalDevice device, VkSurfaceKHR surface)
{
var queueFamilies = vkGetPhysicalDeviceQueueFamilyProperties(device);
uint graphicsFamily = QueueFamilyIgnored;
uint presentFamily = QueueFamilyIgnored;
uint i = 0;
foreach (var queueFamily in queueFamilies)
{
if ((queueFamily.queueFlags & VkQueueFlags.Graphics) != VkQueueFlags.None)
{
graphicsFamily = i;
}
vkGetPhysicalDeviceSurfaceSupportKHR(device, i, surface, out var presentSupport);
if (presentSupport)
{
presentFamily = i;
}
if (graphicsFamily != QueueFamilyIgnored &&
presentFamily != QueueFamilyIgnored)
{
break;
}
i++;
}
return(graphicsFamily, presentFamily);
}
public unsafe QueueFamilyIndices(VkPhysicalDevice device, VkSurfaceKHR surface)
{
int graphicsIndex = -1;
int presentIndex = -1;
uint queueFamilyCount = 0;
VulkanNative.vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, null);
VkQueueFamilyProperties *queueFamilies = stackalloc VkQueueFamilyProperties[(int)queueFamilyCount];
VulkanNative.vkGetPhysicalDeviceQueueFamilyProperties(device, &queueFamilyCount, queueFamilies);
for (int i = 0; i < queueFamilyCount; i++)
{
var q = queueFamilies[i];
if (q.queueCount > 0 && (q.queueFlags & VkQueueFlagBits.VK_QUEUE_GRAPHICS_BIT) != 0)
{
graphicsIndex = i;
}
VkBool32 presentSupported = false;
VkResult result = VulkanNative.vkGetPhysicalDeviceSurfaceSupportKHR(device, (uint)i, surface, &presentSupported);
Helpers.CheckErrors(result);
if (presentIndex < 0 && q.queueCount > 0 && presentSupported)
{
presentIndex = i;
}
}
GraphicsFamily = graphicsIndex;
PresentFamily = presentIndex;
}
public static VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, ref int presentModeCount, VkPresentModeKHR[] presentModes)
{
VkPreconditions.CheckNull(physicalDevice, nameof(physicalDevice));
VkPreconditions.CheckNull(surface, nameof(surface));
return(GetPhysicalDevice(physicalDevice).GetSurfacePresentModes(surface, ref presentModeCount, presentModes));
}
static uint GetMemoryTypeIndex(VkPhysicalDevice vulkanPhysicalDevice)
{
uint memoryTypeIndex = uint.MaxValue;
VkPhysicalDeviceMemoryProperties physicalDeviceMemoryProperties;
vkGetPhysicalDeviceMemoryProperties(vulkanPhysicalDevice, &physicalDeviceMemoryProperties);
var memoryTypesCount = physicalDeviceMemoryProperties.memoryTypeCount;
var memoryTypes = physicalDeviceMemoryProperties.memoryTypes;
for (uint index = 0; index < memoryTypesCount; index++)
{
if ((memoryTypes[unchecked ((int)index)].propertyFlags & (uint)VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0)
{
memoryTypeIndex = index;
break;
}
}
if (memoryTypeIndex == uint.MaxValue)
{
ThrowInvalidOperationException(nameof(memoryTypeIndex), memoryTypeIndex);
}
return(memoryTypeIndex);
}
private bool IsPhysicalDeviceSuitable(VkPhysicalDevice physicalDevice)
{
QueueFamilyIndices indices = this.FindQueueFamilies(physicalDevice);
bool extensionsSupported = this.CheckPhysicalDeviceExtensionSupport(physicalDevice);
// acquire Raytracing features
VkPhysicalDeviceRayTracingFeaturesKHR rayTracingFeatures = new VkPhysicalDeviceRayTracingFeaturesKHR()
{
sType = VkStructureType.VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_FEATURES_KHR,
pNext = null,
};
VkPhysicalDeviceFeatures2 deviceFeatures2 = new VkPhysicalDeviceFeatures2()
{
sType = VkStructureType.VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2,
pNext = &rayTracingFeatures,
};
VulkanNative.vkGetPhysicalDeviceFeatures2(physicalDevice, &deviceFeatures2);
extensionsSupported = extensionsSupported && rayTracingFeatures.rayTracing;
bool swapChainAdequate = false;
if (extensionsSupported)
{
SwapChainSupportDetails swapChainSupport = this.QuerySwapChainSupport(physicalDevice);
swapChainAdequate = (swapChainSupport.formats.Length != 0 && swapChainSupport.presentModes.Length != 0);
}
return(indices.IsComplete() && extensionsSupported && swapChainAdequate);
}
public unsafe SwapChainSupportDetails(VkPhysicalDevice device, VkSurfaceKHR surface)
{
VkSurfaceCapabilitiesKHR capabilitiesKHR;
VulkanNative.vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, &capabilitiesKHR);
capabilities = capabilitiesKHR;
formats = null;
presentModes = null;
uint formatCount;
VulkanNative.vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, null);
if (formatCount > 0)
{
formats = new VkSurfaceFormatKHR[formatCount];
fixed(VkSurfaceFormatKHR *formatsPtr = formats)
{
VulkanNative.vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface, &formatCount, formatsPtr);
}
}
uint presentModeCount;
VulkanNative.vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, null);
if (presentModeCount > 0)
{
presentModes = new VkPresentModeKHR[presentModeCount];
fixed(VkPresentModeKHR *presentsPtr = presentModes)
{
VulkanNative.vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface, &presentModeCount, presentsPtr);
}
}
}
public static VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, out VkSurfaceCapabilitiesKHR capabilities)
{
VkPreconditions.CheckNull(physicalDevice, nameof(physicalDevice));
VkPreconditions.CheckNull(surface, nameof(surface));
return(GetPhysicalDevice(physicalDevice).GetSurfaceCapabilities(surface, out capabilities));
}
private void CreatePhysicalDevice()
{
uint deviceCount = 0;
vkEnumeratePhysicalDevices(_instance, ref deviceCount, null);
if (deviceCount == 0)
{
throw new InvalidOperationException("No physical devices exist.");
}
VkPhysicalDevice[] physicalDevices = new VkPhysicalDevice[deviceCount];
vkEnumeratePhysicalDevices(_instance, ref deviceCount, ref physicalDevices[0]);
// Just use the first one.
_physicalDevice = physicalDevices[0];
vkGetPhysicalDeviceProperties(_physicalDevice, out _physicalDeviceProperties);
string deviceName;
fixed(byte *utf8NamePtr = _physicalDeviceProperties.deviceName)
{
deviceName = Encoding.UTF8.GetString(utf8NamePtr, (int)MaxPhysicalDeviceNameSize);
}
vkGetPhysicalDeviceFeatures(_physicalDevice, out _physicalDeviceFeatures);
vkGetPhysicalDeviceMemoryProperties(_physicalDevice, out _physicalDeviceMemProperties);
}
public static VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, ref int formatCount, VkSurfaceFormatKHR[] formats)
{
VkPreconditions.CheckNull(physicalDevice, nameof(physicalDevice));
VkPreconditions.CheckNull(surface, nameof(surface));
return(GetPhysicalDevice(physicalDevice).GetSurfaceFormats(surface, ref formatCount, formats));
}
private void CreateVertexBuffer(VkDevice device, VkPhysicalDevice physicalDevice)
{
// 初期頂点データ.
var vertices = new Vertex[3] {
new Vertex()
{
Position = new vec3(-.5f, 0.5f, 0.0f), Color = new vec4(0.0f, 0.0f, 1.0f, 1.0f)
},
new Vertex()
{
Position = new vec3(+.5f, 0.5f, 0.0f), Color = new vec4(0.0f, 1.0f, 0.0f, 1.0f)
},
new Vertex()
{
Position = new vec3(0.0f, -.5f, 0.0f), Color = new vec4(1.0f, 0.0f, 0.0f, 1.0f)
},
};
var bufferSize = Marshal.SizeOf <Vertex>() * vertices.Length;
VkMemoryPropertyFlags memoryFlags = VkMemoryPropertyFlags.VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VkMemoryPropertyFlags.VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
SampleHelpers.CreateBuffer(device, physicalDevice, bufferSize, VkBufferUsageFlags.VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, memoryFlags, out m_vertexBuffer, out m_vertexBufferMemory);
// 初期頂点データの書き込み.
MappedMemoryStream mappedStream;
VulkanAPI.vkMapMemory(device, m_vertexBufferMemory, 0, VkDeviceSize.VK_WHOLE_SIZE, 0, out mappedStream);
mappedStream.Write(vertices);
VulkanAPI.vkUnmapMemory(device, m_vertexBufferMemory);
}
public void CreateCubeModel(VkDevice device, VkPhysicalDevice physicalDevice)
{
var cubeVertices = CubeModel.GetVertices();
var cubeIndices = CubeModel.GetIndices();
var vbSize = Marshal.SizeOf <CubeModel.Vertex>() * cubeVertices.Length;
var ibSize = Marshal.SizeOf <ushort>() * cubeIndices.Length;
VkMemoryPropertyFlags flags = VkMemoryPropertyFlags.VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VkMemoryPropertyFlags.VK_MEMORY_PROPERTY_HOST_COHERENT_BIT;
SampleHelpers.CreateBuffer(device, physicalDevice, vbSize, VkBufferUsageFlags.VK_BUFFER_USAGE_VERTEX_BUFFER_BIT, flags, out m_vertexBuffer, out m_vertexBufferMemory);
SampleHelpers.CreateBuffer(device, physicalDevice, ibSize, VkBufferUsageFlags.VK_BUFFER_USAGE_INDEX_BUFFER_BIT, flags, out m_indexBuffer, out m_indexBufferMemory);
// 初期データの書き込み.
MappedMemoryStream mapped;
VulkanAPI.vkMapMemory(device, m_vertexBufferMemory, 0, VkDeviceSize.VK_WHOLE_SIZE, 0, out mapped);
mapped.Write(cubeVertices);
VulkanAPI.vkUnmapMemory(device, m_vertexBufferMemory);
VulkanAPI.vkMapMemory(device, m_indexBufferMemory, 0, VkDeviceSize.VK_WHOLE_SIZE, 0, out mapped);
mapped.Write(cubeIndices);
VulkanAPI.vkUnmapMemory(device, m_indexBufferMemory);
m_resourceManager.Regist(m_vertexBuffer, m_vertexBufferMemory);
m_resourceManager.Regist(m_indexBuffer, m_indexBufferMemory);
}
private static Mesh <VoxelVertex> _DoGenerateMesh(VkDevice device, VkPhysicalDevice physicalDevice, bool optimize)
{
List <Face> faces = new List <Face>();
Stopwatch stopwatch = Stopwatch.StartNew();
Random random = new Random();
ushort[,,] blocks = new ushort[VoxelRenderChunk.CHUNK_SIZE, VoxelRenderChunk.CHUNK_SIZE, VoxelRenderChunk.CHUNK_SIZE];
for (int x2 = 0; x2 < VoxelRenderChunk.CHUNK_SIZE; x2++)
{
for (int z2 = 0; z2 < VoxelRenderChunk.CHUNK_SIZE; z2++)
{
for (int y2 = 0; y2 < VoxelRenderChunk.CHUNK_SIZE; y2++)
{
blocks[x2, y2, z2] = (ushort)(random.Next(6));
}
}
}
VoxelRenderChunk chunk = new VoxelRenderChunk(blocks);
Span <ushort> span = chunk.Span;
int x = 0, y = 0, z = 0;
for (int i = 0; i < span.Length; i++)
{
if (span[i] != 0)
{
faces.AddRange(GenerateFaces(new Vector3(x, y, z), span[i]));
}
z++;
if (z >= VoxelRenderChunk.CHUNK_SIZE)
{
z = 0;
y++;
if (y >= VoxelRenderChunk.CHUNK_SIZE)
{
y = 0;
x++;
}
}
}
Face[] faceArr = faces.ToArray();
if (optimize)
{
LoopFaces(ref faceArr, Vector3.UnitX);
LoopFaces(ref faceArr, Vector3.UnitY);
LoopFaces(ref faceArr, Vector3.UnitZ);
}
VoxelVertex[] vertices = new VoxelVertex[faceArr.Length * 4]; uint[] indicies = new uint[faceArr.Length * 6];
for (uint i = 0; i < faceArr.Length; i++)
{
faceArr[i].Generate(ref vertices, ref indicies, i * 4, i * 6);
}
stopwatch.Stop();
Console.WriteLine(((double)stopwatch.ElapsedTicks) / Stopwatch.Frequency * 1000);
Console.WriteLine($"Vertex Count: {vertices.Length}, Index Count: {indicies.Length}");
return(new Mesh <VoxelVertex>(device, physicalDevice, vertices.ToArray(), indicies.ToArray()));
}
public FTexture(VkDevice device, VkPhysicalDevice physicalDevice, int cmdPoolID, VkQueue queue, string[] paths,
VkFormat format, int width, int height, uint mipLevels = 1)
{
MipLevels = mipLevels;
image = LoadTexture(device, physicalDevice, cmdPoolID, queue, paths, MipLevels);
imageView = CreateColourImageArrayView(device, image, paths.Length, format, MipLevels);
InitMips(device, queue, image, width, height, MipLevels, (uint)paths.Length, cmdPoolID);
}
SwapchainSupport GetSwapchainSupport(VkPhysicalDevice physicalDevice)
{
var cap = surface.GetCapabilities(physicalDevice);
var formats = surface.GetFormats(physicalDevice);
var modes = surface.GetPresentModes(physicalDevice);
return(new SwapchainSupport(cap, new List <VkSurfaceFormatKHR>(formats), new List <VkPresentModeKHR>(modes)));
}
public static VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, int queueFamilyIndex, VkSurfaceKHR surface, out bool pSupported)
{
VkPreconditions.CheckNull(physicalDevice, nameof(physicalDevice));
VkPreconditions.CheckNull(surface, nameof(surface));
VkPreconditions.CheckRange(queueFamilyIndex, 0, int.MaxValue, nameof(queueFamilyIndex));
return(GetPhysicalDevice(physicalDevice).GetSurfaceSupport(queueFamilyIndex, surface, out pSupported));
}
public static extern VkResult GetPhysicalDeviceImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
VkImageTiling tiling,
VkImageUsageFlags usage,
VkImageCreateFlags flags,
IntPtr pImageFormatProperties
);
public static bool TryAllocateMemoryForBuffer(ulong size, VkDevice device, VkPhysicalDevice pDevice, ref VkMemoryRequirements memoryRequirements, ref VkMemoryPropertyFlags memoryProperties, out ulong offset, out VkDeviceMemory mem)
{
if (size > Buffer.LargestBufferSize)
{
Buffer.LargestBufferSize = size;
}
if (size >= Buffer.LargePooledBufferSize)
{
offset = 0;
mem = VkDeviceMemory.Null;
Buffer.PoolMissesDueToSize++;
return(false);
}
else if (size >= Buffer.SmallPooledBufferSize)
{
if (BigMemoryPool == VkDeviceMemory.Null)
{
AllocatePool(out BigMemoryPool, ref device, ref pDevice, ref memoryProperties, ref memoryRequirements, Buffer.LargePooledBufferCount * Buffer.LargePooledBufferSize);
for (ulong i = 0; i < Buffer.LargePooledBufferCount; i++)
{
FreeBig.Enqueue(i * Buffer.LargePooledBufferSize);
}
}
if (FreeBig.TryDequeue(out offset))
{
Buffer.CurrentFreeBigPool = FreeBig.Count;
mem = BigMemoryPool;
return(true);
}
}
else
{
if (SmallMemoryPool == VkDeviceMemory.Null)
{
AllocatePool(out SmallMemoryPool, ref device, ref pDevice, ref memoryProperties, ref memoryRequirements, Buffer.SmallPooledBufferCount * Buffer.SmallPooledBufferSize);
for (ulong i = 0; i < Buffer.SmallPooledBufferCount; i++)
{
FreeSmall.Enqueue(i * Buffer.SmallPooledBufferSize);
}
}
if (FreeSmall.TryDequeue(out offset))
{
Buffer.CurrentFreeSmallPool = FreeSmall.Count;
mem = SmallMemoryPool;
return(true);
}
}
offset = 0;
mem = VkDeviceMemory.Null;
Buffer.PoolMissesDueToExaustion++;
return(false);
}
private static SwapChainSupportDetails QuerySwapChainSupport(VkPhysicalDevice device, VkSurfaceKHR surface)
{
SwapChainSupportDetails details = new SwapChainSupportDetails();
vkGetPhysicalDeviceSurfaceCapabilitiesKHR(device, surface, out details.Capabilities).CheckResult();
details.Formats = vkGetPhysicalDeviceSurfaceFormatsKHR(device, surface);
details.PresentModes = vkGetPhysicalDeviceSurfacePresentModesKHR(device, surface);
return(details);
}
public static extern void GetPhysicalDeviceSparseImageFormatProperties(
VkPhysicalDevice physicalDevice,
VkFormat format,
VkImageType type,
VkSampleCountFlags samples,
VkImageUsageFlags usage,
VkImageTiling tiling,
ref uint pPropertyCount,
IntPtr pProperties
);
private static VkDevice CreateDevice(VkInstance instance, out VkPhysicalDevice physicalDevice,
VkSurfaceKHR surface, out uint queueFamilyIndex)
{
queueFamilyIndex = 0;//SHORTCUT computed from queue properties
physicalDevice = PickPhysicalDevice(instance, surface, out queueFamilyIndex);
List <GCHandle> handles = new List <GCHandle>();
List <string> requiredExtensions = new List <string>();
requiredExtensions.Add("VK_KHR_swapchain");
string[] extensionNames = requiredExtensions.ToArray();
byte[][] pExtensionNames = new byte[extensionNames.Length][];
byte *[] ppExtensionNamesArray = new byte *[extensionNames.Length];
for (int i = 0; i < pExtensionNames.Length; i++)
{
pExtensionNames[i] = Encoding.UTF8.GetBytes(extensionNames[i] + char.MinValue);
GCHandle handle = GCHandle.Alloc(pExtensionNames[i]);
handles.Add(handle);
fixed(byte *p = &(((byte[])handle.Target)[0]))
{
ppExtensionNamesArray[i] = p;
}
}
VkDevice device;
fixed(byte **extensions = &ppExtensionNamesArray[0])
{
float[] pQueuePriorities = new float[] { 1.0f };
VkDeviceQueueCreateInfo deviceQueueCreateInfo = VkDeviceQueueCreateInfo.New();
deviceQueueCreateInfo.queueFamilyIndex = queueFamilyIndex;
deviceQueueCreateInfo.queueCount = 1;
fixed(float *ptr = &(pQueuePriorities[0]))
deviceQueueCreateInfo.pQueuePriorities = ptr;
VkDeviceCreateInfo createInfo = VkDeviceCreateInfo.New();
createInfo.queueCreateInfoCount = 1;
createInfo.pQueueCreateInfos = &deviceQueueCreateInfo;
createInfo.ppEnabledExtensionNames = extensions;
createInfo.enabledExtensionCount = (uint)extensionNames.Length;
device = VkDevice.Null;
Assert(vkCreateDevice(physicalDevice, &createInfo, null, &device));
foreach (var handle in handles)
{
handle.Free();
}
}
return(device);
}
public VkResourceFactory(VkRenderContext rc)
{
RenderContext = rc;
_device = rc.Device;
_physicalDevice = rc.PhysicalDevice;
VkCommandPoolCreateInfo commandPoolCI = VkCommandPoolCreateInfo.New();
commandPoolCI.flags = VkCommandPoolCreateFlags.None;
commandPoolCI.queueFamilyIndex = rc.GraphicsQueueIndex;
}
internal VulkanGraphicsAdapter(VulkanGraphicsProvider graphicsProvider, VkPhysicalDevice vulkanPhysicalDevice)
: base(graphicsProvider)
{
AssertNotNull(vulkanPhysicalDevice, nameof(vulkanPhysicalDevice));
_vulkanPhysicalDevice = vulkanPhysicalDevice;
_vulkanPhysicalDeviceProperties = new ValueLazy <VkPhysicalDeviceProperties>(GetVulkanPhysicalDeviceProperties);
_name = new ValueLazy <string>(GetName);
_ = _state.Transition(to: Initialized);
}
