Premier commit
Cette révision appartient à :
révision
84a72fe30c
200 fichiers modifiés
+61602
Aucun fichier ne correspond à votre recherche
@@ -0,0 +1,303 @@
|
||||
#include "renderer/Texture.hpp"
|
||||
|
||||
#include "core/Logger.hpp"
|
||||
#include "renderer/VulkanBuffer.hpp"
|
||||
#include "renderer/VulkanContext.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cstring>
|
||||
#include <stdexcept>
|
||||
#include <string>
|
||||
#include <vector>
|
||||
|
||||
namespace vercora {
|
||||
namespace {
|
||||
|
||||
VkFormat toVkFormat(TextureFormat format) {
|
||||
switch (format) {
|
||||
case TextureFormat::BC1:
|
||||
// ..._UNORM_BLOCK et non _SRGB_BLOCK : la swapchain de ce moteur est
|
||||
// en UNORM et l'eclairage est calcule tel quel depuis la Phase 2.
|
||||
// Prendre une variante sRGB ici ferait subir a la seule orthophoto
|
||||
// une conversion que rien d'autre dans le pipeline n'applique, donc
|
||||
// la rendrait plus claire que les couleurs de sommet voisines.
|
||||
return VK_FORMAT_BC1_RGB_UNORM_BLOCK;
|
||||
case TextureFormat::RGBA8:
|
||||
break;
|
||||
}
|
||||
return VK_FORMAT_R8G8B8A8_UNORM;
|
||||
}
|
||||
|
||||
// Barriere de transition de layout couvrant TOUTE la chaine de mipmaps. Les
|
||||
// niveaux sont copies d'un bloc, donc il n'y a jamais besoin de transitionner un
|
||||
// niveau isolement (ce que ferait une generation de mipmaps par blit).
|
||||
void transitionLayout(VkCommandBuffer commandBuffer, VkImage image, uint32_t mipLevels,
|
||||
VkImageLayout oldLayout, VkImageLayout newLayout,
|
||||
VkAccessFlags srcAccess, VkAccessFlags dstAccess,
|
||||
VkPipelineStageFlags srcStage, VkPipelineStageFlags dstStage) {
|
||||
VkImageMemoryBarrier barrier{};
|
||||
barrier.sType = VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER;
|
||||
barrier.oldLayout = oldLayout;
|
||||
barrier.newLayout = newLayout;
|
||||
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 = mipLevels;
|
||||
barrier.subresourceRange.baseArrayLayer = 0;
|
||||
barrier.subresourceRange.layerCount = 1;
|
||||
barrier.srcAccessMask = srcAccess;
|
||||
barrier.dstAccessMask = dstAccess;
|
||||
|
||||
vkCmdPipelineBarrier(commandBuffer, srcStage, dstStage, 0,
|
||||
0, nullptr, 0, nullptr, 1, &barrier);
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
TextureData Texture::whitePixelData() {
|
||||
TextureData data;
|
||||
data.width = 1;
|
||||
data.height = 1;
|
||||
data.format = TextureFormat::RGBA8;
|
||||
data.pixels = { 255, 255, 255, 255 };
|
||||
data.mips.push_back({ 1, 1, 0, 4 });
|
||||
data.label = "blanc 1x1";
|
||||
// Emprise volontairement degeneree : cette texture n'est PAS georeferencee,
|
||||
// et personne ne doit croire qu'elle recouvre quoi que ce soit.
|
||||
data.epsg = 0;
|
||||
return data;
|
||||
}
|
||||
|
||||
Texture::Texture(VulkanContext& context, VkCommandPool commandPool, VkQueue queue,
|
||||
const TextureData& data, bool repeat)
|
||||
: context_(context) {
|
||||
if (data.pixels.empty() || data.mips.empty()) {
|
||||
throw std::runtime_error("Texture : donnees vides.");
|
||||
}
|
||||
|
||||
const VkFormat format = toVkFormat(data.format);
|
||||
|
||||
// Verification AVANT toute allocation : sur un GPU sans textureCompressionBC,
|
||||
// creer l'image echouerait de toute facon, mais avec un message du driver
|
||||
// au lieu d'une explication. Le repli existe et il est nomme.
|
||||
VkFormatProperties properties{};
|
||||
vkGetPhysicalDeviceFormatProperties(context_.physicalDevice(), format, &properties);
|
||||
if (!(properties.optimalTilingFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT)) {
|
||||
throw std::runtime_error(
|
||||
"Texture : ce GPU ne sait pas echantillonner le format demande" +
|
||||
std::string(data.format == TextureFormat::BC1
|
||||
? " (BC1). Regenerer la texture avec "
|
||||
"tools/make_ortho_texture.py --format rgba."
|
||||
: "."));
|
||||
}
|
||||
|
||||
const uint32_t mipLevels = static_cast<uint32_t>(data.mips.size());
|
||||
createImage(data.width, data.height, mipLevels, format);
|
||||
uploadAndTransition(commandPool, queue, data);
|
||||
createView(format, mipLevels);
|
||||
createSampler(mipLevels, repeat);
|
||||
}
|
||||
|
||||
Texture::~Texture() {
|
||||
VkDevice device = context_.device();
|
||||
if (sampler_ != VK_NULL_HANDLE) {
|
||||
vkDestroySampler(device, sampler_, nullptr);
|
||||
}
|
||||
if (view_ != VK_NULL_HANDLE) {
|
||||
vkDestroyImageView(device, view_, nullptr);
|
||||
}
|
||||
if (image_ != VK_NULL_HANDLE) {
|
||||
vkDestroyImage(device, image_, nullptr);
|
||||
}
|
||||
if (memory_ != VK_NULL_HANDLE) {
|
||||
vkFreeMemory(device, memory_, nullptr);
|
||||
}
|
||||
}
|
||||
|
||||
void Texture::createImage(uint32_t width, uint32_t height, uint32_t mipLevels,
|
||||
VkFormat format) {
|
||||
VkImageCreateInfo imageInfo{};
|
||||
imageInfo.sType = VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO;
|
||||
imageInfo.imageType = VK_IMAGE_TYPE_2D;
|
||||
imageInfo.extent = { width, height, 1 };
|
||||
imageInfo.mipLevels = mipLevels;
|
||||
imageInfo.arrayLayers = 1;
|
||||
imageInfo.format = format;
|
||||
imageInfo.tiling = VK_IMAGE_TILING_OPTIMAL;
|
||||
imageInfo.initialLayout = VK_IMAGE_LAYOUT_UNDEFINED;
|
||||
imageInfo.usage = VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT;
|
||||
imageInfo.sharingMode = VK_SHARING_MODE_EXCLUSIVE;
|
||||
imageInfo.samples = VK_SAMPLE_COUNT_1_BIT;
|
||||
|
||||
VkDevice device = context_.device();
|
||||
if (vkCreateImage(device, &imageInfo, nullptr, &image_) != VK_SUCCESS) {
|
||||
throw std::runtime_error("Texture : echec de la creation de l'image.");
|
||||
}
|
||||
|
||||
VkMemoryRequirements requirements{};
|
||||
vkGetImageMemoryRequirements(device, image_, &requirements);
|
||||
|
||||
VkMemoryAllocateInfo allocInfo{};
|
||||
allocInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_INFO;
|
||||
allocInfo.allocationSize = requirements.size;
|
||||
allocInfo.memoryTypeIndex = context_.findMemoryType(
|
||||
requirements.memoryTypeBits, VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT);
|
||||
|
||||
if (vkAllocateMemory(device, &allocInfo, nullptr, &memory_) != VK_SUCCESS) {
|
||||
throw std::runtime_error("Texture : echec de l'allocation memoire de l'image.");
|
||||
}
|
||||
vkBindImageMemory(device, image_, memory_, 0);
|
||||
deviceSize_ = requirements.size;
|
||||
}
|
||||
|
||||
void Texture::uploadAndTransition(VkCommandPool commandPool, VkQueue queue,
|
||||
const TextureData& data) {
|
||||
VkDevice device = context_.device();
|
||||
const VkDeviceSize total = static_cast<VkDeviceSize>(data.pixels.size());
|
||||
|
||||
// Un seul buffer de staging pour toute la chaine : les niveaux sont deja
|
||||
// contigus dans le fichier, donc les offsets de copie sont ceux du .vcto.
|
||||
VulkanBuffer staging(context_, total,
|
||||
VK_BUFFER_USAGE_TRANSFER_SRC_BIT,
|
||||
VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT |
|
||||
VK_MEMORY_PROPERTY_HOST_COHERENT_BIT);
|
||||
staging.writeToBuffer(data.pixels.data(), total);
|
||||
staging.unmap();
|
||||
|
||||
VkCommandBufferAllocateInfo allocInfo{};
|
||||
allocInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO;
|
||||
allocInfo.level = VK_COMMAND_BUFFER_LEVEL_PRIMARY;
|
||||
allocInfo.commandPool = commandPool;
|
||||
allocInfo.commandBufferCount = 1;
|
||||
|
||||
VkCommandBuffer commandBuffer = VK_NULL_HANDLE;
|
||||
vkAllocateCommandBuffers(device, &allocInfo, &commandBuffer);
|
||||
|
||||
VkCommandBufferBeginInfo beginInfo{};
|
||||
beginInfo.sType = VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO;
|
||||
beginInfo.flags = VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT;
|
||||
vkBeginCommandBuffer(commandBuffer, &beginInfo);
|
||||
|
||||
const uint32_t mipLevels = static_cast<uint32_t>(data.mips.size());
|
||||
|
||||
transitionLayout(commandBuffer, image_, mipLevels,
|
||||
VK_IMAGE_LAYOUT_UNDEFINED, VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
||||
0, VK_ACCESS_TRANSFER_WRITE_BIT,
|
||||
VK_PIPELINE_STAGE_TOP_OF_PIPE_BIT, VK_PIPELINE_STAGE_TRANSFER_BIT);
|
||||
|
||||
std::vector<VkBufferImageCopy> regions;
|
||||
regions.reserve(mipLevels);
|
||||
for (uint32_t level = 0; level < mipLevels; ++level) {
|
||||
const TextureMipLevel& mip = data.mips[level];
|
||||
VkBufferImageCopy region{};
|
||||
region.bufferOffset = mip.offset;
|
||||
// 0 = "serre sur l'extent de l'image". Indispensable pour un format
|
||||
// compresse, ou bufferRowLength se compterait en TEXELS et non en blocs :
|
||||
// le calculer a la main serait une occasion d'erreur gratuite.
|
||||
region.bufferRowLength = 0;
|
||||
region.bufferImageHeight = 0;
|
||||
region.imageSubresource.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||||
region.imageSubresource.mipLevel = level;
|
||||
region.imageSubresource.baseArrayLayer = 0;
|
||||
region.imageSubresource.layerCount = 1;
|
||||
region.imageOffset = { 0, 0, 0 };
|
||||
region.imageExtent = { mip.width, mip.height, 1 };
|
||||
regions.push_back(region);
|
||||
}
|
||||
|
||||
vkCmdCopyBufferToImage(commandBuffer, staging.handle(), image_,
|
||||
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
||||
static_cast<uint32_t>(regions.size()), regions.data());
|
||||
|
||||
transitionLayout(commandBuffer, image_, mipLevels,
|
||||
VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL,
|
||||
VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL,
|
||||
VK_ACCESS_TRANSFER_WRITE_BIT, VK_ACCESS_SHADER_READ_BIT,
|
||||
VK_PIPELINE_STAGE_TRANSFER_BIT,
|
||||
VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT);
|
||||
|
||||
vkEndCommandBuffer(commandBuffer);
|
||||
|
||||
VkSubmitInfo submitInfo{};
|
||||
submitInfo.sType = VK_STRUCTURE_TYPE_SUBMIT_INFO;
|
||||
submitInfo.commandBufferCount = 1;
|
||||
submitInfo.pCommandBuffers = &commandBuffer;
|
||||
vkQueueSubmit(queue, 1, &submitInfo, VK_NULL_HANDLE);
|
||||
// Transfert unique a l'initialisation : attendre est simple et sans
|
||||
// consequence sur la boucle de rendu, qui n'a pas encore demarre.
|
||||
vkQueueWaitIdle(queue);
|
||||
|
||||
vkFreeCommandBuffers(device, commandPool, 1, &commandBuffer);
|
||||
}
|
||||
|
||||
void Texture::createView(VkFormat format, uint32_t mipLevels) {
|
||||
VkImageViewCreateInfo viewInfo{};
|
||||
viewInfo.sType = VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO;
|
||||
viewInfo.image = image_;
|
||||
viewInfo.viewType = VK_IMAGE_VIEW_TYPE_2D;
|
||||
viewInfo.format = format;
|
||||
viewInfo.subresourceRange.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT;
|
||||
viewInfo.subresourceRange.baseMipLevel = 0;
|
||||
viewInfo.subresourceRange.levelCount = mipLevels;
|
||||
viewInfo.subresourceRange.baseArrayLayer = 0;
|
||||
viewInfo.subresourceRange.layerCount = 1;
|
||||
|
||||
if (vkCreateImageView(context_.device(), &viewInfo, nullptr, &view_) != VK_SUCCESS) {
|
||||
throw std::runtime_error("Texture : echec de la creation de la vue d'image.");
|
||||
}
|
||||
}
|
||||
|
||||
void Texture::createSampler(uint32_t mipLevels, bool repeat) {
|
||||
VkPhysicalDeviceProperties deviceProperties{};
|
||||
vkGetPhysicalDeviceProperties(context_.physicalDevice(), &deviceProperties);
|
||||
|
||||
VkPhysicalDeviceFeatures features{};
|
||||
vkGetPhysicalDeviceFeatures(context_.physicalDevice(), &features);
|
||||
|
||||
VkSamplerCreateInfo samplerInfo{};
|
||||
samplerInfo.sType = VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO;
|
||||
samplerInfo.magFilter = VK_FILTER_LINEAR;
|
||||
samplerInfo.minFilter = VK_FILTER_LINEAR;
|
||||
// CLAMP_TO_EDGE et non REPEAT : la texture recouvre EXACTEMENT l'emprise du
|
||||
// terrain. En repetition, un sommet legerement hors bornes (l'ecretage de la
|
||||
// heightmap en produit) irait chercher la couleur du bord oppose, soit
|
||||
// plusieurs kilometres plus loin.
|
||||
samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
||||
samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
||||
samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE;
|
||||
if (repeat) {
|
||||
// PHASE 27 : texture periodique (bruit de detail), echantillonnee bien
|
||||
// au-dela de [0, 1] - la repetition est ici le comportement voulu.
|
||||
samplerInfo.addressModeU = VK_SAMPLER_ADDRESS_MODE_REPEAT;
|
||||
samplerInfo.addressModeV = VK_SAMPLER_ADDRESS_MODE_REPEAT;
|
||||
samplerInfo.addressModeW = VK_SAMPLER_ADDRESS_MODE_REPEAT;
|
||||
}
|
||||
|
||||
// L'anisotropie n'est demandee que si la feature a ete ACTIVEE sur le device
|
||||
// logique (voir VulkanContext::createLogicalDevice). La demander sans
|
||||
// l'avoir activee est une erreur de validation immediate.
|
||||
if (context_.anisotropyEnabled()) {
|
||||
samplerInfo.anisotropyEnable = VK_TRUE;
|
||||
samplerInfo.maxAnisotropy = deviceProperties.limits.maxSamplerAnisotropy;
|
||||
} else {
|
||||
samplerInfo.anisotropyEnable = VK_FALSE;
|
||||
samplerInfo.maxAnisotropy = 1.0f;
|
||||
}
|
||||
|
||||
samplerInfo.borderColor = VK_BORDER_COLOR_INT_OPAQUE_BLACK;
|
||||
samplerInfo.unnormalizedCoordinates = VK_FALSE;
|
||||
samplerInfo.compareEnable = VK_FALSE;
|
||||
samplerInfo.compareOp = VK_COMPARE_OP_ALWAYS;
|
||||
samplerInfo.mipmapMode = VK_SAMPLER_MIPMAP_MODE_LINEAR;
|
||||
samplerInfo.mipLodBias = 0.0f;
|
||||
samplerInfo.minLod = 0.0f;
|
||||
samplerInfo.maxLod = static_cast<float>(mipLevels);
|
||||
|
||||
if (vkCreateSampler(context_.device(), &samplerInfo, nullptr, &sampler_) != VK_SUCCESS) {
|
||||
throw std::runtime_error("Texture : echec de la creation de l'echantillonneur.");
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace vercora
|
||||
Référencer dans un nouveau ticket
Bloquer un utilisateur