struct mrpt::opengl::TRenderMatrices

Rendering state related to the projection and model-view matrices.

Used to store matrices that will be sent to shaders.

The homogeneous coordinates of a rendered point comes from the product (from right to left) of MODEL, VIEW and PROJECTION matrices:

p = p_matrix * v_matrix * m_matrix * [x y z 1.0]’

#include <mrpt/opengl/TRenderMatrices.h>

struct TRenderMatrices
{
    //
fields

    mrpt::math::CMatrixFloat44 p_matrix;
    mrpt::math::CMatrixFloat44 m_matrix;
    mrpt::math::CMatrixFloat44 v_matrix;
    mrpt::math::CMatrixFloat44 pmv_matrix;
    mrpt::math::CMatrixFloat44 mv_matrix;
    std::optional<mrpt::img::TCamera> pinhole_model;
    double FOV = 30.0f;
    double azimuth = .0;
    double elev = .0;
    double eyeDistance = 1.0f;
    uint32_t viewport_width = 640;
    uint32_t viewport_height = 480;
    bool initialized = false;
    bool is_projective = true;
    mrpt::math::TPoint3D eye = {0, 0, 0};
    mrpt::math::TPoint3D pointing = {0, 0, 0};
    mrpt::math::TPoint3D up = {0, 0, 0};

    // construction

    TRenderMatrices();

    //
methods

    void matricesSetIdentity();
    void computeProjectionMatrix(float zmin, float zmax);
    void computeOrthoProjectionMatrix(float left, float right, float bottom, float top, float znear, float zfar);
    void computeNoProjectionMatrix(float znear, float zfar);
    void applyLookAt();

    void projectPoint(
        float x,
        float y,
        float z,
        float& proj_u,
        float& proj_v,
        float& proj_z_depth
        ) const;

    void projectPointPixels(
        float x,
        float y,
        float z,
        float& proj_u_px,
        float& proj_v_px,
        float& proj_depth
        ) const;

    float getLastClipZNear() const;
    float getLastClipZFar() const;
    void saveToYaml(mrpt::containers::yaml& c) const;
    void print(std::ostream& o) const;
};

Fields

mrpt::math::CMatrixFloat44 p_matrix

Projection matrix, computed by renderNormalScene() from all the parameters above.

Used in shaders.

mrpt::math::CMatrixFloat44 m_matrix

Model matrix.

mrpt::math::CMatrixFloat44 v_matrix

View matrix.

mrpt::math::CMatrixFloat44 pmv_matrix

Result of p_matrix * mv_matrix.

Used in shaders. Updated by renderSetOfObjects()

mrpt::math::CMatrixFloat44 mv_matrix

Result of v_matrix * m_matrix.

Used in shaders. Updated by renderSetOfObjects()

std::optional<mrpt::img::TCamera> pinhole_model

Use the intrinsics (cx,cy,fx,fy) from this model instead of FOV, if defined.

double FOV = 30.0f

Vertical FOV in degrees, used only if pinhole_model is not set.

double azimuth = .0

Camera elev & azimuth, in radians.

uint32_t viewport_width = 640

In pixels.

This may be smaller than the total render window.

bool initialized = false

Is set to true by COpenGLViewport::updateMatricesFromCamera()

bool is_projective = true

true: projective, false: ortho

mrpt::math::TPoint3D eye = {0, 0, 0}

The camera is here.

mrpt::math::TPoint3D pointing = {0, 0, 0}

The camera points to here.

mrpt::math::TPoint3D up = {0, 0, 0}

Up vector of the camera.

Methods

void computeProjectionMatrix(float zmin, float zmax)

Uses is_projective , vw,vh, etc.

and computes p_matrix from either:

• pinhole_model if set, or

• FOV, otherwise. Replacement for obsolete: gluPerspective() and glOrtho()

void computeOrthoProjectionMatrix(
    float left,
    float right,
    float bottom,
    float top,
    float znear,
    float zfar
    )

Especial case for custom parameters of Orthographic projection.

Replacement for obsolete: glOrtho()

void computeNoProjectionMatrix(float znear, float zfar)

Especial case: no projection, opengl coordinates are pixels from (0,0) bottom-left corner.

void applyLookAt()

Updates the current p_matrix such that it “looks at” pointing, with up vector “up”.

Replacement for deprecated OpenGL gluLookAt().

void projectPoint(
    float x,
    float y,
    float z,
    float& proj_u,
    float& proj_v,
    float& proj_z_depth
    ) const

Computes the normalized coordinates (range=[0,1]) on the current rendering viewport of a point with local coordinates (wrt to the current model matrix) of (x,y,z).

The output proj_z_depth is the real distance from the eye to the point.

void projectPointPixels(
    float x,
    float y,
    float z,
    float& proj_u_px,
    float& proj_v_px,
    float& proj_depth
    ) const

Projects a point from global world coordinates into (u,v) pixel coordinates.