Aperçu
----À l'heure actuelle, dans de nombreux logiciels d'apprentissage et CD de jeux, vous pouvez souvent voir divers
La technologie d'affichage graphique s'appuie sur le mouvement graphique, l'entrelacement, la forme des gouttes de pluie, les stores, l'empilement de blocs de construction et d'autres méthodes d'affichage pour rendre l'image plus vivante et plus attrayante pour le public. Cet article explorera comment implémenter diverses techniques d'affichage graphique dans Delphi.
Principes de base
----Dans Delphi, il est très simple d'afficher une image. Définissez simplement un composant TImage dans le formulaire, définissez son attribut d'image, puis sélectionnez n'importe quel fichier .ICO, .BMP, .EMF ou .WMF valide, chargez-le, et le fichier sélectionné sera affiché dans le composant TImage. Mais cela affiche simplement les graphiques directement dans le formulaire, et il n'y a aucune compétence du tout. Afin de donner à l'affichage graphique un effet unique, vous pouvez suivre les étapes suivantes :
----Définissez un composant TImage et chargez d'abord les graphiques à afficher dans le composant TImage. En d'autres termes, chargez le contenu graphique du disque dans la mémoire en tant que cache graphique.
----Créez un nouvel objet bitmap avec la même taille que les graphiques dans le composant TImage.
----Utilisez la fonction CopyRect de Canvas (copiez la zone rectangulaire d'un canevas dans la zone rectangulaire d'un autre canevas), utilisez des techniques et façonnez dynamiquement
dans le contenu d'un fichier bitmap, puis affiche le bitmap sous la forme.
----Méthode de mise en œuvre
Diverses techniques d'affichage graphique sont présentées ci-dessous :
1. Effet push-pull
Les graphiques à afficher sont affichés sur l'écran depuis le haut, le bas, la gauche et la droite, et les anciens graphiques originaux sur l'écran sont masqués en même temps. Cet effet peut être divisé en quatre.
Il en existe trois types : pull-up, pull-down, gauche-pull et droite-pull, mais les principes sont similaires. Prenons l'exemple de l'effet pull-up.
Principe : Tout d'abord, déplacez la première ligne horizontale placée dans le graphique temporaire vers la dernière du bitmap à afficher, puis déplacez les deux premières lignes horizontales du graphique temporaire vers les deux derniers bitmaps à afficher. puis déplacez les trois premiers et les quatre premiers ??? jusqu'à ce que toutes les données graphiques soient déplacées. Pendant le processus de déplacement, vous pouvez voir que le bitmap affiché flotte de bas en haut, obtenant ainsi un effet pull-up.
Algorithme du programme :
PRécédure TForm1.Button1Click(Expéditeur : TObject);
var
nouveaubmp : TBitmap ;
je,hauteurbmp,largeurbmp:entier;
commencer
newbmp:= TBitmap.Create;
newbmp.Width:=image1.Width;
newbmp.Height:=image1.Height;
bmpheight:=image1.Hauteur;
bmpwidth:=image1.Width;
pour i:=0 à bmpheight faire
commencer
newbmp.Canvas.CopyRect(Rect
(0,bmphhauteur-i,bmplargeur,bmphhauteur),
image1.Toile,
Rect(0,0,largeurbmp,i));
form1.Canvas.Draw(120,100,newbmp);
fin;
newbmp.free;
fin;
2. Effet décalé vertical
Principe : divisez les graphiques à afficher en deux parties. Les lignes de numérisation impaires sont déplacées de haut en bas et les lignes de numérisation paires sont déplacées de bas en haut, et les deux sont effectuées en même temps. Depuis l'écran, vous pouvez voir que les graphiques plus clairs apparaissant aux extrémités supérieure et inférieure se déplacent vers le centre de l'écran jusqu'à ce qu'ils soient complètement clairs.
Algorithme du programme :
procédure TForm1.Button4Click(Expéditeur : TObject);
var
nouveaubmp:TBitmap;
i,j,hauteurbmp,largeurbmp:entier;
commencer
newbmp:= TBitmap.Create;
newbmp.Width:=image1.Width;
newbmp.Height:=image1.Height;
bmpheight:=image1.Hauteur;
bmpwidth:=image1.Width;
je:=0;
tandis que je< =bmpheight fais
commencer
j:=je;
tandis que j>0 fais
commencer
newbmp.Canvas.CopyRect(Rect(0,j-1,bmpwidth,j),
image1.Toile,
Rect(0,bmpheight-i+j-1,bmpwidth,bmpheight-i+j));
newbmp.Canvas.CopyRect(Rect
(0,bmphhauteur-j,bmplargeur,bmphhauteur-j+1),
image1.Toile,
Rect(0,ij,bmpwidth,i-j+1));
j:=j-2;
fin;
form1.Canvas.Draw(120,100,newbmp);
je:=i+2;
fin;
newbmp.free;
fin;
3. Effet décalé horizontal
Principe : Même principe que l'effet d'entrelacement vertical, sauf que les graphiques divisés en deux groupes sont déplacés dans l'écran respectivement par les extrémités gauche et droite.
Algorithme du programme :
procédure TForm1.Button5Click(Expéditeur : TObject);
var
nouveaubmp:TBitmap;
i,j,hauteurbmp,largeurbmp:entier;
commencer
newbmp:= TBitmap.Create;
newbmp.Width:=image1.Width;
newbmp.Height:=image1.Height;
bmpheight:=image1.Hauteur;
bmpwidth:=image1.Width;
je:=0;
tandis que je< =bmpwidth fais
commencer
j:=je;
tandis que j>0 fais
commencer
newbmp.Canvas.CopyRect(Rect(j-1,0,j,bmpheight),
image1.Toile,
Rect(bmpwidth-i+j-1,0,bmpwidth-i+j,bmpheight));
newbmp.Canvas.CopyRect(Rect
(bmpwidth-j,0,bmpwidth-j+1,bmphauteur),
image1.Toile,
Rect(ij,0,i-j+1,bmpheight));
j:=j-2;
fin;
form1.Canvas.Draw(120,100,newbmp);
je:=i+2;
fin;
newbmp.free;
fin;
4. Effet goutte de pluie
Principe : Déplacer la dernière ligne de scan des graphiques temporaires de la première à la dernière ligne de scan du bitmap visible en séquence, permettant à cette ligne de scan de laisser sa trace sur l'écran. Ensuite, l'avant-dernière ligne de balayage des graphiques temporaires est déplacée vers la première à l'avant-dernière ligne de balayage du bitmap visible en séquence. Et ainsi de suite pour les lignes de balayage restantes.
Algorithme du programme :
procédure TForm1.Button3Click(Expéditeur : TObject);
var
nouveaubmp:TBitmap;
i,j,hauteurbmp,largeurbmp:entier;
commencer
newbmp:= TBitmap.Create;
newbmp.Width:=image1.Width;
newbmp.Height:=image1.Height;
bmpheight:=image1.Hauteur;
bmpwidth:=image1.Width;
pour i:=hauteur jusqu'à 1 faire
pour j:=1 à je fais
commencer
newbmp.Canvas.CopyRect(Rect(0,j-1,bmpwidth,j),
image1.Toile,
Rect(0,i-1,bmpwidth,i));
form1.Canvas.Draw(120,100,newbmp);
fin;
newbmp.free;
fin;
5. Effet persiennes
Principe : Divisez les données placées dans les graphiques temporaires en plusieurs groupes, puis déplacez-les séquentiellement du premier groupe au dernier groupe. La première fois, chaque groupe déplace la première ligne de numérisation vers la position correspondante du bitmap visible, et la seconde fois. time Déplacez la deuxième ligne de balayage, puis déplacez les troisième et quatrième lignes de balayage.
Algorithme du programme :
procédure TForm1.Button6Click(Expéditeur : TObject);
var
nouveaubmp:TBitmap;
i,j,hauteurbmp,largeurbmp:entier;
xgroup,xcount:entier;
commencer
newbmp:= TBitmap.Create;
newbmp.Width:=image1.Width;
newbmp.Height:=image1.Height;
bmpheight:=image1.Hauteur;
bmpwidth:=image1.Width;
xgroupe :=16 ;
xcount:=bmpheight div xgroup;
pour i:=0 à xcount faire
pour j:=0 à xgroup faire
commencer
newbmp.Canvas.CopyRect(Rect
(0,xcount*j+i-1,bmpwidth,xcount*j+i),
image1.Toile,
Rect(0,xcount*j+i-1,bmpwidth,xcount*j+i));
form1.Canvas.Draw(120,100,newbmp);
fin;
newbmp.Gratuit ;
fin;
6. Effet de bloc de construction
Principe : Il s'agit d'une variante de l'effet goutte de pluie. La différence est que l'effet de bloc de construction déplace un élément graphique à chaque fois, et non seulement une ligne de balayage.
Algorithme du programme :
procédure TForm1.Button7Click(Expéditeur : TObject);
var
nouveaubmp:TBitmap;
i,j,hauteurbmp,largeurbmp:entier;
commencer
newbmp:= TBitmap.Create;
newbmp.Width:=image1.Width;
newbmp.Height:=image1.Height;
bmpheight:=image1.Hauteur;
bmpwidth:=image1.Width;
je:=bmhauteur ;
alors que je>0 fais
commencer
pour j:=10 à je fais
commencer
newbmp.Canvas.CopyRect(Rect(0,j-10,bmpwidth,j),
image1.Toile,
Rect(0,i-10,bmpwidth,i));
form1.Canvas.Draw(120,100,newbmp);
fin;
je:=i-10;
fin;
newbmp.free;
fin;
Conclusion
Les effets d'affichage graphique ci-dessus ont été transmis sur l'ordinateur, l'environnement logiciel est Delphi 3.0 et l'environnement matériel est une machine compatible Pentium 100M. Cela fonctionne très bien.