Les premiers pas
La bibliothèque XLIB réclame comme configuration minimale, un microprocesseur 80286, une carte vidéo VGA et Borland/Turbo Pascal v6.0/7.0.
Caractéristiques générales
- La bibliothèque XLIB prend en charge de plusieurs résolutions graphiques à 256 couleurs modifiées : 320 x 200 pixels, 320 x 240 pixels, 360 x 200 pixels, 360 x 240 pixels, 376 x 282 pixels, 320 x 400 pixels, 320 x 480 pixels, 360 x 400 pixels, 360 x 480 pixels, 360 x 360 pixels, 376 x 308 pixels et 376 x 564 pixels.
- Veuillez noter que certaines des nouvelles résolutions conviennent mieux aux moniteurs à hauteur verticale réglable.
- Les écrans virtuels sont plus grands que l'écran physique (si la mémoire le permet) et ainsi elle permet d'être déplacés à une résolution de pixels dans toutes les directions.
- Une capacité d'écran partagé pour les affichages d'état,...
- Les fonctions de texte prenant en charge les polices de caractères 8x8 et 8x14 en ROM et les polices de caractères définies par l'utilisateur.
- Une prise en charge du retournement de page.
- Les primitives graphiques telles que les fonctions de dessin de lignes et de rectangles et bien sûr les fonctions de manipulation de blocs de bits.
Création des bibliothèques
Pour compiler XLIB, chargez-le simplement dans l'IDE et appuyez sur la touche F9. Si vous préférez le compilateur en ligne de commande, exécutez la commande :
| TPC xlib |
Utiliser la bibliothèque avec vos programmes
L'utilisation de la bibliothèque XLIB dans vos programmes est simple. Il suffit d'inclure l'unité XLIB dans l'instruction USES au début de votre programme, ce qui rendra toutes les procédures et fonctions de composante de la bibliothèque XLIB disponibles :
- Uses XLIB;
Constantes et variables globales
Les résolutions disponibles en mode X de la bibliothèque XLIB sont :
- Const
- XMODE320x200 = 0;
- XMODE320x240 = 1;
- XMODE360x200 = 2;
- XMODE360x240 = 3;
- XMODE360x282 = 4;
- XMODE320x400 = 5;
- XMODE320x480 = 6;
- XMODE360x400 = 7;
- XMODE360x480 = 8;
- XMODE360x360 = 9;
- XMODE376x308 = 10;
- XMODE376x564 = 11;
Sens de rotation de la palette :
- Const
- RBackward = 0;
- RForward = 1;
Les constantes d'erreur :
- Const
- XModeInvalid = -1;
- Error = 1;
- OK = 0;
Les variables globales de l'unité XLIB sont :
| Variable/Type de données | Description |
|---|---|
| InGraphics:Byte | Drapeau indiquant que le système graphique xlib est actif. Défini par la fonction «xsetmode». |
| CurrXMode:Word | Si le système graphique xlib est actif, contient l'identifiant du mode x. Défini par la fonction "xsetmode". Voir aussi les constantes (par exemple XMODE320x200...). |
| ScrnPhysicalByteWidth:Word | Largeur physique de l'écran en octets. Définie par la fonction «xsetmode». |
| ScrnPhysicalPixelWidth:Word | Largeur physique de l'écran en pixels. Définie par la fonction «xsetmode» |
| ScrnPhysicalHeight:Word | Hauteur physique de l'écran en pixels. Définie par la fonction «xsetmode». |
| ErrorValue:Word | Contient une valeur d'erreur. Variable à usage général pour communiquer l'état d'erreur de plusieurs fonctions. La valeur de cette variable n'est généralement valide que pour la dernière fonction appelée qui la définit. |
| SplitScrnOffs:Word | Décalage dans la mémoire vidéo de l'écran partagé. Défini par la fonction «xsetsplitscrn». La valeur n'est valide que si un écran partagé est actif. Voir également la variable globale «SplitScrnActive». |
| SplitScrnScanLine:Word | Ligne de balayage d'écran à laquelle l'écran partagé commence initialement lorsqu'elle est définie par la fonction «xsetsplitscrn». La valeur n'est valide que si un écran partagé est actif. Voir également la variable globale «SplitScrnActive». Cette variable n'est pas mise à jour par «xhidesplitscrn», «xadjustsplitscrn». |
| SplitScrnVisibleHeight:word | Le nombre de lignes de l'écran partagé initial étant actuellement affichées. Modifié par «xhidesplitscrn», «xadjustsplitscrn» et «xshowsplitscrn». |
| Page0Offs:Word | Déplacement dans la mémoire vidéo de l'écran virtuel principal. Initialement défini par la fonction «xsetmode», mais mis à jour par les fonctions «xsetsplitscrn» et «xsetdoublebuffer». |
| Page1Offs:Word | Déplacement dans la mémoire vidéo du deuxième écran virtuel. Défini par et n'est valide qu'après un appel à «xsetdoublebuffer». |
| ScrnLogicalByteWidth:Word | Largeur de l'écran virtuel en octets. Définie par la fonction «xsetmode». |
| ScrnLogicalPixelWidth:Word | Largeur de l'écran virtuel en pixels. Définie par la fonction «xsetmode». |
| ScrnLogicalHeight:Word | Hauteur de l'écran virtuel en pixels. Définie initialement par la fonction «xsetmode», mais mise à jour par les fonctions «xsetsplitscrn» et «xsetdoublebuffer». |
| MaxScrollX:Word | Position maximale de X pixels de l'écran physique dans l'écran virtuel. Défini par la fonction «xsetmode». |
| MaxScrollY:Word | Position Y maximale de l'écran physique dans l'écran virtuel. Définie initialement par la fonction «xsetmode», mais mise à jour par les fonctions «xsetsplitscrn» et «xsetdoublebuffer». |
| DoubleBufferActive:Word | Indique si la double mise en mémoire tampon est activée. Défini par la fonction «xsetdoublebuffer». |
| VisiblePageIdx:Word | Numéro d'index de la page actuellement visible. Initialement défini par la fonction «xsetdoublebuffer» mais mis à jour par «xpageflip». Cette variable n'est utilisée que lorsque la double mise en mémoire tampon est activée. |
| HiddenPageOffs:Word | Déplacement de la page cachée. Initialement défini par la fonction «xsetdoublebuffer» mais mis à jour par «xpageflip». Cette variable n'est utilisée que lorsque la double mise en mémoire tampon est activée. |
| VisiblePageOffs:Word | Déplacement de la page visible. Initialement défini par la fonction «xsetdoublebuffer» mais mis à jour par «xpageflip». Cette variable n'est utilisée que lorsque la double mise en mémoire tampon est activée. |
| NonVisualOffs:Word | Déplacement du premier octet de la RAM non visuelle, la RAM disponible pour l'entreposage de bitmaps,... Défini initialement par la fonction «xsetmode» mais mis à jour par les fonctions «xsetsplitscrn» et «xsetdoublebuffer». |
| TopClip, BottomClip, LeftClip, RightClip:Word |
Définissez le rectangle de découpage pour les fonctions de découpage de bitmaps linéaires et vidéo. Définissez-le manuellement ou par «xsetcliprect». Remarque : les coordonnées X sont en octets car toutes les fonctions de découpage découpent selon les limites d'octets. |
| PhysicalStartPixelX:Word | Déplacement X pixels de l'écran physique (visible) par rapport au coin supérieur gauche (0,0) de l'écran virtuel. |
| PhysicalStartByteX:Word | Déplacement de X octets de l'écran physique (visible) par rapport au coin supérieur gauche (0,0) de l'écran virtuel. |
| PhysicalStartY:Word | Déplacement des pixels Y de l'écran physique (visible) par rapport au coin supérieur gauche (0,0) de l'écran virtuel. |
Procédures et fonctions exportées
xsetmode
| Function XSetMode(mode,WidthInPixels:Word):Word; |
La définition des paramètres :
| Paramètre | Description |
|---|---|
| mode | Le mode requis tel que défini par l'ensemble des «résolutions disponibles en mode X» définies dans le fichier d'entête xlib.h. |
| WidthInPixels | La largeur d'écran virtuelle requise. |
La valeur de retour :
- La largeur réelle en pixels de l'écran virtuel alloué.
Cette fonction initialise le système graphique, définit la résolution d'écran appropriée et alloue un écran virtuel. L'écran virtuel alloué peut ne pas nécessairement avoir la même taille que celle spécifiée dans le paramètre «WidthInPixels» car il est arrondi au multiple inférieur de 4 le plus proche.
La fonction renvoie la largeur réelle de l'écran virtuel alloué en pixels si un mode valide a été sélectionné, sinon renvoie XMODEINVALID.
Enregistre la largeur en pixels de l'écran virtuel dans «ScrnLogicalPixelWidth». Enregistre la largeur en octets de l'écran virtuel dans «ScrnLogicalByteWidth». Les dimensions physiques de l'écran sont définies dans «ScrnPhysicalPixelWidth». «ScrnPhysicalByteWidth» et «ScrnPhysicalHeight». Les autres variables globales définies sont «CurrXMode», «MaxScrollX», «MaxScrollY», «InGraphics». La variable «SplitScrnScanline» est également initialisée à zéro.
Voir aussi :
- Résolutions disponibles en mode X
- Qu'est-ce que le mode X
xselectdefaultplane
| Procedure XSelectDefaultPlane(plane:Byte); |
Active l'accès en lecture/écriture par défaut à un plan spécifié.
xsetsplitscreen
| Procedure XSetSplitScreen(line:Word); |
La définition des paramètres :
| Paramètre | Description |
|---|---|
| line | La ligne de balayage de départ de l'écran partagé requis. |
Cette fonction active l'écran partagé en mode X et définit la ligne de balayage de départ. L'écran partagé réside dans la moitié inférieure de l'écran et possède une adresse de départ de A000:0000 dans la RAM vidéo.
Elle met également à jour Page0Offs pour refléter l'existence de la région d'écran partagé, c'est-à-dire que «MainScrnOffset» est défini sur le déplacement du premier pixel au-delà de la région d'écran partagé. Les autres variables définies sont «Page1Offs» étant défini sur la même valeur que «Page0Offs» (voir la séquence d'appel graphique ci-dessous), «ScrnLogicalHeight», «ScrnPhysicalHeight», «SplitScrnScanLine» et «MaxScrollY».
Cette fonction ne peut pas être appelée après l'activation de la double mise en mémoire tampon, elle renverra une erreur. Pour configurer votre environnement graphique, la séquence d'appels graphiques est la suivante, bien que l'une ou les deux étapes b et c puissent être omises :
- xsetmode
- xsetsplitscreen
- xsetdoublebuffer
Ainsi, lorsque vous appelez cette fonction avec succès, la double mise en mémoire tampon n'est pas active, donc «Page1Offs» est défini sur la même adresse que «Page0Offs».
AVERTISSEMENT : si vous utilisez l'un des modes haute résolution (376 x 564 comme exemple extrême), vous risquez de ne pas avoir suffisamment de mémoire vidéo pour les options d'écran partagé et de double mise en mémoire tampon, car la mémoire vidéo VGA est limitée à 64 Ko.
Voir aussi :
- Qu'est-ce qu'un écran partagé ?
- Qu'est-ce que la double mise en mémoire tampon ?
xsetdoublebuffer
| Function xsetdoublebuffer(PageHeight:Word):Word; |
La définition des paramètres :
| Paramètre | Description |
|---|---|
| PageHeight | La hauteur des deux écrans virtuels à double tampon. |
La valeur de retour :
- La hauteur la plus proche possible de celle spécifiée.
Cette fonction configure deux pages virtuelles à double tampon. La valeur «ErrorValue» est définie en fonction du succès ou de l'échec de cette commande.
Les autres variables définies sont :
| Variable | Description |
|---|---|
| Page1Offs | Déplacement de la deuxième page virtuelle |
| NonVisualOffs | Déplacement du premier octet de la RAM vidéo non visible |
| DoubleBufferActive | Drapeau d'activation de double tampon |
| PageAddrTable | Tableau des déplacement de début des pages de double mise en mémoire tampon |
| ScrnLogicalHeight | Hauteur logique des pages à double tampon. |
| MaxScrollY | Adresse de démarrage verticale maximale de l'écran physique dans l'écran virtuel |
AVERTISSEMENT : si vous utilisez l'un des modes haute résolution (376 x 564 pixels comme exemple extrême), vous risquez de ne pas disposer de suffisamment de RAM vidéo pour les options d'écran partagé et de double mise en mémoire tampon, car la RAM vidéo VGA est limitée à 64 Ko.
Voir aussi :
- Qu'est-ce que la double mise en mémoire tampon ?
xhidesplitscreen
| Procedure XHideSplitScreen; |
Cette fonction masque un écran partagé existant en définissant sa ligne de balayage de départ sur la dernière ligne de balayage de l'écran physique. "ScreenPhysicalHeight" est ajusté mais "SplitScreenScanLine" n'est pas modifié car il est nécessaire pour restaurer l'écran partagé à un stade ultérieur.
AVERTISSEMENT : À utiliser uniquement si SplitScrnLine a été précédemment appelé Disabled pour le mode 5 à 11 (320x400 à 376x564). La mémoire pour l'écran partagé initial est réservée et les limitations de taille de ces modes signifient que tout changement dans la ligne de balayage de l'écran partagé empiètera sur la mémoire vive de l'écran partagé. Mise à jour : désormais désactivé pour ces modes.
Voir aussi :
- Qu'est-ce qu'un écran partagé ?
xshowsplitscreen
| Procedure XShowSplitScreen; |
Restaure la ligne de balayage de départ de l'écran partagé à la ligne de balayage de départ de l'écran partagé initiale définie par «SplitScrnScanLine». «ScreenPhysicalHeight» est ajusté.
AVERTISSEMENT : À utiliser uniquement si SplitScrnLine a été précédemment appelé Disabled (désactivé) pour le mode 4 à 10 (320x400 à 376x564 pixels). La mémoire pour l'écran partagé initial est réservée et les limitations de taille de ces modes signifient que tout changement dans la ligne de balayage de l'écran partagé empiètera sur la mémoire vive de l'écran partagé.
XAdjustSplitScreen
| Procedure XAdjustSplitScreen(line:Word); |
La définition des paramètres :
| Paramètre | Description |
|---|---|
| line | La ligne de balayage à laquelle l'écran partagé doit démarrer. |
Définit la ligne de balayage de départ de l'écran partagé sur une nouvelle ligne de balayage. Les lignes de balayage valides se situent entre la ligne de balayage de départ de l'écran partagé initial et la dernière ligne de balayage de l'écran physique. "ScreenPhysicalHeight" est également ajusté.
AVERTISSEMENT : À utiliser uniquement si SplitScrnLine a été précédemment appelé Disabled pour le mode 4 à 10 (320x400 à 376x564 pixels). La mémoire pour l'écran partagé initial est réservée et les limitations de taille de ces modes signifient que tout changement dans la ligne de balayage de l'écran partagé empiètera sur la RAM de l'écran partagé.
XSetStartAddr
| Procedure XSetStartAddr(X,Y:Word); |
La définition des paramètres :
| Paramètre | Description |
|---|---|
| X,Y | Coordonnées du coin supérieur gauche de l'écran physique dans l'écran virtuel actuel. |
Définissez l'adresse de démarrage physique de l'écran non partagé en mode X dans la page virtuelle actuelle.
X ne doit pas dépasser (largeur logique de l'écran - largeur physique de l'écran), c'est-à-dire «MaxScrollX» et Y ne doit pas dépasser (hauteur logique de l'écran - hauteur physique de l'écran), c'est-à-dire «MaxScrollY»
XPageFlip
| Procedure XPageFlip(X,Y:Word); |
La définition des paramètres :
| Paramètre | Description |
|---|---|
| X,Y | Coordonnées du coin supérieur gauche de l'écran physique dans l'écran virtuel caché si la double mise en mémoire tampon est active, ou l'écran virtuel actuel dans le cas contraire. |
Définit l'adresse de démarrage de l'écran physique dans la page virtuelle actuellement masquée, puis retourne les pages. Si la double mise en mémoire tampon n'est pas active, cette fonction est fonctionnellement équivalente à «xsetstartaddr».
X ne doit pas dépasser (largeur logique de l'écran - largeur physique de l'écran), c'est-à-dire «MaxScrollX» et Y ne doit pas dépasser (hauteur logique de l'écran - hauteur physique de l'écran), c'est-à-dire «MaxScrollY».
xtextmode
| Procedure xtextmode; |
Désactive le mode graphique.
xsetcliprect
| Procedure xsetcliprect(left, top, right, bottom:Word); |
Définit le rectangle de découpage pour les versions de découpage des bitmaps planaires et vidéo.
Remarque : les bitmaps compilées ne peuvent pas être découpées.
xputpix
| Procedure xputpix(X,Y,PageOffset,Color:Word); |
Dessine un point de couleur spécifiée aux coordonnées X, Y dans la page virtuelle commençant au déplacement PageOffset.
xgetpix
| Function xgetpix(X,Y,PageBase:Word):Word; |
Lire un point de coordonnées X, Y dans la page virtuelle commençant au déplacement PageOffset.
xrectpattern
| Procedure xrectpattern(StartX,StartY,EndX,EndY,PageBase:Word;Var Pattern); |
La définition des paramètres :
| Paramètre | Description |
|---|---|
| StartX,StartY | Coordonnées du coin supérieur gauche du rectangle |
| EndX,EndY | Coordonnées du coin inférieur droit du rectangle |
| PageBase | Déplacement de l'écran virtuel |
| *Pattern | Pointeur vers le modèle défini par l'utilisateur (16 octets) |
Routine de remplissage de motif rectangle 4x4 en mode X.
Le coin supérieur gauche du motif est toujours aligné sur une ligne et une colonne multiples de 4. Fonctionne sur tous les VGA. Utilise l'approche consistant à copier le motif dans la mémoire d'affichage hors écran, puis à charger les verrous avec le motif pour chaque ligne de balayage et à remplir chaque ligne de balayage quatre pixels à la fois. Remplit jusqu'à la colonne à EndX et la ligne à EndY, mais sans les inclure. Aucun découpage n'est effectué.
Cette procédure est basé sur le code publié à l'origine dans DDJ Mag par M. Abrash.
Avertissement : les emplacements de mémoire VGA PATTERNBUFFER (A000:FFFc) à A000:FFFF sont réservés au tampon de motifs.
Voir également :
- Références du Journal du Docteur Dobbs.
xrectpatternclipped
Comme ci-dessus mais coupé.
xcpvidrect
| Procedure xcpvidrect(SourceStartX, SourceStartY, SourceEndX, SourceEndY, DestStartX, DestStartY, SourcePageBase, DestPageBase, SourceBitmapWidth, DestBitmapWidth:Word); |
La définition des paramètres :
| Paramètre | Description |
|---|---|
| StartX,StartY | Coordonnées du coin supérieur gauche du rectangle source. |
| EndX,EndY | Coordonnées du coin inférieur droit du rectangle source. |
| DestStartX,DestStartY | Coordonnées de la destination du rectangle |
| SourcePageBase | Déplacement de page du rectangle source |
| DestPageBase | Déplacement de page des rectangles de destination |
| SourceBitmapWidth | Largeur du bitmap dans l'écran virtuel source contenant le rectangle source. |
| DestBitmapWidth | Largeur du bitmap dans l'écran virtuel de destination contenant le rectangle de destination. |
Mémoire d'affichage en mode X pour afficher la routine de copie de mémoire. Le bord gauche du rectangle source modulo 4 doit être égal au bord gauche du rectangle de destination modulo 4. Fonctionne sur tous les cartes vidéo VGA. Utilise l'approche consistant à lire 4 pixels à la fois de la source dans les verrous, puis à écrire les verrous vers la destination. Copie jusqu'à la colonne à SrcEndX et à la ligne à SrcEndY, mais sans les inclure. Aucun découpage n'est effectué. Les résultats ne sont pas garantis si la source et la destination se chevauchent.
Basé sur le code initialement publié dans DDJ Mag par M. Abrash
Voir également :
- Références du Journal du Docteur Dobbs.
xshiftrect
| Procedure xshiftrect(SrcLeft, SrcTop, SrcRight, SrcBottom, DestLeft, DestTop, ScreenOffs:Word); |
La définition des paramètres :
| Paramètre | Description |
|---|---|
| SrcLeft, SrcTop | Coordonnées du coin supérieur gauche du rectangle |
| SrcRight, SrcBottom | Coordonnées du coin inférieur droit du rectangle |
| DestLeft, DestTop | Coordonnées du coin supérieur gauche de la destination |
| ScreenOffs | Déplacement de l'écran virtuel |
Cette fonction copie un rectangle de VRAM sur une autre zone de VRAM, même si la destination chevauche la source. Elle est conçue pour faire défiler du texte de haut en bas et pour déplacer de grandes zones d'écran dans des systèmes de mosaïque. Elle arrondit toutes les coordonnées horizontales à l'octet le plus proche (morceau de 4 colonnes) pour des raisons de vitesse. Cela signifie qu'elle ne peut pas effectuer de défilement horizontal fluide. Pour cela, faites défiler l'écran entier (moins l'écran partagé) ou copiez des zones plus petites dans la mémoire système à l'aide des fonctions du module XPBITMAP.
SrcRight est arrondi vers le haut et les bords gauches sont arrondis vers le bas, pour garantir que les pixels pointés par les paramètres se trouvent à l'intérieur du rectangle. Autrement dit, SrcRight est traité comme (SrcRight+3) >> 2 et SrcLeft comme SrcLeft >> 2.
La largeur du rectangle en octets (largeur en pixels / 4) ne peut pas dépasser 255.
Fonctions de palette pour les modes de couleurs VGA 256
Toutes les fonctions de ce module fonctionnent sur deux variantes du tampon de palette, les tampons bruts et annotés.
Toutes les fonctions se terminant par «raw» fonctionnent sur la structure de palette suivante :
- r0,g0,b0,r1,g1,b1,...rn,gn,bn:Byte;
La structure ne contient aucune référence à l'index de couleur de départ ou au nombre de couleurs entreposées.
Toutes les fonctions se terminant par «struc» fonctionnent sur la structure de palette suivante :
- c, n, r0,g0,b0,r1,g1,b1,...rn,gn,bn:Byte;
où c est la couleur de départ et n le nombre de couleurs entreposées.
ATTENTION : Il n'y a pas de contrôle de validité dans ces fonctions. Il incombe à l'utilisateur de fournir des paramètres valides aux fonctions.
xgetpalraw
| Procedure xgetpalraw(Var pal;numcolrs, startindex:Word); |
Lire la palette DAC dans le tampon brut avec les interruptions désactivées.
AVERTISSEMENT : la mémoire des tampons de palette doit être entièrement pré-allouée.
xgetpalstruc
| Procedure xgetpalstruc(Var pal, numcolrs, startindex:Word); |
Lire la palette DAC dans un tampon de type annoté avec les interruptions désactivées.
AVERTISSEMENT : la mémoire des tampons de palette doit être entièrement pré-allouée.
xputpalraw
| Procedure xputpalraw(Var pal; numcolrs, startindex:Word); |
Écrire la palette DAC à partir du tampon brut avec les interruptions désactivées.
xputpalstruc
| Procedure xputpalstruc(Var pal); |
Écrire une palette DAC à partir d'un tampon de type annoté avec les interruptions désactivées.
xsetrgb
| Procedure xsetrgb(color, redc, greenc, bluec:Byte); |
Définir les composantes RVB d'une couleur VGA.
xrotpalstruc
| Procedure xrotpalstruc(Var pal; direction:Word); |
Faire pivoter les entrées du tampon de palette annoté.
Direction 0 = vers l'arrière, 1 = vers l'avant.
xrotpalraw
| Procedure xrotpalraw(Var pal; direction, numcolrs:Word); |
Faire pivoter un tampon de palette brute. Direction 0 = vers l'arrière, 1 = vers l'avant.
xputcontrastpalstruc
| Procedure xputcontrastpalstruc(Var pal; intensity:Byte); |
Écrire une palette DAC à partir d'un tampon de type annoté avec un réglage d'intensité spécifié (c'est-à-dire que les entrées de palette sont décrémentées lorsque cela est possible par unités «d'intensité»).
Conçu pour faire apparaître ou disparaître une palette sans utiliser de tampon de palette de travail intermédiaire ! (Lent mais efficace en mémoire... Il est correcte pour les petites structures pal).
xtransposepalstruc
| Procedure xtransposepalstruc(Var pal; StartColor:Word); |
Écrire une palette DAC à partir d'un tampon de type annoté avec les interruptions désactivées à partir d'un nouvel index de palette.
xcpcontrastpalstruc
| Function xcpcontrastpalstruc(Var srcpal, destpal; Intensity:Byte); |
Copiez un tampon de palette annoté vers un autre pour effectuer le réglage de l'intensité. Utilisé pour un fondu entrant et sortant rapide et fluide.
xline
| Procedure xline(x0, y0, x1, y1, color, PageBase:Word); |
Tracez une ligne avec les points d'extrémité spécifiés dans la page en commençant par le déplacement «PageBase».
Aucun découpage n'est effectué.
Les polices de caractères
- Const
- FONT8x8 = 0;
- FONT8x15 = 1;
- FONTUSER = 2;
Variables exportées
Remarque : toutes les variables sont en lecture seulement. Si vous les modifiez, les résultats peuvent être imprévisibles.
| Variable/Type de données | Description |
|---|---|
| CharHeight:Byte | Hauteur de l'ensemble de caractères intégré actuel. |
| CharWidth:Byte | Largeur de l'ensemble de caractères intégré actuel. |
| FirstChar:Byte | Premier caractère de l'ensemble de caractères intégré actuel. |
| UserCharHeight:Byte | Hauteur de l'ensemble de caractères utilisateur actuel. |
| UserCharWidth:Byte | Largeur de l'ensemble de caractères utilisateur actuel. |
| UserFirstCh:Byte | Premier caractère de l'ensemble de caractères de l'utilisateur actuel. |
xtextinit
| Procedure xtextinit; |
Initialise le pilote de texte Mode X et définit la police de caractères par défaut (VGA ROM 8x8).
xsetfont
| Procedure xsetfont(FontId:Word); |
Sélectionnez la police de travail où :
| Valeur | Description |
|---|---|
| 0 | VGA ROM 8x8 |
| 1 | VGA ROM 8x14 |
| 2 | Police de caractères bitmap définie par l'utilisateur. |
AVERTISSEMENT : une police de caractères utilisateur doit être enregistrée avant de définir FontID = 2.
Voir également :
- Constantes de police de caractères.
xregisteruserfont
| Procedure xregisteruserfont(Var UserFontPtr); |
Enregistrez une police de caractères utilisateur pour une sélection ultérieure. Une seule police utilisateur peut être enregistrée à un moment donné. L'enregistrement d'une police de caractères utilisateur annule l'enregistrement de la police de caractères utilisateur précédente. Les polices utilisateur ne peuvent pas dépasser 8 pixels de large.
Structure de police de caractères utilisateur
| Déplacement | Type de données | Description |
|---|---|---|
| 0 | Word | Code ASCII du premier caractère de la police de caractères |
| 2 | Byte | Hauteur des caractères dans la police de caractères |
| 3 | Byte | Largeur des caractères dans la police de caractères |
| 4 | n*h*Byte | Les données de police de caractères où n = nombre de caractères et h = hauteur des caractères |
AVERTISSEMENT : Il incombe au programme de s'assurer que tous les caractères dessinés pendant que cette police est active se trouvent dans l'intervalle de caractères définie.
xputchar
| Function xputchar(ch:Char; X, Y, PgOffs, Color:Word):Word; |
Dessinez un caractère de texte à l'emplacement spécifié avec la couleur spécifiée.
La définition des paramètres :
| Paramètre | Description |
|---|---|
| ch | Caractère à dessiner |
| x,y | Coordonnées de l'écran sur lesquelles dessiner ch |
| ScrnOffs | Déplacement de départ de la page sur laquelle dessiner |
| Color | Couleur du texte |
Renvoie la largeur du caractère.
ATTENTION : InitText doit être appelé avant d'utiliser cette fonction.
xprintf
| Procedure xprintf(x, y, ScrnOffs, color:Word; s:String); |
La définition des paramètres :
| Paramètre | Description |
|---|---|
| x,y | Coordonnées de l'écran sur lesquelles dessiner ch |
| ScrnOffs | Déplacement de départ de la page sur laquelle dessiner |
| Color | Couleur du texte |
| s | Texte à afficher |
xbgprintf
| Procedure xbgprintf(x, y, ScrnOffs, fgcolor, bgcolor:Word; s:String); |
La définition des paramètres :
| Paramètre | Description |
|---|---|
| x,y | Coordonnées de l'écran sur lesquelles dessiner ch |
| ScrnOffs | Déplacement de départ de la page sur laquelle dessiner |
| fgcolor | Couleur du premier plan du texte |
| bgcolor | Couleur de l'arrière-plan du texte |
| s | Chaîne à afficher |
xgetcharwidth
| Function xgetcharwidth(ch:Char):Word; |
La définition des paramètres :
| Paramètre | Description |
|---|---|
| ch | Caractère pour obtenir la largeur de |
Plans Bitmaps
Les bitmaps planaires utilisés par ces fonctions ont la structure suivante :
| Type de données | Déplacement | Description |
|---|---|---|
| Byte | 0 | La largeur du Bitmap en octets (groupes de 4 pixels) est comprise entre 1 et 255 |
| Byte | 1 | La hauteur du bitmap dans la plage de lignes est comprise entre 1 et 255 |
| Byte | 2..n1 | Le plan 0 pixels largeur*hauteur octets |
| Byte | n1..n2 | Le plan 1 pixels largeur * hauteur octets |
| Byte | n2..n3 | Le plan 2 pixels largeur*hauteur octets |
| Byte | n3..n4 | Le plan 3 pixels largeur*hauteur octets |
Ces fonctions fournissent les transferts de bitmap les plus rapides possibles de la mémoire système à la vidéo et, de plus, le bitmap unique est applicable à tous les alignements de pixels. Les fonctions masquées n'ont pas besoin de masques séparés puisque tous les pixels non nuls sont considérés comme des pixels de masquage. Par conséquent, si un pixel est égal à 0, le pixel de destination de l'écran correspondant reste inchangé.
xputmaskedpbm
| Procedure xputmaskedpbm(X, Y, ScrnOffs:Word;Var Bitmap); |
Le masque écrit une image bitmap planaire de la RAM système vers la RAM vidéo. Tous les octets de l'image bitmap source zéro indiquent l'octet de destination à laisser inchangé.
Structure de l'image bitmap source :
Width, Height:byte,
Données de l'image bitmap (plan 0)... Données de l'image bitmap (plan 1)..., Données de l'image bitmap (plan 2)..., Données de l'image bitmap (plan 3)...
Remarque : la largeur est en octets, c'est-à-dire beaucoup de 4 pixels.
Limitations : Aucun découpage n'est pris en charge. Prend uniquement en charge les bitmaps dont la largeur est un multiple de 4 pixels.
Voir Outils Bitmap pour les fonctions de conversion bitmap linéaire <-> planaire.
xputpbm
| Procedure xputpbm(X,Y,ScrnOffs:Word;Var Bitmap); |
Écrire une image de plan de bitmap de la RAM système vers la RAM vidéo.
Structure de l'image bitmap source :
Width:byte, Height:byte,
Données bitmap (plan 0)... Données bitmap (plan 1)..., Données bitmap (plan 2)..., Données bitmap (plan 3)...
Remarque : la largeur est en octets, c'est-à-dire beaucoup de 4 pixels.
Limitations : Aucun découpage n'est pris en charge. Prend uniquement en charge les images bitmap dont la largeur est un multiple de 4 pixels.
Voir Outils Bitmap pour les fonctions de conversion bitmap linéaire <-> planaire.
xgetpbm
| Procedure xgetpbm(X,Y:Word; Bw, Bh:Byte; ScrnOffs:Word;Var Bitmap); |
Lire une image bitmap planaire dans la RAM système à partir de la RAM vidéo.
Structure de l'image bitmap source :
Width:byte, Height:byte, Données bitmap (plan 0)... Données bitmap (plan 1)..., Données bitmap (plan 2)..., Données bitmap (plan 3)...
Remarque : la largeur est en octets, c'est-à-dire beaucoup de 4 pixels.
Limitations : Aucun découpage n'est pris en charge. Prend uniquement en charge les images bitmap dont la largeur est un multiple de 4 pixels.
Plans Bitmaps décapés
Il existe trois variantes des procédures précédentes identifiées par les trois extensions de nom de fonction : clipx, clipy, clipxy. Étant donné que la vitesse est essentielle dans la programmation de jeux, vous ne souhaitez pas vérifier le découpage si ce n'est pas nécessaire. Ainsi, pour les sprites se déplaçant uniquement horizontalement, vous utiliserez la version clipx de la fonction put, pour les sprites se déplaçant verticalement, vous utiliserez la version clipy et pour les sprites se déplaçant dans les deux sens, vous utiliserez la version clipxy. Gardez également à l'esprit que les composantes de découpage de ces fonctions supposent que le rectangle de découpage est égal ou supérieur à la taille de la bitmap, c'est-à-dire que si une bitmap est découpée en haut, il est supposé que le bas de la bitmap n'est pas également découpé. De même pour le découpage horizontal.
Remarque : les performances par ordre décroissant sont les suivantes : clipy, clipx, clipxy, les placements masqués étant plus lents que les placements non masqués.
Le découpage horizontal est effectué sur les limites d'octets (4 pixels) plutôt que sur les pixels. Cela permet l'implémentation la plus rapide des fonctions. Ce n'est pas un tel handicap car, d'une part, la largeur de votre écran est un multiple de 4 pixels et, dans la plupart des cas, ce sont les bords de l'écran formant le rectangle de découpage.
Voici un exemple de définition d'un rectangle de découpage sur les bords logiques de l'écran :
- xsetcliprect(0,0,ScrnLogicalByteWidth,ScrnLogicalHeight);
xputpbmclipx
| Procedure XPutPBMClipX(X, Y, ScrnOffs:Word; Var Bitmap); |
xputpbmclipy
| Procedure XPutPBMClipY(X, Y, ScrnOffs:Word; Var Bitmap); |
xputpbmclipxy
| Procedure XPutPBMClipXY(X, Y,ScrnOffs:Word; Var Bitmap); |
xputmaskedpbmclipx
| Procedure XPutMaskedPBMClipX(X, Y, ScrnOffs:Word;Var Bitmap); |
xputmaskedpbmclipy
| Procedure XPutMaskedPBMClipY(X, Y, ScrnOffs:Word;Var Bitmap); |
xputmaskedpbmclipxy
| Procedure XPutMaskedPBMClipXY(X,Y,ScrnOffs:Word; Var Bitmap); |
Pour une description détaillée des paramètres,..., voir les procédures Plaire Bitmap équivalentes.
Bitmaps compilés
L'entretien et l'alimentation des blits masqués compilés par Matthew MacKenzie.
Les procédures sont dédiées aux bitmaps compilés :
- xcompilebitmap compile votre bitmap en code natif écrivant sur l'écran VGA en mode X.
- xputcbitmap convertit les coordonnées X et Y en un emplacement sur l'écran, configure les registres VGA nécessaires et exécute le bitmap compilé en tant que sous-programme.
- xsizeofcbitmap prend un bitmap planaire et renvoie un entier égal à la taille du bitmap compilé que le bitmap planaire produirait. Il s'agit essentiellement d'une version lobotomisée de xcompilebitmap, avec toute la génération de code remplacée par un compteur de taille.
Xcompilebitmap analyse une image bitmap source et génère des instructions 8086 pour tracer chaque pixel différent de zéro. Il est conçu pour être utilisé avant le début de l'action plutôt qu'à la volée. L'image bitmap compilée ne contient aucune branche et aucune référence aux pixels zéro (transparents). Lorsque deux pixels sont séparés par exactement quatre colonnes, ils sont tracés avec un seul magasin de 16 bits et le registre MAPMASK de VGA sera défini au plus quatre fois. En conséquence, votre image bitmap peut s'exécuter plusieurs fois plus rapidement qu'une routine blit masquée traditionnelle de la mémoire vers VGA.
Il n'existe aucun moyen d'effectuer un découpage sur ces images bitmap ou de tracer un pixel de couleur zéro.
Xcompilebitmap fonctionne avec des images bitmap au format bitmap planaire Xlib standard. Sur une échelle de temps de 60 images par seconde, il est en fait relativement lent. Comme une image bitmap compilée est déplaçable, vous pouvez simplement la sauvegarder sur le disque et ne pas inclure l'image bitmap source dans votre programme.
Le format bitmap source est un tableau d'octets, un peu comme ceci :
- eye : array[0..29] of byte =
- ( 4, 7, { colonnes de quatre octets de large et sept lignes de haut }
- 0, 0, 0, 0, 9, 1, 1, 1, 9, 0, 0, 0, 0, 0, 0, 0,
- 0, 0, 9, 9, 1, 1, 1, 4, 4, 9, 9, 0, 0, 0, 0, 0,
- 0, 9, 9, 1, 2, 0, 0, 4, 4, 1, 9, 9, 0, 0, 0, 0,
- 9, 9, 9, 1, 0, 0, 0, 0, 1, 1, 9, 9, 9, 0, 0, 0,
- 0, 9, 9, 1, 2, 0, 0, 2, 1, 1, 9, 9, 0, 0, 0, 0,
- 0, 0, 9, 9, 1, 1, 1, 1, 1, 9, 9, 0, 0, 0, 0, 0,
- 0, 0, 0, 0, 9, 1, 1, 1, 9, 0, 0, 0, 0, 0, 0, 0 );
Il s'agit en fait d'une image bitmap linéaire, ce qui n'est pas le bon format pour la compilation, mais qui est plus agréable à l'oeil humain. Utilisez les procédures Outils Bitmap pour convertir les images bitmap linéaires en images de plans bitmap, et vice-versa.
Pour compiler cette image pour un mode 360 ??pixels (colonnes de 90 octets) :
Notez que les deux tampons doivent exister au préalable. Étant donné que xcompilebitmap renvoie la taille du code compilé, en octets, vous pouvez immédiatement réaffecter le bitmap à la bonne taille si l'utilisation de xsizeofxbitmap ne vous semble pas pratique (la réaffectation peut même être plus rapide, bien que l'utilisation de la fonction soit plus propre). Les pointeurs sont 32 bits car les bitmaps compilés prennent beaucoup de place : ils se situent à une extrémité du spectre vitesse/mémoire. Une bonne règle empirique consiste à allouer (3,5 x hauteur du tampon x largeur du tampon) + 25 octets (arrondir au chiffre supérieur), puis à réduire votre bitmap lorsque vous découvrez combien d'espace vous avez réellement utilisé.
Étant donné que le bitmap compilé doit tenir dans un segment de mémoire, il ne peut pas contenir plus de 19 000 pixels environ. Cela ne constituera pas une limitation pour la plupart des programmeurs sains d'esprit. Si vous n'êtes pas un programmeur sain d'esprit, essayez de diviser votre image énorme et peu maniable en parties plus petites - vous pouvez utiliser la même image bitmap gigantesque si vous la divisez en tranches horizontales pour la compilation. D'ailleurs, diviser la source de cette façon vous permettra d'utiliser une image bitmap source de plus de 64 Ko, ce qui est une idée encore plus malsaine...
Retournons à nos moutons. Une image bitmap est compilée pour une seule largeur d'écran. Si vous utilisez un écran logique plus grand que votre écran physique, appelez le compilateur d'images bitmap avec la largeur logique - l'important est le nombre d'octets par ligne. Notez que vous n'avez pas besoin d'être en mode graphique pour utiliser cette routine. Cela vous permet de développer et de compiler des images bitmap séparément, avec n'importe quel programme utilitaire que vous pourriez créer.
La fonction finale est xputcbitmap. Pour tracer notre oeil à (99,4), sur la page commençant à l'emplacement 0 :
- xputcbitmap(99, 4, 0, CompiledEye);
Cette fonction dépend de la variable globale ScrnLogicalByteWidth du module XMAIN, devant être le même nombre que le paramètre de colonne que vous avez utilisé pour compiler votre bitmap.
Le module XCBITMAP ne prend en charge que les blits mémoire vers VGA. Xlib comprend également des routines non masquantes pouvant rapidement enregistrer et restaurer l'écran d'arrière-plan derrière votre bitmap, en utilisant des opérations de chaîne rapides.
Ce module fait partie du paquet Xlib et est dans le domaine public.
Le programme DEMO2.C inclus démontre la différence de performance entre les blits masqués bitmap planaires et les blits bitmap compilés.
xcompilepbm
| Procedure XCompilePbm(LogicalWidth:Word;Var bitmap,output); |
xsizeofcpbm
| Function XSizeOfCPbm(LogicalWidth:Word;Var Bitmap):Word; |
Identiques aux précédents, mais ils fonctionnent sur PBM.
Bitmaps vidéo
Les procédures VIDEO BITMAPS implémentent un autre type de bitmap pour compléter les bitmaps planaires et compilés, les bitmaps basés sur la VRAM. Si une voiture à 4 cylindres est analogue aux bitmaps planaires, c'est-à-dire économe en mémoire mais peu performante, et qu'un V8 est analogue aux bitmaps compilés, des gourmands en mémoire qui volent vraiment, alors les bitmaps basés sur la VRAM sont les 6 cylindres aux performances modestes avec une consommation de mémoire acceptable.
Pour résumer leurs arguments de vente, les VBM sont modérément rapides avec une consommation de mémoire raisonnable et, contrairement aux bitmaps compilés, peuvent être coupés. Les inconvénients sont qu'ils sont limités par la quantité de mémoire vive vidéo disponible et qu'ils ont une structure complexe.
Le format de bitmap VRAM est plutôt complexe, composé de composants stockés dans la mémoire vive vidéo et de composants dans la mémoire vive système fonctionnant ensemble. Cette complexité nécessite l'existence d'une fonction de création "xmakevbm" prenant une bitmap linéaire d'entrée et génère le VBM équivalent (VRAM Bit Map).
Structure VBM :
- word 0 Size ; Taille totale de cette structure VBM en octets
- word 1 ImageWidth ; Largeur en octets de l'image (pour tous les alignements)
- word 2 ImageHeight ; Hauteur en lignes de balayage de l'image
-
- word 3 Alignment 0 ImagePtr ; Déplacement dans VidRAM de cette image alignée
- +--word 4 MaskPtr ; Déplacement (dans le DS de cette structure) de
- | . ; masques d'alignement
- | .
- | .
- | word 9 Alignment 3 ImagePtr ; Déplacement dans VidRAM de cette image alignée
- +|--word 10 MaskPtr ; Déplacement (dans le DS de cette structure) de
- || ; masques d'alignement
- ||
- |+->byte 21 (word 11) -------+-- ; Masques d'image pour l'alignement 0
- | . |
- | . |
- | byte 21 + ImageWidth*ImageHeight -----+
- |
- | .
- | . ; (de même pour les alignements 1 - 2)
- | .
- |
- +-->byte 21 + 3*ImageWidth*ImageHeight + 1-+-- ; Masques d'image pour l'alignement 3
- . |
- . |
- byte 21 + 4*(ImageWidth*ImageHeight) --+
-
- .
- .
- ; De même pour les alignements 2 et 3
- .
- .
- byte 21 + 4*(ImageWidth*ImageHeight)
(Et n'oubliez pas les données correspondantes dans la mémoire vidéo)
Vous pouvez constater par vous-même la complexité de ce format bitmap. L'image est entreposée dans la mémoire vidéo dans ses 4 alignements différents avec des pointeurs vers ces alignements dans le VBM. De même, il existe 4 alignements des masques correspondants dans le VBM lui-même (vers la fin). Les octets de masque contiennent les paramètres de plan pour les octets vidéo correspondants afin qu'un déplacement de mémoire puisse déplacer jusqu'à 4 pixels à la fois (selon les paramètres de masque) en utilisant les verrous du VGA, ce qui vous donne théoriquement une amélioration de vitesse de 4x par rapport aux blits conventionnels comme ceux implémentés dans "XPBITMAP". En fait, c'est entre 2 et 3 en raison des frais généraux encourus.
Ces bitmaps sont plus difficiles à entreposer dans des fichiers que les PBM et les CBM, mais toujours possibles avec un peu de travail, alors ne les écartez pas comme étant trop difficiles à utiliser. Considérez attentivement tous les formats bitmap avant de décider lequel utiliser. Il peut même y avoir des situations où une application prudente des trois types serait la plus efficace, c'est-à-dire. bitmaps compilés pour les tuiles d'arrière-plan et le personnage principal du jeu (n'ayant jamais besoin d'être découpés), bitmaps basés sur VRAM pour les personnages les plus fréquemment rencontrés (adversaire, extraterrestre,...) étant découpés lorsqu'ils arrivent et quittent votre emplacement actuel et bitmaps planaires pour les personnages plus petits ou moins fréquemment rencontrés.
xmakevbm
| Function xmakevbm(Var lbm; Var VramStart:Word):Pointer; |
Créez le VBM à partir du bitmap linéaire donné et placez les alignements d'image dans la mémoire vidéo en commençant par le déplacement dans la variable pointée par «VramStart». «VramStart» est ensuite mis à jour pour pointer vers le prochain octet libre de la VRAM (juste après le dernier octet des alignements d'image). En général, vous pointerez «VramStart» vers «NonVisualOffs».
La définition des paramètres :
| Paramètre | Description |
|---|---|
| lbm | Pointeur vers la bitmap linéaire d'entrée |
| VramStart | Pointeur vers la variable contenant le déplacement du premier octet VRAM libre. |
xputmaskedvbm
| extern int xputmaskedvbm(int X, int Y, word ScrnOffs, byte far * VBitmap); |
Dessine une image bitmap basée sur la VRAM à (X, Y) par rapport à l'écran avec le décalage de départ «ScrnOffs».
Renvoie 1 si l'image découpée est entièrement découpée (c'est-à-dire qu'aucune partie n'apparaît à l'écran), sinon renvoie 0.
xputmaskedvbmclipx
| Procedure XPutMaskedVBMClipX(X, Y, ScrnOffs:Word; Var SrcVBM); |
xputmaskedvbmclipy
| Procedure XPutMaskedVBMClipY(X,Y,ScrnOffs:Word;Var SrcVBM); |
xputmaskedvbmclipxy
Versions de découpage de «xputmaskedvbm».
Routines de la souris
Ces procédures implémentent des fonctions de gestion de la souris très basiques. Elles fonctionnent en installant une fonction de gestionnaire d'événements lors de l'initialisation interceptant et traitant ensuite les événements de la souris et met automatiquement à jour les variables d'état telles que la position de la souris et l'état du bouton enfoncé. Elles ne prennent pas en charge toutes les fonctionnalités de :
- Écrans partagés
- Fenêtres défilés
- Fenêtres virtuelles
Cela a été fait principalement pour éviter des entraves inutiles aux performances, car la fonction de gestion de la souris a le potentiel de dégrader les performances.
Les programmes communiquent avec le pilote de la souris comme avec d'autres périphériques, via un vecteur d'interruption 33h. Lors de la génération d'une interruption, le pilote de la souris attend un numéro de fonction dans le registre AX et éventuellement d'autres paramètres dans d'autres registres et renvoie des informations via les registres. Une brève description des fonctions de la souris suit :
| Fonctions | Pilote de souris Microsoft |
|---|---|
| 0 | Initialisation de la souris |
| 1 | Afficher le curseur |
| 2 | Masquer le curseur |
| 3 | Obtenir la position de la souris et l'état des boutons |
| 4 | Définir la position du curseur de la souris |
| 5 | Obtenir des informations sur la pression des boutons |
| 6 | Obtenir des informations sur le bouton de déverrouillage |
| 7 | Définir la position horizontale minimum/maximum |
| 8 | Définir la position verticale minimum/maximum |
| 9 | Définir le bloc de curseur graphique |
| 10 | Définir le curseur de texte |
| 11 | Lire les compteurs de mouvements de la souris |
| 12 | Définir le gestionnaire d'événements |
| 13 | Mode d'émulation du crayon lumineux activé |
| 14 | Mode d'émulation du crayon lumineux désactivé |
| 15 | Définir le rapport Mickey/Pixel de la souris |
| 16 | Cacher le curseur conditionnel |
| 19 | Définir le seuil de double vitesse |
En pratique, seules quelques-unes de ces fonctions sont utilisées et encore moins lorsque l'état de la souris est surveillé par une fonction de gestion d'événements telle que celle utilisée dans ce module.
La chose la plus importante à noter lors de l'utilisation du module de souris est que le gestionnaire d'événements de la souris doit être supprimé avant de quitter le programme. C'est une bonne idée d'avoir une fonction de sortie et d'inclure la ligne "xmouseremove" avec tout autre code de nettoyage avant la sortie.
Variables exportées
| Nom/Type de données | Description |
|---|---|
| MouseInstalled:Word | Indique si le gestionnaire de souris est installé |
| MouseHidden:Word | Indique si le curseur de la souris est masqué |
| MouseButtonStatus:Word | Maintient l'état du bouton de la souris |
| MouseX:Word | Position X actuelle du curseur de la souris |
| MouseY:Word | Position Y actuelle du curseur de la souris |
| MouseFrozen:Word | Interdit les mises à jour de position si TRUE |
| MouseColor:Byte | La couleur des curseurs de la souris |
xmouseinit
| Procedure xmouseinit; |
Initialisez les fonctions du pilote de la souris et installez la fonction de gestionnaire d'événements de la souris. Il s'agit de la première fonction que vous devez appeler avant d'utiliser l'une des fonctions de la souris. Ce code de souris utilise les techniques les plus rapides possibles pour enregistrer et restaurer les arrière-plans de la souris et pour dessiner le curseur de la souris.
AVERTISSEMENT : cette fonction utilise et met à jour «NonVisualOffset» pour allouer la mémoire vidéo à l'arrière-plan de la souris enregistré.
Limitations : aucun découpage n'est pris en charge horizontalement pour le curseur de la souris. Aucune vérification de validité n'est effectuée pour NonVisualOffs.
**AVERTISSEMENT ** : Vous devez masquer ou au moins geler le curseur de la souris pendant le dessin à l'aide de l'une des autres procédures XLIB, car le gestionnaire de la souris peut modifier les paramètres du registre VGA à tout moment. Les paramètres du registre VGA ne sont pas conservés, ce qui entraînera un comportement de dessin imprévisible. Si vous savez que le dessin se produira loin du curseur de la souris, définissez MouseFrozen sur TRUE (1), faites votre dessin puis définissez-le sur FALSE (0). Vous pouvez également appeler «xhidemouse», effectuer votre dessin puis appeler «xshowmouse». Une autre alternative est de désactiver les interruptions pendant le dessin, mais le dessin prend généralement beaucoup de temps et avoir les interruptions désactivées trop longtemps n'est pas une bonne idée.
xdefinemousecursor
| Procedure xdefinemousecursor(Var MouseDef; MouseColor:Byte); |
La définition des paramètres :
| Paramètre | Description |
|---|---|
| MouseDef | Un pointeur vers 14 caractères contenant un masque de bits pour toutes les lignes du curseur. |
| MouseColor | La couleur à utiliser lors du dessin du curseur de la souris. |
Définissez une forme de curseur de souris à utiliser dans les redessins de curseur ultérieurs. XMouse a une taille de curseur de souris câblée de 8 pixels de large sur 14 pixels de haut.
AVERTISSEMENT : cette fonction suppose que MouseDef pointe sur 14 octets.
Remarque : l'ordre des bits est inversé. Par exemple, le bit 7 représente le pixel 0 ... le bit 0 représente le pixel 7 dans chaque octet «MouseDef».
xshowmouse
| Procedure xshowmouse; |
Rend le curseur visible s'il était précédemment masqué.
Voir aussi : «xhidemouse».
xhidemouse
| Procedure xhidemouse; |
Rend le curseur masqué s'il était précédemment visible.
Voir aussi : «xshowmouse».
xmouseremove
| Procedure xmouseremove; |
Arrêtez la gestion des événements de la souris et supprimez le gestionnaire de souris.
Remarque : cette fonction DOIT être appelée avant de quitter le programme si un gestionnaire de souris a été installé.
xpositionmouse
| Procedure xpositionmouse(x,y:Integer); |
Positionne le curseur de la souris à l'emplacement spécifié.
xmousewindow
| Procedure xmousewindow(x0, y0, x1, y1:Integer); |
Définit une fenêtre de souris.
xupdatemouse
| Procedure xupdatemouse; |
Force la mise à jour de la position de la souris et le redessin du curseur. Remarque : cette fonction est utile lorsque vous avez défini «MouseFrozen» sur true. Permet à la position du curseur d'être mise à jour manuellement plutôt qu'automatiquement par le gestionnaire installé.
Outils Bitmap
xpbmtobm
| Procedure xpbmtobm(Var sourcepbm, destbm); |
Cette fonction convertit une image bitmap au format planaire au format linéaire utilisé par xcompilebitmap.
AVERTISSEMENT : les images bitmap source et destination doivent être pré-allouées.
Remarque : cette fonction ne peut convertir que les images bitmap planaires qui conviennent. Si la largeur de l'image bitmap planaire source (par plan) est >= 256/4, elle ne peut pas être convertie.
xbmtopbm
| Procedure xbmtopbm(Var sourcepbm, destbm); |
Cette fonction convertit une image bitmap au format linéaire tel qu'utilisé par xcompilebitmap au format planaire.
AVERTISSEMENT : les images bitmap source et destination doivent être pré-allouées.
Remarque : cette fonction ne peut convertir que les images bitmap linéaires qui conviennent. Si la largeur de l'image bitmap linéaire source n'est pas un multiple de 4, elle ne peut pas être convertie.
Routines en cercle
«Wheel Have to See About That» par Matthew MacKenzie.
Les procédures de cercle sont :
- xcircle, curieusement, dessine un cercle.
- xfilledcircle le fait aussi, seul le cercle est rempli (dans certaines bibliothèques, cela s'appelle un disque).
Le mot «cercle» ici fait référence à une chose ronde ayant autant de pixels de haut que de large. Cela ne ressemble à un cercle qu'en mode 320x240 pixels - le mode X d'origine - et en mode 376x282 pixels.
Dans les deux procédures, le cercle est spécifié par les coordonnées du coin supérieur gauche de la plus petite boîte qui le contient, et le diamètre. Certaines fonctions de cercle vous demandent de spécifier un point central; ce système est un peu étrange car un cercle avec un diamètre pair n'a pas de pixel particulier pour centre. Chaque cercle, en revanche, a une boîte avec un coin supérieur gauche.
Aucune limite n'est vérifiée. Un diamètre de zéro ne dessinera rien, et un diamètre négatif fera exploser votre carte vidéo VGA en centaines de milliers de minuscules petits fragments fumants. Aucune des deux fonctions ne prend en charge le découpage.
Le calcul du cercle est basé sur un algorithme décrit par Michael P. Lindner dans une lettre à l'éditeur à la page 8 du Dr. Dobb's Journal #169 (octobre 1990). L'algorithme a été réorganisé pour permettre de dessiner et de déplacer les tracés dans les huit octants en une seule étape, de sorte que chaque pixel n'a pas besoin d'être chargé deux fois dans le processeur. xfilledcircle ne tire pas parti de cette optimisation car il gère différentes parties de chaque tracé à des moments différents.
xcircle
| Procedure xcircle(Left,Top, Diameter, Color, ScreenOffs:Word); |
Dessine un cercle avec le coin supérieur gauche et le diamètre donnés, qui sont donnés en pixels.
xfilledcircle
| Procedure xfilledcircle(Left, Top, Diameter, Color, ScreenOffs:Word); |
Dessine un cercle rempli avec le coin supérieur gauche et le diamètre donnés.
Routines polygonales
xtriangle
| Procedure xtriangle(x0, y0, x1, y1, x2, y2, color, PageBase:Word); |
Cette procédure dessine un triangle rempli étant découpé selon la fenêtre de découpage actuelle définie par TopClip, BottomClip, LeftClip, RightClip. N'oubliez pas : la variable de découpage X est en octets et non en pixels, vous ne pouvez donc découper que sur des limites de 4 pixels.
xpolygon
| Procedure xpolygon(Var vertices; numvertices, color, PageBase:Word); |
Cette procédure est similaire à la fonction triangle mais dessine des polygones convexes. Les sommets sont fournis sous la forme d'un pointeur FAR.
Remarque : un polygone convexe est un polygone tel que si vous tracez une ligne à partir de deux sommets quelconques, chaque point de cette ligne sera à l'intérieur du polygone.
Cette procédure fonctionne en divisant un polygone en ses triangles composants et en appelant la routine triangle ci-dessus pour dessiner chacun d'eux. Les performances sont respectables, mais une routine polygonale personnalisée pourrait être plus rapide.
Section de référence
Selon l'auteur de XLib, Themie Gouthas, le Doctor Dobbs Journal est le meilleur ouvrage de référence pour les graphiques VGA en mode X :
- Numéro 178 juillet 1991 : Première référence au mode X : Résumé de l'article : Le mode X non documenté de VGA prend en charge le retournement de page, rend la mémoire hors écran disponible, possède des pixels carrés et augmente les performances jusqu'à 4 fois.
- Numéro 179 août 1991 : Suite : Résumé de l'article : Michael discute des verrous et du mode X non documenté de VGA.
- Numéro 181 septembre 1991 : Suite : Résumé de l'article : Michael met en pratique l'animation en utilisant les 256 couleurs de VGA.
- Numéro 184 octobre 1991 : Premier d'une série continue couvrant l'animation 3D en utilisant le mode X de VGA. Cette série est toujours en cours (octobre 1992).
- Résumé de l'article : Michael se lance dans l'animation 3D, en commençant par les remplissages de polygones de base et les retournements de page.
Qu'est-ce que le mode X ?
Le mode X est un dérivé du mode standard 13h du VGA (320x200 256 couleurs). Il s'agit d'une famille de modes vidéo non documentés qui sont créés en modifiant les registres du VGA. La beauté du mode X est qu'il offre plusieurs avantages au programmeur :
- Plusieurs pages graphiques là où le mode 13h ne le permet pas, permettant le retournement de page (également connu sous le nom de double tampon) et l'entreposage des images et des données dans la mémoire vidéo hors écran.
- Une organisation de la mémoire vidéo plane qui, bien que plus difficile à programmer, permet au matériel orienté plan du VGA d'être utilisé pour traiter les pixels en parallèle, améliorant ainsi les performances jusqu'à 4 fois par rapport au mode 13h.
Voir le numéro 178-179 de D.D.J. pour une description complète du mode X du VGA.
Qu'est-ce qu'un écran partagé ?
Un écran partagé est une fonctionnalité matérielle intéressante offerte par les cartes vidéo EGA et VGA. Un écran partagé est un mode de fonctionnement graphique dans lequel le matériel divise l'écran graphique visuel horizontalement et traite les deux moitiés comme des écrans individuels, chacun commençant à des emplacements différents dans la RAM vidéo.
La moitié inférieure (qui est généralement appelée écran partagé) commence toujours à l'adresse A000:0000 mais l'adresse de départ de la moitié supérieure est définissable par l'utilisateur.
L'application la plus courante des écrans partagés dans les jeux est l'affichage de l'état dans les jeux à défilement. Les écrans partagés rendent ce type de jeu plus simple à programmer car lorsque la fenêtre de la moitié supérieure défile, le programmeur n'a pas à se soucier de redessiner la moitié inférieure.
Qu'est-ce que le double tamporisateur ?
Le double tamporisateur (également connu sous le nom de page flipping) est la technique la plus souvent utilisée pour faire de l'animation. Elle nécessite un matériel capable d'afficher plusieurs pages graphiques (ou au moins 2). L'animation est réalisée en dessinant une image sur l'écran non visible, puis en affichant l'écran non visible. Une fois la page retournée, le processus recommence. L'image suivante de l'animation est dessinée sur l'écran non visible, la page est à nouveau retournée,...
Qu'est-ce que la triple mise en mémoire tampon ?
La triple mise en mémoire tampon est similaire à la double mise en mémoire tampon à bien des égards, mais elle repose sur la définition de 3 pages pour l'animation. Le principal paramètre de vente de la triple mise en mémoire tampon est qu'elle élimine le besoin d'attendre que le retour vertical retourne les pages avant de dessiner sur la nouvelle page, ce qui permet au programmeur de commencer à créer la prochaine image d'animation immédiatement après avoir terminé la page en cours. Voici comment cela fonctionne p;:
Avec la double mise en mémoire tampon, une fois que vous avez terminé de dessiner la page cachée et que vous êtes prêt à retourner les pages, vous devez attendre que le matériel VGA retourne réellement la page (pendant le retour vertical) avant de commencer à dessiner la page suivante, sinon vous dessinerez sur la page visible.
Avec la triple mise en mémoire tampon, vous parcourez trois pages, ce qui garantit que la page sur laquelle vous dessinez ne sera pas visible.
La triple mise en mémoire tampon peut permettre l'animation la plus rapide possible dans les bonnes conditions, mais l'inconvénient est qu'elle nécessite plus de RAM vidéo. Si vous souhaitez stocker des bitmaps dans la RAM vidéo, comme des tuiles d'arrière-plan, la double mise en mémoire tampon serait la meilleure alternative.