Discussion :

[NoIdea]

Bonjour à tous, j'essaie de me déplacer dans une scène importée (au format .obj) et le calcul nécessaire à ma camera commence a prendre du temps (je tourne a 20 fps avec camera et 40 sans).

Aujourd'hui, voici le code de ma camera (j'utilise les coordonnées sphériques).

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
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
class Camera
{
    private :
        float Angle1;//horizontal
        float Angle2;//vertical
        float Distance;
        static const Vector3D up;
 
 
        Vector3D GetPosition()//Position de la camera dans le repère ayant pour origine l'objet fixé.
        {
            Vector3D Position;
            float Distancetmp=Distance;
            if(Angle2<0)
                Distancetmp=std::min(static_cast<float>(-Center.z/sin(Angle2)), Distance)-0.001;
            Position.x=Distancetmp*cos(Angle1)*cos(Angle2);
            Position.y=Distancetmp*sin(Angle1)*cos(Angle2);
            Position.z=Distancetmp*sin(Angle2);
            return Position;
        }
 
    public :
        Vector3D Center;//Coordonnées de l'objet a fixé dans le repère opengl.
        Camera() : Angle1(0), Angle2(0.5), Distance(10){}
 
 
        void Show()
        {
            glMatrixMode(GL_MODELVIEW);
            glLoadIdentity();
 
 
            Vector3D Position=Center+GetPosition();
            gluLookAt(Position.x,Position.y,Position.z,Center.x,Center.y,Center.z,0,0,1);
 
        }
        void RotateTop(float Angle)
        {
            Angle*=M_PI/180;
            Angle2+=Angle;
            if(Angle2<-M_PI/2)
                Angle2=-M_PI/2+0.001;
            else if(Angle2>M_PI/2)
                Angle2=M_PI/2-0.001;
        }
        void RotateSide(float Angle)
        {
            Angle*=M_PI/180;
            Angle1+=Angle;
        }
        void Move(const Vector3D& v)
        {
            float z=Center.z;
            Vector3D Position;
            Position=GetPosition()*(-1);
            Position.z=0;
            Center+=Position.GetUnit()*v.x;
            Center+=Position.CrossProduct(up).GetUnit()*v.y;
            Center.z=z;
        }
        void Move(float a, float b, float c)
        {
            Vector3D tmp;
            tmp.x=a;
            tmp.y=b;
            tmp.z=c;
            Move(tmp);
        }
        void IncreaseDistance(float d)
        {
            Distance+=d;
            if(Distance<0)
                Distance=0.001;
        }
        float GetSideAngle() const
        {
            return Angle1*180/M_PI;
        }
        Vector3D GetPos()
        {
            return Center+GetPosition();
        }
 
};
 
 
const Vector3D Camera::up(0,0,1);

Comme vous voyez, tous mes calculs sont fait par le processeur. Est-il possible de les faire faire facilement par la carte graphique avec glRotate et glTranslate ? Si oui, comment ? Il faudrait que je puisse garder les mêmes fonctions publiques.

Au cas où ceci pourrait vous aider, voici un exemple d'utilisation :

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
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
if(Input.IsKeyDown(sf::Key::Z))
            {
                cam.Move(0.1,0,0);
            }
 
            if(Input.IsKeyDown(sf::Key::Q)&&Input.IsMouseButtonDown(sf::Mouse::Right))
            {
                cam.Move(0,-0.1,0);
 
            }
            if(Input.IsKeyDown(sf::Key::D)&&Input.IsMouseButtonDown(sf::Mouse::Right))
            {
                cam.Move(0,0.1,0);
            }
            if(Input.IsKeyDown(sf::Key::S))
            {
                cam.Move(-0.1,0,0);
            }
            if(Input.IsKeyDown(sf::Key::Q)&& !Input.IsMouseButtonDown(sf::Mouse::Right))
            {
                cam.RotateSide(1);
            }
            if(Input.IsKeyDown(sf::Key::D)&& !Input.IsMouseButtonDown(sf::Mouse::Right))
            {
                cam.RotateSide(-1);
            }
if(Input.IsMouseButtonDown(sf::Mouse::Right)&&ok)
        {
            cam.RotateSide(-(static_cast<float>(Input.GetMouseX())-xac)/3);
            cam.RotateTop((static_cast<float>(Input.GetMouseY())-yac)/3);
 
        }

Merci d'avance.

[LittleWhite]

Bonjour,

Je ne sais pas quelle bibliothèque vous utilisez pour récupérer les touches, mais cette partie peut être très lente si cela est fait n'importe comment (surtout avec la SDL en fait).

Maintenant, pour le faire du coté GPU, à cause de la gestion des évènements ce n'est pas possible.

Sinon, je n'ai pas vu de calcul lourd ...

[NoIdea]

Code :

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

Je ne sais pas quelle bibliothèque vous utilisez pour récupérer les touches

La SFML pour l'instant, mais je vais bientôt passer a qt

Sinon, je n'ai pas vu de calcul lourd ...

Il me semblait que c'était les calculs de sinus et cosinus à chaque frame qui était lourd + l'appel à gluLookAt. N'y aurait il pas un moyen pour que le GPU fasse les rotations/translation nécessaire ?

mais cette partie peut être très lente si cela est fait n'importe comment

Je vais voir si c'est cela qui ralentit vraiment mais j'ai des doutes.

[LittleWhite]

Il me semblait que c'était les calculs de sinus et cosinus à chaque frame qui était lourd + l'appel à gluLookAt. N'y aurait il pas un moyen pour que le GPU fasse les rotations/translation nécessaire ?

Si c'est fait qu'une fois par frame, c'est bon, pas de problème.
Sinon, pour le faire faire sur le GPU, il faut préparer une matrice de vue et la faire multiplier dans un vertex shader.
Je doute que le gain soit significatif.

Utilisez donc un profiler.

De plus, combien d'objets affichez vous ?

[LeGreg]

Il me semblait que c'était les calculs de sinus et cosinus à chaque frame qui était lourd + l'appel à gluLookAt. N'y aurait il pas un moyen pour que le GPU fasse les rotations/translation nécessaire ?

Le GPU va faire les rotations et translations mais pour ça il faut que vous lui passiez les matrices correspondantes. Et les matrices correspondantes sont calculées avec des cos/sinus et les appels à gluLookAt (ou équivalent).
Certes vous pourriez lui passer directement vos coordonnées sphériques et il pourrait calculer la matrice directement, mais comme on a dit, vous ne bougez la caméra qu'une seule fois par frame (en principe) donc le calcul est négligeable par rapport à la somme de ce qu'il faut pour afficher tout le reste (calculer les rotations/translations de milliers d'objets dans une scène par exemple).

Essayer de calculer combien de fois vous passez dans le code de modification de caméra, si vous y passez un grand nombre de fois par frames (entre deux present()) alors vous avez un problème dans le reste de votre code.