VulkanHelperFunction.h File Reference

Class that contains helper functions for Vulkan. More...

#include "commonVulkan.h"
#include "VulkanContext.h"

Go to the source code of this file.

Macros
#define	INDEX_E(x, y, W)   ((y)*(W) + (x))

Functions
uint32_t	findMemoryType (vk::PhysicalDevice &physicalDevice, uint32_t typeFilter, vk::MemoryPropertyFlags properties)
uint32_t	findFastMemoryType (vk::PhysicalDevice &physicalDevice, uint32_t typeFilter, vk::MemoryPropertyFlags properties)
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::ImageView	createImageView (vk::Device &device, vk::Image image, vk::Format format, vk::ImageAspectFlags aspectFlags)
vk::CommandBuffer	beginSingleTimeCommands (VulkanContext *context, vk::CommandPool &commandPool)
void	endSingleTimeCommands (VulkanContext *context, vk::CommandPool &commandPool, vk::CommandBuffer commandBuffer)
void	transitionImageLayout (VulkanContext *context, vk::CommandPool &commandPool, vk::Image image, vk::Format format, vk::ImageLayout oldLayout, vk::ImageLayout newLayout)
void	createBuffer (vk::DeviceSize size, vk::BufferUsageFlags usage, vk::MemoryPropertyFlags properties, vk::Buffer &buffer, vk::DeviceMemory &bufferMemory, vk::Device &device, vk::PhysicalDevice &physicalDevice)
void	createFastBuffer (vk::DeviceSize size, vk::BufferUsageFlags usage, vk::MemoryPropertyFlags properties, vk::Buffer &buffer, vk::DeviceMemory &bufferMemory, vk::Device &device, vk::PhysicalDevice &physicalDevice)
std::vector< uint32_t >	generate_picture_EBO (const glm::vec2 &s)
glm::mat3x3	glmEulerAnglesDegreeToRotationMatrix (glm::vec3)
glm::mat3x3	glmEulerAnglesDegreeToRotationMatrixNotOMAF (glm::vec3)
glm::quat	ApproximateAverage (std::vector< glm::quat > quaternions)
glm::vec3	eulerAngleXYZFromRotationMatrix (glm::mat3x3 &mat)
glm::vec3	quatToEuler (glm::quat)

Detailed Description

Class that contains helper functions for Vulkan.

Definition in file VulkanHelperFunction.h.

Macro Definition Documentation

INDEX_E

#define INDEX_E	(		x,
			y,
			W
	)		((y)*(W) + (x))

Definition at line 41 of file VulkanHelperFunction.h.

Function Documentation

ApproximateAverage()

glm::quat ApproximateAverage

(

std::vector< glm::quat >

quaternions

)

Average of quaternions "close" to each other (faster than full conversion)

Definition at line 406 of file VulkanHelperFunction.cpp.

                                                           {
    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);
}

beginSingleTimeCommands()

vk::CommandBuffer beginSingleTimeCommands	(	VulkanContext *	context,
		vk::CommandPool &	commandPool
	)

Definition at line 117 of file VulkanHelperFunction.cpp.

{
    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;
}

createBuffer()

void createBuffer	(	vk::DeviceSize	size,
		vk::BufferUsageFlags	usage,
		vk::MemoryPropertyFlags	properties,
		vk::Buffer &	buffer,
		vk::DeviceMemory &	bufferMemory,
		vk::Device &	device,
		vk::PhysicalDevice &	physicalDevice
	)

Definition at line 243 of file VulkanHelperFunction.cpp.

{
    // 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);
}

createFastBuffer()

void createFastBuffer	(	vk::DeviceSize	size,
		vk::BufferUsageFlags	usage,
		vk::MemoryPropertyFlags	properties,
		vk::Buffer &	buffer,
		vk::DeviceMemory &	bufferMemory,
		vk::Device &	device,
		vk::PhysicalDevice &	physicalDevice
	)

Definition at line 224 of file VulkanHelperFunction.cpp.

{
    // 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);
}

createImage()

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
	)

Definition at line 73 of file VulkanHelperFunction.cpp.

{
    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);
}

createImageView()

vk::ImageView createImageView	(	vk::Device &	device,
		vk::Image	image,
		vk::Format	format,
		vk::ImageAspectFlags	aspectFlags
	)

Definition at line 98 of file VulkanHelperFunction.cpp.

{
    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);
}

endSingleTimeCommands()

void endSingleTimeCommands	(	VulkanContext *	context,
		vk::CommandPool &	commandPool,
		vk::CommandBuffer	commandBuffer
	)

Definition at line 128 of file VulkanHelperFunction.cpp.

{
    commandBuffer.end();
 
    vk::SubmitInfo submitInfo(0, nullptr, nullptr, 1, &commandBuffer);
 
    context->graphicsQueue.submit(submitInfo, nullptr);
    context->graphicsQueue.waitIdle();
    context->device.freeCommandBuffers(commandPool, 1, &commandBuffer);
}

eulerAngleXYZFromRotationMatrix()

glm::vec3 eulerAngleXYZFromRotationMatrix

(

glm::mat3x3 &

mat

)

Definition at line 426 of file VulkanHelperFunction.cpp.

                                                         {
    //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;
}

findFastMemoryType()

uint32_t findFastMemoryType	(	vk::PhysicalDevice &	physicalDevice,
		uint32_t	typeFilter,
		vk::MemoryPropertyFlags	properties
	)

Definition at line 39 of file VulkanHelperFunction.cpp.

{
    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!");
    }
}

findMemoryType()

uint32_t findMemoryType	(	vk::PhysicalDevice &	physicalDevice,
		uint32_t	typeFilter,
		vk::MemoryPropertyFlags	properties
	)

Definition at line 29 of file VulkanHelperFunction.cpp.

{
    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!");
}

generate_picture_EBO()

std::vector< uint32_t > generate_picture_EBO

(

const glm::vec2 &

s

)

Definition at line 265 of file VulkanHelperFunction.cpp.

{
    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;
}

glmEulerAnglesDegreeToRotationMatrix()

glm::mat3x3 glmEulerAnglesDegreeToRotationMatrix

(

glm::vec3

rotationDegrees

)

Get rotation as a matrix

Definition at line 131 of file helpersSynthesis.cpp.

{
    // /!\ 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]);
}

glmEulerAnglesDegreeToRotationMatrixNotOMAF()

glm::mat3x3 glmEulerAnglesDegreeToRotationMatrixNotOMAF

(

glm::vec3

rotationDegrees

)

Get a matrix (from euler angles in openxr) NOT OMAF !

Definition at line 143 of file helpersSynthesis.cpp.

{
    // /!\ 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]);
}

quatToEuler()

glm::vec3 quatToEuler

(

glm::quat

q

)

Definition at line 495 of file VulkanHelperFunction.cpp.

                               {
    //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;
}

transitionImageLayout()

void transitionImageLayout	(	VulkanContext *	context,
		vk::CommandPool &	commandPool,
		vk::Image	image,
		vk::Format	format,
		vk::ImageLayout	oldLayout,
		vk::ImageLayout	newLayout
	)

Definition at line 139 of file VulkanHelperFunction.cpp.

{
    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);
}