struct mrpt::opengl::TRenderMatrices

Overview

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 v_matrix_no_translation;
    mrpt::math::CMatrixFloat44 pmv_matrix;
    mrpt::math::CMatrixFloat44 mv_matrix;
    mrpt::math::CMatrixFloat44 light_pv;
    mrpt::math::CMatrixFloat44 light_p;
    mrpt::math::CMatrixFloat44 light_v;
    mrpt::math::CMatrixFloat44 light_pmv;
    bool is1stShadowMapPass = false;
    std::optional<mrpt::img::TCamera> pinhole_model;
    double FOV = 30.0f;
    double azimuth = .0;
    double elev = .0;
    double roll = .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 computeLightProjectionMatrix(float zmin, float zmax, const TLightParameters& lp);
    void computeOrthoProjectionMatrix(float left, float right, float bottom, float top, float znear, float zfar);
    void computeNoProjectionMatrix(float znear, float zfar);
    void computeViewMatrix();

    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;
    float getLastLightClipZNear() const;
    float getLastLightClipZFar() const;
    void saveToYaml(mrpt::containers::yaml& c) const;
    void print(std::ostream& o) const;

    static mrpt::math::CMatrixFloat44 OrthoProjectionMatrix(
        float left,
        float right,
        float bottom,
        float top,
        float znear,
        float zfar
        );

    static mrpt::math::CMatrixFloat44 LookAt(
        const mrpt::math::TVector3D& lookFrom,
        const mrpt::math::TVector3D& lookAt,
        const mrpt::math::TVector3D& up,
        mrpt::math::CMatrixFloat44* viewWithoutTranslation = nullptr
        );
};

Fields

mrpt::math::CMatrixFloat44 p_matrix

Projection matrix, computed by Viewport from camera parameters.

mrpt::math::CMatrixFloat44 m_matrix

Model matrix.

mrpt::math::CMatrixFloat44 v_matrix

View matrix.

mrpt::math::CMatrixFloat44 v_matrix_no_translation

View matrix with null translation.

mrpt::math::CMatrixFloat44 pmv_matrix

Result of p_matrix * mv_matrix (=P*V*M).

Used in shaders. Updated by Viewport::updateMatricesFromCamera()

mrpt::math::CMatrixFloat44 mv_matrix

Result of v_matrix * m_matrix.

Used in shaders. Updated by Viewport::updateMatricesFromCamera()

mrpt::math::CMatrixFloat44 light_pv

Result of p_matrix * v_matrix (=P*V) for the directional light point-of-view.

Used in shadow-generation shaders. Updated by Viewport::updateMatricesFromCamera()

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 Viewport::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 computeLightProjectionMatrix(float zmin, float zmax, const TLightParameters& lp)

Updates light_pv.

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

Especial case for custom parameters of Orthographic projection.

Equivalent to p_matrix = ortho(...);.

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 computeViewMatrix()

Updates v_matrix (and v_matrix_no_translation) using the current camera position and pointing-to coordinates.

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.

static mrpt::math::CMatrixFloat44 OrthoProjectionMatrix(
    float left,
    float right,
    float bottom,
    float top,
    float znear,
    float zfar
    )

Computes and returns an orthographic projection matrix.

Equivalent to obsolete glOrtho() or glm::ortho().

static mrpt::math::CMatrixFloat44 LookAt(
    const mrpt::math::TVector3D& lookFrom,
    const mrpt::math::TVector3D& lookAt,
    const mrpt::math::TVector3D& up,
    mrpt::math::CMatrixFloat44* viewWithoutTranslation = nullptr
    )

Computes the view matrix from a “forward” and an “up” vector.

Equivalent to obsolete gluLookAt() or glm::lookAt().