Vulkan 学习笔记：Command Buffers

最新推荐文章于 2024-06-29 09:11:46 发布
最新推荐文章于 2024-06-29 09:11:46 发布
阅读量487 收藏
点赞数
分类专栏： Vulkan 文章标签： 学习 图形渲染
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/one_chow_chow/article/details/127621876
版权

单个command buffer代码

#include "Renderer.h"

int main() {
	Renderer r;
	// need to send command into command pool when creating a window
	auto device = r._device;
	auto queue = r._queue;

	// Fence
	// wait for the gpu to be ready on the cpu side?
	// cpu wait for gpu
	VkFence fence;
	VkFenceCreateInfo fence_create_info{};
	fence_create_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
	vkCreateFence(device, &fence_create_info, nullptr, &fence);

	// Semaphore
	// semaphore tells gpu when other process completed
	VkSemaphore semaphore;
	VkSemaphoreCreateInfo semaphore_create_info{};
	semaphore_create_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
	vkCreateSemaphore(device ,&semaphore_create_info, nullptr, &semaphore);
	//semaphore_create_info.flag
	
	// Command Pool
	// allocate command buffers in a pool
	// as destroy pool, also destroy all buffers
	VkCommandPool command_pool;
	VkCommandPoolCreateInfo pool_create_info{};
	pool_create_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
	pool_create_info.queueFamilyIndex = r._graphics_family_index;// probably which queue to execute the commmand
	pool_create_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;

	std::cout << "Command Pool Created" << std::endl;
	ErrorCheck(vkCreateCommandPool(device, &pool_create_info, nullptr, &command_pool));

	// Command Buffer
	VkCommandBuffer command_buffer;
	VkCommandBufferAllocateInfo command_buffer_allocate_info{};
	command_buffer_allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
	command_buffer_allocate_info.commandPool = command_pool;
	command_buffer_allocate_info.commandBufferCount = 1;// how many command buffer to allocate for the pool
	command_buffer_allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;//
	// initial state
	vkAllocateCommandBuffers(device, &command_buffer_allocate_info, &command_buffer);
	{
		
		VkCommandBufferBeginInfo begin_info{};
		begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
		//begin_info.flags = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
		// recording state
		vkBeginCommandBuffer(command_buffer, &begin_info);

		// vkCmd...

		// need to set viewport per command buffer
		VkViewport viewport{};
		viewport.maxDepth = 1.0f;
		viewport.minDepth = 0.0f;
		viewport.width = 512;
		viewport.height = 512;
		viewport.x = 0;
		viewport.y = 0;
		vkCmdSetViewport(command_buffer, 0, 1, &viewport);

		// executable state, end recording compile the cb on gpu?? 
		vkEndCommandBuffer(command_buffer);
	}
	{
		// submit command buffer to gpu
		VkSubmitInfo submit_info{};
		submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
		submit_info.commandBufferCount = 1;
		submit_info.pCommandBuffers = &command_buffer;

		// submit command buffer to gpu
		vkQueueSubmit(queue, 1, &submit_info, fence);
	}
	// true: need to wait for all fence to complete before continue, false: wait only 1 fence
	vkWaitForFences(device, 1, &fence, VK_TRUE, UINT64_MAX);

	// gpu works concurrently with cpu, wait for the queue
	// wait for the submit to be done
	// if commented , error: Attempt to destroy command pool with VkCommandBuffer 0x2109f440ab0[] which is in use.
	// because command buffer wasn't complete on gpu when cpu tries to delete it,need to wait on cpu side
	vkQueueWaitIdle(queue);

	// destroy command pool
	vkDestroyCommandPool(device, command_pool, nullptr);
	vkDestroyFence(device, fence, nullptr);
}

多个command buffer，将如下部分替换（//***）
用semaphore做不同gpu command buffer间的同步

// Command Buffer
VkCommandBuffer command_buffer[2];//***
VkCommandBufferAllocateInfo command_buffer_allocate_info{};
command_buffer_allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
command_buffer_allocate_info.commandPool = command_pool;
command_buffer_allocate_info.commandBufferCount = 2;// ***
command_buffer_allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
// initial state
vkAllocateCommandBuffers(device, &command_buffer_allocate_info, command_buffer);// ***
{
	
	VkCommandBufferBeginInfo begin_info{};
	begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
	//begin_info.flags = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
	// recording state
	vkBeginCommandBuffer(command_buffer[0], &begin_info);// ***

	// vkCmd...

	// need to set viewport per command buffer
	VkViewport viewport{};
	viewport.maxDepth = 1.0f;
	viewport.minDepth = 0.0f;
	viewport.width = 512;
	viewport.height = 512;
	viewport.x = 0;
	viewport.y = 0;
	vkCmdSetViewport(command_buffer[0], 0, 1, &viewport);// ***

	// executable state, end recording compile the cb on gpu?? 
	vkEndCommandBuffer(command_buffer[0]);// ***
}
{

	VkCommandBufferBeginInfo begin_info{};
	begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
	//begin_info.flags = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
	// recording state
	vkBeginCommandBuffer(command_buffer[1], &begin_info);// ***

	// vkCmd...

	// need to set viewport per command buffer
	VkViewport viewport{};
	viewport.maxDepth = 1.0f;
	viewport.minDepth = 0.0f;
	viewport.width = 512;
	viewport.height = 512;
	viewport.x = 0;
	viewport.y = 0;
	vkCmdSetViewport(command_buffer[1], 0, 1, &viewport);// ***

	// executable state, end recording compile the cb on gpu?? 
	vkEndCommandBuffer(command_buffer[1]);// ***
}
{
	// submit command buffer to gpu
	VkSubmitInfo submit_info{};
	submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
	submit_info.commandBufferCount = 1;
	submit_info.pCommandBuffers = &command_buffer[0];// ***
	submit_info.signalSemaphoreCount = 1;// ***
	submit_info.pSignalSemaphores = &semaphore;// signal the semaphore// ***

	vkQueueSubmit(queue, 1, &submit_info, VK_NULL_HANDLE);// ***
}
{
	//VkPipelineStageFlags flags[]{ VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT };
	VkPipelineStageFlags flags[]{ VK_PIPELINE_STAGE_ALL_COMMANDS_BIT };// all need to be done after signaled// ***
	// submit command buffer to gpu
	VkSubmitInfo submit_info{};
	submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
	submit_info.commandBufferCount = 1;
	submit_info.pCommandBuffers = &command_buffer[1];// ***
	submit_info.waitSemaphoreCount = 1;
	submit_info.pWaitSemaphores = &semaphore;// ***
	// where we are going to wait for semaphores, as signaled then access certain stage
	// as the command buffer reaches fragment shader stage, it wait for the semaphore
	submit_info.pWaitDstStageMask = flags;// pipeline stage mask// ***

	// submit command buffer to gpu
	vkQueueSubmit(queue, 1, &submit_info, VK_NULL_HANDLE);// ***
}

// true: need to wait for all fence to complete before continue, false: wait only 1 fence
//vkWaitForFences(device, 1, &fence, VK_TRUE, UINT64_MAX);
vkQueueWaitIdle(queue);

// destroy command pool
vkDestroyCommandPool(device, command_pool, nullptr);
vkDestroyFence(device, fence, nullptr);
vkDestroySemaphore(device, semaphore, nullptr);

课程结束完整代码
main.cpp

#include "Renderer.h"

int main() {
	Renderer r;
	// need to send command into command pool when creating a window
	auto device = r._device;
	auto queue = r._queue;

	// Fence
	// wait for the gpu to be ready on the cpu side?
	// cpu wait for gpu
	VkFence fence;
	VkFenceCreateInfo fence_create_info{};
	fence_create_info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
	vkCreateFence(device, &fence_create_info, nullptr, &fence);

	// Semaphore
	// semaphore tells gpu when other process completed
	VkSemaphore semaphore;
	VkSemaphoreCreateInfo semaphore_create_info{};
	semaphore_create_info.sType = VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO;
	vkCreateSemaphore(device ,&semaphore_create_info, nullptr, &semaphore);
	//semaphore_create_info.flag
	
	// Command Pool
	// allocate command buffers in a pool
	// as destroy pool, also destroy all buffers
	VkCommandPool command_pool;
	VkCommandPoolCreateInfo pool_create_info{};
	pool_create_info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
	pool_create_info.queueFamilyIndex = r._graphics_family_index;// probably which queue to execute the commmand
	pool_create_info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;

	std::cout << "Command Pool Created" << std::endl;
	ErrorCheck(vkCreateCommandPool(device, &pool_create_info, nullptr, &command_pool));

	// Command Buffer
	VkCommandBuffer command_buffer[2];
	VkCommandBufferAllocateInfo command_buffer_allocate_info{};
	command_buffer_allocate_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
	command_buffer_allocate_info.commandPool = command_pool;
	command_buffer_allocate_info.commandBufferCount = 2;// how many command buffer to allocate for the pool
	command_buffer_allocate_info.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;//
	// initial state
	vkAllocateCommandBuffers(device, &command_buffer_allocate_info, command_buffer);
	{
		
		VkCommandBufferBeginInfo begin_info{};
		begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
		//begin_info.flags = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
		// recording state
		vkBeginCommandBuffer(command_buffer[0], &begin_info);

		// vkCmd...
		vkCmdPipelineBarrier(command_buffer[0], VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, nullptr, 0, nullptr, 0, nullptr);

		// need to set viewport per command buffer
		VkViewport viewport{};
		viewport.maxDepth = 1.0f;
		viewport.minDepth = 0.0f;
		viewport.width = 512;
		viewport.height = 512;
		viewport.x = 0;
		viewport.y = 0;
		vkCmdSetViewport(command_buffer[0], 0, 1, &viewport);

		// executable state, end recording compile the cb on gpu?? 
		vkEndCommandBuffer(command_buffer[0]);
	}
	{

		VkCommandBufferBeginInfo begin_info{};
		begin_info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
		//begin_info.flags = VK_COMMAND_BUFFER_USAGE_RENDER_PASS_CONTINUE_BIT;
		// recording state
		vkBeginCommandBuffer(command_buffer[1], &begin_info);

		// vkCmd...

		// need to set viewport per command buffer
		VkViewport viewport{};
		viewport.maxDepth = 1.0f;
		viewport.minDepth = 0.0f;
		viewport.width = 512;
		viewport.height = 512;
		viewport.x = 0;
		viewport.y = 0;
		vkCmdSetViewport(command_buffer[1], 0, 1, &viewport);

		// executable state, end recording compile the cb on gpu?? 
		vkEndCommandBuffer(command_buffer[1]);
	}
	{
		// submit command buffer to gpu
		VkSubmitInfo submit_info{};
		submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
		submit_info.commandBufferCount = 1;
		submit_info.pCommandBuffers = &command_buffer[0];
		submit_info.signalSemaphoreCount = 1;
		submit_info.pSignalSemaphores = &semaphore;// signal the semaphore

		// submit command buffer to gpu
		//vkQueueSubmit(queue, 1, &submit_info, fence);
		vkQueueSubmit(queue, 1, &submit_info, VK_NULL_HANDLE);
	}
	{
		//VkPipelineStageFlags flags[]{ VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT };
		VkPipelineStageFlags flags[]{ VK_PIPELINE_STAGE_ALL_COMMANDS_BIT };// all need to be done after signaled
		// submit command buffer to gpu
		VkSubmitInfo submit_info{};
		submit_info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
		submit_info.commandBufferCount = 1;
		submit_info.pCommandBuffers = &command_buffer[1];
		submit_info.waitSemaphoreCount = 1;
		submit_info.pWaitSemaphores = &semaphore;
		// where we are going to wait for semaphores, as signaled then access certain stage
		// as the command buffer reaches fragment shader stage, it wait for the semaphore
		submit_info.pWaitDstStageMask = flags;// pipeline stage mask

		// submit command buffer to gpu
		vkQueueSubmit(queue, 1, &submit_info, VK_NULL_HANDLE);
	}

	// true: need to wait for all fence to complete before continue, false: wait only 1 fence
	//vkWaitForFences(device, 1, &fence, VK_TRUE, UINT64_MAX);

	// gpu works concurrently with cpu, wait for the queue
	// wait for the submit to be done
	// if commented , error: Attempt to destroy command pool with VkCommandBuffer 0x2109f440ab0[] which is in use.
	// because command buffer wasn't complete on gpu when cpu tries to delete it,need to wait on cpu side
	vkQueueWaitIdle(queue);

	// destroy command pool
	vkDestroyCommandPool(device, command_pool, nullptr);
	vkDestroyFence(device, fence, nullptr);
	vkDestroySemaphore(device, semaphore, nullptr);
}

Render.cpp

#include "Renderer.h"

Renderer::Renderer() {
	_SetupDebug();
	_InitInstance();
	_InitDebug();
	_InitDevice();
}

Renderer::~Renderer() {
	_DeInitDevice();
	_DeInitDebug();
	_DeInitInstance();
}

void Renderer::_InitInstance()
{
	VkApplicationInfo application_info{};
	application_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
	application_info.apiVersion = VK_API_VERSION_1_3;//tells driver api version
	application_info.applicationVersion = VK_MAKE_VERSION(0, 1, 0);
	application_info.pApplicationName = "Vulkan_tutorial_1";

	VkInstanceCreateInfo instance_create_info{};
	instance_create_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
	instance_create_info.pApplicationInfo = &application_info;
	instance_create_info.enabledLayerCount = _instance_layers.size();
	instance_create_info.ppEnabledLayerNames = _instance_layers.data();
	instance_create_info.enabledExtensionCount = _instance_extensions.size();
	instance_create_info.ppEnabledExtensionNames = _instance_extensions.data();
	//instance_create_info.pNext = &debug_callback_create_info;// add loader message

	//std::cout << "Vulkan Instance create error check" << std::endl;
	ErrorCheck(vkCreateInstance(&instance_create_info, nullptr, &_Instance));
}

void Renderer::_DeInitInstance() {
	vkDestroyInstance(_Instance, nullptr);
	_Instance = nullptr;

}

void Renderer::_InitDevice()
{
	// give the logical device used to render
	{
		uint32_t gpu_count = 0;
		// return gpu_count
		vkEnumeratePhysicalDevices(_Instance, &gpu_count, nullptr);
		std::vector<VkPhysicalDevice> gpu_list(gpu_count);
		// return the number of handles actually written to pPhysicalDevices
		vkEnumeratePhysicalDevices(_Instance, &gpu_count, gpu_list.data());
		_gpu = gpu_list[0];
		// properties are returned
		vkGetPhysicalDeviceProperties(_gpu, &_gpu_properties);
	}
	{
		// get _graphics_family_index
		// similarly query properties of queues available on a physical device
		uint32_t family_count = 0;
		vkGetPhysicalDeviceQueueFamilyProperties(_gpu, &family_count, nullptr);
		std::vector<VkQueueFamilyProperties> family_property_list{ family_count };
		vkGetPhysicalDeviceQueueFamilyProperties(_gpu, &family_count, family_property_list.data());

		bool found = false;
		for (uint32_t i = 0; i < family_count; ++i) {
			// VK_QUEUE_GRAPHICS_BIT specifies that queues in this queue family support graphics operations.
			if (family_property_list[i].queueFlags & VK_QUEUE_GRAPHICS_BIT) {
				found = true;
				_graphics_family_index = i;
			}
		}
		if (!found) {
			assert(0 && "VULKAN ERROR: QUEUE FAMILY SUPPORT NOT FOUND");
			std::cout << "VULKAN ERROR: QUEUE FAMILY SUPPORT NOT FOUND " << std::endl;
			std::exit(-1);
		}
	}
	{
		// how many instance layers, instances
		uint32_t layer_count = 0;
		vkEnumerateInstanceLayerProperties(&layer_count, nullptr);
		std::vector<VkLayerProperties> layer_property_list(layer_count);
		// gives the layer currently installed in the system
		vkEnumerateInstanceLayerProperties(&layer_count, layer_property_list.data());
		std::cout << "instance_layers " << std::endl;
		for (auto& i : layer_property_list) {
			std::cout << " " << i.layerName << "\t\t  | " << i.description << std::endl;
		}
		std::cout << std::endl;
		/*
		instance_layers
		 VK_LAYER_AMD_switchable_graphics                 | AMD switchable graphics layer
		 VK_LAYER_RENDERDOC_Capture               | Debugging capture layer for RenderDoc
		 VK_LAYER_LUNARG_api_dump                 | LunarG API dump layer
		 VK_LAYER_LUNARG_gfxreconstruct           | GFXReconstruct Capture Layer Version 0.9.15
		 VK_LAYER_KHRONOS_synchronization2                | Khronos Synchronization2 layer
		 VK_LAYER_KHRONOS_validation              | Khronos Validation Layer
		 VK_LAYER_LUNARG_monitor                  | Execution Monitoring Layer
		 VK_LAYER_LUNARG_screenshot               | LunarG image capture layer
		 VK_LAYER_KHRONOS_profiles                | Khronos Profiles layer
		*/
	}
	{
		// how many instance layers, instances
		uint32_t layer_count = 0;
		vkEnumerateDeviceLayerProperties(_gpu, &layer_count, nullptr);
		std::vector<VkLayerProperties> layer_property_list(layer_count);
		// gives the layer currently installed in the system
		vkEnumerateDeviceLayerProperties(_gpu, &layer_count, layer_property_list.data());
		std::cout << "device_layers " << std::endl;
		for (auto& i : layer_property_list) {
			std::cout << " " << i.layerName << "\t\t  | " << i.description << std::endl;
		}
		std::cout << std::endl;
	}

	float queue_priorities[]{ 1.0f };
	VkDeviceQueueCreateInfo  device_queue_create_info{};
	device_queue_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
	device_queue_create_info.queueFamilyIndex = _graphics_family_index;
	device_queue_create_info.queueCount = 1;
	device_queue_create_info.pQueuePriorities = queue_priorities;

	VkDeviceCreateInfo device_create_info{};
	device_create_info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
	device_create_info.queueCreateInfoCount = 1;
	device_create_info.pQueueCreateInfos = &device_queue_create_info;
	device_create_info.enabledLayerCount = _device_layers.size();
	device_create_info.ppEnabledLayerNames = _device_layers.data();
	device_create_info.enabledExtensionCount = _device_extensions.size();
	device_create_info.ppEnabledExtensionNames = _device_extensions.data();

	// return device
	//std::cout << "VULKAN ERROR: QUEUE FAMILY SUPPORTING GRAPHICS NOT FOUND CHECK" << std::endl;
	ErrorCheck(vkCreateDevice(_gpu, &device_create_info, nullptr, &_device));

	// fetch the queue handle
	vkGetDeviceQueue(_device, _graphics_family_index, 0, &_queue);// 0 < queue_count_family = 1
}

void Renderer::_DeInitDevice() {
	vkDestroyDevice(_device, nullptr);
	_device = nullptr;
}

VKAPI_ATTR VkBool32  VKAPI_CALL
VulkanDebugCallBack(
	VkDebugReportFlagsEXT flags,// VkDebugReportCallbackCreateInfoEXT.flags
	VkDebugReportObjectTypeEXT obj_type,
	uint64_t src_obj,
	size_t location,
	int32_t msg_code,
	const char* layer_prefix,
	const char* msg,
	void* user_data

)
{
	// flags has bit on xxx
	if (flags & VK_DEBUG_REPORT_INFORMATION_BIT_EXT) {
		std::cout << "DEBUG INFO: ";
	}
	if (flags & VK_DEBUG_REPORT_WARNING_BIT_EXT) {
		std::cout << "DEBUG WARNING: ";
	}
	if (flags & VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT) {
		std::cout << "DEBUG PERFORMANCE_WARNING: ";
	}
	if (flags & VK_DEBUG_REPORT_ERROR_BIT_EXT) {
		std::cout << "DEBUG ERROR: ";
	}
	if (flags & VK_DEBUG_REPORT_DEBUG_BIT_EXT) {
		std::cout << "DEBUG DEBUG: ";
	}
	std::cout << "@[ " << layer_prefix << " ]: ";
	std::cout << msg << std::endl;
	return false;
}

void Renderer::_SetupDebug()
{
	debug_callback_create_info.sType = VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT;
	debug_callback_create_info.pfnCallback = VulkanDebugCallBack;//  PFN_vkDebugReportCallbackEXT
	debug_callback_create_info.flags = VK_DEBUG_REPORT_INFORMATION_BIT_EXT | \
		VK_DEBUG_REPORT_WARNING_BIT_EXT | \
		VK_DEBUG_REPORT_PERFORMANCE_WARNING_BIT_EXT | \
		VK_DEBUG_REPORT_ERROR_BIT_EXT | \
		VK_DEBUG_REPORT_DEBUG_BIT_EXT;

	// layer needed to use is in the device, must be in the instance

	_instance_layers.push_back("VK_LAYER_KHRONOS_validation");
	_device_layers.push_back("VK_LAYER_KHRONOS_validation");

	//_instance_layers.push_back("VK_LAYER_AMD_switchable_graphics");
	//_device_layers.push_back("VK_LAYER_AMD_switchable_graphics");

	_instance_layers.push_back("VK_LAYER_RENDERDOC_Capture");
	_device_layers.push_back("VK_LAYER_RENDERDOC_Capture");

	// too much info
	//_instance_layers.push_back("VK_LAYER_LUNARG_api_dump");
	//_device_layers.push_back("VK_LAYER_LUNARG_api_dump");

	_instance_layers.push_back("VK_LAYER_LUNARG_gfxreconstruct");
	_device_layers.push_back("VK_LAYER_LUNARG_gfxreconstruct");

	// VK_ERROR_LAYER_NOT_PRESENT
	//_instance_layers.push_back(" VK_LAYER_KHRONOS_synchronization2");
	//_device_layers.push_back(" VK_LAYER_KHRONOS_synchronization2");

	//_instance_layers.push_back("VK_LAYER_LUNARG_monitor");
	//_device_layers.push_back("VK_LAYER_LUNARG_monitor");

	//_instance_layers.push_back("VK_LAYER_LUNARG_screenshot");
	//_device_layers.push_back("VK_LAYER_LUNARG_screenshot");

	//_instance_layers.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
	_instance_extensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);
	//_device_extensions.push_back(VK_EXT_DEBUG_REPORT_EXTENSION_NAME);

	// VK_ERROR_LAYER_NOT_PRESENT
	//_instance_layers.push_back(" VK_LAYER_KHRONOS_profiles");
	//_device_layers.push_back(" VK_LAYER_KHRONOS_profiles");



}

PFN_vkCreateDebugReportCallbackEXT fvkCreateDebugReportCallbackEXT = nullptr;
PFN_vkDestroyDebugReportCallbackEXT fvkDestroyDebugReportCallbackEXT = nullptr;

void Renderer::_InitDebug()
{
	// function pointer??
	fvkCreateDebugReportCallbackEXT = (PFN_vkCreateDebugReportCallbackEXT)vkGetInstanceProcAddr(_Instance, "vkCreateDebugReportCallbackEXT");
	fvkDestroyDebugReportCallbackEXT = (PFN_vkDestroyDebugReportCallbackEXT)vkGetInstanceProcAddr(_Instance, "vkDestroyDebugReportCallbackEXT");
	if (nullptr == fvkCreateDebugReportCallbackEXT || nullptr == fvkDestroyDebugReportCallbackEXT) {
		assert(0 && "Vulkan can't take debug function pointer");
		std::cout << "Vulkan can't take debug function pointer" << std::endl;
		std::exit(-1);
	}


	//std::cout << "Vulkan failed to set up a debug message check" << std::endl;
	ErrorCheck(fvkCreateDebugReportCallbackEXT(_Instance, &debug_callback_create_info, nullptr, &_debug_report));

	//fvkCreateDebugReportCallbackEXT(_Instance, nullptr, nullptr, nullptr);
}

void Renderer::_DeInitDebug()
{
	fvkDestroyDebugReportCallbackEXT(_Instance, _debug_report, nullptr);
	_debug_report = VK_NULL_HANDLE;
}

Render.h

#pragma once

#include <vulkan/vulkan.h>
#include "Shared.h"
#include <vector>
#include <iostream>
#include <cstdlib>
#include <assert.h>

class Renderer
{
public:
	Renderer();
	~Renderer();
//private:
	void _InitInstance();
	void _DeInitInstance();

	void _InitDevice();
	void _DeInitDevice();

	void _SetupDebug();
	void _InitDebug();
	void _DeInitDebug();

	VkInstance _Instance = VK_NULL_HANDLE;
	VkPhysicalDevice _gpu = VK_NULL_HANDLE;
	VkDevice _device = VK_NULL_HANDLE;
	VkPhysicalDeviceProperties _gpu_properties = {};
	VkQueue _queue = VK_NULL_HANDLE;

	uint32_t _graphics_family_index = 0;

	std::vector<const char*> _instance_layers;
	std::vector<const char*> _instance_extensions;
	std::vector<const char*> _device_layers;
	std::vector<const char*> _device_extensions;

	VkDebugReportCallbackEXT _debug_report = VK_NULL_HANDLE;

	VkDebugReportCallbackCreateInfoEXT debug_callback_create_info{};

};
Nemoxy
关注
专栏目录
Vulkan小白 - Command Buffer
笔落梦昙的博客
05-09 689
   vkspec.html#commandbuffers Engaging the Voyage to Vulkan
Vulkan 学习笔记：创建Window
Nemoxy的博客
11-01 520
用windows.h创建简单窗口，供vulkan调用
Vulkan Tutorial 16 Command buffers
weixin_30672295的博客
06-15 82
操作系统:Windows8.1 显卡:Nivida GTX965M 开发工具：Visual Studio 2017 诸如绘制和内存操作相关命令，在Vulkan中不是通过函数直接调用的。我们需要在命令缓冲区对象中记录我们期望的任何操作。这样做的优点是可以提前在多线程中完成所有绘制命令相关的装配工作，并在主线程循环结构中通知Vulkan执行具体的命令。 Command pools ...
Vulkan学习（五）: Command buffers & Rendering & Presentation
jiamada的博客
05-31 745
目录FramebuffersCommand buffersCommand poolsCommand buffer allocationStarting command buffer recordingStarting a render passBasic drawing commands & Finishing up Framebuffers   在render pass创建期间指定attachments ，并绑定到VkFramebuffer对象。 framebuffer引用所有VkImageVie
Command Buffers In Unity
zengjunjie59的博客
05-20 1362
Command Buffers In Unity 1、参考文档：1、Unity官方文档:https://docs.unity3d.com/Manual/GraphicsCommandBuffers.html2、Unity官方API:https://docs.unity3d.com/ScriptReference/Rendering.CommandBuffer.html3、CSDN 博客:http://blog.csdn.net/puppet_master/article/details/726699772
【转载】Vulkan 1.2 知识串讲（2）—— COMMAND BUFFER
hbar1973的博客
03-11 1610
【转载】Vulkan 1.2 知识串讲（2）—— COMMAND BUFFER 文章转自 电子设备中的画家|王烁 于 2021 年 4 月 29 日发表 上一节聊到了instance、physical device、logical device、queue的概念，这一节我们继续往上聊，下一个就是command buffer。 Command buffer用于录制command，然后submit到queue中，进行执行。Command buffer有两种类型，primary command buffer，可以
Vulkan入门系列4 - Command Buffers 和 Secondary Command Buffers
最新发布
GPU全栈博主-程序哥
06-29 332
在前面入门系列2中(Vulkan入门系列2- 绘制三角形)，我们了解Vulkan绘制三角形的全过程，对Vulkan绘制流程和主要模块有了全局的了解，接下来是从局部介绍Vulkan中的主要模块，本节介绍 Command Buffers 和 Secondary Command Buffers。在Vulkan中，像绘制操作，内存传输等命令，不能通过函数调用的方式直接执行。必须将这些命令记录命令缓冲区对象中，即记录在Command Buffers中。
vulkan-guide:vulkan入门指南
04-30
在"vulkan-guide:vulkan入门指南"中，你将找到一系列逐步的教程，帮助你从零开始学习Vulkan。这份指南通常会涵盖以下几个关键知识点： 1. **基础知识**：首先，你会接触到Vulkan的基本概念，如设备、实例、物理设备...
Vulkan2DRenderer:使用Vulkan API作为后端的易于使用的2D渲染引擎
05-15
Vulkan 2D渲染器库 :red_exclamation_mark: 该项目正在进行中（pre-alpha）。 API频繁更改，ABI更改，崩溃... :red_exclamation_mark: Vulkan 2D渲染器是一个C ++ 17库，旨在为实时应用程序提供易于使用的高性能2D...
Vortice.Vulkan：https：www.khronos.orgvulkan的跨平台.NET绑定
02-05
Vortice.Vulkan是 API的低级绑定。 学分 Vortice.Vulkan的开发，贡献和错误修正，方法如下： 阿梅尔·科莱奇 思想和发电机部分是基于 其他类似项目： 使用Vortice.Vulkan的项目： 赞助商 为了进一步帮助开发这些...
vulkan中文教程
03-22
vulkan在国内几乎没有什么资料可以参考，本着分享的想法，为广大想要学习vulkan的道友们提供一点帮助，拿走不谢 声明，这不是本人自己翻译的，也是从别人那里下载的
Vulkan教程翻译之五 创建 Command Buffer
Bleach3的博客
05-07 905
创建 Command Buffer 这一章节的代码文件是04-init_command_buffer.cpp。 基础的 Command Buffer 操作 在其他图形API里，应用也许会通过API调用来设置某个属性，比如调用 glLineWidth() 设置线条宽度。在底层，驱动把API调用转换成GPU特定的命令，并且该命令放到 command buffer 里。驱动还通过创建和销毁 co...
3.72 Command Buffer及URP概述
s178435865的专栏
10-29 910
3.72 Command Buffer及URP概述
[Vulkan教程]绘制一个三角形/绘制/命令缓冲（Command buffers）
楚栋浩的博客
10-23 721
[Vulkan教程]绘制一个三角形/绘制/命令缓冲（Command buffers）
Unity ECS 对数据改变有两种方法，Entity command buffers (ECB)和EntityManager
尘封的羽翼
05-10 739
1、创建，销毁Entity，以及对Entity的结构进行更改（比如增加删除Component）都要通过EntityManager等接口来实现。主线程实现Componet 数据操作修改。在Job中需要通过Entity Command Buffer实现对Entity修改操作的记录；在Job中，只能实现对Entity的Component组件进行数据修改的功能。2、如果你想将一个job中修改Component 修改，就必须使用ECB。//都是实现了主线程对Componet 数据操作修改。//传入到job中使用。
VULKAN-04-init_command_buffer 研究[完善中doing]
计算机视觉算法、工程、产品
01-11 159
/* VULKAN_SAMPLE_SHORT_DESCRIPTION Create Vulkan command buffer */ /* This is part of the draw cube progression */ #include <util_init.hpp> #include <assert.h> #include <cstdlib> int sample_main(int argc, char *argv[]) { VkResult .
Hello Vulkan（六）| 图形渲染新技术Vulkan Command Buffers及光追
虹图AI开放平台是基于虹图自研的AI能力，打造的围绕音视频等应用场景的AI技术开放平台。提供人像人体特效、人体行为分析、内容审核、人脸实名认证、图像特效等视觉AI技术，加速AI为中小企业业务赋能。
02-24 385
本期将继续分享关于Vulkan的关于「CommandBuffers」以及「光追RayTracing」，本期也将会是我们此次教程的最后一章了，后续会再推出其他系列讲解，也会加入我们虹图产品在不同平台的使用方法教程和一些有趣的使用场景分享。
vulakn教程--Drawing a Triangle--Draw--CommandBuffer
lbknxy的专栏
09-20 1517
原文地址 ： vulkan-tutorialCommand buffers在Vulkan中，像绘画命令、内存转换等操作并不是直接通过方法调用去完成的，而是需要把所有的操作放在Command Buffer 里。这样的一个好处就是：那些已设置好的具有难度的绘图工作都可以在多线程的情况下提前完成。Command poolsCommand pools 管理Command buffer 的内存而且Comma
初始Vulkun（12）：命令缓冲区（Command buffers）
weixin_44200074的博客
08-09 1280
创建命令缓冲区记录绘制命令
Vulkan编程指南：权威的Vulkan学习手册
"《Vulkan编程指南：Vulkan官方学习指南》是一本全面介绍Vulkan图形API的专业书籍，由Vulkan API的主要负责人Graham Sellers撰写，并得到语言负责人John Kessenich的贡献。本书旨在帮助有经验的图形程序员理解和掌握...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值