96601494d5
Use getAssetPath() instead of ASSET_PATH to support broader range of platforms. Multisampling example determines sample rate from device at runtime. Move example wrapper code from DemoViewController.mm to dedicated MVKExample.cpp file. Remove AssImp libraries for iOS and macOS from repo, and add instructions for generating them from AssImp source files. Update general README.md file to mention support for iOS and macOS platforms. Add Apple logo for README.md. Update Vulkan logo to current registered TM logo. Update copyright notice of MoltenVK example files to MIT license. Examples use +/- on main keyboard, instead of numpad.
909 lines
32 KiB
C++
909 lines
32 KiB
C++
/*
|
|
* Vulkan Example - Texture loading (and display) example (including mip maps)
|
|
*
|
|
* Copyright (C) 2016-2017 by Sascha Willems - www.saschawillems.de
|
|
*
|
|
* This code is licensed under the MIT license (MIT) (http://opensource.org/licenses/MIT)
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#include <vector>
|
|
|
|
#define GLM_FORCE_RADIANS
|
|
#define GLM_FORCE_DEPTH_ZERO_TO_ONE
|
|
#include <glm/glm.hpp>
|
|
#include <glm/gtc/matrix_transform.hpp>
|
|
#include <gli/gli.hpp>
|
|
|
|
#include <vulkan/vulkan.h>
|
|
#include "vulkanexamplebase.h"
|
|
#include "VulkanDevice.hpp"
|
|
#include "VulkanBuffer.hpp"
|
|
|
|
#define VERTEX_BUFFER_BIND_ID 0
|
|
#define ENABLE_VALIDATION false
|
|
|
|
// Vertex layout for this example
|
|
struct Vertex {
|
|
float pos[3];
|
|
float uv[2];
|
|
float normal[3];
|
|
};
|
|
|
|
class VulkanExample : public VulkanExampleBase
|
|
{
|
|
public:
|
|
// Contains all Vulkan objects that are required to store and use a texture
|
|
// Note that this repository contains a texture class (VulkanTexture.hpp) that encapsulates texture loading functionality in a class that is used in subsequent demos
|
|
struct Texture {
|
|
VkSampler sampler;
|
|
VkImage image;
|
|
VkImageLayout imageLayout;
|
|
VkDeviceMemory deviceMemory;
|
|
VkImageView view;
|
|
uint32_t width, height;
|
|
uint32_t mipLevels;
|
|
} texture;
|
|
|
|
struct {
|
|
VkPipelineVertexInputStateCreateInfo inputState;
|
|
std::vector<VkVertexInputBindingDescription> bindingDescriptions;
|
|
std::vector<VkVertexInputAttributeDescription> attributeDescriptions;
|
|
} vertices;
|
|
|
|
vks::Buffer vertexBuffer;
|
|
vks::Buffer indexBuffer;
|
|
uint32_t indexCount;
|
|
|
|
vks::Buffer uniformBufferVS;
|
|
|
|
struct {
|
|
glm::mat4 projection;
|
|
glm::mat4 model;
|
|
glm::vec4 viewPos;
|
|
float lodBias = 0.0f;
|
|
} uboVS;
|
|
|
|
struct {
|
|
VkPipeline solid;
|
|
} pipelines;
|
|
|
|
VkPipelineLayout pipelineLayout;
|
|
VkDescriptorSet descriptorSet;
|
|
VkDescriptorSetLayout descriptorSetLayout;
|
|
|
|
VulkanExample() : VulkanExampleBase(ENABLE_VALIDATION)
|
|
{
|
|
zoom = -2.5f;
|
|
rotation = { 0.0f, 15.0f, 0.0f };
|
|
title = "Vulkan Example - Texture loading";
|
|
enableTextOverlay = true;
|
|
}
|
|
|
|
~VulkanExample()
|
|
{
|
|
// Clean up used Vulkan resources
|
|
// Note : Inherited destructor cleans up resources stored in base class
|
|
|
|
destroyTextureImage(texture);
|
|
|
|
vkDestroyPipeline(device, pipelines.solid, nullptr);
|
|
|
|
vkDestroyPipelineLayout(device, pipelineLayout, nullptr);
|
|
vkDestroyDescriptorSetLayout(device, descriptorSetLayout, nullptr);
|
|
|
|
vertexBuffer.destroy();
|
|
indexBuffer.destroy();
|
|
uniformBufferVS.destroy();
|
|
}
|
|
|
|
// Enable physical device features required for this example
|
|
virtual void getEnabledFeatures()
|
|
{
|
|
// Enable anisotropic filtering if supported
|
|
if (deviceFeatures.samplerAnisotropy) {
|
|
enabledFeatures.samplerAnisotropy = VK_TRUE;
|
|
};
|
|
}
|
|
|
|
// Create an image memory barrier used to change the layout of an image and put it into an active command buffer
|
|
void setImageLayout(VkCommandBuffer cmdBuffer, VkImage image, VkImageAspectFlags aspectMask, VkImageLayout oldImageLayout, VkImageLayout newImageLayout, VkImageSubresourceRange subresourceRange)
|
|
{
|
|
// Create an image barrier object
|
|
VkImageMemoryBarrier imageMemoryBarrier = vks::initializers::imageMemoryBarrier();;
|
|
imageMemoryBarrier.oldLayout = oldImageLayout;
|
|
imageMemoryBarrier.newLayout = newImageLayout;
|
|
imageMemoryBarrier.image = image;
|
|
imageMemoryBarrier.subresourceRange = subresourceRange;
|
|
|
|
// Only sets masks for layouts used in this example
|
|
// For a more complete version that can be used with other layouts see vks::tools::setImageLayout
|
|
|
|
// Source layouts (old)
|
|
switch (oldImageLayout)
|
|
{
|
|
case VK_IMAGE_LAYOUT_UNDEFINED:
|
|
// Only valid as initial layout, memory contents are not preserved
|
|
// Can be accessed directly, no source dependency required
|
|
imageMemoryBarrier.srcAccessMask = 0;
|
|
break;
|
|
case VK_IMAGE_LAYOUT_PREINITIALIZED:
|
|
// Only valid as initial layout for linear images, preserves memory contents
|
|
// Make sure host writes to the image have been finished
|
|
imageMemoryBarrier.srcAccessMask = VK_ACCESS_HOST_WRITE_BIT;
|
|
break;
|
|
case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
|
|
// Old layout is transfer destination
|
|
// Make sure any writes to the image have been finished
|
|
imageMemoryBarrier.srcAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
|
break;
|
|
}
|
|
|
|
// Target layouts (new)
|
|
switch (newImageLayout)
|
|
{
|
|
case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL:
|
|
// Transfer source (copy, blit)
|
|
// Make sure any reads from the image have been finished
|
|
imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_READ_BIT;
|
|
break;
|
|
case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL:
|
|
// Transfer destination (copy, blit)
|
|
// Make sure any writes to the image have been finished
|
|
imageMemoryBarrier.dstAccessMask = VK_ACCESS_TRANSFER_WRITE_BIT;
|
|
break;
|
|
case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL:
|
|
// Shader read (sampler, input attachment)
|
|
imageMemoryBarrier.dstAccessMask = VK_ACCESS_SHADER_READ_BIT;
|
|
break;
|
|
}
|
|
|
|
// Put barrier on top of pipeline
|
|
VkPipelineStageFlags srcStageFlags = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
|
|
VkPipelineStageFlags destStageFlags = VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT;
|
|
|
|
// Put barrier inside setup command buffer
|
|
vkCmdPipelineBarrier(
|
|
cmdBuffer,
|
|
srcStageFlags,
|
|
destStageFlags,
|
|
VK_FLAGS_NONE,
|
|
0, nullptr,
|
|
0, nullptr,
|
|
1, &imageMemoryBarrier);
|
|
}
|
|
|
|
void loadTexture()
|
|
{
|
|
// We use the Khronos texture format (https://www.khronos.org/opengles/sdk/tools/KTX/file_format_spec/)
|
|
std::string filename = getAssetPath() + "textures/metalplate01_rgba.ktx";
|
|
// Texture data contains 4 channels (RGBA) with unnormalized 8-bit values, this is the most commonly supported format
|
|
VkFormat format = VK_FORMAT_R8G8B8A8_UNORM;
|
|
|
|
// Set to true to use linear tiled images
|
|
// This is just for learning purposes and not suggested, as linear tiled images are pretty restricted and often only support a small set of features (e.g. no mips, etc.)
|
|
bool forceLinearTiling = false;
|
|
|
|
#if defined(__ANDROID__)
|
|
// Textures are stored inside the apk on Android (compressed)
|
|
// So they need to be loaded via the asset manager
|
|
AAsset* asset = AAssetManager_open(androidApp->activity->assetManager, filename.c_str(), AASSET_MODE_STREAMING);
|
|
assert(asset);
|
|
size_t size = AAsset_getLength(asset);
|
|
assert(size > 0);
|
|
|
|
void *textureData = malloc(size);
|
|
AAsset_read(asset, textureData, size);
|
|
AAsset_close(asset);
|
|
|
|
gli::texture2d tex2D(gli::load((const char*)textureData, size));
|
|
#else
|
|
gli::texture2d tex2D(gli::load(filename));
|
|
#endif
|
|
|
|
assert(!tex2D.empty());
|
|
|
|
VkFormatProperties formatProperties;
|
|
|
|
texture.width = static_cast<uint32_t>(tex2D[0].extent().x);
|
|
texture.height = static_cast<uint32_t>(tex2D[0].extent().y);
|
|
texture.mipLevels = static_cast<uint32_t>(tex2D.levels());
|
|
|
|
// Get device properites for the requested texture format
|
|
vkGetPhysicalDeviceFormatProperties(physicalDevice, format, &formatProperties);
|
|
|
|
// Only use linear tiling if requested (and supported by the device)
|
|
// Support for linear tiling is mostly limited, so prefer to use
|
|
// optimal tiling instead
|
|
// On most implementations linear tiling will only support a very
|
|
// limited amount of formats and features (mip maps, cubemaps, arrays, etc.)
|
|
VkBool32 useStaging = true;
|
|
|
|
// Only use linear tiling if forced
|
|
if (forceLinearTiling)
|
|
{
|
|
// Don't use linear if format is not supported for (linear) shader sampling
|
|
useStaging = !(formatProperties.linearTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT);
|
|
}
|
|
|
|
VkMemoryAllocateInfo memAllocInfo = vks::initializers::memoryAllocateInfo();
|
|
VkMemoryRequirements memReqs = {};
|
|
|
|
if (useStaging)
|
|
{
|
|
// Create a host-visible staging buffer that contains the raw image data
|
|
VkBuffer stagingBuffer;
|
|
VkDeviceMemory stagingMemory;
|
|
|
|
VkBufferCreateInfo bufferCreateInfo = vks::initializers::bufferCreateInfo();
|
|
bufferCreateInfo.size = tex2D.size();
|
|
// This buffer is used as a transfer source for the buffer copy
|
|
bufferCreateInfo.usage = VK_BUFFER_USAGE_TRANSFER_SRC_BIT;
|
|
bufferCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
|
|
VK_CHECK_RESULT(vkCreateBuffer(device, &bufferCreateInfo, nullptr, &stagingBuffer));
|
|
|
|
// Get memory requirements for the staging buffer (alignment, memory type bits)
|
|
vkGetBufferMemoryRequirements(device, stagingBuffer, &memReqs);
|
|
|
|
memAllocInfo.allocationSize = memReqs.size;
|
|
// Get memory type index for a host visible buffer
|
|
memAllocInfo.memoryTypeIndex = vulkanDevice->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
|
|
|
|
VK_CHECK_RESULT(vkAllocateMemory(device, &memAllocInfo, nullptr, &stagingMemory));
|
|
VK_CHECK_RESULT(vkBindBufferMemory(device, stagingBuffer, stagingMemory, 0));
|
|
|
|
// Copy texture data into staging buffer
|
|
uint8_t *data;
|
|
VK_CHECK_RESULT(vkMapMemory(device, stagingMemory, 0, memReqs.size, 0, (void **)&data));
|
|
memcpy(data, tex2D.data(), tex2D.size());
|
|
vkUnmapMemory(device, stagingMemory);
|
|
|
|
// Setup buffer copy regions for each mip level
|
|
std::vector<VkBufferImageCopy> bufferCopyRegions;
|
|
uint32_t offset = 0;
|
|
|
|
for (uint32_t i = 0; i < texture.mipLevels; i++)
|
|
{
|
|
VkBufferImageCopy bufferCopyRegion = {};
|
|
bufferCopyRegion.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
bufferCopyRegion.imageSubresource.mipLevel = i;
|
|
bufferCopyRegion.imageSubresource.baseArrayLayer = 0;
|
|
bufferCopyRegion.imageSubresource.layerCount = 1;
|
|
bufferCopyRegion.imageExtent.width = static_cast<uint32_t>(tex2D[i].extent().x);
|
|
bufferCopyRegion.imageExtent.height = static_cast<uint32_t>(tex2D[i].extent().y);
|
|
bufferCopyRegion.imageExtent.depth = 1;
|
|
bufferCopyRegion.bufferOffset = offset;
|
|
|
|
bufferCopyRegions.push_back(bufferCopyRegion);
|
|
|
|
offset += static_cast<uint32_t>(tex2D[i].size());
|
|
}
|
|
|
|
// Create optimal tiled target image
|
|
VkImageCreateInfo imageCreateInfo = vks::initializers::imageCreateInfo();
|
|
imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
|
|
imageCreateInfo.format = format;
|
|
imageCreateInfo.mipLevels = texture.mipLevels;
|
|
imageCreateInfo.arrayLayers = 1;
|
|
imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
imageCreateInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
|
|
imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
// Set initial layout of the image to undefined
|
|
imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
|
imageCreateInfo.extent = { texture.width, texture.height, 1 };
|
|
imageCreateInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
|
|
|
|
VK_CHECK_RESULT(vkCreateImage(device, &imageCreateInfo, nullptr, &texture.image));
|
|
|
|
vkGetImageMemoryRequirements(device, texture.image, &memReqs);
|
|
|
|
memAllocInfo.allocationSize = memReqs.size;
|
|
memAllocInfo.memoryTypeIndex = vulkanDevice->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
|
|
|
VK_CHECK_RESULT(vkAllocateMemory(device, &memAllocInfo, nullptr, &texture.deviceMemory));
|
|
VK_CHECK_RESULT(vkBindImageMemory(device, texture.image, texture.deviceMemory, 0));
|
|
|
|
VkCommandBuffer copyCmd = VulkanExampleBase::createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
|
|
|
|
// Image barrier for optimal image
|
|
|
|
// The sub resource range describes the regions of the image we will be transition
|
|
VkImageSubresourceRange subresourceRange = {};
|
|
// Image only contains color data
|
|
subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
// Start at first mip level
|
|
subresourceRange.baseMipLevel = 0;
|
|
// We will transition on all mip levels
|
|
subresourceRange.levelCount = texture.mipLevels;
|
|
// The 2D texture only has one layer
|
|
subresourceRange.layerCount = 1;
|
|
|
|
// Optimal image will be used as destination for the copy, so we must transfer from our
|
|
// initial undefined image layout to the transfer destination layout
|
|
setImageLayout(
|
|
copyCmd,
|
|
texture.image,
|
|
VK_IMAGE_ASPECT_COLOR_BIT,
|
|
VK_IMAGE_LAYOUT_UNDEFINED,
|
|
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
|
subresourceRange);
|
|
|
|
// Copy mip levels from staging buffer
|
|
vkCmdCopyBufferToImage(
|
|
copyCmd,
|
|
stagingBuffer,
|
|
texture.image,
|
|
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
|
static_cast<uint32_t>(bufferCopyRegions.size()),
|
|
bufferCopyRegions.data());
|
|
|
|
// Change texture image layout to shader read after all mip levels have been copied
|
|
texture.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
|
setImageLayout(
|
|
copyCmd,
|
|
texture.image,
|
|
VK_IMAGE_ASPECT_COLOR_BIT,
|
|
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
|
texture.imageLayout,
|
|
subresourceRange);
|
|
|
|
VulkanExampleBase::flushCommandBuffer(copyCmd, queue, true);
|
|
|
|
// Clean up staging resources
|
|
vkFreeMemory(device, stagingMemory, nullptr);
|
|
vkDestroyBuffer(device, stagingBuffer, nullptr);
|
|
}
|
|
else
|
|
{
|
|
VkImage mappableImage;
|
|
VkDeviceMemory mappableMemory;
|
|
|
|
// Load mip map level 0 to linear tiling image
|
|
VkImageCreateInfo imageCreateInfo = vks::initializers::imageCreateInfo();
|
|
imageCreateInfo.imageType = VK_IMAGE_TYPE_2D;
|
|
imageCreateInfo.format = format;
|
|
imageCreateInfo.mipLevels = 1;
|
|
imageCreateInfo.arrayLayers = 1;
|
|
imageCreateInfo.samples = VK_SAMPLE_COUNT_1_BIT;
|
|
imageCreateInfo.tiling = VK_IMAGE_TILING_LINEAR;
|
|
imageCreateInfo.usage = VK_IMAGE_USAGE_SAMPLED_BIT;
|
|
imageCreateInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
|
imageCreateInfo.initialLayout = VK_IMAGE_LAYOUT_PREINITIALIZED;
|
|
imageCreateInfo.extent = { texture.width, texture.height, 1 };
|
|
VK_CHECK_RESULT(vkCreateImage(device, &imageCreateInfo, nullptr, &mappableImage));
|
|
|
|
// Get memory requirements for this image
|
|
// like size and alignment
|
|
vkGetImageMemoryRequirements(device, mappableImage, &memReqs);
|
|
// Set memory allocation size to required memory size
|
|
memAllocInfo.allocationSize = memReqs.size;
|
|
|
|
// Get memory type that can be mapped to host memory
|
|
memAllocInfo.memoryTypeIndex = vulkanDevice->getMemoryType(memReqs.memoryTypeBits, VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
|
|
|
|
// Allocate host memory
|
|
VK_CHECK_RESULT(vkAllocateMemory(device, &memAllocInfo, nullptr, &mappableMemory));
|
|
|
|
// Bind allocated image for use
|
|
VK_CHECK_RESULT(vkBindImageMemory(device, mappableImage, mappableMemory, 0));
|
|
|
|
// Get sub resource layout
|
|
// Mip map count, array layer, etc.
|
|
VkImageSubresource subRes = {};
|
|
subRes.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
|
|
VkSubresourceLayout subResLayout;
|
|
void *data;
|
|
|
|
// Get sub resources layout
|
|
// Includes row pitch, size offsets, etc.
|
|
vkGetImageSubresourceLayout(device, mappableImage, &subRes, &subResLayout);
|
|
|
|
// Map image memory
|
|
VK_CHECK_RESULT(vkMapMemory(device, mappableMemory, 0, memReqs.size, 0, &data));
|
|
|
|
// Copy image data into memory
|
|
memcpy(data, tex2D[subRes.mipLevel].data(), tex2D[subRes.mipLevel].size());
|
|
|
|
vkUnmapMemory(device, mappableMemory);
|
|
|
|
// Linear tiled images don't need to be staged
|
|
// and can be directly used as textures
|
|
texture.image = mappableImage;
|
|
texture.deviceMemory = mappableMemory;
|
|
texture.imageLayout = VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL;
|
|
|
|
VkCommandBuffer copyCmd = VulkanExampleBase::createCommandBuffer(VK_COMMAND_BUFFER_LEVEL_PRIMARY, true);
|
|
|
|
// Setup image memory barrier transfer image to shader read layout
|
|
|
|
// The sub resource range describes the regions of the image we will be transition
|
|
VkImageSubresourceRange subresourceRange = {};
|
|
// Image only contains color data
|
|
subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
// Start at first mip level
|
|
subresourceRange.baseMipLevel = 0;
|
|
// Only one mip level, most implementations won't support more for linear tiled images
|
|
subresourceRange.levelCount = 1;
|
|
// The 2D texture only has one layer
|
|
subresourceRange.layerCount = 1;
|
|
|
|
setImageLayout(
|
|
copyCmd,
|
|
texture.image,
|
|
VK_IMAGE_ASPECT_COLOR_BIT,
|
|
VK_IMAGE_LAYOUT_PREINITIALIZED,
|
|
texture.imageLayout,
|
|
subresourceRange);
|
|
|
|
VulkanExampleBase::flushCommandBuffer(copyCmd, queue, true);
|
|
}
|
|
|
|
// Create a texture sampler
|
|
// In Vulkan textures are accessed by samplers
|
|
// This separates all the sampling information from the texture data. This means you could have multiple sampler objects for the same texture with different settings
|
|
// Note: Similar to the samplers available with OpenGL 3.3
|
|
VkSamplerCreateInfo sampler = vks::initializers::samplerCreateInfo();
|
|
sampler.magFilter = VK_FILTER_LINEAR;
|
|
sampler.minFilter = VK_FILTER_LINEAR;
|
|
sampler.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
|
|
sampler.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
|
|
sampler.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
|
|
sampler.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
|
|
sampler.mipLodBias = 0.0f;
|
|
sampler.compareOp = VK_COMPARE_OP_NEVER;
|
|
sampler.minLod = 0.0f;
|
|
// Set max level-of-detail to mip level count of the texture
|
|
sampler.maxLod = (useStaging) ? (float)texture.mipLevels : 0.0f;
|
|
// Enable anisotropic filtering
|
|
// This feature is optional, so we must check if it's supported on the device
|
|
if (vulkanDevice->features.samplerAnisotropy)
|
|
{
|
|
// Use max. level of anisotropy for this example
|
|
sampler.maxAnisotropy = vulkanDevice->properties.limits.maxSamplerAnisotropy;
|
|
sampler.anisotropyEnable = VK_TRUE;
|
|
}
|
|
else
|
|
{
|
|
// The device does not support anisotropic filtering
|
|
sampler.maxAnisotropy = 1.0;
|
|
sampler.anisotropyEnable = VK_FALSE;
|
|
}
|
|
sampler.borderColor = VK_BORDER_COLOR_FLOAT_OPAQUE_WHITE;
|
|
VK_CHECK_RESULT(vkCreateSampler(device, &sampler, nullptr, &texture.sampler));
|
|
|
|
// Create image view
|
|
// Textures are not directly accessed by the shaders and
|
|
// are abstracted by image views containing additional
|
|
// information and sub resource ranges
|
|
VkImageViewCreateInfo view = vks::initializers::imageViewCreateInfo();
|
|
view.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
|
view.format = format;
|
|
view.components = { VK_COMPONENT_SWIZZLE_R, VK_COMPONENT_SWIZZLE_G, VK_COMPONENT_SWIZZLE_B, VK_COMPONENT_SWIZZLE_A };
|
|
// The subresource range describes the set of mip levels (and array layers) that can be accessed through this image view
|
|
// It's possible to create multiple image views for a single image referring to different (and/or overlapping) ranges of the image
|
|
view.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
|
view.subresourceRange.baseMipLevel = 0;
|
|
view.subresourceRange.baseArrayLayer = 0;
|
|
view.subresourceRange.layerCount = 1;
|
|
// Linear tiling usually won't support mip maps
|
|
// Only set mip map count if optimal tiling is used
|
|
view.subresourceRange.levelCount = (useStaging) ? texture.mipLevels : 1;
|
|
// The view will be based on the texture's image
|
|
view.image = texture.image;
|
|
VK_CHECK_RESULT(vkCreateImageView(device, &view, nullptr, &texture.view));
|
|
}
|
|
|
|
// Free all Vulkan resources used by a texture object
|
|
void destroyTextureImage(Texture texture)
|
|
{
|
|
vkDestroyImageView(device, texture.view, nullptr);
|
|
vkDestroyImage(device, texture.image, nullptr);
|
|
vkDestroySampler(device, texture.sampler, nullptr);
|
|
vkFreeMemory(device, texture.deviceMemory, nullptr);
|
|
}
|
|
|
|
void buildCommandBuffers()
|
|
{
|
|
VkCommandBufferBeginInfo cmdBufInfo = vks::initializers::commandBufferBeginInfo();
|
|
|
|
VkClearValue clearValues[2];
|
|
clearValues[0].color = defaultClearColor;
|
|
clearValues[1].depthStencil = { 1.0f, 0 };
|
|
|
|
VkRenderPassBeginInfo renderPassBeginInfo = vks::initializers::renderPassBeginInfo();
|
|
renderPassBeginInfo.renderPass = renderPass;
|
|
renderPassBeginInfo.renderArea.offset.x = 0;
|
|
renderPassBeginInfo.renderArea.offset.y = 0;
|
|
renderPassBeginInfo.renderArea.extent.width = width;
|
|
renderPassBeginInfo.renderArea.extent.height = height;
|
|
renderPassBeginInfo.clearValueCount = 2;
|
|
renderPassBeginInfo.pClearValues = clearValues;
|
|
|
|
for (int32_t i = 0; i < drawCmdBuffers.size(); ++i)
|
|
{
|
|
// Set target frame buffer
|
|
renderPassBeginInfo.framebuffer = frameBuffers[i];
|
|
|
|
VK_CHECK_RESULT(vkBeginCommandBuffer(drawCmdBuffers[i], &cmdBufInfo));
|
|
|
|
vkCmdBeginRenderPass(drawCmdBuffers[i], &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
|
|
|
|
VkViewport viewport = vks::initializers::viewport((float)width, (float)height, 0.0f, 1.0f);
|
|
vkCmdSetViewport(drawCmdBuffers[i], 0, 1, &viewport);
|
|
|
|
VkRect2D scissor = vks::initializers::rect2D(width, height, 0, 0);
|
|
vkCmdSetScissor(drawCmdBuffers[i], 0, 1, &scissor);
|
|
|
|
vkCmdBindDescriptorSets(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0, 1, &descriptorSet, 0, NULL);
|
|
vkCmdBindPipeline(drawCmdBuffers[i], VK_PIPELINE_BIND_POINT_GRAPHICS, pipelines.solid);
|
|
|
|
VkDeviceSize offsets[1] = { 0 };
|
|
vkCmdBindVertexBuffers(drawCmdBuffers[i], VERTEX_BUFFER_BIND_ID, 1, &vertexBuffer.buffer, offsets);
|
|
vkCmdBindIndexBuffer(drawCmdBuffers[i], indexBuffer.buffer, 0, VK_INDEX_TYPE_UINT32);
|
|
|
|
vkCmdDrawIndexed(drawCmdBuffers[i], indexCount, 1, 0, 0, 0);
|
|
|
|
vkCmdEndRenderPass(drawCmdBuffers[i]);
|
|
|
|
VK_CHECK_RESULT(vkEndCommandBuffer(drawCmdBuffers[i]));
|
|
}
|
|
}
|
|
|
|
void draw()
|
|
{
|
|
VulkanExampleBase::prepareFrame();
|
|
|
|
// Command buffer to be sumitted to the queue
|
|
submitInfo.commandBufferCount = 1;
|
|
submitInfo.pCommandBuffers = &drawCmdBuffers[currentBuffer];
|
|
|
|
// Submit to queue
|
|
VK_CHECK_RESULT(vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE));
|
|
|
|
VulkanExampleBase::submitFrame();
|
|
}
|
|
|
|
void generateQuad()
|
|
{
|
|
// Setup vertices for a single uv-mapped quad made from two triangles
|
|
std::vector<Vertex> vertices =
|
|
{
|
|
{ { 1.0f, 1.0f, 0.0f }, { 1.0f, 1.0f },{ 0.0f, 0.0f, 1.0f } },
|
|
{ { -1.0f, 1.0f, 0.0f }, { 0.0f, 1.0f },{ 0.0f, 0.0f, 1.0f } },
|
|
{ { -1.0f, -1.0f, 0.0f }, { 0.0f, 0.0f },{ 0.0f, 0.0f, 1.0f } },
|
|
{ { 1.0f, -1.0f, 0.0f }, { 1.0f, 0.0f },{ 0.0f, 0.0f, 1.0f } }
|
|
};
|
|
|
|
// Setup indices
|
|
std::vector<uint32_t> indices = { 0,1,2, 2,3,0 };
|
|
indexCount = static_cast<uint32_t>(indices.size());
|
|
|
|
// Create buffers
|
|
// For the sake of simplicity we won't stage the vertex data to the gpu memory
|
|
// Vertex buffer
|
|
VK_CHECK_RESULT(vulkanDevice->createBuffer(
|
|
VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,
|
|
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
|
&vertexBuffer,
|
|
vertices.size() * sizeof(Vertex),
|
|
vertices.data()));
|
|
// Index buffer
|
|
VK_CHECK_RESULT(vulkanDevice->createBuffer(
|
|
VK_BUFFER_USAGE_INDEX_BUFFER_BIT,
|
|
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
|
&indexBuffer,
|
|
indices.size() * sizeof(uint32_t),
|
|
indices.data()));
|
|
}
|
|
|
|
void setupVertexDescriptions()
|
|
{
|
|
// Binding description
|
|
vertices.bindingDescriptions.resize(1);
|
|
vertices.bindingDescriptions[0] =
|
|
vks::initializers::vertexInputBindingDescription(
|
|
VERTEX_BUFFER_BIND_ID,
|
|
sizeof(Vertex),
|
|
VK_VERTEX_INPUT_RATE_VERTEX);
|
|
|
|
// Attribute descriptions
|
|
// Describes memory layout and shader positions
|
|
vertices.attributeDescriptions.resize(3);
|
|
// Location 0 : Position
|
|
vertices.attributeDescriptions[0] =
|
|
vks::initializers::vertexInputAttributeDescription(
|
|
VERTEX_BUFFER_BIND_ID,
|
|
0,
|
|
VK_FORMAT_R32G32B32_SFLOAT,
|
|
offsetof(Vertex, pos));
|
|
// Location 1 : Texture coordinates
|
|
vertices.attributeDescriptions[1] =
|
|
vks::initializers::vertexInputAttributeDescription(
|
|
VERTEX_BUFFER_BIND_ID,
|
|
1,
|
|
VK_FORMAT_R32G32_SFLOAT,
|
|
offsetof(Vertex, uv));
|
|
// Location 1 : Vertex normal
|
|
vertices.attributeDescriptions[2] =
|
|
vks::initializers::vertexInputAttributeDescription(
|
|
VERTEX_BUFFER_BIND_ID,
|
|
2,
|
|
VK_FORMAT_R32G32B32_SFLOAT,
|
|
offsetof(Vertex, normal));
|
|
|
|
vertices.inputState = vks::initializers::pipelineVertexInputStateCreateInfo();
|
|
vertices.inputState.vertexBindingDescriptionCount = static_cast<uint32_t>(vertices.bindingDescriptions.size());
|
|
vertices.inputState.pVertexBindingDescriptions = vertices.bindingDescriptions.data();
|
|
vertices.inputState.vertexAttributeDescriptionCount = static_cast<uint32_t>(vertices.attributeDescriptions.size());
|
|
vertices.inputState.pVertexAttributeDescriptions = vertices.attributeDescriptions.data();
|
|
}
|
|
|
|
void setupDescriptorPool()
|
|
{
|
|
// Example uses one ubo and one image sampler
|
|
std::vector<VkDescriptorPoolSize> poolSizes =
|
|
{
|
|
vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER, 1),
|
|
vks::initializers::descriptorPoolSize(VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, 1)
|
|
};
|
|
|
|
VkDescriptorPoolCreateInfo descriptorPoolInfo =
|
|
vks::initializers::descriptorPoolCreateInfo(
|
|
static_cast<uint32_t>(poolSizes.size()),
|
|
poolSizes.data(),
|
|
2);
|
|
|
|
VK_CHECK_RESULT(vkCreateDescriptorPool(device, &descriptorPoolInfo, nullptr, &descriptorPool));
|
|
}
|
|
|
|
void setupDescriptorSetLayout()
|
|
{
|
|
std::vector<VkDescriptorSetLayoutBinding> setLayoutBindings =
|
|
{
|
|
// Binding 0 : Vertex shader uniform buffer
|
|
vks::initializers::descriptorSetLayoutBinding(
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
|
VK_SHADER_STAGE_VERTEX_BIT,
|
|
0),
|
|
// Binding 1 : Fragment shader image sampler
|
|
vks::initializers::descriptorSetLayoutBinding(
|
|
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER,
|
|
VK_SHADER_STAGE_FRAGMENT_BIT,
|
|
1)
|
|
};
|
|
|
|
VkDescriptorSetLayoutCreateInfo descriptorLayout =
|
|
vks::initializers::descriptorSetLayoutCreateInfo(
|
|
setLayoutBindings.data(),
|
|
static_cast<uint32_t>(setLayoutBindings.size()));
|
|
|
|
VK_CHECK_RESULT(vkCreateDescriptorSetLayout(device, &descriptorLayout, nullptr, &descriptorSetLayout));
|
|
|
|
VkPipelineLayoutCreateInfo pPipelineLayoutCreateInfo =
|
|
vks::initializers::pipelineLayoutCreateInfo(
|
|
&descriptorSetLayout,
|
|
1);
|
|
|
|
VK_CHECK_RESULT(vkCreatePipelineLayout(device, &pPipelineLayoutCreateInfo, nullptr, &pipelineLayout));
|
|
}
|
|
|
|
void setupDescriptorSet()
|
|
{
|
|
VkDescriptorSetAllocateInfo allocInfo =
|
|
vks::initializers::descriptorSetAllocateInfo(
|
|
descriptorPool,
|
|
&descriptorSetLayout,
|
|
1);
|
|
|
|
VK_CHECK_RESULT(vkAllocateDescriptorSets(device, &allocInfo, &descriptorSet));
|
|
|
|
// Setup a descriptor image info for the current texture to be used as a combined image sampler
|
|
VkDescriptorImageInfo textureDescriptor;
|
|
textureDescriptor.imageView = texture.view; // The image's view (images are never directly accessed by the shader, but rather through views defining subresources)
|
|
textureDescriptor.sampler = texture.sampler; // The sampler (Telling the pipeline how to sample the texture, including repeat, border, etc.)
|
|
textureDescriptor.imageLayout = texture.imageLayout; // The current layout of the image (Note: Should always fit the actual use, e.g. shader read)
|
|
|
|
std::vector<VkWriteDescriptorSet> writeDescriptorSets =
|
|
{
|
|
// Binding 0 : Vertex shader uniform buffer
|
|
vks::initializers::writeDescriptorSet(
|
|
descriptorSet,
|
|
VK_DESCRIPTOR_TYPE_UNIFORM_BUFFER,
|
|
0,
|
|
&uniformBufferVS.descriptor),
|
|
// Binding 1 : Fragment shader texture sampler
|
|
// Fragment shader: layout (binding = 1) uniform sampler2D samplerColor;
|
|
vks::initializers::writeDescriptorSet(
|
|
descriptorSet,
|
|
VK_DESCRIPTOR_TYPE_COMBINED_IMAGE_SAMPLER, // The descriptor set will use a combined image sampler (sampler and image could be split)
|
|
1, // Shader binding point 1
|
|
&textureDescriptor) // Pointer to the descriptor image for our texture
|
|
};
|
|
|
|
vkUpdateDescriptorSets(device, static_cast<uint32_t>(writeDescriptorSets.size()), writeDescriptorSets.data(), 0, NULL);
|
|
}
|
|
|
|
void preparePipelines()
|
|
{
|
|
VkPipelineInputAssemblyStateCreateInfo inputAssemblyState =
|
|
vks::initializers::pipelineInputAssemblyStateCreateInfo(
|
|
VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
|
|
0,
|
|
VK_FALSE);
|
|
|
|
VkPipelineRasterizationStateCreateInfo rasterizationState =
|
|
vks::initializers::pipelineRasterizationStateCreateInfo(
|
|
VK_POLYGON_MODE_FILL,
|
|
VK_CULL_MODE_NONE,
|
|
VK_FRONT_FACE_COUNTER_CLOCKWISE,
|
|
0);
|
|
|
|
VkPipelineColorBlendAttachmentState blendAttachmentState =
|
|
vks::initializers::pipelineColorBlendAttachmentState(
|
|
0xf,
|
|
VK_FALSE);
|
|
|
|
VkPipelineColorBlendStateCreateInfo colorBlendState =
|
|
vks::initializers::pipelineColorBlendStateCreateInfo(
|
|
1,
|
|
&blendAttachmentState);
|
|
|
|
VkPipelineDepthStencilStateCreateInfo depthStencilState =
|
|
vks::initializers::pipelineDepthStencilStateCreateInfo(
|
|
VK_TRUE,
|
|
VK_TRUE,
|
|
VK_COMPARE_OP_LESS_OR_EQUAL);
|
|
|
|
VkPipelineViewportStateCreateInfo viewportState =
|
|
vks::initializers::pipelineViewportStateCreateInfo(1, 1, 0);
|
|
|
|
VkPipelineMultisampleStateCreateInfo multisampleState =
|
|
vks::initializers::pipelineMultisampleStateCreateInfo(
|
|
VK_SAMPLE_COUNT_1_BIT,
|
|
0);
|
|
|
|
std::vector<VkDynamicState> dynamicStateEnables = {
|
|
VK_DYNAMIC_STATE_VIEWPORT,
|
|
VK_DYNAMIC_STATE_SCISSOR
|
|
};
|
|
VkPipelineDynamicStateCreateInfo dynamicState =
|
|
vks::initializers::pipelineDynamicStateCreateInfo(
|
|
dynamicStateEnables.data(),
|
|
static_cast<uint32_t>(dynamicStateEnables.size()),
|
|
0);
|
|
|
|
// Load shaders
|
|
std::array<VkPipelineShaderStageCreateInfo,2> shaderStages;
|
|
|
|
shaderStages[0] = loadShader(getAssetPath() + "shaders/texture/texture.vert.spv", VK_SHADER_STAGE_VERTEX_BIT);
|
|
shaderStages[1] = loadShader(getAssetPath() + "shaders/texture/texture.frag.spv", VK_SHADER_STAGE_FRAGMENT_BIT);
|
|
|
|
VkGraphicsPipelineCreateInfo pipelineCreateInfo =
|
|
vks::initializers::pipelineCreateInfo(
|
|
pipelineLayout,
|
|
renderPass,
|
|
0);
|
|
|
|
pipelineCreateInfo.pVertexInputState = &vertices.inputState;
|
|
pipelineCreateInfo.pInputAssemblyState = &inputAssemblyState;
|
|
pipelineCreateInfo.pRasterizationState = &rasterizationState;
|
|
pipelineCreateInfo.pColorBlendState = &colorBlendState;
|
|
pipelineCreateInfo.pMultisampleState = &multisampleState;
|
|
pipelineCreateInfo.pViewportState = &viewportState;
|
|
pipelineCreateInfo.pDepthStencilState = &depthStencilState;
|
|
pipelineCreateInfo.pDynamicState = &dynamicState;
|
|
pipelineCreateInfo.stageCount = static_cast<uint32_t>(shaderStages.size());
|
|
pipelineCreateInfo.pStages = shaderStages.data();
|
|
|
|
VK_CHECK_RESULT(vkCreateGraphicsPipelines(device, pipelineCache, 1, &pipelineCreateInfo, nullptr, &pipelines.solid));
|
|
}
|
|
|
|
// Prepare and initialize uniform buffer containing shader uniforms
|
|
void prepareUniformBuffers()
|
|
{
|
|
// Vertex shader uniform buffer block
|
|
VK_CHECK_RESULT(vulkanDevice->createBuffer(
|
|
VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT,
|
|
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT,
|
|
&uniformBufferVS,
|
|
sizeof(uboVS),
|
|
&uboVS));
|
|
|
|
updateUniformBuffers();
|
|
}
|
|
|
|
void updateUniformBuffers()
|
|
{
|
|
// Vertex shader
|
|
uboVS.projection = glm::perspective(glm::radians(60.0f), (float)width / (float)height, 0.001f, 256.0f);
|
|
glm::mat4 viewMatrix = glm::translate(glm::mat4(), glm::vec3(0.0f, 0.0f, zoom));
|
|
|
|
uboVS.model = viewMatrix * glm::translate(glm::mat4(), cameraPos);
|
|
uboVS.model = glm::rotate(uboVS.model, glm::radians(rotation.x), glm::vec3(1.0f, 0.0f, 0.0f));
|
|
uboVS.model = glm::rotate(uboVS.model, glm::radians(rotation.y), glm::vec3(0.0f, 1.0f, 0.0f));
|
|
uboVS.model = glm::rotate(uboVS.model, glm::radians(rotation.z), glm::vec3(0.0f, 0.0f, 1.0f));
|
|
|
|
uboVS.viewPos = glm::vec4(0.0f, 0.0f, -zoom, 0.0f);
|
|
|
|
VK_CHECK_RESULT(uniformBufferVS.map());
|
|
memcpy(uniformBufferVS.mapped, &uboVS, sizeof(uboVS));
|
|
uniformBufferVS.unmap();
|
|
}
|
|
|
|
void prepare()
|
|
{
|
|
VulkanExampleBase::prepare();
|
|
loadTexture();
|
|
generateQuad();
|
|
setupVertexDescriptions();
|
|
prepareUniformBuffers();
|
|
setupDescriptorSetLayout();
|
|
preparePipelines();
|
|
setupDescriptorPool();
|
|
setupDescriptorSet();
|
|
buildCommandBuffers();
|
|
prepared = true;
|
|
}
|
|
|
|
virtual void render()
|
|
{
|
|
if (!prepared)
|
|
return;
|
|
draw();
|
|
}
|
|
|
|
virtual void viewChanged()
|
|
{
|
|
updateUniformBuffers();
|
|
}
|
|
|
|
void changeLodBias(float delta)
|
|
{
|
|
uboVS.lodBias += delta;
|
|
if (uboVS.lodBias < 0.0f)
|
|
{
|
|
uboVS.lodBias = 0.0f;
|
|
}
|
|
if (uboVS.lodBias > texture.mipLevels)
|
|
{
|
|
uboVS.lodBias = (float)texture.mipLevels;
|
|
}
|
|
updateUniformBuffers();
|
|
updateTextOverlay();
|
|
}
|
|
|
|
virtual void keyPressed(uint32_t keyCode)
|
|
{
|
|
switch (keyCode)
|
|
{
|
|
case KEY_KPADD:
|
|
case GAMEPAD_BUTTON_R1:
|
|
changeLodBias(0.1f);
|
|
break;
|
|
case KEY_KPSUB:
|
|
case GAMEPAD_BUTTON_L1:
|
|
changeLodBias(-0.1f);
|
|
break;
|
|
}
|
|
}
|
|
|
|
virtual void getOverlayText(VulkanTextOverlay *textOverlay)
|
|
{
|
|
if (vulkanDevice->features.samplerAnisotropy) {
|
|
std::stringstream ss;
|
|
ss << std::setprecision(2) << std::fixed << uboVS.lodBias;
|
|
#if defined(__ANDROID__)
|
|
textOverlay->addText("LOD bias: " + ss.str() + " (Buttons L1/R1 to change)", 5.0f, 85.0f, VulkanTextOverlay::alignLeft);
|
|
#else
|
|
textOverlay->addText("LOD bias: " + ss.str() + " (numpad +/- to change)", 5.0f, 85.0f, VulkanTextOverlay::alignLeft);
|
|
#endif
|
|
}
|
|
}
|
|
};
|
|
|
|
VULKAN_EXAMPLE_MAIN()
|