HoviTron Video Pipeline: RenderingParameters Class Reference

Class that encapsulates the rendering parameters (RVS internal parameters + virtual camera parameters). More...

#include <RenderingParameters.h>

Public Member Functions
void	init (int view, WindowAbstract window, VulkanWrapper wraps)

	~RenderingParameters ()

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

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

const InputProvider::Extrinsics	getVirtualExtrinsics (int view)

const InputProvider::Intrinsics	getVirtualIntrinsics (int view)

void	setStartingPt (glm::vec3 startPos, glm::vec3 startRot)

const glm::vec3	getStartingPosition ()

const glm::vec3	getStartingRotation ()

Data Fields
float	blendingFactor = 5.0

float	pixelThreshold = 30

const glm::mat3x3	conversionToOMAF = { 0,-1,0, 0,0,1, -1,0,0 }

float	maxMult = 10

float	scaleFactor = 1.0

std::vector< glm::vec2 >	virtualViewDef

InputProvider::ProjectionType	projectionType = InputProvider::ProjectionType::PROJECTION_INVALID

float	max_depth = 0.0

float	min_depth = FLT_MAX

float	farPlaneHeadset = 10

float	nearPlaneHeadset = 0.1

Detailed Description

Class that encapsulates the rendering parameters (RVS internal parameters + virtual camera parameters).

Class that encapsulates the rendering parameters (RVS internal parameters + virtual camera parameters). If the HVT_UDP_CONTROL macro is used, a UDP server is created on a new thread. This allow some parameters to be modified using UDP messages.

Definition at line 108 of file RenderingParameters.h.

Constructor & Destructor Documentation

◆ ~RenderingParameters()

RenderingParameters::~RenderingParameters ( )

Clean up the ressources

Definition at line 58 of file RenderingParameters.cpp.

{
#ifdef HVT_UDP_CONTROL
    serverIsActive = false;
    serverThread.join();
#endif
}

Member Function Documentation

◆ getStartingPosition()

const glm::vec3 RenderingParameters::getStartingPosition ( )

Return starting position

Definition at line 160 of file RenderingParameters.cpp.

{
#ifdef HVT_UDP_CONTROL
    startPosMut.lock();
#endif
    const glm::vec3 res = glm::vec3(startingPosition);
#ifdef HVT_UDP_CONTROL
    startPosMut.unlock();
#endif
    return res;
}

◆ getStartingRotation()

const glm::vec3 RenderingParameters::getStartingRotation ( )

Return starting rotation

Definition at line 172 of file RenderingParameters.cpp.

{
#ifdef HVT_UDP_CONTROL
    startPosMut.lock();
#endif
    const glm::vec3 res = glm::vec3(startingRotation);
#ifdef HVT_UDP_CONTROL
    startPosMut.unlock();
#endif
    return res;
}

◆ getVirtualExtrinsics()

const InputProvider::Extrinsics RenderingParameters::getVirtualExtrinsics ( int view )

Return the extrinsics for the requested view

Definition at line 103 of file RenderingParameters.cpp.

{
    InputProvider::Extrinsics pose = { .position = {0,0,0}, .rotation = {0,0,0} };
 
    //TODO move that at a better place
    glm::vec3 averagePos = { 0,0,0 };
    for (int i = 0; i < virtualExtrinsics.size(); i++) {
        averagePos += virtualExtrinsics[i].position;
    }
    averagePos /= virtualExtrinsics.size();
 
    if (virtualMode == VirtualMode::Static1) {
#ifdef HVT_UDP_CONTROL
        mutex.lock();
#endif
        pose.position = staticPosition[0] + (virtualExtrinsics[view].position - averagePos );
        pose.rotation = quatToEuler(staticQuaternion[0]);
#ifdef HVT_UDP_CONTROL
        mutex.unlock();
#endif
        //pose.rotation = static[0];
    }
    else if (virtualMode == VirtualMode::Static2) {
#ifdef HVT_UDP_CONTROL
        mutex.lock();
#endif
        pose.position = staticPosition[1] + (virtualExtrinsics[view].position - averagePos );
        pose.rotation = quatToEuler(staticQuaternion[1]);
#ifdef HVT_UDP_CONTROL
        mutex.unlock();
#endif
    }
    else {
        assert(virtualExtrinsics.size() > view);
        pose = virtualExtrinsics[view];
    }
    return pose;
}

◆ getVirtualIntrinsics()

const InputProvider::Intrinsics RenderingParameters::getVirtualIntrinsics ( int view )

Return the intrinsics for the requested view

Definition at line 142 of file RenderingParameters.cpp.

{
    assert(virtualIntrasics.size() > view);
    return virtualIntrasics[view];
}

◆ init()

void RenderingParameters::init	(	int	view,
		WindowAbstract *	window,
		VulkanWrapper *	wraps
	)

Init the parameters

Definition at line 27 of file RenderingParameters.cpp.

{
#endif
    window = wind;
    wrapper = wraps;
 
    virtualExtrinsics.resize(viewNum);
    virtualIntrasics.resize(viewNum);
    virtualViewDef.resize(viewNum);
 
    staticPosition.resize(staticPoses);
    staticQuaternion.resize(staticPoses);
 
    for (int i = 0; i < viewNum; i++) {
        auto ext = window->getSwapchainExtent(i);
        virtualViewDef[i] = glm::vec2(ext.width, ext.height);
        virtualExtrinsics[i].position = glm::vec3(0, 0, 0);
        virtualExtrinsics[i].rotation = glm::vec3(0, 0, 0);
        projectionType = InputProvider::ProjectionType::PROJECTION_PERSPECTIVE;
        auto intra = InputProvider::PerspectiveIntrinsics();
        virtualIntrasics[i] = intra;
        std::get<InputProvider::PerspectiveIntrinsics>(virtualIntrasics[i]).principle = glm::vec2(ext.width, ext.height) / 2.0f;
        std::get<InputProvider::PerspectiveIntrinsics>(virtualIntrasics[i]).focals = glm::vec2(ext.width, ext.width) / 2.0f;
        virtualIntrasics.push_back(intra);
    }
#ifdef HVT_UDP_CONTROL
    setupUDPServer();
#endif // HVT_UDP_CONTROL
 
}

◆ setStartingPt()

void RenderingParameters::setStartingPt	(	glm::vec3	startPos,
		glm::vec3	startRot
	)

Set an offset to the system

Definition at line 148 of file RenderingParameters.cpp.

{
#ifdef HVT_UDP_CONTROL
    startPosMut.lock();
#endif
    startingPosition = startPos;
    startingRotation = startRot;
#ifdef HVT_UDP_CONTROL
    startPosMut.unlock();
#endif
}

◆ updateSpaceTransform() [1/2]

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

Update the extrinsics for the virtual camera

Definition at line 66 of file RenderingParameters.cpp.

{
    for (int i = 0; i < virtualExtrinsics.size(); i++) {
        virtualExtrinsics[i].position = translation;//glm::vec3(translation[0], translation[1], translation[2]);
        virtualExtrinsics[i].rotation = rotation;//glm::vec3(rotation[0], rotation[1], rotation[2]);
    }
}

◆ updateSpaceTransform() [2/2]

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

Update the extrinsics (translation and rotation) and the intrasics ( focals and principle point and using info in fov) for the virtual camera corresponding to the view

Definition at line 74 of file RenderingParameters.cpp.

{
    virtualExtrinsics[view].position = translation;// glm::vec3(translation[0], translation[1], translation[2]);
    virtualExtrinsics[view].rotation = rotation;//glm::vec3(rotation[0], rotation[1], rotation[2]);
 
    auto tl = std::tan(fov[0]); //left
    auto tr = std::tan(fov[1]); //right
    auto tt = std::tan(fov[2]); //top
    auto tb = std::tan(fov[3]); //down
 
    auto tw = tr - tl;
    auto th = tt - tb;
 
    auto x0 = (-tl) / tw;
    auto y0 = (-tb) / th;
 
    if (projectionType == InputProvider::ProjectionType::PROJECTION_PERSPECTIVE) {
        std::get<InputProvider::PerspectiveIntrinsics>(virtualIntrasics[view]).focals.x = virtualViewDef[view].x / tw;
        std::get<InputProvider::PerspectiveIntrinsics>(virtualIntrasics[view]).focals.y = virtualViewDef[view].y / th;
 
 
        std::get<InputProvider::PerspectiveIntrinsics>(virtualIntrasics[view]).principle.x = x0 * virtualViewDef[view].x;
        std::get<InputProvider::PerspectiveIntrinsics>(virtualIntrasics[view]).principle.y = (1 - y0) * virtualViewDef[view].y;
    }
    else {
        throw std::runtime_error("Unsupported projection type for virtual parameter"); //TODO support this (Should not be complicated since fov are already the angle that we need for ver_range and hor_range)
    }
}

Field Documentation

◆ blendingFactor

float RenderingParameters::blendingFactor = 5.0

Blending factor

Definition at line 122 of file RenderingParameters.h.

◆ conversionToOMAF

const glm::mat3x3 RenderingParameters::conversionToOMAF = { 0,-1,0, 0,0,1, -1,0,0 }

Matrix to convert from OpenXR to OMAF

Definition at line 126 of file RenderingParameters.h.

◆ farPlaneHeadset

float RenderingParameters::farPlaneHeadset = 10

far plane for the headset

Definition at line 150 of file RenderingParameters.h.

◆ max_depth

float RenderingParameters::max_depth = 0.0

max depthand min depth for depth extension

Definition at line 145 of file RenderingParameters.h.

◆ maxMult

float RenderingParameters::maxMult = 10

Factor to multiply the depth to avoid problem when virtual camera is to far from the camera array

Definition at line 129 of file RenderingParameters.h.

◆ min_depth

float RenderingParameters::min_depth = FLT_MAX

min depth for depth extension

Definition at line 147 of file RenderingParameters.h.

◆ nearPlaneHeadset

float RenderingParameters::nearPlaneHeadset = 0.1

near plane for the headset

Definition at line 152 of file RenderingParameters.h.

◆ pixelThreshold

float RenderingParameters::pixelThreshold = 30

Pixel threshold

Definition at line 124 of file RenderingParameters.h.

◆ projectionType

InputProvider::ProjectionType RenderingParameters::projectionType = InputProvider::ProjectionType::PROJECTION_INVALID

Define the projection type for the virtual view

Definition at line 142 of file RenderingParameters.h.

◆ scaleFactor

float RenderingParameters::scaleFactor = 1.0

Factor to scale the scene (don't use when depth is needed)

Definition at line 131 of file RenderingParameters.h.

◆ virtualViewDef

std::vector<glm::vec2> RenderingParameters::virtualViewDef

Definition of the virtual view that should be rendered

Definition at line 140 of file RenderingParameters.h.

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

Public Member Functions

Data Fields