void foo() {
{
/* [CompareImageFile] */
CORRADE_COMPARE_WITH("actual.png", "expected.png",
(DebugTools::CompareImageFile{15.5f, 5.0f}));
/* [CompareImageFile] */
}
{
/* [CompareImageFile-manager] */
PluginManager::Manager<Trade::AbstractImporter> manager;
CORRADE_COMPARE_WITH("actual.png", "expected.png",
(DebugTools::CompareImageFile{manager, 15.5f, 5.0f}));
/* [CompareImageFile-manager] */
}
{
/* [CompareImageFile-skip] */
PluginManager::Manager<Trade::AbstractImporter> manager;
if(manager.loadState("AnyImageImporter") == PluginManager::LoadState::NotFound ||
manager.loadState("PngImporter") == PluginManager::LoadState::NotFound)
CORRADE_SKIP("AnyImageImporter/PngImporter not found, can't compare.");
CORRADE_COMPARE_WITH("actual.png", "expected.png",
(DebugTools::CompareImageFile{manager, 15.5f, 5.0f}));
/* [CompareImageFile-skip] */
}
{
/* [CompareImageToFile] */
Image2D actual = doProcessing();
CORRADE_COMPARE_WITH(actual, "expected.png",
(DebugTools::CompareImageToFile{15.5f, 5.0f}));
/* [CompareImageToFile] */
/* [CompareFileToImage] */
Image2D expected = loadExpectedImage();
CORRADE_COMPARE_WITH("actual.png", expected,
(DebugTools::CompareFileToImage{15.5f, 5.0f}));
/* [CompareFileToImage] */
}
}
void AnyImporterTest::ogg() {
if(_manager.loadState("VorbisAudioImporter") == PluginManager::LoadState::NotFound)
CORRADE_SKIP("VorbisAudioImporter plugin not found, cannot test");
AnyImporter importer{_manager};
CORRADE_VERIFY(importer.openFile(OGG_FILE));
/* Check only parameters, as it is good enough proof that it is working */
CORRADE_COMPARE(importer.format(), Buffer::Format::Mono16);
CORRADE_COMPARE(importer.frequency(), 96000);
}
void AnyImageConverterTest::png() {
if(_manager.loadState("PngImageConverter") == PluginManager::LoadState::NotFound)
CORRADE_SKIP("PngImageConverter plugin not found, cannot test");
if(Utility::Directory::fileExists(PNG_OUTPUT_FILE))
CORRADE_VERIFY(Utility::Directory::rm(PNG_OUTPUT_FILE));
/* Just test that the exported file exists */
AnyImageConverter converter{_manager};
CORRADE_VERIFY(converter.exportToFile(Image, PNG_OUTPUT_FILE));
CORRADE_VERIFY(Utility::Directory::fileExists(PNG_OUTPUT_FILE));
}
bool screenshot(PluginManager::Manager<Trade::AbstractImageConverter>& manager, GL::AbstractFramebuffer& framebuffer, const PixelFormat format, const std::string& filename) {
Containers::Pointer<Trade::AbstractImageConverter> converter;
if(!(converter = manager.loadAndInstantiate("AnyImageConverter")))
return false;
Image2D image = framebuffer.read(framebuffer.viewport(), {format});
if(!converter->exportToFile(image, filename))
return false;
Debug{} << "DebugTools::screenshot(): saved a" << format << "image of size" << image.size() << "to" << filename;
return true;
}
void AnyImageImporterTest::png() {
if(_manager.loadState("PngImporter") == PluginManager::LoadState::NotFound)
CORRADE_SKIP("PngImporter plugin not found, cannot test");
AnyImageImporter importer{_manager};
CORRADE_VERIFY(importer.openFile(PNG_FILE));
/* Check only size, as it is good enough proof that it is working */
std::optional<ImageData2D> image = importer.image2D(0);
CORRADE_VERIFY(image);
CORRADE_COMPARE(image->size(), Vector2i(3, 2));
}
CubeMapExample::CubeMapExample(const Arguments& arguments): Platform::Application(arguments, Configuration().setTitle("Magnum Cube Map Example")) {
GL::Renderer::enable(GL::Renderer::Feature::DepthTest);
GL::Renderer::enable(GL::Renderer::Feature::FaceCulling);
/* Set up perspective camera */
(_cameraObject = new Object3D(&_scene))
->translate(Vector3::zAxis(3.0f));
(_camera = new SceneGraph::Camera3D(*_cameraObject))
->setAspectRatioPolicy(SceneGraph::AspectRatioPolicy::Extend)
.setProjectionMatrix(Matrix4::perspectiveProjection(Deg(55.0f), 1.0f, 0.001f, 100.0f))
.setViewport(GL::defaultFramebuffer.viewport().size());
/* Load image importer plugin */
PluginManager::Manager<Trade::AbstractImporter> manager;
Containers::Pointer<Trade::AbstractImporter> importer = manager.loadAndInstantiate("JpegImporter");
if(!importer) std::exit(1);
_resourceManager.set<Trade::AbstractImporter>("jpeg-importer",
importer.release(), ResourceDataState::Final, ResourcePolicy::Manual);
/* Add objects to scene */
(new CubeMap(arguments.argc == 2 ? arguments.argv[1] : "", &_scene, &_drawables))
->scale(Vector3(20.0f));
(new Reflector(&_scene, &_drawables))
->scale(Vector3(0.5f))
.translate(Vector3::xAxis(-0.5f));
(new Reflector(&_scene, &_drawables))
->scale(Vector3(0.3f))
.rotate(Deg(37.0f), Vector3::xAxis())
.translate(Vector3::xAxis(0.3f));
/* We don't need the importer anymore */
_resourceManager.free<Trade::AbstractImporter>();
}
AreaLightsExample::AreaLightsExample(const Arguments& arguments): Platform::Application{arguments, NoCreate} {
/* Try to create multisampled context, but be nice and fall back if not
available. Enable only 2x MSAA if we have enough DPI. */
{
const Vector2 dpiScaling = this->dpiScaling({});
Configuration conf;
conf.setTitle("Magnum Area Lights Example")
.setSize(conf.size(), dpiScaling);
GLConfiguration glConf;
glConf.setSampleCount(dpiScaling.max() < 2.0f ? 8 : 2);
if(!tryCreate(conf, glConf))
create(conf, glConf.setSampleCount(0));
}
/* Make it all DARK, eanble face culling so one-sided lights are properly
visualized */
GL::Renderer::enable(GL::Renderer::Feature::FaceCulling);
GL::Renderer::setClearColor(0x000000_rgbf);
/* Setup the plane mesh, which will be used for both the floor and light
visualization */
_vertices = GL::Buffer{};
_vertices.setData(LightVertices, GL::BufferUsage::StaticDraw);
_plane = GL::Mesh{};
_plane.setPrimitive(GL::MeshPrimitive::TriangleFan)
.addVertexBuffer(_vertices, 0, Shaders::Generic3D::Position{}, Shaders::Generic3D::Normal{})
.setCount(Containers::arraySize(LightVertices));
/* Setup project and floor plane tranformation matrix */
_projection = Matrix4::perspectiveProjection(60.0_degf, 4.0f/3.0f, 0.1f, 50.0f);
_transformation = Matrix4::rotationX(-90.0_degf)*Matrix4::scaling(Vector3{25.0f});
/* Load LTC matrix and BRDF textures */
PluginManager::Manager<Trade::AbstractImporter> manager;
Containers::Pointer<Trade::AbstractImporter> importer = manager.loadAndInstantiate("DdsImporter");
if(!importer) std::exit(1);
const Utility::Resource rs{"arealights-data"};
if(!importer->openData(rs.getRaw("ltc_amp.dds")))
std::exit(2);
/* Set texture data and parameters */
Containers::Optional<Trade::ImageData2D> image = importer->image2D(0);
CORRADE_INTERNAL_ASSERT(image);
_ltcAmp = GL::Texture2D{};
_ltcAmp.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setMinificationFilter(GL::SamplerFilter::Linear)
.setStorage(1, GL::TextureFormat::RG32F, image->size())
.setSubImage(0, {}, *image);
if(!importer->openData(rs.getRaw("ltc_mat.dds")))
std::exit(2);
/* Set texture data and parameters */
image = importer->image2D(0);
CORRADE_INTERNAL_ASSERT(image);
_ltcMat = GL::Texture2D{};
_ltcMat.setWrapping(GL::SamplerWrapping::ClampToEdge)
.setMagnificationFilter(GL::SamplerFilter::Linear)
.setMinificationFilter(GL::SamplerFilter::Linear)
.setStorage(1, GL::TextureFormat::RGBA32F, image->size())
.setSubImage(0, {}, *image);
/* Compile shaders */
_areaLightShader = AreaLightShader{};
_flatShader = Shaders::Flat3D{};
/* Create the UI */
_ui.emplace(Vector2{windowSize()}/dpiScaling(), windowSize(), framebufferSize(), Ui::mcssDarkStyleConfiguration(), "ƒ₀");
Interconnect::connect(*_ui, &Ui::UserInterface::inputWidgetFocused, *this, &AreaLightsExample::startTextInput);
Interconnect::connect(*_ui, &Ui::UserInterface::inputWidgetBlurred, *this, &AreaLightsExample::stopTextInput);
/* Base UI plane */
_baseUiPlane.emplace(*_ui);
Interconnect::connect(_baseUiPlane->metalness, &Ui::Input::valueChanged, *this, &AreaLightsExample::enableApplyButton);
Interconnect::connect(_baseUiPlane->roughness, &Ui::Input::valueChanged, *this, &AreaLightsExample::enableApplyButton);
Interconnect::connect(_baseUiPlane->f0, &Ui::Input::valueChanged, *this, &AreaLightsExample::enableApplyButton);
Interconnect::connect(_baseUiPlane->apply, &Ui::Button::tapped, *this, &AreaLightsExample::apply);
Interconnect::connect(_baseUiPlane->reset, &Ui::Button::tapped, *this, &AreaLightsExample::reset);
/* Apply the default values */
apply();
}
int main() {
/* Create an instance, load function pointers */
VkInstance instance;
{
VkInstanceCreateInfo info{};
info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
MAGNUM_VK_ASSERT_OUTPUT(vkCreateInstance(&info, nullptr, &instance));
}
flextVkInitInstance(instance, &flextVkInstance);
/* Hardcoded memory type index (yes, I'm cheating) */
constexpr UnsignedInt MemoryTypeIndex = 0;
/* Create a device */
VkPhysicalDevice physicalDevice;
{
UnsignedInt count = 1;
MAGNUM_VK_ASSERT_OUTPUT_INCOMPLETE(vkEnumeratePhysicalDevices(instance, &count, &physicalDevice));
CORRADE_INTERNAL_ASSERT(count == 1);
} {
VkPhysicalDeviceProperties properties;
vkGetPhysicalDeviceProperties(physicalDevice, &properties);
Debug{} << "Using" << properties.deviceName;
CORRADE_INTERNAL_ASSERT(properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_DISCRETE_GPU ||
properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_INTEGRATED_GPU ||
properties.deviceType == VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU);
} {
VkQueueFamilyProperties properties;
UnsignedInt count = 1;
vkGetPhysicalDeviceQueueFamilyProperties(physicalDevice, &count, &properties);
CORRADE_INTERNAL_ASSERT(count == 1);
CORRADE_INTERNAL_ASSERT(properties.queueFlags & VK_QUEUE_GRAPHICS_BIT);
} {
VkPhysicalDeviceMemoryProperties properties{};
vkGetPhysicalDeviceMemoryProperties(physicalDevice, &properties);
CORRADE_INTERNAL_ASSERT(properties.memoryTypeCount >= 1);
CORRADE_INTERNAL_ASSERT(properties.memoryHeapCount >= 1);
CORRADE_INTERNAL_ASSERT(properties.memoryTypes[MemoryTypeIndex].propertyFlags & VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT);
CORRADE_INTERNAL_ASSERT(properties.memoryTypes[MemoryTypeIndex].heapIndex == 0);
}
VkDevice device;
{
const Float zero = 0.0f;
VkDeviceQueueCreateInfo queueInfo{};
queueInfo.sType = VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO;
queueInfo.queueFamilyIndex = 0; /* The first family from above */
queueInfo.queueCount = 1;
queueInfo.pQueuePriorities = &zero;
VkDeviceCreateInfo info{};
info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
info.queueCreateInfoCount = 1;
info.pQueueCreateInfos = &queueInfo;
MAGNUM_VK_ASSERT_OUTPUT(vkCreateDevice(physicalDevice, &info, nullptr, &device));
}
flextVkInitDevice(device, &flextVkDevice, vkGetDeviceProcAddr);
/* Create a queue */
VkQueue queue;
vkGetDeviceQueue(device, 0, 0, &queue);
/* Allocate a command buffer */
VkCommandPool commandPool;
{
VkCommandPoolCreateInfo info{};
info.sType = VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO;
info.flags = VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT;
info.queueFamilyIndex = 0;
MAGNUM_VK_ASSERT_OUTPUT(vkCreateCommandPool(device, &info, nullptr, &commandPool));
}
VkCommandBuffer commandBuffer;
{
VkCommandBufferAllocateInfo info{};
info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
info.commandPool = commandPool;
info.commandBufferCount = 1;
MAGNUM_VK_ASSERT_OUTPUT(vkAllocateCommandBuffers(device, &info, &commandBuffer));
}
/* Render pass */
VkRenderPass renderPass;
{
VkAttachmentDescription color{};
color.format = VK_FORMAT_R8G8B8A8_SRGB;
color.samples = VK_SAMPLE_COUNT_1_BIT;
color.loadOp = VK_ATTACHMENT_LOAD_OP_CLEAR;
color.storeOp = VK_ATTACHMENT_STORE_OP_STORE;
color.initialLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
color.finalLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkAttachmentReference colorRef{};
colorRef.attachment = 0; /* color output from the shader */
colorRef.layout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
VkSubpassDescription render{};
render.colorAttachmentCount = 1;
render.pColorAttachments = &colorRef;
VkRenderPassCreateInfo info{};
info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_CREATE_INFO;
info.attachmentCount = 1;
info.pAttachments = &color;
info.subpassCount = 1;
info.pSubpasses = &render;
MAGNUM_VK_ASSERT_OUTPUT(vkCreateRenderPass(device, &info, nullptr, &renderPass));
}
/* Framebuffer image */
VkImage image;
{
VkImageCreateInfo info{};
info.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
info.imageType = VK_IMAGE_TYPE_2D;
info.format = VK_FORMAT_R8G8B8A8_SRGB;
info.extent = {800, 600, 1};
info.mipLevels = 1;
info.arrayLayers = 1;
info.samples = VK_SAMPLE_COUNT_1_BIT;
info.tiling = VK_IMAGE_TILING_LINEAR;
info.usage = VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT;
info.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
MAGNUM_VK_ASSERT_OUTPUT(vkCreateImage(device, &info, nullptr, &image));
}
VkDeviceMemory imageMemory;
{
VkMemoryRequirements requirements;
vkGetImageMemoryRequirements(device, image, &requirements);
CORRADE_INTERNAL_ASSERT(requirements.size == 800*600*4);
VkMemoryAllocateInfo info{};
info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
info.allocationSize = requirements.size;
info.memoryTypeIndex = MemoryTypeIndex; /* Assuming the type from above */
MAGNUM_VK_ASSERT_OUTPUT(vkAllocateMemory(device, &info, nullptr, &imageMemory));
MAGNUM_VK_ASSERT_OUTPUT(vkBindImageMemory(device, image, imageMemory, 0));
}
VkImageView color;
{
VkImageViewCreateInfo info{};
info.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
info.image = image;
info.viewType = VK_IMAGE_VIEW_TYPE_2D;
info.format = VK_FORMAT_R8G8B8A8_SRGB;
info.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
info.subresourceRange.baseMipLevel = 0;
info.subresourceRange.levelCount = 1;
info.subresourceRange.baseArrayLayer = 0;
info.subresourceRange.layerCount = 1;
MAGNUM_VK_ASSERT_OUTPUT(vkCreateImageView(device, &info, nullptr, &color));
}
/* Vertex buffer */
VkBuffer buffer;
{
VkBufferCreateInfo info{};
info.sType = VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO;
info.size = 3*2*4*4; /* Three vertices, each is four-element pos & color */
info.usage = VK_BUFFER_USAGE_VERTEX_BUFFER_BIT;
MAGNUM_VK_ASSERT_OUTPUT(vkCreateBuffer(device, &info, nullptr, &buffer));
}
VkDeviceMemory bufferMemory;
{
VkMemoryRequirements requirements;
vkGetBufferMemoryRequirements(device, buffer, &requirements);
CORRADE_INTERNAL_ASSERT(requirements.size == 3*2*4*4);
VkMemoryAllocateInfo info{};
info.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
info.allocationSize = requirements.size;
info.memoryTypeIndex = MemoryTypeIndex; /* Assuming the type from above */
MAGNUM_VK_ASSERT_OUTPUT(vkAllocateMemory(device, &info, nullptr, &bufferMemory));
MAGNUM_VK_ASSERT_OUTPUT(vkBindBufferMemory(device, buffer, bufferMemory, 0));
/* Fill the data */
void* data;
MAGNUM_VK_ASSERT_OUTPUT(vkMapMemory(device, bufferMemory, 0, VK_WHOLE_SIZE, 0, &data));
auto view = Containers::arrayCast<Vector4>(Containers::arrayView(static_cast<char*>(data), 3*2*4*4));
view[0] = {-0.5f, -0.5f, 0.0f, 1.0f}; /* Left vertex, red color */
view[1] = 0xff0000ff_srgbaf;
view[2] = { 0.5f, -0.5f, 0.0f, 1.0f}; /* Right vertex, green color */
view[3] = 0x00ff00ff_srgbaf;
view[4] = { 0.0f, 0.5f, 0.0f, 1.0f}; /* Top vertex, blue color */
view[5] = 0x0000ffff_srgbaf;
vkUnmapMemory(device, bufferMemory);
}
/* Framebuffer */
VkFramebuffer framebuffer;
{
VkFramebufferCreateInfo info{};
info.sType = VK_STRUCTURE_TYPE_FRAMEBUFFER_CREATE_INFO;
info.renderPass = renderPass;
info.attachmentCount = 1;
info.pAttachments = &color;
info.width = 800;
info.height = 600;
info.layers = 1;
MAGNUM_VK_ASSERT_OUTPUT(vkCreateFramebuffer(device, &info, nullptr, &framebuffer));
}
/* Create the shader */
VkShaderModule shader;
{
auto o = [](UnsignedShort length, UnsignedShort opcode) {
return UnsignedInt(length << 16 | opcode);
};
auto s = [](const char(&s)[5]) {
return UnsignedInt(s[3] << 24 | s[2] << 16 | s[1] << 8 | s[0]);
};
const UnsignedInt code[]{
/* I am the generator, I have 66 IDs max, instruction schema is 0 */
SpvMagicNumber, SpvVersion, 0, 66, 0,
o(2, SpvOpCapability), SpvCapabilityShader,
o(3, SpvOpMemoryModel), SpvAddressingModelLogical, SpvMemoryModelGLSL450,
/* Function %1 is vertex shader and has %12, %13 as input and %15, %16 as output */
o(8, SpvOpEntryPoint), SpvExecutionModelVertex, 1, s("ver\0"), 12, 13, 15, 16,
/* Function %2 is fragment shader and has %5 as input and %6 as output */
o(6, SpvOpEntryPoint), SpvExecutionModelFragment, 2, s("fra\0"), 5, 6,
/* Input/output layouts */
o(4, SpvOpDecorate), 12, SpvDecorationLocation, 0, /* in position = 0 */
o(4, SpvOpDecorate), 13, SpvDecorationLocation, 1, /* in color = 1 */
o(4, SpvOpDecorate), 15, SpvDecorationBuiltIn, SpvBuiltInPosition, /* out position = gl_Position */
o(4, SpvOpDecorate), 16, SpvDecorationLocation, 0, /* out color = 0 */
o(4, SpvOpDecorate), 5, SpvDecorationLocation, 0, /* in color = 0 */
o(4, SpvOpDecorate), 6, SpvDecorationLocation, 0, /* out color = 0 */
/* Types */
o(2, SpvOpTypeVoid), 7, /* %7 = void */
o(3, SpvOpTypeFunction), 8, 7, /* %8 = void () */
o(3, SpvOpTypeFloat), 9, 32, /* %9 = float */
o(4, SpvOpTypeVector), 10, 9, 4, /* %10 = vec4 */
o(4, SpvOpTypePointer), 11, SpvStorageClassInput, 10, /* %11 = in vec4* */
o(4, SpvOpVariable), 11, 12, SpvStorageClassInput, /* %12 = in position */
o(4, SpvOpVariable), 11, 13, SpvStorageClassInput, /* %13 = in color */
o(4, SpvOpTypePointer), 14, SpvStorageClassOutput, 10, /* %14 = out vec4* */
o(4, SpvOpVariable), 14, 15, SpvStorageClassOutput, /* %15 = out position */
o(4, SpvOpVariable), 14, 16, SpvStorageClassOutput, /* %16 = out color */
o(4, SpvOpVariable), 11, 5, SpvStorageClassInput, /* %5 = frag in color */
o(4, SpvOpVariable), 14, 6, SpvStorageClassOutput, /* %6 = frag out color */
/* %1 = void ver() */
o(5, SpvOpFunction), 7, 1, SpvFunctionControlMaskNone, 8,
o(2, SpvOpLabel), 33,
o(4, SpvOpLoad), 10, 30, 12, /* %30 = load position as vec4 */
o(4, SpvOpLoad), 10, 31, 13, /* %31 = load color as vec4 */
o(3, SpvOpStore), 15, 30, /* store position from %30 */
o(3, SpvOpStore), 16, 31, /* store color from %31 */
o(1, SpvOpReturn),
o(1, SpvOpFunctionEnd),
/* %2 = void fra() */
o(5, SpvOpFunction), 7, 2, SpvFunctionControlMaskNone, 8,
o(2, SpvOpLabel), 34,
o(4, SpvOpLoad), 10, 32, 5, /* %32 = load color as vec4 */
o(3, SpvOpStore), 6, 32, /* store color from %32 */
o(1, SpvOpReturn),
o(1, SpvOpFunctionEnd)
};
VkShaderModuleCreateInfo info{};
info.sType = VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO;
info.codeSize = sizeof(code);
info.pCode = code;
MAGNUM_VK_ASSERT_OUTPUT(vkCreateShaderModule(device, &info, nullptr, &shader));
}
/* Pipeline layout */
VkPipelineLayout pipelineLayout;
{
VkPipelineLayoutCreateInfo info{};
info.sType = VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO;
info.setLayoutCount = 0;
info.pushConstantRangeCount = 0;
MAGNUM_VK_ASSERT_OUTPUT(vkCreatePipelineLayout(device, &info, nullptr, &pipelineLayout));
}
/* Create a graphics pipeline */
VkPipeline pipeline;
{
VkVertexInputBindingDescription binding{};
binding.binding = 0;
binding.stride = 2*4*4;
VkVertexInputAttributeDescription attributes[2]{};
attributes[0].location = 0; /* position attribute */
attributes[0].binding = binding.binding;
attributes[0].format = VK_FORMAT_R32G32B32A32_SFLOAT;
attributes[0].offset = 0;
attributes[1].location = 1; /* color attribute */
attributes[1].binding = binding.binding;
attributes[1].format = VK_FORMAT_R32G32B32A32_SFLOAT;
attributes[1].offset = 4*4;
VkPipelineVertexInputStateCreateInfo vertexInputInfo{};
vertexInputInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO;
vertexInputInfo.vertexBindingDescriptionCount = 1;
vertexInputInfo.pVertexBindingDescriptions = &binding;
vertexInputInfo.vertexAttributeDescriptionCount = 2;
vertexInputInfo.pVertexAttributeDescriptions = attributes;
VkPipelineInputAssemblyStateCreateInfo inputAssemblyInfo{};
inputAssemblyInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO;
inputAssemblyInfo.topology = VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
VkViewport viewport{};
viewport.width = 800.0f;
viewport.height = 600.0f;
viewport.maxDepth = 1.0f;
VkRect2D scissor{{}, {800, 600}};
VkPipelineViewportStateCreateInfo viewportInfo{};
viewportInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO;
viewportInfo.viewportCount = 1;
viewportInfo.pViewports = &viewport;
viewportInfo.scissorCount = 1;
viewportInfo.pScissors = &scissor;
VkPipelineRasterizationStateCreateInfo rasterizationInfo{};
rasterizationInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO;
rasterizationInfo.lineWidth = 1.0f;
/* the zero-filled defaults are good enough apparently */
VkPipelineMultisampleStateCreateInfo multisampleInfo{};
multisampleInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO;
multisampleInfo.rasterizationSamples = VK_SAMPLE_COUNT_1_BIT;
VkPipelineColorBlendAttachmentState blend{};
blend.colorWriteMask = VK_COLOR_COMPONENT_R_BIT|
VK_COLOR_COMPONENT_G_BIT|
VK_COLOR_COMPONENT_B_BIT|
VK_COLOR_COMPONENT_A_BIT;
VkPipelineColorBlendStateCreateInfo colorBlendInfo{};
colorBlendInfo.sType = VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO;
colorBlendInfo.attachmentCount = 1;
colorBlendInfo.pAttachments = &blend;
VkPipelineShaderStageCreateInfo stages[2]{};
stages[0].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
stages[0].stage = VK_SHADER_STAGE_VERTEX_BIT;
stages[0].module = shader;
stages[0].pName = "ver";
stages[1].sType = VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO;
stages[1].stage = VK_SHADER_STAGE_FRAGMENT_BIT;
stages[1].module = shader;
stages[1].pName = "fra";
VkGraphicsPipelineCreateInfo info{};
info.sType = VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO;
info.stageCount = 2;
info.pStages = stages;
info.pVertexInputState = &vertexInputInfo;
info.pInputAssemblyState = &inputAssemblyInfo;
info.pViewportState = &viewportInfo;
info.pRasterizationState = &rasterizationInfo;
info.pMultisampleState = &multisampleInfo;
info.pColorBlendState = &colorBlendInfo;
info.layout = pipelineLayout;
info.renderPass = renderPass;
info.subpass = 0;
MAGNUM_VK_ASSERT_OUTPUT(vkCreateGraphicsPipelines(device, nullptr, 1, &info, nullptr, &pipeline));
}
/* Begin recording */
{
VkCommandBufferBeginInfo info{};
info.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
MAGNUM_VK_ASSERT_OUTPUT(vkBeginCommandBuffer(commandBuffer, &info));
}
/* Convert the image to the proper layout */
{
VkImageMemoryBarrier barrier{};
barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
barrier.dstAccessMask = VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
barrier.oldLayout = VK_IMAGE_LAYOUT_UNDEFINED;
barrier.newLayout = VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL;
barrier.srcQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
barrier.dstQueueFamilyIndex = VK_QUEUE_FAMILY_IGNORED;
barrier.image = image;
barrier.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
barrier.subresourceRange.baseMipLevel = 0;
barrier.subresourceRange.levelCount = 1;
barrier.subresourceRange.baseArrayLayer = 0;
barrier.subresourceRange.layerCount = 1;
vkCmdPipelineBarrier(commandBuffer, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, VK_PIPELINE_STAGE_ALL_COMMANDS_BIT, 0, 0, nullptr, 0, nullptr, 1, &barrier);
}
/* Begin a render pass, set up clear color */
{
VkRenderPassBeginInfo info{};
info.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO;
info.renderPass = renderPass;
info.framebuffer = framebuffer;
info.renderArea = VkRect2D{{}, {800, 600}};
info.clearValueCount = 1;
const Color4 color = 0x1f1f1f_srgbf;
info.pClearValues = reinterpret_cast<const VkClearValue*>(&color);
vkCmdBeginRenderPass(commandBuffer, &info, VK_SUBPASS_CONTENTS_INLINE);
}
/* Bind the pipeline */
vkCmdBindPipeline(commandBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
/* Bind the vertex buffer */
{
const VkDeviceSize offset = 0;
vkCmdBindVertexBuffers(commandBuffer, 0, 1, &buffer, &offset);
}
/* Draw the triangle */
vkCmdDraw(commandBuffer, 3, 1, 0, 0);
/* End a render pass */
vkCmdEndRenderPass(commandBuffer);
/* End recording */
MAGNUM_VK_ASSERT_OUTPUT(vkEndCommandBuffer(commandBuffer));
/* Fence to wait on command buffer completeness */
VkFence fence;
{
VkFenceCreateInfo info{};
info.sType = VK_STRUCTURE_TYPE_FENCE_CREATE_INFO;
MAGNUM_VK_ASSERT_OUTPUT(vkCreateFence(device, &info, nullptr, &fence));
}
/* Submit the command buffer */
{
VkSubmitInfo info{};
info.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
info.commandBufferCount = 1;
info.pCommandBuffers = &commandBuffer;
MAGNUM_VK_ASSERT_OUTPUT(vkQueueSubmit(queue, 1, &info, fence));
}
/* Wait until done, 1 second max */
MAGNUM_VK_ASSERT_OUTPUT(vkWaitForFences(device, 1, &fence, true, 1000000000ull));
/* Read the image back */
{
void* data;
MAGNUM_VK_ASSERT_OUTPUT(vkMapMemory(device, imageMemory, 0, VK_WHOLE_SIZE, 0, &data));
ImageView2D image{PixelFormat::RGBA8Unorm, {800, 600}, Containers::arrayView(static_cast<char*>(data), 800*600*4)};
PluginManager::Manager<Trade::AbstractImageConverter> manager;
auto converter = manager.loadAndInstantiate("AnyImageConverter");
CORRADE_INTERNAL_ASSERT(converter);
converter->exportToFile(image, "image.png");
Debug{} << "Saved an image to image.png";
vkUnmapMemory(device, imageMemory);
}
/* Clean up */
vkDestroyPipeline(device, pipeline, nullptr);
vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
vkDestroyShaderModule(device, shader, nullptr);
vkDestroyFramebuffer(device, framebuffer, nullptr);
vkDestroyBuffer(device, buffer, nullptr);
vkFreeMemory(device, bufferMemory, nullptr);
vkDestroyImageView(device, color, nullptr);
vkDestroyImage(device, image, nullptr);
vkFreeMemory(device, imageMemory, nullptr);
vkDestroyRenderPass(device, renderPass, nullptr);
vkDestroyFence(device, fence, nullptr);
vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer);
vkDestroyCommandPool(device, commandPool, nullptr);
vkDestroyDevice(device, nullptr);
vkDestroyInstance(instance, nullptr);
}