Glm :: Perspektive Erklärung

Ich versuche zu verstehen, was der folgende code macht:

glm::mat4 Projection = glm::perspective(35.0f, 1.0f, 0.1f, 100.0f);

Schafft es ein Projektions-matrix? Clips aus alles, was nicht in der Ansicht des Benutzers?
Ich war nicht in der Lage, alles zu finden auf der API-Seite, und das einzige, was ich finden konnte in der pdf auf Ihrer website:

gluPerspective:

glm::mat4 perspective(float fovy, float aspect, float zNear,
float zFar);
glm::dmat4 perspective(
double fovy, double aspect, double zNear,
double zFar);
From GLM_GTC_matrix_transform extension: <glm/gtc/matrix_transform.hpp>

Aber es erklärt nicht die Parameter. Vielleicht habe ich etwas verpasst.

InformationsquelleAutor der Frage Trt Trt | 2011-11-13

  1. 21

    Es erzeugt eine Projektions-matrix, d.h. die matrix, die beschreibt, den Satz von linearen Gleichungen, Transformationen von Vektoren aus dem Auge Raum in clip-space. Matrizen sind wirklich keine schwarze Magie. Im Fall von OpenGL, die Sie passieren, um ein 4-by-4-Anordnung von zahlen:

    X_x Y_x Z_x T_x
X_y Y_y Z_y T_y
X_z Y_z Z_z T_z
X_w Y_w Z_w W_w

    Können Sie multply ein 4-Vektor durch eine 4×4 matrix:

    v' = M * v

v'_x = M_xx * v_x + M_yx * v_y + M_zx * v_z + M_tx * v_w
v'_y = M_xy * v_x + M_yy * v_y + M_zy * v_z + M_ty * v_w
v'_z = M_xz * v_x + M_yz * v_y + M_zz * v_z + M_tz * v_w
v'_w = M_xw * v_x + M_yw * v_y + M_zw * v_z + M_tw * v_w

    Nach erreichen der clip-space (d.h. nach der Projektion Schritt), die primitive sind abgeschnitten. Die Eckpunkte, die aus der Beschneidung sind dann in der Perspektive teilen, d.h.

    v'_x = v_x /v_w
v'_y = v_y /v_w
v'_z = v_z /v_w
( v_w = 1 = v_w /v_w )

    Und das ist es. Es gibt wirklich nichts mehr Los, in alle diese Transformations-Schritte als normale matrix-Vektor-Multiplikation.

    Nun die kühle Sache über dieses ist, dass die Matrizen können verwendet werden, um zu beschreiben, die die relative Ausrichtung eines Koordinatensystems in ein anderes Koordinatensystem. Was die Perspektive der Transformation wird ist, dass Sie lassen Sie uns die Eckpunkte z-Werte "schlüpfen" in Ihre projizierten w-Werte. Und durch die Perspektive teilen eine nicht-Einheit w führen wird "Verzerrung" der vertex-Koordinaten. Eckpunkte mit kleinen z aufgeteilt werden durch ein kleines B, also Ihre Koordinaten "blow" up", während die Knoten mit großen z "gequetscht" werden, das ist, was verursacht die perspektivische Wirkung.

    InformationsquelleAutor der Antwort datenwolf

  2. -1

    Dies ist eine c-standalone-version der gleichen Funktion. Das ist in etwa eine Kopie paste-version von das original.

    # include <math.h>
# include <stdlib.h>
# include <string.h>

typedef struct s_mat {
    float *array;
    int width;
    int height;
} t_mat;

t_mat *mat_new(int width, int height)
{
    t_mat *to_return;

    to_return = (t_mat*)malloc(sizeof(t_mat));
    to_return->array = malloc(width * height * sizeof(float));
    to_return->width = width;
    to_return->height = height;
    return (to_return);
}

void mat_zero(t_mat *dest)
{
    bzero(dest->array, dest->width * dest->height * sizeof(float));
}

void mat_set(t_mat *m, int x, int y, float val)
{
    if (m == NULL || x > m->width || y > m->height)
        return ;
    m->array[m->width * (y - 1) + (x - 1)] = val;
}

t_mat *mat_perspective(float angle, float ratio,
        float near, float far)
{
    t_mat *to_return;
    float tan_half_angle;

    to_return = mat_new(4, 4);
    mat_zero(to_return);
    tan_half_angle = tan(angle /2);
    mat_set(to_return, 1, 1, 1 /(ratio * tan_half_angle));
    mat_set(to_return, 2, 2, 1 /(tan_half_angle));
    mat_set(to_return, 3, 3, -(far + near) /(far - near));
    mat_set(to_return, 4, 3, -1);
    mat_set(to_return, 3, 4, -(2 * far * near) /(far - near));
    return (to_return);
}

    InformationsquelleAutor der Antwort Moebius

Schreibe einen Kommentar