int main(int /*argc*/, char ** /*argv*/) { try { vk::UniqueInstance instance = vk::su::createInstance(AppName, EngineName, vk::su::getInstanceExtensions()); #if !defined(NDEBUG) vk::UniqueDebugReportCallbackEXT debugReportCallback = vk::su::createDebugReportCallback(instance); #endif std::vector<vk::PhysicalDevice> physicalDevices = instance->enumeratePhysicalDevices(); assert(!physicalDevices.empty()); vk::su::SurfaceData surfaceData(instance, AppName, AppName, vk::Extent2D(500, 500)); std::pair<uint32_t, uint32_t> graphicsAndPresentQueueFamilyIndex = vk::su::findGraphicsAndPresentQueueFamilyIndex(physicalDevices[0], surfaceData.surface); vk::UniqueDevice device = vk::su::createDevice(physicalDevices[0], graphicsAndPresentQueueFamilyIndex.first, vk::su::getDeviceExtensions()); /* VULKAN_HPP_KEY_START */ const vk::Format depthFormat = vk::Format::eD16Unorm; vk::FormatProperties formatProperties = physicalDevices[0].getFormatProperties(depthFormat); vk::ImageTiling tiling; if (formatProperties.linearTilingFeatures & vk::FormatFeatureFlagBits::eDepthStencilAttachment) { tiling = vk::ImageTiling::eLinear; } else if (formatProperties.optimalTilingFeatures & vk::FormatFeatureFlagBits::eDepthStencilAttachment) { tiling = vk::ImageTiling::eOptimal; } else { throw std::runtime_error("DepthStencilAttachment is not supported for D16Unorm depth format."); } vk::ImageCreateInfo imageCreateInfo(vk::ImageCreateFlags(), vk::ImageType::e2D, depthFormat, vk::Extent3D(surfaceData.extent, 1), 1, 1, vk::SampleCountFlagBits::e1, tiling, vk::ImageUsageFlagBits::eDepthStencilAttachment); vk::UniqueImage depthImage = device->createImageUnique(imageCreateInfo); vk::PhysicalDeviceMemoryProperties memoryProperties = physicalDevices[0].getMemoryProperties(); vk::MemoryRequirements memoryRequirements = device->getImageMemoryRequirements(depthImage.get()); uint32_t typeBits = memoryRequirements.memoryTypeBits; uint32_t typeIndex = uint32_t(~0); for (uint32_t i = 0; i < memoryProperties.memoryTypeCount; i++) { if ((typeBits & 1) && ((memoryProperties.memoryTypes[i].propertyFlags & vk::MemoryPropertyFlagBits::eDeviceLocal) == vk::MemoryPropertyFlagBits::eDeviceLocal)) { typeIndex = i; break; } typeBits >>= 1; } assert(typeIndex != ~0); vk::UniqueDeviceMemory depthMemory = device->allocateMemoryUnique(vk::MemoryAllocateInfo(memoryRequirements.size, typeIndex)); device->bindImageMemory(depthImage.get(), depthMemory.get(), 0); vk::ComponentMapping componentMapping(vk::ComponentSwizzle::eR, vk::ComponentSwizzle::eG, vk::ComponentSwizzle::eB, vk::ComponentSwizzle::eA); vk::ImageSubresourceRange subResourceRange(vk::ImageAspectFlagBits::eDepth, 0, 1, 0, 1); vk::UniqueImageView depthView = device->createImageViewUnique(vk::ImageViewCreateInfo(vk::ImageViewCreateFlags(), depthImage.get(), vk::ImageViewType::e2D, depthFormat, componentMapping, subResourceRange)); /* VULKAN_HPP_KEY_END */ #if defined(VK_USE_PLATFORM_WIN32_KHR) DestroyWindow(surfaceData.window); #else #pragma error "unhandled platform" #endif } catch (vk::SystemError err) { std::cout << "vk::SystemError: " << err.what() << std::endl; exit(-1); } catch (std::runtime_error err) { std::cout << "std::runtime_error: " << err.what() << std::endl; exit(-1); } catch (...) { std::cout << "unknown error\n"; exit(-1); } return 0; }
int main(int /*argc*/, char ** /*argv*/) { try { vk::UniqueInstance instance = vk::su::createInstance(AppName, EngineName, vk::su::getInstanceExtensions()); #if !defined(NDEBUG) vk::UniqueDebugReportCallbackEXT debugReportCallback = vk::su::createDebugReportCallback(instance); #endif std::vector<vk::PhysicalDevice> physicalDevices = instance->enumeratePhysicalDevices(); assert(!physicalDevices.empty()); vk::su::SurfaceData surfaceData(instance, AppName, AppName, vk::Extent2D(64, 64)); std::pair<uint32_t, uint32_t> graphicsAndPresentQueueFamilyIndex = vk::su::findGraphicsAndPresentQueueFamilyIndex(physicalDevices[0], surfaceData.surface); vk::UniqueDevice device = vk::su::createDevice(physicalDevices[0], graphicsAndPresentQueueFamilyIndex.first, vk::su::getDeviceExtensions()); vk::Format colorFormat = vk::su::pickColorFormat(physicalDevices[0].getSurfaceFormatsKHR(surfaceData.surface.get())); vk::Format depthFormat = vk::Format::eD16Unorm; /* VULKAN_HPP_KEY_START */ vk::AttachmentDescription attachmentDescriptions[2]; attachmentDescriptions[0] = vk::AttachmentDescription(vk::AttachmentDescriptionFlags(), colorFormat, vk::SampleCountFlagBits::e1, vk::AttachmentLoadOp::eClear, vk::AttachmentStoreOp::eStore, vk::AttachmentLoadOp::eDontCare, vk::AttachmentStoreOp::eDontCare, vk::ImageLayout::eUndefined, vk::ImageLayout::ePresentSrcKHR); attachmentDescriptions[1] = vk::AttachmentDescription(vk::AttachmentDescriptionFlags(), depthFormat, vk::SampleCountFlagBits::e1, vk::AttachmentLoadOp::eClear, vk::AttachmentStoreOp::eDontCare, vk::AttachmentLoadOp::eDontCare, vk::AttachmentStoreOp::eDontCare, vk::ImageLayout::eUndefined, vk::ImageLayout::eDepthStencilAttachmentOptimal); vk::AttachmentReference colorReference(0, vk::ImageLayout::eColorAttachmentOptimal); vk::AttachmentReference depthReference(1, vk::ImageLayout::eDepthStencilAttachmentOptimal); vk::SubpassDescription subpass(vk::SubpassDescriptionFlags(), vk::PipelineBindPoint::eGraphics, 0, nullptr, 1, &colorReference, nullptr, &depthReference); vk::UniqueRenderPass renderPass = device->createRenderPassUnique(vk::RenderPassCreateInfo(vk::RenderPassCreateFlags(), 2, attachmentDescriptions, 1, &subpass)); // Note: No need to explicitly destroy the RenderPass or the Semaphore, as the corresponding destroy // functions are called by the destructor of the UniqueRenderPass and the UniqueSemaphore on leaving this scope. /* VULKAN_HPP_KEY_END */ #if defined(VK_USE_PLATFORM_WIN32_KHR) DestroyWindow(surfaceData.window); #else #pragma error "unhandled platform" #endif } catch (vk::SystemError err) { std::cout << "vk::SystemError: " << err.what() << std::endl; exit(-1); } catch (std::runtime_error err) { std::cout << "std::runtime_error: " << err.what() << std::endl; exit(-1); } catch (...) { std::cout << "unknown error\n"; exit(-1); } return 0; }
int main(int /*argc*/, char ** /*argv*/) { try { vk::UniqueInstance instance = vk::su::createInstance(AppName, EngineName, vk::su::getInstanceExtensions()); #if !defined(NDEBUG) vk::UniqueDebugReportCallbackEXT debugReportCallback = vk::su::createDebugReportCallback(instance); #endif std::vector<vk::PhysicalDevice> physicalDevices = instance->enumeratePhysicalDevices(); assert(!physicalDevices.empty()); vk::su::SurfaceData surfaceData(instance, AppName, AppName, vk::Extent2D(64, 64)); std::pair<uint32_t, uint32_t> graphicsAndPresentQueueFamilyIndex = vk::su::findGraphicsAndPresentQueueFamilyIndex(physicalDevices[0], surfaceData.surface); vk::UniqueDevice device = vk::su::createDevice(physicalDevices[0], graphicsAndPresentQueueFamilyIndex.first, vk::su::getDeviceExtensions()); vk::UniqueCommandPool commandPool = vk::su::createCommandPool(device, graphicsAndPresentQueueFamilyIndex.first); std::vector<vk::UniqueCommandBuffer> commandBuffers = device->allocateCommandBuffersUnique(vk::CommandBufferAllocateInfo(commandPool.get(), vk::CommandBufferLevel::ePrimary, 1)); vk::Queue graphicsQueue = device->getQueue(graphicsAndPresentQueueFamilyIndex.first, 0); vk::su::SwapChainData swapChainData(physicalDevices[0], device, surfaceData.surface, surfaceData.extent, vk::ImageUsageFlagBits::eColorAttachment | vk::ImageUsageFlagBits::eTransferSrc , graphicsAndPresentQueueFamilyIndex.first, graphicsAndPresentQueueFamilyIndex.second); vk::su::DepthBufferData depthBufferData(physicalDevices[0], device, vk::Format::eD16Unorm, surfaceData.extent); vk::UniqueRenderPass renderPass = vk::su::createRenderPass(device, swapChainData.colorFormat, depthBufferData.format); std::vector<vk::UniqueFramebuffer> framebuffers = vk::su::createFramebuffers(device, renderPass, swapChainData.imageViews, depthBufferData.imageView, surfaceData.extent); /* VULKAN_KEY_START */ // create a vertex buffer for some vertex and color data vk::UniqueBuffer vertexBuffer = device->createBufferUnique(vk::BufferCreateInfo(vk::BufferCreateFlags(), sizeof(coloredCubeData), vk::BufferUsageFlagBits::eVertexBuffer)); // allocate device memory for that buffer vk::MemoryRequirements memoryRequirements = device->getBufferMemoryRequirements(vertexBuffer.get()); uint32_t memoryTypeIndex = vk::su::findMemoryType(physicalDevices[0].getMemoryProperties(), memoryRequirements.memoryTypeBits, vk::MemoryPropertyFlagBits::eHostVisible | vk::MemoryPropertyFlagBits::eHostCoherent); vk::UniqueDeviceMemory deviceMemory = device->allocateMemoryUnique(vk::MemoryAllocateInfo(memoryRequirements.size, memoryTypeIndex)); // copy the vertex and color data into that device memory uint8_t *pData = static_cast<uint8_t*>(device->mapMemory(deviceMemory.get(), 0, memoryRequirements.size)); memcpy(pData, coloredCubeData, sizeof(coloredCubeData)); device->unmapMemory(deviceMemory.get()); // and bind the device memory to the vertex buffer device->bindBufferMemory(vertexBuffer.get(), deviceMemory.get(), 0); vk::UniqueSemaphore imageAcquiredSemaphore = device->createSemaphoreUnique(vk::SemaphoreCreateInfo(vk::SemaphoreCreateFlags())); vk::ResultValue<uint32_t> currentBuffer = device->acquireNextImageKHR(swapChainData.swapChain.get(), vk::su::FenceTimeout, imageAcquiredSemaphore.get(), nullptr); assert(currentBuffer.result == vk::Result::eSuccess); assert(currentBuffer.value < framebuffers.size()); vk::ClearValue clearValues[2]; clearValues[0].color = vk::ClearColorValue(std::array<float, 4>({ 0.2f, 0.2f, 0.2f, 0.2f })); clearValues[1].depthStencil = vk::ClearDepthStencilValue(1.0f, 0); commandBuffers[0]->begin(vk::CommandBufferBeginInfo(vk::CommandBufferUsageFlags())); vk::RenderPassBeginInfo renderPassBeginInfo(renderPass.get(), framebuffers[currentBuffer.value].get(), vk::Rect2D(vk::Offset2D(0, 0), surfaceData.extent), 2, clearValues); commandBuffers[0]->beginRenderPass(renderPassBeginInfo, vk::SubpassContents::eInline); VkDeviceSize offset = 0; commandBuffers[0]->bindVertexBuffers(0, vertexBuffer.get(), offset); commandBuffers[0]->endRenderPass(); commandBuffers[0]->end(); vk::su::submitAndWait(device, graphicsQueue, commandBuffers[0]); // Note: No need to explicitly destroy the vertexBuffer, deviceMemory, or semaphore, as the destroy functions are called // by the destructor of the UniqueBuffer, UniqueDeviceMemory, and UniqueSemaphore, respectively, on leaving this scope. /* VULKAN_KEY_END */ #if defined(VK_USE_PLATFORM_WIN32_KHR) DestroyWindow(surfaceData.window); #else #pragma error "unhandled platform" #endif } catch (vk::SystemError err) { std::cout << "vk::SystemError: " << err.what() << std::endl; exit(-1); } catch (std::runtime_error err) { std::cout << "std::runtime_error: " << err.what() << std::endl; exit(-1); } catch (...) { std::cout << "unknown error\n"; exit(-1); } return 0; }
Layer::List Factory::toLayers(Data::Base& data) { Layer::List layers; //qDebug() << "Layer::Factory converting" << Data::Type::toString(data.typeID()); try { switch (data.typeID()) { case Data::Type::Bank: { Data::Bank& bank(dynamic_cast<Data::Bank&>(data)); layers << convert(bank); } break; case Data::Type::GeometryList: { Data::GeometryList& list(dynamic_cast<Data::GeometryList&>(data)); layers << convert(list); } break; case Data::Type::Geometry: { Data::Geometry& geometry(dynamic_cast<Data::Geometry&>(data)); layers << convert(geometry); } break; case Data::Type::PointChargeList: { Data::PointChargeList& charges(dynamic_cast<Data::PointChargeList&>(data)); layers << convert(charges); } break; case Data::Type::MolecularOrbitalsList: { Data::MolecularOrbitalsList& list(dynamic_cast<Data::MolecularOrbitalsList&>(data)); layers << convert(list); } break; case Data::Type::MolecularOrbitals: { Data::MolecularOrbitals& molecularOrbitals(dynamic_cast<Data::MolecularOrbitals&>(data)); layers.append(new MolecularOrbitals(molecularOrbitals)); } break; case Data::Type::ExcitedStates: { Data::ExcitedStates& states(dynamic_cast<Data::ExcitedStates&>(data)); layers.append(new ExcitedStates(states)); } break; case Data::Type::Frequencies: { Data::Frequencies& frequencies(dynamic_cast<Data::Frequencies&>(data)); layers.append(new Frequencies(frequencies)); } break; case Data::Type::FileList: { Data::FileList& fileList(dynamic_cast<Data::FileList&>(data)); layers << convert(fileList); } break; case Data::Type::GridData: { QLOG_WARN() << "Data::GridData passed to LayerFactory"; //Data::GridData& grid(dynamic_cast<Data::GridData&>(data)); //layers.append(new CubeData(grid)); } break; case Data::Type::CubeData: { Data::CubeData& cube(dynamic_cast<Data::CubeData&>(data)); layers.append(new CubeData(cube)); } break; case Data::Type::EfpFragment: { Data::EfpFragment& efp(dynamic_cast<Data::EfpFragment&>(data)); layers.append(new EfpFragment(efp)); } break; case Data::Type::EfpFragmentList: { Data::EfpFragmentList& efpList(dynamic_cast<Data::EfpFragmentList&>(data)); layers << convert(efpList); } break; case Data::Type::Mesh: { Data::Mesh& meshData(dynamic_cast<Data::Mesh&>(data)); Data::Surface surface(meshData); Layer::Surface* surfaceLayer(new Surface(surface)); surfaceLayer->setCheckState(Qt::Checked); layers.append(surfaceLayer); } break; case Data::Type::Surface: { Data::Surface& surfaceData(dynamic_cast<Data::Surface&>(data)); Layer::Surface* surfaceLayer(new Surface(surfaceData)); surfaceLayer->setCheckState(surfaceData.isVisible() ? Qt::Checked : Qt::Unchecked); layers.append(surfaceLayer); } break; case Data::Type::Nmr: { Data::Nmr& nmrData(dynamic_cast<Data::Nmr&>(data)); Layer::Nmr* nmrLayer(new Nmr(nmrData)); layers.append(nmrLayer); } break; default: QLOG_WARN() << "Unimplemented data type in Layer::Factory" << Data::Type::toString(data.typeID()); break; } } catch (const std::bad_cast& e) { QLOG_ERROR() << "Data cast in Layer::Factory failed" << Data::Type::toString(data.typeID()); } return layers; }