Quelle est la fonction glFrustum faire?

Selon MSDN, nous sommes en multipliant le cours de la matrice avec le point de vue de la matrice. Ce que la matrice parlons-nous ici? Aussi à partir de MSDN:

"La fonction glFrustum multiplie la matrice courante par cette matrice, avec le résultat du remplacement de la matrice actuelle. C'est, si M est la matrice actuelle et F est le champ de vue de la perspective de la matrice, puis glFrustum remplace M par M • F."

Maintenant, à partir de mes connaissances actuelles de la 12e année de calcul (où je suis actuellement), M est un vecteur et M produit scalaire F retourne un scalaire, alors comment peut-on remplacer un vecteur par un scalaire?

Je suis également pas sûr de ce que "clipping" les avions sont et comment ils peuvent être référencé par une valeur flottante.

Veuillez phrase de votre réponse, en termes de paramètres, et aussi sur le plan conceptuel. J'apprécierais vraiment que.

Je suis en train d'apprendre openGL via ce tutoriel: http://www.youtube.com/watch?v=WdGF7Bw6SUg. Il est en fait pas vraiment du bien, car il n'explique rien, ou autre, il suppose que l'on sait openGL. J'apprécierais vraiment un lien vers un tutoriel sinon, j'apprécie vraiment votre temps et vos réponses! Je suis sûr que je peux lutte et de comprendre les choses.

"Il est en fait pas vraiment du bien, car il n'explique rien, ou autre, il suppose que l'on sait openGL." Alors, pourquoi êtes-vous à l'aide d'un tutoriel que vous avez vous-même l'admet, n'est pas bon? Vous pourriez Google pour "tutoriel OpenGL" et de trouver quelque chose de mieux.
Merci pour les conseils.

OriginalL'auteur user2316667 | 2013-05-28

  1. 11

    Vous ne comprenez pas ce qu'il dit. M est une matrice. M•F est donc aussi une matrice. Il construit un point de vue de la matrice. Voir cet article pour une explication de la façon dont elle est construite et lorsque vous souhaitez utiliser glFrustum() vs gluPerspective():

    glFrustum() et gluPerspective() produisent de la perspective matrices de projection que vous pouvez utiliser pour transformer d'oeil l'espace de coordonnées de clip espace de coordonnées. La principale différence entre les deux est que glFrustum() est plus générale et permet en dehors de l'axe des projections, tandis que gluPerspective() ne produit symétrique (sur l'axe) des projections. En effet, vous pouvez utiliser glFrustum() pour mettre en œuvre gluPerspective().

    Les plans de découpe sont de plans de coupe des coupes du monde de sorte qu'ils n'ont pas à être rendus. Le champ de vue décrit l'endroit où les avions sont dans l'espace. Ses côtés définir l'affichage du volume.

    Nous sommes en fait l'apprentissage des matrices de cette semaine. Je serai de retour à relire les définitions et donner la meilleure réponse!

    OriginalL'auteur user1118321

  2. 7

    glFrustum génère une matrice de projection perspective.

    Cette matrice de cartes d'une partie de l'espace (le "fustum") de votre écran. De nombreuses mises en garde s'appliquent (normalisé les coordonnées de périphérique, la perspective de diviser, etc), mais c'est l'idée.

    La partie qui vous intrigue est un vestige de l'obsolète OpenGL API. Vous pouvez ignorer en toute sécurité, car en général, vous appliquez gluFrustum() sur une identité, d'une matrice de projection, de sorte que la multiplication mentionné dans la doc n'a pas d'effet.

    Un peut-être plus compréhensible de la façon de faire les choses est la suivante : 

    //Projection matrix : 45° Field of View, 4:3 ratio, display range : 0.1 unit <-> 100 units
glm::mat4 Projection = glm::perspective(45.0f, 4.0f /3.0f, 0.1f, 100.0f);
//Or, for an ortho camera :
//glm::mat4 Projection = glm::ortho(-10.0f,10.0f,-10.0f,10.0f,0.0f,100.0f); //In world coordinates

//Camera matrix
glm::mat4 View       = glm::lookAt(
                            glm::vec3(4,3,3), //Camera is at (4,3,3), in World Space
                            glm::vec3(0,0,0), //and looks at the origin
                            glm::vec3(0,1,0)  //Head is up (set to 0,-1,0 to look upside-down)
                       );
//Model matrix : an identity matrix (model will be at the origin)
glm::mat4 Model      = glm::mat4(1.0f);
//Our ModelViewProjection : multiplication of our 3 matrices
glm::mat4 MVP        = Projection * View * Model; //Remember, matrix multiplication is the other way around

    Ici, j'ai utilisé glm::point de vue (l'équivalent de l'ancienne gluPerspective() ), mais vous pouvez utiliser gluFrustum trop.

    Comme pour les arguments de la fonction, ils sont mieux expliquées par cette partie de la doc :

    en bas à gauche - nearVal de droite et de haut - nearVal préciser les points sur
    la proximité de plan de découpe qui sont mappés sur le coin inférieur gauche et supérieur
    virages à droite de la fenêtre, en supposant que l'œil est situé à (0,
    0, 0)

    Si vous n'êtes pas familier avec des matrices de transformation, j'ai écrit un tutoriel ici; la "Matrice de Projection" de la section, en particulier, devraient vous aider.

    Je voulais juste dire que ton tuto a obtenu d'être la meilleure description de la matrice des transformations que j'ai jamais lu. Bravo!

    OriginalL'auteur Calvin1602