public void CreateCommandPool()
{
var createInfo = new CommandPoolCreateInfo(0);
using (Device.CreateCommandPool(createInfo)) { }
using (Device.CreateCommandPool(createInfo, CustomAllocator)) { }
}
public unsafe CommandBufferPool(Vk api, Device device, Queue queue, object queueLock, uint queueFamilyIndex, bool isLight = false)
{
_api = api;
_device = device;
_queue = queue;
_queueLock = queueLock;
_owner = Thread.CurrentThread;
var commandPoolCreateInfo = new CommandPoolCreateInfo()
{
SType = StructureType.CommandPoolCreateInfo,
QueueFamilyIndex = queueFamilyIndex,
Flags = CommandPoolCreateFlags.CommandPoolCreateTransientBit |
CommandPoolCreateFlags.CommandPoolCreateResetCommandBufferBit
};
api.CreateCommandPool(device, commandPoolCreateInfo, null, out _pool).ThrowOnError();
// We need at least 2 command buffers to get texture data in some cases.
_totalCommandBuffers = isLight ? 2 : MaxCommandBuffers;
_totalCommandBuffersMask = _totalCommandBuffers - 1;
_commandBuffers = new ReservedCommandBuffer[_totalCommandBuffers];
_queuedIndexes = new int[_totalCommandBuffers];
_queuedIndexesPtr = 0;
_queuedCount = 0;
for (int i = 0; i < _totalCommandBuffers; i++)
{
_commandBuffers[i].Initialize(api, device, _pool);
WaitAndDecrementRef(i);
}
}
void InitCommandBuffers()
{
CommandPoolCreateInfo poolCreateInfo = new CommandPoolCreateInfo
{
QueueFamilyIndex = 0,
Flags = CommandPoolCreateFlags.ResetCommandBuffer,
};
mainCmdPool = device.CreateCommandPool(poolCreateInfo);
CommandBufferAllocateInfo bufferAllocInfo = new CommandBufferAllocateInfo
{
CommandBufferCount = 1,
CommandPool = mainCmdPool,
Level = CommandBufferLevel.Primary,
};
mainCmd = device.AllocateCommandBuffers(bufferAllocInfo)[0];
cleanupStack.Push(() => {
device.FreeCommandBuffer(mainCmdPool, mainCmd);
mainCmd = null;
device.DestroyCommandPool(mainCmdPool);
mainCmdPool = null;
});
}
public unsafe CommandBufferPool(Vk api, Device device, Queue queue, uint queueFamilyIndex, bool isLight = false)
{
_api = api;
_device = device;
_queue = queue;
_owner = Thread.CurrentThread;
var commandPoolCreateInfo = new CommandPoolCreateInfo()
{
SType = StructureType.CommandPoolCreateInfo,
QueueFamilyIndex = queueFamilyIndex,
Flags = CommandPoolCreateFlags.CommandPoolCreateTransientBit |
CommandPoolCreateFlags.CommandPoolCreateResetCommandBufferBit
};
api.CreateCommandPool(device, commandPoolCreateInfo, null, out _pool).ThrowOnError();
_totalCommandBuffers = isLight ? 1 : MaxCommandBuffers;
_totalCommandBuffersMask = _totalCommandBuffers - 1;
_commandBuffers = new ReservedCommandBuffer[_totalCommandBuffers];
for (int i = 0; i < _totalCommandBuffers; i++)
{
_commandBuffers[i].Initialize(api, device, _pool);
}
}
protected CommandPool CreateCommandPool(uint queueFamily)
{
var commandPoolCreateInfo = new CommandPoolCreateInfo(queueFamily);
commandPoolCreateInfo.Flags = CommandPoolCreateFlags.ResetCommandBuffer;
return(device.CreateCommandPool(commandPoolCreateInfo));
}
protected virtual void CreateCommandBuffer()
{
// Command pool
var commandPoolCreateInfo = new CommandPoolCreateInfo
{
StructureType = StructureType.CommandPoolCreateInfo,
QueueFamilyIndex = 0,
Flags = CommandPoolCreateFlags.ResetCommandBuffer
};
commandPool = device.CreateCommandPool(ref commandPoolCreateInfo);
// Command buffer
var commandBufferAllocationInfo = new CommandBufferAllocateInfo
{
StructureType = StructureType.CommandBufferAllocateInfo,
Level = CommandBufferLevel.Primary,
CommandPool = commandPool,
CommandBufferCount = 1
};
CommandBuffer commandBuffer;
device.AllocateCommandBuffers(ref commandBufferAllocationInfo, &commandBuffer);
this.commandBuffer = commandBuffer;
}
public bool SetQueueName(string qName,
int famIndex, int qIndex, CommandPoolCreateFlags poolFlags)
{
if (mQueueNames.ContainsKey(qName))
{
Misc.SafeInvoke(eErrorSpam, "Queue name already in use: " + qName + " in SetQueueName()");
return(false);
}
int physIndex = mPhysicals.IndexOf(mLogical.Parent);
if (famIndex < 0 || famIndex >= mDeviceQueueFamProps[physIndex].Length)
{
Misc.SafeInvoke(eErrorSpam, "Bad queue family index: " + famIndex + " in SetQueueName()");
return(false);
}
if (qIndex < 0 || qIndex >= mQueueLimits[physIndex][qIndex])
{
Misc.SafeInvoke(eErrorSpam, "Bad queue index: " + qIndex + " in SetQueueName()");
return(false);
}
Queue q = mLogical.GetQueue(famIndex, qIndex);
mQueueNames.Add(qName, q);
//make a command pool for this queue
CommandPoolCreateInfo cpci = new CommandPoolCreateInfo(
famIndex, poolFlags);
mCommandPools.Add(qName, mLogical.CreateCommandPool(cpci));
return(true);
}
CommandBuffer [] CreateCommandBuffers(Image [] images, Framebuffer [] framebuffers, RenderPass renderPass, SurfaceCapabilitiesKhr surfaceCapabilities)
{
var createPoolInfo = new CommandPoolCreateInfo {
Flags = CommandPoolCreateFlags.ResetCommandBuffer
};
var commandPool = device.CreateCommandPool(createPoolInfo);
var commandBufferAllocateInfo = new CommandBufferAllocateInfo {
Level = CommandBufferLevel.Primary,
CommandPool = commandPool,
CommandBufferCount = (uint)images.Length
};
var buffers = device.AllocateCommandBuffers(commandBufferAllocateInfo);
for (int i = 0; i < images.Length; i++)
{
var commandBufferBeginInfo = new CommandBufferBeginInfo();
buffers [i].Begin(commandBufferBeginInfo);
var renderPassBeginInfo = new RenderPassBeginInfo {
Framebuffer = framebuffers [i],
RenderPass = renderPass,
ClearValues = new ClearValue [] { new ClearValue {
Color = new ClearColorValue(new float [] { 0.9f, 0.7f, 0.0f, 1.0f })
} },
RenderArea = new Rect2D {
Extent = surfaceCapabilities.CurrentExtent
}
};
buffers [i].CmdBeginRenderPass(renderPassBeginInfo, SubpassContents.Inline);
buffers [i].CmdEndRenderPass();
buffers [i].End();
}
return(buffers);
}
void CreateCommandBuffer()
{
/*
* We are getting closer to the end. In order to send commands to the device(GPU),
* we must first record commands into a command buffer.
* To allocate a command buffer, we must first create a command pool. So let us do that.
*/
CommandPoolCreateInfo commandPoolCreateInfo = new CommandPoolCreateInfo()
{
Flags = 0,
// the queue family of this command pool. All command buffers allocated from this command pool,
// must be submitted to queues of this family ONLY.
QueueFamilyIndex = computeQueueFamilyIndex
};
commandPool = device.CreateCommandPool(commandPoolCreateInfo);
/*
* Now allocate a command buffer from the command pool.
*/
CommandBufferAllocateInfo commandBufferAllocateInfo = new CommandBufferAllocateInfo()
{
//commandBufferAllocateInfo.commandPool = commandPool; // specify the command pool to allocate from.
// if the command buffer is primary, it can be directly submitted to queues.
// A secondary buffer has to be called from some primary command buffer, and cannot be directly
// submitted to a queue. To keep things simple, we use a primary command buffer.
Level = CommandBufferLevel.Primary, // VK_COMMAND_BUFFER_LEVEL_PRIMARY;
CommandBufferCount = 1 // allocate a single command buffer.
};
commandBuffers = commandPool.AllocateBuffers(commandBufferAllocateInfo); // allocate command buffer.
/*
* Now we shall start recording commands into the newly allocated command buffer.
*/
CommandBufferBeginInfo beginInfo = new CommandBufferBeginInfo()
{
Flags = CommandBufferUsages.OneTimeSubmit// VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT; // the buffer is only submitted and used once in this application.
};
commandBuffers[0].Begin(beginInfo); // start recording commands.
/*
* We need to bind a pipeline, AND a descriptor set before we dispatch.
* The validation layer will NOT give warnings if you forget these, so be very careful not to forget them.
*/
commandBuffers[0].CmdBindPipeline(PipelineBindPoint.Compute, pipelines[0]); // VK_PIPELINE_BIND_POINT_COMPUTE, pipeline);
commandBuffers[0].CmdBindDescriptorSets(PipelineBindPoint.Compute, pipelineLayout, 0, new[] { descriptorSet }); // VK_PIPELINE_BIND_POINT_COMPUTE, pipelineLayout, 0, 1, &descriptorSet, 0, NULL);
/*
* Calling vkCmdDispatch basically starts the compute pipeline, and executes the compute shader.
* The number of workgroups is specified in the arguments.
* If you are already familiar with compute shaders from OpenGL, this should be nothing new to you.
*/
commandBuffers[0].CmdDispatch((int)Math.Ceiling((double)(WIDTH / WORKGROUP_SIZE)), (int)Math.Ceiling((double)(HEIGHT / WORKGROUP_SIZE)), 1);
commandBuffers[0].End(); // end recording commands.
}
protected void CreateCommandPool()
{
var poolInfo = new CommandPoolCreateInfo
{
QueueFamilyIndex = (uint)data.queueFamilyIndices.GraphicsFamily
};
commandPool = device.CreateCommandPool(poolInfo);
}
public PrimaryCommandBufferPool(Device vulkanDevice, uint FamilyIndex, int commandBufferCount)
{
this.LogicalDevice = vulkanDevice;
var createPoolInfo = new CommandPoolCreateInfo {
Flags = CommandPoolCreateFlags.ResetCommandBuffer, QueueFamilyIndex = FamilyIndex
};
this.CommandPool = LogicalDevice.CreateCommandPool(createPoolInfo);
AllocateBuffers(commandBufferCount);
}
public unsafe CommandBufferPool(GraphicsDevice graphicsDevice) : base(graphicsDevice)
{
var commandPoolCreateInfo = new CommandPoolCreateInfo
{
StructureType = StructureType.CommandPoolCreateInfo,
QueueFamilyIndex = 0, //device.NativeCommandQueue.FamilyIndex
Flags = CommandPoolCreateFlags.ResetCommandBuffer
};
commandPool = graphicsDevice.NativeDevice.CreateCommandPool(ref commandPoolCreateInfo);
}
private void CreateCommandPool()
{
var indices = new QueueFamilyIndices(vkPhysicalDevice, vkSurface);
var poolInfo = new CommandPoolCreateInfo()
{
QueueFamilyIndex = (uint)indices.GraphicsFamily,
Flags = 0,
};
vkCommandPool = vkDevice.CreateCommandPool(poolInfo);
}
public unsafe CommandPool(Api api, uint queueFamilyIndex, bool allowReset)
{
_api = api;
var poolInfo = new CommandPoolCreateInfo();
poolInfo.SType = StructureType.CommandPoolCreateInfo;
poolInfo.QueueFamilyIndex = queueFamilyIndex;
poolInfo.Flags = allowReset ? CommandPoolCreateFlags.CommandPoolCreateResetCommandBufferBit : 0;
Util.Verify(_api.Vk.CreateCommandPool(_api.Device.VkDevice, poolInfo, null, out _vkCommandPool), $"{nameof(CommandPool)}: Unable to create a command pool");
}
void CreateCommandPool(uint queue_family_index, out CommandPool pool)
{
var cmd_pool_create_info = new CommandPoolCreateInfo
{
sType = StructureType.CommandPoolCreateInfo, // VkStructureType sType
pNext = IntPtr.Zero, // const void *pNext
flags = 0, // VkCommandPoolCreateFlagBits flags
queueFamilyIndex = queue_family_index // uint32_t queueFamilyIndex
};
vk.CreateCommandPool(GetDevice, ref cmd_pool_create_info, (AllocationCallbacks *)0, out pool).CheckError();
}
CommandPool CreateCommandPool(uint queueFamily)
{
// Command pools are opaque objects that command buffer memory is allocated from, and
// which allow the implementation to amortize the cost of resource creation across multiple
// command buffers. Command pools are application-synchronized, meaning that a command pool
// must not be used concurrently in multiple threads. That includes use via recording
// commands on any command buffers allocated from the pool, as well as operations that
// allocate, free, and reset command buffers or the pool itself.
var commandPoolCreateInfo = new CommandPoolCreateInfo(queueFamily);
commandPoolCreateInfo.Flags = CommandPoolCreateFlags.ResetCommandBuffer;
return(device.CreateCommandPool(commandPoolCreateInfo));
}
private CommandPool CreateCommandPool()
{
var poolCreateInfo = new CommandPoolCreateInfo(
flags: CommandPoolCreateFlags.CommandPoolCreateResetCommandBufferBit,
queueFamilyIndex: this.QueueIndices.GraphicsFamily.Value);
CommandPool pool;
var res = VkApi.CreateCommandPool(this.Device, &poolCreateInfo, null, &pool);
if (res != Result.Success)
{
throw new VMASharp.VulkanResultException("Command Pool Creation Failed!", res);
}
return(pool);
}
CommandPool GetPool(QueueFlags type)
{
CommandPool pool;
if (pools.TryGetValue(type, out pool))
{
return(pool);
}
CommandPoolCreateInfo info = new CommandPoolCreateInfo
{
QueueFamilyIndex = GetQueue(type).queueFamilyIndex,
Flags = (uint)CommandPoolCreateFlags.ResetCommandBuffer,
};
pool = Device.CreateCommandPool(info, null);
pools.Add(type, pool);
return(pool);
}
CommandBuffer [] CreateCommandBuffers(Image [] images, Framebuffer [] framebuffers, Pipeline pipeline, Buffer vertexBuffer, Buffer indexBuffer, uint indexLength)
{
var createPoolInfo = new CommandPoolCreateInfo {
Flags = CommandPoolCreateFlags.ResetCommandBuffer
};
var commandPool = device.CreateCommandPool(createPoolInfo);
var commandBufferAllocateInfo = new CommandBufferAllocateInfo {
Level = CommandBufferLevel.Primary,
CommandPool = commandPool,
CommandBufferCount = (uint)images.Length
};
var buffers = device.AllocateCommandBuffers(commandBufferAllocateInfo);
var commandBufferBeginInfo = new CommandBufferBeginInfo();
for (int i = 0; i < images.Length; i++)
{
buffers [i].Begin(commandBufferBeginInfo);
var renderPassBeginInfo = new RenderPassBeginInfo {
Framebuffer = framebuffers [i],
RenderPass = renderPass,
ClearValues = new ClearValue [] { new ClearValue {
Color = new ClearColorValue(new float [] { 0.9f, 0.87f, 0.75f, 1.0f })
} },
RenderArea = new Rect2D {
Extent = surfaceCapabilities.CurrentExtent
}
};
buffers [i].CmdBeginRenderPass(renderPassBeginInfo, SubpassContents.Inline);
buffers [i].CmdBindDescriptorSets(PipelineBindPoint.Graphics, pipelineLayout, 0, descriptorSets, null);
buffers [i].CmdBindPipeline(PipelineBindPoint.Graphics, pipeline);
buffers [i].CmdBindVertexBuffers(0, new Buffer [] { vertexBuffer }, new DeviceSize [] { 0 });
buffers [i].CmdBindIndexBuffer(indexBuffer, 0, IndexType.Uint16);
buffers [i].CmdDrawIndexed(indexLength, 1, 0, 0, 0);
buffers [i].CmdEndRenderPass();
buffers [i].End();
}
return(buffers);
}
public unsafe Frame(uint graphicsQueueFamily, Device device, Vk vk)
{
_device = device;
_vk = vk;
FenceCreateInfo fenceCreateInfo = VkInit.FenceCreateInfo(true);
SemaphoreCreateInfo semaphoreCreateInfo = VkInit.SemaphoreCreateInfo();
VkUtil.AssertVulkan(vk.CreateFence(_device, fenceCreateInfo, null, out Fence renderFence));
VkUtil.AssertVulkan(vk.CreateSemaphore(_device, semaphoreCreateInfo, null, out Semaphore renderSemaphore));
VkUtil.AssertVulkan(vk.CreateSemaphore(_device, semaphoreCreateInfo, null, out Semaphore presentSemaphore));
RenderSemaphore = renderSemaphore;
PresentSemaphore = presentSemaphore;
RenderFence = renderFence;
CommandPoolCreateInfo commandPoolCreateInfo = VkInit.CommandPoolCreateInfo(graphicsQueueFamily, 0);
VkUtil.AssertVulkan(_vk.CreateCommandPool(_device, commandPoolCreateInfo, null, out _commandPool));
CreateCommandBuffers();
_commandBufferIndex = 0;
}
static void CreateCommandBuffer()
{
// Command pool
var commandPoolCreateInfo = new CommandPoolCreateInfo
{
QueueFamilyIndex = 0,
Flags = (uint)CommandPoolCreateFlags.ResetCommandBuffer,
};
commandPool = device.CreateCommandPool(commandPoolCreateInfo, null);
Console.WriteLine("[ OK ] Command Pool");
// Command Buffer
var commandBufferAllocationInfo = new CommandBufferAllocateInfo
{
Level = CommandBufferLevel.Primary,
CommandPool = commandPool,
CommandBufferCount = 1,
};
commandBuffer = device.AllocateCommandBuffers(commandBufferAllocationInfo);
Console.WriteLine("[ OK ] Command Buffer");
}
public unsafe CommandPool CreateCommandPool(ref CommandPoolCreateInfo createInfo, AllocationCallbacks* allocator = null)
{
CommandPool commandPool;
fixed (CommandPoolCreateInfo* __createInfo__ = &createInfo)
{
vkCreateCommandPool(this, __createInfo__, allocator, &commandPool).CheckError();
}
return commandPool;
}
protected virtual void CreateCommandBuffer()
{
// Command pool
var commandPoolCreateInfo = new CommandPoolCreateInfo
{
StructureType = StructureType.CommandPoolCreateInfo,
QueueFamilyIndex = 0,
Flags = CommandPoolCreateFlags.ResetCommandBuffer
};
commandPool = device.CreateCommandPool(ref commandPoolCreateInfo);
// Command buffer
var commandBufferAllocationInfo = new CommandBufferAllocateInfo
{
StructureType = StructureType.CommandBufferAllocateInfo,
Level = CommandBufferLevel.Primary,
CommandPool = commandPool,
CommandBufferCount = 1
};
CommandBuffer commandBuffer;
device.AllocateCommandBuffers(ref commandBufferAllocationInfo, &commandBuffer);
this.commandBuffer = commandBuffer;
}
/// <summary>
/// Initializes the specified device.
/// </summary>
/// <param name="graphicsProfiles">The graphics profiles.</param>
/// <param name="deviceCreationFlags">The device creation flags.</param>
/// <param name="windowHandle">The window handle.</param>
private unsafe void InitializePlatformDevice(GraphicsProfile[] graphicsProfiles, DeviceCreationFlags deviceCreationFlags, object windowHandle)
{
if (nativeDevice != Device.Null)
{
// Destroy previous device
ReleaseDevice();
}
rendererName = Adapter.Description;
PhysicalDeviceProperties physicalDeviceProperties;
NativePhysicalDevice.GetProperties(out physicalDeviceProperties);
ConstantBufferDataPlacementAlignment = (int)physicalDeviceProperties.Limits.MinUniformBufferOffsetAlignment;
RequestedProfile = graphicsProfiles.Last();
var queueProperties = NativePhysicalDevice.QueueFamilyProperties;
// Command lists are thread-safe and execute deferred
IsDeferred = true;
// TODO VULKAN
// Create Vulkan device based on profile
uint queuePriorities = 0;
var queueCreateInfo = new DeviceQueueCreateInfo
{
StructureType = StructureType.DeviceQueueCreateInfo,
QueueFamilyIndex = 0,
QueueCount = 1,
QueuePriorities = new IntPtr(&queuePriorities)
};
var enabledFeature = new PhysicalDeviceFeatures
{
FillModeNonSolid = true,
ShaderClipDistance = true,
ShaderCullDistance = true,
SamplerAnisotropy = true,
DepthClamp = true,
};
var extensionProperties = NativePhysicalDevice.GetDeviceExtensionProperties();
var availableExtensionNames = new List <string>();
var desiredExtensionNames = new List <string>();
for (int index = 0; index < extensionProperties.Length; index++)
{
var namePointer = new IntPtr(Interop.Fixed(ref extensionProperties[index].ExtensionName));
var name = Marshal.PtrToStringAnsi(namePointer);
availableExtensionNames.Add(name);
}
desiredExtensionNames.Add("VK_KHR_swapchain");
if (!availableExtensionNames.Contains("VK_KHR_swapchain"))
{
throw new InvalidOperationException();
}
if (availableExtensionNames.Contains("VK_EXT_debug_marker") && IsDebugMode)
{
desiredExtensionNames.Add("VK_EXT_debug_marker");
IsProfilingSupported = true;
}
var enabledExtensionNames = desiredExtensionNames.Select(Marshal.StringToHGlobalAnsi).ToArray();
try
{
var deviceCreateInfo = new DeviceCreateInfo
{
StructureType = StructureType.DeviceCreateInfo,
QueueCreateInfoCount = 1,
QueueCreateInfos = new IntPtr(&queueCreateInfo),
EnabledExtensionCount = (uint)enabledExtensionNames.Length,
EnabledExtensionNames = enabledExtensionNames.Length > 0 ? new IntPtr(Interop.Fixed(enabledExtensionNames)) : IntPtr.Zero,
EnabledFeatures = new IntPtr(&enabledFeature)
};
nativeDevice = NativePhysicalDevice.CreateDevice(ref deviceCreateInfo);
}
finally
{
foreach (var enabledExtensionName in enabledExtensionNames)
{
Marshal.FreeHGlobal(enabledExtensionName);
}
}
NativeCommandQueue = nativeDevice.GetQueue(0, 0);
//// Prepare copy command list (start it closed, so that every new use start with a Reset)
var commandPoolCreateInfo = new CommandPoolCreateInfo
{
StructureType = StructureType.CommandPoolCreateInfo,
QueueFamilyIndex = 0, //device.NativeCommandQueue.FamilyIndex
Flags = CommandPoolCreateFlags.ResetCommandBuffer
};
NativeCopyCommandPool = NativeDevice.CreateCommandPool(ref commandPoolCreateInfo);
var commandBufferAllocationInfo = new CommandBufferAllocateInfo
{
StructureType = StructureType.CommandBufferAllocateInfo,
Level = CommandBufferLevel.Primary,
CommandPool = NativeCopyCommandPool,
CommandBufferCount = 1
};
CommandBuffer nativeCommandBuffer;
NativeDevice.AllocateCommandBuffers(ref commandBufferAllocationInfo, &nativeCommandBuffer);
NativeCopyCommandBuffer = nativeCommandBuffer;
DescriptorPools = new HeapPool(this);
nativeResourceCollector = new NativeResourceCollector(this);
graphicsResourceLinkCollector = new GraphicsResourceLinkCollector(this);
EmptyTexelBuffer = Buffer.Typed.New(this, 1, PixelFormat.R32G32B32A32_Float);
}
internal static unsafe extern Result vkCreateCommandPool(Device device, CommandPoolCreateInfo* createInfo, AllocationCallbacks* allocator, CommandPool* commandPool);
