Discussion :

[ChPr]

Bonjour à toutes et à tous,

Dans le développement de mon application GPS sur un Raspberry PI 3B, je me trouve confronté à un problème de durée d'exécution des tâches graphiques.

BeanzMaster m'avait suggéré d'essayer OpenGL.

Apparemment, OpenGL est actif sur mon Raspberry Pi 3B (avec stretch) car j'ai exécuté avec succès un des exemples (un cube qui tourne).

Pour autant, je me pose deux questions :

- la faisabilité,
- le gain de temps d'exécution graphique obtenu.

Pour la faisabilité, est-il possible de réaliser l'équivalent de ce qui suit :

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
 
     begin // Chargement des tuiles
       for i:= 0 to 4 do
         for j:= 0 to 4 do
           with Tuile do
           begin     {Chargement d'un panel de 25 cartes de 256 x 256 pixels²}
             NomTuile:= 'Cartes'+SepRep+Nom+IntToStr(Zoom)+SepRep+IntToStr(OSMLon+i-2)+SepRep+IntToStr(OSMLat+j-2)+'.jpg';
             if FileExists(NomTuile) then
             begin
               bmpTuile.LoadFromFile(NomTuile);
               bmpCarte.CanvasBGRA.CopyRect(Rect(DimTuile*i, DimTuile*j, DimTuile*(i+1), DimTuile*(j+1)), bmpTuile, Rect(0, 0, DimTuile, DimTuile));
             end;
           end;
     end;
 
procedure TAffCarte.PaintBoxPaint(Sender: TObject); // Rafraichissement de l'affichage
var
  i: Integer;
begin
  try
    if NbPtTrace > 1 then
      with bmpCarte do
        DrawLineAntialias(PtsTrace[NbPtTrace-2].X, PtsTrace[NbPtTrace-2].Y, PtsTrace[NbPtTrace-1].X, PtsTrace[NbPtTrace-1].Y, $FF0000, 1); // Tracé d'un segment de ligne
    bmpAff := TBGRABitmap.Create(DimCarte, DimCarte, BGRAWhite);
    bmpAff.PutImageAngle(Dec0.X-Depl.X, Dec0.Y-Depl.Y, bmpCarte, CapDeg,
         DemiCarte.X-(Dec0.X-Depl.X), DemiCarte.Y-(Dec0.Y-Depl.Y), $FF, True, False); // Déplacement et rotation
    BGRAReplace(bmpAff, bmpAff.Resample(Round(DimCarte*kZoom), Round(DimCarte*kZoom), rmSimpleStretch)); //Zoom
    CentreAff.X:= Round(DemiCarte.X*kZoom);
    CentreAff.Y:= Round(DemiCarte.Y*kZoom);
    HG.X:= Round((1-kZoom)*(DemiCarte.X))-128;
    HG.Y:= Round((1-kZoom)*(DemiCarte.Y))-340;
    Aff_Infos_GPS(CentreAff.X, CentreAff.Y+260, TxtGPS, bmpAff, clInfPos, CSSLightYellow); // Affichage d'un texte
    bmpAff.PutImage(CentreAff.X-32, CentreAff.Y-32, BmpCible, dmSetExceptTransparent, $FF); // Affichage d'une icône (un cible ici)
    bmpAff.Draw(PaintBox.Canvas, HG.X, HG.Y, False); // Trace la carte avec ses déplacements, zoom et rotation
    bmpAff.Destroy;
  except
    bmpAff.Destroy;
  end;
end;

De manière synoptique :

- Charger 25 tuiles de 256 x 256 pixels² dans un composant appelé "Carte" (1280 x 1280 pixels²) de type OpenGL (?)

-Affichage à récurrence rapide de (inférieur à 0.5 seconde serait bien) :

- Ajout d'un segment de ligne à la carte,
- Déplacement et rotation et effet de zoom d'une partie de cette carte,
- Ajout d'un texte (avec transparence),
- Ajout d'une cible,
- Affichage du tout.

Voilà ce que ça donne avec BGRABitmap.



Et maintenant, quel gain de temps espérer par rapport à BGRAbitmap ?

Cordialement.

Pierre

[JP CASSOU]

Bjr,

Quelques suggestions de corrections dans votre code

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

//try // Pas ici. Le mettre juste après la création du bmpAff  
   // if NbPtTrace > 1 then
   //  with bmpCarte do
   //    DrawLineAntialias(PtsTrace[NbPtTrace-2].X, PtsTrace[NbPtTrace-2].Y, PtsTrace[NbPtTrace-1].X, PtsTrace[NbPtTrace-1].Y, $FF0000, 1); // Tracé d'un segment de ligne
   if (NbPtTrace > 1) then
      DrawLineAntialias(PtsTrace[NbPtTrace-2].X, PtsTrace[NbPtTrace-2].Y, PtsTrace[NbPtTrace-1].X, PtsTrace[NbPtTrace-1].Y, $FF0000, 1); // Tracé d'un segment de ligne

    bmpAff := TBGRABitmap.Create(DimCarte, DimCarte, BGRAWhite); // OK
    try 
    
    bmpAff.PutImageAngle(Dec0.X-Depl.X, Dec0.Y-Depl.Y, bmpCarte, CapDeg,
         DemiCarte.X-(Dec0.X-Depl.X), DemiCarte.Y-(Dec0.Y-Depl.Y), $FF, True, False); // Déplacement et rotation
    BGRAReplace(bmpAff, bmpAff.Resample(Round(DimCarte*kZoom), Round(DimCarte*kZoom), rmSimpleStretch)); //Zoom
    CentreAff.X:= Round(DemiCarte.X*kZoom);
    CentreAff.Y:= Round(DemiCarte.Y*kZoom);
    HG.X:= Round((1-kZoom)*(DemiCarte.X))-128;
    HG.Y:= Round((1-kZoom)*(DemiCarte.Y))-340;
    Aff_Infos_GPS(CentreAff.X, CentreAff.Y+260, TxtGPS, bmpAff, clInfPos, CSSLightYellow); // Affichage d'un texte
    bmpAff.PutImage(CentreAff.X-32, CentreAff.Y-32, BmpCible, dmSetExceptTransparent, $FF); // Affichage d'une icône (un cible ici)
    bmpAff.Draw(PaintBox.Canvas, HG.X, HG.Y, False); // Trace la carte avec ses déplacements, zoom et rotation
    //  bmpAff.Destroy; Inutile. De plus, il ne faut jamais utiliser Destroy
  //except
  finally
    FreeAndNil(bmpAff); // FreeAndNil libère l'objet. Du coup, la méthode Destroy est appelée.
    //bmpAff.Destroy;
  end;

[ChPr]

Merci pour ces suggestions. Pour autant, "with bmpCarte do" est nécessaire pour "DrawLineAntialias".

Cordialement.

Pierre

[BeanzMaster]

Salut

Le cheminement avec OpenGL est bien évidemment différent.

1) Il faudra charger tes images dans une Texture OpenGL (dans le GPU)
2) Ensuite un simple plan où tu appliqueras ta texture sera suffisant
3) Tu pourras facilement Zoomer et faire des rotations de ton objet plan. Le placage de la texture, tu n'auras pas à t'en occuper

Tout se passera dans le GPU donc il clair que le gain en performance sera excellent.

[circular17]

Bonjour,

Il est possible de mélanger BGRABitmap et OpenGL. Il y a une unité BGRAOpenGL qui fournit des fonctions BGLTexture pour charger directement des textures (en VRAM) ou encore TBGLBitmap qui est comme TBGRABitmap (en RAM) mais adapté à OpenGL. La propriété Texture est une texture utilisable avec OpenGL. Enfin, la fonction MakeTextureAndFree renvoie la texture OpenGL (en VRAM) et libère l'objet TBGLBitmap (en RAM).

Il y a des exemples dans le répertoire "bgrabitmap/test/test4lcl_opengl". Les exemples 1, 2 et 3 utilisent le composant TOpenGLControl du paquet lazopenglcontext pour l'affichage.

Une chose à prendre en considération est que OpenGL fonctionne avec un contexte, qui correspond à la surface active. L'invocation des textures OpenGL doit se faire dans le bon contexte, ce qui est le cas notamment dans l'évenement Paint du contrôle OpenGL. De là, un appel à une fonction de chargement fonctionne bien (il suffit d'avoir un booléen pour savoir si le chargement a déjà été fait ou pas).

Les textures sont des interfaces IBGLTexture, qui sont libérées automatiquement à la fin du programme ou bien si on leur affecte la valeur nil. En principe, pour bien faire il faudrait les libérer dans le bon contexte OpenGL.

S'il y a une seule surface OpenGL, il n'y a pas d'ambiguïté mais sinon, c'est quelque chose à gérer. Cela est fait par le composant TBGLVirtualScreen du paquet BGLControls (dans le même répertoire que BGRABitmapPack), ce sont les exemples 0 et tux_game.

Cordialement

[ChPr]

Merci "circular17" pour ces précisions.

Je suis passé à "BGRAOpenGL" pour mon application de GPS et cela fonctionne très bien. Il a fallu régler quelques problèmes de coordonnées, mais maintenant c'est OK et c'est très fluide.

Cordialement.

Pierre

[circular17]

Avec plaisir.

Oui j'ai lu vos pérégrinations. Il semble que vous vous en soyez sorti en fin de compte.