VulkanWrapper Class Reference

Class that manages the classes related to Vulkan code and act as a wrapper around them. More...

#include <VulkanWrapper.h>

Public Types
using	RenderPassType = VulkanRenderpass

Public Member Functions
	VulkanWrapper (WindowAbstract *window, PipelineMode pmode)
void	init ()
void	endInit (InputProvider *input, StartingPosition startingPt=StartingPosition::Average)
void	start ()
void	cleanUp ()
void	recreateSwapChain ()
void	updateSpaceTransform (glm::vec3 translation, glm::vec3 rotation)
void	updateSpaceTransform (glm::vec3 translation, glm::vec3 rotation, glm::vec4 fov, int view)
void	waitIdle ()
void	createImageCall (uint32_t width, uint32_t height, vk::Format format, vk::ImageTiling tiling, vk::ImageUsageFlags usage, vk::MemoryPropertyFlags properties, vk::Image &image, vk::DeviceMemory &imageMemory)
void	createBufferCall (vk::DeviceSize size, vk::BufferUsageFlags usage, vk::MemoryPropertyFlags properties, vk::Buffer &buffer, vk::DeviceMemory &bufferMemory)
void	copyMemory (VkDeviceSize &size, vk::DeviceMemory &memory, unsigned char *dataToCopy)
void	destroyImageAndMemory (std::vector< vk::Image > &vectorImage, std::vector< vk::DeviceMemory > &vectorMemory)
void	destroyBufferAndMemory (std::vector< vk::Buffer > &vectorBuffer, std::vector< vk::DeviceMemory > &vectorMemory)
bool	isDepthOutputRecquired ()
void	setBlendingFactor (float blendingfactor)
void	setTriangleThreshold (float triangleThreshold)
bool	isUsingDifferentViewSize ()
VulkanContext *	getContext ()
vk::Extent2D	getSwapchainExtend (int view=0)
vk::Extent2D	getRenderOutputExtent ()
std::vector< vk::Format >	getRenderPassSupportedDepthFormats () const
vk::Format	getSwapchainFormat (int view=0)
vk::Format	getDepthSwapchainFormat (int view=0)
vk::ImageLayout	getLayoutAfterRenderpass ()
int	getAttachmentSize ()
int	getViewNumber ()
void	setAverageInputPosition (std::vector< InputProvider::StreamFrameInfo > &frameInfo)
void	addDeltaToStartingPoint (glm::vec3 dPos, glm::vec3 dRot)
void	setCorrectionRotation (int camId, glm::vec3 rotationCorrection)
void	setCorrectionTranslation (int camId, glm::vec3 translationCorrection)
void	setCorrectionFocal (int camId, glm::vec2 focals)
void	setCorrectionPrincipalPt (int camId, glm::vec2 principalPt)
void	setScaleFactor (float scaleFactor)
const std::vector< glm::vec3 >	getCorrectionVectorRotation ()
const std::vector< InputProvider::StreamFrameInfo >	getFramesInfo (int view)
void	saveConfigurationsToDisk ()
void	loadConfigurationsFromDisk ()
std::vector< bool >	getCameraActivation ()
void	toggleCamera (int i)
void	setCameraActivation (std::vector< bool > activation)

Data Fields
bool	framebufferResized = false
const vk::Format	internalColorAttachmentFormat = vk::Format::eR8G8B8A8Unorm
const vk::Format	internal1DAttachmentFormat = vk::Format::eR32Sfloat
const vk::Format	qualityAttachmentFormat = vk::Format::eR32Sfloat
const bool	multiviewSetup
bool	requireAverageInputPosition = true
VulkanContext	context
RenderingParameters	params

Detailed Description

Class that manages the classes related to Vulkan code and act as a wrapper around them.

Class that manages the classes related to Vulkan code and act as a wrapper around them. It manages the creation of the VulkanContext class, the RenderingParameter, the Vulkan RenderPass, ect ...

Definition at line 66 of file VulkanWrapper.h.

Member Typedef Documentation

RenderPassType

using VulkanWrapper::RenderPassType = VulkanRenderpass

Definition at line 216 of file VulkanWrapper.h.

Constructor & Destructor Documentation

VulkanWrapper()

VulkanWrapper::VulkanWrapper	(	WindowAbstract *	window,
		PipelineMode	pmode
	)

Create the VulkanWrapper object

Definition at line 43 of file VulkanWrapper.cpp.

                                                                       :
  context(window),
  renderPass([&]()->VulkanRenderPassAbstract*{
             switch (pmode) {
              default:
               return new VulkanRenderPass(&context, this);
             }
             }()),
  drawing(&context, renderPass.get(), window, this),
  multiviewSetup(window->useOpenXR())
{
    this->window = window;
    window->setWrapper(this);
    
}

Member Function Documentation

addDeltaToStartingPoint()

void VulkanWrapper::addDeltaToStartingPoint	(	glm::vec3	dPos,
		glm::vec3	dRot
	)

Add an offset to the stored by the virtual parameters

Definition at line 480 of file VulkanWrapper.cpp.

{
    auto R = glmEulerAnglesDegreeToRotationMatrixNotOMAF(params.getStartingRotation());
    auto dR = glmEulerAnglesDegreeToRotationMatrixNotOMAF(dRot);
 
    auto pos = params.getStartingPosition() + glm::transpose(R)* dPos;
    auto rot = glm::transpose(R) * dRot * R;
 
    params.setStartingPt(pos,rot);
 
 
}

cleanUp()

void VulkanWrapper::cleanUp

(

)

Start to cleanup ressources. The classes of the project have to be destroyed in a certain order

Definition at line 270 of file VulkanWrapper.cpp.

{
 
    if(drawing.isInitialized()) {
        drawing.cleanup();
    }
 
    //pipeline.cleanUp();
    if(renderPass->isInitialized()){
        renderPass->cleanUp();
    }
    /*
    if (!window->isSwapChainNeeded()) {
        static_cast<NoWindow*>(window)->cleanUpRessources();
    }*/
    window->cleanUp();
 
}

copyMemory()

void VulkanWrapper::copyMemory	(	VkDeviceSize &	size,
		vk::DeviceMemory &	memory,
		unsigned char *	dataToCopy
	)

Copy the data to the requested device memory location

Definition at line 328 of file VulkanWrapper.cpp.

{
    void* data;
    context.device.mapMemory(memory, 0, size, {}, &data);
    memcpy(dataToCopy, data, static_cast<size_t>(size));
    context.device.unmapMemory(memory);
}

createBufferCall()

void VulkanWrapper::createBufferCall	(	vk::DeviceSize	size,
		vk::BufferUsageFlags	usage,
		vk::MemoryPropertyFlags	properties,
		vk::Buffer &	buffer,
		vk::DeviceMemory &	bufferMemory
	)

Create a vk::Buffer with the requested characteristics

Definition at line 324 of file VulkanWrapper.cpp.

{
    createBuffer(size, usage, properties, buffer, bufferMemory, context.device, context.physicalDevice);
}

createImageCall()

void VulkanWrapper::createImageCall	(	uint32_t	width,
		uint32_t	height,
		vk::Format	format,
		vk::ImageTiling	tiling,
		vk::ImageUsageFlags	usage,
		vk::MemoryPropertyFlags	properties,
		vk::Image &	image,
		vk::DeviceMemory &	imageMemory
	)

Create a vk::Image with the requested characteristics

Definition at line 320 of file VulkanWrapper.cpp.

{
    createImage(context.device,context.physicalDevice,width,height,format,tiling,usage,properties,image,imageMemory);
}

destroyBufferAndMemory()

void VulkanWrapper::destroyBufferAndMemory	(	std::vector< vk::Buffer > &	vectorBuffer,
		std::vector< vk::DeviceMemory > &	vectorMemory
	)

Destroy the buffer and their associated buffer mamory

Definition at line 348 of file VulkanWrapper.cpp.

{
    //delete image
    for (auto const& buf : vectorBuffer) {
        context.device.destroyBuffer(buf);
    }
    //delete attachement memory
    for (auto const& mem : vectorMemory) {
        context.device.freeMemory(mem);
    }
}

destroyImageAndMemory()

void VulkanWrapper::destroyImageAndMemory	(	std::vector< vk::Image > &	vectorImage,
		std::vector< vk::DeviceMemory > &	vectorMemory
	)

Destroy the images and their associated memory

Definition at line 336 of file VulkanWrapper.cpp.

{
    //delete image
    for (auto const& image : vectorImage) {
        context.device.destroyImage(image);
    }
    //delete attachement memory
    for (auto const& mem : vectorMemory) {
        context.device.freeMemory(mem);
    }
}

endInit()

void VulkanWrapper::endInit	(	InputProvider *	input,
		StartingPosition	startingPt = StartingPosition::Average
	)

Continue the initialisation process once the InputProvider has been created.

Definition at line 98 of file VulkanWrapper.cpp.

                                                                                     {
    this->inputProvider = inputProvider;
    auto input = inputProvider->enumerateStreamsParameters();
    assert(input.size() >= 1);
 
    correctionVectorRotation.resize(input.size());
    correctionVectorTranslation.resize(input.size());
    correctionPrincipalPt.resize(input.size());
    correctionFocal.resize(input.size());
 
 
    streamFrameInfos.resize(input.size());
    cameraActivation.resize(input.size(),true);
 
    float maxD = input[0].farDepth;
    float minD = input[0].nearDepth;
    for (const auto & in : input) {
        maxD = in.farDepth > maxD ? in.farDepth : maxD;
        minD = in.nearDepth > minD ? in.nearDepth : minD;
    }
    params.max_depth = maxD;
    params.min_depth = minD;
    
    
    D(PRINT("=====renderpass======"));
    renderPass->init(inputProvider);
    D(PRINT("=====drawing======"));
    drawing.init(inputProvider);
    
    if (startingPt == StartingPosition::Average) {
        requireAverageInputPosition = true;
    }
    else {
        requireAverageInputPosition = false;
    }
}

getAttachmentSize()

int VulkanWrapper::getAttachmentSize

(

)

Get the number of attachment required by view by getting it from the window. Usually it's the size of the number of images in the swapchain. (or max of this if there is multiple swapchain)

Definition at line 447 of file VulkanWrapper.cpp.

{
    return window->getAttachmentSize();
}

getCameraActivation()

std::vector< bool > VulkanWrapper::getCameraActivation

(

)

Return which input cameras are activated

Definition at line 209 of file VulkanWrapper.cpp.

{
    return cameraActivation;
}

getContext()

VulkanContext * VulkanWrapper::getContext

(

)

Return the VulkanContext class

Definition at line 394 of file VulkanWrapper.cpp.

{
    return &context;
}

getCorrectionVectorRotation()

const std::vector< glm::vec3 > VulkanWrapper::getCorrectionVectorRotation

(

)

Return the vector related to rotation

Definition at line 539 of file VulkanWrapper.cpp.

{
    return correctionVectorRotation;
}

getDepthSwapchainFormat()

vk::Format VulkanWrapper::getDepthSwapchainFormat

(

int

view = 0

)

Return the format selected by the swapchain for depth

Definition at line 433 of file VulkanWrapper.cpp.

{
    return window->getDepthSwapchainFormat(view);
}

getFramesInfo()

const std::vector< InputProvider::StreamFrameInfo > VulkanWrapper::getFramesInfo

(

int

view

)

Retrieve the information from the InputProvider to render a new frame for the requested view

Definition at line 544 of file VulkanWrapper.cpp.

{
    if (requestChange) {
        context.device.waitIdle();
#ifdef HVT_UDP_CONTROL
        mutexAct.lock();
#endif
        drawing.cleanup();
        renderPass->cleanUp();
        renderPass->init(inputProvider);
        drawing.init(inputProvider);
        requestChange = false;
#ifdef HVT_UDP_CONTROL
        mutexAct.unlock();
#endif
    }
    inputProvider->acquireStreamsFrames(params.getVirtualExtrinsics(view), streamFrameInfos);
    if (requireAverageInputPosition) {
        setAverageInputPosition(streamFrameInfos);
    }
 
    assert(correctionVectorRotation.size() == streamFrameInfos.size());
 
    for (int i = 0; i < correctionVectorRotation.size(); i++) {
        streamFrameInfos[i].extrinsics.rotation += correctionVectorRotation[i];
        streamFrameInfos[i].extrinsics.position += correctionVectorTranslation[i];
 
        if (streamFrameInfos[i].intrinsics.index() == 0) {
            std::get<InputProvider::PerspectiveIntrinsics>(streamFrameInfos[i].intrinsics).focals += correctionFocal[i];
            std::get<InputProvider::PerspectiveIntrinsics>(streamFrameInfos[i].intrinsics).principle += correctionPrincipalPt[i];
        }
        
    }
 
    return streamFrameInfos;
}

getLayoutAfterRenderpass()

vk::ImageLayout VulkanWrapper::getLayoutAfterRenderpass

(

)

Return the image layout where the image should be at the end of the rendering operation. In the case of WindowGLFW, it will be vk::ImageLayout::ePresentSrcKHR When used with an headset, it will be vk::ImageLayout::eColorAttachmentOptimal

Definition at line 438 of file VulkanWrapper.cpp.

{
    auto res = vk::ImageLayout::eColorAttachmentOptimal;
    if (!window->useOpenXR() && !window->isIndepFromWindowDimension()) {
        res = vk::ImageLayout::ePresentSrcKHR;
    }
    return res;
}

getRenderOutputExtent()

vk::Extent2D VulkanWrapper::getRenderOutputExtent

(

)

Return the size of theresult of the rendering

Definition at line 404 of file VulkanWrapper.cpp.

{
    /*if (window->isIndepFromWindowDimension()) {
        //return VirtualView [0]
        auto size = app->getConfig().params_virtual[0].getSize();
        return vk::Extent2D(size.width,size.height);
    }
    else { */
        //return the size of the first swapchain
        //return window->swapChainExtent[0];
    //}
        vk::Extent2D max = {0,0};
        for (int i = 0; i < window->getViewNumber(); i++) {
            auto ext = window->getSwapchainExtent(i);
            if (max.width < ext.width) {
                max.width = ext.width;
            }
            if (max.height < ext.height) {
                max.height = ext.height;
            }
        }
        return max;
}

getRenderPassSupportedDepthFormats()

std::vector< vk::Format > VulkanWrapper::getRenderPassSupportedDepthFormats

(

)

const

return the list of the depth format supported for the selected renderpass

Definition at line 94 of file VulkanWrapper.cpp.

                                                                            {
  return renderPass->getSupportedDepthFormats();
}

getSwapchainExtend()

vk::Extent2D VulkanWrapper::getSwapchainExtend

(

int

view = 0

)

Return the size of the swapchain for the requested view

Definition at line 399 of file VulkanWrapper.cpp.

{
    return window->getSwapchainExtent(view);
}

getSwapchainFormat()

vk::Format VulkanWrapper::getSwapchainFormat

(

int

view = 0

)

Return the format selected by the swapchain

Definition at line 428 of file VulkanWrapper.cpp.

{
    return window->getSwapchainFormat(view);//window->swapChainImageFormat[view];
}

getViewNumber()

int VulkanWrapper::getViewNumber

(

)

Return the number of view required by the systems. Usually only one view when displayed on the screen, 2 for a stereographic headset and 4 if a certain openxr extension has been activated.

Definition at line 452 of file VulkanWrapper.cpp.

{
    return window->getViewNumber();
}

init()

void VulkanWrapper::init

(

)

Do the first step of the initialisation process of the VulkanWrapper. Start the initialization of the Window, Create the VulkanContext object, create the RenderingParameters class.

Definition at line 64 of file VulkanWrapper.cpp.

{
#endif
 
    window->initWindow();
#ifdef __ANDROID__
    ShadersList::getInstance().loadShaders(appAndroid);
#else
    ShadersList::getInstance().loadShaders();
#endif
    if (!context.isInitialized()) {
        D(PRINT("====context======="));
        context.initVulkan();
    }
    D(PRINT("===continue window initialisation==="));
    window->continueInit();
    //set the number of attachment to 
    attachmentSize = window->getAttachmentSize();
    int viewNum = window->getViewNumber();
 
#ifdef HVT_UDP_CONTROL
    params.init(viewNum, window, this, port);
    this->port = port;
#else
    params.init(viewNum, window, this);
#endif // DEBUG
 
    D(PRINT("Size of attachment = %d", attachmentSize));
}

isDepthOutputRecquired()

bool VulkanWrapper::isDepthOutputRecquired

(

)

Return true if the depth has to be given as a result of the rendering

Definition at line 360 of file VulkanWrapper.cpp.

{
    return window->isDepthRecquired();
}

isUsingDifferentViewSize()

bool VulkanWrapper::isUsingDifferentViewSize

(

)

Return true if view of different size are used

Definition at line 376 of file VulkanWrapper.cpp.

{
    assert(params.virtualViewDef.size()  > 0);
    if (params.virtualViewDef.size() == 1) {
        return false;
    }
    else {
        auto ref = params.virtualViewDef[0];
        for (auto & v : params.virtualViewDef) {
            if (v[0] != ref[0] || v[1] != ref[1]) {
                return true;
            }
        }
        return false;
    }
    
}

loadConfigurationsFromDisk()

void VulkanWrapper::loadConfigurationsFromDisk

(

)

Load the corrections to be applied on input from a json file

Definition at line 182 of file VulkanWrapper.cpp.

{
    
    std::ifstream stream(fileN, std::ifstream::out);
 
    json j;
    std::cout << "load correction of rotation to disk at " << fileN << std::endl;
    if (stream.is_open()) {
        j << stream;
 
        for (auto& cam : j["camera"]) {
            int id = cam["id"];
            auto r = j["camera"][id]["correction"]["rotation"];
            correctionVectorRotation[id] = { r[0],r[1],r[2] };
            auto t = j["camera"][id]["correction"]["translation"];
            correctionVectorTranslation[id] = { t[0],t[1],t[2] };
            auto p = j["camera"][id]["correction"]["principalPt"];
            correctionPrincipalPt[id] = { p[0],p[1] };
            auto f = j["camera"][id]["correction"]["focal"];
            correctionFocal[id] = { f[0],f[1] };
        }
    }
    else {
        std::cout << "No save file found" << std::endl;
    }
}

recreateSwapChain()

void VulkanWrapper::recreateSwapChain

(

)

This function is called when the swapchain has to be recreated (mainly when the window size change)

Definition at line 289 of file VulkanWrapper.cpp.

{
#ifdef __ANDROID__
    LOGI("recreate swapchain");
#else
    std::cout << ("recreation swapchain !") << std::endl;
#endif
    window->checkForCorrectSize();
    //could be better TODO -> https://vulkan-tutorial.com/Drawing_a_triangle/Swap_chain_recreation
    context.device.waitIdle();
    //cleanUp
    cleanUp();
    //init
#ifdef HVT_UDP_CONTROL
    init(port);
#else
    init();
#endif
 
}

saveConfigurationsToDisk()

void VulkanWrapper::saveConfigurationsToDisk

(

)

Save the corrections to be applied on input in a json file

Definition at line 136 of file VulkanWrapper.cpp.

{
    
    std::cout << "Save correction of rotation to disk at " << fileN << std::endl;
    std::ofstream stream(fileN, std::ifstream::out);
 
    assert(correctionVectorRotation.size() == correctionVectorTranslation.size());
    assert(correctionVectorTranslation.size() == correctionPrincipalPt.size());
    assert(correctionPrincipalPt.size() == correctionFocal.size());
 
    
    json j;
    for (int id = 0; id < correctionVectorRotation.size(); id ++ ) {
        //j["camera"][id] = json::array();
        j["camera"][id]["id"] = id;
        
        //j["camera"][id]["correction"] = json::object();
        auto r = correctionVectorRotation[id];
        j["camera"][id]["correction"]["rotation"] = { r.x,r.y,r.z };
        auto t = correctionVectorTranslation[id];
        j["camera"][id]["correction"]["translation"] = {t.x,t.y,t.z};
        auto p = correctionPrincipalPt[id];
        j["camera"][id]["correction"]["principalPt"] = json::array({p.x,p.y});
        auto f = correctionFocal[id];
        j["camera"][id]["correction"]["focal"] = json::array({f.x,f.y});
 
        //j["camera"][id]["current"] = json::array();
        auto ro = streamFrameInfos[id].extrinsics.rotation;
        j["camera"][id]["current"]["rotation"] = {ro.x,ro.y,ro.z};
        auto to = streamFrameInfos[id].extrinsics.position;
        j["camera"][id]["current"]["translation"] = { to.x,to.y,to.z };
 
        //-------- TODO case with equirectangular 
        if (streamFrameInfos[id].intrinsics.index() == 0) {
            auto po = std::get<InputProvider::PerspectiveIntrinsics>(streamFrameInfos[id].intrinsics).principle;
            j["camera"][id]["current"]["principalPt"] = json::array({ po.x,po.y });
            auto fo = std::get<InputProvider::PerspectiveIntrinsics>(streamFrameInfos[id].intrinsics).focals;
            j["camera"][id]["current"]["focal"] = json::array({ fo.x,fo.y });
        }
 
    }
    stream << j.dump(4);
 
    stream.close();
}

setAverageInputPosition()

void VulkanWrapper::setAverageInputPosition

(

std::vector< InputProvider::StreamFrameInfo > &

frameInfo

)

Calculate the position at the middle of the input camera array

Definition at line 457 of file VulkanWrapper.cpp.

{
    glm::vec3 averagePos = {0,0,0};
    glm::vec3 averageRot = {0,0,0};
    const int numInput = frameInfo.size();
 
    for (auto f : frameInfo) {
        averagePos += f.extrinsics.position;
        //averageRot += f.extrinsics.rotation;
    }
    averagePos /= numInput;
    //averageRot /= numInput;
 
    //convert from OMAF to the coordinate system used by virtual parameters
    auto conversion = glm::transpose(params.conversionToOMAF);
    auto pos  =  conversion * averagePos;
 
    params.setStartingPt(pos, averageRot);
    //params.startingRotation = conversion * averageRot * glm::transpose(conversion) ;
 
    requireAverageInputPosition = false;
}

setBlendingFactor()

void VulkanWrapper::setBlendingFactor

(

float

blendingfactor

)

Set the blending factor for RVS

Definition at line 365 of file VulkanWrapper.cpp.

{
    params.blendingFactor = blendingfactor;
}

setCameraActivation()

void VulkanWrapper::setCameraActivation

(

std::vector< bool >

activation

)

Set which camera are activated

Definition at line 238 of file VulkanWrapper.cpp.

{
    
    assert(activation.size() == cameraActivation.size());
 
    bool valid = false;
    for (auto a : activation) {
        valid += a;
    }
 
    if (valid) {
#ifdef HVT_UDP_CONTROL
        mutexAct.lock();
#endif
        requestChange = true;
        cameraActivation = activation;
#ifdef HVT_UDP_CONTROL
        mutexAct.unlock();
#endif
    }
    else {
        PRINT("Invalid activation vector. At least one camera should be activated");
    }
}

setCorrectionFocal()

void VulkanWrapper::setCorrectionFocal	(	int	camId,
		glm::vec2	focals
	)

Store an offset to be applied on the focal of one of the input camera

Definition at line 513 of file VulkanWrapper.cpp.

{
    if (camId < correctionFocal.size()) {
        correctionFocal[camId] += focals;
    }
    else {
        PRINT("Camera %i does not exist, only %i camera are availables", camId, (int)correctionFocal.size());
    }
}

setCorrectionPrincipalPt()

void VulkanWrapper::setCorrectionPrincipalPt	(	int	camId,
		glm::vec2	principalPt
	)

Store an offset to be applied on the principal point of one of the input camera

Definition at line 523 of file VulkanWrapper.cpp.

{
    if (camId < correctionFocal.size()) {
        correctionPrincipalPt[camId] += principalPt;
    }
    else {
        PRINT("Camera %i does not exist, only %i camera are availables", camId, (int)correctionPrincipalPt.size());
    }
}

setCorrectionRotation()

void VulkanWrapper::setCorrectionRotation	(	int	camId,
		glm::vec3	rotationCorrection
	)

Store an offset to be applied on the rotation of one of the input camera

Definition at line 493 of file VulkanWrapper.cpp.

{
    if (camId < correctionVectorRotation.size()) {
        correctionVectorRotation[camId] += rotationCorrection;
    }
    else {
        PRINT("Camera %i does not exist, only %i camera are availables", camId, (int) correctionVectorRotation.size());
    }
}

setCorrectionTranslation()

void VulkanWrapper::setCorrectionTranslation	(	int	camId,
		glm::vec3	translationCorrection
	)

Store an offset to be applied on the translation of one of the input camera

Definition at line 503 of file VulkanWrapper.cpp.

{
    if (camId < correctionVectorTranslation.size()) {
        correctionVectorTranslation[camId] += translationCorrection;
    }
    else {
        PRINT("Camera %i does not exist, only %i camera are availables", camId, (int)correctionVectorTranslation.size());
    }
}

setScaleFactor()

void VulkanWrapper::setScaleFactor

(

float

scaleFactor

)

Set the scene at a certain scale

Definition at line 533 of file VulkanWrapper.cpp.

{
    assert(scaleFactor > 0);
    params.scaleFactor = scaleFactor;
}

setTriangleThreshold()

void VulkanWrapper::setTriangleThreshold

(

float

triangleThreshold

)

Set the triangle threshold

Definition at line 370 of file VulkanWrapper.cpp.

{
    assert(triangleThreshold > 0);
    params.pixelThreshold = triangleThreshold;
}

start()

void VulkanWrapper::start

(

)

Call the mainloop function that is part of the WindowAbstract class

Definition at line 263 of file VulkanWrapper.cpp.

{
 
    window->mainLoop(&drawing);
    context.device.waitIdle();
}

toggleCamera()

void VulkanWrapper::toggleCamera

(

int

i

)

Activate/desactivate the specified input camera

Definition at line 214 of file VulkanWrapper.cpp.

{
    
    assert( i < cameraActivation.size() );
 
    if (!cameraActivation[i] || renderPass->inputImage > 1 ) {
#ifdef HVT_UDP_CONTROL
 
        mutexAct.lock();
#endif // HVT_UDP_CONTROL
 
        requestChange = true;
        cameraActivation[i] = !cameraActivation[i];
#ifdef HVT_UDP_CONTROL
        mutexAct.unlock();
#endif
    }
    else {
        //we don't need to desactivate all the camera
        //always let one activated
        std::cout << "Impossible to desactivate camera " << i << " :there must always be one camera active" << std::endl;
    }
}

updateSpaceTransform() [1/2]

void VulkanWrapper::updateSpaceTransform	(	glm::vec3	translation,
		glm::vec3	rotation
	)

Update the translation and rotation of the virtual view

Definition at line 310 of file VulkanWrapper.cpp.

{
 
    params.updateSpaceTransform(translation,rotation);
 
}

updateSpaceTransform() [2/2]

void VulkanWrapper::updateSpaceTransform	(	glm::vec3	translation,
		glm::vec3	rotation,
		glm::vec4	fov,
		int	view
	)

Update the translation, rotation as well as the field of view of the specified virtual view

Definition at line 603 of file VulkanWrapper.cpp.

                                                                                                     {
 
    params.updateSpaceTransform(translation, rotation, fov, view);
}

waitIdle()

void VulkanWrapper::waitIdle

(

)

Wait for the device to be idle

Definition at line 317 of file VulkanWrapper.cpp.

                             {
    context.device.waitIdle();
}

Field Documentation

context

VulkanContext VulkanWrapper::context

Reference to the class that manges object and info related to vulkan context

Definition at line 194 of file VulkanWrapper.h.

framebufferResized

bool VulkanWrapper::framebufferResized = false

Put the true if the framebuffer was resized

Definition at line 177 of file VulkanWrapper.h.

internal1DAttachmentFormat

const vk::Format VulkanWrapper::internal1DAttachmentFormat = vk::Format::eR32Sfloat

Format for the attachment in 1D used internally (usually for the pseudo depth attachment)

Definition at line 182 of file VulkanWrapper.h.

internalColorAttachmentFormat

const vk::Format VulkanWrapper::internalColorAttachmentFormat = vk::Format::eR8G8B8A8Unorm

Format for the attachment in color used internally

Definition at line 180 of file VulkanWrapper.h.

multiviewSetup

const bool VulkanWrapper::multiviewSetup

Usually at true when openxr is used

Definition at line 189 of file VulkanWrapper.h.

params

RenderingParameters VulkanWrapper::params

Refrence to the class that manage the virtual parameters

Definition at line 197 of file VulkanWrapper.h.

qualityAttachmentFormat

const vk::Format VulkanWrapper::qualityAttachmentFormat = vk::Format::eR32Sfloat

Format for the quality attachment in color used internally

Definition at line 184 of file VulkanWrapper.h.

requireAverageInputPosition

bool VulkanWrapper::requireAverageInputPosition = true

true if the avarage position has to be calculated

Definition at line 191 of file VulkanWrapper.h.

---

The documentation for this class was generated from the following files:

• VulkanWrapper.h
• VulkanWrapper.cpp