[Dev-Pascal] Utilisation de l'unité Graph [Résolu]

[Roland Chastain]

Bonjour !

J'ai testé l'unité Graph (éditeur Dev-Pascal, compilateur Free-Pascal 2.6.0).

La prise en main est plutôt facile. Une fois le chemin de l'unité correctement enregistré dans les options du compilateur (voir à ce sujet le récent tutoriel d'Alcatîz), ça fonctionne. Le seul autre problème que j'ai rencontré était un "integer" que j'ai dû remplacer par un "smallint" dans la procédure d'initialisation de l'écran graphique.

Pour s'initier aux bases du graphisme, l'unité Graph est encore peut-être ce qu'il y a de mieux. (Si vous utilisez une autre librairie pour vos graphismes, n'hésitez pas à en parler dans cette discussion.) Pour ma part, je pense que je continuerai à m'en servir.

Voici mon programme. On y voit une façon d'initialiser le mode graphique (il y en d'autres), et l'emploi de quelques fonctions. Si vous êtes intéressé, je vous invite à contribuer. Que diriez-vous d'un petit concours de graphisme, sans prétention mais plutôt dans le but de rassembler une petite collection d'exemples ?

Code :

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
// Dev-Pascal + Free-Pascal 2.6.0
// Utilisation de l'unité Graph
 
program exemple;
uses
  crt, graph;
var
  // variables pour l'initialisation du mode graphique
  gd, gm: smallint;
begin
  // initialisation d'un écran graphique de 640 sur 480 pixels
  gd := vga;
  gm := vgahi;
  initgraph(gd, gm, '');
  if graphresult = grok then
  begin
    setbkcolor(white);
    cleardevice;
    delay(1000);
    setcolor(blue);
    line(0, 0, 639, 479);
    line(0, 479, 639, 0);
    delay(1000);
    setcolor(green);
    rectangle(0, 0, 639, 479);
    delay(1000);
    setcolor(blue);
    circle(640 div 2, 480 div 2, 100);
    delay(1000);
    setfillstyle(solidfill,yellow);
    floodfill(320 - 1,240,blue);
    setfillstyle(solidfill,lightblue);
    floodfill(320 + 1,240,blue);
    delay(5000);
    closegraph;
  end;
end.

[M.Dlb]

Si tu es intéressé par le graphisme, tu peux aussi regarder la librairie SDL qui est hyper complète même si elle est assez "bas-niveau". En particulier: http://www.freepascal-meets-sdl.net/

Tu peux t'inspirer des résultats du dernier défi, où Titeee et moi-même avions proposé un jeu Tetris programmé avec SDL

http://www.developpez.net/forums/d11...nspire-tetris/

[Roland Chastain]

Merci, je vais regarder ça. Peut-être le sujet d'une autre discussion sur le même principe ?

[Paul TOTH]

A l'époque ou je développais en Turbo Pascal j'ai très vite abandonné l'unité Graph qui donnait des performances assez lamentables...mais à l'époque mes programmes tournaient sur un 386, voir un 486DX le bon vieux temps

[Roland Chastain]

Envoyé par Paul TOTH

A l'époque ou je développais en Turbo Pascal j'ai très vite abandonné l'unité Graph qui donnait des performances assez lamentables...mais à l'époque mes programmes tournaient sur un 386, voir un 486DX le bon vieux temps

C'est vrai que les possibilités de cette unité sont très limitées, mais si on ne lui demande pas trop, elle peut rendre de bons services. Pour tracer des courbes, par exemple, ça va très bien.

Le programme suivant, à partir de deux points choisis par l'utilisateur, trace la droite passant par ces deux points, puis la perpendiculaire passant par le deuxième point.

Code :

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
program graph010;
uses
  crt, graph;
 
// pour deux points donnés, on veut trouver
// 1° l'équation de la droite passant par ces deux points
// 2° l'équation d'une droite perpendiculaire à la précédente
// et la coupant en un point donné
 
var
  gd, gm: smallint;
  x, y: real;
  a, b, c, d: real;
  x1, y1, x2, y2: real;
  xs, ys: integer;
 
begin
  //x1 := 0;
  //y1 := 0;
  //x2 := 3;
  //y2 := 1;
 
  clrscr;
  write('x1='); readln(x1);
  write('y1='); readln(y1);
  write('x2='); readln(x2);
  write('y2='); readln(y2);
 
  a := (y2 - y1) / (x2 - x1);
  b := y1 - a * x1;
 
  c := -1 / a;
  d := y2 - c * x2;
 
  gd := vga;
  gm := vgahi;
  initgraph(gd, gm, '');
  if graphresult = grok then
  begin
    setbkcolor(white);
    cleardevice;
    setcolor(darkgray);
    rectangle(40, 40, 599, 439);
    // repère
    line(80, 240, 559, 240);
    line(320, 80, 320, 399);
    // titre
    outTextXY(80, 80, 'Essai de l''unit'+chr(130)+' Graph');
 
    // droite 1
    x := -240;
    repeat
      y := a * x + b;
      if (y >= -160) and (y < 160) then
      begin
        xs := trunc(x);
        ys := trunc(y);
        putpixel(xs + 320, 480 - (ys + 240), blue);
      end;
      x := x + 1/10;
    until x >= 239;
 
    // droite 2
    x := -240;
    repeat
      y := c * x + d;
      if (y >= -160) and (y < 160) then
      begin
        xs := trunc(x);
        ys := trunc(y);
        putpixel(xs + 320, 480 - (ys + 240), green);
      end;
      x := x + 1/10;
    until x >= 239;
 
    ReadKey;
    CloseGraph;
  end;
 end.

[Roland Chastain]

A l'occasion d'une question posée dans le forum, j'ai refait un tour de l'unité Graph, et je me suis aperçu d'une erreur que j'ai faite dans mes exemples précédents.

Code :

1
2
3
 
uses
  crt, graph;

En mode graphique sous Windows il faut utiliser l'unité WinCrt pour les procédures telles que ReadKey et KeyPressed.

Mais du coup ces procédures ne sont plus disponibles pour le mode console.

Il ne reste plus qu'à utiliser ReadLn, comme on peut le voir dans l'exemple suivant :

Code :

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
 
program Graph_15;
 
uses
  Graph, WinCrt;
 
var
  //
  Pilote, Mode: SmallInt;
  //
  xs, ys: Single;
  xw, yw: Word;
 
const
  e: Single = 1 / 100;
  r: Single = 8;
 
begin
  Pilote := Vga;
  Mode := VgaHi;
  //
  InitGraph(Pilote, Mode, '');
  //
  if GraphResult = grOk then
  begin
    SetBkColor(DarkGray);
    ClearDevice;
    //
    xs := -r;
    repeat
      ys := Sqrt((r * r - xs * xs));
      //
      xw := 640 div 2 + Round(xs * 20);
      yw := 480 div 2 - Round(ys * 20);
      //
      PutPixel(xw, yw, White);
      PutPixel(640 - xw, 480 - yw, Yellow);
      //
      xs := xs + e;
      //
    until xs >= r;
    //
    SetColor(White);
    OutTextXY(10, 10, 'Pressez une touche !');
    ReadKey;
    CloseGraph;
    //
    WriteLn('Pressez une touche !');
    ReadLn;
  end;
end.

[Roland Chastain]

Un mot pour clore peut-être cette discussion. Le principal intérêt de l'unité Graph de Free Pascal, c'est qu'elle permet de faire tourner des programmes écrits pour Turbo Pascal.

Il faut seulement faire attention au mode de compilation. Dans les sources Turbo Pascal, les variables "pilote" et "mode" de l'exemple ci-dessus sont du type Integer. Cette déclaration est acceptée par FPC en mode Turbo Pascal et en mode Free Pascal. Pour les modes Object Pascal et Delphi, on doit utiliser le type SmallInt.

Pour bien faire, il faudrait ajouter dans les exemples une directive de compilation qui sélectionne en fonction du mode la ligne convenable. Si quelqu'un pouvait proposer le code, ce serait parfait.