Discussion :

[dsouffou]

Hello

J'ai un petit problème (pour changer) j'ai une scène OSG avec un matrix de vue et un matrix de projection que je récupère d'une scène Opengl,
comme cela:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
        osg::Matrixd modelViewMatrix(m_dModelMatrix[0], m_dModelMatrix[1], m_dModelMatrix[2], m_dModelMatrix[3],
            m_dModelMatrix[4], m_dModelMatrix[5], m_dModelMatrix[6], m_dModelMatrix[7],
            m_dModelMatrix[8], m_dModelMatrix[9], m_dModelMatrix[10], m_dModelMatrix[11],
            m_dModelMatrix[12], m_dModelMatrix[13], m_dModelMatrix[14], m_dModelMatrix[15]
        );
 
        osg::Matrixd projectionMatrix(m_dProjetMatrix[0], m_dProjetMatrix[1], m_dProjetMatrix[2], m_dProjetMatrix[3],
            m_dProjetMatrix[4], m_dProjetMatrix[5], m_dProjetMatrix[6], m_dProjetMatrix[7],
            m_dProjetMatrix[8], m_dProjetMatrix[9], m_dProjetMatrix[10], m_dProjetMatrix[11],
            m_dProjetMatrix[12], m_dProjetMatrix[13], m_dProjetMatrix[14], m_dProjetMatrix[15]
        );
 
        Camera->setViewMatrix(modelViewMatrix);
        Camera->setProjectionMatrix(projectionMatrix);

Et mon problème vient du fait que j'ai du clipping sur ma scène OSG que je n'ai pas sur ma scène Opengl :
Je précise : (Pour les 2 scènes)
- Le near est a -10000
- Le far est a 10000


Mais si j'utilise le paramètre pour la caméra :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Camera->setComputeNearFarMode(osg::CullSettings::DO_NOT_COMPUTE_NEAR_FAR);

Je n'ai plus le clipping. Ce qui pourrais régler le problème, cependant certaines fonctions on besoin du near and far sinon j'obtiens un écran noir.


Ma question est donc : Comment je pourrais appliquer la vue de la deuxième image sans pour autant désactiver les calcul du near and far ?

Merci d'avance

Daoudou

[LittleWhite]

Bonjour,

À quelle distance est votre caméra des tuiles ?

[dsouffou]

Bonjour,

À quelle distance est votre caméra des tuiles ?

Bonjour

Ma caméra est a une distance de 5. J'ai compris que en plaçant le modelView ma camera ne dépasser pas la valeurs de 10 sur l'axe Z (up) alors que visuellement je suis très haut.

Je vais voir s'il y a un moyen de modifier la distance de la caméra.

Daoudou

[LittleWhite]

Essayez avec un near à 1. Il me parait vraiment étrange d'avoir un near négatif, mais peut être que je commence à perdre mes réflexes de programmeur de rendu .

[dsouffou]

Essayez avec un near à 1. Il me parait vraiment étrange d'avoir un near négatif, mais peut être que je commence à perdre mes réflexes de programmeur de rendu .

J'ai essayez avec un near a 1 mais cela ne change rien.

Cependant j'ai également remarqué que ma caméra ce trouvé toujours avec un eye a l'emplacement X = 4, y = 0 et Z = 4.

Ma théorie serait donc que comme ma scène est plutôt grande peut-être que comme l'œil ma caméra ce trouve a cette emplacement elle n'affiche pas les objets se trouvant derrière elle, par exemple un objet placer a X = -4, y = -4 et Z = 0. Ou sinon cela est du au fait que j'ai une projection orthographique.

[LittleWhite]

Qu'est ce que eye ? L'emplacement de la caméra, ou bien la direction ?

[dsouffou]

Qu'est ce que eye ? L'emplacement de la caméra, ou bien la direction ?

Il s'agit de l'emplacement

[LittleWhite]

OK. Mais il me semble logique que quelque chose derrière la caméra ne soit pas affiché, non ? Et ce, même en projection orthographique (ce qui n'a pas vraiment d'importance ici).

[dsouffou]

OK. Mais il me semble logique que quelque chose derrière la caméra ne soit pas affiché, non ? Et ce, même en projection orthographique (ce qui n'a pas vraiment d'importance ici).

En effet cela est parfaitement logique, du coup je continue de chercher des solutions au début j'ai pensé a faire ce


Je récupère position de la caméra OpenGL en se basant sur la projection matrix et le modelview matrix

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
gluUnProject((m_iViewport[2] - m_iViewport[0]) / 2, (m_iViewport[3] - m_iViewport[1]) / 2,
            0.0, m_dModelMatrix, m_dProjetMatrix, m_iViewport, &m_dCamera_pos[0], &m_dCamera_pos[1], &m_dCamera_pos[2]);

Puis je défini le modelView matrix et la Projection Matrix en les récupérant de ma scène OpenGL

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
osg::Matrixd modelViewMatrix(m_dModelMatrix[0], m_dModelMatrix[1], m_dModelMatrix[2], m_dModelMatrix[3],
            m_dModelMatrix[4], m_dModelMatrix[5], m_dModelMatrix[6], m_dModelMatrix[7],
            m_dModelMatrix[8], m_dModelMatrix[9], m_dModelMatrix[10], m_dModelMatrix[11],
            m_dModelMatrix[12], m_dModelMatrix[13], m_dModelMatrix[14], m_dModelMatrix[15]
        );
 
        osg::Matrixd projectionMatrix(m_dProjetMatrix[0], m_dProjetMatrix[1], m_dProjetMatrix[2], m_dProjetMatrix[3],
            m_dProjetMatrix[4], m_dProjetMatrix[5], m_dProjetMatrix[6], m_dProjetMatrix[7],
            m_dProjetMatrix[8], m_dProjetMatrix[9], m_dProjetMatrix[10], m_dProjetMatrix[11],
            m_dProjetMatrix[12], m_dProjetMatrix[13], m_dProjetMatrix[14], m_dProjetMatrix[15]
        );

Ensuite je créer une première caméra et pour la fonction setViewMatrixAsLookAt, je prend comme oeil la position de la caméra récupérer au dessus, pour le center je prend les valeurs inverse de la position de la caméra

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
m_pCamera->setViewMatrixAsLookAt(
            m_Veye1,
            m_Vcenter1,
            m_Vup
        );

cela me permet d'avoir la même vue mais sans le clipping vue que la caméra se positionne correctement

Ensuite comme le setViewMatrixAsLookAt me pose des problème de rotation pour la caméra je récupère le viewMatrix de la première caméra

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
        osg::Matrix viewTest = m_pCamera->getViewMatrix();
 
        osg::Vec3f transView1 = viewTest.getTrans();
        viewTest.setTrans(transView1);

et pour finir je passe la viewMatrix récupérer sur la premère caméra et je les passe a la caméra principal

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
        m_pNodeCamera->setProjectionMatrix(projectionMatrix);
        m_pNodeCamera->setViewMatrix(viewTest );

sauf que même comme sa pour des scène OpenGl complexe j'ai des problème de translation de la caméra.

oui c'est complexe mais j'ai pas trouver d'autre solution pour pallier au clipping

[LittleWhite]

La position de la caméra devrait être connue côté CPU, car c'est avec elle que l'on génère la matrice de vue. Donc, pas besoin du gluUnProject. La matrice de projection aussi, car elle est générée suivant le viewport voulu (et la projection voulue ). Ces matrices sont ensuite envoyées au GPU (avec la matrice modèle) pour transformer la position des points du modèle en un point à l'écran. Tout est dit dans ce chapitre et système de coordonnées"]le suivant (et celui d'après ).
Mais bon, vous semblez vouloir récupérer le tout d'une scène OpenGL, pour mettre dans OSG. Quel est le but ? Pourquoi ne pas tout faire depuis OSG, ou dans OpenGL ?

Lorsque je vois cet antique tutoriel (il doit y en avoir une traduction sur Developpez.com ), j'ai l'impression que les matrices doivent être passées à la fonction et ce n'est donc pas une fonction pour récupérer ces matrices.
Ce que la fonction vous retourne, c'est une droite, allant de l'oeil de la caméra et avec la direction indiquée par le point que vous passez (suivent la projection). Mais, comme dit précédemment, en théorie, vous avez déjà la position de la caméra, utilisée pour créer la matrice vue.
Le centre, pour la fonction setViewMatrixAsLookAt, c'est le point regardé par la caméra. Du coup, qu'est ce que l'inverse de la position de la caméra ? Le point symétriquement opposé à la position de la caméra, par rapport à 0,0,0. Dans un tel cas, mettre 0,0,0, reviens au même . Par contre, cela créer une caméra de type "satellite", qui orbite autour de 0,0,0 et les translation de caméra ne pourront pas fonctionner (déplacer une caméra sur un rail, tout en regardant 0,0,0) (tout en tournant la tête). Autrement dit, c'est pas une caméra libre/type FPS.

Pour finir, vous jouez avec deux caméras. Seulement pour hacker une solution ? Ou parce que vous avez deux scène et vous avez un rendu dans une texture (style, caméra de surveillance dans un coin de l'application) ?

Voilà, j'espère que cela permettra de vous faire avancer

[dsouffou]

La position de la caméra devrait être connue côté CPU, car c'est avec elle que l'on génère la matrice de vue. Donc, pas besoin du gluUnProject. La matrice de projection aussi, car elle est générée suivant le viewport voulu (et la projection voulue ). Ces matrices sont ensuite envoyées au GPU (avec la matrice modèle) pour transformer la position des points du modèle en un point à l'écran. Tout est dit dans ce chapitre et système de coordonnées"]le suivant (et celui d'après ).
Mais bon, vous semblez vouloir récupérer le tout d'une scène OpenGL, pour mettre dans OSG. Quel est le but ? Pourquoi ne pas tout faire depuis OSG, ou dans OpenGL ?

Lorsque je vois cet antique tutoriel (il doit y en avoir une traduction sur Developpez.com ), j'ai l'impression que les matrices doivent être passées à la fonction et ce n'est donc pas une fonction pour récupérer ces matrices.
Ce que la fonction vous retourne, c'est une droite, allant de l'oeil de la caméra et avec la direction indiquée par le point que vous passez (suivent la projection). Mais, comme dit précédemment, en théorie, vous avez déjà la position de la caméra, utilisée pour créer la matrice vue.
Le centre, pour la fonction setViewMatrixAsLookAt, c'est le point regardé par la caméra. Du coup, qu'est ce que l'inverse de la position de la caméra ? Le point symétriquement opposé à la position de la caméra, par rapport à 0,0,0. Dans un tel cas, mettre 0,0,0, reviens au même . Par contre, cela créer une caméra de type "satellite", qui orbite autour de 0,0,0 et les translation de caméra ne pourront pas fonctionner (déplacer une caméra sur un rail, tout en regardant 0,0,0) (tout en tournant la tête). Autrement dit, c'est pas une caméra libre/type FPS.

Pour finir, vous jouez avec deux caméras. Seulement pour hacker une solution ? Ou parce que vous avez deux scène et vous avez un rendu dans une texture (style, caméra de surveillance dans un coin de l'application) ?

Voilà, j'espère que cela permettra de vous faire avancer

Le but, je travail sur un logiciel de visualisation qui utilise OpenGL et j'ai plusieurs scènes OpenGL ma mission est de prendre la scènes OpenGL et de la reporter sur OSG (tout en gardant OpenGL, ma mission n'as pas pour but de remplacer) et du coup, évidemment la caméra avec, bien entendu les 2 scènes sont lancer en même temps donc si je bouge sur la scènes OpenGL les mouvements de la caméra doivent correspondre.




Non j'ai deux caméras pour hacker une solution ^^', pour certaines scènes OpenGL, la caméra d'OSG a les bons déplacement mais pour les scènes OpenGL plus complexe je n'ai pas les bonnes translation


Merci pour votre aide je vais me replonger sur ces tutoriels mais votre aide est toujours la bienvenue XD

[dsouffou]

La position de la caméra devrait être connue côté CPU, car c'est avec elle que l'on génère la matrice de vue. Donc, pas besoin du gluUnProject. La matrice de projection aussi, car elle est générée suivant le viewport voulu (et la projection voulue ). Ces matrices sont ensuite envoyées au GPU (avec la matrice modèle) pour transformer la position des points du modèle en un point à l'écran. Tout est dit dans ce chapitre et système de coordonnées"]le suivant (et celui d'après ).
Mais bon, vous semblez vouloir récupérer le tout d'une scène OpenGL, pour mettre dans OSG. Quel est le but ? Pourquoi ne pas tout faire depuis OSG, ou dans OpenGL ?

Lorsque je vois cet antique tutoriel (il doit y en avoir une traduction sur Developpez.com ), j'ai l'impression que les matrices doivent être passées à la fonction et ce n'est donc pas une fonction pour récupérer ces matrices.
Ce que la fonction vous retourne, c'est une droite, allant de l'oeil de la caméra et avec la direction indiquée par le point que vous passez (suivent la projection). Mais, comme dit précédemment, en théorie, vous avez déjà la position de la caméra, utilisée pour créer la matrice vue.
Le centre, pour la fonction setViewMatrixAsLookAt, c'est le point regardé par la caméra. Du coup, qu'est ce que l'inverse de la position de la caméra ? Le point symétriquement opposé à la position de la caméra, par rapport à 0,0,0. Dans un tel cas, mettre 0,0,0, reviens au même . Par contre, cela créer une caméra de type "satellite", qui orbite autour de 0,0,0 et les translation de caméra ne pourront pas fonctionner (déplacer une caméra sur un rail, tout en regardant 0,0,0) (tout en tournant la tête). Autrement dit, c'est pas une caméra libre/type FPS.

Pour finir, vous jouez avec deux caméras. Seulement pour hacker une solution ? Ou parce que vous avez deux scène et vous avez un rendu dans une texture (style, caméra de surveillance dans un coin de l'application) ?

Voilà, j'espère que cela permettra de vous faire avancer

Et oui effectivement je voudrais plus une caméra libre/type FPS plutôt que "satellite", mon approche avec setViewMatrixAsLookAt n'est pas la bonne du coup si j'ai bien compris vos explications

[LittleWhite]

En effet, je ne pense pas que ce soit la bonne méthode. Avez-vous accès au code OpenGL des scènes ? Est-ce que ces scènes font partis intégrantes de votre programme ? Pourquoi refaire avec OSG ?
En OpenGL 1, on pouvait récupérer la matrice de vue de cette façon :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

glGetDoublev(GL_MODELVIEW_MATRIX, modelview);

mais je doute que ce soit si simple.

Sinon, pour reproduire une scène, il va falloir y aller de manière brute et la recréer à la main (récupérer les modèles, les charger dans l'application et les afficher, puis implémenter une caméra et tout le toutim).

[dsouffou]

En effet, je ne pense pas que ce soit la bonne méthode. Avez-vous accès au code OpenGL des scènes ? Est-ce que ces scènes font partis intégrantes de votre programme ? Pourquoi refaire avec OSG ?
En OpenGL 1, on pouvait récupérer la matrice de vue de cette façon :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

glGetDoublev(GL_MODELVIEW_MATRIX, modelview);

mais je doute que ce soit si simple.

Sinon, pour reproduire une scène, il va falloir y aller de manière brute et la recréer à la main (récupérer les modèles, les charger dans l'application et les afficher, puis implémenter une caméra et tout le toutim).

Oui j'ai accès au code OpenGL.
En effet je doit refaire cela de manière brute, j'ai recréer à la main chaque modèles, je les charges et les affiches et c'est uniquement l'implémentation de la caméra qui me pose problèmes. Et je refais en OSG (et avec OsgOcean) parce que mon chef veux une visualisation plus "jolie" que la visu de leurs scène OpenGL.

(Je suis désolé je peut pas fournir plus d'explication sur le code OpenGL que l'ont utilise ^^')

[LittleWhite]

Si vous avez accès au code OpenGL, pourquoi ne pas le lire et le réimplémenter (ou même le copier coller )? Habituellement, le code pour implémenter une caméra n'est pas vraiment très compliqué (on regarde les touches que l'utilisateur appuie, on déplace soit la position, soit la où regarde la caméra (direction, souvent modifier par la souris) et très très rarement, le vecteur up).
Pour rendre un programme OpenGL plus beau, pas besoin d'OSG, il suffit d'utiliser les bons shaders/techniques de rendu. Bien sûr, je ne renie pas l'utilisation d'OSG qui peut rendre plus facile le travail .

[dsouffou]

Si vous avez accès au code OpenGL, pourquoi ne pas le lire et le réimplémenter (ou même le copier coller )? Habituellement, le code pour implémenter une caméra n'est pas vraiment très compliqué (on regarde les touches que l'utilisateur appuie, on déplace soit la position, soit la où regarde la caméra (direction, souvent modifier par la souris) et très très rarement, le vecteur up).
Pour rendre un programme OpenGL plus beau, pas besoin d'OSG, il suffit d'utiliser les bons shaders/techniques de rendu. Bien sûr, je ne renie pas l'utilisation d'OSG qui peut rendre plus facile le travail .

Oui j'ai parcouru le code OpenGL et il s'avère qu'ils font modifie le modelView matrix et malheureusement l'utilisation d'OSG ma était imposer

Mais merci pour vos explications

[LittleWhite]

Oui, mais modifier la matrice modelview, c'est normal, sinon, on aurait pas de caméra qui bouge .

[dsouffou]

Oui, mais modifier la matrice modelview, c'est normal, sinon, on aurait pas de caméra qui bouge .

Oui pardon
Je voulais simplement dire que contrairement au tutoriel d'OpenGL sur la caméra :
https://learnopengl.com/Getting-started/Camera

Nous n'utilisons pas de fonction lookAt, avec une position, un target et un up.

Mais je suis en train de retranscrire le notre code OpenGL sur OpenSceneGraph.