virtual void render()
{
if (!prepared)
return;
vkDeviceWaitIdle(device);
draw();
vkDeviceWaitIdle(device);
}
virtual void render()
{
if (!prepared)
return;
vkDeviceWaitIdle(device);
draw();
vkDeviceWaitIdle(device);
updateUniformBuffers();
}
virtual void render()
{
if (!prepared)
return;
vkDeviceWaitIdle(device);
draw();
vkDeviceWaitIdle(device);
if (!paused)
{
reBuildCommandBuffers();
}
}
buildOffscreenCommandBuffer();
prepared = true;
}
virtual void render()
{
if (!prepared)
return;
vkDeviceWaitIdle(device);
draw();
vkDeviceWaitIdle(device);
if (!paused)
{
updateLight();
void resize_vulkan_wm_swapchain(ReaperRoot& root, const VulkanBackend& backend, PresentationInfo& presentInfo,
VkExtent2D extent)
{
REAPER_PROFILE_SCOPE("Vulkan", MP_RED);
log_debug(root, "vulkan: resizing wm swapchain");
// Destroy what needs to be
Assert(vkDeviceWaitIdle(backend.device) == VK_SUCCESS);
vkDestroySemaphore(backend.device, presentInfo.imageAvailableSemaphore, nullptr);
vkDestroySemaphore(backend.device, presentInfo.renderingFinishedSemaphore, nullptr);
destroy_swapchain_framebuffers(backend, presentInfo);
destroy_swapchain_renderpass(backend, presentInfo);
vkDestroySwapchainKHR(backend.device, presentInfo.swapchain, nullptr);
presentInfo.swapchain = VK_NULL_HANDLE;
// Reconfigure even if we know most of what we expect/need
SwapchainDescriptor swapchainDesc;
swapchainDesc.preferredImageCount = presentInfo.imageCount;
swapchainDesc.preferredFormat = presentInfo.surfaceFormat;
swapchainDesc.preferredExtent = {extent.width, extent.height}; // New extent
configure_vulkan_wm_swapchain(root, backend, swapchainDesc, presentInfo);
create_vulkan_wm_swapchain(root, backend, presentInfo);
}
void VulkanRenderManager::EndSyncFrame(int frame) {
FrameData &frameData = frameData_[frame];
Submit(frame, false);
// This is brutal! Should probably wait for a fence instead, not that it'll matter much since we'll
// still stall everything.
vkDeviceWaitIdle(vulkan_->GetDevice());
// At this point we can resume filling the command buffers for the current frame since
// we know the device is idle - and thus all previously enqueued command buffers have been processed.
// No need to switch to the next frame number.
VkCommandBufferBeginInfo begin{
VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,
nullptr,
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT
};
VkResult res = vkBeginCommandBuffer(frameData.mainCmd, &begin);
assert(res == VK_SUCCESS);
if (useThread_) {
std::unique_lock<std::mutex> lock(frameData.push_mutex);
frameData.readyForFence = true;
frameData.push_condVar.notify_all();
}
}
VulkanCommon::~VulkanCommon() {
if( Vulkan.Device != VK_NULL_HANDLE ) {
vkDeviceWaitIdle( Vulkan.Device );
for( size_t i = 0; i < Vulkan.SwapChain.Images.size(); ++i ) {
if( Vulkan.SwapChain.Images[i].ImageView != VK_NULL_HANDLE ) {
vkDestroyImageView( GetDevice(), Vulkan.SwapChain.Images[i].ImageView, nullptr );
}
}
if( Vulkan.SwapChain.Handle != VK_NULL_HANDLE ) {
vkDestroySwapchainKHR( Vulkan.Device, Vulkan.SwapChain.Handle, nullptr );
}
vkDestroyDevice( Vulkan.Device, nullptr );
}
if( Vulkan.PresentationSurface != VK_NULL_HANDLE ) {
vkDestroySurfaceKHR( Vulkan.Instance, Vulkan.PresentationSurface, nullptr );
}
if( Vulkan.Instance != VK_NULL_HANDLE ) {
vkDestroyInstance( Vulkan.Instance, nullptr );
}
if( VulkanLibrary ) {
#if defined(VK_USE_PLATFORM_WIN32_KHR)
FreeLibrary( VulkanLibrary );
#elif defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR)
dlclose( VulkanLibrary );
#endif
}
}
void destroy_vulkan_renderer_backend(ReaperRoot& root, VulkanBackend& backend)
{
REAPER_PROFILE_SCOPE("Vulkan", MP_RED1);
log_info(root, "vulkan: destroying backend");
destroy_vulkan_wm_swapchain(root, backend, backend.presentInfo);
log_debug(root, "vulkan: waiting for current work to finish");
Assert(vkDeviceWaitIdle(backend.device) == VK_SUCCESS);
log_debug(root, "vulkan: destroying logical device");
vkDestroyDevice(backend.device, nullptr);
log_debug(root, "vulkan: destroying presentation surface");
vkDestroySurfaceKHR(backend.instance, backend.presentInfo.surface, nullptr);
delete root.renderer->window;
root.renderer->window = nullptr;
#if defined(REAPER_DEBUG)
log_debug(root, "vulkan: detaching debug callback");
vulkan_destroy_debug_callback(backend);
#endif
vkDestroyInstance(backend.instance, nullptr);
log_debug(root, "vulkan: unloading {}", REAPER_VK_LIB_NAME);
Assert(backend.vulkanLib != nullptr);
dynlib::close(backend.vulkanLib);
backend.vulkanLib = nullptr;
}
GrVkBackendContext::~GrVkBackendContext() {
vkDeviceWaitIdle(fDevice);
vkDestroyDevice(fDevice, nullptr);
fDevice = VK_NULL_HANDLE;
vkDestroyInstance(fInstance, nullptr);
fInstance = VK_NULL_HANDLE;
}
void v_window::_updateOSWindow() {
xcb_generic_event_t* event = xcb_poll_for_event(_xcb_connection); //非阻塞的方式接收事件 xcb_wait_for_event为阻塞式
if(!event){
return;
}
switch(event->response_type & ~0x80){
case XCB_CLIENT_MESSAGE:
if( ( (xcb_client_message_event_t*)event )->data.data32[ 0 ] == _xcb_atom_window_reply->atom ) {
close();
}
break;
case XCB_CONFIGURE_NOTIFY:
if(xcb_configure_notify_event_t* cfg = (xcb_configure_notify_event_t*)event){
if(_width != cfg->width || _height != cfg->height) {
_width = cfg->width;
_height = cfg->height;
vkDeviceWaitIdle(_renderer->getDevice());
_initSwapchain();
_initSwapchainImageViews();
if (onResize != nullptr) {
onResize(_width, _height);
}
}
}
break;
default:
break;
}
free(event);
}
void Tutorial03::ChildClear() {
if( GetDevice() != VK_NULL_HANDLE ) {
vkDeviceWaitIdle( GetDevice() );
if( (Vulkan.GraphicsCommandBuffers.size() > 0) && (Vulkan.GraphicsCommandBuffers[0] != VK_NULL_HANDLE) ) {
vkFreeCommandBuffers( GetDevice(), Vulkan.GraphicsCommandPool, static_cast<uint32_t>(Vulkan.GraphicsCommandBuffers.size()), &Vulkan.GraphicsCommandBuffers[0] );
Vulkan.GraphicsCommandBuffers.clear();
}
if( Vulkan.GraphicsCommandPool != VK_NULL_HANDLE ) {
vkDestroyCommandPool( GetDevice(), Vulkan.GraphicsCommandPool, nullptr );
Vulkan.GraphicsCommandPool = VK_NULL_HANDLE;
}
if( Vulkan.GraphicsPipeline != VK_NULL_HANDLE ) {
vkDestroyPipeline( GetDevice(), Vulkan.GraphicsPipeline, nullptr );
Vulkan.GraphicsPipeline = VK_NULL_HANDLE;
}
if( Vulkan.RenderPass != VK_NULL_HANDLE ) {
vkDestroyRenderPass( GetDevice(), Vulkan.RenderPass, nullptr );
Vulkan.RenderPass = VK_NULL_HANDLE;
}
for( size_t i = 0; i < Vulkan.Framebuffers.size(); ++i ) {
if( Vulkan.Framebuffers[i] != VK_NULL_HANDLE ) {
vkDestroyFramebuffer( GetDevice(), Vulkan.Framebuffers[i], nullptr );
Vulkan.Framebuffers[i] = VK_NULL_HANDLE;
}
}
Vulkan.Framebuffers.clear();
}
}
void SkinningAppVk::shutdownRendering(void) {
vkDeviceWaitIdle(device());
// destroy other resources here
vkDestroyPipeline(device(), mPipeline, NULL);
}
bool NvGLFWContextVK::readFramebufferRGBX32(uint8_t *dest, int32_t& w, int32_t& h) {
NvVkRenderTarget& rt = *mainRenderTarget();
w = rt.width();
h = rt.height();
if (!dest)
return true;
VkFormat format = rt.targetFormat();
if (format == VK_FORMAT_R8G8B8A8_UNORM) {
uint32_t size = 4 * w * h;
VkBufferImageCopy region;
region.bufferOffset = 0;
region.bufferRowLength = 0;
region.bufferImageHeight = 0;
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
region.imageSubresource.baseArrayLayer = 0;
region.imageSubresource.layerCount = 1;
region.imageSubresource.mipLevel = 0;
region.imageOffset = { 0, 0, 0 };
region.imageExtent = { (uint32_t)w, (uint32_t)h, 1 };
NvVkBuffer dstBuffer;
VkResult result = createAndFillBuffer(size, VK_BUFFER_USAGE_FLAG_BITS_MAX_ENUM, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT, dstBuffer);
VkCommandBuffer cmd = beginTempCmdBuffer();
vkCmdCopyImageToBuffer(cmd,
rt.image(),
VK_IMAGE_LAYOUT_GENERAL,
dstBuffer.buffer,
1, ®ion);
result = doneWithTempCmdBufferSubmit(cmd);
vkDeviceWaitIdle(device());
uint8_t* ptr = NULL;
result = vkMapMemory(device(), dstBuffer.mem, 0, size, 0, (void**)&ptr);
uint32_t rowSize = w * 4;
ptr += rowSize * (h - 1);
for (int32_t i = 0; i < h; i++) {
memcpy(dest, ptr, rowSize);
dest += rowSize;
ptr -= rowSize;
}
return true;
}
return false;
}
void tut7_render_cleanup_essentials(struct tut7_render_essentials *essentials, struct tut2_device *dev)
{
vkDeviceWaitIdle(dev->device);
vkDestroySemaphore(dev->device, essentials->sem_post_acquire, NULL);
vkDestroySemaphore(dev->device, essentials->sem_pre_submit, NULL);
vkDestroyFence(dev->device, essentials->exec_fence, NULL);
free(essentials->images);
}
virtual void render()
{
if (!prepared)
return;
vkDeviceWaitIdle(device);
draw();
vkDeviceWaitIdle(device);
if (animStart > 0.0f)
{
animStart -= frameTimer * 5.0f;
}
if ((animate) & (animStart <= 0.0f))
{
timer += frameTimer * 0.1f;
if (timer > 1.0)
{
timer -= 1.0f;
}
}
updateUniformBuffers();
}
void op3d::Engine::recreateSwapChain()
{
vkDeviceWaitIdle(device);
swapChain.create(device, surface, physicalDevice, window);
swapChain.createImageViews(device, swapChainImageViews);
createRenderPass();
createGraphicsPipeline();
createDepthResources();
createFramebuffers();
createCommandBuffers();
}
void op3d::Engine::mainLoop()
{
while (!glfwWindowShouldClose(window))
{
glfwPollEvents();
updateUniformBuffer();
drawFrame();
}
vkDeviceWaitIdle(device);
glfwDestroyWindow(window);
glfwTerminate();
}
void VkContext::Destroy() {
vkDeviceWaitIdle(dev);
// Free command buffers
if (drawCmdBuffers.size() > 0) {
vkFreeCommandBuffers(dev, cmdPool, (u32)drawCmdBuffers.size(),
&drawCmdBuffers[0]);
}
// Destroy command pools
vkDestroyCommandPool(dev, cmdPool, nullptr);
// Destroy semaphores
vkDestroySemaphore(dev, acquireCompleteSemaphore, nullptr);
vkDestroySemaphore(dev, renderCompleteSemaphore, nullptr);
// Destroy swapchain image views
for (u32 i = 0; i < swapchainImageViews.size(); i++) {
vkDestroyImageView(dev, swapchainImageViews[i], nullptr);
}
// Destroy swapchain
if (swapchain) {
vkDestroySwapchainKHR(dev, swapchain, nullptr);
}
// Destroy surface
if (surf) {
vkDestroySurfaceKHR(instance, surf, nullptr);
}
// Destroy device
if (dev) {
vkDestroyDevice(dev, nullptr);
}
#ifdef VOXL_DEBUG
// Destroy debug report callback
if (msgCallback != VK_NULL_HANDLE) {
vkDestroyDebugReportCallbackEXT(instance, msgCallback, nullptr);
}
#endif
// Destroy instance
if (instance) {
vkDestroyInstance(instance, nullptr);
}
// Terminate GLFW
glfwTerminate();
}
Tutorial03::~Tutorial03() {
ChildClear();
if( GetDevice() != VK_NULL_HANDLE ) {
vkDeviceWaitIdle( GetDevice() );
if( Vulkan.ImageAvailableSemaphore != VK_NULL_HANDLE ) {
vkDestroySemaphore( GetDevice(), Vulkan.ImageAvailableSemaphore, nullptr );
}
if( Vulkan.RenderingFinishedSemaphore != VK_NULL_HANDLE ) {
vkDestroySemaphore( GetDevice(), Vulkan.RenderingFinishedSemaphore, nullptr );
}
}
}
CommandBufferManager::~CommandBufferManager()
{
// If the worker thread is enabled, wait for it to exit.
if (m_use_threaded_submission)
{
// Wait for all command buffers to be consumed by the worker thread.
m_submit_semaphore.Wait();
m_submit_loop->Stop();
m_submit_thread.join();
}
vkDeviceWaitIdle(g_vulkan_context->GetDevice());
DestroyCommandBuffers();
}
void VulkanWindow::Finalize()
{
if ( VkResult result = vkQueueWaitIdle ( mVulkanRenderer.GetQueue() ) )
{
std::cerr << "vkQueueWaitIdle failed: " << GetVulkanResultString ( result );
}
if ( VkResult result = vkDeviceWaitIdle ( mVulkanRenderer.GetDevice() ) )
{
std::cerr << "vkDeviceWaitIdle failed: " << GetVulkanResultString ( result );
}
FinalizeFrameBuffers();
FinalizeDepthStencil();
FinalizeImageViews();
FinalizeSwapchain();
FinalizeSurface();
}
void VulkanRenderManager::ThreadFunc() {
setCurrentThreadName("RenderMan");
int threadFrame = threadInitFrame_;
bool nextFrame = false;
bool firstFrame = true;
while (true) {
{
if (nextFrame) {
threadFrame++;
if (threadFrame >= vulkan_->GetInflightFrames())
threadFrame = 0;
}
FrameData &frameData = frameData_[threadFrame];
std::unique_lock<std::mutex> lock(frameData.pull_mutex);
while (!frameData.readyForRun && run_) {
VLOG("PULL: Waiting for frame[%d].readyForRun", threadFrame);
frameData.pull_condVar.wait(lock);
}
if (!frameData.readyForRun && !run_) {
// This means we're out of frames to render and run_ is false, so bail.
break;
}
VLOG("PULL: frame[%d].readyForRun = false", threadFrame);
frameData.readyForRun = false;
// Previously we had a quick exit here that avoided calling Run() if run_ was suddenly false,
// but that created a race condition where frames could end up not finished properly on resize etc.
// Only increment next time if we're done.
nextFrame = frameData.type == VKRRunType::END;
assert(frameData.type == VKRRunType::END || frameData.type == VKRRunType::SYNC);
}
VLOG("PULL: Running frame %d", threadFrame);
if (firstFrame) {
ILOG("Running first frame (%d)", threadFrame);
firstFrame = false;
}
Run(threadFrame);
VLOG("PULL: Finished frame %d", threadFrame);
}
// Wait for the device to be done with everything, before tearing stuff down.
vkDeviceWaitIdle(vulkan_->GetDevice());
VLOG("PULL: Quitting");
}
Tutorial01::~Tutorial01() {
if( Vulkan.Device != VK_NULL_HANDLE ) {
vkDeviceWaitIdle( Vulkan.Device );
vkDestroyDevice( Vulkan.Device, nullptr );
}
if( Vulkan.Instance != VK_NULL_HANDLE ) {
vkDestroyInstance( Vulkan.Instance, nullptr );
}
if( VulkanLibrary ) {
#if defined(VK_USE_PLATFORM_WIN32_KHR)
FreeLibrary( VulkanLibrary );
#elif defined(VK_USE_PLATFORM_XCB_KHR) || defined(VK_USE_PLATFORM_XLIB_KHR)
dlclose( VulkanLibrary );
#endif
}
}
void VulkanExampleBase::windowResize()
{
if (!prepared)
{
return;
}
prepared = false;
// Recreate swap chain
width = destWidth;
height = destHeight;
createSetupCommandBuffer();
setupSwapChain();
// Recreate the frame buffers
vkDestroyImageView(device, depthStencil.view, nullptr);
vkDestroyImage(device, depthStencil.image, nullptr);
vkFreeMemory(device, depthStencil.mem, nullptr);
setupDepthStencil();
for (uint32_t i = 0; i < frameBuffers.size(); i++)
{
vkDestroyFramebuffer(device, frameBuffers[i], nullptr);
}
setupFrameBuffer();
flushSetupCommandBuffer();
// Command buffers need to be recreated as they may store
// references to the recreated frame buffer
destroyCommandBuffers();
createCommandBuffers();
buildCommandBuffers();
vkQueueWaitIdle(queue);
vkDeviceWaitIdle(device);
// Notify derived class
windowResized();
viewChanged();
prepared = true;
}
void ProfilerVK::resize()
{
if (getRequiredTimers() < m_queryPoolSize) return;
if (m_queryPool) {
// not exactly efficient, but when timers changed a lot, we have a slow frame anyway
// cleaner would be allocating more pools
vkDeviceWaitIdle(m_device);
vkDestroyQueryPool(m_device, m_queryPool, m_allocator);
}
VkQueryPoolCreateInfo create_info = { VK_STRUCTURE_TYPE_QUERY_POOL_CREATE_INFO };
create_info.queryType = VK_QUERY_TYPE_TIMESTAMP;
create_info.queryCount = getRequiredTimers();
m_queryPoolSize = create_info.queryCount;
VkResult res = vkCreateQueryPool(m_device, &create_info, m_allocator, &m_queryPool);
assert(res == VK_SUCCESS);
}
void shutdown() {
on_window_resize_listener = static_cast<size_t >(-1);
if (vk_globals::device != nullptr) {
vkDeviceWaitIdle(vk_globals::device);
shutdown_swap_chain();
vkDestroyDevice(vk_globals::device, nullptr);
vk_globals::device = nullptr;
}
if (vk_globals::surface != nullptr) {
vkDestroySurfaceKHR(vk_globals::instance, vk_globals::surface, nullptr);
}
if (vk_globals::instance != nullptr) {
vkDestroyInstance(vk_globals::instance, nullptr);
}
}
virtual void render()
{
if (!prepared)
return;
draw();
if (animate)
{
if (animStart > 0.0f)
{
animStart -= frameTimer * 5.0f;
}
else if (animStart <= 0.0f)
{
timer += frameTimer * 0.04f;
if (timer > 1.f)
timer = 0.f;
}
}
vkDeviceWaitIdle(device);
updateUniformBuffers();
}
void VulkanWindow::OnResizeViewport ( int32_t aX, int32_t aY, uint32_t aWidth, uint32_t aHeight )
{
VkSurfaceCapabilitiesKHR surface_capabilities{};
VkResult result {vkGetPhysicalDeviceSurfaceCapabilitiesKHR ( mVulkanRenderer.GetPhysicalDevice(), mVkSurfaceKHR, &surface_capabilities ) };
if ( result == VK_SUCCESS && std::memcmp ( &surface_capabilities, &mVkSurfaceCapabilitiesKHR, sizeof ( VkSurfaceCapabilitiesKHR ) ) != 0 )
{
if ( VK_SUCCESS != ( result = vkQueueWaitIdle ( mVulkanRenderer.GetQueue() ) ) )
{
std::ostringstream stream;
stream << "vkQueueWaitIdle failed: " << GetVulkanResultString ( result );
throw std::runtime_error ( stream.str().c_str() );
}
if ( VK_SUCCESS != ( result = vkDeviceWaitIdle ( mVulkanRenderer.GetDevice() ) ) )
{
std::ostringstream stream;
stream << "vkDeviceWaitIdle failed: " << GetVulkanResultString ( result );
throw std::runtime_error ( stream.str().c_str() );
}
FinalizeFrameBuffers();
FinalizeDepthStencil();
FinalizeImageViews();
InitializeSwapchain();
InitializeImageViews();
InitializeDepthStencil();
InitializeFrameBuffers();
}
mVkViewport.x = static_cast<float> ( aX );
mVkViewport.y = static_cast<float> ( aY );
mVkViewport.width = static_cast<float> ( aWidth );
mVkViewport.height = static_cast<float> ( aHeight );
// Clip Scissors to surface extents
mVkScissor.offset.x = ( aX < 0 ) ? 0 : aX;
mVkScissor.offset.y = ( aY < 0 ) ? 0 : aY;
mVkScissor.extent.width = ( aX + aWidth > mVkSurfaceCapabilitiesKHR.currentExtent.width ) ? mVkSurfaceCapabilitiesKHR.currentExtent.width : aX + aWidth;
mVkScissor.extent.height = ( aY + aHeight > mVkSurfaceCapabilitiesKHR.currentExtent.height ) ? mVkSurfaceCapabilitiesKHR.currentExtent.height : aY + aHeight;
}
static void glfw_key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) {
if (action == GLFW_PRESS) {
if (key == GLFW_KEY_ESCAPE) {
glfwSetWindowShouldClose(window, GLFW_TRUE);
} else if (key == GLFW_KEY_F11 || key == GLFW_KEY_ENTER && mods == GLFW_MOD_ALT) {
static int last_window_xpos, last_window_ypos;
static int last_window_width, last_window_height;
VK_CHECK(vkDeviceWaitIdle(vk.device));
GLFWmonitor* monitor = glfwGetWindowMonitor(window);
if (monitor == nullptr) {
glfwGetWindowPos(window, &last_window_xpos, &last_window_ypos);
last_window_width = window_width;
last_window_height = window_height;
monitor = glfwGetPrimaryMonitor();
const GLFWvidmode* mode = glfwGetVideoMode(monitor);
glfwSetWindowMonitor(window, monitor, 0, 0, mode->width, mode->height, mode->refreshRate);
} else {
glfwSetWindowMonitor(window, nullptr, last_window_xpos, last_window_ypos, last_window_width, last_window_height, 0);
}
}
}
}
static void
gst_vulkan_device_finalize (GObject * object)
{
GstVulkanDevice *device = GST_VULKAN_DEVICE (object);
g_free (device->queue_family_props);
device->queue_family_props = NULL;
if (device->cmd_pool)
vkDestroyCommandPool (device->device, device->cmd_pool, NULL);
device->cmd_pool = VK_NULL_HANDLE;
if (device->device) {
vkDeviceWaitIdle (device->device);
vkDestroyDevice (device->device, NULL);
}
device->device = VK_NULL_HANDLE;
if (device->instance)
gst_object_unref (device->instance);
device->instance = VK_NULL_HANDLE;
G_OBJECT_CLASS (parent_class)->finalize (object);
}