VulkanHelperFunction.cpp

/* ----------------------
* Copyright 2023 Université Libre de Bruxelles(ULB), Universidad Politécnica de Madrid(UPM), CREAL, Deutsches Zentrum für Luft - und Raumfahrt(DLR)
 
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at < http://www.apache.org/licenses/LICENSE-2.0>
 
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissionsand
* limitations under the License.
---------------------- */
 
 
#include "VulkanHelperFunction.h"
#include"VulkanContext.h"
 
#include "commonVulkan.h"
 
#define _USE_MATH_DEFINES
#include <math.h>
 
#include <glm/gtc/quaternion.hpp>
#ifndef __ANDROID__
#include <numbers>
#endif
 
uint32_t findMemoryType(vk::PhysicalDevice& physicalDevice, uint32_t typeFilter, vk::MemoryPropertyFlags properties)
{
    vk::PhysicalDeviceMemoryProperties memProperties = physicalDevice.getMemoryProperties();
    for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) {
        if ((typeFilter & (1 << i)) && (memProperties.memoryTypes[i].propertyFlags & properties) == properties) {
            return i;
        }
    }
    throw std::runtime_error("failed to find suitable memory type!");
}
uint32_t findFastMemoryType(vk::PhysicalDevice& physicalDevice, uint32_t typeFilter, vk::MemoryPropertyFlags properties)
{
    vk::PhysicalDeviceMemoryProperties memProperties = physicalDevice.getMemoryProperties();
 
    uint32_t memoryType = 0;
    bool found = false;
    int score = 0;
    for (uint32_t i = 0; i < memProperties.memoryTypeCount; i++) {
        if ((typeFilter & (1 << i)) && (memProperties.memoryTypes[i].propertyFlags & properties) == properties) {
            if (!found){
                memoryType = i;
                found = true;
            }
            else {
                if ( ((properties & vk::MemoryPropertyFlagBits::eHostVisible) == vk::MemoryPropertyFlagBits::eHostVisible)&& (memProperties.memoryTypes[i].propertyFlags & (vk::MemoryPropertyFlagBits::eDeviceLocal | vk::MemoryPropertyFlagBits::eHostVisible))) {
                    //in general memory with device type is faster than one with eHostVisible only
                    //but it is also smaller 
                    memoryType = i;
                }
                else if ( ((properties & vk::MemoryPropertyFlagBits::eDeviceLocal) == vk::MemoryPropertyFlagBits::eDeviceLocal)&& !(memProperties.memoryTypes[i].propertyFlags & (vk::MemoryPropertyFlagBits::eDeviceLocal | vk::MemoryPropertyFlagBits::eHostVisible))) {
                    //in general memory with device local flag is enough and can fit more
                    memoryType = i;
                }
            }
        }
    }
    if (found) {
        return memoryType;
    }
    else {
        throw std::runtime_error("failed to find suitable memory type!");
    }
}
 
void createImage(vk::Device& device, vk::PhysicalDevice& physicalDevice, uint32_t width, uint32_t height, vk::Format format, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::MemoryPropertyFlags properties, vk::Image& image, vk::DeviceMemory& imageMemory)
{
    vk::ImageCreateInfo imageInfo(
        vk::ImageCreateFlags(),     //flags
        vk::ImageType::e2D,         //imageType
        format, //format
        { static_cast<uint32_t>(width), static_cast<uint32_t>(height), 1 }, //extend
        1,                          //mipLevels
        1,                          //array
        vk::SampleCountFlagBits::e1,    //samples
        tiling,     //tiling
        usage,  //usage
        vk::SharingMode::eExclusive     //sharingMode
    );
    imageInfo.initialLayout = vk::ImageLayout::eUndefined;
 
    image = device.createImage(imageInfo);
 
    vk::MemoryRequirements memRequirement = device.getImageMemoryRequirements(image);
    vk::MemoryAllocateInfo allocInfo(memRequirement.size, findMemoryType(physicalDevice, memRequirement.memoryTypeBits, properties));
 
    imageMemory = device.allocateMemory(allocInfo, nullptr);
    device.bindImageMemory(image, imageMemory, 0);
}
 
vk::ImageView createImageView(vk::Device& device, vk::Image image, vk::Format format, vk::ImageAspectFlags aspectFlags)
{
    vk::ImageSubresourceRange subRessources(
        aspectFlags, //aspectMask
        0,  //baseMipLevel
        1, //levelCount
        0,  //baseArrayLayer
        1   //layerCount
    );
    vk::ImageViewCreateInfo viewInfo(
        vk::ImageViewCreateFlags(), //flags
        image,      //image
        vk::ImageViewType::e2D, //imageView
        format,     //format
        {},     //components
        subRessources       //subRessourceRange
    );
    return device.createImageView(viewInfo);
}
vk::CommandBuffer beginSingleTimeCommands(VulkanContext* context, vk::CommandPool& commandPool)
{
    vk::CommandBufferAllocateInfo allocInfo(commandPool, vk::CommandBufferLevel::ePrimary, 1);
    vk::CommandBuffer commandBuffer = context->device.allocateCommandBuffers(allocInfo).front();
 
    vk::CommandBufferBeginInfo beginInfo(vk::CommandBufferUsageFlagBits::eOneTimeSubmit);
    commandBuffer.begin(beginInfo);
 
    return commandBuffer;
}
 
void endSingleTimeCommands(VulkanContext* context, vk::CommandPool& commandPool, vk::CommandBuffer commandBuffer)
{
    commandBuffer.end();
 
    vk::SubmitInfo submitInfo(0, nullptr, nullptr, 1, &commandBuffer);
 
    context->graphicsQueue.submit(submitInfo, nullptr);
    context->graphicsQueue.waitIdle();
    context->device.freeCommandBuffers(commandPool, 1, &commandBuffer);
}
 
void transitionImageLayout(VulkanContext* context, vk::CommandPool& commandPool, vk::Image image, vk::Format format, vk::ImageLayout oldLayout, vk::ImageLayout newLayout)
{
    vk::CommandBuffer commandBuffer = beginSingleTimeCommands(context, commandPool);
 
    vk::ImageAspectFlags aspectMask = vk::ImageAspectFlagBits::eColor;
 
    if (newLayout == vk::ImageLayout::eDepthStencilAttachmentOptimal) {
        aspectMask = vk::ImageAspectFlagBits::eDepth;
 
        if (context->hasStencilComponent(format)) {
            aspectMask |= vk::ImageAspectFlagBits::eStencil;
        }
    }
 
    vk::ImageSubresourceRange subRessources(
        aspectMask, //aspectMask
        0,  //baseMipLevel
        1, //levelCount
        0,  //baseArrayLayer
        1   //layerCount
    );
    vk::PipelineStageFlags sourceStage;
    vk::PipelineStageFlags destinationStage;
    vk::AccessFlags srcAccess;
    vk::AccessFlags dstAccess;
 
    if (oldLayout == vk::ImageLayout::eUndefined && newLayout == vk::ImageLayout::eTransferDstOptimal) {
        srcAccess = {};
        dstAccess = vk::AccessFlagBits::eTransferWrite;
 
        sourceStage = vk::PipelineStageFlagBits::eTopOfPipe;
        destinationStage = vk::PipelineStageFlagBits::eTransfer;
    }
    else if (oldLayout == vk::ImageLayout::eTransferDstOptimal && newLayout == vk::ImageLayout::eShaderReadOnlyOptimal) {
        srcAccess = vk::AccessFlagBits::eTransferWrite;
        dstAccess = vk::AccessFlagBits::eShaderRead;
 
        sourceStage = vk::PipelineStageFlagBits::eTransfer;
        destinationStage = vk::PipelineStageFlagBits::eFragmentShader;
    }
    else if (oldLayout == vk::ImageLayout::eUndefined && newLayout == vk::ImageLayout::eShaderReadOnlyOptimal) {
        srcAccess = {};
        dstAccess = vk::AccessFlagBits::eShaderRead;
 
        sourceStage = vk::PipelineStageFlagBits::eTopOfPipe;
        destinationStage = vk::PipelineStageFlagBits::eFragmentShader;
    }
    else if (oldLayout == vk::ImageLayout::eUndefined && newLayout == vk::ImageLayout::eDepthStencilAttachmentOptimal) {
        srcAccess = {};
        dstAccess = vk::AccessFlagBits::eDepthStencilAttachmentRead | vk::AccessFlagBits::eDepthStencilAttachmentWrite;
 
        sourceStage = vk::PipelineStageFlagBits::eTopOfPipe;
        destinationStage = vk::PipelineStageFlagBits::eEarlyFragmentTests;
    }
    else if (oldLayout == vk::ImageLayout::eUndefined && newLayout == vk::ImageLayout::eColorAttachmentOptimal) {
        //check this ?
        srcAccess = {};
        dstAccess = vk::AccessFlagBits::eColorAttachmentWrite;
 
        sourceStage = vk::PipelineStageFlagBits::eTopOfPipe;
        destinationStage = vk::PipelineStageFlagBits::eColorAttachmentOutput;
 
    }
    else {
        throw std::invalid_argument("unsupported layout transition!");
    }
 
 
    vk::ImageMemoryBarrier barrier(
        srcAccess,      // srcAccessMask    //TODO
        dstAccess,      //dstAccesMask  //TODO
        oldLayout,  //oldLayout
        newLayout,  //newLayout
        VK_QUEUE_FAMILY_IGNORED, // srcqueueFamily
        VK_QUEUE_FAMILY_IGNORED,    //dstQueueFamily
        image,  //image
        subRessources //subressourcesRange
    );
    commandBuffer.pipelineBarrier(sourceStage, destinationStage, {}, 0, nullptr, 0, nullptr, 1, &barrier);
 
 
    endSingleTimeCommands(context, commandPool, commandBuffer);
}
 
 
void createFastBuffer(vk::DeviceSize size, vk::BufferUsageFlags usage, vk::MemoryPropertyFlags properties, vk::Buffer& buffer, vk::DeviceMemory& bufferMemory, vk::Device& device, vk::PhysicalDevice& physicalDevice)
{
    // create buffer
    vk::BufferCreateInfo createInfo(
        vk::BufferCreateFlags(),
        size, //size
        usage, //usage
        vk::SharingMode::eExclusive         //sharing mode
    );
    buffer = device.createBuffer(createInfo);
 
    // allocate device memory for that buffer
    vk::MemoryRequirements memRequirements = device.getBufferMemoryRequirements(buffer);
    uint32_t memoryTypeIndex = findFastMemoryType(physicalDevice, memRequirements.memoryTypeBits, properties);
    vk::MemoryAllocateInfo memAllocInfo(memRequirements.size, memoryTypeIndex);
    bufferMemory = device.allocateMemory(memAllocInfo);
 
    device.bindBufferMemory(buffer, bufferMemory, 0);
}
void createBuffer(vk::DeviceSize size, vk::BufferUsageFlags usage, vk::MemoryPropertyFlags properties, vk::Buffer& buffer, vk::DeviceMemory& bufferMemory, vk::Device & device, vk::PhysicalDevice & physicalDevice)
{
    // create buffer
    vk::BufferCreateInfo createInfo(
        vk::BufferCreateFlags(),
        size, //size
        usage, //usage
        vk::SharingMode::eExclusive         //sharing mode
    );
    buffer = device.createBuffer(createInfo);
 
    // allocate device memory for that buffer
    vk::MemoryRequirements memRequirements = device.getBufferMemoryRequirements(buffer);
    uint32_t memoryTypeIndex = findMemoryType(physicalDevice, memRequirements.memoryTypeBits, properties);
    vk::MemoryAllocateInfo memAllocInfo(memRequirements.size, memoryTypeIndex);
    bufferMemory = device.allocateMemory(memAllocInfo);
 
    device.bindBufferMemory(buffer, bufferMemory, 0);
}
 
 
 
std::vector<uint32_t> generate_picture_EBO(const glm::vec2 & s)
{
    const size_t tileSize = 4;
    const size_t W = s[0];
    const size_t H = s[1];
 
    const size_t nbOfTileW = (W + tileSize - 1) / tileSize;
    const size_t nbOfTileH = (H + tileSize - 1) / tileSize;
 
    size_t elements_number = 3 * 2 * (H - 1) * (W - 1);
    std::vector<uint32_t> indices;
    indices.resize(elements_number);
 
    size_t offset = 0;
    const auto tileOffset = 6 * tileSize * tileSize;
 
    for (size_t yTile = 0; yTile < nbOfTileH ; ++yTile)
    {
        for (size_t xTile = 0; xTile < nbOfTileW ; ++xTile)
        {
            auto yBase = yTile * tileSize;
            auto xBase = xTile * tileSize;
 
            auto currentTileOffset = offset;
 
            for (size_t xd = 0 ; xd < tileSize ; xd++) {
                for (size_t yd = 0 ; yd < tileSize ; yd++) {
                    auto x = xd + xBase;
                    auto y = yd + yBase;
                    
                    auto currentTileSizeW = std::min(tileSize, W -1 - xBase);
                    if (x < W - 1 && y < H-1) {
                        indices[currentTileOffset + 6 * INDEX_E(xd, yd, (currentTileSizeW)) + 0] = uint32_t(INDEX_E(x, y, W));
                        indices[currentTileOffset + 6 * INDEX_E(xd, yd, (currentTileSizeW)) + 1] = uint32_t(INDEX_E(x + 1, y, W));
                        indices[currentTileOffset + 6 * INDEX_E(xd, yd, (currentTileSizeW)) + 2] = uint32_t(INDEX_E(x, y + 1, W));
 
                        indices[currentTileOffset + 6 * INDEX_E(xd, yd, (currentTileSizeW)) + 3] = uint32_t(INDEX_E(x, y + 1, W));
                        indices[currentTileOffset + 6 * INDEX_E(xd, yd, (currentTileSizeW)) + 4] = uint32_t(INDEX_E(x + 1, y, W));
                        indices[currentTileOffset + 6 * INDEX_E(xd, yd, (currentTileSizeW)) + 5] = uint32_t(INDEX_E(x + 1, y + 1, W));
                        
                        offset += 6;
                    }
                }
            }
        }
    }
 
    printf("Real number of elements %i\n", int(elements_number));
    return indices;
}
 
glm::mat3x3 glmRotationMatrixFromRotationAroundX(float rx)
{
    /*The following is not correct because glm use column major representation
    return glm::mat3x3(
        1.f, 0.f, 0.f,
        0.f, cos(rx), -sin(rx),
        0.f, sin(rx), cos(rx));*/
        //the correct way:
    return glm::mat3x3(
        1.f, 0.f, 0.f,
        0.f, cos(rx), sin(rx),
        0.f, -sin(rx), cos(rx));
}
 
glm::mat3x3 glmRotationMatrixFromRotationAroundY(float ry)
{
    /*
    The following is not correct because glm use column major representation
    return glm::mat3x3(
        cos(ry), 0.f, sin(ry),
        0.f, 1.f, 0.f,
        -sin(ry), 0.f, cos(ry));*/
        //the correct way:
    return glm::mat3x3(
        cos(ry), 0.f, -sin(ry),
        0.f, 1.f, 0.f,
        sin(ry), 0.f, cos(ry));
}
 
glm::mat3x3 glmRotationMatrixFromRotationAroundZ(float rz)
{
    /*The following is not correct because glm use column major representation
    return glm::mat3x3(
        cos(rz), -sin(rz), 0.f,
        sin(rz), cos(rz), 0.f,
        0.f, 0.f, 1.f);*/
        //the correct way:
    return glm::mat3x3(
        cos(rz), sin(rz), 0.f,
        -sin(rz), cos(rz), 0.f,
        0.f, 0.f, 1.f);
}
 
glm::mat3x3 glmEulerAnglesDegreeToRotationMatrix(glm::vec3 rotationDegrees)
{
    // /!\ should be in rad !!!!!!!!!!!!!!!
    //for rotation in OMAF
    auto const radperdeg = 0.01745329252f;
    auto rotation = radperdeg * rotationDegrees;
    return
        glmRotationMatrixFromRotationAroundZ(rotation[0]) *
        glmRotationMatrixFromRotationAroundY(rotation[1]) *
        glmRotationMatrixFromRotationAroundX(rotation[2]);
}
 
glm::mat3x3 glmEulerAnglesDegreeToRotationMatrixNotOMAF(glm::vec3 rotationDegrees)
{
    // /!\ should be in degree !!!!!!!!!!!!!!!
    // not for OMAF !!!!
    auto const radperdeg = 0.01745329252f;
    auto rotation = radperdeg * rotationDegrees;
    return glmRotationMatrixFromRotationAroundZ(rotation[2]) *
        glmRotationMatrixFromRotationAroundY(rotation[1]) *
        glmRotationMatrixFromRotationAroundX(rotation[0]);
}
 
#ifdef USE_OPENXR
 
glm::quat XrQuaternionToGLMQuat(XrQuaternionf & q) {
    glm::quat quad;
    quad.x = q.x;
    quad.y = q.y;
    quad.z = q.z;
    quad.w = q.w;
    return quad;
    
}
XrQuaternionf GLMQuatToXrQuaternion(glm::quat & q) {
    XrQuaternionf quad;
    quad.x = q.x;
    quad.y = q.y;
    quad.z = q.z;
    quad.w = q.w;
    return quad;
    
}
 
#endif // USE_OPENXR
 
//modified from : https://math.stackexchange.com/questions/61146/averaging-quaternions
glm::quat ApproximateAverage(std::vector<glm::quat> quaternions) {
    auto qLength = quaternions.size();
    const float weightCst = 1.0f / qLength;
    glm::quat qAvg = { 0.0, 0.0, 0.0, 0.0 };
    for (int i = 0; i < qLength; i++) {
        glm::quat q = quaternions[i];
        double weight = weightCst;
 
        // Correct for double cover, by ensuring that dot product
        // of quats[i] and quats[0] is positive
        
        if (i > 0 && glm::dot(quaternions[i], quaternions[0]) < 0.0) {
            weight = -weight;
        }
 
        qAvg += glm::quat(weight * q.x, weight * q.y, weight * q.z, weight * q.w);
    }
    return glm::normalize(qAvg);
}
 
glm::vec3 eulerAngleXYZFromRotationMatrix(glm::mat3x3& matA) {
    //source: http://eecs.qmul.ac.uk/~gslabaugh/publications/euler.pdf
    auto mat = glm::transpose(matA);
 
    auto R11 = mat[0][0];
    auto R21 = mat[1][0];
    auto R31 = mat[2][0];
 
    auto R12 = mat[0][1];
    auto R22 = mat[1][1];
    auto R32 = mat[2][1];
 
    auto R13 = mat[0][2];
    auto R23 = mat[1][2];
    auto R33 = mat[2][2];
 
    float theta = 0;
    float phi = 0;
    float psi = 0;
 
#ifndef __ANDROID__
    const double pi = std::numbers::pi;
#else
    const double pi = M_PI;
#endif
    if (std::abs(R31) != 1) {
        auto t1 = std::asin(R31);
        auto t2 = pi - t1;
        theta = std::abs(t1) <= std::abs(t2) ? t1 : t2;
 
        auto cost1 = std::cos(t1);
        auto cost2 = std::cos(t2);
 
        auto psi1 = std::atan2(R32/cost1,R33/cost1);
        auto psi2 = std::atan2(R32 /cost2, R33 /cost2);
        psi = std::abs(t1) <= std::abs(t2) ? psi1 : psi2;
 
        auto phi1 = std::atan2(R21 / cost1, R11 / cost1);
        auto phi2 = std::atan2(R21 / cost2, R11 / cost2);
        phi = std::abs(t1) <= std::abs(t2) ? phi1 : phi2;
    }
    else {
        phi = 0;
        if (R31 == -1) {
            theta = pi / 2.0f;
            psi = phi + atan2(R12, R13);
        }
        else {
            theta = -1.0f * pi / 2.0f;
            psi = -1 * phi + atan2(-R12, -R13);
        }
    }
    return 180.0f * glm::vec3(psi,theta,phi) / (float) pi;
}
/*
* slower but more precise than above
glm::quat averageWithEigen(std::vector<glm::quat> quaternions) {
    auto qLength = quaternions.size();
    float weight = 1.0f / qLength;
    glm::mat4x4 accum = glm::zero<glm::mat4x4>();
    for (int i = 0; i < qLength; i++) {
        glm::quat q = quaternions[i];
        glm::vec4 qVec = {q.x,q.y,q.z,q.w};
        glm::mat4x4 prodW = glm::outerProduct(qVec , qVec) * weight;
        accum += prodW;
    }
    //TODO find eigen value of the matrice
}*/
 
glm::vec3 quatToEuler(glm::quat q) {
    //for eulerInOpenXRSpace
    glm::vec3 out = {0,0,0};
 
    //roll
    double siny_cosp = 2 * (q.w * q.z + q.x * q.y);
    double cosy_cosp = 1 - 2 * (q.y * q.y + q.z * q.z);
    out[2] = std::atan2(siny_cosp, cosy_cosp) * (180.0 / M_PI);
 
    // pitch
    double sinp = 2 * (q.w * q.y - q.z * q.x);
    if (std::abs(sinp) >= 1) {
        out[1] = std::copysign(M_PI / 2, sinp) * (180.0 / M_PI); // use 90 degrees if out of range
    }
    else {
        //rotationsOMAF[view][2] = std::asin(sinp) * (180.0 / M_PI);
        out[1] = std::asin(sinp) * (180.0 / M_PI);
    }
 
    // Roll
    double sinr_cosp = 2 * (q.w * q.x + q.y * q.z);
    double cosr_cosp = 1 - 2 * (q.x * q.x + q.y * q.y);
    //rotationsOMAF[view][1] = -1 * std::atan2(sinr_cosp, cosr_cosp) * (180.0 / M_PI);
    out[0] = std::atan2(sinr_cosp, cosr_cosp) * (180.0 / M_PI);
 
    return out;
}