diff --git a/Anciens fichiers/divers.asm b/Anciens fichiers/divers.asm deleted file mode 100644 index 9dc32bb9..00000000 --- a/Anciens fichiers/divers.asm +++ /dev/null @@ -1,3962 +0,0 @@ -; Grafx2 - The Ultimate 256-color bitmap paint program -; -; Copyright 1996-2001 Sunset Design (Guillaume Dorme & Karl Maritaud) -; -; Grafx2 is free software; you can redistribute it and/or -; modify it under the terms of the GNU General Public License -; as published by the Free Software Foundation; version 2 -; of the License. -; -; Grafx2 is distributed in the hope that it will be useful, -; but WITHOUT ANY WARRANTY; without even the implied warranty of -; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -; GNU General Public License for more details. -; -; You should have received a copy of the GNU General Public License -; along with Grafx2; if not, see or -; write to the Free Software Foundation, Inc., -; 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -MC_POUR_P2=0 - -.386P -.MODEL FLAT - -_TEXT Segment dword public 'code' - Assume cs:_TEXT, ds:_DATA - -public Effacer_ecran_courant -public Copier_image_dans_brosse -public Permuter_dans_l_image_les_couleurs -public Remap_general_LOWLEVEL -public Scroll_picture -public Clavier_americain -public Clavier_de_depart -public Recuperer_nb_lignes -public Passer_en_mode_texte -public Detection_souris -public Get_input -public Set_mouse_position -public Clip_mouse -public Sensibilite_souris -public Attendre_fin_de_click -public Set_color -public Set_palette -public Palette_64_to_256 -public Palette_256_to_64 -public Effacer_image_courante -public Effacer_image_courante_Stencil -public Wait_VBL -public Tempo_jauge -public Round_div -public Palette_Compter_nb_couleurs_utilisees -public Get_key -public Pixel_dans_ecran_courant -public Lit_pixel_dans_ecran_courant -public Lit_pixel_dans_ecran_brouillon -public Lit_pixel_dans_ecran_backup -public Lit_pixel_dans_ecran_feedback -public Pixel_dans_brosse -public Lit_pixel_dans_brosse -public Freespace -public Type_de_lecteur_de_disquette -public Disk_map -public Disque_dur_present -public Lecteur_CDROM_present -public Ellipse_Calculer_limites -public Pixel_dans_ellipse -public Pixel_dans_cercle -public Bit -public Couleur_ILBM_line -public Initialiser_chrono -public Tester_chrono -public Remplacer_une_couleur -public Remplacer_toutes_les_couleurs_dans_limites -public Meilleure_couleur -public Meilleure_couleur_sans_exclusion -public Effet_Colorize_interpole -public Effet_Colorize_additif -public Effet_Colorize_soustractif -public Effet_Trame -public Flip_X_LOWLEVEL -public Flip_Y_LOWLEVEL -public Rotate_90_deg_LOWLEVEL -public Rotate_180_deg_LOWLEVEL -public Zoomer_une_ligne -public Copier_une_partie_d_image_dans_une_autre - - -extrn Ecran_backup :dword -extrn Largeur_ecran :word -extrn Hauteur_ecran :word -extrn Forcer_affichage_curseur :byte -extrn Afficher_curseur :near -extrn Effacer_curseur :near -extrn Calculer_coordonnees_pinceau:near -extrn Principal_Palette :dataptr -extrn Exclude_color :dataptr - -; Données pour le colorize - -extrn Table_de_multiplication_par_Facteur_A:dataptr -extrn Table_de_multiplication_par_Facteur_B:dataptr -extrn FX_Feedback_Ecran:dword - -; Données pour les trames - -extrn Trame:dataptr ; Sprite de la trame -extrn Trame_Largeur:word ; Largeur de la trame -extrn Trame_Hauteur:word ; Hauteur de la trame - -; Données sur l'image - -extrn Principal_Ecran :dword -extrn Principal_Image_modifiee :byte -extrn Principal_Largeur_image :word -extrn Principal_Hauteur_image :word - -extrn Principal_Split :word -extrn Principal_X_Zoom :word -extrn Loupe_Mode:byte - -extrn Limite_Haut :word -extrn Limite_Bas :word -extrn Limite_Gauche :word -extrn Limite_Droite :word - -; Données sur le brouillon - -extrn Brouillon_Ecran :dword -extrn Brouillon_Largeur_image :word -extrn Brouillon_Hauteur_image :word - -; Données sur la brosse - -extrn Brosse :dword -extrn Brosse_Largeur :word -extrn Brosse_Hauteur :word - -; Données sur le menu - -extrn Menu_Ordonnee:word - -; Données sur la souris - -extrn Mouse_X:word -extrn Mouse_Y:word -extrn Mouse_K:byte -extrn INPUT_Nouveau_Mouse_X:word -extrn INPUT_Nouveau_Mouse_Y:word -extrn INPUT_Nouveau_Mouse_K:byte -extrn Mouse_Facteur_de_correction_X:byte -extrn Mouse_Facteur_de_correction_Y:byte - -extrn Operation_Taille_pile:byte -extrn Operation_en_cours:word -extrn Operation_dans_loupe:byte - -; Données sur les touches - -extrn Touche :word -extrn Touche_ASCII :byte -extrn Config_Touche :dword -extrn INPUT_Keyb_mode:byte - -extrn Autoriser_changement_de_couleur_pendant_operation:byte - -; Données sur les ellipses et les cercles: - -extrn Table_des_carres :dataptr -extrn Ellipse_Curseur_X :dword -extrn Ellipse_Curseur_Y :dword -extrn Ellipse_Rayon_vertical_au_carre :dword -extrn Ellipse_Rayon_horizontal_au_carre:dword -extrn Ellipse_Limite_High :dword -extrn Ellipse_Limite_Low :dword -extrn Cercle_Curseur_X :dword -extrn Cercle_Curseur_Y :dword -extrn Cercle_Limite :dword - -extrn LBM_Buffer:dataptr -extrn HBPm1 :byte - -extrn MODE_X_Valeur_initiale_de_esi:dword ; Variables de travail (aucun -extrn MODE_X_Valeur_initiale_de_edi:dword ; rapport avec leurs noms !!) - -extrn MC_Indice:dword ; pour indexer la table d'exclusion -extrn MC_Table_differences:dword ; Table précalculée des différences -extrn MC_DR:dword -extrn MC_DV:dword -extrn MC_DB:dword - -extrn Etat_chrono :byte -extrn Chrono_cmp :dword -extrn Chrono_delay:dword - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - - -; -- Néttoyer l'écran courant -- - -Effacer_ecran_courant proc near - - push edi - - mov edi,Principal_Ecran - - xor eax,eax - xor ecx,ecx - mov ax,Principal_Largeur_image - mov cx,Principal_Hauteur_image - mul ecx - mov ecx,eax - xor eax,eax - - ; On efface ECX pixels: - shr ecx,1 - jnc Effacer_ecran_courant_Longueur_multiple_de_2 - stosb - Effacer_ecran_courant_Longueur_multiple_de_2: - shr ecx,1 - jnc Effacer_ecran_courant_Longueur_multiple_de_4 - stosw - Effacer_ecran_courant_Longueur_multiple_de_4: - rep stosd - - pop edi - - ret - -Effacer_ecran_courant endp - - - -; -- Copier une partie de l'image dans la brosse -- - -Copier_image_dans_brosse proc near - - push ebp - mov ebp,esp - - arg Debut_X:word,Debut_Y:word,Largeur:word,Hauteur:word,Largeur_image:word - - push ebx - push esi - push edi - - - ; On place dans ESI l'adresse de départ de l'image: - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Debut_Y - mov bx,Largeur_image - mov cx,Debut_X - mul ebx - mov esi,Principal_Ecran - add eax,ecx - add esi,eax - - ; On place dans EDI l'adresse de départ de la brosse: - mov edi,Brosse - - ; On place dans EAX la distance entre la fin d'une ligne de l'image et le - ; début de la suivante: - xor eax,eax - mov ax,Largeur_image - sub ax,Largeur - - ; On place dans DX le nombre de lignes à copier: - mov dx,Hauteur - - xor ecx,ecx - Copier_image_dans_brosse_Pour_chaque_ligne: - - ; On met dans CX le nombre de pixels à copier sur la ligne: - mov cx,Largeur - - ; On recopie CX fois les pixels: - shr cx,1 - jnc Copier_image_dans_brosse_Largeur_multiple_de_2 - movsb - Copier_image_dans_brosse_Largeur_multiple_de_2: - shr cx,1 - jnc Copier_image_dans_brosse_Largeur_multiple_de_4 - movsw - Copier_image_dans_brosse_Largeur_multiple_de_4: - rep movsd - - ; On rajoute à ESI la distance EAX - add esi,eax - - ; On passe à la ligne suivante s'il y en a une: - dec dx - jnz Copier_image_dans_brosse_Pour_chaque_ligne - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Copier_image_dans_brosse endp - - - - -; -- Permuter deux couleurs dans l'image -- - -Permuter_dans_l_image_les_couleurs proc near - - push ebp - mov ebp,esp - - arg Couleur_1:byte,Couleur_2:byte - - push ebx - - - ; On place dans EBX l'adresse du début de l'image - mov ebx,Principal_Ecran - - ; On place dans ECX le nb de pixels à traiter - xor eax,eax - xor ecx,ecx - mov ax,Principal_Largeur_image - mov cx,Principal_Hauteur_image - mul ecx - mov ecx,eax - - ; On place dans DL la 1ère couleur à échanger - mov dl,Couleur_1 - - ; On place dans DH la 2ème couleur à échanger - mov dh,Couleur_2 - - Permuter_dans_l_image_les_couleurs_Pour_chaque_pixel: - - ; On lit la couleur du pixel en cours: - mov al,[ebx] - - ; Si le pixel est de Couleur_1 - cmp al,dl - jne Permuter_dans_l_image_les_couleurs_Test_1 - ; On le met en Couleur_2 - mov [ebx],dh - jmp Permuter_dans_l_image_les_couleurs_Fin_des_tests - Permuter_dans_l_image_les_couleurs_Test_1: - - ; Si le pixel est de Couleur_2 - cmp al,dh - jne Permuter_dans_l_image_les_couleurs_Fin_des_tests - ; On le met en Couleur_1 - mov [ebx],dl - Permuter_dans_l_image_les_couleurs_Fin_des_tests: - - - ; On passe au pixel suivant: - dec ecx - jnz Permuter_dans_l_image_les_couleurs_Pour_chaque_pixel - - - pop ebx - - mov esp,ebp - pop ebp - - ret - -Permuter_dans_l_image_les_couleurs endp - - - -; -- Remplacer une couleur par une autre dans un buffer -- - -Remap_general_LOWLEVEL proc near - - push ebp - mov ebp,esp - - arg Tab_conv:dword,Buffer:dword,Largeur:word,Hauteur:word,Largeur_buf:word - - push ebx - push edi - push esi - - - xor esi,esi - - ; On place dans EBX l'adresse de la table de conversion - mov ebx,Tab_conv - - ; On place dans EDI l'adresse du début de l'image - mov edi,Buffer - - ; On place dans ESI la distance qu'il y a entre la fin d'une ligne de - ; l'image et le début de la suivante: - mov si,Largeur_buf - xor eax,eax ; Ces deux initialisations sont faites ici pour éviter - mov dx,Hauteur ; une pénalité sur la modificatione de SI - sub si,Largeur - - Remap_general_Pour_chaque_ligne: - - mov cx,Largeur - Remap_general_Pour_chaque_pixel: - - ; On lit la couleur du pixel en cours: - mov al,[edi] - ; On fait la conversion de la couleur à l'aide de la table de conversion - mov al,[ebx+eax] - ; On replace la nouvelle couleur à l'emplacement en cours - mov [edi],al - - ; On passe au pixel suivant: - inc edi - dec cx - jnz Remap_general_Pour_chaque_pixel - - ; On passe à la ligne suivante: - add edi,esi - dec dx - jnz Remap_general_Pour_chaque_ligne - - - pop esi - pop edi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Remap_general_LOWLEVEL endp - - - -Scroll_picture proc near - - push ebp - mov ebp,esp - - arg Decalage_X:word,Decalage_Y:word - - push ebx - push esi - push edi - - - ; On place dans ESI l'adresse du backup, qui sera la source de la copie - mov esi,Ecran_backup - - ; On place dans EDI l'adresse de Principal_Ecran[Decalage_Y][Decalage_X] - mov edi,Principal_Ecran - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Decalage_Y - mov bx,Principal_Largeur_image ; EBX contient la largeur de l'image - mov cx,Decalage_X ; ECX contient le Decalage_X - mul ebx - add edi,eax - add edi,ecx - - ; On place dans AX le nb de pixels à copier à la droite de - ; (Decalage_X,Decalage_Y) - mov ax,bx - sub ax,cx - - ; On place dans DX le nb de lignes à copier sous (Decalage_X,Decalage_Y) - mov dx,Principal_Hauteur_image - sub dx,Decalage_Y - jz Scroll_picture_Fin_de_traitement_Bas - - Scroll_picture_Pour_chaque_ligne_Bas: - - ; On place dans CX le nb de pixels à copier - mov cx,ax - - ; On fait une copier 32 bits de CX pixels de ESI vers EDI - shr cx,1 - jnc Scroll_picture_Bas_Droite_Multiple_de_2 - movsb - Scroll_picture_Bas_Droite_Multiple_de_2: - shr cx,1 - jnc Scroll_picture_Bas_Droite_Multiple_de_4 - movsw - Scroll_picture_Bas_Droite_Multiple_de_4: - rep movsd - - ; On replace EDI en tout début de ligne - sub edi,ebx - - ; On place dans CX le nb de pixels à copier - mov cx,Decalage_X - - ; On fait une copier 32 bits de CX pixels de ESI vers EDI - shr cx,1 - jnc Scroll_picture_Bas_Gauche_Multiple_de_2 - movsb - Scroll_picture_Bas_Gauche_Multiple_de_2: - shr cx,1 - jnc Scroll_picture_Bas_Gauche_Multiple_de_4 - movsw - Scroll_picture_Bas_Gauche_Multiple_de_4: - rep movsd - - ; On passe à la ligne suivante -;; add esi,ebx - add edi,ebx - dec dx - jnz Scroll_picture_Pour_chaque_ligne_Bas - - Scroll_picture_Fin_de_traitement_Bas: - - ; On vient de faire le traitement pour toutes les lignes placées sous - ; Decalage_Y. On va maintenant s'occuper de la partie au-dessus. - - ; On place dans EDI l'adresse de Principal_Ecran[0][Decalage_X] - movzx edi,Decalage_X - add edi,Principal_Ecran - - ; On place dans DX le nb de lignes à copier au-dessus de - ; (Decalage_X,Decalage_Y) - mov dx,Decalage_Y - cmp dx,0 - je Scroll_picture_Fin_de_traitement_Haut - - Scroll_picture_Pour_chaque_ligne_Haut: - - ; On place dans CX le nb de pixels à copier - mov cx,ax - - ; On fait une copier 32 bits de CX pixels de ESI vers EDI - shr cx,1 - jnc Scroll_picture_Haut_Droite_Multiple_de_2 - movsb - Scroll_picture_Haut_Droite_Multiple_de_2: - shr cx,1 - jnc Scroll_picture_Haut_Droite_Multiple_de_4 - movsw - Scroll_picture_Haut_Droite_Multiple_de_4: - rep movsd - - ; On replace EDI en tout début de ligne - sub edi,ebx - - ; On place dans CX le nb de pixels à copier - mov cx,Decalage_X - - ; On fait une copier 32 bits de CX pixels de ESI vers EDI - shr cx,1 - jnc Scroll_picture_Haut_Gauche_Multiple_de_2 - movsb - Scroll_picture_Haut_Gauche_Multiple_de_2: - shr cx,1 - jnc Scroll_picture_Haut_Gauche_Multiple_de_4 - movsw - Scroll_picture_Haut_Gauche_Multiple_de_4: - rep movsd - - ; On passe à la ligne suivante -;; add esi,ebx - add edi,ebx - dec dx - jnz Scroll_picture_Pour_chaque_ligne_Haut - - Scroll_picture_Fin_de_traitement_Haut: - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Scroll_picture endp - - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; ---- Gestion du mode texte pour pouvoir repasser dans le mode d'origine ---- - -; -- Récupérer les informations du mode texte initial -- -Recuperer_nb_lignes proc near - - pushad - - mov ax,1130h - xor bh,bh - push es - int 10h - pop es - inc dl - mov [esp+28],dl - - popad - - ret - -Recuperer_nb_lignes endp - - -; -- Passer dans un mode texte 25 ou 50 lignes -- -Passer_en_mode_texte proc near - - push ebp - mov ebp,esp - - arg Nb_lignes:byte - - push ax - push bx - push dx - - mov ax,3 - int 10h - cmp Nb_lignes,50 - jne pas_mode_50 - mov ax,1112h - xor bl,bl - mov dl,50 - int 10h - pas_mode_50: - - pop dx - pop bx - pop ax - - mov esp,ebp - pop ebp - - ret - -Passer_en_mode_texte endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; ----------------------- Passer en clavier américain ------------------------ - -Clavier_americain proc near - - push ax - push bx - - mov ax,0AD83h - int 2Fh - mov INPUT_Keyb_mode,bl - mov ax,0AD82h - xor bl,bl - int 2Fh - - pop bx - pop ax - - ret - -Clavier_americain endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; -------------------- Repasser dans le clavier de départ -------------------- - -Clavier_de_depart proc near - - push ax - push bx - - mov ax,0AD82h - mov bl,INPUT_Keyb_mode - int 2Fh - - pop bx - pop ax - - ret - -Clavier_de_depart endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; ---------------- Détection de la présence d'un driver souris --------------- - -Detection_souris proc near - - push bx - - xor ax,ax - int 33h - - pop bx - - ret - -Detection_souris endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; ------- Récupération des entrées de l'utilisateur (souris/clavier) --------- - -Get_input proc near - - pushad - - - ; Gestion de la souris: - - ; Appel à l'interruption pour connaître les nouvelles coordonnées: - - mov ax,0003h - int 33h - - ; CX = Position X - ; DX = Position Y - ; BL = Etat des boutons - - ; Dans le cas où les 2 boutons sont enfoncés... - - cmp bl,3 - jb Get_input_Saut_inhibe_2_boutons - - ; ... on n'en considère aucun: - - xor bl,bl - - Get_input_Saut_inhibe_2_boutons: - - ; On transfère dans les variables les nouvelles valeurs: - - mov ax,cx - mov cl,Mouse_Facteur_de_correction_X - shr ax,cl - mov cl,Mouse_Facteur_de_correction_Y - shr dx,cl - mov INPUT_Nouveau_Mouse_X,ax - mov INPUT_Nouveau_Mouse_Y,dx - mov INPUT_Nouveau_Mouse_K,bl - - - ; Gestion des touches: - - ; Par défaut -> pas de touches enfoncées - - mov Touche,0 - mov Touche_ASCII,0 - - ; Appel à l'interruption pour savoir si une touche est appuyée - - mov ah,11h - int 16h - - ; ZERO -> Pas de touche - - ; S'il n'y en a pas, on se contente de la valeur par défaut et on sort - - jz Get_input_Pas_de_touche - - ; Sinon, appel à l'interruption pour connaître son scancode - - mov ah,10h - int 16h - - ; AH = Scancode - ; AL = Caractère ASCII - - ; On place le scan code dans la partie basse de [Touche] - - mov byte ptr[Touche],ah - mov Touche_ASCII,al ; ... et le code ASCII dans Touche_ASCII - - ; Appel à l'interruption pour connaitre l'état des touches de contrôle - - mov ah,02h - int 16h - - ; AL = Etat des touches de contrôle - - - ; On oublie les informations sur Insert, CapsLock, NumLock et ScrollLock - - and al,00001111b - - ; On associe les deux Shifts (2 bits de poids faible) - - mov ah,al - and ah,00000001b - shr al,1 - or al,ah - - ; On met le resultat dans la partie haute de [Touche] - - mov byte ptr[Touche+1],al - - - ; On gère le cas où [Touche] est un déplacement du curseur - - mov ax,Touche - - ; Test [Touche] = Emulation de MOUSE UP - - cmp ax,word ptr[Config_Touche] - jne Get_input_Pas_emulation_Haut - - cmp INPUT_Nouveau_Mouse_Y,0 - je Get_input_Pas_de_touche - - dec INPUT_Nouveau_Mouse_Y - - jmp Get_input_Fin_emulation - - Get_input_Pas_emulation_Haut: - - ; Test [Touche] = Emulation de MOUSE DOWN - - cmp ax,word ptr[Config_Touche+2] - jne Get_input_Pas_emulation_Bas - - mov ax,INPUT_Nouveau_Mouse_Y - mov bx,Hauteur_ecran - dec bx - cmp ax,bx - jae Get_input_Pas_de_touche - - inc ax - mov INPUT_Nouveau_Mouse_Y,ax - - jmp Get_input_Fin_emulation - - Get_input_Pas_emulation_Bas: - - ; Test [Touche] = Emulation de MOUSE LEFT - - cmp ax,word ptr[Config_Touche+4] - jne Get_input_Pas_emulation_Gauche - - cmp INPUT_Nouveau_Mouse_X,0 - je Get_input_Pas_de_touche - - dec INPUT_Nouveau_Mouse_X - - jmp Get_input_Fin_emulation - - Get_input_Pas_emulation_Gauche: - - ; Test [Touche] = Emulation de MOUSE RIGHT - - cmp ax,word ptr[Config_Touche+6] - jne Get_input_Pas_emulation_Droite - - mov ax,INPUT_Nouveau_Mouse_X - mov bx,Largeur_ecran - dec bx - cmp ax,bx - jae Get_input_Pas_de_touche - - inc ax - mov INPUT_Nouveau_Mouse_X,ax - jmp Get_input_Fin_emulation - - Get_input_Pas_emulation_Droite: - - ; Test [Touche] = Emulation de MOUSE CLICK LEFT - - cmp ax,word ptr[Config_Touche+8] - jne Get_input_Pas_emulation_Click_gauche - - mov INPUT_Nouveau_Mouse_K,1 - jmp Get_input_Pas_de_touche - - Get_input_Pas_emulation_Click_gauche: - - ; Test [Touche] = Emulation de MOUSE CLICK RIGHT - - cmp ax,word ptr[Config_Touche+10] - jne Get_input_Pas_de_touche - - mov INPUT_Nouveau_Mouse_K,2 - jmp Get_input_Pas_de_touche - - Get_input_Fin_emulation: - - mov cl,Mouse_Facteur_de_correction_X - mov ax,INPUT_Nouveau_Mouse_X - mov dx,INPUT_Nouveau_Mouse_Y - shl ax,cl - mov cl,Mouse_Facteur_de_correction_Y - shl dx,cl - mov cx,ax - mov ax,0004h - int 33h - - Get_input_Pas_de_touche: - - - ; Gestion "avancée" du curseur: interdire la descente du curseur dans le - ; menu lorsqu'on est en train de travailler dans l'image - - - cmp Operation_Taille_pile,0 - je Get_input_Pas_de_correction - - xor bl,bl ; BL va indiquer si on doit corriger la position du curseur - - ; Si le curseur ne se trouve plus dans l'image - mov ax,Menu_Ordonnee - cmp INPUT_Nouveau_Mouse_Y,ax - jb Get_input_Fin_correction_Y - - ; On bloque le curseur en fin d'image - dec ax ; La ligne !!au-dessus!! du menu - inc bl - mov INPUT_Nouveau_Mouse_Y,ax - - Get_input_Fin_correction_Y: - - - cmp Loupe_Mode,0 - jz Get_input_Fin_correction_X - - mov ax,INPUT_Nouveau_Mouse_X - cmp Operation_dans_loupe,0 - jnz Get_input_X_dans_loupe - - mov dx,Principal_Split - cmp ax,dx - jb Get_input_Fin_correction_X - - dec dx - inc bl - mov INPUT_Nouveau_Mouse_X,dx - - jmp Get_input_Fin_correction_X - Get_input_X_dans_loupe: - - mov dx,Principal_X_Zoom - cmp ax,dx - jae Get_input_Fin_correction_X - - inc bl - mov INPUT_Nouveau_Mouse_X,dx - - Get_input_Fin_correction_X: - - - or bl,bl - jz Get_input_Pas_de_correction_du_curseur - - mov cl,Mouse_Facteur_de_correction_X - mov ax,INPUT_Nouveau_Mouse_X - mov dx,INPUT_Nouveau_Mouse_Y - shl ax,cl - mov cl,Mouse_Facteur_de_correction_Y - shl dx,cl - mov cx,ax - mov ax,0004h - int 33h - - Get_input_Pas_de_correction_du_curseur: - - - mov ax,Touche - or ax,ax - jz Get_input_Pas_de_correction - ; Enfin, on inhibe les touches (sauf si c'est un changement de couleur - ; ou de taille de pinceau lors d'une des operations suivantes: - ; OPERATION_DESSIN_CONTINU, OPERATION_DESSIN_DISCONTINU, OPERATION_SPRAY - cmp Autoriser_changement_de_couleur_pendant_operation,0 - jz Get_input_Il_faut_inhiber_les_touches - - ; A ce stade là, on sait qu'on est dans une des 3 opérations supportant - ; le changement de couleur ou de taille de pinceau. - cmp ax,word ptr [Config_Touche+12] - je Get_input_Pas_de_correction - cmp ax,word ptr [Config_Touche+14] - je Get_input_Pas_de_correction - cmp ax,word ptr [Config_Touche+16] - je Get_input_Pas_de_correction - cmp ax,word ptr [Config_Touche+18] - je Get_input_Pas_de_correction - cmp ax,word ptr [Config_Touche+20] - je Get_input_Pas_de_correction - cmp ax,word ptr [Config_Touche+22] - je Get_input_Pas_de_correction - cmp ax,word ptr [Config_Touche+24] - je Get_input_Pas_de_correction - cmp ax,word ptr [Config_Touche+26] - je Get_input_Pas_de_correction - cmp ax,word ptr [Config_Touche+28] - je Get_input_Pas_de_correction - cmp ax,word ptr [Config_Touche+30] - je Get_input_Pas_de_correction - - Get_input_Il_faut_inhiber_les_touches: - mov word ptr Touche,0 - - Get_input_Pas_de_correction: - - - ; On commence à mettre à jour les variables globales - - mov ax,INPUT_Nouveau_Mouse_X - mov bx,INPUT_Nouveau_Mouse_Y - mov cl,INPUT_Nouveau_Mouse_K - - cmp ax,Mouse_X - jne Get_input_Affichage_curseur - - cmp bx,Mouse_Y - jne Get_input_Affichage_curseur - - cmp cl,Mouse_K - jne Get_input_Affichage_curseur - - cmp Forcer_affichage_curseur,0 - je Get_input_Fin_Get_input - - Get_input_Affichage_curseur: - - mov Forcer_affichage_curseur,0 - - pushad - call Effacer_curseur - popad - - mov Mouse_X,ax - mov Mouse_Y,bx - mov Mouse_K,cl - - ; Calcul des coordonnées du pinceau: - call Calculer_coordonnees_pinceau - - pushad - call Afficher_curseur - popad - - Get_input_Fin_Get_input: - - popad - - ret - -Get_input endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; -------- Repositionner la souris en fonction de Mouse_X et Mouse_Y --------- - -Set_mouse_position proc near - - push ax - push cx - push dx - - - mov cl,Mouse_Facteur_de_correction_X - mov ax,Mouse_X - mov dx,Mouse_Y - shl ax,cl - mov cl,Mouse_Facteur_de_correction_Y - shl dx,cl - mov cx,ax - mov ax,0004h - int 33h - - pop dx - pop cx - pop ax - - ret - -Set_mouse_position endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; ---- Définir le champ de déplacement de la souris suivant la résolution ---- - -Clip_mouse proc near - - push ax - push cx - push dx - - - ; Règle les dimensions de l'espace virtuel de la souris et corrige le - ; programme pour une précision au pixel près. - - - ; On règle le clip en hauteur: - - mov cl,Mouse_Facteur_de_correction_Y - mov dx,Hauteur_ecran - mov ax,0008h - dec dx - shl dx,cl - xor cx,cx - int 33h - - ; On règle le clip en largeur: - - mov cl,Mouse_Facteur_de_correction_X - mov dx,Largeur_ecran - mov ax,0007h - dec dx - shl dx,cl - xor cx,cx - int 33h - - pop dx - pop cx - pop ax - - ret - -Clip_mouse endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -Sensibilite_souris proc near - - push ebp - mov ebp,esp - - arg Sensibilite_X:word,Sensibilite_Y:word - - push ax - push cx - push dx - - - ; Règlage de la sensibilité - - mov ax,0Fh - mov cx,Sensibilite_X - mov dx,Sensibilite_Y - int 33h - - - pop dx - pop cx - pop ax - - mov esp,ebp - pop ebp - - ret - -Sensibilite_souris endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -Attendre_fin_de_click proc near - - pushad - - - Attendre_fin_de_click_Boucle: - - mov ax,0003h - int 33h ; Fout en l'air AX,BC,CX et DX - or bl,bl - jnz Attendre_fin_de_click_Boucle - - mov Mouse_K,0 - - - popad - - ret - -Attendre_fin_de_click endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -; --------------------------- Définir une couleur ---------------------------- - -Set_color proc near - - push ebp - mov ebp,esp - - arg Couleur:byte, Rouge:byte , Vert:byte, Bleu:byte - - - mov dx,3C8h - mov al,Couleur - out dx,al - inc dx - mov al,Rouge - out dx,al - mov al,Vert - out dx,al - mov al,Bleu - out dx,al - - - mov esp,ebp - pop ebp - - ret - -Set_color endp - -; --------------------------- Définir une palette ---------------------------- - -Set_palette proc near - - push ebp - mov ebp,esp - - arg Palette:dataptr - - push esi - - -; xor al,al ; Méthode rapide mais qui ne fonctionne pas avec -; mov dx,3C8h ; toutes les cartes vidéo. -; out dx,al -; -; inc dx -; mov esi,Palette -; mov ecx,768 -; rep outsb - - mov esi,Palette ; Méthode un peu plus lente mais qui fonctionne avec - mov dx,3C9h ; toutes les cartes vidéo compatibles VGA. - xor cl,cl - Set_palette_Loop: - dec dx - mov al,cl - out dx,al - inc dx - outsb - outsb - outsb - inc cl ; On incrémente le numéro de couleur et - jnz Set_palette_Loop ; s'il repasse à 0, c'est qu'on a terminé. - - - pop esi - - mov esp,ebp - pop ebp - - ret - -Set_palette endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; ----------- Conversion d'une palette 6 bits en une palette 8 bits ---------- - -Palette_64_to_256 proc near - - push ebp - mov ebp,esp - - arg Palette:dataptr - - pushad - - - mov esi,Palette - mov cx,768 - - Boucle_64_to_256: - - mov al,[esi] - shl al,2 - mov [esi],al - inc esi - dec cx - jnz Boucle_64_to_256 - - - popad - - mov esp,ebp - pop ebp - - ret - -Palette_64_to_256 endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; ----------- Conversion d'une palette 8 bits en une palette 6 bits ---------- - -Palette_256_to_64 proc near - - push ebp - mov ebp,esp - - arg Palette:dataptr - - pushad - - - mov esi,Palette - mov cx,768 - - Boucle_256_to_64: - - mov al,[esi] - shr al,2 - mov [esi],al - inc esi - dec cx - jnz Boucle_256_to_64 - - - popad - - mov esp,ebp - pop ebp - - ret - -Palette_256_to_64 endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; ------------ Effacer l'image courante avec une certaine couleur ------------ - -Effacer_image_courante proc near - - push ebp - mov ebp,esp - - arg Couleur:byte - - push edi - - - xor edx,edx - xor eax,eax - mov dx,Principal_Hauteur_image - mov ax,Principal_Largeur_image - mul edx - mov ecx,eax - - mov dl,Couleur - mov dh,dl - mov ax,dx - shl eax,16 - mov ax,dx - - mov edi,Principal_Ecran - - shr ecx,1 - jnc Effacer_image_Pair - stosb ; On commence par se débarrasser du 1er byte - ; en cas d'imparité - Effacer_image_Pair: - - shr ecx,1 - jnc Effacer_image_test_de_superiorite_a_3 - stosw ; On se débarrasse des 2ème et 3ème bytes en - ; cas de "non-multiplicité-de-4" - Effacer_image_test_de_superiorite_a_3: - - ; copie 32 bits - rep stosd - - - pop edi - - mov esp,ebp - pop ebp - - ret - -Effacer_image_courante endp - - - -; ---- Effacer l'image courante avec une certaine couleur en mode Stencil ---- - -Effacer_image_courante_Stencil proc near - - push ebp - mov ebp,esp - - arg Couleur:byte, Pochoir:dataptr - - push ebx - push edi - - - ; Dans ECX on met le nombre de pixels dans l'image - xor edx,edx - xor eax,eax - mov dx,Principal_Hauteur_image - mov ax,Principal_Largeur_image - mul edx - mov ecx,eax - - ; On met dans EBX l'adresse de la table de pochoir - mov ebx,Pochoir - - ; On nettoie la partie haute de EDX - xor edx,edx - - ; On met dans AL la couleur d'effacement - mov al,Couleur - - ; On met dans EDI l'adresse de l'image à effacer - mov edi,Principal_Ecran - - Effacer_image_Stencil_Pour_chaque_pixel: - - mov dl,[edi] - cmp byte ptr [ebx+edx],0 - jne Effacer_image_Stencil_Pas_de_modif - mov [edi],al - Effacer_image_Stencil_Pas_de_modif: - - inc edi - dec ecx - jnz Effacer_image_Stencil_Pour_chaque_pixel - - - - pop edi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Effacer_image_courante_Stencil endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; ----------------- Attendre un balayage vertical de l'écran ----------------- - -Wait_VBL proc near - - mov dx,3DAh - - VBL_Boucle: - in al,dx - test al,08h - jnz VBL_Boucle - - VBL_Attente: - in al,dx - test al,08h - jz VBL_Attente - - ret - -Wait_VBL endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; ------ Attendre une certain laps de temps pour temporiser les jauges ------- - -Tempo_jauge proc near - - push ebp - mov ebp,esp - - arg Vitesse:byte; - - - mov cl,Vitesse - Tempo_Boucle: - call Wait_VBL - dec cl - jnz Tempo_Boucle - - - mov esp,ebp - pop ebp - - ret - -Tempo_jauge endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -Round_div proc near - - push ebp - mov ebp,esp - - arg Numerateur:dword,Diviseur:dword - - - mov eax,Numerateur - mov ecx,Diviseur - xor edx,edx - div ecx - shr ecx,1 - cmp edx,ecx - jbe Round_div_Pas_arrondi_a_la_valeur_superieure - - inc ax - - Round_div_Pas_arrondi_a_la_valeur_superieure: - - - mov esp,ebp - pop ebp - - ret - -Round_div endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -Palette_Compter_nb_couleurs_utilisees proc near - - push ebp - mov ebp,esp - - arg Tableau:dataptr - - pushad - - - ; On commence par mettre toutes les valeurs à 0 - mov ecx,256 - mov edi,Tableau - xor eax,eax - rep stosd - - ; On parcourt ensuite l'écran courant pour compter les utilisations des - ; couleurs: - - ; Dans ECX on met le nombre de pixels dans l'image - xor edx,edx - xor eax,eax - mov dx,Principal_Hauteur_image - mov ax,Principal_Largeur_image - mul edx - mov ecx,eax - - ; On place dans ESI le début de l'image - mov esi,Principal_Ecran - - ; On place dans EBX le début de la table d'utilisation des couleurs: - mov ebx,Tableau - - ; On nettoie la partie haute de EAX - xor eax,eax - - Compter_Pour_chaque_pixel: - - ; On lit la couleur dans AL (donc aussi dans EAX) - mov al,[esi] - - ; On incrémente l'utilisation de la couleur AL: - inc dword ptr[ebx+4*eax] - - ; On passe au pixel suivant - inc esi - dec ecx - jnz Compter_Pour_chaque_pixel - - ; On va maintenant compter dans la table les couleurs utilisées: - - xor ax,ax ; On initialise le compteur à 0 - mov cx,256 ; On initialise le compte à rebours à 256 - xor edx,edx ; On initialise l'indice à 0 - - Compter_Pour_chaque_couleur: - - cmp dword ptr[ebx+4*edx],0 - je Compter_Couleur_pas_utilisee - inc ax - Compter_Couleur_pas_utilisee: - - inc dx - dec cx - jnz Compter_Pour_chaque_couleur - - ; On stock le résultat (AX) dans la pile pour que le POPAD ne le détruise - ; pas: - - - mov [esp+28],ax - popad - - mov esp,ebp - pop ebp - - ret - -Palette_Compter_nb_couleurs_utilisees endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -Get_key proc near - - mov ah,8 - int 21h - - ret - -Get_key endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; -- Afficher un pixel dans l'écran virtuel courant -- - -Pixel_dans_ecran_courant proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word,Couleur:byte - - - xor eax,eax - xor edx,edx - xor ecx,ecx - mov ax,Y - mov dx,Principal_Largeur_image - mov cx,X - mul edx - add eax,ecx - mov dl,Couleur - add eax,Principal_Ecran - - mov [eax],dl - - - mov esp,ebp - pop ebp - - ret - -Pixel_dans_ecran_courant endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; -- Lire la couleur d'un pixel dans l'écran virtuel courant -- - -Lit_pixel_dans_ecran_courant proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word - - - xor eax,eax - xor edx,edx - xor ecx,ecx - mov ax,Y - mov dx,Principal_Largeur_image - mov cx,X - mul edx - add ecx,eax - add ecx,Principal_Ecran - - mov al,[ecx] - - - mov esp,ebp - pop ebp - - ret - -Lit_pixel_dans_ecran_courant endp - - - -; -- Lire la couleur d'un pixel dans l'écran virtuel brouillon -- - -Lit_pixel_dans_ecran_brouillon proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word - - - xor eax,eax - xor edx,edx - xor ecx,ecx - mov ax,Y - mov dx,Brouillon_Largeur_image - mov cx,X - mul edx - add ecx,eax - add ecx,Brouillon_Ecran - - mov al,[ecx] - - - mov esp,ebp - pop ebp - - ret - -Lit_pixel_dans_ecran_brouillon endp - - - -; -- Lire la couleur d'un pixel dans l'écran virtuel de sauvegarde -- - -Lit_pixel_dans_ecran_backup proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word - - - xor ecx,ecx - xor edx,edx - xor eax,eax - mov cx,X - mov dx,Y - mov ax,Principal_Largeur_image - add ecx,Ecran_backup - mul edx - add ecx,eax - - mov al,[ecx] - - - mov esp,ebp - pop ebp - - ret - -Lit_pixel_dans_ecran_backup endp - - - -; -- Lire la couleur d'un pixel dans l'écran de feedback -- - -Lit_pixel_dans_ecran_feedback proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word - - - xor eax,eax - xor edx,edx - xor ecx,ecx - mov ax,Y - mov dx,Principal_Largeur_image - mov cx,X - mul edx - add ecx,eax - add ecx,FX_Feedback_Ecran - - mov al,[ecx] - - - mov esp,ebp - pop ebp - - ret - -Lit_pixel_dans_ecran_feedback endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; -- Définir la couleur d'un pixel dans la brosse -- - -Pixel_dans_brosse proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word,Couleur:byte - - - xor eax,eax - xor edx,edx - xor ecx,ecx - mov ax,Y - mov dx,Brosse_Largeur - mov cx,X - mul edx - add eax,ecx - mov dl,Couleur - add eax,Brosse - - mov [eax],dl - - - mov esp,ebp - pop ebp - - ret - -Pixel_dans_brosse endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; -- Lire la couleur d'un pixel dans la brosse -- - -Lit_pixel_dans_brosse proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word - - - xor eax,eax - xor edx,edx - xor ecx,ecx - mov ax,Y - mov dx,Brosse_Largeur - mov cx,X - mul edx - add eax,ecx - add eax,Brosse - - mov al,[eax] - - - mov esp,ebp - pop ebp - - ret - -Lit_pixel_dans_brosse endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; Renseigne sur la quantité de place libre sur un lecteur quelconque -; -; Entrée: Octet = n° de lecteur (0:courant, 1:A, 2:B, 3:C, 4:D, ...) -; -; Sortie: Long = -1 : Lecteur invalide -; sinon : Place libre sur le lecteur - -Freespace proc near - - push ebp - mov ebp,esp - - arg Numero_de_lecteur:byte - - push ebx - push cx - push edx - - - ; On appelle l'interruption du DOS - - mov ah,36h - mov dl,Numero_de_lecteur - int 21h - - ; On regarde si AX = 0FFFFh (dans ce cas => Erreur) - - cmp ax,0FFFFh - je Freespace_Erreur - - ; Sinon: - - mul bx ; DX:AX = AX*BX - - push ax ; EAX = DX:AX = AX*BX - mov ax,dx - shl eax,16 - pop ax - - xor ebx,ebx ; EDX:EAX = AX*BX*CX - mov bx,cx - mul ebx - - jmp Freespace_Fin_de_traitement - - Freespace_Erreur: - - mov eax,0FFFFFFFFh - - Freespace_Fin_de_traitement: - - - pop edx - pop cx - pop ebx - - mov esp,ebp - pop ebp - - ret - -Freespace endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; Renseigne sur un lecteur de disquette: -; -; Entrée: Octet = n° du lecteur de disquette (commence à 0) -; -; Sortie: Octet = 0 : Pas de lecteur -; 1 : Lecteur 360 Ko -; 2 : Lecteur 1.2 Mo -; 3 : Lecteur 720 Ko -; 4 : Lecteur 1.4 Mo -; 5 : Lecteur 2.8 Mo (???) -; 6 : Lecteur 2.8 Mo - -Type_de_lecteur_de_disquette proc near - - push ebp - mov ebp,esp - - arg Numero_de_lecteur:byte - - xor eax,eax - mov al,10h - out 70h,al - in al,71h - - cmp Numero_de_lecteur,0 - jne Type_de_lecteur_de_disquette_B - shr al,4 - jmp Type_de_lecteur_de_disquette_Fin_de_traitement - Type_de_lecteur_de_disquette_B: - and al,0Fh - - Type_de_lecteur_de_disquette_Fin_de_traitement: - - mov esp,ebp - pop ebp - - ret - -Type_de_lecteur_de_disquette endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; Renseigne sur la lettre logique d'un lecteur -; (utile pour tester si un lecteur de disquette est A: ou B: aux yeux du DOS) -; -; Entrée: Octet = n° du lecteur (1=A, 2=B ...) -; -; Sortie: Octet = 0FFh : Pas de lecteur (???) -; sinon: numéro représentant la lettre logique du lecteur -; (commence à 1) - -Disk_map proc near - - push ebp - mov ebp,esp - - arg Numero_de_lecteur:byte - - push bx - - - xor eax,eax - mov ax,440Eh - mov bl,Numero_de_lecteur - int 21h - - jnc Disk_map_OK - - mov al,0FFh - jmp Disk_map_Fin - - Disk_map_OK: - or al,al - jnz Disk_map_Fin - - mov al,Numero_de_lecteur - - Disk_map_Fin: - xor ah,ah - - - pop bx - - mov esp,ebp - pop ebp - - ret - -Disk_map endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; Renseigne sur un disque dur: -; -; Entrée: Octet = n° du disque dur (0:C, 1:D, 2:E, ...) -; -; Sortie: Octet = 0 : Pas de lecteur -; 1 : Disque dur présent - -Disque_dur_present proc near - - push ebp - mov ebp,esp - - arg Numero_de_disque:byte - - pushad - - - ; On se renseigne sur le disque à l'aide de la fonction 08h de - ; l'interruption 13h - - mov ah,08h - mov dl,Numero_de_disque - push es - or dl,80h - int 13h ; modifie ES! - - pop es ; POP du ES memorisé juste avant l'INT 13h - - ; Le disque est absent si CF ou si AH<>0 - - jc Disque_dur_present_Pas_de_disque - or ah,ah - jnz Disque_dur_present_Pas_de_disque - - ; Il peut arriver que ces tests soient insuffisants, il faut alors comparer - ; le n° du drive avec le nb de disques durs installés (nb dans DL) - - mov ah,Numero_de_disque - inc ah - cmp ah,dl - ja Disque_dur_present_Pas_de_disque - - ; On doit maintenant pouvoir supposer que le disque en question est bien - ; installé - - mov byte ptr[esp+28],1 - jmp Disque_dur_present_Fin_de_traitement - - Disque_dur_present_Pas_de_disque: - - mov byte ptr[esp+28],0 - - Disque_dur_present_Fin_de_traitement: - - - popad - - mov esp,ebp - pop ebp - - ret - -Disque_dur_present endp - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - -; Renseigne sur un lecteur CD-ROM: -; -; Entrée : Octet = n° du lecteur (0:A, 1:B, 2:C, ...) -; -; Sortie : Octet = 0 : Le lecteur n'est pas un CD-ROM -; 1 : Le lecteur est un CD-ROM - -Lecteur_CDROM_present proc near - - push ebp - mov ebp,esp - - arg Numero_de_lecteur:byte - - push bx - push cx - push dx - - - ; Détection du n° de version de MSCDEX - - mov ax,150Ch - int 2Fh - cmp bh,2 - jb Lecteur_CDROM_present_Mauvaise_version - - ; On est donc avec une version de MSCDEX assez récente (enfin, disons... - ; ... pas trop obsolète). - - ; On demande des informations sur le lecteur de la part de MSCDEX v2.00 - - mov ax,150Bh - xor ch,ch - mov cl,Numero_de_lecteur - int 2Fh - - ; On détermine maintenant si le lecteur est de type CD-ROM grâce aux - ; résultats - - cmp bx,0ADADh - jne Lecteur_CDROM_present_Pas_CDROM - or ax,ax - jz Lecteur_CDROM_present_Pas_CDROM - - jmp Lecteur_CDROM_present_CDROM_OK - - Lecteur_CDROM_present_Mauvaise_version: - - ; On va être obligé de traiter le problème avec une vieille version - ; merdique de MSCDEX: ça me fait chier, plus personne ne devrait posséder - ; des antiquités pareilles. Moi je dit que ce genre de personne ne mérite - ; pas de pouvoir utiliser GRAFX 2 ! - - ; mais bon... comme je me trouve dans un bon jour, je vais faire un effort - ; et je vais demander quelques informations à pépé MSCDEX. Mais faut pas - ; abuser: le gars il a intérêt à avoir ses lecteurs CD-ROM les uns à la - ; suite des autres... je ne m'amuserai pas à prendre en compte un cas - ; aussi chiant... enfin tu me diras, le type est suffisamment emmerdant pour - ; avoir une vieille version de MSCDEX, il serait bien du genre à mettre ses - ; lecteurs CD-ROM dans n'importe quel ordre, le gars. - - mov ax,1500h - xor bx,bx - int 2Fh - - cmp Numero_de_lecteur,cl ; Si le lecteur demandé se trouve avant le premier lecteur CD, - jb Lecteur_CDROM_present_Pas_CDROM ; c'est que c'est pas un lecteur CD-ROM - - add cx,bx - cmp Numero_de_lecteur,cl ; Pareille, si le lecteur est après le dernier, - jge Lecteur_CDROM_present_Pas_CDROM ; c'est que c'est pas un lecteur CD-ROM - - Lecteur_CDROM_present_CDROM_OK: - - mov ax,1 - jmp Lecteur_CDROM_present_Fin_de_traitement - - Lecteur_CDROM_present_Pas_CDROM: - - xor ax,ax - - Lecteur_CDROM_present_Fin_de_traitement: - - - pop dx - pop cx - pop bx - - mov esp,ebp - pop ebp - - ret - -Lecteur_CDROM_present endp - - - - - - -; -- Calculer les variables globales nécessaires au tracé d'une ellipse -- - -Ellipse_Calculer_limites proc near - - push ebp - mov ebp,esp - - arg Rayon_horizontal:word,Rayon_vertical:word - - push ebx - - - mov ebx,offset Table_des_carres - xor eax,eax - xor ecx,ecx - mov ax,Rayon_horizontal - mov cx,Rayon_vertical - mov eax,[ebx+4*eax] - mov ecx,[ebx+4*ecx] - mov Ellipse_Rayon_horizontal_au_carre,eax - mov Ellipse_Rayon_vertical_au_carre,ecx - mul ecx - mov Ellipse_Limite_High,edx - mov Ellipse_Limite_Low,eax - - - pop ebx - - mov esp,ebp - pop ebp - - ret - -Ellipse_Calculer_limites endp - - - - - - -; -- Teste si un point se trouve ou non dans l'ellipse en cours de tracé -- - -Pixel_dans_ellipse proc near - - push ebx - push esi - push edi - - - ; On fait pointer EBX sur la table des puissances de 2: - mov ebx,offset Table_des_carres - - ; On place dans ECX la valeur absolue de X - mov ecx,Ellipse_Curseur_X - or ecx,ecx - jnl Pixel_dans_ellipse_X_positif - neg ecx - Pixel_dans_ellipse_X_positif: - - ; On place dans EAX la valeur X^2 - mov eax,[ebx+4*ecx] - - ; On met dans EDX:EAX la valeur ( B^2 x X^2 ): - mul dword ptr[Ellipse_Rayon_vertical_au_carre] - - ; On stock le résultat ( B^2 x X^2 ) dans EDI:ESI : - mov edi,edx - mov esi,eax - - ; On place dans ECX la valeur absolue de Y - mov ecx,Ellipse_Curseur_Y - or ecx,ecx - jnl Pixel_dans_ellipse_Y_positif - neg ecx - Pixel_dans_ellipse_Y_positif: - - ; On place dans EAX la valeur Y^2 - mov eax,[ebx+4*ecx] - - ; On met dans EDX:EAX la valeur ( A^2 x Y^2 ): - mul dword ptr[Ellipse_Rayon_horizontal_au_carre] - - ; On fait la somme de ( B^2 x X^2 ) avec ( A^2 x Y^2 ) dans EDX:EAX : - add eax,esi - adc edx,edi - - ; On regarde si cette valeur est inferieure ou égale à la limite de - ; l'ellipse: - cmp edx,Ellipse_Limite_High - je Pixel_dans_ellipse_Regarder_la_partie_basse - setb al - jmp Pixel_dans_ellipse_Fin_de_traitement - Pixel_dans_ellipse_Regarder_la_partie_basse: - cmp eax,Ellipse_Limite_Low - setbe al - Pixel_dans_ellipse_Fin_de_traitement: - - movzx eax,al - - pop edi - pop esi - pop ebx - - ret - -Pixel_dans_ellipse endp - - - - - - -; -- Teste si un point se trouve ou non dans le cercle en cours de tracé -- - -Pixel_dans_cercle proc near - - push ebx - - - ; On fait pointer EBX sur la table des puissances de 2: - mov ebx,offset Table_des_carres - - ; On place dans EAX et ECX les valeurs absolues de X et Y: - mov eax,Cercle_Curseur_X - mov ecx,Cercle_Curseur_Y - or eax,eax - jnl Pixel_dans_cercle_X_positif - neg eax - Pixel_dans_cercle_X_positif: - or ecx,ecx - jnl Pixel_dans_cercle_Y_positif - neg ecx - Pixel_dans_cercle_Y_positif: - - ; On place dans EAX et ECX les valeurs X^2 et Y^2 : - mov eax,[ebx+4*eax] - mov ecx,[ebx+4*ecx] - - ; On place dans EAX la somme ( X^2 + Y^2 ) : - add eax,ecx - - ; On regarde si la distance est dans la limite du cercle: - cmp eax,Cercle_Limite - setbe al - - and eax,0FFh - - - pop ebx - - ret - -Pixel_dans_cercle endp - - - - - - -; -- Extraire 1 bit d'un octet -- - -Bit proc near - - push ebp - mov ebp,esp - - arg Octet:byte,Rang:byte - - mov al,Octet - mov cl,Rang - shr al,cl - and al,1 - - mov esp,ebp - pop ebp - - ret - -Bit endp - - - - - - -; -- Trouver la couleur du pixel (ILBM) à afficher en Pos_X -- - -Couleur_ILBM_line proc near - - push ebp - mov ebp,esp - - arg Pos_X:word, Vraie_taille_ligne:word - - push bx - push esi - - - xor eax,eax - mov ax,Pos_X - ; CL sera le rang auquel on extrait les bits de la couleur - mov cl,7 - and al,7 - sub cl,al - - ; ESI pointe sur le Buffer de ligne ILBM - mov esi,LBM_Buffer - - xor bl,bl - xor dh,dh - mov dl,HBPm1 - CIL_Loop: - push dx - mov ax,Vraie_taille_ligne - mul dx - add ax,Pos_X - shr ax,3 - - mov bh,[esi+eax] - - shr bh,cl - and bh,1 - - shl bl,1 - add bl,bh - - pop dx - dec dl - jns CIL_Loop - - mov al,bl - - - pop esi - pop bx - - mov esp,ebp - pop ebp - - ret - -Couleur_ILBM_line endp - - - - - - -; -- Démarrer le chrono -- - -Initialiser_chrono proc near - - push ebp - mov ebp,esp - - arg Delai:dword - - mov eax,Delai - mov Chrono_delay,eax - - xor ah,ah - int 1Ah - mov word ptr[Chrono_cmp+0],dx - mov word ptr[Chrono_cmp+2],cx - - mov esp,ebp - pop ebp - - ret - -Initialiser_chrono endp - - - - - - -; -- Met Etat_chrono à 1 si le compte à rebours est atteint -- - -Tester_chrono proc near - - xor ah,ah - int 1Ah - - ; On transfère CX:DX dans EAX - mov ax,cx - shl eax,16 - mov ax,dx - - sub eax,Chrono_delay - cmp eax,Chrono_cmp - jna Tester_Chrono_delay_pas_encore_atteint - - mov Etat_chrono,1 - - Tester_Chrono_delay_pas_encore_atteint: - - ret - -Tester_chrono endp - - - - - -; -- Remplacement d'une couleur dans l'image par une autre -- - -Remplacer_une_couleur proc near - - push ebp - mov ebp,esp - - arg Ancienne_couleur:byte, Nouvelle_couleur:byte - - push edi - - - ; Dans ECX on met le nombre de pixels dans l'image - xor edx,edx - xor eax,eax - mov dx,Principal_Hauteur_image - mov ax,Principal_Largeur_image - mul edx - mov ecx,eax - - ; Dans AL on place la couleur que l'on veut remplacer et dans AH la couleur - ; par laquelle on veut la remplacer - mov al,Ancienne_couleur - mov ah,Nouvelle_couleur - - ; EDI pointe sur le début de l'image - mov edi,Principal_Ecran - - RUC_Pour_chaque_pixel: - - cmp al,[edi] - jne RUC_Pas_de_changement - mov [edi],ah - RUC_Pas_de_changement: - - ; On change de pixel - inc edi - dec ecx - jnz RUC_Pour_chaque_pixel - - - pop edi - - mov esp,ebp - pop ebp - - ret - -Remplacer_une_couleur endp - - - - - -; -- Remplacement de toutes les couleurs dans l'image à l'aide d'une table -- -; -- et ceci en respectant les limites -- - -Remplacer_toutes_les_couleurs_dans_limites proc near - - push ebp - mov ebp,esp - - arg Table_de_remplacement:dword - - - push esi - push edi - push ebx - - xor ebx,ebx - - ; ESI pointe sur le début de la ligne d'écran actuelle - mov esi,Principal_Ecran - mov bx,Limite_Gauche - add esi,ebx - xor eax,eax - mov bx,Limite_Haut - mov ax,Principal_Largeur_image - mul ebx - add esi,eax - ; EDI pointe sur la position actuelle dans l'écran - mov edi,esi - ; EBX pointe sur la table de remplacement - mov ebx,Table_de_remplacement - - ; On place dans CX le nombre de lignes à traiter - mov cx,Limite_Bas - sub cx,Limite_Haut - RTLCDL_Pour_chaque_ligne: - - ; On met dans DX le nombre de pixels à traiter et on nettoye la partie - ; haute de EAX - mov dx,Limite_Droite - xor eax,eax - sub dx,Limite_Gauche - RTLCDL_Pour_chaque_pixel_de_ligne: - - mov al,[edi] - mov al,[eax+ebx] - mov [edi],al - inc edi - - dec dx - jns RTLCDL_Pour_chaque_pixel_de_ligne - - ; On change de ligne - mov ax,Principal_Largeur_image - add esi,eax - mov edi,esi - dec cx - jns RTLCDL_Pour_chaque_ligne - - pop ebx - pop edi - pop esi - - - mov esp,ebp - pop ebp - - ret - -Remplacer_toutes_les_couleurs_dans_limites endp - - - - - -;///////////////////////////////////////////////////////////////////////////// -;// Inclusion du fichier contenant les fonctions Meilleure_couleur* // -;///////////////////////////////////////////////////////////////////////////// - -IF MC_POUR_P2 - INCLUDE mcpourp2.asm -ELSE - INCLUDE mcnormal.asm -ENDIF - -;///////////////////////////////////////////////////////////////////////////// - - - - - -; -- Gestion de l'effet Colorize à l'aide de la méthode d'interpolation - -Effet_Colorize_interpole proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word,Couleur:byte - - push ebx - push esi - push edi - - - ; Facteur_A=256*(100-Colorize_Opacite)/100 - ; Facteur_B=256*( Colorize_Opacite)/100 - ; - ; (Couleur_dessous*Facteur_A+Couleur*Facteur_B)/256 - - ; On fait tout de suite pointer ESI sur les coordonnées (X,Y) dans l'image - xor eax,eax - xor edx,edx - xor esi,esi - mov ax,Y - mov dx,Principal_Largeur_image - mov si,X - mul edx - add esi,eax - add esi,FX_Feedback_Ecran - - xor edx,edx - xor ecx,ecx - xor ebx,ebx - xor eax,eax - - ; On place dans ESI 3*Couleur_dessous (ESI est la position dans la palette - ; des teintes de la Couleur_dessous), et dans EDI 3*Couleur (EDI est la - ; position dans la palette des teintes de la Couleur) - mov al,[esi] - mov bl,Couleur - xor esi,esi - xor edi,edi - mov si,ax - mov di,bx - add si,si - add di,di - add si,ax - add di,bx - - ; On fait pointer EDI et ESI correctement sur la palette - add esi,offset Principal_Palette - add edi,offset Principal_Palette - -; ; On mémorise dans BL,CL,DL les 3 teintes de Couleur_dessous -; mov bl,[esi+0] -; mov cl,[esi+1] -; mov dl,[esi+2] -; -; ; On fait pointer ESI sur la table de multiplication par le Facteur_A -; mov esi,offset Table_de_multiplication_par_Facteur_A -; -; ; On mémorise dans BH,CH,DH les 3 teintes de Couleur -; mov bh,[edi+0] -; mov ch,[edi+1] -; mov dh,[edi+2] -; -; ; On fait pointer EDI sur la table de multiplication par le Facteur_B -; mov edi,offset Table_de_multiplication_par_Facteur_B - - ; On mémorise dans BL,CL,DL les 3 teintes de Couleur_dessous - ; et dans BH,CH,DH les 3 teintes de Couleur - mov bl,[esi] - mov bh,[edi] - inc esi - inc edi - mov cl,[esi] - mov ch,[edi] - inc esi - inc edi - mov dl,[esi] - mov dh,[edi] - - ; On fait pointer ESI sur la table de multiplication par le Facteur_A - ; et EDI sur la table de multiplication par le Facteur_B - mov esi,offset Table_de_multiplication_par_Facteur_A - mov edi,offset Table_de_multiplication_par_Facteur_B - -; ; On va s'occuper de la composante bleue (DX) -; -; xor ah,ah -; mov al,dh -; mov ax,[edi+2*eax] ; AX = (Bleu *Facteur_B) -; xor dh,dh -; add ax,[esi+2*edx] ; AX += (Bleu_dessous*Facteur_A) -; shr ax,8 -; push eax -; -; ; On va s'occuper de la composante verte (CX) et rouge (BX) -; -; mov dl,ch -; mov al,bh -; mov dx,[edi+2*edx] ; DX = (Vert *Facteur_B) -; xor ch,ch -; add dx,[esi+2*ecx] ; DX += (Vert_dessous *Facteur_A) -; mov ax,[edi+2*eax] ; AX = (Rouge *Facteur_B) -; xor bh,bh -; add ax,[esi+2*ebx] ; AX += (Rouge_dessous*Facteur_A) -; shr dx,8 -; shr ax,8 -; push edx -; push eax - - ; On va s'occuper de la composante bleue (DX) - - xor eax,eax - mov al,dh - xor dh,dh - add eax,eax - add edx,edx - add eax,offset Table_de_multiplication_par_Facteur_B - add edx,offset Table_de_multiplication_par_Facteur_A - mov ax,[eax] ; AX = (Bleu *Facteur_B) - add ax,[edx] ; AX += (Bleu_dessous*Facteur_A) - shr ax,8 - push eax - - ; On va s'occuper de la composante verte (CX) et rouge (BX) - - xor eax,eax - xor edx,edx - mov al,ch - mov dl,cl - add eax,eax - add edx,edx - add eax,offset Table_de_multiplication_par_Facteur_B - add edx,offset Table_de_multiplication_par_Facteur_A - mov ax,[eax] ; AX = (Vert *Facteur_B) - add ax,[edx] ; AX += (Vert_dessous*Facteur_A) - shr ax,8 - push eax - - xor eax,eax - xor edx,edx - mov al,bh - mov dl,bl - add eax,eax - add edx,edx - add eax,offset Table_de_multiplication_par_Facteur_B - add edx,offset Table_de_multiplication_par_Facteur_A - mov ax,[eax] ; AX = (Vert *Facteur_B) - add ax,[edx] ; AX += (Vert_dessous*Facteur_A) - shr ax,8 - push eax - - call Meilleure_couleur - add esp,12 - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Effet_Colorize_interpole endp - - - - - - - -; -- Gestion de l'effet Colorize à l'aide de la méthode additive - -Effet_Colorize_additif proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word,Couleur:byte - - push ebx - push esi - push edi - - - ; On fait tout de suite pointer ESI sur les coordonnées (X,Y) dans l'image - xor eax,eax - xor edx,edx - xor esi,esi - mov ax,Y - mov dx,Principal_Largeur_image - mov si,X - mul edx - add esi,eax - add esi,FX_Feedback_Ecran - - xor edx,edx - xor ecx,ecx - xor ebx,ebx - xor eax,eax - - ; On lit dans AL (EAX) la couleur en (X,Y) - mov al,[esi] - - ; On met dans CL (ECX) la couleur à rajouter - mov cl,Couleur - - ; On multiplie AX (EAX) par 3 - mov dx,ax - add ax,ax - add ax,dx - - ; On multiplie CX (ECX) par 3 - mov dx,cx - add cx,cx - add cx,dx - - ; On fait pointer EBX sur Principal_Palette - mov ebx,offset Principal_Palette - - - ; On va traiter la composante bleue: - - - ; On place dans DL Principal_Palette[AL].B - mov dl,[ebx+eax+2] - - ; On place dans DH Principal_Palette[CL].B - mov dh,[ebx+ecx+2] - - cmp dh,dl - ja Effet_Colorize_additif_Bleu_Superieur - xor dh,dh - jmp Effet_Colorize_additif_Bleu_Fin_de_traitement - Effet_Colorize_additif_Bleu_Superieur: - shr dx,8 - Effet_Colorize_additif_Bleu_Fin_de_traitement: - - push edx ; On passe la composante bleue que l'on désire - - - ; On va traiter la composante verte: - - - ; On place dans DL Principal_Palette[AL].V - mov dl,[ebx+eax+1] - - ; On place dans DH Principal_Palette[CL].V - mov dh,[ebx+ecx+1] - - cmp dh,dl - ja Effet_Colorize_additif_Vert_Superieur - xor dh,dh - jmp Effet_Colorize_additif_Vert_Fin_de_traitement - Effet_Colorize_additif_Vert_Superieur: - shr dx,8 - Effet_Colorize_additif_Vert_Fin_de_traitement: - - push edx ; On passe la composante verte que l'on désire - - - ; On va traiter la composante rouge: - - - ; On place dans DL Principal_Palette[AL].R - mov dl,[ebx+eax+0] - - ; On place dans DH Principal_Palette[CL].R - mov dh,[ebx+ecx+0] - - cmp dh,dl - ja Effet_Colorize_additif_Rouge_Superieur - xor dh,dh - jmp Effet_Colorize_additif_Rouge_Fin_de_traitement - Effet_Colorize_additif_Rouge_Superieur: - shr dx,8 - Effet_Colorize_additif_Rouge_Fin_de_traitement: - - push edx ; On passe la composante rouge que l'on désire - call Meilleure_couleur - add esp,12 - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Effet_Colorize_additif endp - - - - - - - -; -- Gestion de l'effet Colorize à l'aide de la méthode soustractive - -Effet_Colorize_soustractif proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word,Couleur:byte - - push ebx - push esi - push edi - - - ; On fait tout de suite pointer ESI sur les coordonnées (X,Y) dans l'image - xor eax,eax - xor edx,edx - xor esi,esi - mov ax,Y - mov dx,Principal_Largeur_image - mov si,X - mul edx - add esi,eax - add esi,FX_Feedback_Ecran - - xor edx,edx - xor ecx,ecx - xor ebx,ebx - xor eax,eax - - ; On lit dans AL (EAX) la couleur en (X,Y) - mov al,[esi] - - ; On met dans CL (ECX) la couleur à soustraire - mov cl,Couleur - - ; On multiplie AX (EAX) par 3 - mov dx,ax - add ax,ax - add ax,dx - - ; On multiplie CX (ECX) par 3 - mov dx,cx - add cx,cx - add cx,dx - - ; On fait pointer EBX sur Principal_Palette - mov ebx,offset Principal_Palette - - - ; On va traiter la composante bleue: - - - ; On place dans DL Principal_Palette[AL].B - mov dl,[ebx+eax+2] - - ; On place dans DH Principal_Palette[CL].B - mov dh,[ebx+ecx+2] - - cmp dh,dl - jb Effet_Colorize_soustractif_Bleu_Superieur - xor dh,dh - jmp Effet_Colorize_soustractif_Bleu_Fin_de_traitement - Effet_Colorize_soustractif_Bleu_Superieur: - shr dx,8 - Effet_Colorize_soustractif_Bleu_Fin_de_traitement: - - push edx ; On passe la composante bleue que l'on désire - - - ; On va traiter la composante verte: - - - ; On place dans DL Principal_Palette[AL].V - mov dl,[ebx+eax+1] - - ; On place dans DH Principal_Palette[CL].V - mov dh,[ebx+ecx+1] - - cmp dh,dl - jb Effet_Colorize_soustractif_Vert_Superieur - xor dh,dh - jmp Effet_Colorize_soustractif_Vert_Fin_de_traitement - Effet_Colorize_soustractif_Vert_Superieur: - shr dx,8 - Effet_Colorize_soustractif_Vert_Fin_de_traitement: - - push edx ; On passe la composante verte que l'on désire - - - ; On va traiter la composante rouge: - - - ; On place dans DL Principal_Palette[AL].R - mov dl,[ebx+eax+0] - - ; On place dans DH Principal_Palette[CL].R - mov dh,[ebx+ecx+0] - - cmp dh,dl - jb Effet_Colorize_soustractif_Rouge_Superieur - xor dh,dh - jmp Effet_Colorize_soustractif_Rouge_Fin_de_traitement - Effet_Colorize_soustractif_Rouge_Superieur: - shr dx,8 - Effet_Colorize_soustractif_Rouge_Fin_de_traitement: - - push edx ; On passe la composante rouge que l'on désire - call Meilleure_couleur - add esp,12 - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Effet_Colorize_soustractif endp - - - - - - - - -; -- Gestion des trames -- - -Effet_Trame proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word - - - xor edx,edx - - ; renvoie Trame[X%Trame_Largeur][Y%Trame_Hauteur] - - mov ax,X - div Trame_Largeur - mov cx,dx ; CX contient X%Trame_Largeur - - mov ax,Y - xor dx,dx - div Trame_Hauteur ; DX contient Y%Trame_Hauteur - - shl cx,4 ; CX= (X%Trame_Largeur)*16 - add dx,cx ; DX=((X%Trame_Largeur)*16)+(Y%Trame_Hauteur) - add edx,offset Trame ; EDX pointe sur Trame[X%Trame_Largeur][Y%Trame_Hauteur] - - mov al,[edx] - - - mov esp,ebp - pop ebp - - ret - -Effet_Trame endp - - - - - - - -; -- Effectuer une invertion de la brosse / une droite horizontale -- - -Flip_Y_LOWLEVEL proc near - - push ebx - push esi - push edi - - ; On va se servir de ESI pour pointer sur la partie supérieure de la brosse - ; et de EDI pour pointer sur la partie basse. - - mov esi,Brosse - - xor eax,eax - xor ebx,ebx - mov ax,Brosse_Hauteur - mov bx,Brosse_Largeur - dec ax - mov edi,Brosse - mul ebx - add edi,eax - - xor ecx,ecx - - Flip_Y_Tant_que: - - cmp edi,esi - jbe Flip_Y_Fin_tant_que - - ; Il faut inverser les lignes de la brosse pointées par EDI et ESI - ; ("Brosse_Largeur" octets en tout) - - mov cx,Brosse_Largeur - - ; On va se préparer à une inversion 32 bits de lignes. Pour cela, on - ; traite tout de suite les excédants - - shr cx,1 - jnc Flip_Y_Largeur_multiple_de_2 - - mov al,[esi] - mov ah,[edi] - mov [edi],al - mov [esi],ah - inc edi - inc esi - - Flip_Y_Largeur_multiple_de_2: - - shr cx,1 - jnc Flip_Y_Largeur_multiple_de_4 - - mov ax,[esi] - mov bx,[edi] - mov [edi],ax - mov [esi],bx - add edi,2 - add esi,2 - - Flip_Y_Largeur_multiple_de_4: - - ; Avant de se mettre à faire de l'inversion 32 bits, on vérifie qu'il - ; reste bien des dwords à traiter (cas d'une brosse trop étroite) - - or cx,cx - jz Flip_Y_Fin_de_ligne - - Flip_Y_Pour_chaque_pixel: - - mov eax,[esi] - mov ebx,[edi] - mov [edi],eax - mov [esi],ebx - add edi,4 - add esi,4 - - dec cx - jnz Flip_Y_Pour_chaque_pixel - - Flip_Y_Fin_de_ligne: - - ; On change de ligne, il faut donc mettre à jour ESI et EDI: ESI doit - ; pointer sur le début de la ligne suivante (ce qui est déja le cas), et - ; EDI sur le début de la ligne précédente - - movzx ebx,Brosse_Largeur - sub edi,ebx ; EDI se retrouve en début de la ligne en cours - sub edi,ebx ; EDI se retrouve en début de ligne précédente - - jmp Flip_Y_Tant_que - - Flip_Y_Fin_tant_que: - - - pop edi - pop esi - pop ebx - - ret - -Flip_Y_LOWLEVEL endp - - - - - - - -; -- Effectuer une invertion de la brosse / une droite verticale -- - -Flip_X_LOWLEVEL proc near - - push esi - push edi - - ; On va se servir de ESI pour pointer sur la partie gauche de la brosse et - ; de EDI pour pointer sur la partie droite. - - mov esi,Brosse - - xor eax,eax - mov edi,esi - mov ax,Brosse_Largeur - dec ax - add edi,eax - - ; On met dans EDX la largeur d'une ligne de brosse - xor edx,edx - mov dx,Brosse_largeur - - Flip_X_Tant_que: - - ; On sauve les valeurs initiales des pointeurs pour les changements de - ; colonne - - mov MODE_X_Valeur_initiale_de_esi,esi - mov MODE_X_Valeur_initiale_de_edi,edi - - cmp edi,esi - jbe Flip_X_Fin_tant_que - - ; Il faut inverser les colonnes de la brosse pointées par EDI et ESI - ; ("Brosse_Hauteur" octets en tout) - - mov cx,Brosse_Hauteur - - Flip_X_Pour_chaque_ligne: - - mov al,[esi] - mov ah,[edi] - mov [edi],al - mov [esi],ah - add edi,edx - add esi,edx - - dec cx - jnz Flip_X_Pour_chaque_ligne - - - ; On change de colonne, il faut donc mettre à jour ESI et EDI: ESI doit - ; pointer sur la colonne suivante, et EDI sur la colonne précédente - - mov esi,MODE_X_Valeur_initiale_de_esi - mov edi,MODE_X_Valeur_initiale_de_edi - inc esi - dec edi - - jmp Flip_X_Tant_que - - Flip_X_Fin_tant_que: - - - pop edi - pop esi - - ret - -Flip_X_LOWLEVEL endp - - - - - - - - -; -- Effectuer une rotation de 90° sur la brosse -- - -Rotate_90_deg_LOWLEVEL proc near - - push ebp - mov ebp,esp - - arg Source:dword,Destination:dword - - ; Brosse_Largeur & Brosse_Hauteur doivent être les dimensions de la brosse - ; Source - - push ebx - push esi - push edi - - ; On place ESI sur le point haut-droit de la brosse source: - xor eax,eax - mov esi,Source - mov ax,Brosse_Largeur - add esi,eax - dec esi - - ; Et on mémorise son emplacement initial: - mov MODE_X_Valeur_initiale_de_esi,esi - - ; On place EDI sur le point haut-gauche de la brosse destination: - mov edi,Destination - - ; On place dans EBX la distance entre 2 lignes dans la source: - xor ebx,ebx - mov bx,Brosse_Largeur - - ; On place dans DX le nombre de lignes/destination (colonnes/source) à - ; traiter: - mov dx,bx - - Rotate_90_deg_Pour_chaque_ligne: - - mov esi,MODE_X_Valeur_initiale_de_esi - - ; On place dans CX le nombre de colonnes/destination (lignes/source) à - ; traiter: - mov cx,Brosse_Hauteur - - Rotate_90_deg_Pour_chaque_colonne: - - ; On transfert le pixel: - mov al,[esi] - mov [edi],al - - ; Et on passe à la colonne de destination suivante: - add esi,ebx - inc edi - dec cx - jnz Rotate_90_deg_Pour_chaque_colonne - - ; Et on passe à la ligne de destination suivante: - dec MODE_X_Valeur_initiale_de_esi - dec dx - jnz Rotate_90_deg_Pour_chaque_ligne - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Rotate_90_deg_LOWLEVEL endp - - - - - - - - -; -- Effectuer une rotation de 180° sur la brosse (version compatible 386) -- - -Rotate_180_deg_LOWLEVEL proc near - - push ebx - push esi - push edi - - ; On va se servir de ESI pour pointer sur la partie supérieure de la brosse - ; et de EDI pour pointer sur la partie basse. - - mov esi,Brosse - - xor eax,eax - xor ebx,ebx - mov ax,Brosse_Hauteur - mov bx,Brosse_Largeur - dec ax - mov edi,Brosse - mul ebx - add edi,eax - - movzx edx,Brosse_Largeur ; EDX contient la largeur de la brosse - - Rotate_180_deg_Tant_que: - - cmp edi,esi - jbe Rotate_180_deg_Fin_tant_que - - ; Il faut inverser les lignes de la brosse pointées par EDI et ESI - ; (EDX octets en tout) - - mov ecx,edx - - ; Comme on fait pas un Flip_Y mais une rotation de 180°, on "ejecte" EDI - ; au bout de sa ligne - add edi,edx - dec edi - - ; On va se préparer à une inversion 16 bits de lignes. Pour cela, on - ; traite tout de suite les excédants - - shr cx,1 - jnc Rotate_180_deg_Largeur_multiple_de_2 - - mov al,[esi] - mov ah,[edi] - mov [edi],al - mov [esi],ah - dec edi - inc esi - - Rotate_180_deg_Largeur_multiple_de_2: - - ; On s'apprête à faire un traitement sur des words, on doit donc se - ; laisser la place d'y accéder. - - dec edi - - ; Avant de se mettre à faire de l'inversion 16 bits, on vérifie qu'il - ; reste bien des words à traiter (cas d'une brosse trop étroite) - - or cx,cx - jz Rotate_180_deg_Fin_de_ligne - - Rotate_180_deg_Pour_chaque_pixel: - - mov ax,[esi] - mov bx,[edi] - xchg ah,al ; On doit permutter les 2 octets pour que l'inversion soit correcte - xchg bh,bl ; On doit permutter les 2 octets pour que l'inversion soit correcte - mov [edi],ax - mov [esi],bx - sub edi,2 - add esi,2 - - dec cx - jnz Rotate_180_deg_Pour_chaque_pixel - - Rotate_180_deg_Fin_de_ligne: - - ; On change de ligne, il faut donc mettre à jour ESI et EDI: ESI doit - ; pointer sur le début de la ligne suivante (ce qui est déjà le cas), et - ; EDI sur le début de la ligne précédente - - ; Note: EDI se retrouve déjà au début de la ligne en cours puisqu'on l'a - ; éjecté (au début de traitement de la ligne) en fin de ligne, et - ; qu'il a fait le parcours de la ligne en sens inverse. Seulement, - ; il a légèrement débordé sur la gauche, c'est pourquoi on doit le - ; corriger par une incrémentation de 2 (car on a traité des words). - - add edi,2 ; EDI se retrouve en debut de la ligne en cours - sub edi,edx ; EDI se retrouve en début de ligne précédente - - jmp Rotate_180_deg_Tant_que - - Rotate_180_deg_Fin_tant_que: - - - pop edi - pop esi - pop ebx - - ret - -Rotate_180_deg_LOWLEVEL endp - - - - - -; Etirer une ligne selon un facteur donné vers un buffer - -Zoomer_une_ligne proc near - - push ebp - mov ebp,esp - - arg Ligne_originale:dword,Ligne_zoomee:dword,Facteur:word,Largeur:word - - push esi - push edi - - ; On place dans ESI l'adresse de la ligne orignale (à zoomer): - mov esi,Ligne_originale - - ; On place dans EDI l'adresse de la ligne résultat (zoomée): - mov edi,Ligne_zoomee - - ; On place dans DX le nombre de pixels à zoomer sur la ligne: - mov dx,Largeur - - ; On nettoye la partie haute de ECX: - xor ecx,ecx - - ZUL_Pour_chaque_pixel: - - ; On lit la couleur à recopier dans AL - mov cl,[esi] - mov ch,cl - mov ax,cx - shl eax,16 - mov ax,cx - - ; On place dans ECX le facteur: - mov cx,Facteur - - ; On recopie ECX fois AL dans EDI le + vite possible par copie 8/16/32 bits - shr cx,1 - jnc ZUL_ECX_multiple_de_2 - stosb - ZUL_ECX_multiple_de_2: - shr cx,1 - jnc ZUL_ECX_multiple_de_4 - stosw - ZUL_ECX_multiple_de_4: - rep stosd - - ; On passe au pixel suivant: - inc esi - dec dx - jnz ZUL_Pour_chaque_pixel - - - pop edi - pop esi - - mov esp,ebp - pop ebp - - ret - -Zoomer_une_ligne endp - - - - - - -; -- Copier une partie d'une image vers une autre -- - -Copier_une_partie_d_image_dans_une_autre proc near - - push ebp - mov ebp,esp - - arg Source:dword,S_Pos_X:word,S_Pos_Y:word,Largeur:word,Hauteur:word,Largeur_source:word,Destination:dword,D_Pos_X:word,D_Pos_Y:word,Largeur_destination:word - - push ebx - push esi - push edi - - ; On place dans ESI l'adresse de la source en (S_Pos_X,S_Pos_Y) - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,S_Pos_Y - mov bx,Largeur_source - mov cx,S_Pos_X - mul ebx - mov esi,Source - add eax,ecx - add esi,eax - - ; On place dans EDI l'adresse de la destination en (D_Pos_X,D_Pos_Y) - xor eax,eax - mov ax,D_Pos_Y - mov bx,Largeur_destination - mov cx,D_Pos_X - mul ebx - mov edi,Destination - add eax,ecx - add edi,eax - - ; On place dans EAX la distance entre la fin d'une ligne de l'image source - ; et le début de la suivante à l'abscisse S_Pos_X: - xor eax,eax - mov ax,Largeur_source - sub ax,Largeur - - ; On place dans EBX la distance entre la fin d'une ligne de l'image - ; destination et le début de la suivante à l'abscisse D_Pos_X: - xor ebx,ebx - mov bx,Largeur_destination - sub bx,Largeur - - ; On place dans DX le nombre de lignes à traiter - mov dx,Hauteur - - CUPDIDUA_Pour_chaque_ligne: - - ; On place dans CX le nombre de pixels à traiter sur la ligne: - mov cx,Largeur - - ; On fait une copie au mieux par 8/16/32 bits: - shr cx,1 - jnc CUPDIDUA_CX_multiple_de_2 - movsb - CUPDIDUA_CX_multiple_de_2: - shr cx,1 - jnc CUPDIDUA_CX_multiple_de_4 - movsw - CUPDIDUA_CX_multiple_de_4: - repnz movsd - - ; On passe à la ligne suivante: - add esi,eax - add edi,ebx - dec dx - jnz CUPDIDUA_Pour_chaque_ligne - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Copier_une_partie_d_image_dans_une_autre endp - - - - - - - - -_TEXT ENDS -END - - - - - - - - - - - - - -; -- Gestion de l'effet Smooth - -Effet_Smooth2 proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word,Couleur:byte - - push ebx - push esi - push edi - - - ; On fait tout de suite pointer ESI sur les coordonnées (X,Y) dans l'image - xor eax,eax - xor edx,edx - xor esi,esi - mov ax,Y - mov dx,Principal_Largeur_image - mov si,X - mul edx - add esi,eax - add esi,FX_Feedback_Ecran - - ; On vérifie d'abord que le point ne soit pas à la périphérie de l'image - - cmp X,0 - je Effet_Smooth_Sur_la_peripherie - cmp Y,0 - je Effet_Smooth_Sur_la_peripherie - mov ax,Principal_Largeur_image - mov dx,Principal_Hauteur_image - dec ax - dec dx - cmp X,ax - je Effet_Smooth_Sur_la_peripherie - cmp Y,dx - jne Effet_Smooth_Traitement_normal - - Effet_Smooth_Sur_la_peripherie: - - ; On est sur la périphérie, donc on ne modifie pas la couleur du point de - ; l'image. - - mov al,[esi] - jmp Effet_Smooth_Fin_de_traitement - - Effet_Smooth_Traitement_normal: - - ; On va se servir de BX,CX et DX comme cumuleurs de Rouge,Vert et Bleu - - xor edi,edi - xor ah,ah - mov al,[esi] ; AX = couleur du pixel en (X,Y) - mov di,ax ; DI = couleur du pixel en (X,Y) - add ax,ax ; AX = 2 * couleur du pixel en (X,Y) - add di,ax ; DI = 3 * couleur du pixel en (X,Y) - add edi,offset Principal_Palette ; EDI pointe sur la palette[Couleur du pixel en (X,Y)].R - xor ah,ah - mov al,[edi+0] - mov bx,ax - mov al,[edi+1] - mov cx,ax - mov al,[edi+2] - mov dx,ax - add bx,bx ; On double la valeur rouge du point (X,Y) - add cx,cx ; On double la valeur verte du point (X,Y) - add dx,dx ; On double la valeur bleue du point (X,Y) - - inc esi ; On fait pointer ESI sur (X+1,Y) - xor edi,edi - xor ah,ah - mov al,[esi] ; AX = couleur du pixel en (X+1,Y) - mov di,ax ; DI = couleur du pixel en (X+1,Y) - add ax,ax ; AX = 2 * couleur du pixel en (X+1,Y) - add di,ax ; DI = 3 * couleur du pixel en (X+1,Y) - add edi,offset Principal_Palette ; EDI pointe sur la palette[Couleur du pixel en (X+1,Y)].R - xor ah,ah ; \_ AX = Palette[Couleur du pixel en (X+1,Y)].R - mov al,[edi+0] ; / - add bx,ax ; On cumule les rouges dans BX - mov al,[edi+1] ; AX = Palette[Couleur du pixel en (X+1,Y)].V - add cx,ax ; On cumule les verts dans CX - mov al,[edi+2] ; AX = Palette[Couleur du pixel en (X+1,Y)].B - add dx,ax ; On cumule les bleus dans DX - - sub esi,2 ; On fait pointer ESI sur (X-1,Y) - xor edi,edi - xor ah,ah - mov al,[esi] ; AX = couleur du pixel en (X-1,Y) - mov di,ax ; DI = couleur du pixel en (X-1,Y) - add ax,ax ; AX = 2 * couleur du pixel en (X-1,Y) - add di,ax ; DI = 3 * couleur du pixel en (X-1,Y) - add edi,offset Principal_Palette ; EDI pointe sur la palette[Couleur du pixel en (X-1,Y)].R - xor ah,ah ; \_ AX = Palette[Couleur du pixel en (X-1,Y)].R - mov al,[edi+0] ; / - add bx,ax ; On cumule les rouges dans BX - mov al,[edi+1] ; AX = Palette[Couleur du pixel en (X-1,Y)].V - add cx,ax ; On cumule les verts dans CX - mov al,[edi+2] ; AX = Palette[Couleur du pixel en (X-1,Y)].B - add dx,ax ; On cumule les bleus dans DX - - add esi,1025 ; On fait pointer ESI sur (X,Y+1) - xor edi,edi - xor ah,ah - mov al,[esi] ; AX = couleur du pixel en (X,Y+1) - mov di,ax ; DI = couleur du pixel en (X,Y+1) - add ax,ax ; AX = 2 * couleur du pixel en (X,Y+1) - add di,ax ; DI = 3 * couleur du pixel en (X,Y+1) - add edi,offset Principal_Palette ; EDI pointe sur la palette[Couleur du pixel en (X,Y+1)].R - xor ah,ah ; \_ AX = Palette[Couleur du pixel en (X,Y+1)].R - mov al,[edi+0] ; / - add bx,ax ; On cumule les rouges dans BX - mov al,[edi+1] ; AX = Palette[Couleur du pixel en (X,Y+1)].V - add cx,ax ; On cumule les verts dans CX - mov al,[edi+2] ; AX = Palette[Couleur du pixel en (X,Y+1)].B - add dx,ax ; On cumule les bleus dans DX - - sub esi,2048 ; On fait pointer ESI sur (X,Y-1) - xor edi,edi - xor ah,ah - mov al,[esi] ; AX = couleur du pixel en (X,Y-1) - mov di,ax ; DI = couleur du pixel en (X,Y-1) - add ax,ax ; AX = 2 * couleur du pixel en (X,Y-1) - add di,ax ; DI = 3 * couleur du pixel en (X,Y-1) - add edi,offset Principal_Palette ; EDI pointe sur la palette[Couleur du pixel en (X,Y-1)].R - xor ah,ah ; \_ AX = Palette[Couleur du pixel en (X,Y-1)].R - mov al,[edi+0] ; / - add bx,ax ; On cumule les rouges dans BX - mov al,[edi+1] ; AX = Palette[Couleur du pixel en (X,Y-1)].V - add cx,ax ; On cumule les verts dans CX - mov al,[edi+2] ; AX = Palette[Couleur du pixel en (X,Y-1)].B - add dx,ax ; On cumule les bleus dans DX - - mov di,6 - - mov ax,dx ; On passe le paramètre (Cumul_bleu / 6) - xor dx,dx - div di - cmp ah,3 - jb Effet_Smooth_Pas_plus_bleu - inc al - Effet_Smooth_Pas_plus_bleu: - push eax - - mov ax,cx ; On passe le paramètre (Cumul_vert / 6) - xor dx,dx - div di - cmp ah,3 - jb Effet_Smooth_Pas_plus_vert - inc al - Effet_Smooth_Pas_plus_vert: - push eax - - mov ax,bx ; On passe le paramètre (Cumul_rouge / 6) - xor dx,dx - div di - cmp ah,3 - jb Effet_Smooth_Pas_plus_rouge - inc al - Effet_Smooth_Pas_plus_rouge: - push eax - - call Meilleure_couleur - add esp,12 ; 12 = 3 paramètres codés sur 4 octets - - Effet_Smooth_Fin_de_traitement: - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Effet_Smooth2 endp - - - -; -- Remplacer une couleur par une autre dans la brosse -- - -Remap_brush_LOWLEVEL proc near - - push ebp - mov ebp,esp - - arg Table_de_conversion:dword - - push ebx - push edi - - - ; On place dans EDI l'adresse du début de la brosse - mov edi,Brosse - - ; On place dans EAX le nombre total de pixels à convertir - xor eax,eax - xor ecx,ecx - mov ax,Brosse_Largeur - mov cx,Brosse_Hauteur - mul ecx - - ; On place dans ECX le nb de pixels à traiter - mov ecx,eax - - ; On place dans EBX l'adresse de la table de conversion - mov ebx,Table_de_conversion - - ; On nettoie la partie haute de EAX pour qu'après chaque lecture de AL, - ; EAX puisse servir d'index dans la table de conversion pointée par EBX - xor eax,eax - - Remap_brush_Pour_chaque_pixel: - - ; On lit la couleur du pixel en cours: - mov al,[edi] - - ; On fait la conversion de la couleur à l'aide de la table de conversion - mov al,[ebx+eax] - - ; On replace la nouvelle couleur à l'emplacement en cours - mov [edi],al - - ; On passe au pixel suivant: - inc edi - - dec ecx - jnz Remap_brush_Pour_chaque_pixel - - - pop edi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Remap_brush_LOWLEVEL endp diff --git a/Anciens fichiers/op_asm.asm b/Anciens fichiers/op_asm.asm deleted file mode 100644 index ba4f159d..00000000 --- a/Anciens fichiers/op_asm.asm +++ /dev/null @@ -1,1517 +0,0 @@ -; Grafx2 - The Ultimate 256-color bitmap paint program -; -; Copyright 1996-2001 Sunset Design (Guillaume Dorme & Karl Maritaud) -; -; Grafx2 is free software; you can redistribute it and/or -; modify it under the terms of the GNU General Public License -; as published by the Free Software Foundation; version 2 -; of the License. -; -; Grafx2 is distributed in the hope that it will be useful, -; but WITHOUT ANY WARRANTY; without even the implied warranty of -; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -; GNU General Public License for more details. -; -; You should have received a copy of the GNU General Public License -; along with Grafx2; if not, see or -; write to the Free Software Foundation, Inc., -; 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -.386P -.MODEL FLAT - - -_DATA Segment dword public 'data' - Assume cs:_TEXT, ds:_DATA - - - -; ---- Variables export‚es ---- - -; ---- D‚claration des variables ---- - -; Variables … utilisation g‚n‚rale - - VarA dd 0 - VarB dd 0 - VarC dd 0 - VarD dd 0 - VarE dd 0 - VarF dd 0 - -; Variables pour le dithering Flloyd-Steinberg - - DSFRouge dd 0 - DSFVert dd 0 - DSFBleu dd 0 - DSFRougeAD dd 0 - DSFVertAD dd 0 - DSFBleuAD dd 0 - - - -_DATA ENDS - - - - - - - - - -_TEXT Segment dword public 'code' - Assume cs:_TEXT, ds:_DATA - - - -; ---- Fonctions export‚es ---- - -; -- Fonctions de dithering Flloyd-Steinberg -- -public OPASM_DitherFS_6123 -public OPASM_DitherFS_623 -public OPASM_DitherFS_12 -public OPASM_DitherFS_6 -public OPASM_DitherFS -public OPASM_DitherFS_2 -public OPASM_Compter_occurences -public OPASM_Analyser_cluster -public OPASM_Split_cluster_Rouge -public OPASM_Split_cluster_Vert -public OPASM_Split_cluster_Bleu - - - - -OPASM_DitherFS_6123 proc near - - push ebp - mov ebp,esp - - arg Destination:dword,Source:dword,Largeur:dword,Palette:dword,TableC:dword,ReducR:byte,ReducV:byte,ReducB:byte,NbbV:byte,NbbB:byte - - push ebx - push esi - push edi - - - ; On place dans ESI l'adresse de la source - mov esi,Source - ; On place dans EDI l'adresse de la destination - mov edi,Destination - - ; On place dans VarA la largeur … traiter - mov eax,Largeur - mov VarA,eax - - ; Pour chacun des pixels sur la largeur: - DFS6123_Pour_chaque_pixel: - - ; On regarde la meilleure couleur d'aprŠs la table de conversion 24b->8b - mov edx,[esi] ; EDX = XBVR - xor eax,eax ; EAX = 0000 - xor ebx,ebx ; EBX = 0000 - mov al,dl ; EAX = 000R - mov bl,dh ; EBX = 000V - shr edx,16 ; EDX = 00XB - mov DSFRouge,eax - xor dh,dh ; EDX = 000B - mov DSFVert ,ebx - mov DSFBleu ,edx - mov cl,ReducR - shr eax,cl ; EAX = 000r - mov cl,ReducV - shr ebx,cl ; EBX = 000v - mov cl,ReducB - shr edx,cl ; EDX = 000b - mov cl,NbbV - shl eax,cl ; EAX = 00r0 - or eax,ebx ; EAX = 00rv - mov cl,NbbB - shl eax,cl ; EAX = 0rv0 - mov ebx,TableC ; EBX = Table conversion - or edx,eax ; EDX = 0rvb - xor eax,eax - mov al,[ebx+edx] ; EAX = Table[R,V,B] - - ; On le place dans la destination - mov [edi],al - - ; On regarde la couleur de la palette - mov ebx,Palette - add ebx,eax - shl eax,1 - add ebx,eax ; EBX = &Palette[Table[R,V,B]].R - xor eax,eax - xor ecx,ecx - xor edx,edx - mov al,[ebx+0] ; EAX = 000R - mov cl,[ebx+1] ; ECX = 000V - mov dl,[ebx+2] ; EDX = 000B - - ; On calcule l'erreur - sub eax,DSFRouge - sub ecx,DSFVert - sub edx,DSFBleu - neg eax - neg ecx - neg edx - mov DSFRouge,eax - mov DSFVert ,ecx - mov DSFBleu ,edx - - ; On initialise la quantit‚ d'erreur … diffuser - mov DSFRougeAD,eax - mov DSFVertAD ,ecx - mov DSFBleuAD ,edx - - ; On diffuse l'erreur sur le pixel de droite (6) - mov eax,DSFRouge - mov ebx,DSFVert - mov ecx,DSFBleu - ; "Multiplication sign‚e par 7" - sal eax,3 - sal ebx,3 - sal ecx,3 - sub eax,DSFRouge - sub ebx,DSFVert - sub ecx,DSFBleu - ; Division sign‚e par 16 - sar eax,4 - sar ebx,4 - sar ecx,4 - ; Mise … jour de la quantit‚ … diffuser - sub DSFRougeAD,eax - sub DSFVertAD ,ebx - sub DSFBleuAD ,ecx - ; Diffusion de l'erreur dans la source - add esi,3 - add al,[esi+0] - adc ah,0 - jz DSF6123_6R_Pas_de_debordement - sar ax,16 - not ax - DSF6123_6R_Pas_de_debordement: - add bl,[esi+1] - adc bh,0 - jz DSF6123_6V_Pas_de_debordement - sar bx,16 - not bx - DSF6123_6V_Pas_de_debordement: - add cl,[esi+2] - adc ch,0 - jz DSF6123_6B_Pas_de_debordement - sar cx,16 - not cx - DSF6123_6B_Pas_de_debordement: - mov [esi+0],al - mov [esi+1],bl - mov [esi+2],cl - - ; On diffuse l'erreur sur le pixel en bas … gauche (1) - mov eax,DSFRouge - mov ebx,DSFVert - mov ecx,DSFBleu - ; "Multiplication sign‚e par 3" - sal eax,1 - sal ebx,1 - sal ecx,1 - add eax,DSFRouge - add ebx,DSFVert - add ecx,DSFBleu - ; Division sign‚e par 16 - sar eax,4 - sar ebx,4 - sar ecx,4 - ; Mise … jour de la quantit‚ … diffuser - sub DSFRougeAD,eax - sub DSFVertAD ,ebx - sub DSFBleuAD ,ecx - ; Diffusion de l'erreur dans la source - mov edx,Largeur - shl edx,1 - add edx,Largeur - add esi,edx - add al,[esi+0] - adc ah,0 - jz DSF6123_1R_Pas_de_debordement - sar ax,16 - not ax - DSF6123_1R_Pas_de_debordement: - add bl,[esi+1] - adc bh,0 - jz DSF6123_1V_Pas_de_debordement - sar bx,16 - not bx - DSF6123_1V_Pas_de_debordement: - add cl,[esi+2] - adc ch,0 - jz DSF6123_1B_Pas_de_debordement - sar cx,16 - not cx - DSF6123_1B_Pas_de_debordement: - mov [esi+0],al - mov [esi+1],bl - mov [esi+2],cl - - ; On diffuse l'erreur sur le pixel en bas (2) - mov eax,DSFRouge - mov ebx,DSFVert - mov ecx,DSFBleu - ; Division sign‚e par 4 - sar eax,2 - sar ebx,2 - sar ecx,2 - ; Mise … jour de la quantit‚ … diffuser - sub DSFRougeAD,eax - sub DSFVertAD ,ebx - sub DSFBleuAD ,ecx - ; Diffusion de l'erreur dans la source - add esi,3 - add al,[esi+0] - adc ah,0 - jz DSF6123_2R_Pas_de_debordement - sar ax,16 - not ax - DSF6123_2R_Pas_de_debordement: - add bl,[esi+1] - adc bh,0 - jz DSF6123_2V_Pas_de_debordement - sar bx,16 - not bx - DSF6123_2V_Pas_de_debordement: - add cl,[esi+2] - adc ch,0 - jz DSF6123_2B_Pas_de_debordement - sar cx,16 - not cx - DSF6123_2B_Pas_de_debordement: - mov [esi+0],al - mov [esi+1],bl - mov [esi+2],cl - - ; On diffuse l'erreur sur le pixel en bas … droite (3) - mov eax,DSFRougeAD - mov ebx,DSFVertAD - mov ecx,DSFBleuAD - ; Diffusion de l'erreur dans la source - add esi,3 - add al,[esi+0] - adc ah,0 - jz DSF6123_3R_Pas_de_debordement - sar ax,16 - not ax - DSF6123_3R_Pas_de_debordement: - add bl,[esi+1] - adc bh,0 - jz DSF6123_3V_Pas_de_debordement - sar bx,16 - not bx - DSF6123_3V_Pas_de_debordement: - add cl,[esi+2] - adc ch,0 - jz DSF6123_3B_Pas_de_debordement - sar cx,16 - not cx - DSF6123_3B_Pas_de_debordement: - mov [esi+0],al - mov [esi+1],bl - mov [esi+2],cl - - ; On passe au pixel suivant - sub esi,edx - sub esi,6 - inc edi - dec VarA - jnz DFS6123_Pour_chaque_pixel - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -OPASM_DitherFS_6123 endp - - - -OPASM_DitherFS_623 proc near - - push ebp - mov ebp,esp - - arg Destination:dword,Source:dword,Largeur:dword,Palette:dword,TableC:dword,ReducR:byte,ReducV:byte,ReducB:byte,NbbV:byte,NbbB:byte - - push ebx - push esi - push edi - - - ; On place dans ESI l'adresse de la source - mov esi,Source - ; On place dans EDI l'adresse de la destination - mov edi,Destination - - ; On regarde la meilleure couleur d'aprŠs la table de conversion 24b->8b - mov edx,[esi] ; EDX = XBVR - xor eax,eax ; EAX = 0000 - xor ebx,ebx ; EBX = 0000 - mov al,dl ; EAX = 000R - mov bl,dh ; EBX = 000V - shr edx,16 ; EDX = 00XB - mov DSFRouge,eax - xor dh,dh ; EDX = 000B - mov DSFVert ,ebx - mov DSFBleu ,edx - mov cl,ReducR - shr eax,cl ; EAX = 000r - mov cl,ReducV - shr ebx,cl ; EBX = 000v - mov cl,ReducB - shr edx,cl ; EDX = 000b - mov cl,NbbV - shl eax,cl ; EAX = 00r0 - or eax,ebx ; EAX = 00rv - mov cl,NbbB - shl eax,cl ; EAX = 0rv0 - mov ebx,TableC ; EBX = Table conversion - or edx,eax ; EDX = 0rvb - xor eax,eax - mov al,[ebx+edx] ; EAX = Table[R,V,B] - - ; On le place dans la destination - mov [edi],al - - ; On regarde la couleur de la palette - mov ebx,Palette - add ebx,eax - shl eax,1 - add ebx,eax ; EBX = &Palette[Table[R,V,B]].R - xor eax,eax - xor ecx,ecx - xor edx,edx - mov al,[ebx+0] ; EAX = 000R - mov cl,[ebx+1] ; ECX = 000V - mov dl,[ebx+2] ; EDX = 000B - - ; On calcule l'erreur - sub eax,DSFRouge - sub ecx,DSFVert - sub edx,DSFBleu - neg eax - neg ecx - neg edx - mov DSFRouge,eax - mov DSFVert ,ecx - mov DSFBleu ,edx - - ; On initialise la quantit‚ d'erreur … diffuser - mov DSFRougeAD,eax - mov DSFVertAD ,ecx - mov DSFBleuAD ,edx - - ; On diffuse l'erreur sur le pixel de droite (6) - mov eax,DSFRouge - mov ebx,DSFVert - mov ecx,DSFBleu - ; "Multiplication sign‚e par 7" - sal eax,3 - sal ebx,3 - sal ecx,3 - sub eax,DSFRouge - sub ebx,DSFVert - sub ecx,DSFBleu - ; Division sign‚e par 16 - sar eax,4 - sar ebx,4 - sar ecx,4 - ; Mise … jour de la quantit‚ … diffuser - sub DSFRougeAD,eax - sub DSFVertAD ,ebx - sub DSFBleuAD ,ecx - ; Diffusion de l'erreur dans la source - add esi,3 - add al,[esi+0] - adc ah,0 - jz DSF623_6R_Pas_de_debordement - sar ax,16 - not ax - DSF623_6R_Pas_de_debordement: - add bl,[esi+1] - adc bh,0 - jz DSF623_6V_Pas_de_debordement - sar bx,16 - not bx - DSF623_6V_Pas_de_debordement: - add cl,[esi+2] - adc ch,0 - jz DSF623_6B_Pas_de_debordement - sar cx,16 - not cx - DSF623_6B_Pas_de_debordement: - mov [esi+0],al - mov [esi+1],bl - mov [esi+2],cl - - ; On diffuse l'erreur sur le pixel en bas … gauche (1) - mov eax,DSFRouge - mov ebx,DSFVert - mov ecx,DSFBleu - ; "Multiplication sign‚e par 3" - sal eax,1 - sal ebx,1 - sal ecx,1 - add eax,DSFRouge - add ebx,DSFVert - add ecx,DSFBleu - ; Division sign‚e par 16 - sar eax,4 - sar ebx,4 - sar ecx,4 - ; Mise … jour de la quantit‚ … diffuser - sub DSFRougeAD,eax - sub DSFVertAD ,ebx - sub DSFBleuAD ,ecx - ; Diffusion de l'erreur dans la source - mov edx,Largeur - shl edx,1 - add edx,Largeur - add esi,edx - - ; On diffuse l'erreur sur le pixel en bas (2) - mov eax,DSFRouge - mov ebx,DSFVert - mov ecx,DSFBleu - ; Division sign‚e par 4 - sar eax,2 - sar ebx,2 - sar ecx,2 - ; Mise … jour de la quantit‚ … diffuser - sub DSFRougeAD,eax - sub DSFVertAD ,ebx - sub DSFBleuAD ,ecx - ; Diffusion de l'erreur dans la source - add esi,3 - add al,[esi+0] - adc ah,0 - jz DSF623_2R_Pas_de_debordement - sar ax,16 - not ax - DSF623_2R_Pas_de_debordement: - add bl,[esi+1] - adc bh,0 - jz DSF623_2V_Pas_de_debordement - sar bx,16 - not bx - DSF623_2V_Pas_de_debordement: - add cl,[esi+2] - adc ch,0 - jz DSF623_2B_Pas_de_debordement - sar cx,16 - not cx - DSF623_2B_Pas_de_debordement: - mov [esi+0],al - mov [esi+1],bl - mov [esi+2],cl - - ; On diffuse l'erreur sur le pixel en bas … droite (3) - mov eax,DSFRougeAD - mov ebx,DSFVertAD - mov ecx,DSFBleuAD - ; Diffusion de l'erreur dans la source - add esi,3 - add al,[esi+0] - adc ah,0 - jz DSF623_3R_Pas_de_debordement - sar ax,16 - not ax - DSF623_3R_Pas_de_debordement: - add bl,[esi+1] - adc bh,0 - jz DSF623_3V_Pas_de_debordement - sar bx,16 - not bx - DSF623_3V_Pas_de_debordement: - add cl,[esi+2] - adc ch,0 - jz DSF623_3B_Pas_de_debordement - sar cx,16 - not cx - DSF623_3B_Pas_de_debordement: - mov [esi+0],al - mov [esi+1],bl - mov [esi+2],cl - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -OPASM_DitherFS_623 endp - - - -OPASM_DitherFS_12 proc near - - push ebp - mov ebp,esp - - arg Destination:dword,Source:dword,Largeur:dword,Palette:dword,TableC:dword,ReducR:byte,ReducV:byte,ReducB:byte,NbbV:byte,NbbB:byte - - push ebx - push esi - push edi - - - ; On place dans ESI l'adresse de la source - mov esi,Source - ; On place dans EDI l'adresse de la destination - mov edi,Destination - - ; On regarde la meilleure couleur d'aprŠs la table de conversion 24b->8b - mov edx,[esi] ; EDX = XBVR - xor eax,eax ; EAX = 0000 - xor ebx,ebx ; EBX = 0000 - mov al,dl ; EAX = 000R - mov bl,dh ; EBX = 000V - shr edx,16 ; EDX = 00XB - mov DSFRouge,eax - xor dh,dh ; EDX = 000B - mov DSFVert ,ebx - mov DSFBleu ,edx - mov cl,ReducR - shr eax,cl ; EAX = 000r - mov cl,ReducV - shr ebx,cl ; EBX = 000v - mov cl,ReducB - shr edx,cl ; EDX = 000b - mov cl,NbbV - shl eax,cl ; EAX = 00r0 - or eax,ebx ; EAX = 00rv - mov cl,NbbB - shl eax,cl ; EAX = 0rv0 - mov ebx,TableC ; EBX = Table conversion - or edx,eax ; EDX = 0rvb - xor eax,eax - mov al,[ebx+edx] ; EAX = Table[R,V,B] - - ; On le place dans la destination - mov [edi],al - - ; On regarde la couleur de la palette - mov ebx,Palette - add ebx,eax - shl eax,1 - add ebx,eax ; EBX = &Palette[Table[R,V,B]].R - xor eax,eax - xor ecx,ecx - xor edx,edx - mov al,[ebx+0] ; EAX = 000R - mov cl,[ebx+1] ; ECX = 000V - mov dl,[ebx+2] ; EDX = 000B - - ; On calcule l'erreur - sub eax,DSFRouge - sub ecx,DSFVert - sub edx,DSFBleu - neg eax - neg ecx - neg edx - mov DSFRouge,eax - mov DSFVert ,ecx - mov DSFBleu ,edx - - ; On diffuse l'erreur sur le pixel en bas … gauche (1) - mov eax,DSFRouge - mov ebx,DSFVert - mov ecx,DSFBleu - ; "Multiplication sign‚e par 3" - sal eax,1 - sal ebx,1 - sal ecx,1 - add eax,DSFRouge - add ebx,DSFVert - add ecx,DSFBleu - ; Division sign‚e par 16 - sar eax,4 - sar ebx,4 - sar ecx,4 - ; Diffusion de l'erreur dans la source - mov edx,Largeur - add esi,3 - shl edx,1 - add edx,Largeur - add esi,edx - add al,[esi+0] - adc ah,0 - jz DSF12_1R_Pas_de_debordement - sar ax,16 - not ax - DSF12_1R_Pas_de_debordement: - add bl,[esi+1] - adc bh,0 - jz DSF12_1V_Pas_de_debordement - sar bx,16 - not bx - DSF12_1V_Pas_de_debordement: - add cl,[esi+2] - adc ch,0 - jz DSF12_1B_Pas_de_debordement - sar cx,16 - not cx - DSF12_1B_Pas_de_debordement: - mov [esi+0],al - mov [esi+1],bl - mov [esi+2],cl - - ; On diffuse l'erreur sur le pixel en bas (2) - mov eax,DSFRouge - mov ebx,DSFVert - mov ecx,DSFBleu - ; Division sign‚e par 4 - sar eax,2 - sar ebx,2 - sar ecx,2 - ; Diffusion de l'erreur dans la source - add esi,3 - add al,[esi+0] - adc ah,0 - jz DSF12_2R_Pas_de_debordement - sar ax,16 - not ax - DSF12_2R_Pas_de_debordement: - add bl,[esi+1] - adc bh,0 - jz DSF12_2V_Pas_de_debordement - sar bx,16 - not bx - DSF12_2V_Pas_de_debordement: - add cl,[esi+2] - adc ch,0 - jz DSF12_2B_Pas_de_debordement - sar cx,16 - not cx - DSF12_2B_Pas_de_debordement: - mov [esi+0],al - mov [esi+1],bl - mov [esi+2],cl - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -OPASM_DitherFS_12 endp - - - -OPASM_DitherFS_6 proc near - - push ebp - mov ebp,esp - - arg Destination:dword,Source:dword,Largeur:dword,Palette:dword,TableC:dword,ReducR:byte,ReducV:byte,ReducB:byte,NbbV:byte,NbbB:byte - - push ebx - push esi - push edi - - - ; On place dans ESI l'adresse de la source - mov esi,Source - ; On place dans EDI l'adresse de la destination - mov edi,Destination - - ; On place dans VarA la largeur … traiter - mov eax,Largeur - mov VarA,eax - - ; Pour chacun des pixels sur la largeur: - DFS6_Pour_chaque_pixel: - - ; On regarde la meilleure couleur d'aprŠs la table de conversion 24b->8b - mov edx,[esi] ; EDX = XBVR - xor eax,eax ; EAX = 0000 - xor ebx,ebx ; EBX = 0000 - mov al,dl ; EAX = 000R - mov bl,dh ; EBX = 000V - shr edx,16 ; EDX = 00XB - mov DSFRouge,eax - xor dh,dh ; EDX = 000B - mov DSFVert ,ebx - mov DSFBleu ,edx - mov cl,ReducR - shr eax,cl ; EAX = 000r - mov cl,ReducV - shr ebx,cl ; EBX = 000v - mov cl,ReducB - shr edx,cl ; EDX = 000b - mov cl,NbbV - shl eax,cl ; EAX = 00r0 - or eax,ebx ; EAX = 00rv - mov cl,NbbB - shl eax,cl ; EAX = 0rv0 - mov ebx,TableC ; EBX = Table conversion - or edx,eax ; EDX = 0rvb - xor eax,eax - mov al,[ebx+edx] ; EAX = Table[R,V,B] - - ; On le place dans la destination - mov [edi],al - - ; On regarde la couleur de la palette - mov ebx,Palette - add ebx,eax - shl eax,1 - add ebx,eax ; EBX = &Palette[Table[R,V,B]].R - xor eax,eax - xor ecx,ecx - xor edx,edx - mov al,[ebx+0] ; EAX = 000R - mov cl,[ebx+1] ; ECX = 000V - mov dl,[ebx+2] ; EDX = 000B - - ; On calcule l'erreur - sub eax,DSFRouge - sub ecx,DSFVert - sub edx,DSFBleu - neg eax - neg ecx - neg edx - mov DSFRouge,eax - mov DSFVert ,ecx - mov DSFBleu ,edx - - ; On diffuse l'erreur sur le pixel de droite (6) - mov eax,DSFRouge - mov ebx,DSFVert - mov ecx,DSFBleu - ; "Multiplication sign‚e par 7" - sal eax,3 - sal ebx,3 - sal ecx,3 - sub eax,DSFRouge - sub ebx,DSFVert - sub ecx,DSFBleu - ; Division sign‚e par 16 - sar eax,4 - sar ebx,4 - sar ecx,4 - ; Diffusion de l'erreur dans la source - add esi,3 - add al,[esi+0] - adc ah,0 - jz DSF6_6R_Pas_de_debordement - sar ax,16 - not ax - DSF6_6R_Pas_de_debordement: - add bl,[esi+1] - adc bh,0 - jz DSF6_6V_Pas_de_debordement - sar bx,16 - not bx - DSF6_6V_Pas_de_debordement: - add cl,[esi+2] - adc ch,0 - jz DSF6_6B_Pas_de_debordement - sar cx,16 - not cx - DSF6_6B_Pas_de_debordement: - mov [esi+0],al - mov [esi+1],bl - mov [esi+2],cl - - ; On passe au pixel suivant - inc edi - dec VarA - jnz DFS6_Pour_chaque_pixel - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -OPASM_DitherFS_6 endp - - - -OPASM_DitherFS proc near - - push ebp - mov ebp,esp - - arg Destination:dword,Source:dword,TableC:dword,ReducR:byte,ReducV:byte,ReducB:byte,NbbV:byte,NbbB:byte - - push ebx - push esi - push edi - - - ; On place dans ESI l'adresse de la source - mov esi,Source - ; On place dans EDI l'adresse de la destination - mov edi,Destination - - ; On regarde la meilleure couleur d'aprŠs la table de conversion 24b->8b - mov edx,[esi] ; EDX = XBVR - xor eax,eax ; EAX = 0000 - xor ebx,ebx ; EBX = 0000 - mov al,dl ; EAX = 000R - mov bl,dh ; EBX = 000V - shr edx,16 ; EDX = 00XB - mov DSFRouge,eax - xor dh,dh ; EDX = 000B - mov DSFVert ,ebx - mov DSFBleu ,edx - mov cl,ReducR - shr eax,cl ; EAX = 000r - mov cl,ReducV - shr ebx,cl ; EBX = 000v - mov cl,ReducB - shr edx,cl ; EDX = 000b - mov cl,NbbV - shl eax,cl ; EAX = 00r0 - or eax,ebx ; EAX = 00rv - mov cl,NbbB - shl eax,cl ; EAX = 0rv0 - mov ebx,TableC ; EBX = Table conversion - or edx,eax ; EDX = 0rvb - xor eax,eax - mov al,[ebx+edx] ; EAX = Table[R,V,B] - - ; On le place dans la destination - mov [edi],al - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -OPASM_DitherFS endp - - - -OPASM_DitherFS_2 proc near - - push ebp - mov ebp,esp - - arg Destination:dword,Source:dword,Hauteur:dword,Palette:dword,TableC:dword,ReducR:byte,ReducV:byte,ReducB:byte,NbbV:byte,NbbB:byte - - push ebx - push esi - push edi - - - ; On place dans ESI l'adresse de la source - mov esi,Source - ; On place dans EDI l'adresse de la destination - mov edi,Destination - - ; On place dans VarA la hauteur … traiter - mov eax,Hauteur - mov VarA,eax - - ; Pour chacun des pixels sur la largeur: - DFS2_Pour_chaque_pixel: - - ; On regarde la meilleure couleur d'aprŠs la table de conversion 24b->8b - mov edx,[esi] ; EDX = XBVR - xor eax,eax ; EAX = 0000 - xor ebx,ebx ; EBX = 0000 - mov al,dl ; EAX = 000R - mov bl,dh ; EBX = 000V - shr edx,16 ; EDX = 00XB - mov DSFRouge,eax - xor dh,dh ; EDX = 000B - mov DSFVert ,ebx - mov DSFBleu ,edx - mov cl,ReducR - shr eax,cl ; EAX = 000r - mov cl,ReducV - shr ebx,cl ; EBX = 000v - mov cl,ReducB - shr edx,cl ; EDX = 000b - mov cl,NbbV - shl eax,cl ; EAX = 00r0 - or eax,ebx ; EAX = 00rv - mov cl,NbbB - shl eax,cl ; EAX = 0rv0 - mov ebx,TableC ; EBX = Table conversion - or edx,eax ; EDX = 0rvb - xor eax,eax - mov al,[ebx+edx] ; EAX = Table[R,V,B] - - ; On le place dans la destination - mov [edi],al - - ; On regarde la couleur de la palette - mov ebx,Palette - add ebx,eax - shl eax,1 - add ebx,eax ; EBX = &Palette[Table[R,V,B]].R - xor eax,eax - xor ecx,ecx - xor edx,edx - mov al,[ebx+0] ; EAX = 000R - mov cl,[ebx+1] ; ECX = 000V - mov dl,[ebx+2] ; EDX = 000B - - ; On calcule l'erreur - sub eax,DSFRouge - sub ecx,DSFVert - sub edx,DSFBleu - neg eax - neg ecx - neg edx - mov DSFRouge,eax - mov DSFVert ,ecx - mov DSFBleu ,edx - - ; On diffuse l'erreur sur le pixel en bas (2) - mov eax,DSFRouge - mov ebx,DSFVert - mov ecx,DSFBleu - ; Division sign‚e par 4 - sar eax,2 - sar ebx,2 - sar ecx,2 - ; Diffusion de l'erreur dans la source - add esi,3 - add al,[esi+0] - adc ah,0 - jz DSF2_2R_Pas_de_debordement - sar ax,16 - not ax - DSF2_2R_Pas_de_debordement: - add bl,[esi+1] - adc bh,0 - jz DSF2_2V_Pas_de_debordement - sar bx,16 - not bx - DSF2_2V_Pas_de_debordement: - add cl,[esi+2] - adc ch,0 - jz DSF2_2B_Pas_de_debordement - sar cx,16 - not cx - DSF2_2B_Pas_de_debordement: - mov [esi+0],al - mov [esi+1],bl - mov [esi+2],cl - - ; On passe au pixel suivant - inc edi - dec VarA - jnz DFS2_Pour_chaque_pixel - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -OPASM_DitherFS_2 endp - - - -OPASM_Compter_occurences proc near - - push ebp - mov ebp,esp - - arg destination:dword,source:dword,taille:dword,reducR:byte,reducV:byte,reducB:byte,nbbV:byte,nbbB:byte - - push ebx - push esi - push edi - - - ; On place dans ESI l'adresse de la source - mov esi,source - ; On place dans EDI l'adresse de la destination - mov edi,destination - - ; On place dans VarA le nb de pixels … traiter - mov eax,taille - mov VarA,eax - - ; Pour chacun des pixels: - CO_Pour_chaque_pixel: - - ; On regarde la couleur - xor eax,eax ; EAX = 0000 - xor ebx,ebx ; EBX = 0000 - xor edx,edx ; EDX = 0000 - mov al,[esi] ; EAX = 000R - mov dx,[esi+1] ; EDX = 00BV - mov cl,reducR - xchg bl,dh ; EBX = 000B EDX = 000V - shr eax,cl ; EAX = 000r - mov cl,reducV - shr edx,cl ; EDX = 000v - mov cl,reducB - shr ebx,cl ; EBX = 000b - mov cl,nbbV - shl eax,cl ; EAX = 00r0 - or eax,edx ; EAX = 00rv - mov cl,nbbB - shl eax,cl ; EAX = 0rv0 - or eax,ebx ; EAX = 0rvb - shl eax,2 ; EAX = 0rvb * 4 - inc dword ptr[edi+eax] - - ; On passe au pixel suivant - add esi,3 - dec VarA - jnz CO_Pour_chaque_pixel - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -OPASM_Compter_occurences endp - - - - -OPASM_Analyser_cluster proc near - - push ebp - mov ebp,esp - - arg tableO:dword,rmin:dword,vmin:dword,bmin:dword,rmax:dword,vmax:dword,bmax:dword,rdec:dword,vdec:dword,bdec:dword,rinc:dword,vinc:dword,binc:dword,nbocc:dword - - push ebx - push esi - push edi - - - ; On place dans ESI l'adresse de base de la table d'occurence - mov esi,tableO - - ; On place dans DSF????? la valeur minimale des teintes - mov eax,[rmin] - mov ebx,[vmin] - mov ecx,[bmin] - mov eax,[eax] - mov ebx,[ebx] - mov ecx,[ecx] - mov DSFRouge,eax - mov DSFVert ,ebx - mov DSFBleu ,ecx - ; On place dans VarDEF la valeur maximale courante des teintes - mov VarD,eax - mov VarE,ebx - mov VarF,ecx - ; On place dans DSF?????AD la valeur maximale des teintes - mov eax,[rmax] - mov ebx,[vmax] - mov ecx,[bmax] - mov eax,[eax] - mov ebx,[ebx] - mov ecx,[ecx] - mov DSFRougeAD,eax - mov DSFVertAD ,ebx - mov DSFBleuAD ,ecx - ; On place dans VarABC la valeur minimale courante des teintes - mov VarA,eax - mov VarB,ebx - mov VarC,ecx - - ; On place dans EDI le nombre d'occurences - xor edi,edi - - ; Pour chaque Rouge - mov ebx,DSFRouge - AC_Pour_chaque_rouge: - - ; Pour chaque Vert - mov ecx,DSFVert - AC_Pour_chaque_vert: - - ; Pour chaque Bleu - mov edx,DSFBleu - AC_Pour_chaque_bleu: - - ; On regarde le nombre d'occurences (=>EAX) - mov eax,ebx - or eax,ecx - or eax,edx - shl eax,2 - mov eax,[esi+eax] - - ; S'il y a des occurences - or eax,eax - jz AC_Pas_d_occurences - - ; On incr‚mente le compteur - add edi,eax - - ; On met … jour les bornes - cmp ebx,VarA ; r ? rmin - jae AC_r_sup_rmin - mov VarA,ebx - AC_r_sup_rmin: - cmp ebx,VarD ; r ? rmax - jbe AC_r_inf_rmax - mov VarD,ebx - AC_r_inf_rmax: - cmp ecx,VarB ; v ? vmin - jae AC_v_sup_vmin - mov VarB,ecx - AC_v_sup_vmin: - cmp ecx,VarE ; v ? vmax - jbe AC_v_inf_vmax - mov VarE,ecx - AC_v_inf_vmax: - cmp edx,VarC ; b ? bmin - jae AC_b_sup_bmin - mov VarC,edx - AC_b_sup_bmin: - cmp edx,VarF ; b ? bmax - jbe AC_b_inf_bmax - mov VarF,edx - AC_b_inf_bmax: - - AC_Pas_d_occurences: - - ; On passe au bleu suivant - add edx,binc - cmp edx,DSFBleuAD - jbe AC_Pour_chaque_bleu - - ; On passe au vert suivant - add ecx,vinc - cmp ecx,DSFVertAD - jbe AC_Pour_chaque_vert - - ; On passe au rouge suivant - add ebx,rinc - cmp ebx,DSFRougeAD - jbe AC_Pour_chaque_rouge - - ; On retourne les r‚sultats - ; Nb d'occurences - mov eax,nbocc - mov [eax],edi - ; Rmin & Rmax - mov eax,VarA - mov ebx,VarD - mov ecx,rdec - mov edx,rmin - mov edi,rmax - shr eax,cl - shr ebx,cl - mov [edx],eax - mov [edi],ebx - ; Vmin & Vmax - mov eax,VarB - mov ebx,VarE - mov ecx,vdec - mov edx,vmin - mov edi,vmax - shr eax,cl - shr ebx,cl - mov [edx],eax - mov [edi],ebx - ; Bmin & Bmax - mov eax,VarC - mov ebx,VarF - mov ecx,bdec - mov edx,bmin - mov edi,bmax - shr eax,cl - shr ebx,cl - mov [edx],eax - mov [edi],ebx - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -OPASM_Analyser_cluster endp - - - - -OPASM_Split_cluster_Rouge proc near - - push ebp - mov ebp,esp - - arg tableO:dword,rmin:dword,vmin:dword,bmin:dword,rmax:dword,vmax:dword,bmax:dword,rinc:dword,vinc:dword,binc:dword,limite:dword,rdec:dword,rouge:dword - - push ebx - push esi - push edi - - - ; On place dans ESI l'adresse de base de la table d'occurence - mov esi,tableO - - ; On place dans EDI le nombre d'occurences - xor edi,edi - - ; Pour chaque Rouge - mov ebx,rmin - SCR_Pour_chaque_rouge: - - ; Pour chaque Vert - mov ecx,vmin - SCR_Pour_chaque_vert: - - ; Pour chaque Bleu - mov edx,bmin - SCR_Pour_chaque_bleu: - - ; On regarde le nombre d'occurences (=>EAX) - mov eax,ebx - or eax,ecx - or eax,edx - shl eax,2 - mov eax,[esi+eax] - - ; On le rajoute … EDI - add edi,eax - cmp edi,limite - jae SCR_Fin_recherche - - ; On passe au bleu suivant - add edx,binc - cmp edx,bmax - jbe SCR_Pour_chaque_bleu - - ; On passe au vert suivant - add ecx,vinc - cmp ecx,vmax - jbe SCR_Pour_chaque_vert - - ; On passe au rouge suivant - add ebx,rinc - cmp ebx,rmax - jbe SCR_Pour_chaque_rouge - - SCR_Fin_recherche: - - ; On retourne le r‚sultat - mov ecx,rdec - shr ebx,cl - mov eax,rouge - mov [eax],ebx - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -OPASM_Split_cluster_Rouge endp - - - -OPASM_Split_cluster_Vert proc near - - push ebp - mov ebp,esp - - arg tableO:dword,rmin:dword,vmin:dword,bmin:dword,rmax:dword,vmax:dword,bmax:dword,rinc:dword,vinc:dword,binc:dword,limite:dword,vdec:dword,vert:dword - - push ebx - push esi - push edi - - - ; On place dans ESI l'adresse de base de la table d'occurence - mov esi,tableO - - ; On place dans EDI le nombre d'occurences - xor edi,edi - - ; Pour chaque Vert - mov ebx,vmin - SCV_Pour_chaque_vert: - - ; Pour chaque Rouge - mov ecx,rmin - SCV_Pour_chaque_rouge: - - ; Pour chaque Bleu - mov edx,bmin - SCV_Pour_chaque_bleu: - - ; On regarde le nombre d'occurences (=>EAX) - mov eax,ebx - or eax,ecx - or eax,edx - shl eax,2 - mov eax,[esi+eax] - - ; On le rajoute … EDI - add edi,eax - cmp edi,limite - jae SCV_Fin_recherche - - ; On passe au bleu suivant - add edx,binc - cmp edx,bmax - jbe SCV_Pour_chaque_bleu - - ; On passe au rouge suivant - add ecx,rinc - cmp ecx,rmax - jbe SCV_Pour_chaque_rouge - - ; On passe au vert suivant - add ebx,vinc - cmp ebx,vmax - jbe SCV_Pour_chaque_vert - - SCV_Fin_recherche: - - ; On retourne le r‚sultat - mov ecx,vdec - shr ebx,cl - mov eax,vert - mov [eax],ebx - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -OPASM_Split_cluster_Vert endp - - - -OPASM_Split_cluster_Bleu proc near - - push ebp - mov ebp,esp - - arg tableO:dword,rmin:dword,vmin:dword,bmin:dword,rmax:dword,vmax:dword,bmax:dword,rinc:dword,vinc:dword,binc:dword,limite:dword,bdec:dword,bleu:dword - - push ebx - push esi - push edi - - - ; On place dans ESI l'adresse de base de la table d'occurence - mov esi,tableO - - ; On place dans EDI le nombre d'occurences - xor edi,edi - - ; Pour chaque Bleu - mov ebx,bmin - SCB_Pour_chaque_bleu: - - ; Pour chaque Rouge - mov ecx,rmin - SCB_Pour_chaque_rouge: - - ; Pour chaque Vert - mov edx,vmin - SCB_Pour_chaque_vert: - - ; On regarde le nombre d'occurences (=>EAX) - mov eax,ebx - or eax,ecx - or eax,edx - shl eax,2 - mov eax,[esi+eax] - - ; On le rajoute … EDI - add edi,eax - cmp edi,limite - jae SCB_Fin_recherche - - ; On passe au vert suivant - add edx,vinc - cmp edx,vmax - jbe SCB_Pour_chaque_vert - - ; On passe au rouge suivant - add ecx,rinc - cmp ecx,rmax - jbe SCB_Pour_chaque_rouge - - ; On passe au bleu suivant - add ebx,binc - cmp ebx,bmax - jbe SCB_Pour_chaque_bleu - - SCB_Fin_recherche: - - ; On retourne le r‚sultat - mov ecx,bdec - shr ebx,cl - mov eax,bleu - mov [eax],ebx - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -OPASM_Split_cluster_Bleu endp - - - - -_TEXT ENDS -END diff --git a/Anciens fichiers/vesahigh.c b/Anciens fichiers/vesahigh.c deleted file mode 100644 index 0522ea41..00000000 --- a/Anciens fichiers/vesahigh.c +++ /dev/null @@ -1,221 +0,0 @@ -/* Grafx2 - The Ultimate 256-color bitmap paint program - - Copyright 1996-2001 Sunset Design (Guillaume Dorme & Karl Maritaud) - - Grafx2 is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License - as published by the Free Software Foundation; version 2 - of the License. - - Grafx2 is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with Grafx2; if not, see or - write to the Free Software Foundation, Inc., - 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -*/ -#include -#include "vesalfb.h" - - -// - -- --- ----\/\ Detection du support VESA sur la machine: /\/---- --- -- - - -void Support_VESA(void) -{ - struct S_Buffer_VESA Buffer_VESA; - word Retour; - - VESA_Erreur=0; - - // Lecture des infos du VESA: - Retour=Get_VESA_info(&Buffer_VESA); - if (Retour==0x004F) - { - // Les interruptions VESA sont interprˆt‚es par la carte vid‚o - - if (memcmp(Buffer_VESA.Signature,"VESA",4)==0) - { - // La signature "VESA" est bien pr‚sente - VESA_Liste_des_modes =Buffer_VESA.Liste_des_modes; - VESA_Version_Unite =(Buffer_VESA.Version >> 8); - VESA_Version_Decimale=(Buffer_VESA.Version & 0xFF); - strncpy(VESA_Constructeur,Buffer_VESA.Fabricant,TAILLE_NOM_CONSTRUCTEUR); - VESA_Constructeur[TAILLE_NOM_CONSTRUCTEUR]='\0'; - VESA_Taille_memoire =Buffer_VESA.Memoire; - } - else - { - // Pas de signature VESA sur la carte - VESA_Erreur=1; - } - - } - else - { - // La carte vid‚o n'a jamais entendu parler du VESA - VESA_Erreur=1; - } -} - - - -// - -- --- -----\/\ Detection du support VESA pour un mode: /\/----- --- -- - - -void Mode_VESA_supporte(word Mode,int Indice_mode) -{ - struct S_Buffer_VESA Buffer_VESA; - struct S_Buffer_mode_VESA Buffer_mode_VESA; - word Retour; - int Code_fenetres=0; - int Granularite=0; - int Indice; - int Taille; - - VESA_Erreur=0; - - /* - On va commencer par regarder si le mode n'est pas dans la liste de ceux - support‚s par la carte. Pour cela, il nous faut redemander cette liste - car certaines cartes la "perdent" d'un appel sur l'autre. - */ - - // Lecture des infos du VESA: - Retour=Get_VESA_info(&Buffer_VESA); - if (Retour==0x004F) - { - // Les interruptions VESA sont interprˆt‚es par la carte vid‚o - - Taille=65536L*(int)Buffer_VESA.Memoire; - - // On regarde si le mode se trouve dans la liste - for (Indice=0;Buffer_VESA.Liste_des_modes[Indice]!=0xFFFF;Indice++) - if (Buffer_VESA.Liste_des_modes[Indice]==Mode) - break; - - if (Buffer_VESA.Liste_des_modes[Indice]==Mode) - { - // Le mode est dans la liste - - // Lecture des infos du mode VESA: - Retour=Get_VESA_mode_info(Mode,&Buffer_mode_VESA); - - if (Retour==0x004F) - { - if ((Buffer_mode_VESA.Attributs & 1)==0) - VESA_Erreur=1; - - // On calcule le facteur de granularit‚: - switch(Buffer_mode_VESA.Granularite) - { - case 64 : - Granularite=0; - break; - case 32 : - Granularite=1; - break; - case 16 : - Granularite=2; - break; - case 8 : - Granularite=3; - break; - case 4 : - Granularite=4; - break; - case 2 : - Granularite=5; - break; - case 1 : - Granularite=6; - break; - default : - VESA_Erreur=1; - }; - - // On calcule le code des fenˆtres: - // 0 = Lecture & ‚criture dans A - // 1 = Lecture & ‚criture dans B - // 2 = Lecture dans A et ‚criture dans B - // 3 = Lecture dans B et ‚criture dans A - - if ((Buffer_mode_VESA.Attributs_fenetre_A & 7)==7) - // La fenˆtre A suffit … tout faire (lecture & ‚criture) - Code_fenetres=0; - else - { - if ((Buffer_mode_VESA.Attributs_fenetre_B & 7)==7) - // La fenˆtre B suffit … tout faire (lecture & ‚criture) - Code_fenetres=1; - else - { - // La fenˆtre B ne suffira pas … tout faire - - if ( ((Buffer_mode_VESA.Attributs_fenetre_A & 3)==3) && - ((Buffer_mode_VESA.Attributs_fenetre_B & 5)==5) ) - // La fenˆtre A est lisible et la fenˆtre B inscriptible - Code_fenetres=2; - else - { - if ( ((Buffer_mode_VESA.Attributs_fenetre_B & 3)==3) && - ((Buffer_mode_VESA.Attributs_fenetre_A & 5)==5) ) - // La fenˆtre B est lisible et la fenˆtre A inscriptible - Code_fenetres=3; - else - VESA_Erreur=1; - } - } - } - - // On v‚rifie que la taille des fenˆtres soit bien de 64Ko: - if (Buffer_mode_VESA.Taille_fenetres!=64) - VESA_Erreur=1; - - if ( (VESA_Erreur==0) || - ((Buffer_mode_VESA.Attributs & 128) && - (Buffer_mode_VESA.Adresse_LFB!=0)) ) - { - VESA_Erreur=0; - VESA_Mode_Infos[Indice_mode].Granularite=Granularite; - VESA_Mode_Infos[Indice_mode].Code_fenetres=Code_fenetres; - Get_VESA_protected_mode_WinFuncPtr(); - VESA_Mode_Infos[Indice_mode].WinFuncPtr=VESA_WinFuncPtr; - if (Buffer_mode_VESA.Attributs & 128) - { - // LFB support‚ - VESA_Mode_Infos[Indice_mode].Adresse_physique_LFB=Buffer_mode_VESA.Adresse_LFB; - VESA_Mode_Infos[Indice_mode].Taille_LFB=Taille; - } - else - VESA_Mode_Infos[Indice_mode].Adresse_physique_LFB=0; - } - } - else - { - // Le mode est renseign‚ dans la liste mais n'est pas support‚ - VESA_Erreur=1; - } - } - else - { - // Le mode n'est pas dans la liste - VESA_Erreur=1; - } - } - else - { - // La carte vid‚o n'a jamais entendu parler du VESA - VESA_Erreur=1; - } - - // Si le mode n'est pas support‚, on disable les modes vid‚os bas‚s sur - // ce mode VESA: - if (VESA_Erreur!=0) - for (Indice=0;Indice or -; write to the Free Software Foundation, Inc., -; 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -.386P -.MODEL FLAT - - -_DATA Segment dword public 'data' - Assume cs:_TEXT, ds:_DATA - - - -; ---- Variables exportées ---- - -public LFB_Selecteur -public LFB_Adresse -public LFB_Taille - - - -; ---- Déclaration des variables ---- - - LFB_Selecteur dw 0 ; Sélecteur utilisé par le mapping du LFB - LFB_Adresse dd 0 ; Adresse où est mappée le LFB - LFB_Taille dd 0 ; Taille de la mémoire LFB - - Handle_temporaire dw 0 ; Handle de bloc mémoire DOS utilisé temporairement - - -_DATA ENDS - - - - - - - - - -_TEXT Segment dword public 'code' - Assume cs:_TEXT, ds:_DATA - - - -; ---- Fonctions exportées ---- - -; -- Fonctions VESA -- -public Get_VESA_info -public Get_VESA_mode_info -public Get_VESA_protected_mode_WinFuncPtr -public Set_VESA_mode -public Initialiser_le_LFB -public Fermer_le_LFB - -public Pixel_VESA_LFB -public Lit_pixel_VESA_LFB -public Effacer_tout_l_ecran_VESA_LFB -public Block_VESA_LFB -public Pixel_Preview_Normal_VESA_LFB -public Pixel_Preview_Loupe_VESA_LFB -public Ligne_horizontale_XOR_VESA_LFB -public Ligne_verticale_XOR_VESA_LFB -public Display_brush_Color_VESA_LFB -public Display_brush_Mono_VESA_LFB -public Clear_brush_VESA_LFB -public Remap_screen_VESA_LFB -public Afficher_partie_de_l_ecran_VESA_LFB -public Afficher_une_ligne_a_l_ecran_VESA_LFB -public Lire_une_ligne_a_l_ecran_VESA_LFB -public Afficher_partie_de_l_ecran_zoomee_VESA_LFB -public Display_brush_Color_Zoom_VESA_LFB -public Display_brush_Mono_Zoom_VESA_LFB -public Clear_brush_Zoom_VESA_LFB - -; ---- Fonctions importées ---- - -; -- Fonctions DPMI -- -extrn Physical_address_mapping :near -extrn Free_physical_address_mapping:near -extrn Lock_linear_region :near -extrn Unlock_linear_region :near -extrn Allocate_ldt_descriptor :near -extrn Free_ldt_descriptor :near -extrn Set_segment_base_address :near -extrn Set_segment_limit :near -extrn Set_descriptor_access_rights :near -extrn Get_segment_base_address :near - -; -- Autres variables externes -- -extrn Brosse:dword -extrn Principal_Ecran:dword -extrn Principal_Decalage_X:word -extrn Principal_Decalage_Y:word -extrn Largeur_ecran:word -extrn Hauteur_ecran:word -extrn Menu_Ordonnee:word -extrn Principal_X_Zoom:word - -extrn Table_mul_facteur_zoom:dataptr ; Table de multiplication par le facteur -extrn Loupe_Decalage_X:word -extrn Loupe_Decalage_Y:word -extrn Loupe_Facteur :word - -extrn Limite_Haut_Zoom :word -extrn Limite_Gauche_Zoom :word -extrn Limite_visible_Bas_Zoom :word -extrn Limite_visible_Droite_Zoom:word - -extrn VESA_WinFuncPtr:dword - -; -- Procédures externes -- -extrn Zoomer_une_ligne:near - - - - -; - -- --- ----\/\ Lecture des informations VESA : /\/---- --- -- - - -Convertir_adresse_MR_MP proc near - - ; EDI = Adresse d'une adresse à corriger - - push eax - push ecx - - mov eax,[edi] ; EAX = adresse à corriger - mov ecx,eax - shr eax,16 - shl eax,4 - and ecx,0FFFFh - add eax,ecx - mov [edi],eax - - pop ecx - pop eax - - ret - -Convertir_adresse_MR_MP endp - - - -Get_VESA_info proc near - - push ebp - mov ebp,esp - - arg Buffer:dword - - push ebx - push esi - push edi - - - ; On commence par allouer un buffer en mode réel de 1024+64 octets - mov ax,0100h ; "DPMI : Allocate Dos memory blocks" - mov bx,68d ; BX = (1024+64)/16 = 68 paragraphes - int 31h - jc GVI_Erreur - - ; On sauve l'handle du buffer dans la pile - push dx - - ; On place dans EDX l'adresse du buffer - xor edx,edx - mov dx,ax - shl edx,4 - - ; On nettoie ce(s) buffer(s) - mov edi,edx ; On place en EDX - xor eax,eax ; ... la valeur 0 - mov ecx,0110h ; ... sur 1024+64 positions - rep stosd ; !!! Maintenant !!! - - ; On demande les infos VESA: (AX=4F00, ES:DI=Adresse du buffer) - mov edi,edx ; Adresse des valeurs des registres à passer à l'interruption - add edx,40h ; EDX=segment du buffer d'infos VESA - shr edx,4 - mov dword ptr[edi+1Ch],00004F00h ; EAX passé à l'interruption - mov dword ptr[edi+00h],00000000h ; EDI passé à l'interruption - mov word ptr[edi+22h],dx ; ES passé à l'interruption - shl edx,4 - mov dword ptr[edx],32454256h ; valeur hexa de "VBE2" - mov ax,0300h ; Service DPMI simuler une interruption en mode réel - mov bl,10h ; Interruption à appeler (int vidéo) - xor bh,bh ; Flags de mode d'appel d'interruption - xor cx,cx ; Nb d'elements de la pile à passer - int 31h ; Appel de l'interruption du DPMI - - ; On place dans EBX la valeur EAX de retour de l'interruption - mov ebx,dword ptr[edi+1Ch] - - ; On recopie le buffer du mode réel vers le mode protégé - mov ecx,256 ; (256 dword = 1024 octets) - mov esi,edx - mov edi,Buffer - rep movsd - - ; Puis on corrige chacune des adresses: - mov edi,Buffer - add edi,06h - call Convertir_adresse_MR_MP ; Fabricant - add edi,08h - call Convertir_adresse_MR_MP ; Liste des modes - add edi,08h - call Convertir_adresse_MR_MP ; Vendeur - add edi,04h - call Convertir_adresse_MR_MP ; Produit - add edi,04h - call Convertir_adresse_MR_MP ; Révision - - ; On libŠre le buffer en mode réel de 1024+64 octets - mov ax,0101h ; "DPMI : Free Dos memory blocks" - pop dx ; DX = handle du buffer - int 31h - jnc GVI_Pas_d_erreur - - - GVI_Erreur: - - mov bx,0FF00h - - GVI_Pas_d_erreur: - - mov ax,bx - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Get_VESA_info endp - - - - - - -Get_VESA_mode_info proc near - - push ebp - mov ebp,esp - - arg Mode:word,Buffer:dword - - push ebx - push esi - push edi - - - ; On commence par allouer un buffer en mode réel de 256+64 octets - mov ax,0100h ; "DPMI : Allocate Dos memory blocks" - mov bx,20d ; BX = (256+64)/16 = 20 paragraphes - int 31h - jc GVMI_Erreur - - ; On sauve l'handle du buffer dans la pile - push dx - - ; On place dans EDX l'adresse du buffer - xor edx,edx - mov dx,ax - shl edx,4 - - ; On nettoie ce(s) buffer(s) - mov edi,edx ; On place en EDX - xor eax,eax ; ... la valeur 0 - mov ecx,0080d ; ... sur 256+64 positions - rep stosd ; !!! Maintenant !!! - - ; On demande les infos VESA: (AX=4F01, CX=Mode, ES:DI=Adresse du buffer) - mov edi,edx ; Adresse des valeurs des registres à passer à l'interruption - add edx,40h ; EDX=segment du buffer d'infos VESA - shr edx,4 - mov ax,Mode ; ECX=Mode vidéo dont ont recherche les informations - mov dword ptr[edi+1Ch],00004F01h ; EAX passé à l'interruption - mov word ptr[edi+18h],ax ; ECX passé à l'interruption - mov dword ptr[edi+00h],00000000h ; EDI passé à l'interruption - mov word ptr[edi+22h],dx ; ES passé à l'interruption - shl edx,4 - mov ax,0300h ; Service DPMI simuler une interruption en mode réel - mov bl,10h ; Interruption à appeler (int vidéo) - xor bh,bh ; Flags de mode d'appel d'interruption - xor cx,cx ; Nb d'elements de la pile à passer - int 31h ; Appel de l'interruption du DPMI - - ; On place dans EBX la valeur EAX de retour de l'interruption - mov ebx,dword ptr[edi+1Ch] - - ; On recopie le buffer du mode réel vers le mode protégé - mov ecx,64 ; (64 dword = 256 octets) - mov esi,edx - mov edi,Buffer - rep movsd - - ; Puis on corrige chacune des adresses: - mov edi,Buffer - add edi,0Ch - call Convertir_adresse_MR_MP ; Adresse WinFuncPtr (Mode réel) - - ; On libŠre le buffer en mode réel de 256+64 octets - mov ax,0101h ; "DPMI : Free Dos memory blocks" - pop dx ; DX = handle du buffer - int 31h - jnc GVMI_Pas_d_erreur - - - GVMI_Erreur: - - mov bx,0FF00h - - GVMI_Pas_d_erreur: - - mov ax,bx - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Get_VESA_mode_info endp - - - - - -; Renvoie dans EAX l'adresse de la fonction WinFuncPtr du mode protégé - -Get_VESA_protected_mode_WinFuncPtr proc near - - push ebx - push edi - - - mov VESA_WinFuncPtr,00000000h - - ; On commence par allouer un buffer en mode réel de 64 octets - mov ax,0100h ; "DPMI : Allocate Dos memory blocks" - mov bx,4d ; BX = 64/16 = 4 paragraphes - int 31h - jc GVPMW_Erreur_d_allocation_de_memoire - - ; On sauve l'handle du buffer - mov Handle_temporaire,dx - - ; On place dans EDX l'adresse du buffer - xor edx,edx - mov dx,ax - shl edx,4 - - ; On nettoie ce buffer - mov edi,edx ; On place en EDX - xor eax,eax ; ... la valeur 0 - mov ecx,0016d ; ... sur 64 positions - rep stosd ; !!! Maintenant !!! - - ; On demande les infos VESA PMI: (AX=4F0A, BX=0) - mov ax,0300h ; Service DPMI simuler une interruption en mode réel - mov bl,10h ; Interruption à appeler (int vidéo) - xor bh,bh ; Flags de mode d'appel d'interruption - xor cx,cx ; Nb d'elements de la pile à passer - mov edi,edx ; Adresse des valeurs des registres à passer à l'interruption - mov dword ptr[edi+1Ch],00004F0Ah ; EAX passé à l'interruption - mov dword ptr[edi+10h],00000000h ; EBX passé à l'interruption - int 31h ; Appel de l'interruption du DPMI - - ; On vérifie que la valeur de AX de retour soit = 004Fh - mov eax,dword ptr[edi+1Ch] - cmp ax,004Fh - jne GVPMW_Fonction_VESA_non_supportee - - ; On sauve l'adresse dans VESA_WinFuncPtr - xor eax,eax - xor ecx,ecx - mov ax,word ptr[edi+34] ; ES retourné par l'interruption - mov cx,word ptr[edi+00] ; DI retourné par l'interruption - shl eax,4 - add eax,ecx - mov cx,[eax] - add eax,ecx - mov VESA_WinFuncPtr,eax - - GVPMW_Fonction_VESA_non_supportee: - - ; On libŠre le buffer en mode réel de 64 octets - mov ax,0101h ; "DPMI : Free Dos memory blocks" - mov dx,Handle_temporaire ; DX = handle du buffer - int 31h - - GVPMW_Erreur_d_allocation_de_memoire: - - - pop edi - pop ebx - - ret - -Get_VESA_protected_mode_WinFuncPtr endp - - - - - -; - -- --- ----\/\ Passage dans un mode vidéo VESA : /\/---- --- -- - - -Set_VESA_mode proc near - - push ebp - mov ebp,esp - - arg Mode:word - - push ebx - - - mov ax,4F02h - mov bx,Mode - int 10h - - - pop ebx - - mov esp,ebp - pop ebp - - ret - -Set_VESA_mode endp - - - - - -; - -- --- ----\/\ Initialiser le LFB d'un mode VESA 2.0 : /\/---- --- -- - - -Initialiser_le_LFB proc near - - push ebp - mov ebp,esp - - arg Adresse_physique:dword,Taille:dword - - push ebx - push esi - push edi - - ; Mémorisation de la taille - mov eax,Taille - mov LFB_Taille,eax - - ; Allocation d'un descripteur LDT pour le mapping du LFB - mov eax,Offset LFB_Selecteur - push eax - mov eax,1 - push eax - call Allocate_ldt_descriptor - add esp,8 - - or ax,ax - jnz Initialiser_le_LFB_Erreur_d_allocation_du_descripteur - - ; Modification des droits d'accŠs du descripteur - mov eax,00008092h - push eax - mov ax,LFB_Selecteur - push eax - call Set_descriptor_access_rights - add esp,8 - - or ax,ax - jnz Initialiser_le_LFB_Erreur_changement_des_droits_du_descripteur - - ; Mapping de l'adresse physique - mov eax,Offset LFB_Adresse - push eax - mov eax,LFB_Taille - push eax - mov eax,Adresse_physique - push eax - call Physical_address_mapping - add esp,12 - - or ax,ax - jnz Initialiser_le_LFB_Erreur_mapping_de_l_adresse_physique - - ; Assignation de l'adresse de base du segment - mov eax,[eax] - mov eax,LFB_Adresse - push eax - mov ax,LFB_Selecteur - push eax - call Set_segment_base_address - add esp,8 - - or ax,ax - jnz Initialiser_le_LFB_Erreur_assignation_de_l_adresse_de_base_du_segment - - ; Assignation de la limite du segment - mov eax,LFB_Taille - dec eax - push eax - mov ax,LFB_Selecteur - push eax - call Set_segment_limit - add esp,8 - - or ax,ax - jnz Initialiser_le_LFB_Erreur_assignation_de_la_limite_du_segment - - ; Vérouillage de la mémoire linéaire - mov eax,LFB_Taille - push eax - mov eax,LFB_Adresse - push eax - call Lock_linear_region - add esp,8 - - or ax,ax - jnz Initialiser_le_LFB_Erreur_verouillage_de_la_memoire_lineaire - - ; On renvoie un code d'erreur nul - xor eax,eax - - jmp Initialiser_le_LFB_Fin_du_traitement - - - Initialiser_le_LFB_Erreur_d_allocation_du_descripteur: - Initialiser_le_LFB_Erreur_changement_des_droits_du_descripteur: - Initialiser_le_LFB_Erreur_mapping_de_l_adresse_physique: - Initialiser_le_LFB_Erreur_assignation_de_l_adresse_de_base_du_segment: - Initialiser_le_LFB_Erreur_assignation_de_la_limite_du_segment: - Initialiser_le_LFB_Erreur_verouillage_de_la_memoire_lineaire: - - mov eax,1 - - Initialiser_le_LFB_Fin_du_traitement: - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Initialiser_le_LFB endp - - - - - - -; - -- --- ----\/\ Fermer le LFB d'un mode VESA 2.0 : /\/---- --- -- - - -Fermer_le_LFB proc near - - ; Dévérouillage de la mémoire linéaire - mov eax,LFB_Taille - push eax - mov eax,LFB_Adresse - push eax - call Unlock_linear_region - add esp,8 - - or ax,ax - jnz Fermer_le_LFB_Erreur_deverouillage_de_la_memoire_lineaire - - ; Démapping de l'adresse physique - mov eax,LFB_Adresse - push eax - call Free_physical_address_mapping - add esp,4 - - or ax,ax - jnz Fermer_le_LFB_Erreur_demapping_de_l_adresse_physique - - ; Libération du descripteur LDT pour le mapping du LFB - mov ax,LFB_Selecteur - push eax - call Free_ldt_descriptor - add esp,4 - - or ax,ax - jnz Fermer_le_LFB_Erreur_de_liberation_du_descripteur - - ; On renvoie un code d'erreur nul - xor eax,eax - - jmp Fermer_le_LFB_Fin_du_traitement - - - Fermer_le_LFB_Erreur_deverouillage_de_la_memoire_lineaire: - Fermer_le_LFB_Erreur_demapping_de_l_adresse_physique: - Fermer_le_LFB_Erreur_de_liberation_du_descripteur: - - mov eax,1 - - Fermer_le_LFB_Fin_du_traitement: - - - ret - -Fermer_le_LFB endp - - - - - - - - - - - - - - -Pixel_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word,Couleur:byte - - - xor eax,eax - xor edx,edx - xor ecx,ecx - mov ax,Largeur_ecran - mov dx,Y - mov cx,X - mul edx - add eax,ecx - mov cl,Couleur - add eax,LFB_Adresse - mov [eax],cl - - - mov esp,ebp - pop ebp - - ret - -Pixel_VESA_LFB endp - - - - -Lit_pixel_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word - - - xor eax,eax - xor edx,edx - xor ecx,ecx - mov ax,Largeur_ecran - mov dx,Y - mov cx,X - mul edx - add eax,ecx - add eax,LFB_Adresse - mov al,[eax] - - - mov esp,ebp - pop ebp - - ret - -Lit_pixel_VESA_LFB endp - - - - -Effacer_tout_l_ecran_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg Couleur:byte - - push edi - - - ; On place EDI en début d'écran: - - mov edi,LFB_Adresse - - ; On met ECX à Largeur_ecran*Menu_Ordonnee/4: - - xor eax,eax - xor edx,edx - mov ax,Largeur_ecran - mov dx,Menu_Ordonnee - mul edx - shr eax,2 - mov ecx,eax - - ; On met dans EAX 4 fois la couleur: - - mov dl,Couleur - mov dh,dl - mov ax,dx - shl eax,16 - mov ax,dx - - rep stosd - - - pop edi - - mov esp,ebp - pop ebp - - ret - -Effacer_tout_l_ecran_VESA_LFB endp - - - - - -; - -- --- ----\/\ Afficher un bloc de couleur en FLAT : /\/---- --- -- - - -Block_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Hauteur:word,Couleur:byte - - push ebx - push esi - push edi - - - ; Calculer dans EDI les coordonnées (Pos_X,Pos_Y) dans la destination - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Pos_Y - mov bx,Largeur_ecran - mov cx,Pos_X - mul ebx - mov edi,LFB_Adresse - add eax,ecx - add edi,eax - - ; On met dans EAX 4 fois la couleur - mov cl,Couleur - mov ch,cl - mov ax,cx - shl eax,16 - mov ax,cx - - ; On place dans DX le nb de lignes à traiter - mov dx,Hauteur - - ; On met dans EBX la distance entre 2 lignes de destination - xor ebx,ebx - mov bx,Largeur_ecran - sub bx,Largeur - - ; On met dans ESI la largeur à traiter: - xor esi,esi - mov si,Largeur - - Block_VESA_LFB_Pour_chaque_ligne: - - ; On place dans CX le nb de pixels à traiter sur la ligne - mov ecx,esi - - ; On fait une copie de la ligne - shr cx,1 - jnc Block_VESA_LFB_Multiple_de_2 - stosb - Block_VESA_LFB_Multiple_de_2: - shr cx,1 - jnc Block_VESA_LFB_Multiple_de_4 - stosw - Block_VESA_LFB_Multiple_de_4: - repne stosd - - ; On passe à la ligne suivante - add edi,ebx - dec dx - jnz Block_VESA_LFB_Pour_chaque_ligne - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Block_VESA_LFB endp - - - - - - - -; -- Affichage d'un pixel dans l'écran, par rapport au décalage de l'image -; dans l'écran, en mode normal (pas en mode loupe) -- - -; Note: si on modifie cette procédure, il faudra penser à faire également la -; modif dans la procédure Pixel_Preview_Loupe_VESA_LFB. - -Pixel_Preview_Normal_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word,Couleur:byte - - - mov dl,Couleur - mov cx,Y - mov ax,X - sub cx,Principal_Decalage_Y - sub ax,Principal_Decalage_X - push edx - push ecx - push eax - - call Pixel_VESA_LFB - - - mov esp,ebp - pop ebp - - ret - -Pixel_Preview_Normal_VESA_LFB endp - - - - -; -- Affichage d'un pixel dans l'écran, par rapport au décalage de l'image -; dans l'écran, en mode loupe -- - -Pixel_Preview_Loupe_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word,Couleur:byte - - push ebx - - - ; On affiche d'abord le pixel dans la partie non-zoomée - - mov dl,Couleur ; Ca ne co–te pas trop - mov cx,Y ; en code de recopier - mov ax,X ; le contenu de la - sub cx,Principal_Decalage_Y ; procédure - sub ax,Principal_Decalage_X ; Pixel_Preview_Normal_VESA_LFB - push edx ; et ‡a fait gagner du - push ecx ; temps, et ce temps est - push eax ; assez précieux vu que - call Pixel_VESA_LFB ; c'est appelé TRES souvent. - add esp,12 ; 3 paramŠtres dword - - ; On regarde si on peut afficher le pixel également dans la loupe - - mov ax,Y - cmp ax,Limite_Haut_Zoom - jb Pixel_Preview_Loupe_VESA_LFB_Fin - cmp ax,Limite_visible_Bas_Zoom - ja Pixel_Preview_Loupe_VESA_LFB_Fin - mov ax,X - cmp ax,Limite_Gauche_Zoom - jb Pixel_Preview_Loupe_VESA_LFB_Fin - cmp ax,Limite_visible_Droite_Zoom - ja Pixel_Preview_Loupe_VESA_LFB_Fin - - ; On passe la couleur - - mov al,Couleur - mov edx,Table_mul_facteur_zoom ; On pointe sur la table de x (OPTI) - push eax - - ; On calcule dans EAX (X) et ECX (Y) le démarrage du bloc: - - xor eax,eax - xor ecx,ecx - mov ax,X - mov cx,Y - sub ax,Loupe_Decalage_X - sub cx,Loupe_Decalage_Y - mov ax,[edx+2*eax] - mov cx,[edx+2*ecx] - - ; On sauve ces valeurs dans BX (X) et DX (Y): - - mov bx,ax - mov dx,cx - - ; On s'occupe de la hauteur: - - add cx,Loupe_Facteur - cmp cx,Menu_Ordonnee - ja Pixel_Preview_Loupe_VESA_LFB_Tronque_en_hauteur - - mov cx,Loupe_Facteur - push ecx - jmp Pixel_Preview_Loupe_VESA_LFB_Traitement_de_la_largeur - - Pixel_Preview_Loupe_VESA_LFB_Tronque_en_hauteur: - - mov cx,dx - neg cx - add cx,Menu_Ordonnee - push ecx - - ; On s'occupe de la largeur: - - Pixel_Preview_Loupe_VESA_LFB_Traitement_de_la_largeur: - - add bx,Principal_X_Zoom - - mov ax,Loupe_Facteur - push eax - - ; On passe le début en Y: - push edx - - ; On passe le début en X: - push ebx - - call Block_VESA_LFB - add esp,20 ; 20 = 5 paramŠtres de type dword - - - Pixel_Preview_Loupe_VESA_LFB_Fin: - - - pop ebx - - mov esp,ebp - pop ebp - - ret - -Pixel_Preview_Loupe_VESA_LFB endp - - - - -; - -- ---\/\ Afficher une ligne horizontale XOR en VESA LFB : /\/--- -- - - -Ligne_horizontale_XOR_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word - - push ebx - push edi - - - ; On calcule la valeur initiale de EDI: - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Pos_Y - mov bx,Largeur_ecran - mov cx,Pos_X - mul ebx - mov edi,LFB_Adresse - add eax,ecx - add edi,eax - - ; On met dans ECX le nombre de pixels à traiter: - xor ecx,ecx - mov cx,Largeur - - shr cx,1 - jnc Ligne_horizontale_XOR_VESA_LFB_CX_multiple_de_2 - not byte ptr[edi] ; On commence par se débarrasser du 1er byte - inc edi ; en cas d'imparité - Ligne_horizontale_XOR_VESA_LFB_CX_multiple_de_2: - shr cx,1 - jnc Ligne_horizontale_XOR_VESA_LFB_CX_multiple_de_4 - not word ptr[edi] ; On se débarrasse des 2Šme et 3Šme bytes en - add edi,2 ; cas de "non-multiplicité-de-4" - Ligne_horizontale_XOR_VESA_LFB_CX_multiple_de_4: - - or cx,cx - jz Ligne_horizontale_XOR_VESA_LFB_Fin - - ; copie 32 bits - Ligne_horizontale_XOR_VESA_LFB_Copie_32_bits: - not dword ptr[edi] - add edi,4 - dec cx - jnz Ligne_horizontale_XOR_VESA_LFB_Copie_32_bits - - Ligne_horizontale_XOR_VESA_LFB_Fin: - - - pop edi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Ligne_horizontale_XOR_VESA_LFB endp - - - - - - -; - -- ---\/\ Afficher une ligne verticale XOR en VESA LFB : /\/--- -- - - -Ligne_verticale_XOR_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Hauteur:word - - - ; On calcule la valeur initiale de EDX: - xor eax,eax - xor edx,edx - xor ecx,ecx - mov ax,Pos_Y - mov dx,Largeur_ecran - mov cx,Pos_X - mul edx - mov edx,LFB_Adresse - add eax,ecx - add edx,eax - - ; On met dans EAX la distance entre deux lignes: - xor eax,eax - mov ax,Largeur_ecran - - ; On met dans CX le nombre de lignes à traiter - mov cx,Hauteur - - Ligne_verticale_XOR_VESA_LFB_Boucle: - - not byte ptr[edx] - add edx,eax - - dec cx - jnz Ligne_verticale_XOR_VESA_LFB_Boucle - - - mov esp,ebp - pop ebp - - ret - -Ligne_verticale_XOR_VESA_LFB endp - - - - - - -; Afficher une partie de la brosse en couleur en VESA LFB - -Display_brush_Color_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Hauteur:word,Couleur_de_transparence:byte,Largeur_brosse:word - - push ebx - push esi - push edi - - - ; Calculer dans EDI les coordonnées (Pos_X,Pos_Y) à l'écran - xor eax,eax - xor edx,edx - xor ecx,ecx - mov ax,Pos_Y - mov dx,Largeur_ecran - mov cx,Pos_X - mul edx - mov edi,LFB_Adresse - add eax,ecx - add edi,eax - - ; Calculer dans ESI les coordonnées (Decalage_X,Decalage_Y) dans la brosse - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_brosse - mov bx,Decalage_Y - mov cx,Decalage_X - mul ebx - mov esi,Brosse - add eax,ecx - add esi,eax - - ; On place dans DX le nb de lignes à traiter - mov dx,Hauteur - - ; On place dans BH la couleur de transparence - mov bh,Couleur_de_transparence - - ; On place dans EAX la distance entre deux lignes à l'écran - xor eax,eax - mov ax,Largeur_ecran - sub ax,Largeur - - Display_brush_Color_VESA_LFB_Pour_chaque_ligne: - - ; On place dans CX le nb de pixels à traiter sur la ligne - mov cx,Largeur - - Display_brush_Color_VESA_LFB_Pour_chaque_pixel: - - ; On lit le contenu de la brosse - mov bl,[esi] - - ; Gestion de la transparence - cmp bl,bh - je Display_brush_Color_VESA_LFB_Pas_de_copie - - ; On affiche le pixel de la brosse à l'écran - mov [edi],bl - - Display_brush_Color_VESA_LFB_Pas_de_copie: - - ; On passe au pixel suivant - inc esi - inc edi - dec cx - jnz Display_brush_Color_VESA_LFB_Pour_chaque_pixel - - ; On passe à la ligne suivante - mov cx,Largeur_brosse - add edi,eax - sub cx,Largeur - add esi,ecx - dec dx - jnz Display_brush_Color_VESA_LFB_Pour_chaque_ligne - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Display_brush_Color_VESA_LFB endp - - - - - -; Afficher une partie de la brosse en monochrome en VESA LFB - -Display_brush_Mono_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Hauteur:word,Couleur_de_transparence:byte,Couleur:byte,Largeur_brosse:word - - push ebx - push esi - push edi - - - ; Calculer dans EDI les coordonnées (Pos_X,Pos_Y) à l'écran - xor eax,eax - xor edx,edx - xor ecx,ecx - mov ax,Pos_Y - mov dx,Largeur_ecran - mov cx,Pos_X - mul edx - mov edi,LFB_Adresse - add eax,ecx - add edi,eax - - ; Calculer dans ESI les coordonnées (Decalage_X,Decalage_Y) dans la brosse - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_brosse - mov bx,Decalage_Y - mov cx,Decalage_X - mul ebx - mov esi,Brosse - add eax,ecx - add esi,eax - - ; On place dans DX le nb de lignes à traiter - mov dx,Hauteur - - ; On place dans BH la couleur de transparence - mov bh,Couleur_de_transparence - - ; On place dans BL la couleur de coloriage - mov bl,Couleur - - ; On place dans EAX la distance entre 2 lignes à l'écran - xor eax,eax - mov ax,Largeur_ecran - sub ax,Largeur - - Display_brush_Mono_VESA_LFB_Pour_chaque_ligne: - - ; On place dans CX le nb de pixels à traiter sur la ligne - mov cx,Largeur - - Display_brush_Mono_VESA_LFB_Pour_chaque_pixel: - - ; On vérifie que le contenu de la brosse ne soit pas transparent - cmp [esi],bh - je Display_brush_Mono_VESA_LFB_Pas_de_copie - - ; On affiche le pixel de la brosse à l'écran - mov [edi],bl - - Display_brush_Mono_VESA_LFB_Pas_de_copie: - - ; On passe au pixel suivant - inc esi - inc edi - dec cx - jnz Display_brush_Mono_VESA_LFB_Pour_chaque_pixel - - ; On passe à la ligne suivante - mov cx,Largeur_brosse - add edi,eax - sub cx,Largeur - add esi,ecx - dec dx - jnz Display_brush_Mono_VESA_LFB_Pour_chaque_ligne - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Display_brush_Mono_VESA_LFB endp - - - - - -; Effacer la partie de la brosse affichée à l'écran en VESA LFB - -Clear_brush_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Hauteur:word,Couleur_de_transparence:byte,Largeur_image:word - - push ebx - push esi - push edi - - - ; Calculer dans EDI les coordonnées (Pos_X,Pos_Y) à l'écran - xor eax,eax - xor edx,edx - xor ecx,ecx - mov ax,Pos_Y - mov dx,Largeur_ecran - mov cx,Pos_X - mul edx - mov edi,LFB_Adresse - add eax,ecx - add edi,eax - - ; Calculer dans ESI les coordonnées - ; (Pos_X+Principal_Decalage_X,Pos_Y+Principal_Decalage_Y) dans l'image - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Pos_Y - mov bx,Largeur_image - mov cx,Pos_X - add ax,Principal_Decalage_Y - add cx,Principal_Decalage_X - mul ebx - mov esi,Principal_Ecran - add eax,ecx - add esi,eax - - ; On place dans DX le nb de lignes à traiter - mov dx,Hauteur - - ; On met dans EBX la distance entre 2 lignes à l'écran - xor ebx,ebx - mov bx,Largeur_ecran - sub bx,Largeur - - ; On met dans EAX la distance entre 2 lignes dans l'image - xor eax,eax - mov ax,Largeur_image - sub ax,Largeur - - ; On nettoie la partie haute de ECX: - xor ecx,ecx - - Clear_brush_VESA_LFB_Pour_chaque_ligne: - - ; On place dans CX le nb de pixels à traiter sur la ligne - mov cx,Largeur - - ; On fait une copie de la ligne - shr cx,1 - jnc Clear_brush_VESA_LFB_Multiple_de_2 - movsb - Clear_brush_VESA_LFB_Multiple_de_2: - shr cx,1 - jnc Clear_brush_VESA_LFB_Multiple_de_4 - movsw - Clear_brush_VESA_LFB_Multiple_de_4: - rep movsd - - ; On passe à la ligne suivante - add esi,eax - add edi,ebx - dec dx - jnz Clear_brush_VESA_LFB_Pour_chaque_ligne - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Clear_brush_VESA_LFB endp - - - - - - -; Remapper une partie de l'écran en VESA LFB - -Remap_screen_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Hauteur:word,Conversion:dword - - push ebx - push esi - push edi - - - ; Calculer dans EDI les coordonnées (Pos_X,Pos_Y) à l'écran - xor eax,eax - xor edx,edx - xor ecx,ecx - mov ax,Pos_Y - mov dx,Largeur_ecran - mov cx,Pos_X - mul edx - mov edi,LFB_Adresse - add eax,ecx - add edi,eax - - ; On place dans DX le nb de lignes à traiter - mov dx,Hauteur - - ; On place dans EBX l'adresse de la table de conversion - mov ebx,Conversion - - ; On nettoie (entre autres) la partie haute de EAX - xor eax,eax - - ; On met dans ESI la distance entre la fin d'une ligne et le début de la - ; suivante - xor esi,esi - mov si,Largeur_ecran - sub si,Largeur - - Remap_screen_VESA_LFB_Pour_chaque_ligne: - - ; On place dans CX le nb de pixels à traiter sur la ligne - mov cx,Largeur - - Remap_screen_VESA_LFB_Pour_chaque_pixel: - - mov al,[edi] - mov al,[ebx+eax] - mov [edi],al - - ; On passe au pixel suivant - inc edi - dec cx - jnz Remap_screen_VESA_LFB_Pour_chaque_pixel - - ; On passe à la ligne suivante - add edi,esi - - dec dx - jnz Remap_screen_VESA_LFB_Pour_chaque_ligne - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Remap_screen_VESA_LFB endp - - - - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -; Afficher une partie de l'image tel quel sur l'écran - -Afficher_partie_de_l_ecran_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg Largeur:word,Hauteur:word,Largeur_image:word - - push ebx - push esi - push edi - - - ; Calculer dans EDI les coordonnées (0,0) dans la destination - mov edi,LFB_Adresse - - ; Calculer dans ESI les coordonnées (Pos_X_source,Pos_Y_source) - ; dans la source - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Principal_Decalage_Y - mov bx,Largeur_image - mov cx,Principal_Decalage_X - mul ebx - mov esi,Principal_Ecran - add eax,ecx - add esi,eax - - ; On place dans DX le nb de lignes à traiter - mov dx,Hauteur - - ; On met dans EBX la distance entre 2 lignes de la destination - xor ebx,ebx - mov bx,Largeur_ecran - sub bx,Largeur - - ; On met dans EAX la distance entre 2 lignes de la source - xor eax,eax - mov ax,Largeur_image - sub ax,Largeur - - ; On nettoie la partie haute de ECX: - xor ecx,ecx - - Afficher_partie_de_l_ecran_VESA_LFB_Pour_chaque_ligne: - - ; On place dans CX le nb de pixels à traiter sur la ligne - mov cx,Largeur - - ; On fait une copie de la ligne - shr cx,1 - jnc Afficher_partie_de_l_ecran_VESA_LFB_Multiple_de_2 - movsb - Afficher_partie_de_l_ecran_VESA_LFB_Multiple_de_2: - shr cx,1 - jnc Afficher_partie_de_l_ecran_VESA_LFB_Multiple_de_4 - movsw - Afficher_partie_de_l_ecran_VESA_LFB_Multiple_de_4: - rep movsd - - ; On passe à la ligne suivante - add esi,eax - add edi,ebx - dec dx - jnz Afficher_partie_de_l_ecran_VESA_LFB_Pour_chaque_ligne - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Afficher_partie_de_l_ecran_VESA_LFB endp - - - - - - - -; Afficher une ligne à l'écran - -Afficher_une_ligne_a_l_ecran_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Ligne:dword - - push ebx - push esi - push edi - - - ; On met dans ESI l'adresse de la ligne à copier: - mov esi,Ligne - - ; On calcule la valeur initiale de EDI: - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Pos_Y - mov bx,Largeur_ecran - mov cx,Pos_X - mul ebx - mov edi,LFB_Adresse - add eax,ecx - add edi,eax - - ; On met dans ECX le nombre de pixels à traiter: - xor ecx,ecx - mov cx,Largeur - - ; On les traite au mieux par copie 8/16/32 bits - shr cx,1 - jnc Afficher_une_ligne_a_l_ecran_VESA_LFB_ECX_multiple_de_2 - movsb - Afficher_une_ligne_a_l_ecran_VESA_LFB_ECX_multiple_de_2: - shr cx,1 - jnc Afficher_une_ligne_a_l_ecran_VESA_LFB_ECX_multiple_de_4 - movsw - Afficher_une_ligne_a_l_ecran_VESA_LFB_ECX_multiple_de_4: - rep movsd - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Afficher_une_ligne_a_l_ecran_VESA_LFB endp - - - - - - - - - - - - - -; Lire une ligne à l'écran et la stocker dans un buffer - - -Lire_une_ligne_a_l_ecran_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Ligne:dword - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI: - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Pos_Y - mov bx,Largeur_ecran - mov cx,Pos_X - mul ebx - mov esi,LFB_Adresse - add eax,ecx - add esi,eax - - ; On met dans EDI l'adresse de la ligne à copier: - mov edi,Ligne - - ; On met dans ECX le nombre de pixels à traiter: - xor ecx,ecx - mov cx,Largeur - - ; On les traite au mieux par copie 8/16/32 bits - shr cx,1 - jnc Lire_une_ligne_a_l_ecran_VESA_LFB_ECX_multiple_de_2 - movsb - Lire_une_ligne_a_l_ecran_VESA_LFB_ECX_multiple_de_2: - shr cx,1 - jnc Lire_une_ligne_a_l_ecran_VESA_LFB_ECX_multiple_de_4 - movsw - Lire_une_ligne_a_l_ecran_VESA_LFB_ECX_multiple_de_4: - rep movsd - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Lire_une_ligne_a_l_ecran_VESA_LFB endp - - - - - -; Afficher une partie de l'image zoomée à l'écran - -Afficher_partie_de_l_ecran_zoomee_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg Largeur:word,Hauteur:word,Largeur_image:word,Buffer:dword - - ; Largeur = Largeur non zoomée - ; Hauteur = Hauteur zoomée - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=Principal_Ecran+((Loupe_Decalage_Y*Largeur_image)+Loupe_Decalage_X) - - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_image - mov bx,Loupe_Decalage_Y - mov cx,Loupe_Decalage_X - mul ebx - mov esi,Principal_Ecran - add eax,ecx - add esi,eax - - ; On met dans DI la valeur Largeur*Facteur - mov ax,Largeur - mul Loupe_Facteur - mov di,ax - - ; On met dans EDX la ligne en cours de traitement: - xor edx,edx - - ; On met dans EBX la distance entre deux lignes d'image - xor ebx,ebx - mov bx,Largeur_image - - APDLEZ_VESA_LFB_Pour_chaque_ligne_a_zoomer: - - ; On eclate la ligne à zoomer: - push dx - mov ax,Loupe_Facteur - mov cx,Largeur - push ecx ; Largeur - push eax ; Facteur - push Buffer ; Ligne zoomée - push esi ; Ligne originale - call Zoomer_une_ligne - add esp,16 - pop dx - - ; On l'affiche Facteur fois à l'écran (sur des lignes consécutives): - mov cx,Loupe_Facteur - - APDLEZ_VESA_LFB_Pour_chaque_ligne: - - ; On affiche la ligne zoomée - push cx - push dx - push Buffer ; Ligne - push edi ; Largeur*Facteur - push edx ; Pos_Y - mov ax,Principal_X_Zoom - push eax ; Pos_X - call Afficher_une_ligne_a_l_ecran_VESA_LFB - add esp,16 - pop dx - pop cx - - ; On passe à la ligne suivante - inc dx ; -> On vérifie qu'on ne soit - cmp dx,Hauteur ; pas arrivé à la ligne - je APDLEZ_VESA_LFB_Menu_Ordonnee_atteinte ; terminale - dec cx ; -> ou que l'on ai terminé de - jnz APDLEZ_VESA_LFB_Pour_chaque_ligne ; traiter la ligne à zoomer - - ; On passe à la ligne à zoomer suivante: - ; sans oublier de passer à la ligne image suivante - add esi,ebx - jmp APDLEZ_VESA_LFB_Pour_chaque_ligne_a_zoomer - - APDLEZ_VESA_LFB_Menu_Ordonnee_atteinte: - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Afficher_partie_de_l_ecran_zoomee_VESA_LFB endp - - - - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - - - - -; Afficher une ligne transparente en VESA LFB - -Afficher_une_ligne_transparente_a_l_ecran_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Ligne:dword,Couleur_transparence:byte - - push ebx - push esi - push edi - - - ; On met dans ESI l'adresse de la ligne à copier: - mov esi,Ligne - - ; On calcule la valeur initiale de EDI: - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Pos_Y - mov bx,Largeur_ecran - mov cx,Pos_X - mul ebx - mov edi,LFB_Adresse - add eax,ecx - add edi,eax - - ; On met dans AH la couleur de transparence: - mov ah,Couleur_transparence - - ; On met dans CX le nombre de pixels à traiter: - mov cx,Largeur - - ; Pour chaque pixel de la ligne - AULTALE_VESA_LFB_Pour_chaque_pixel: - - ; On lit la source - mov al,[esi] - inc esi ; MAJ du Pointeur de source - - ; On vérifie qu'elle soit <> de la couleur de transparence - cmp al,ah - je AULTALE_VESA_LFB_Pas_de_copie - - ; Et on la copie dans la destination - mov [edi],al - - AULTALE_VESA_LFB_Pas_de_copie: - inc edi ; MAJ du Pointeur de destination - - ; Hop! et un de moins - dec cx - jnz AULTALE_VESA_LFB_Pour_chaque_pixel - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Afficher_une_ligne_transparente_a_l_ecran_VESA_LFB endp - - - -; Afficher une ligne transparente en VESA LFB - -Afficher_une_ligne_transparente_mono_a_l_ecran_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Ligne:dword,Couleur_transparence:byte,Couleur:byte - - push ebx - push esi - push edi - - - ; On met dans ESI l'adresse de la ligne à copier: - mov esi,Ligne - - ; On calcule la valeur initiale de EDI: - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Pos_Y - mov bx,Largeur_ecran - mov cx,Pos_X - mul ebx - mov edi,LFB_Adresse - add eax,ecx - add edi,eax - - ; On met dans AL la couleur de transparence: - mov al,Couleur_transparence - - ; On met dans DL la couleur à utiliser: - mov dl,Couleur - - ; On met dans CX le nombre de pixels à traiter: - mov cx,Largeur - - ; Pour chaque pixel de la ligne - AULTMALE_VESA_LFB_Pour_chaque_pixel: - - ; On vérifie que la source soit <> de la couleur de transparence - cmp al,[esi] - je AULTMALE_VESA_LFB_Pas_de_copie - - ; Et on copie la couleur dans la destination - mov [edi],dl - - AULTMALE_VESA_LFB_Pas_de_copie: - inc esi ; MAJ du Pointeur de source - inc edi ; MAJ du Pointeur de destination - - ; Hop! et un de moins - dec cx - jnz AULTMALE_VESA_LFB_Pour_chaque_pixel - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Afficher_une_ligne_transparente_mono_a_l_ecran_VESA_LFB endp - - - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - - -; Afficher une partie de la brosse zoomée en couleur en VESA LFB - -Display_brush_Color_Zoom_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Pos_Y_Fin:word,Couleur_de_transparence:byte,Largeur_brosse:word,Buffer:dword - - ; Largeur_brosse=Largeur réelle de la brosse - ; Largeur = Largeur non zoomée - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=Brosse+((Decalage_Y*Largeur_brosse)+Decalage_X) - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_brosse - mov bx,Decalage_Y - mov cx,Decalage_X - mul ebx - mov esi,Brosse - add eax,ecx - add esi,eax - - ; On met dans DI la valeur Largeur*Facteur - mov ax,Largeur - mul Loupe_Facteur - mov di,ax - - ; On met dans DX la ligne en cours de traitement: - xor dx,Pos_Y - - DBCZ_VESA_LFB_Pour_chaque_ligne_a_zoomer: - - ; On eclate la ligne à zoomer: - push dx - mov ax,Loupe_Facteur - mov cx,Largeur - push ecx ; Largeur - push eax ; Facteur - push Buffer ; Ligne zoomée - push esi ; Ligne originale - call Zoomer_une_ligne - add esp,16 - pop dx - - ; On sauve l'ancienne valeur de ESI: - push esi - - ; On place dans ESI la position courante en Y - mov esi,edx - - ; On empile à l'avance les derniers paramŠtres qui ne changent jamais le - ; long de la mˆme ligne zoomée: - mov al,Couleur_de_transparence - push eax ; Couleur de transparence - push Buffer ; Ligne - push edi ; Largeur*Facteur - - ; On l'affiche Facteur fois à l'écran (sur des lignes consécutives): - mov bx,Loupe_Facteur ; BX n'est pas foutu en l'air par la routine appelée - - DBCZ_VESA_LFB_Pour_chaque_ligne: - - ; On affiche la ligne zoomée - mov ax,Pos_X - push esi ; Pos_Y - push eax ; Pos_X - call Afficher_une_ligne_transparente_a_l_ecran_VESA_LFB - add esp,8 ; (Pos_X & Pos_Y) - - ; On passe à la ligne suivante - inc si ; -> On vérifie qu'on ne soit - cmp si,Pos_Y_Fin ; pas arrivé à la ligne - je DBCZ_VESA_LFB_Hauteur_atteinte ; terminale - dec bx ; -> ou que l'on ai terminé de - jnz DBCZ_VESA_LFB_Pour_chaque_ligne ; traiter la ligne à zoomer - - ; On passe à la ligne à zoomer suivante: - ; sans oublier de passer à la ligne brosse suivante - - ; On commence par retirer les paramŠtres précédemment passés - add esp,12 ; (Largeur*Facteur & Ligne & Couleur de transparence) - - ; On sauve la ligne courante dans DX: - mov edx,esi - - ; On restaure l'ancienne valeur de ESI: - pop esi - - mov bx,Largeur_brosse ; En théorie, la partie haute de EBX est propre - add esi,ebx - jmp DBCZ_VESA_LFB_Pour_chaque_ligne_a_zoomer - - DBCZ_VESA_LFB_Hauteur_atteinte: - - ; On ramŠne la pile dans un état normal - add esp,16 ; (Largeur*Facteur + Ligne + Couleur de transparence + ESI) - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Display_brush_Color_Zoom_VESA_LFB endp - - - - - - - -; Afficher une partie de la brosse zoomée en monochrome en VESA LFB - -Display_brush_Mono_Zoom_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Pos_Y_Fin:word,Couleur_de_transparence:byte,Couleur:byte,Largeur_brosse:word,Buffer:dword - - ; Largeur_brosse=Largeur réelle de la brosse - ; Largeur = Largeur non zoomée - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=Brosse+((Decalage_Y*Largeur_brosse)+Decalage_X) - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_brosse - mov bx,Decalage_Y - mov cx,Decalage_X - mul ebx - mov esi,Brosse - add eax,ecx - add esi,eax - - ; On met dans DI la valeur Largeur*Facteur - mov ax,Largeur - mul Loupe_Facteur - mov di,ax - - ; On met dans DX la ligne en cours de traitement: - xor dx,Pos_Y - - DBMZ_VESA_LFB_Pour_chaque_ligne_a_zoomer: - - ; On eclate la ligne à zoomer: - push dx - mov ax,Loupe_Facteur - mov cx,Largeur - push ecx ; Largeur - push eax ; Facteur - push Buffer ; Ligne zoomée - push esi ; Ligne originale - call Zoomer_une_ligne - add esp,16 - pop dx - - ; On sauve l'ancienne valeur de ESI: - push esi - - ; On place dans ESI la position courante en Y - mov esi,edx - - ; On empile à l'avance les derniers paramètres qui ne changent jamais - ; le long de la même ligne zoomée: - mov al,Couleur - mov cl,Couleur_de_transparence - push eax ; Couleur d'affichage - push ecx ; Couleur de transparence - push Buffer ; Ligne - push edi ; Largeur*Facteur - - ; On l'affiche Facteur fois à l'écran (sur des lignes consécutives): - mov bx,Loupe_Facteur ; BX n'est pas foutu en l'air par la routine appelée - - DBMZ_VESA_LFB_Pour_chaque_ligne: - - ; On affiche la ligne zoomée - mov ax,Pos_X - push esi ; Pos_Y - push eax ; Pos_X - call Afficher_une_ligne_transparente_mono_a_l_ecran_VESA_LFB - add esp,8 ; (Pos_X+Pos_Y) - - ; On passe à la ligne suivante - inc si ; -> On vérifie qu'on ne soit - cmp si,Pos_Y_Fin ; pas arrivé à la ligne - je DBMZ_VESA_LFB_Hauteur_atteinte ; terminale - dec bx ; -> ou que l'on ai terminé de - jnz DBMZ_VESA_LFB_Pour_chaque_ligne ; traiter la ligne à zoomer - - ; On passe à la ligne à zoomer suivante: - ; sans oublier de passer à la ligne brosse suivante - - ; On commence par retirer les paramŠtres précédemment passés - add esp,16 ; (Largeur*Facteur + Ligne + Couleur de transparence + Couleur) - - ; On sauve la ligne courante dans DX: - mov edx,esi - - ; On restaure l'ancienne valeur de ESI: - pop esi - - mov bx,Largeur_brosse ; En théorie, la partie haute de EBX est propre - add esi,ebx - jmp DBMZ_VESA_LFB_Pour_chaque_ligne_a_zoomer - - DBMZ_VESA_LFB_Hauteur_atteinte: - - ; On ramŠne la pile dans un état normal - add esp,20 ; (Largeur*Facteur + Ligne + Couleur de transparence + Couleur + ESI) - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Display_brush_Mono_Zoom_VESA_LFB endp - - - - - -; Effacer une partie de la brosse zoomée en VESA LFB - -Clear_brush_Zoom_VESA_LFB proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Pos_Y_Fin:word,Couleur_de_transparence:byte,Largeur_image:word,Buffer:dword - - ; Largeur_brosse=Largeur réelle de la brosse - ; Largeur = Largeur non zoomée - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=Principal_Ecran+((Decalage_Y*Largeur_image)+Decalage_X) - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_image - mov bx,Decalage_Y - mov cx,Decalage_X - mul ebx - mov esi,Principal_Ecran - add eax,ecx - add esi,eax - - ; On met dans DI la valeur Largeur*Facteur - mov ax,Largeur - mul Loupe_Facteur - mov di,ax - - ; On met dans DX la ligne en cours de traitement: - xor dx,Pos_Y - - CBZ_VESA_LFB_Pour_chaque_ligne_a_zoomer: - - ; On eclate la ligne à zoomer: - push dx - mov ax,Loupe_Facteur - mov cx,Largeur - push ecx ; Largeur - push eax ; Facteur - push Buffer ; Ligne zoomée - push esi ; Ligne originale - call Zoomer_une_ligne - add esp,16 - pop dx - - ; On sauve l'ancienne valeur de ESI: - push esi - - ; On place dans ESI la position courante en Y - mov esi,edx - - ; On empile à l'avance les derniers paramŠtres qui ne changent jamais le - ; long de la mˆme ligne zoomée: - push Buffer ; Ligne - push edi ; Largeur*Facteur - - ; On l'affiche Facteur fois à l'écran (sur des lignes consécutives): - mov bx,Loupe_Facteur ; BX n'est pas foutu en l'air par la routine appelée - - CBZ_VESA_LFB_Pour_chaque_ligne: - - ; On affiche la ligne zoomée - mov ax,Pos_X - push esi ; Pos_Y - push eax ; Pos_X - call Afficher_une_ligne_a_l_ecran_VESA_LFB - add esp,8 ; (Pos_X+Pos_Y) - - ; On passe à la ligne suivante - inc si ; -> On vérifie qu'on ne soit - cmp si,Pos_Y_Fin ; pas arrivé à la ligne - je CBZ_VESA_LFB_Hauteur_atteinte ; terminale - dec bx ; -> ou que l'on ai terminé de - jnz CBZ_VESA_LFB_Pour_chaque_ligne ; traiter la ligne à zoomer - - ; On passe à la ligne à zoomer suivante: - ; sans oublier de passer à la ligne brosse suivante - - ; On commence par retirer les paramŠtres précédemment passés - add esp,8 ; (Largeur*Facteur + Ligne) - - ; On sauve la ligne courante dans DX: - mov edx,esi - - ; On restaure l'ancienne valeur de ESI: - pop esi - - mov bx,Largeur_image ; En théorie, la partie haute de EBX est propre - add esi,ebx - jmp CBZ_VESA_LFB_Pour_chaque_ligne_a_zoomer - - CBZ_VESA_LFB_Hauteur_atteinte: - - ; On ramŠne la pile dans un état normal - add esp,12 ; (Largeur*Facteur + Ligne + ESI) - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Clear_brush_Zoom_VESA_LFB endp - - - - - - -_TEXT ENDS -END - - - diff --git a/Anciens fichiers/vesalfb.h b/Anciens fichiers/vesalfb.h deleted file mode 100644 index 15295230..00000000 --- a/Anciens fichiers/vesalfb.h +++ /dev/null @@ -1,132 +0,0 @@ -/* Grafx2 - The Ultimate 256-color bitmap paint program - - Copyright 1996-2001 Sunset Design (Guillaume Dorme & Karl Maritaud) - - Grafx2 is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License - as published by the Free Software Foundation; version 2 - of the License. - - Grafx2 is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with Grafx2; if not, see or - write to the Free Software Foundation, Inc., - 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -*/ - -#ifndef _VESALFB_H_ -#define _VESALFB_H_ - -#include "struct.h" -#include "global.h" - -struct S_Buffer_VESA -{ - // VESA 1.0 - char Signature[4]; // = 'VESA' - word Version; // Nø de version - char * Fabricant; // Nom du fabricant - dword Capacite; // Bits de capacit‚ du DAC - word * Liste_des_modes; // Liste des modes vid‚os support‚s par le VESA - word Memoire; // Taille de la m‚moire en blocs de 64K - - // VESA 2.0 - word Version_bios; // Version du BIOS du fabricant - char * Vendeur; // Nom du vendeur - char * Produit; // Nom du produit - char * Revision; // Nom de la r‚vision - - // Filler - byte Filler[990]; // Reserv‚ -}; - - - -struct S_Buffer_mode_VESA -{ - // VESA 1.0 - word Attributs; // Attributs du mode (00h) - byte Attributs_fenetre_A; // Attributs de la fenˆtre A (02h) - byte Attributs_fenetre_B; // Attributs de la fenˆtre B (03h) - word Granularite; // Granularit‚ des fenˆtres en Ko (04h) - word Taille_fenetres; // Taille des fenˆtres en Ko (06h) - word Segment_fenetre_A; // Segment de la fenˆtre A (08h) - word Segment_fenetre_B; // Segment de la fenˆtre B (0Ah) - byte * WinFuncPtr; // Fonction d'AX=4F05 en mode r‚el(0Ch) - word Octets_par_ligne; // Nombre d'octets par ligne (10h) - - // Optionnels ou OEM - word Largeur; // Largeur en pixels (12h) - word Hauteur; // Hauteur en pixels (14h) - byte Largeur_de_char; // Largeur des caractères en pxls (16h) - byte Hauteur_de_char; // Hauteur des caractères en pxls (17h) - byte Nb_plans; // Nombre de plans de m‚moire (18h) - byte Nb_bits_par_pixel; // Nombre de bits par pixel (19h) - byte Nb_banques; // Nombre de banques (1Ah) - byte Modele_de_memoire; // Modèle de m‚moire (1Bh) - byte Taille_des_banques; // Taille des banques en Ko (1Ch) - byte Nombre_de_pages; // Nombre de pages d'image (1Dh) - byte Reserve; // Reserv‚ (=1) (1Eh) - - // VESA 1.2 - byte Taille_masque_rouge; // Taille du masque des rouges (1Fh) - byte Pos_masque_rouge; // Position du masque des rouges (20h) - byte Taille_masque_vert; // Taille du masque des verts (21h) - byte Pos_masque_vert; // Position du masque des verts (22h) - byte Taille_masque_bleu; // Taille du masque des bleus (23h) - byte Pos_masque_bleu; // Position du masque des bleus (24h) - byte Taille_masque_res; // Taille d'un masque reserv‚ (25h) - byte Pos_masque_res; // Position d'un masque reserv‚ (26h) - byte Direct_screen_mode; // Direct screen mode info (27h) - - // VESA 2.0 - byte * Adresse_LFB; // Adresse du LFB (28h) - byte * Adresse_offscreen; // Pointeur vers le d‚but de la m‚moire offscreen (2Ch) - word Taille_offscreen; // Taille de la m‚moire offscreen en Ko (30h) - - // Filler - byte Filler[206]; -}; - - - - extern word LFB_Selecteur; // S‚lecteur utilis‚ par le mapping du LFB - extern word LFB_Adresse; // Adresse o— est mapp‚e le LFB - extern word LFB_Taille; // Taille de la m‚moire LFB - - - - word Get_VESA_info ( struct S_Buffer_VESA * Buffer_VESA); - word Get_VESA_mode_info(word Mode, struct S_Buffer_mode_VESA * Buffer_mode_VESA); - void Get_VESA_protected_mode_WinFuncPtr(void); - word Set_VESA_mode(word Mode); - word Initialiser_le_LFB(byte * Adresse_physique,dword Taille); - word Fermer_le_LFB(void); - - void Pixel_VESA_LFB (word X,word Y,byte Couleur); - byte Lit_pixel_VESA_LFB (word X,word Y); - void Effacer_tout_l_ecran_VESA_LFB (byte Couleur); - void Block_VESA_LFB (word Debut_X,word Debut_Y,word Largeur,word Hauteur,byte Couleur); - void Pixel_Preview_Normal_VESA_LFB (word X,word Y,byte Couleur); - void Pixel_Preview_Loupe_VESA_LFB (word X,word Y,byte Couleur); - void Ligne_horizontale_XOR_VESA_LFB(word Pos_X,word Pos_Y,word Largeur); - void Ligne_verticale_XOR_VESA_LFB (word Pos_X,word Pos_Y,word Hauteur); - void Display_brush_Color_VESA_LFB (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse); - void Display_brush_Mono_VESA_LFB (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse); - void Clear_brush_VESA_LFB (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_image); - void Remap_screen_VESA_LFB (word Pos_X,word Pos_Y,word Largeur,word Hauteur,byte * Table_de_conversion); - void Afficher_partie_de_l_ecran_VESA_LFB (word Largeur,word Hauteur,word Largeur_image); - void Afficher_une_ligne_a_l_ecran_VESA_LFB (word Pos_X,word Pos_Y,word Largeur,byte * Ligne); - void Lire_une_ligne_a_l_ecran_VESA_LFB (word Pos_X,word Pos_Y,word Largeur,byte * Ligne); - void Afficher_partie_de_l_ecran_zoomee_VESA_LFB(word Largeur,word Hauteur,word Largeur_image,byte * Buffer); - void Display_brush_Color_Zoom_VESA_LFB(word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_brosse,byte * Buffer); - void Display_brush_Mono_Zoom_VESA_LFB (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse,byte * Buffer); - void Clear_brush_Zoom_VESA_LFB (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_image,byte * Buffer); - - - -#endif diff --git a/Anciens fichiers/video.asm b/Anciens fichiers/video.asm deleted file mode 100644 index ceb5b581..00000000 --- a/Anciens fichiers/video.asm +++ /dev/null @@ -1,6922 +0,0 @@ -; Grafx2 - The Ultimate 256-color bitmap paint program -; -; Copyright 1996-2001 Sunset Design (Guillaume Dorme & Karl Maritaud) -; -; Grafx2 is free software; you can redistribute it and/or -; modify it under the terms of the GNU General Public License -; as published by the Free Software Foundation; version 2 -; of the License. -; -; Grafx2 is distributed in the hope that it will be useful, -; but WITHOUT ANY WARRANTY; without even the implied warranty of -; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -; GNU General Public License for more details. -; -; You should have received a copy of the GNU General Public License -; along with Grafx2; if not, see or -; write to the Free Software Foundation, Inc., -; 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. - -.386P -.MODEL FLAT - -_TEXT Segment dword public 'code' - Assume cs:_TEXT, ds:_DATA - -; -- Fonctions MCGA -- -public Set_mode_MCGA -public Pixel_MCGA -public Lit_pixel_MCGA -public Effacer_tout_l_ecran_MCGA -public Block_MCGA -public Pixel_Preview_Normal_MCGA -public Pixel_Preview_Loupe_MCGA -public Ligne_horizontale_XOR_MCGA -public Ligne_verticale_XOR_MCGA -; -- Fonctions Mode X -- -public Set_mode_X -public Pixel_mode_X -public Lit_pixel_mode_X -public Effacer_tout_l_ecran_mode_X -public Block_mode_X -public Pixel_Preview_Normal_mode_X -public Pixel_Preview_Loupe_mode_X -public Ligne_horizontale_XOR_mode_X -public Ligne_verticale_XOR_mode_X -; -- Fonctions VESA -- -public VESA_Change_banque_Fenetre_A -public VESA_Change_banque_Fenetre_B -public VESA_Change_banque_Fenetre_A_et_B -public VESA_Change_banque_Fenetre_A_FAST -public VESA_Change_banque_Fenetre_B_FAST -public VESA_Change_banque_Fenetre_A_et_B_FAST -;public Support_VESA -;public Mode_VESA_supporte -public Initialiser_mode_video_VESA -public Retoucher_CRTC -public Pixel_VESA -public Lit_pixel_VESA -public Effacer_tout_l_ecran_VESA -public Block_VESA -public Pixel_Preview_Normal_VESA -public Pixel_Preview_Loupe_VESA -public Ligne_horizontale_XOR_VESA -public Ligne_verticale_XOR_VESA - -public Display_brush_Color_MCGA -public Display_brush_Mono_MCGA -public Clear_brush_MCGA - -public Display_brush_Color_VESA -public Display_brush_Mono_VESA -public Clear_brush_VESA - -public Display_brush_Color_mode_X -public Display_brush_Mono_mode_X -public Clear_brush_mode_X - -public Remap_screen_MCGA -public Remap_screen_mode_X -public Remap_screen_VESA - -public Afficher_partie_de_l_ecran_MCGA -public Afficher_une_ligne_a_l_ecran_MCGA -public Lire_une_ligne_a_l_ecran_MCGA -public Afficher_partie_de_l_ecran_zoomee_MCGA -public Afficher_partie_de_l_ecran_mode_X -public Afficher_une_ligne_a_l_ecran_mode_X -public Lire_une_ligne_a_l_ecran_mode_X -public Afficher_partie_de_l_ecran_zoomee_mode_X -public Afficher_partie_de_l_ecran_VESA -public Afficher_une_ligne_a_l_ecran_VESA -public Lire_une_ligne_a_l_ecran_VESA -public Afficher_partie_de_l_ecran_zoomee_VESA - -public Display_brush_Color_Zoom_MCGA -public Display_brush_Mono_Zoom_MCGA -public Clear_brush_Zoom_MCGA -public Display_brush_Color_Zoom_mode_X -public Display_brush_Mono_Zoom_mode_X -public Clear_brush_Zoom_mode_X -public Display_brush_Color_Zoom_VESA -public Display_brush_Mono_Zoom_VESA -public Clear_brush_Zoom_VESA - - -; -- Variables externes relatives au Mode X -- -extrn Mode_X_Ptr :dword -extrn MODE_X_Decalage_synchro :dword -extrn MODE_X_Largeur_de_ligne :word -extrn MODE_X_Valeur_initiale_de_esi:dword -extrn MODE_X_Valeur_initiale_de_edi:dword - -; -- Variables externes relatives au VESA -- -extrn Granularite :byte -extrn Mode_X_Ptr :dataptr ; Table de modification des registres du CRTC -extrn VESA_Erreur :byte -extrn VESA_WinFuncPtr :dword -extrn VESA_Liste_des_modes :dword -extrn VESA_Decalage_synchro :dword -extrn VESA_Largeur_ecran_en_dword :word -extrn VESA_Banque_en_cours :byte -extrn VESA_Derniere_banque_Fenetre_A_utilisee:byte -extrn VESA_Derniere_banque_Fenetre_B_utilisee:byte -extrn VESA_Change_banque_lecture :dword -extrn VESA_Change_banque_ecriture :dword -extrn VESA_Change_banque_lect_ecr :dword -extrn VESA_Version_Unite :byte -extrn VESA_Version_Decimale :byte -extrn VESA_Constructeur :dword -extrn VESA_Taille_memoire :word - -; -- Autres variables externes -- -extrn Brosse:dword -extrn Principal_Ecran:dword -extrn Principal_Largeur_image:word -extrn Principal_Hauteur_image:word -extrn Principal_Decalage_X:word -extrn Principal_Decalage_Y:word -extrn Largeur_ecran:word -extrn Hauteur_ecran:word -extrn Menu_Ordonnee:word -extrn Principal_X_Zoom:word - -extrn Table_mul_facteur_zoom:dataptr ; Table de multiplication par le facteur -extrn Loupe_Decalage_X:word -extrn Loupe_Decalage_Y:word -extrn Loupe_Facteur :word - -extrn Limite_Haut_Zoom :word -extrn Limite_Gauche_Zoom :word -extrn Limite_visible_Bas_Zoom :word -extrn Limite_visible_Droite_Zoom:word - -; -- Proc‚dures externes -- -extrn Zoomer_une_ligne:near - - - -; *************************************************************************** -; *************************************************************************** -; ********************************** MCGA *********************************** -; *************************************************************************** -; *************************************************************************** - - -Set_mode_MCGA proc near - - pushad - - - mov ax,13h - int 10h - - - popad - - ret - -Set_mode_MCGA endp - - - -Pixel_MCGA proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word,Couleur:byte - - - mov eax,0A0140h - mov cl,Couleur - mul Y - add ax,X - mov [eax],cl - - - mov esp,ebp - pop ebp - - ret - -Pixel_MCGA endp - - - - -Lit_pixel_MCGA proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word - - - mov eax,0A0140h - mul Y - add ax,X - mov al,[eax] - - - mov esp,ebp - pop ebp - - ret - -Lit_pixel_MCGA endp - - - - -Effacer_tout_l_ecran_MCGA proc near - - push ebp - mov ebp,esp - - arg Couleur:byte - - push edi - - - ; On place EDI en d‚but d'‚cran: - - mov edi,0A0000h - - ; On met (E)CX … 320*Menu_Ordonnee/4: ( *80 <=> <<6 + <<4) - - xor ecx,ecx - mov ax,Menu_Ordonnee - mov cx,ax - shl ax,6 - shl cx,4 - add cx,ax - - ; On met dans EAX 4 fois la couleur: - - mov dl,Couleur - mov dh,dl - mov ax,dx - shl eax,16 - mov ax,dx - - - rep stosd - - pop edi - - mov esp,ebp - pop ebp - - ret - -Effacer_tout_l_ecran_MCGA endp - - - - -Block_MCGA proc near - - push ebp - mov ebp,esp - - arg Debut_X:word, Debut_Y:word, Largeur:word, Hauteur:word, Couleur:byte - - push esi - push edi - - - ; On met dans EDI la position de d‚part du dessin de block - - mov edi,0A0000h - mov ax,Debut_Y - mov dx,ax - shl ax,8 - add ax,Debut_X - shl dx,6 - add ax,dx - mov di,ax - - ; On met dans SI l'incr‚mentation de DI … chaque ligne - - mov si,320 - sub si,Largeur - - ; On remplit EAX avec 4 fois la couleur - - mov dl,Couleur - mov dh,dl - mov ax,dx - shl eax,16 - mov ax,dx - - mov dx,Hauteur - - xor ecx,ecx - - Block_MCGA_Pour_chaque_ligne: - - mov cx,Largeur ; CX = Nb pixels … afficher sur la ligne - - shr cx,1 - jnc Block_MCGA_Pair - stosb ; On commence par se d‚barrasser du 1er byte - ; en cas d'imparit‚} - - Block_MCGA_Pair: - - shr cx,1 - jnc Block_MCGA_test_de_superiorite_a_3 - stosw ; On se d‚barrasse des 2Šme et 3Šme bytes en - ; cas de "non-multiplicit‚-de-4" - Block_MCGA_test_de_superiorite_a_3: - - ; copie 32 bits - rep stosd - - add di,si - dec dx - - jnz Block_MCGA_Pour_chaque_ligne - - - pop edi - pop esi - - mov esp,ebp - pop ebp - - ret - -Block_MCGA endp - - - - -; -- Affichage d'un pixel dans l'‚cran, par rapport au d‚calage de l'image -; dans l'‚cran, en mode normal (pas en mode loupe) -- - -; Note: si on modifie cette proc‚dure, il faudra penser … faire ‚galement la -; modif dans la proc‚dure Pixel_Preview_Loupe_MCGA. - -Pixel_Preview_Normal_MCGA proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word,Couleur:byte - - - mov dl,Couleur - mov cx,Y - mov ax,X - sub cx,Principal_Decalage_Y - sub ax,Principal_Decalage_X - push edx - push ecx - push eax - - call Pixel_MCGA - - - mov esp,ebp - pop ebp - - ret - -Pixel_Preview_Normal_MCGA endp - - - - -; -- Affichage d'un pixel dans l'‚cran, par rapport au d‚calage de l'image -; dans l'‚cran, en mode loupe -- - -Pixel_Preview_Loupe_MCGA proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word,Couleur:byte - - push ebx - - - ; On affiche d'abord le pixel dans la partie non-zoom‚e - - mov dl,Couleur ; Ca ne co–te pas trop - mov cx,Y ; en code de recopier - mov ax,X ; le contenu de la - sub cx,Principal_Decalage_Y ; proc‚dure - sub ax,Principal_Decalage_X ; Pixel_Preview_Normal_MCGA - push edx ; et ‡a fait gagner du - push ecx ; temps, et ce temps est - push eax ; assez pr‚cieux vu que - call Pixel_MCGA ; c'est appel‚ TRES souvent. - add esp,12 ; 3 paramŠtres dword - - ; On regarde si on peut afficher le pixel ‚galement dans la loupe - - mov ax,Y - cmp ax,Limite_Haut_Zoom - jb Pixel_Preview_Loupe_MCGA_Fin - cmp ax,Limite_visible_Bas_Zoom - ja Pixel_Preview_Loupe_MCGA_Fin - mov ax,X - cmp ax,Limite_Gauche_Zoom - jb Pixel_Preview_Loupe_MCGA_Fin - cmp ax,Limite_visible_Droite_Zoom - ja Pixel_Preview_Loupe_MCGA_Fin - - ; On passe la couleur - - mov al,Couleur - mov edx,Table_mul_facteur_zoom ; On pointe sur la table de x (OPTI) - push eax - - ; On calcule dans EAX (X) et ECX (Y) le d‚marrage du bloc: - - xor eax,eax - xor ecx,ecx - mov ax,X - mov cx,Y - sub ax,Loupe_Decalage_X - sub cx,Loupe_Decalage_Y - mov ax,[edx+2*eax] - mov cx,[edx+2*ecx] - - ; On sauve ces valeurs dans BX (X) et DX (Y): - - mov bx,ax - mov dx,cx - - ; On s'occupe de la hauteur: - - add cx,Loupe_Facteur - cmp cx,Menu_Ordonnee - ja Pixel_Preview_Loupe_MCGA_Tronque_en_hauteur - - mov cx,Loupe_Facteur - push ecx - jmp Pixel_Preview_Loupe_MCGA_Traitement_de_la_largeur - - Pixel_Preview_Loupe_MCGA_Tronque_en_hauteur: - - mov cx,dx - neg cx - add cx,Menu_Ordonnee - push ecx - - ; On s'occupe de la largeur: - - Pixel_Preview_Loupe_MCGA_Traitement_de_la_largeur: - - add bx,Principal_X_Zoom - - mov ax,Loupe_Facteur - push eax - - ; On passe le d‚but en Y: - push edx - - ; On passe le d‚but en X: - push ebx - - call Block_MCGA - - - add esp,20 ; 20 = 5 paramŠtres de type dword - pop ebx - - Pixel_Preview_Loupe_MCGA_Fin: - - mov esp,ebp - pop ebp - - ret - -Pixel_Preview_Loupe_MCGA endp - - - - -Ligne_horizontale_XOR_MCGA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word, Pos_Y:word, Largeur:word - - push edi - - - ; On met dans EDI la position de d‚part du dessin de la ligne - - mov edi,0A0000h - mov ax,Pos_Y - mov dx,ax - shl ax,8 - add ax,Pos_X - shl dx,6 - add ax,dx - mov di,ax - - - mov cx,Largeur ; CX = Nb pixels … afficher sur la ligne - - shr cx,1 - jnc LH_MCGA_Pair - not byte ptr[edi] ; On commence par se d‚barrasser du 1er byte - inc edi ; en cas d'imparit‚ - - - LH_MCGA_Pair: - - shr cx,1 - jnc LH_MCGA_test_de_superiorite_a_3 - not word ptr[edi] ; On se d‚barrasse des 2Šme et 3Šme bytes en - add edi,2 ; cas de "non-multiplicit‚-de-4" - - LH_MCGA_test_de_superiorite_a_3: - - or cx,cx - jz LH_MCGA_Fin - - ; copie 32 bits - LH_MCGA_Copie_32_bits: - not dword ptr[edi] - add edi,4 - dec cx - jnz LH_MCGA_Copie_32_bits - - LH_MCGA_Fin: - - - pop edi - - mov esp,ebp - pop ebp - - ret - -Ligne_horizontale_XOR_MCGA endp - - - - -Ligne_verticale_XOR_MCGA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word, Pos_Y:word, Hauteur:word - - - ; On met dans EDX la position de d‚part du dessin de la ligne - - mov edx,0A0000h - mov ax,Pos_Y - mov cx,ax - shl ax,8 - add ax,Pos_X - shl cx,6 - add ax,cx - mov dx,ax - - - mov cx,Hauteur ; CX = Nb pixels … afficher sur la ligne - - LV_MCGA_Boucle: - - not byte ptr[edx] - add dx,320 - - dec cx - jnz LV_MCGA_Boucle - - - mov esp,ebp - pop ebp - - ret - -Ligne_verticale_XOR_MCGA endp - - - - -; *************************************************************************** -; *************************************************************************** -; ********************************* MODE X ********************************** -; *************************************************************************** -; *************************************************************************** - - - - -Set_mode_X proc near - - pushad - - mov ax,13h - int 10h - - mov dx,3C6h ; \ - xor al,al ; -+-> Palette Off - out dx,al ; / - mov dx,3C4h - mov ax,0604h - out dx,ax - mov ax,0100h - out dx,ax - - mov al,01h ; \ - out dx,al ; + - inc dx ; | - in al,dx ; | - mov ah,al ; | - mov al,01h ; | - push ax ; | - mov al,ah ; | - or al,20h ; +-> Screen Off - out dx,al ; / - - mov esi,Mode_X_Ptr - cld - lodsb - or al,al - jz DontSetDot - mov dx,3C2h - out dx,al - DontSetDot: - - mov dx,3C4h - mov ax,0300h - out dx,ax - mov dx,3D4h - mov al,11h - out dx,al - inc dx - in al,dx - and al,7Fh - out dx,al - - dec dx - lodsb - xor ecx,ecx - mov cl,al - rep outsw - - mov ax,Largeur_ecran - shr ax,3 - mov ah,al - mov al,13h - out dx,ax - - mov dx,3C4h - mov ax,0F02h - out dx,ax - - mov edi,0A0000h - xor eax,eax - mov ecx,4000h - rep stosd - - - ; On calcule le d‚calage qu'il y a entre la fin de l'‚cran et le d‚but - ; de la ligne suivante: - ; - ; Decalage = (Largeur_image - Largeur_ecran) - - xor ebx,ebx - mov bx,Principal_Largeur_image - sub bx,Largeur_ecran - mov MODE_X_Decalage_synchro,ebx - - ; On calcule la largeur logique d'une ligne: - ; - ; Largeur_de_ligne = Largeur_ecran shr 2 - - mov ax,Largeur_ecran - shr ax,2 - mov MODE_X_Largeur_de_ligne,ax - - mov dx,3C4h ; \ - pop ax ; -+-> Screen On - out dx,ax ; / - mov dx,3C6h ; \ - mov al,0FFh ; -+-> Palette On - out dx,al ; / - - - popad - - ret - -Set_mode_X endp - - - -Pixel_mode_X proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word,Couleur:byte - - pushad - - mov dx,3C4h - mov ax,102h - mov bx,X - mov cx,bx - and cl,03d - shl ah,cl - out dx,ax - - xor eax,eax - mov ax,MODE_X_Largeur_de_ligne - mul Y - add eax,0A0000h - - shr bx,2 - add ax,bx - mov bl,Couleur - mov [eax],bl - - popad - - mov esp,ebp - pop ebp - - ret - -Pixel_mode_X endp - - - -Lit_pixel_mode_X proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word - - push bx - - mov bx,X - mov cx,bx - and cl,03d - mov dx,3CEh - mov al,04h - mov ah,cl - out dx,ax - - xor eax,eax - mov ax,MODE_X_Largeur_de_ligne - mul Y - add eax,0A0000h - - shr bx,02d - add ax,bx - mov al,[eax] - - - pop bx - - mov esp,ebp - pop ebp - - ret - -Lit_pixel_mode_X endp - - - -Effacer_tout_l_ecran_mode_X proc near - - push ebp - mov ebp,esp - - arg Couleur:byte - - pushad - - - ; On fait passer la carte VGA en mode ‚criture sur 4 plans simultan‚s - - mov dx,3C4h - mov ax,0F02h - out dx,ax - - ; On place EDI en d‚but d'‚cran: - - mov edi,0A0000h - - ; On met EBX … 4 fois la couleur: - - mov al,Couleur - mov ah,al - mov bx,ax - shl ebx,16 - mov bx,ax - - ; On calcule le nb de dwords visibles dans l'image - - mov ax,Menu_ordonnee - mul MODE_X_Largeur_de_ligne - shr ax,2 - mov cx,ax - jnc @@Pas_de_probleme - - mov [edi],bx - add edi,2 - - @@Pas_de_probleme: - - @@Boucle: - - mov [edi],ebx - add edi,4 - dec cx - jnz @@Boucle - - - popad - - mov esp,ebp - pop ebp - - ret - -Effacer_tout_l_ecran_mode_X endp - - - - -Block_mode_X proc near - - push ebp - mov ebp,esp - - arg Debut_X:word,Debut_Y:word,Largeur:word,Hauteur:word,Couleur:byte - - pushad - - - ; On met dans CL le plan initial - - mov bx,Debut_X - mov cl,bl - and cl,00000011b - - ; On met dans CH la couleur - - mov ch,Couleur - - ; On met dans ESI la valeur initiale de EDI - - mov ax,Debut_Y - mul MODE_X_Largeur_de_ligne - shr bx,2 - add ax,bx - mov esi,0A0000h - mov si,ax - - mov bx,Largeur ; BX = Nb de colonnes … afficher - mov dx,3C4h ; DX = Port du CRTC (chngt de plan) - - Block_mode_X_Pour_chaque_colonne: - - ; On passe dans le plan d‚tenu par CL - - mov ax,102h - shl ah,cl - out dx,ax - - ; On dessine la colonne en partant de ESI, et sur Hauteur pixels - - mov edi,esi - mov ax,Hauteur ; AX = Nb de pixels … dessiner - - Block_mode_X_Pour_chaque_ligne_du_block: - - ; On recopie un pixel de la couleur demand‚e - - mov [edi],ch - - ; On passe … la ligne suivante - - add di,MODE_X_Largeur_de_ligne - dec ax - jnz Block_mode_X_Pour_chaque_ligne_du_block - - ; On change de colonne: - - dec bx ; Si plus de colonnes … traiter - jz Block_mode_X_Fin_de_traitement ; -> On arrˆte le traitement - - inc cl ; Sinon, on se prepare … passer au plan - and cl,00000011b ; suivant. Si Plan <> 0 - jnz Block_mode_X_Pour_chaque_colonne ; -> On reprend simplement - - inc esi ; Sinon, on incr‚mente l'adresse - jmp Block_mode_X_Pour_chaque_colonne ; et on reprend - - Block_mode_X_Fin_de_traitement: - - - popad - - mov esp,ebp - pop ebp - - ret - -Block_mode_X endp - - - - -; -- Affichage d'un pixel dans l'‚cran, par rapport au d‚calage de l'image -; dans l'‚cran, en mode normal (pas en mode loupe) -- - -; Note: si on modifie cette proc‚dure, il faudra penser … faire ‚galement la -; modif dans la proc‚dure Pixel_Preview_Loupe_mode_X. - -Pixel_Preview_Normal_mode_X proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word,Couleur:byte - - - mov dl,Couleur - mov cx,Y - mov ax,X - sub cx,Principal_Decalage_Y - sub ax,Principal_Decalage_X - push edx - push ecx - push eax - - call Pixel_mode_X - - - mov esp,ebp - pop ebp - - ret - -Pixel_Preview_Normal_mode_X endp - - - - -; -- Affichage d'un pixel dans l'‚cran, par rapport au d‚calage de l'image -; dans l'‚cran, en mode loupe -- - -Pixel_Preview_Loupe_mode_X proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word,Couleur:byte - - push ebx - - - ; On affiche d'abord le pixel dans la partie non-zoom‚e - - mov dl,Couleur ; Ca ne co–te pas trop - mov cx,Y ; en code de recopier - mov ax,X ; le contenu de la - sub cx,Principal_Decalage_Y ; proc‚dure - sub ax,Principal_Decalage_X ; Pixel_Preview_Normal_mode_X - push edx ; et ‡a fait gagner du - push ecx ; temps, et ce temps est - push eax ; assez pr‚cieux vu que - call Pixel_mode_X ; c'est appel‚ TRES souvent. - add esp,12 ; 3 paramŠtres dword - - ; On regarde si on peut afficher le pixel ‚galement dans la loupe - - mov ax,Y - cmp ax,Limite_Haut_Zoom - jb Pixel_Preview_Loupe_mode_X_Fin - cmp ax,Limite_visible_Bas_Zoom - ja Pixel_Preview_Loupe_mode_X_Fin - mov ax,X - cmp ax,Limite_Gauche_Zoom - jb Pixel_Preview_Loupe_mode_X_Fin - cmp ax,Limite_visible_Droite_Zoom - ja Pixel_Preview_Loupe_mode_X_Fin - - ; On passe la couleur - - mov al,Couleur - mov edx,Table_mul_facteur_zoom ; On pointe sur la table de x (OPTI) - push eax - - ; On calcule dans EAX (X) et ECX (Y) le d‚marrage du bloc: - - xor eax,eax - xor ecx,ecx - mov ax,X - mov cx,Y - sub ax,Loupe_Decalage_X - sub cx,Loupe_Decalage_Y - mov ax,[edx+2*eax] - mov cx,[edx+2*ecx] - - ; On sauve ces valeurs dans BX (X) et DX (Y): - - mov bx,ax - mov dx,cx - - ; On s'occupe de la hauteur: - - add cx,Loupe_Facteur - cmp cx,Menu_Ordonnee - ja Pixel_Preview_Loupe_mode_X_Tronque_en_hauteur - - mov cx,Loupe_Facteur - push ecx - jmp Pixel_Preview_Loupe_mode_X_Traitement_de_la_largeur - - Pixel_Preview_Loupe_mode_X_Tronque_en_hauteur: - - mov cx,dx - neg cx - add cx,Menu_Ordonnee - push ecx - - ; On s'occupe de la largeur: - - Pixel_Preview_Loupe_mode_X_Traitement_de_la_largeur: - - add bx,Principal_X_Zoom - - mov ax,Loupe_Facteur - push eax - - ; On passe le d‚but en Y: - push edx - - ; On passe le d‚but en X: - push ebx - - call Block_mode_X - - - add esp,20 ; 20 = 5 paramŠtres de type dword - pop ebx - - Pixel_Preview_Loupe_mode_X_Fin: - - mov esp,ebp - pop ebp - - ret - -Pixel_Preview_Loupe_mode_X endp - - - - -Ligne_horizontale_XOR_mode_X proc near - - push ebp - mov ebp,esp - - arg Pos_X:word, Pos_Y:word, Largeur:word - - push ebx - push esi - push edi - - - ; On met dans CL le plan initial - - mov bx,Pos_X - mov cl,bl - and cl,00000011b - - ; On met dans ESI la valeur initiale de EDI - ; (ESI=D‚but de ligne, EDI=Position dans la ligne) - - mov esi,0A0000h - mov ax,Pos_Y - mul MODE_X_Largeur_de_ligne - shr bx,2 - add ax,bx - mov si,ax - - ; On met dans BX la coordonn‚e de fin +1 - - mov bx,Pos_X - add bx,Largeur - - ; On place dans CH le nb de plans … traiter - - mov ch,4 - - LH_Pour_chaque_plan: - - ; On initialise EDI - - mov edi,esi - - ; On passe dans le plan d‚tenu par CL - - ; Plan d'‚criture: - - mov dx,3C4h ; DX = Port du CRTC (chngt de plan) - mov ax,102h - shl ah,cl - out dx,ax - - ; Plan de lecture: - - mov dx,3CEh ; DX = Port du TS (enfin, je crois) - mov ah,cl - mov al,04h - out dx,ax - - ; On met dans AX la coordonn‚e de d‚part - - mov ax,Pos_X - - LH_Boucle: - - cmp ax,bx - jae LH_Fin_de_traitement - - not byte ptr[edi] ; On inverse le pixel courant - - inc edi ; On passe … la coordonn‚e +4 - add ax,4 - - jmp LH_Boucle - - LH_Fin_de_traitement: - - ; On pr‚pare CL pour le prochain plan: - - inc cl - and cl,00000011b - jnz LH_On_repasse_pas_dans_le_plan_0 - - ; On pr‚pare ESI pour le prochain plan: - - inc esi - - LH_On_repasse_pas_dans_le_plan_0: - - ; On pr‚pare la coordonn‚e de d‚part pour le prochain plan: - - inc Pos_X - - ; On regarde s'il reste un plan … traiter: - - dec ch - jnz LH_Pour_chaque_plan - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Ligne_horizontale_XOR_mode_X endp - - - - -Ligne_verticale_XOR_mode_X proc near - - push ebp - mov ebp,esp - - arg Pos_X:word, Pos_Y:word, Hauteur:word - - - ; On met dans CL le plan initial - - mov cx,Pos_X - and cl,00000011b - - ; On passe dans le plan d‚tenu par CL - - ; Plan d'‚criture: - - mov dx,3C4h ; DX = Port du CRTC (chngt de plan) - mov ax,102h - shl ah,cl - out dx,ax - - ; Plan de lecture: - - mov dx,3CEh ; DX = Port du TS (enfin, je crois) - mov ah,cl - mov al,04h - out dx,ax - - ; On met dans EDX la coordonn‚e initiale - - mov edx,0A0000h - mov cx,Pos_X - mov ax,Pos_Y - mul MODE_X_Largeur_de_ligne - shr cx,2 - add ax,cx - mov dx,ax - - ; On place dans CX le nb de pixels … traiter - - mov cx,Hauteur - - ; On place dans AX la distance qu'il y a d'une ligne … l'autre: - - mov ax,Mode_X_Largeur_de_ligne - - LV_Pour_chaque_ligne: - - not byte ptr[edx] - add dx,ax - - dec cx - jnz LV_Pour_chaque_ligne - - - mov esp,ebp - pop ebp - - ret - -Ligne_verticale_XOR_mode_X endp - - - - -; *************************************************************************** -; *************************************************************************** -; ********************************** VESA *********************************** -; *************************************************************************** -; *************************************************************************** - - - -VESA_Change_banque_Fenetre_A_FAST proc near - -; ParamŠtre en entr‚e: -; AL = Banque sur laquelle aller dans la fenˆtre A - - cmp al,VESA_Derniere_banque_Fenetre_A_utilisee - je VESA_Change_banque_Fenetre_A_FAST_Pas_besoin_de_changer - - pushad - xor ah,ah - mov cl,Granularite - mov dx,ax - xor bx,bx - shl dx,cl - mov ax,4F05h - call [VESA_WinFuncPtr] - popad - mov VESA_Derniere_banque_Fenetre_A_utilisee,al - - VESA_Change_banque_Fenetre_A_FAST_Pas_besoin_de_changer: - - ret - -VESA_Change_banque_Fenetre_A_FAST endp - - - -VESA_Change_banque_Fenetre_B_FAST proc near - -; ParamŠtre en entr‚e: -; AL = Banque sur laquelle aller dans la fenˆtre B - - cmp al,VESA_Derniere_banque_Fenetre_B_utilisee - je VESA_Change_banque_Fenetre_B_FAST_Pas_besoin_de_changer - - pushad - xor ah,ah - mov cl,Granularite - mov dx,ax - mov bx,1 - shl dx,cl - mov ax,4F05h - call [VESA_WinFuncPtr] - popad - mov VESA_Derniere_banque_Fenetre_B_utilisee,al - - VESA_Change_banque_Fenetre_B_FAST_Pas_besoin_de_changer: - - ret - -VESA_Change_banque_Fenetre_B_FAST endp - - - -VESA_Change_banque_Fenetre_A_et_B_FAST proc near - -; ParamŠtre en entr‚e: -; AL = Banque sur laquelle aller dans les fenˆtres A et B - - cmp al,VESA_Derniere_banque_Fenetre_A_utilisee - je VESA_Change_banque_Fenetre_A_et_B_FAST_Pas_besoin_de_changer_A - - pushad - xor ah,ah - mov cl,Granularite - mov dx,ax - xor bx,bx - shl dx,cl - mov ax,4F05h - call [VESA_WinFuncPtr] - popad - mov VESA_Derniere_banque_Fenetre_A_utilisee,al - - VESA_Change_banque_Fenetre_A_et_B_FAST_Pas_besoin_de_changer_A: - - cmp al,VESA_Derniere_banque_Fenetre_B_utilisee - je VESA_Change_banque_Fenetre_A_et_B_FAST_Pas_besoin_de_changer_B - - pushad - xor ah,ah - mov cl,Granularite - mov dx,ax - mov bx,1 - shl dx,cl - mov ax,4F05h - call [VESA_WinFuncPtr] - popad - mov VESA_Derniere_banque_Fenetre_B_utilisee,al - - VESA_Change_banque_Fenetre_A_et_B_FAST_Pas_besoin_de_changer_B: - - ret - -VESA_Change_banque_Fenetre_A_et_B_FAST endp - - - -VESA_Change_banque_Fenetre_A proc near - -; ParamŠtre en entr‚e: -; AL = Banque sur laquelle aller dans la fenˆtre A - - cmp al,VESA_Derniere_banque_Fenetre_A_utilisee - je VESA_Change_banque_Fenetre_A_Pas_besoin_de_changer - - pushad - xor ah,ah - mov cl,Granularite - mov dx,ax - xor bx,bx - shl dx,cl - mov ax,4F05h - int 10h - popad - mov VESA_Derniere_banque_Fenetre_A_utilisee,al - - VESA_Change_banque_Fenetre_A_Pas_besoin_de_changer: - - ret - -VESA_Change_banque_Fenetre_A endp - - - -VESA_Change_banque_Fenetre_B proc near - -; ParamŠtre en entr‚e: -; AL = Banque sur laquelle aller dans la fenˆtre B - - cmp al,VESA_Derniere_banque_Fenetre_B_utilisee - je VESA_Change_banque_Fenetre_B_Pas_besoin_de_changer - - pushad - xor ah,ah - mov cl,Granularite - mov dx,ax - mov bx,1 - shl dx,cl - mov ax,4F05h - int 10h - popad - mov VESA_Derniere_banque_Fenetre_B_utilisee,al - - VESA_Change_banque_Fenetre_B_Pas_besoin_de_changer: - - ret - -VESA_Change_banque_Fenetre_B endp - - - -VESA_Change_banque_Fenetre_A_et_B proc near - -; ParamŠtre en entr‚e: -; AL = Banque sur laquelle aller dans les fenˆtres A et B - - cmp al,VESA_Derniere_banque_Fenetre_A_utilisee - je VESA_Change_banque_Fenetre_A_et_B_Pas_besoin_de_changer_A - - pushad - xor ah,ah - mov cl,Granularite - mov dx,ax - xor bx,bx - shl dx,cl - mov ax,4F05h - int 10h - popad - mov VESA_Derniere_banque_Fenetre_A_utilisee,al - - VESA_Change_banque_Fenetre_A_et_B_Pas_besoin_de_changer_A: - - cmp al,VESA_Derniere_banque_Fenetre_B_utilisee - je VESA_Change_banque_Fenetre_A_et_B_Pas_besoin_de_changer_B - - pushad - xor ah,ah - mov cl,Granularite - mov dx,ax - mov bx,1 - shl dx,cl - mov ax,4F05h - int 10h - popad - mov VESA_Derniere_banque_Fenetre_B_utilisee,al - - VESA_Change_banque_Fenetre_A_et_B_Pas_besoin_de_changer_B: - - ret - -VESA_Change_banque_Fenetre_A_et_B endp - - - -;; - -- --- ----\/\ Detection du support VESA sur la machine: /\/---- --- -- - -; -;Support_VESA proc near -; -; pushad -; -; ; On pr‚suppose qu'il n'y a pas d'erreur (pour l'instant) -; -; mov VESA_Erreur,0 -; -; ; On passe en mode graphique, o— nous attend un super buffer de 64Ko -; -; mov ax,0013h -; int 10h -; mov dx,03C6h ; On ‚teint la palette -; xor al,al -; out dx,al -; -; ; On demande les infos VESA: (AX=4F00, ES:DI=Adresse du buffer) -; -; mov ax,0300h ; Service DPMI simuler une interruption en mode r‚el -; mov bl,10h ; Interruption … appeler (int vid‚o) -; xor bh,bh ; Etat des flags pass‚ … l'interruption -; xor cx,cx ; Nb d'elements de la pile … passer -; mov edi,0A8000h ; Adresse des valeurs des registres … passer … l'interruption -; mov dword ptr[edi+28],00004F00h ; EAX pass‚ … l'interruption -; mov dword ptr[edi+00],00000000h ; EDI pass‚ … l'interruption -; mov word ptr[edi+34],0A000h ; ES pass‚ … l'interruption -; mov edx,0A0000h -; mov dword ptr[edx],32454256h ; valeur hexa de "VBE2" -; int 31h ; Appel de l'interruption du DPMI -; -; ; Si AX <> 004F => Echec -; -; mov eax,dword ptr[edi+28] -; cmp ax,004Fh -; je Support_VESA_Pas_d_echec -; -; ; L'appel … l'interruption a ‚chou‚ -; -; Support_VESA_Echec: -; -; mov VESA_Erreur,1 -; jmp Support_VESA_Fin_traitement -; -; Support_VESA_Pas_d_echec: -; -; ; L'appel … l'interruption n'a pas ‚chou‚ -; -; ; On v‚rifie que la signature soit bien ‚gale … VESA: -; -; mov esi,0A0000h -; cmp byte ptr[esi+0],'V' -; jne Support_VESA_Echec -; -; cmp byte ptr[esi+1],'E' -; jne Support_VESA_Echec -; -; cmp byte ptr[esi+2],'S' -; jne Support_VESA_Echec -; -; cmp byte ptr[esi+3],'A' -; jne Support_VESA_Echec -; -; ; La signature est bien pr‚sente -; -; ; On enregistre l'adresse de la liste des modes VESA support‚s: -; -; xor ebx,ebx -; xor eax,eax -; mov bx,[esi+16] ; (Lst_Seg) -; mov ax,[esi+14] ; (Lst_Ofs) -; shl ebx,4 -; add ebx,eax -; mov VESA_Liste_des_modes,ebx -; -; ; On enregistre le num‚ro de version de VESA -; -; mov ax,word ptr[esi+4] -; mov VESA_Version_Unite,ah -; mov VESA_Version_Decimale,al -; -; ; On enregistre l'adresse de la chaŒne du constructeur -; -; xor ebx,ebx -; xor eax,eax -; mov bx,word ptr[esi+8] -; mov ax,word ptr[esi+6] -; shl ebx,4 -; add ebx,eax -; mov VESA_Constructeur,ebx -; -; ; On enregistre la taille totale de m‚moire vid‚o -; -; mov ax,[esi+18] -; mov VESA_Taille_memoire,ax -; -; -; Support_VESA_Fin_Traitement: -; -; popad -; -; ret -; -;Support_VESA endp -; -; -; -;; - -- --- -----\/\ Detection du support VESA pour un mode: /\/----- --- -- - -; -;Mode_VESA_supporte proc near -; -; push ebp -; mov ebp,esp -; -; arg Mode:word -; -; pushad -; -; ; On pressupose qu'il n'y a pas d'erreur (pour l'instant) -; ; On se servira de la valeur de SI comme code d'erreur pour faciliter le -; ; d‚bugging -; -; mov si,4 ; Code d'erreur de base -; mov VESA_Erreur,0 -; -; ; On va commencer par regarder si le mode n'est pas dans la liste de ceux -; ; support‚s par la carte. Pour cela, il nous faut redemander cette liste -; ; car certaines cartes la "perdent" d'un appel sur l'autre. -; -; ; On passe en mode graphique, o— nous attend un super buffer de 64Ko -; -; mov ax,0013h -; int 10h -; mov dx,03C6h ; On ‚teint la palette -; xor al,al -; out dx,al -; -; ; On demande les infos VESA: (AX=4F00, ES:DI=Adresse du buffer) -; -; mov ax,0300h ; Service DPMI simuler une interruption en mode r‚el -; mov bl,10h ; Interruption … appeler (int vid‚o) -; xor bh,bh ; Etat des flags pass‚ … l'interruption -; xor cx,cx ; Nb d'elements de la pile … passer -; mov edi,0A8000h ; Adresse des valeurs des registres … passer … l'interruption -; mov dword ptr[edi+28],00004F00h ; EAX pass‚ … l'interruption -; mov dword ptr[edi+00],00000000h ; EDI pass‚ … l'interruption -; mov word ptr[edi+34],0A000h ; ES pass‚ … l'interruption -; mov edx,0A0000h -; mov dword ptr[edx],32454256h ; valeur hexa de "VBE2" -; int 31h ; Appel de l'interruption du DPMI -; -; ; Si AX <> 004F => Echec -; -; mov eax,dword ptr[edi+28] -; cmp ax,004Fh -; jne Mode_VESA_supporte_Echec -; -; ; On enregistre l'adresse de la liste des modes VESA support‚s dans EDI -; -; mov edi,0A0000h -; xor ebx,ebx -; xor eax,eax -; mov bx,[edi+16] ; (Lst_Seg) -; mov ax,[edi+14] ; (Lst_Ofs) -; shl ebx,4 -; add ebx,eax -; mov edi,ebx -; -; ; Et on parcours la liste pour chercher le mode demand‚ -; -; mov ax,Mode -; -; Mode_VESA_supporte_Boucle: -; -; cmp [edi],ax -; je Mode_VESA_supporte_Fin_boucle -; -; cmp word ptr[edi],0FFFFh -; je Mode_VESA_supporte_Fin_boucle -; -; add edi,2 -; jmp Mode_VESA_supporte_Boucle -; -; Mode_VESA_supporte_Fin_boucle: -; -; ; Si le mode en cours = FFFF => Echec -; -; mov si,5 ; Nouveau code d'erreur -; -; cmp word ptr[edi],ax -; je Mode_VESA_supporte_Pas_echec -; -; ; Ce mode vid‚o VESA n'est pas support‚: -; -; Mode_VESA_supporte_Echec: -; -; mov ax,si -; mov VESA_Erreur,al -; jmp Mode_VESA_supporte_Fin_traitement -; -; Mode_VESA_supporte_Pas_echec: -; -; ; Ce mode vid‚o VESA est un ‚l‚ment de la liste: -; -; ; On passe en mode graphique, o— nous attend un super buffer de 64Ko (c00l) -; -; mov ax,0013h -; int 10h -; mov dx,03C6h ; On ‚teint la palette -; xor al,al -; out dx,al -; -; ; On demande les infos VESA du mode: (AX=4F01, CX=Mode, ES:DI=Adresse du buffer) -; -; mov ax,0300h ; Service DPMI simuler une interruption en mode r‚el -; mov bl,10h ; Interruption … appeler (int vid‚o) -; xor bh,bh ; Etat des flags pass‚ … l'interruption -; xor cx,cx ; Nb d'elements de la pile … passer -; mov edi,0A8000h ; Adresse des valeurs des registres … passer … l'interruption -; mov dword ptr[edi+28],00004F01h ; AX pass‚ … l'interruption -; xor edx,edx -; mov dx,Mode -; mov dword ptr[edi+24],edx ; ECX pass‚ … l'interruption -; mov dword ptr[edi+00],00000000h ; EDI pass‚ … l'interruption -; mov word ptr[edi+34],0A000h ; ES pass‚ … l'interruption -; int 31h ; Appel de l'interruption du DPMI -; -; ; Si AX <> 004F => Echec -; -; mov si,6 ; Nouveau code d'erreur -; -; mov eax,dword ptr[edi+28] -; cmp ax,004Fh -; jne Mode_VESA_supporte_Echec -; -; ; L'appel … l'interruption n'a pas ‚chou‚ -; -; ; On v‚rifie l'utilit‚ des deux fenˆtres: -; -; mov edi,0A0000h -; mov al,[edi+2] -; and al,7 -; cmp al,7 -; jne Mode_VESA_supporte_Fenetre_A_insuffisante -; -; mov VESA_Erreur,0 -; jmp Mode_VESA_supporte_Traitement_fenetres_termine -; -; Mode_VESA_supporte_Fenetre_A_insuffisante: -; -; mov al,[edi+3] -; and al,7 -; cmp al,7 -; jne Mode_VESA_supporte_Fenetre_B_insuffisante -; -; mov VESA_Erreur,1 -; jmp Mode_VESA_supporte_Traitement_fenetres_termine -; -; Mode_VESA_supporte_Fenetre_B_insuffisante: -; -; mov al,[edi+2] -; test al,1 -; jz Mode_VESA_supporte_Pas_fenetres_par_defaut -; -; mov VESA_Erreur,2 -; jmp Mode_VESA_supporte_Traitement_fenetres_termine -; -; Mode_VESA_supporte_Pas_fenetres_par_defaut: -; -; test al,2 -; jz Mode_VESA_supporte_Fenetre_A_pas_lisible -; -; mov VESA_Erreur,3 -; jmp Mode_VESA_supporte_Traitement_fenetres_termine -; -; Mode_VESA_supporte_Fenetre_A_pas_lisible: -; -; mov VESA_Erreur,2 -; -; Mode_VESA_supporte_Traitement_fenetres_termine: -; -; ; On v‚rifie que la taille des fenˆtres soit bien de 64Ko: -; -; mov si,7 ; Nouveau code d'erreur -; -; cmp word ptr[edi+6],64 -; jne Mode_VESA_supporte_Echec -; -; ; On lit la valeur de granularite: -; -; mov ax,[edi+4] -; -; ; Et on en d‚duit un facteur de granularite: -; -; ; Test si granularite = 64: -; -; cmp ax,64 -; jne Mode_VESA_supporte_Gran_pas_64 -; -; mov Granularite,0 -; jmp Mode_VESA_supporte_Fin_traitement_granularite -; -; Mode_VESA_supporte_Gran_pas_64: -; -; ; Test si granularite = 32: -; -; cmp ax,32 -; jne Mode_VESA_supporte_Gran_pas_32 -; -; mov Granularite,1 -; jmp Mode_VESA_supporte_Fin_traitement_granularite -; -; Mode_VESA_supporte_Gran_pas_32: -; -; ; Test si granularite = 16: -; -; cmp ax,16 -; jne Mode_VESA_supporte_Gran_pas_16 -; -; mov Granularite,2 -; jmp Mode_VESA_supporte_Fin_traitement_granularite -; -; Mode_VESA_supporte_Gran_pas_16: -; -; ; Test si granularite = 8: -; -; cmp ax,8 -; jne Mode_VESA_supporte_Gran_pas_8 -; -; mov Granularite,3 -; jmp Mode_VESA_supporte_Fin_traitement_granularite -; -; Mode_VESA_supporte_Gran_pas_8: -; -; ; Test si granularite = 4: -; -; cmp ax,4 -; jne Mode_VESA_supporte_Gran_pas_4 -; -; mov Granularite,4 -; jmp Mode_VESA_supporte_Fin_traitement_granularite -; -; Mode_VESA_supporte_Gran_pas_4: -; -; ; Test si granularite = 2: -; -; cmp ax,2 -; jne Mode_VESA_supporte_Gran_pas_2 -; -; mov Granularite,5 -; jmp Mode_VESA_supporte_Fin_traitement_granularite -; -; Mode_VESA_supporte_Gran_pas_2: -; -; ; Test si granularite = 1: -; -; cmp ax,1 -; jne Mode_VESA_supporte_Gran_pas_1 -; -; mov Granularite,6 -; jmp Mode_VESA_supporte_Fin_traitement_granularite -; -; Mode_VESA_supporte_Gran_pas_1: -; -; mov VESA_Erreur,4 -; -; Mode_VESA_supporte_Fin_traitement_granularite: -; -; -; -; mov VESA_WinFuncPtr,00000000h -; -; ; On passe en mode graphique, o— nous attend un super buffer de 64Ko (c00l) -; -; mov ax,0013h -; int 10h -; mov dx,03C6h ; On ‚teint la palette -; xor al,al -; out dx,al -; -; ; On demande le code de changement de banque -; -; mov ax,0300h ; Service DPMI simuler une interruption en mode r‚el -; mov bl,10h ; Interruption … appeler (int vid‚o) -; xor bh,bh ; Etat des flags pass‚ … l'interruption -; xor cx,cx ; Nb d'elements de la pile … passer -; mov edi,0A8000h ; Adresse des valeurs des registres … passer … l'interruption -; mov dword ptr[edi+28],00004F0Ah ; EAX pass‚ … l'interruption -; mov dword ptr[edi+16],00000000h ; EBX pass‚ … l'interruption -; int 31h ; Appel de l'interruption du DPMI -; -; ; Si AX <> 004F => Echec -; -; mov si,8 ; Nouveau code d'erreur -; -; mov eax,dword ptr[edi+28] -; cmp ax,004Fh -; jne Mode_VESA_supporte_Fin_traitement -; -; ; On note l'adresse du handler software de changement de banque -; -; xor eax,eax -; xor ecx,ecx -; mov ax,word ptr[edi+34] ; ES retourn‚ par l'interruption -; mov cx,word ptr[edi+00] ; DI retourn‚ par l'interruption -; shl eax,4 -; add eax,ecx -; mov cx,[eax] -; add eax,ecx -; mov VESA_WinFuncPtr,eax -; -; Mode_VESA_supporte_Fin_traitement: -; -; -; popad -; -; mov esp,ebp -; pop ebp -; -; ret -; -;Mode_VESA_supporte endp - - - -; -- Initialisation du Mode Graphique VESA -- - -Initialiser_mode_video_VESA proc near - - push ebp - mov ebp,esp - - arg Video_mode:word - - push ebx - - mov VESA_Derniere_banque_Fenetre_A_utilisee,0 - mov VESA_Derniere_banque_Fenetre_B_utilisee,0 - - mov ax,4F02h - mov bx,Video_mode - int 10h - - ; On donne la largeur logique de l'‚cran car certaines cartes vid‚o la - ; reconnaissent mal... (va savoir pourquoi!?) - mov ax,4F06h - xor bl,bl - mov cx,Largeur_ecran - int 10h - - ; On calcule la distance d'octet en m‚moire qu'il y a entre la fin d'une - ; ligne d'image … l'‚cran et le d‚but de la suivante … l'‚cran: - ; - ; Decalage = (Largeur_image - Largeur_ecran) - - xor ebx,ebx - mov bx,Principal_Largeur_image - sub bx,Largeur_ecran - mov VESA_Decalage_synchro,ebx - - ; On calcule la largeur d'une ligne de l'‚cran en dword: - ; - ; Largeur en dword = Largeur_ecran shr 2 - - mov ax,Largeur_ecran - shr ax,2 - mov VESA_Largeur_ecran_en_dword,ax - - pop ebx - - mov esp,ebp - pop ebp - - ret - -Initialiser_mode_video_VESA endp - - - -; - --/\/ Retoucher les registres du CRTC pour redimensionner l'‚cran \/\-- - - -Retoucher_CRTC proc near - - pushad - - mov esi,Mode_X_Ptr - cld - lodsb - or al,al - jz NoThankYou - mov dx,3C2h - out dx,al - NoThankYou: - - mov dx,3D4h - mov al,11h - out dx,al - inc dx - in al,dx - and al,7Fh - out dx,al - - dec dx - lodsb - xor ecx,ecx - mov cl,al - rep outsw - - popad - - ret - -Retoucher_CRTC endp - - - - -; -- Affichage d'un point graphique en X,Y -- - -Pixel_VESA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Couleur:byte - - - mov edx,0A0000h - mov cl,Couleur - - mov ax,Pos_Y - mul Largeur_ecran - add ax,Pos_X - adc dx,0 - - xchg dx,ax - call [VESA_Change_banque_ecriture] - - mov [edx],cl - - - mov esp,ebp - pop ebp - - ret - -Pixel_VESA endp - - - - -; -- R‚cup‚ration d'un point graphique en X,Y -- - -Lit_pixel_VESA proc near - - push ebp - mov ebp,esp - - ARG Pos_X:word,Pos_Y:word - - - xor eax,eax - mov edx,0A0000h - - mov ax,Pos_Y - mul Largeur_ecran - add ax,Pos_X - adc dx,0 - - xchg dx,ax - call [VESA_Change_banque_lecture] - - mov al,byte ptr[edx] - - - mov esp,ebp - pop ebp - - ret - -Lit_pixel_VESA endp - - - -Effacer_tout_l_ecran_VESA proc near - - push ebp - mov ebp,esp - - arg Couleur:byte - - pushad - - - ; On met dans EBX 4 fois la couleur - - mov al,Couleur - mov ah,al - mov bx,ax - shl ebx,16 - mov bx,ax - - ; On calcule l'endroit jusqu'o— on efface l'ecran - - mov ax,Menu_ordonnee - mul Largeur_ecran - - ; DX = DerniŠre banque touch‚e - ; AX = DerniŠre position touch‚e - - shr ax,2 ; On divise AX par 4 puisqu'on travaille avec des dword - - Pour_chaque_banque: - - ; On passe … la banque DL - - xchg dx,ax - call [VESA_Change_banque_ecriture] - xchg dx,ax - - ; On se positionne en d‚but de banque: - - mov edi,0A0000h - - ; On efface AX mots: - - mov cx,ax - - ; On met dans EAX 4 fois la couleur: - - mov eax,ebx - - Boucle: - - mov [edi],eax - add edi,4 - dec cx - jnz Boucle - - mov ax,4000h ; On demande pour la prochaine banque un remplissage sur - ; toute sa taille - - dec dl - jns Pour_chaque_banque - - - popad - - mov esp,ebp - pop ebp - - ret - -Effacer_tout_l_ecran_VESA endp - - - - - -Block_VESA proc near - - push ebp - mov ebp,esp - - arg Debut_X:word,Debut_Y:word,Largeur:word,Hauteur:word,Couleur:byte - - push ebx - push esi - push edi - - - ; On place dans ESI 4 fois la couleur - - mov cl,Couleur - mov ch,cl - mov si,cx - shl esi,16 - mov si,cx - - ; On calcule dans EDI la premiŠre coordonn‚e du bloc: - - mov ax,Debut_Y - mul Largeur_ecran - add ax,Debut_X - adc dx,0 - mov edi,0A0000h - mov di,ax - - ; On m‚morise la banque n‚cessaire - - mov VESA_Banque_en_cours,dl - - ; On passe dans cette banque - - mov al,dl - call [VESA_Change_banque_ecriture] - - ; On met dans BX le nombre de ligne … traiter: - - mov bx,Hauteur - - ; On met dans DX le d‚calage qu'il faudra effectuer en fin de ligne sur DI - ; pour qu'il pointe sur la nouvelle ligne - - mov dx,Largeur_ecran - sub dx,Largeur - - xor ecx,ecx - - Block_VESA_Pour_chaque_ligne: - - ; On regarde si la totalit‚ de la ligne loge dans la banque: - - mov cx,di - add cx,Largeur - jc Block_VESA_Ligne_rompue - - ; A ce stade, on sait que la ligne loge entiŠrement sur l'‚cran - - ; On va donc placer dans EAX 4 fois la couleur - - mov eax,esi - - ; On place dans CX le nb de pixels … afficher sur la ligne - - mov cx,Largeur - - ; On commence par afficher les "d‚chets" de d‚but de ligne - - shr cx,1 - jnc Block_VESA_Ininterrompue_Largeur_paire - stosb - - Block_VESA_Ininterrompue_Largeur_paire: - - shr cx,1 - jnc Block_VESA_Ininterrompue_Largeur_multiple_de_4 - stosw - - Block_VESA_Ininterrompue_Largeur_multiple_de_4: - - ; On affiche ce qui reste de la ligne - - rep stosd - - ; On regarde si ce n'‚tait pas la derniŠre ligne - - dec bx - jz Block_VESA_Fin_de_traitement - - ; Sinon, - ; Maintenant que la ligne est affich‚e, on regarde si le changement de - ; ligne ne d‚clenche pas un changement de banque: - - add di,dx - jnc Block_VESA_Pour_chaque_ligne - - ; Si le changement de banque est n‚cessaire, on s'en fait un: - - inc VESA_Banque_en_cours - mov al,VESA_Banque_en_cours - call [VESA_Change_banque_ecriture] - jmp Block_VESA_Pour_chaque_ligne - - Block_VESA_Ligne_rompue: - - ; A ce stade, on sait que la ligne ne loge pas entiŠrement sur l'‚cran - - ; On m‚morise dans la pile ce qu'il restera … afficher … la droite de la - ; rupture: - - push cx - - ; On place dans EAX 4 fois la couleur - - mov eax,esi - - ; On met dans CX le nb de pixels affichables avant la rupture - - mov cx,di - neg cx - - ; On commence par afficher les "d‚chets" de d‚but de ligne - - shr cx,1 - jnc Block_VESA_Interrompue_Largeur_gauche_paire - stosb - - Block_VESA_Interrompue_Largeur_gauche_paire: - - shr cx,1 - jnc Block_VESA_Interrompue_Largeur_gauche_multiple_de_4 - stosw - - Block_VESA_Interrompue_Largeur_gauche_multiple_de_4: - - ; On affiche ce qui reste de la partie gauche de la ligne - - rep stosd - - ; On change de banque: - - inc VESA_Banque_en_cours - mov al,VESA_Banque_en_cours - call [VESA_Change_banque_ecriture] - mov eax,esi - - ; On replace EDI en d‚but de banque - - mov edi,0A0000h - - ; On restaure le nb de pixels … afficher … droite de la rupture - - pop cx - - ; On commence par afficher les "d‚chets" de d‚but de ligne - - shr cx,1 - jnc Block_VESA_Interrompue_Largeur_droite_paire - stosb - - Block_VESA_Interrompue_Largeur_droite_paire: - - shr cx,1 - jnc Block_VESA_Interrompue_Largeur_droite_multiple_de_4 - stosw - - Block_VESA_Interrompue_Largeur_droite_multiple_de_4: - - ; On affiche ce qui reste de la partie droite de la ligne - - rep stosd - - ; On regarde si ce n'‚tait pas la derniŠre ligne - ; (on peut se permettre de supposer qu'aprŠs ce changement de banque, - ; on ne cours qu'un risque proche de 0 qu'un nouveau changement de - ; banque survienne lors du changement de ligne - pour ne pas dire que - ; c'est une chose impossible) - - add di,dx - dec bx - jnz Block_VESA_Pour_chaque_ligne - - - Block_VESA_Fin_de_traitement: - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Block_VESA endp - - - - -; -- Affichage d'un pixel dans l'‚cran, par rapport au d‚calage de l'image -; dans l'‚cran, en mode normal (pas en mode loupe) -- - -; Note: si on modifie cette proc‚dure, il faudra penser … faire ‚galement la -; modif dans la proc‚dure Pixel_Preview_Loupe_VESA. - -Pixel_Preview_Normal_VESA proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word,Couleur:byte - - - mov dl,Couleur - mov cx,Y - mov ax,X - sub cx,Principal_Decalage_Y - sub ax,Principal_Decalage_X - push edx - push ecx - push eax - - call Pixel_VESA - - - mov esp,ebp - pop ebp - - ret - -Pixel_Preview_Normal_VESA endp - - - - -; -- Affichage d'un pixel dans l'‚cran, par rapport au d‚calage de l'image -; dans l'‚cran, en mode loupe -- - -Pixel_Preview_Loupe_VESA proc near - - push ebp - mov ebp,esp - - arg X:word,Y:word,Couleur:byte - - push ebx - - - ; On affiche d'abord le pixel dans la partie non-zoom‚e - - mov dl,Couleur ; Ca ne co–te pas trop - mov cx,Y ; en code de recopier - mov ax,X ; le contenu de la - sub cx,Principal_Decalage_Y ; proc‚dure - sub ax,Principal_Decalage_X ; Pixel_Preview_Normal_VESA - push edx ; et ‡a fait gagner du - push ecx ; temps, et ce temps est - push eax ; assez pr‚cieux vu que - call Pixel_VESA ; c'est appel‚ TRES souvent. - add esp,12 ; 3 paramŠtres dword - - ; On regarde si on peut afficher le pixel ‚galement dans la loupe - - mov ax,Y - cmp ax,Limite_Haut_Zoom - jb Pixel_Preview_Loupe_VESA_Fin - cmp ax,Limite_visible_Bas_Zoom - ja Pixel_Preview_Loupe_VESA_Fin - mov ax,X - cmp ax,Limite_Gauche_Zoom - jb Pixel_Preview_Loupe_VESA_Fin - cmp ax,Limite_visible_Droite_Zoom - ja Pixel_Preview_Loupe_VESA_Fin - - ; On passe la couleur - - mov al,Couleur - mov edx,Table_mul_facteur_zoom ; On pointe sur la table de x (OPTI) - push eax - - ; On calcule dans EAX (X) et ECX (Y) le d‚marrage du bloc: - - xor eax,eax - xor ecx,ecx - mov ax,X - mov cx,Y - sub ax,Loupe_Decalage_X - sub cx,Loupe_Decalage_Y - mov ax,[edx+2*eax] - mov cx,[edx+2*ecx] - - ; On sauve ces valeurs dans BX (X) et DX (Y): - - mov bx,ax - mov dx,cx - - ; On s'occupe de la hauteur: - - add cx,Loupe_Facteur - cmp cx,Menu_Ordonnee - ja Pixel_Preview_Loupe_VESA_Tronque_en_hauteur - - mov cx,Loupe_Facteur - push ecx - jmp Pixel_Preview_Loupe_VESA_Traitement_de_la_largeur - - Pixel_Preview_Loupe_VESA_Tronque_en_hauteur: - - mov cx,dx - neg cx - add cx,Menu_Ordonnee - push ecx - - ; On s'occupe de la largeur: - - Pixel_Preview_Loupe_VESA_Traitement_de_la_largeur: - - add bx,Principal_X_Zoom - - mov ax,Loupe_Facteur - push eax - - ; On passe le d‚but en Y: - push edx - - ; On passe le d‚but en X: - push ebx - - call Block_VESA - - - add esp,20 ; 20 = 5 paramŠtres de type dword - pop ebx - - Pixel_Preview_Loupe_VESA_Fin: - - mov esp,ebp - pop ebp - - ret - -Pixel_Preview_Loupe_VESA endp - - - -Ligne_horizontale_XOR_VESA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word, Pos_Y:word, Largeur:word - - - mov edx,0A0000h - mov ax,Pos_Y - mul Largeur_ecran - add ax,Pos_X - adc dx,0 - - xchg dx,ax - call [VESA_Change_banque_lect_ecr] - - mov cx,Largeur - - LH_VESA_Boucle: - - not byte ptr[edx] - - inc dx - jnz LH_VESA_Pas_de_changement_de_banque - - inc al - call [VESA_Change_banque_lect_ecr] - - LH_VESA_Pas_de_changement_de_banque: - - dec cx - jnz LH_VESA_Boucle - - - mov esp,ebp - pop ebp - - ret - -Ligne_horizontale_XOR_VESA endp - - - - -Ligne_verticale_XOR_VESA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word, Pos_Y:word, Hauteur:word - - push ebx - - - mov bx,Largeur_ecran - mov edx,0A0000h - mov ax,Pos_Y - mul bx - add ax,Pos_X - adc dx,0 - - xchg dx,ax - call [VESA_Change_banque_lect_ecr] - - mov cx,Hauteur - - LV_VESA_Boucle: - - not byte ptr[edx] - - add dx,bx - jnc LV_VESA_Pas_de_changement_de_banque - - inc al - call [VESA_Change_banque_lect_ecr] - - LV_VESA_Pas_de_changement_de_banque: - - dec cx - jnz LV_VESA_Boucle - - - pop ebx - - mov esp,ebp - pop ebp - - ret - -Ligne_verticale_XOR_VESA endp - - - - - -; Afficher une partie de la brosse en couleur en MCGA - -Display_brush_Color_MCGA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Hauteur:word,Couleur_de_transparence:byte,Largeur_brosse:word - - push ebx - push esi - push edi - - - ; Calculer dans EDI les coordonn‚es (Pos_X,Pos_Y) … l'‚cran - mov edi,0A0000h - mov di,Pos_Y ; | - mov bx,di ; | - shl di,8 ; |- DI <- Pos_Y * 320 - shl bx,6 ; | - add di,bx ; | - add di,Pos_X - - ; Calculer dans ESI les coordonn‚es (Decalage_X,Decalage_Y) dans la brosse - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_brosse - mov bx,Decalage_Y - mov cx,Decalage_X - mul ebx - mov esi,Brosse - add eax,ecx - add esi,eax - - ; On place dans DX le nb de lignes … traiter - mov dx,Hauteur - - ; On place dans BH la couleur de transparence - mov bh,Couleur_de_transparence - - ; On place dans EAX la distance entre deux lignes … l'‚cran - mov eax,320 - sub ax,Largeur - - Display_brush_Color_MCGA_Pour_chaque_ligne: - - ; On place dans CX le nb de pixels … traiter sur la ligne - mov cx,Largeur - - Display_brush_Color_MCGA_Pour_chaque_pixel: - - ; On lit le contenu de la brosse - mov bl,[esi] - - ; Gestion de la transparence - cmp bl,bh - je Display_brush_Color_MCGA_Pas_de_copie - - ; On affiche le pixel de la brosse … l'‚cran - mov [edi],bl - - Display_brush_Color_MCGA_Pas_de_copie: - - ; On passe au pixel suivant - inc esi - inc edi - dec cx - jnz Display_brush_Color_MCGA_Pour_chaque_pixel - - ; On passe … la ligne suivante - mov cx,Largeur_brosse - add edi,eax - sub cx,Largeur - add esi,ecx - dec dx - jnz Display_brush_Color_MCGA_Pour_chaque_ligne - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Display_brush_Color_MCGA endp - - - - - -; Afficher une partie de la brosse en monochrome en MCGA - -Display_brush_Mono_MCGA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Hauteur:word,Couleur_de_transparence:byte,Couleur:byte,Largeur_brosse:word - - push ebx - push esi - push edi - - - ; Calculer dans EDI les coordonn‚es (Pos_X,Pos_Y) … l'‚cran - mov edi,0A0000h - mov di,Pos_Y ; | - mov bx,di ; | - shl di,8 ; |- DI <- Pos_Y * 320 - shl bx,6 ; | - add di,bx ; | - add di,Pos_X - - ; Calculer dans ESI les coordonn‚es (Decalage_X,Decalage_Y) dans la brosse - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_brosse - mov bx,Decalage_Y - mov cx,Decalage_X - mul ebx - mov esi,Brosse - add eax,ecx - add esi,eax - - ; On place dans DX le nb de lignes … traiter - mov dx,Hauteur - - ; On place dans BH la couleur de transparence - mov bh,Couleur_de_transparence - - ; On place dans BL la couleur de coloriage - mov bl,Couleur - - ; On place dans EAX la distance entre 2 lignes … l'‚cran - mov eax,320 - sub ax,Largeur - - Display_brush_Mono_MCGA_Pour_chaque_ligne: - - ; On place dans CX le nb de pixels … traiter sur la ligne - mov cx,Largeur - - Display_brush_Mono_MCGA_Pour_chaque_pixel: - - ; On v‚rifie que le contenu de la brosse ne soit pas transparent - cmp [esi],bh - je Display_brush_Mono_MCGA_Pas_de_copie - - ; On affiche le pixel de la brosse … l'‚cran - mov [edi],bl - - Display_brush_Mono_MCGA_Pas_de_copie: - - ; On passe au pixel suivant - inc esi - inc edi - dec cx - jnz Display_brush_Mono_MCGA_Pour_chaque_pixel - - ; On passe … la ligne suivante - mov cx,Largeur_brosse - add edi,eax - sub cx,Largeur - add esi,ecx - dec dx - jnz Display_brush_Mono_MCGA_Pour_chaque_ligne - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Display_brush_Mono_MCGA endp - - - - - -; Effacer la partie de la brosse affich‚e … l'‚cran en MCGA - -Clear_brush_MCGA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Hauteur:word,Couleur_de_transparence:byte,Largeur_image:word - - push ebx - push esi - push edi - - - ; Calculer dans EDI les coordonn‚es (Pos_X,Pos_Y) … l'‚cran - mov edi,0A0000h - mov ax,Pos_Y ; | - mov di,ax ; | - shl ax,6 ; |- DI <- Pos_Y * 320 - shl di,8 ; | - add di,ax ; | - add di,Pos_X - - ; Calculer dans ESI les coordonn‚es - ; (Pos_X+Principal_Decalage_X,Pos_Y+Principal_Decalage_Y) dans l'image - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Pos_Y - mov bx,Largeur_image - mov cx,Pos_X - add ax,Principal_Decalage_Y - add cx,Principal_Decalage_X - mul ebx - mov esi,Principal_Ecran - add eax,ecx - add esi,eax - - ; On place dans DX le nb de lignes … traiter - mov dx,Hauteur - - ; On met dans EBX la distance entre 2 lignes … l'‚cran - mov ebx,320 - sub bx,Largeur - - ; On met dans EAX la distance entre 2 lignes dans l'image - xor eax,eax - mov ax,Largeur_image - sub ax,Largeur - - ; On nettoie la partie haute de ECX: - xor ecx,ecx - - Clear_brush_MCGA_Pour_chaque_ligne: - - ; On place dans CX le nb de pixels … traiter sur la ligne - mov cx,Largeur - - ; On fait une copie de la ligne - shr cx,1 - jnc Clear_brush_MCGA_Multiple_de_2 - movsb - Clear_brush_MCGA_Multiple_de_2: - shr cx,1 - jnc Clear_brush_MCGA_Multiple_de_4 - movsw - Clear_brush_MCGA_Multiple_de_4: - rep movsd - - ; On passe … la ligne suivante - add esi,eax - add edi,ebx - dec dx - jnz Clear_brush_MCGA_Pour_chaque_ligne - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Clear_brush_MCGA endp - - - - - - -; Afficher une partie de la brosse en couleur en VESA - -Display_brush_Color_VESA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Hauteur:word,Couleur_de_transparence:byte,Largeur_brosse:word - - push ebx - push esi - push edi - - - ; Calculer dans ESI les coordonn‚es (Decalage_X,Decalage_Y) dans la brosse - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_brosse - mov bx,Decalage_Y - mov cx,Decalage_X - mul ebx - mov esi,Brosse - add eax,ecx - add esi,eax - - ; Calculer dans EDI les coordonn‚es (Pos_X,Pos_Y) … l'‚cran - mov edi,0A0000h - mov ax,Pos_Y - mul Largeur_ecran - add ax,Pos_X - adc dx,0 - mov di,ax - - ; On passe dans la banque n‚cessaire (et on la m‚morise dans AL) - mov al,dl - call [VESA_Change_banque_ecriture] - - ; On place dans AH la couleur de transparence - mov ah,Couleur_de_transparence - - ; On place dans BX la diff‚rence … l'‚cran entre 2 lignes: - mov bx,Largeur_ecran - sub bx,Largeur - - Display_brush_Color_VESA_Pour_chaque_ligne: - - ; On place dans CX le nb de pixels … traiter sur la ligne - mov cx,Largeur - - Display_brush_Color_VESA_Pour_chaque_pixel: - - ; On lit le contenu de la brosse - mov dl,[esi] - - ; Gestion de la transparence - cmp dl,ah - je Display_brush_Color_VESA_Pas_de_copie - - ; On affiche le pixel de la brosse … l'‚cran - mov [edi],dl - - Display_brush_Color_VESA_Pas_de_copie: - - ; On passe au pixel suivant - inc esi - inc di - - jz Display_brush_Color_VESA_Debordement_1 - - dec cx - jnz Display_brush_Color_VESA_Pour_chaque_pixel - jmp Display_brush_Color_VESA_Fin_de_ligne - - Display_brush_Color_VESA_Debordement_1: - - ; On passe dans la banque suivante - inc al - call [VESA_Change_banque_ecriture] - dec cx - jnz Display_brush_Color_VESA_Pour_chaque_pixel - - Display_brush_Color_VESA_Fin_de_ligne: - - ; On passe … la ligne suivante - mov cx,Largeur_brosse - sub cx,Largeur - add esi,ecx - add di,bx - - jc Display_brush_Color_VESA_Debordement_2 - - dec Hauteur - jnz Display_brush_Color_VESA_Pour_chaque_ligne - jmp Display_brush_Color_VESA_Fin_de_traitement - - Display_brush_Color_VESA_Debordement_2: - - ; On passe dans la banque suivante - inc al - call [VESA_Change_banque_ecriture] - dec Hauteur - jnz Display_brush_Color_VESA_Pour_chaque_ligne - - Display_brush_Color_VESA_Fin_de_traitement: - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Display_brush_Color_VESA endp - - - - - -; Afficher une partie de la brosse en monochrome en VESA - -Display_brush_Mono_VESA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Hauteur:word,Couleur_de_transparence:byte,Couleur:byte,Largeur_brosse:word - - push ebx - push esi - push edi - - - ; Calculer dans ESI les coordonn‚es (Decalage_X,Decalage_Y) dans la brosse - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_brosse - mov bx,Decalage_Y - mov cx,Decalage_X - mul ebx - mov esi,Brosse - add eax,ecx - add esi,eax - - ; Calculer dans EDI les coordonn‚es (Pos_X,Pos_Y) … l'‚cran - mov edi,0A0000h - mov ax,Pos_Y - mul Largeur_ecran - add ax,Pos_X - adc dx,0 - mov di,ax - - ; On passe dans la banque n‚cessaire (et on la m‚morise dans AL) - mov al,dl - call [VESA_Change_banque_ecriture] - - ; On place dans AH la couleur de transparence - mov ah,Couleur_de_transparence - - ; On place dans DL la couleur de coloriage - mov dl,Couleur - - ; On place dans BX la diff‚rence … l'‚cran entre 2 lignes: - mov bx,Largeur_ecran - sub bx,Largeur - - Display_brush_Mono_VESA_Pour_chaque_ligne: - - ; On place dans CX le nb de pixels … traiter sur la ligne - mov cx,word ptr[Largeur] - - Display_brush_Mono_VESA_Pour_chaque_pixel: - - ; On v‚rifie que le contenu de la brosse ne soit pas la couleur de - ; transparence - cmp [esi],ah - je Display_brush_Mono_VESA_Pas_de_copie - - ; On affiche un pixel de la couleur … l'‚cran - mov [edi],dl - - Display_brush_Mono_VESA_Pas_de_copie: - - ; On passe au pixel suivant - inc esi - inc di - - jz Display_brush_Mono_VESA_Debordement_1 - - dec cx - jnz Display_brush_Mono_VESA_Pour_chaque_pixel - jmp Display_brush_Mono_VESA_Fin_de_ligne - - Display_brush_Mono_VESA_Debordement_1: - - ; On passe dans la banque suivante - inc al - call [VESA_Change_banque_ecriture] - dec cx - jnz Display_brush_Mono_VESA_Pour_chaque_pixel - - Display_brush_Mono_VESA_Fin_de_ligne: - - ; On passe … la ligne suivante - mov cx,Largeur_brosse - sub cx,Largeur - add esi,ecx - add di,bx - - jc Display_brush_Mono_VESA_Debordement_2 - - dec Hauteur - jnz Display_brush_Mono_VESA_Pour_chaque_ligne - jmp Display_brush_Mono_VESA_Fin_de_traitement - - Display_brush_Mono_VESA_Debordement_2: - - ; On passe dans la banque suivante - inc al - call [VESA_Change_banque_ecriture] - dec Hauteur - jnz Display_brush_Mono_VESA_Pour_chaque_ligne - - Display_brush_Mono_VESA_Fin_de_traitement: - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Display_brush_Mono_VESA endp - - - - - - -; Effacer la partie de la brosse affich‚e … l'‚cran en VESA - -Clear_brush_VESA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Hauteur:word,Couleur_de_transparence:byte,Largeur_image:word - - push ebx - push esi - push edi - - - ; Calculer dans ESI les coordonn‚es - ; (Pos_X+Principal_Decalage_X,Pos_Y+Principal_Decalage_Y) dans l'image - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Pos_Y - mov bx,Largeur_image - mov cx,Pos_X - add ax,Principal_Decalage_Y - add cx,Principal_Decalage_X - mul ebx - mov esi,Principal_Ecran - add eax,ecx - add esi,eax - - ; Calculer dans EDI les coordonn‚es (Pos_X,Pos_Y) … l'‚cran - mov edi,0A0000h - mov ax,Pos_Y - mul Largeur_ecran - add ax,Pos_X - adc dx,0 - mov di,ax - - ; On passe dans la banque n‚cessaire (et on la m‚morise dans AL) - mov al,dl - call [VESA_Change_banque_ecriture] - - ; On place dans DX la diff‚rence entre 2 lignes … l'‚cran - mov dx,Largeur_ecran - sub dx,Largeur - - ; On place dans EBX la diff‚rence entre 2 lignes dans l'image - mov bx,Largeur_image - sub bx,Largeur - - Clear_brush_VESA_Pour_chaque_ligne: - - ; On place dans CX le nb de pixels … traiter sur la ligne - mov cx,Largeur - - Clear_brush_VESA_Pour_chaque_pixel: - - ; On recopie le pixel de l'image … l'‚cran - mov ah,[esi] - inc esi - mov [edi],ah - inc di - - jz Clear_brush_VESA_Debordement_1 - - dec cx - jnz Clear_brush_VESA_Pour_chaque_pixel - jmp Clear_brush_VESA_Fin_de_ligne - - Clear_brush_VESA_Debordement_1: - - ; On passe dans la banque suivante - inc al - call [VESA_Change_banque_ecriture] - -; ; On r‚ajuste EDI qui vient de sortir du segment vid‚o -; mov edi,0A0000h - - dec cx - jnz Clear_brush_VESA_Pour_chaque_pixel - - Clear_brush_VESA_Fin_de_ligne: - - ; On passe … la ligne suivante - add esi,ebx - add di,dx - - jc Clear_brush_VESA_Debordement_2 - - dec Hauteur - jnz Clear_brush_VESA_Pour_chaque_ligne - jmp Clear_brush_VESA_Fin_de_traitement - - Clear_brush_VESA_Debordement_2: - - ; On passe dans la banque suivante - inc al - call [VESA_Change_banque_ecriture] - dec Hauteur - jnz Clear_brush_VESA_Pour_chaque_ligne - - Clear_brush_VESA_Fin_de_traitement: - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Clear_brush_VESA endp - - - - - - -; Afficher une partie de la brosse en couleur en mode X - -Display_brush_Color_mode_X proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Hauteur:word,Couleur_de_transparence:byte,Largeur_brosse:dword - - push ebx - push esi - push edi - - ; On nettoye la partie haute de Largeur_brosse - and Largeur_brosse,0FFFFh - - ; Calculer dans ESI les coordonn‚es (Decalage_X,Decalage_Y) dans la brosse - xor ebx,ebx - xor ecx,ecx - mov eax,Largeur_brosse - mov bx,Decalage_Y - mov cx,Decalage_X - mul ebx - mov esi,Brosse - add eax,ecx - add esi,eax - - ; Calculer dans EDI les coordonn‚es (Pos_X,Pos_Y) … l'‚cran et dans AX - ; le plan (AH = 1, 2, 4 ou 8) et le nø de registre de chgnt de plan - mov edi,0A0000h - mov ax,MODE_X_Largeur_de_ligne - mov cx,Pos_X - mul Pos_Y - mov dx,cx - shr dx,2 - add ax,dx - mov di,ax - - mov ax,0102h - and cx,03h - shl ah,cl - - ; On passe dans le plan de d‚part - ; - ; Pour passer dans le plan N (0-3) en ‚criture: - ; out 3C4h,02h - ; out 3C5h,1 shl N - ; - mov dx,3C4h - out dx,ax - - ; On sauve la valeur initiale de EDI - mov MODE_X_Valeur_initiale_de_edi,edi - - ; On sauve la valeur initiale de ESI - mov MODE_X_Valeur_initiale_de_esi,esi - - ; On place dans BH la couleur de transparence - mov bh,Couleur_de_transparence - - Display_brush_Color_mode_X_Pour_chaque_colonne: - - ; On place dans CX le nb de pixels … traiter sur la colonne - mov cx,Hauteur - - ; On place dans DX la distance entre 2 lignes … l'‚cran - mov dx,MODE_X_Largeur_de_ligne - - Display_brush_Color_mode_X_Pour_chaque_ligne: - - ; On lit le contenu de la brosse - mov bl,[esi] - - ; Gestion de la transparence - cmp bl,bh - je Display_brush_Color_mode_X_Pas_de_copie - - ; On affiche le pixel de la brosse … l'‚cran - mov [edi],bl - - Display_brush_Color_mode_X_Pas_de_copie: - - ; On passe … la ligne suivante - add esi,Largeur_brosse - add di,dx - dec cx - jnz Display_brush_Color_mode_X_Pour_chaque_ligne - - ; On passe … la colonne suivante - inc MODE_X_Valeur_initiale_de_esi - mov esi,MODE_X_Valeur_initiale_de_esi - - add ah,ah - cmp ah,10h - jne Display_brush_Color_mode_X_Pas_de_reset_de_plan - - inc MODE_X_Valeur_initiale_de_edi - mov ah,01h - - Display_brush_Color_mode_X_Pas_de_reset_de_plan: - - mov edi,MODE_X_Valeur_initiale_de_edi - - ; On passe dans le nouveau plan - ; - ; Pour passer dans le plan N (0-3) en ‚criture: - ; out 3C4h,02h - ; out 3C5h,1 shl N - ; - mov dx,3C4h - out dx,ax - - dec Largeur - jnz Display_brush_Color_mode_X_Pour_chaque_colonne - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Display_brush_Color_mode_X endp - - - - - - -; Afficher une partie de la brosse en monochrome en mode X - -Display_brush_Mono_mode_X proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Hauteur:word,Couleur_de_transparence:byte,Couleur:byte,Largeur_brosse:dword - - push ebx - push esi - push edi - - - ; On nettoye la partie haute de Largeur_brosse - and Largeur_brosse,0FFFFh - - ; Calculer dans ESI les coordonn‚es (Decalage_X,Decalage_Y) dans la brosse - xor ebx,ebx - xor ecx,ecx - mov eax,Largeur_brosse - mov bx,Decalage_Y - mov cx,Decalage_X - mul ebx - mov esi,Brosse - add eax,ecx - add esi,eax - - ; Calculer dans EDI les coordonn‚es (Pos_X,Pos_Y) … l'‚cran et dans AX - ; le plan (AH = 1, 2, 4 ou 8) et le nø de registre de chgnt de plan - mov edi,0A0000h - mov ax,MODE_X_Largeur_de_ligne - mov cx,Pos_X - mul Pos_Y - mov dx,cx - shr dx,2 - add ax,dx - mov di,ax - - mov ax,0102h - and cx,03h - shl ah,cl - - ; On passe dans le plan de d‚part - ; - ; Pour passer dans le plan N (0-3) en ‚criture: - ; out 3C4h,02h - ; out 3C5h,1 shl N - ; - mov dx,3C4h - out dx,ax - - ; On sauve la valeur initiale de EDI - mov MODE_X_Valeur_initiale_de_edi,edi - - ; On sauve la valeur initiale de ESI - mov MODE_X_Valeur_initiale_de_esi,esi - - ; On place dans BH la couleur de transparence - mov bh,Couleur_de_transparence - - ; On place dans BL la couleur de coloriage - mov bl,Couleur - - Display_brush_Mono_mode_X_Pour_chaque_colonne: - - ; On place dans CX le nb de pixels … traiter sur la colonne - mov cx,Hauteur - - ; On place dans DX la distance entre 2 lignes … l'‚cran - mov dx,MODE_X_Largeur_de_ligne - - Display_brush_Mono_mode_X_Pour_chaque_ligne: - - ; On v‚rifie que le contenu de la brosse ne soit pas transparent - cmp [esi],bh - je Display_brush_Mono_mode_X_Pas_de_copie - - ; On affiche le pixel de la brosse … l'‚cran - mov [edi],bl - - Display_brush_Mono_mode_X_Pas_de_copie: - - ; On passe … la ligne suivante - add esi,Largeur_brosse - add di,dx - dec cx - jnz Display_brush_Mono_mode_X_Pour_chaque_ligne - - ; On passe … la colonne suivante - inc MODE_X_Valeur_initiale_de_esi - mov esi,MODE_X_Valeur_initiale_de_esi - - add ah,ah - cmp ah,10h - jne Display_brush_Mono_mode_X_Pas_de_reset_de_plan - - inc MODE_X_Valeur_initiale_de_edi - mov ah,01h - - Display_brush_Mono_mode_X_Pas_de_reset_de_plan: - - mov edi,MODE_X_Valeur_initiale_de_edi - - ; On passe dans le nouveau plan - ; - ; Pour passer dans le plan N (0-3) en ‚criture: - ; out 3C4h,02h - ; out 3C5h,1 shl N - ; - mov dx,3C4h - out dx,ax - - dec Largeur - jnz Display_brush_Mono_mode_X_Pour_chaque_colonne - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Display_brush_Mono_mode_X endp - - - - - - -; Effacer la partie visible de la brosse en mode X - -Clear_brush_mode_X proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Hauteur:word,Couleur_de_transparence:byte,Largeur_image:dword - - push ebx - push esi - push edi - - - ; On nettoye la partie haute de Largeur_image - and Largeur_image,0FFFFh - - ; Calculer dans ESI les coordonn‚es - ; (Pos_X+Principal_Decalage_X,Pos_Y+Principal_Decalage_Y) dans l'image - xor eax,eax - xor ecx,ecx - mov ax,Pos_Y - mov ebx,Largeur_image - mov cx,Pos_X - add ax,Principal_Decalage_Y - add cx,Principal_Decalage_X - mul ebx - mov esi,Principal_Ecran - add eax,ecx - add esi,eax - - ; On sauve la valeur initiale de ESI - mov MODE_X_Valeur_initiale_de_esi,esi - - ; Calculer dans EDI les coordonn‚es (Pos_X,Pos_Y) … l'‚cran et dans AX - ; le plan (AH = 1, 2, 4 ou 8) et le nø de registre de chgnt de plan - mov edi,0A0000h - mov ax,MODE_X_Largeur_de_ligne - mov cx,Pos_X - mul Pos_Y - mov dx,cx - shr dx,2 - add ax,dx - mov di,ax - - mov ax,0102h - and cx,03h - shl ah,cl - - ; On passe dans le plan de d‚part - ; - ; Pour passer dans le plan N (0-3) en ‚criture: - ; out 3C4h,02h - ; out 3C5h,1 shl N - ; - mov dx,3C4h - out dx,ax - - ; On sauve la valeur initiale de EDI - mov MODE_X_Valeur_initiale_de_edi,edi - - Clear_brush_mode_X_Pour_chaque_colonne: - - ; On place dans CX le nb de pixels … traiter sur la colonne - mov cx,Hauteur - - ; On place dans DX la distance entre 2 lignes … l'‚cran - mov dx,MODE_X_Largeur_de_ligne - - Clear_brush_mode_X_Pour_chaque_ligne: - - ; On copie le pixel de l'image vers l'‚cran en passant … la ligne - ; suivante - mov bl,[esi] - add esi,Largeur_image - mov [edi],bl - add di,dx - - dec cx - jnz Clear_brush_mode_X_Pour_chaque_ligne - - ; On passe … la colonne suivante - inc MODE_X_Valeur_initiale_de_esi - mov esi,MODE_X_Valeur_initiale_de_esi - - add ah,ah - cmp ah,10h - jne Clear_brush_mode_X_Pas_de_reset_de_plan - - inc MODE_X_Valeur_initiale_de_edi - mov ah,01h - - Clear_brush_mode_X_Pas_de_reset_de_plan: - - mov edi,MODE_X_Valeur_initiale_de_edi - - ; On passe dans le nouveau plan - ; - ; Pour passer dans le plan N (0-3) en ‚criture: - ; out 3C4h,02h - ; out 3C5h,1 shl N - ; - mov dx,3C4h - out dx,ax - - dec Largeur - jnz Clear_brush_mode_X_Pour_chaque_colonne - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Clear_brush_mode_X endp - - - - - - - -; Remapper une partie de l'‚cran en MCGA - -Remap_screen_MCGA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Hauteur:word,Conversion:dword - - push ebx - push esi - push edi - - - ; Calculer dans EDI les coordonn‚es (Pos_X,Pos_Y) … l'‚cran - - mov edi,0A0000h - mov di,Pos_Y ; | - mov bx,di ; | - shl di,8 ; |_ DI <- (Pos_Y*320) + Pos_X - shl bx,6 ; | - add di,bx ; | - add di,Pos_X ; | - - ; On place dans DX le nb de lignes … traiter - - mov dx,Hauteur - - ; On place dans EBX l'adresse de la table de conversion - - mov ebx,Conversion - - ; On nettoie (entre autres) la partie haute de EAX - - xor eax,eax - - ; On met dans ESI la distance entre la fin d'une ligne et le d‚but de la - ; suivante - - mov esi,320 - sub si,Largeur - - Remap_screen_MCGA_Pour_chaque_ligne: - - ; On place dans CX le nb de pixels … traiter sur la ligne - - mov cx,Largeur - - Remap_screen_MCGA_Pour_chaque_pixel: - - mov al,[edi] - mov al,[ebx+eax] - mov [edi],al - - ; On passe au pixel suivant - inc edi - dec cx - jnz Remap_screen_MCGA_Pour_chaque_pixel - - ; On passe … la ligne suivante - add edi,esi - - dec dx - jnz Remap_screen_MCGA_Pour_chaque_ligne - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Remap_screen_MCGA endp - - - - - - - -; Remapper une partie de l'‚cran en mode X - -Remap_screen_mode_X proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Hauteur:word,Conversion:dword - - push ebx - push esi - push edi - - - ; On met dans CL le plan initial - - mov bx,Pos_X - mov cl,bl - and cl,00000011b - - ; On met dans ESI la valeur initiale de EDI - ; (ESI=D‚but de ligne, EDI=Position dans la ligne) - - mov esi,0A0000h - mov ax,Pos_Y - mul MODE_X_Largeur_de_ligne - shr bx,2 - add ax,bx - mov si,ax - - ; On met dans BX la coordonn‚e de fin +1 (horizontalement) - - mov bx,Pos_X - add bx,Largeur - - Remap_screen_mode_X_Pour_chaque_ligne: - - ; On place dans CH le nb de plans … traiter - - mov ch,4 - - Remap_screen_mode_X_Pour_chaque_plan: - - ; On initialise EDI - - mov edi,esi - - ; On passe dans le plan d‚tenu par CL - - ; Plan d'‚criture: - - mov dx,3C4h ; DX = Port du CRTC (chngt de plan) - mov ax,102h - shl ah,cl - out dx,ax - - ; Plan de lecture: - - mov dx,3CEh ; DX = Port du TS (enfin, je crois) - mov ah,cl - mov al,04h - out dx,ax - - ; On met dans AX la coordonn‚e de d‚part - - mov ax,Pos_X - - Remap_screen_mode_X_Boucle: - - cmp ax,bx - jae Remap_screen_mode_X_Fin_de_traitement - - ; On convertit le pixel courant - xor edx,edx - mov dl,[edi] - add edx,Conversion - mov dl,[edx] - mov [edi],dl - - inc edi ; On passe … la coordonn‚e +4 - add ax,4 - - jmp Remap_screen_mode_X_Boucle - - Remap_screen_mode_X_Fin_de_traitement: - - ; On pr‚pare CL pour le prochain plan: - - inc cl - and cl,00000011b - jnz Remap_screen_mode_X_On_repasse_pas_dans_le_plan_0 - - ; On pr‚pare ESI pour le prochain plan: - - inc esi - - Remap_screen_mode_X_On_repasse_pas_dans_le_plan_0: - - ; On pr‚pare la coordonn‚e de d‚part pour le prochain plan: - - inc Pos_X - - ; On regarde s'il reste un plan … traiter: - - dec ch - jnz Remap_screen_mode_X_Pour_chaque_plan - - ; On passe … la ligne suivante - dec si ; ESI a forc‚ment ripp‚ sur la droite, on le corrige - add si,MODE_X_Largeur_de_ligne ; et on passe … la suivante - sub Pos_X,4 ; On fait de mˆme avec Pos_X - - dec Hauteur - jnz Remap_screen_mode_X_Pour_chaque_ligne - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Remap_screen_mode_X endp - - - - - - - - - -; Remapper une partie de l'‚cran en VESA - -Remap_screen_VESA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Hauteur:word,Conversion:dword - - push ebx - push esi - push edi - - - ; Calculer dans EDI les coordonn‚es (Pos_X,Pos_Y) … l'‚cran - - mov edi,0A0000h - mov ax,Pos_Y - mul Largeur_ecran - add ax,Pos_X - adc dx,0 - mov di,ax - - ; On passe dans la banque n‚cessaire (et on la m‚morise dans AL) - - mov al,dl - call [VESA_Change_banque_lect_ecr] - - ; On place dans EBX l'adresse de la table de conversion - - mov ebx,Conversion - - ; On nettoie la partie haute de EDX - - xor edx,edx - - ; On met dans SI la distance entre la fin d'une ligne et le d‚but de la - ; suivante - - mov si,Largeur_ecran - sub si,Largeur - - Remap_screen_VESA_Pour_chaque_ligne: - - ; On place dans CX le nb de pixels … traiter sur la ligne - - mov cx,Largeur - - Remap_screen_VESA_Pour_chaque_pixel: - - mov dl,[edi] - mov dl,[edx+ebx] - mov [edi],dl - - ; On passe au pixel suivant - - inc di - jz Remap_screen_VESA_Debordement_1 - - dec cx - jnz Remap_screen_VESA_Pour_chaque_pixel - jmp Remap_screen_VESA_Fin_de_ligne - - Remap_screen_VESA_Debordement_1: - - ; On passe dans la banque suivante - - inc al - call [VESA_Change_banque_lect_ecr] - - dec cx - jnz Remap_screen_VESA_Pour_chaque_pixel - - Remap_screen_VESA_Fin_de_ligne: - - ; On passe … la ligne suivante - - add di,si - jc Remap_screen_VESA_Debordement_2 - - dec Hauteur - jnz Remap_screen_VESA_Pour_chaque_ligne - jmp Remap_screen_VESA_Fin_de_traitement - - Remap_screen_VESA_Debordement_2: - - ; On passe dans la banque suivante - - inc al - call [VESA_Change_banque_lect_ecr] - - dec Hauteur - jnz Remap_screen_VESA_Pour_chaque_ligne - - Remap_screen_VESA_Fin_de_traitement: - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Remap_screen_VESA endp - - - - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -; Afficher une partie de l'image tel quel sur l'‚cran - -Afficher_partie_de_l_ecran_MCGA proc near - - push ebp - mov ebp,esp - - arg Largeur:word,Hauteur:word,Largeur_image:word - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=Principal_Ecran+((Principal_Decalage_Y*Largeur_image)+Principal_Decalage_X) - - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_image - mov bx,Principal_Decalage_Y - mov cx,Principal_Decalage_X - mul ebx - mov esi,Principal_Ecran - add eax,ecx - add esi,eax - - ; On calcule la valeur initiale de EDI: - ; - ; Valeur initiale=0A0000h - - mov edi,0A0000h - - ; On met dans EAX la distance qu'il y a entre le dernier pixel affich‚ - ; d'une ligne et le premier pixel affich‚ de la ligne suivante DANS L'IMAGE - ; - ; EAX = Largeur_image-Largeur - - xor eax,eax - mov ax,Largeur_image - sub ax,Largeur - - ; On met dans EBX la distance qu'il y a entre le dernier pixel affich‚ - ; d'une ligne et le premier pixel affich‚ de la ligne suivante DANS L'ECRAN - ; - ; EBX = 320 - Largeur - mov ebx,320 - sub bx,Largeur - - ; On met dans DX le nombre de lignes … traiter: - mov dx,Hauteur - - ; On nettoye la partie haute de ECX: (OPTIM.: VIRABLE CAR FAIT PLUS HAUT) - xor ecx,ecx - - APDLE_MCGA_Pour_chaque_ligne: - - ; On met dans ECX le nombre de pixels … traiter: - - mov cx,Largeur - - ; On les traite au mieux par copie 8/16/32 bits - shr cx,1 - jnc APDLE_MCGA_ECX_multiple_de_2 - movsb - APDLE_MCGA_ECX_multiple_de_2: - shr cx,1 - jnc APDLE_MCGA_ECX_multiple_de_4 - movsw - APDLE_MCGA_ECX_multiple_de_4: - rep movsd - - ; On passe … la ligne suivante - ; sans oublier d'incr‚menter correctement ESI et EDI - add esi,eax - add edi,ebx - - dec dx - jnz APDLE_MCGA_Pour_chaque_ligne - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Afficher_partie_de_l_ecran_MCGA endp - - - - -; Afficher une ligne … l'‚cran - -Afficher_une_ligne_a_l_ecran_MCGA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Ligne:dword - - push esi - push edi - - - ; On met dans ESI l'adresse de la ligne … copier: - mov esi,Ligne - - ; On calcule la valeur initiale de EDI: - ; - ; Valeur initiale=0A0000h+((Pos_Y*320)+Pos_X) - mov ax,320 - mov edi,0A0000h - mul Pos_Y - add ax,Pos_X - mov di,ax - - ; On met dans ECX le nombre de pixels … traiter: - xor ecx,ecx - mov cx,Largeur - - ; On les traite au mieux par copie 8/16/32 bits - shr cx,1 - jnc AULALE_MCGA_ECX_multiple_de_2 - movsb - AULALE_MCGA_ECX_multiple_de_2: - shr cx,1 - jnc AULALE_MCGA_ECX_multiple_de_4 - movsw - AULALE_MCGA_ECX_multiple_de_4: - rep movsd - - - pop edi - pop esi - - mov esp,ebp - pop ebp - - ret - -Afficher_une_ligne_a_l_ecran_MCGA endp - - - - - -; Lire une ligne … l'‚cran et la stocker dans un buffer - -Lire_une_ligne_a_l_ecran_MCGA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Ligne:dword - - push esi - push edi - - - ; On met dans EDI l'adresse de la ligne … lire: - - mov edi,Ligne - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=0A0000h+((Pos_Y*320)+Pos_X) - - mov ax,320 - mov esi,0A0000h - mul Pos_Y - add ax,Pos_X - mov si,ax - - ; On met dans ECX le nombre de pixels … traiter: - - xor ecx,ecx - mov cx,Largeur - - ; On les traite au mieux par copie 8/16/32 bits - shr cx,1 - jnc LULALE_MCGA_ECX_multiple_de_2 - movsb - LULALE_MCGA_ECX_multiple_de_2: - shr cx,1 - jnc LULALE_MCGA_ECX_multiple_de_4 - movsw - LULALE_MCGA_ECX_multiple_de_4: - rep movsd - - - pop edi - pop esi - - mov esp,ebp - pop ebp - - ret - -Lire_une_ligne_a_l_ecran_MCGA endp - - - - - - -; Afficher une partie de l'image zoom‚e … l'‚cran - -Afficher_partie_de_l_ecran_zoomee_MCGA proc near - - push ebp - mov ebp,esp - - arg Largeur:word,Hauteur:word,Largeur_image:word,Buffer:dword - - ; Largeur = Largeur non zoom‚e - ; Hauteur = Hauteur zoom‚e - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=Principal_Ecran+((Loupe_Decalage_Y*Largeur_image)+Loupe_Decalage_X) - - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_image - mov bx,Loupe_Decalage_Y - mov cx,Loupe_Decalage_X - mul ebx - mov esi,Principal_Ecran - add eax,ecx - add esi,eax - - ; On met dans DI la valeur Largeur*Facteur - mov ax,Largeur - mul Loupe_Facteur - mov di,ax - - ; On met dans EDX la ligne en cours de traitement: - xor edx,edx - - ; On met dans EBX la distance entre deux lignes d'image - xor ebx,ebx - mov bx,Largeur_image - - APDLEZ_MCGA_Pour_chaque_ligne_a_zoomer: - - ; On eclate la ligne … zoomer: - push dx - mov ax,Loupe_Facteur - mov cx,Largeur - push ecx ; Largeur - push eax ; Facteur - push Buffer ; Ligne zoom‚e - push esi ; Ligne originale - call Zoomer_une_ligne - add esp,16 - pop dx - - ; On l'affiche Facteur fois … l'‚cran (sur des lignes cons‚cutives): - mov cx,Loupe_Facteur - - APDLEZ_MCGA_Pour_chaque_ligne: - - ; On affiche la ligne zoom‚e - push cx - push dx - push Buffer ; Ligne - push edi ; Largeur*Facteur - push edx ; Pos_Y - mov ax,Principal_X_Zoom - push eax ; Pos_X - call Afficher_une_ligne_a_l_ecran_MCGA - add esp,16 - pop dx - pop cx - - ; On passe … la ligne suivante - inc dx ; -> On v‚rifie qu'on ne soit - cmp dx,Hauteur ; pas arriv‚ … la ligne - je APDLEZ_MCGA_Menu_Ordonnee_atteinte ; terminale - dec cx ; -> ou que l'on ai termin‚ de - jnz APDLEZ_MCGA_Pour_chaque_ligne ; traiter la ligne … zoomer - - ; On passe … la ligne … zoomer suivante: - ; sans oublier de passer … la ligne image suivante - add esi,ebx - jmp APDLEZ_MCGA_Pour_chaque_ligne_a_zoomer - - APDLEZ_MCGA_Menu_Ordonnee_atteinte: - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Afficher_partie_de_l_ecran_zoomee_MCGA endp - - - - - - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - - - - - - -; Afficher une partie de l'image tel quel sur l'‚cran - -Afficher_partie_de_l_ecran_VESA proc near - - push ebp - mov ebp,esp - - arg Largeur:word,Hauteur:word,Largeur_image:word - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=Principal_Ecran+((Principal_Decalage_Y*Largeur_image)+Principal_Decalage_X) - - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_image - mov bx,Principal_Decalage_Y - mov cx,Principal_Decalage_X - mul ebx - mov esi,Principal_Ecran - add eax,ecx - add esi,eax - - ; On calcule la valeur initiale de EDI: - ; - ; Valeur initiale=0A0000h - - mov edi,0A0000h - ; Et on passe dans la banque correspondante - xor al,al - call [VESA_Change_banque_ecriture] - - ; On met dans EBX la distance qu'il y a entre le dernier pixel affich‚ - ; d'une ligne et le premier pixel affich‚ de la ligne suivante DANS L'IMAGE - ; - ; EBX = Largeur_image-Largeur - - mov bx,Largeur_image - sub bx,Largeur - - ; On met dans DX le nombre de lignes … traiter: - - mov dx,Hauteur - - ; On nettoye la partie haute de ECX: (OPTIM.: VIRABLE CAR FAIT PLUS HAUT) - - xor ecx,ecx - - APDLE_VESA_Pour_chaque_ligne: - - ; On met dans ECX le nombre de pixels … traiter: - - mov cx,Largeur - - ; On regarde si la ligne loge totalement dans la banque en cours - add cx,di - jc APDLE_VESA_Debordement_de_ligne - - ; Si c'est le cas: - mov cx,Largeur ; correction de CX … cause du test - - ; On effectue une copie 8/16/32 bits - shr cx,1 - jnc APDLE_VESA_Nobreak_ECX_multiple_de_2 - movsb - APDLE_VESA_Nobreak_ECX_multiple_de_2: - shr cx,1 - jnc APDLE_VESA_Nobreak_ECX_multiple_de_4 - movsw - APDLE_VESA_Nobreak_ECX_multiple_de_4: - rep movsd - - jmp APDLE_VESA_Fin_traitement_ligne - - - ; Si ce n'est pas le cas (d‚bordement de la ligne) - APDLE_VESA_Debordement_de_ligne: - - ; A ce stade, on sait que la ligne ne loge pas entiŠrement sur l'‚cran - - ; On m‚morise dans la pile ce qu'il restera … afficher … la droite de la - ; rupture: - push cx - - ; On met dans CX le nb de pixels affichables avant la rupture: - mov cx,di - neg cx - - ; On effectue une copie 8/16/32 bits de la partie gauche de la rupture: - shr cx,1 - jnc APDLE_VESA_BreakLeft_ECX_multiple_de_2 - movsb - APDLE_VESA_BreakLeft_ECX_multiple_de_2: - shr cx,1 - jnc APDLE_VESA_BreakLeft_ECX_multiple_de_4 - movsw - APDLE_VESA_BreakLeft_ECX_multiple_de_4: - rep movsd - - ; On change de banque: - inc al - call [VESA_Change_banque_ecriture] - - ; On replace EDI en d‚but de banque - mov edi,0A0000h - - ; On restaure le nb de pixels … afficher … droite de la rupture - pop cx - - ; On effectue une copie 8/16/32 bits de la partie droite de la rupture: - shr cx,1 - jnc APDLE_VESA_BreakRight_ECX_multiple_de_2 - movsb - APDLE_VESA_BreakRight_ECX_multiple_de_2: - shr cx,1 - jnc APDLE_VESA_BreakRight_ECX_multiple_de_4 - movsw - APDLE_VESA_BreakRight_ECX_multiple_de_4: - rep movsd - - - APDLE_VESA_Fin_traitement_ligne: - ; Le traitement de la ligne est termin‚, on change de ligne: - - ; On passe … la ligne suivante en incr‚mentant correctement ESI et (E)DI: - mov cx,Largeur_ecran - add esi,ebx - sub cx,Largeur - add di,cx - jnc APDLE_VESA_Fin_traitement_ligne_Sans_cht_bnk - - ; Cas o— le changement de ligne entraŒne un changement de banque: - inc al - call [VESA_Change_banque_ecriture] - - APDLE_VESA_Fin_traitement_ligne_Sans_cht_bnk: - ; On a fait le changement de ligne, on peut voir s'il reste des lignes … - ; traiter: - - dec dx - jnz APDLE_VESA_Pour_chaque_ligne - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Afficher_partie_de_l_ecran_VESA endp - - - - -; Afficher une ligne … l'‚cran - -Afficher_une_ligne_a_l_ecran_VESA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Ligne:dword - - push esi - push edi - - - ; On met dans ESI l'adresse de la ligne … copier: - - mov esi,Ligne - - ; On calcule la valeur initiale de EDI: - ; - ; Valeur initiale=0A0000h+((Pos_Y*Largeur_ecran)+Pos_X) - - mov ax,Largeur_ecran - mov edi,0A0000h - mul Pos_Y - add ax,Pos_X - adc dx,0 - mov di,ax - ; Et on passe dans la banque correspondante - mov al,dl - call [VESA_Change_banque_ecriture] - - ; On met dans ECX le nombre de pixels … traiter: - xor ecx,ecx - mov cx,Largeur - - ; On regarde si la ligne loge totalement dans la banque en cours - add cx,di - jc AULALE_VESA_Debordement_de_ligne - - ; Si c'est le cas: - mov cx,Largeur ; correction de CX … cause du test - - ; On effectue une copie 8/16/32 bits - shr cx,1 - jnc AULALE_VESA_Nobreak_ECX_multiple_de_2 - movsb - AULALE_VESA_Nobreak_ECX_multiple_de_2: - shr cx,1 - jnc AULALE_VESA_Nobreak_ECX_multiple_de_4 - movsw - AULALE_VESA_Nobreak_ECX_multiple_de_4: - rep movsd - - jmp AULALE_VESA_Fin_traitement_ligne - - - ; Si ce n'est pas le cas (d‚bordement de la ligne) - AULALE_VESA_Debordement_de_ligne: - - ; A ce stade, on sait que la ligne ne loge pas entiŠrement sur l'‚cran - - ; On m‚morise dans la pile ce qu'il restera … afficher … la droite de la - ; rupture: - push cx - - ; On met dans CX le nb de pixels affichables avant la rupture: - mov cx,di - neg cx - - ; On effectue une copie 8/16/32 bits de la partie gauche de la rupture: - shr cx,1 - jnc AULALE_VESA_BreakLeft_ECX_multiple_de_2 - movsb - AULALE_VESA_BreakLeft_ECX_multiple_de_2: - shr cx,1 - jnc AULALE_VESA_BreakLeft_ECX_multiple_de_4 - movsw - AULALE_VESA_BreakLeft_ECX_multiple_de_4: - rep movsd - - ; On change de banque: - inc al - call [VESA_Change_banque_ecriture] - - ; On replace EDI en d‚but de banque - mov edi,0A0000h - - ; On restaure le nb de pixels … afficher … droite de la rupture - pop cx - - ; On effectue une copie 8/16/32 bits de la partie droite de la rupture: - shr cx,1 - jnc AULALE_VESA_BreakRight_ECX_multiple_de_2 - movsb - AULALE_VESA_BreakRight_ECX_multiple_de_2: - shr cx,1 - jnc AULALE_VESA_BreakRight_ECX_multiple_de_4 - movsw - AULALE_VESA_BreakRight_ECX_multiple_de_4: - rep movsd - - - AULALE_VESA_Fin_traitement_ligne: - - - pop edi - pop esi - - mov esp,ebp - pop ebp - - ret - -Afficher_une_ligne_a_l_ecran_VESA endp - - - - - -; Lire une ligne … l'‚cran et la stocker dans un buffer - -Lire_une_ligne_a_l_ecran_VESA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Ligne:dword - - push esi - push edi - - - ; On met dans EDI l'adresse de la ligne … lire: - - mov edi,Ligne - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=0A0000h+((Pos_Y*Largeur_ecran)+Pos_X) - - mov ax,Largeur_ecran - mov esi,0A0000h - mul Pos_Y - add ax,Pos_X - adc dx,0 - mov si,ax - ; Et on passe dans la banque correspondante - mov al,dl - call [VESA_Change_banque_ecriture] - - ; On met dans ECX le nombre de pixels … traiter: - xor ecx,ecx - mov cx,Largeur - - ; On regarde si la ligne loge totalement dans la banque en cours - add cx,si - jc LULALE_VESA_Debordement_de_ligne - - ; Si c'est le cas: - mov cx,Largeur ; correction de CX … cause du test - - ; On effectue une copie 8/16/32 bits - shr cx,1 - jnc LULALE_VESA_Nobreak_ECX_multiple_de_2 - movsb - LULALE_VESA_Nobreak_ECX_multiple_de_2: - shr cx,1 - jnc LULALE_VESA_Nobreak_ECX_multiple_de_4 - movsw - LULALE_VESA_Nobreak_ECX_multiple_de_4: - rep movsd - - jmp LULALE_VESA_Fin_traitement_ligne - - - ; Si ce n'est pas le cas (d‚bordement de la ligne) - LULALE_VESA_Debordement_de_ligne: - - ; A ce stade, on sait que la ligne ne loge pas entiŠrement sur l'‚cran - - ; On m‚morise dans la pile ce qu'il restera … afficher … la droite de la - ; rupture: - push cx - - ; On met dans CX le nb de pixels affichables avant la rupture: - mov cx,si - neg cx - - ; On effectue une copie 8/16/32 bits de la partie gauche de la rupture: - shr cx,1 - jnc LULALE_VESA_BreakLeft_ECX_multiple_de_2 - movsb - LULALE_VESA_BreakLeft_ECX_multiple_de_2: - shr cx,1 - jnc LULALE_VESA_BreakLeft_ECX_multiple_de_4 - movsw - LULALE_VESA_BreakLeft_ECX_multiple_de_4: - rep movsd - - ; On change de banque: - inc al - call [VESA_Change_banque_ecriture] - - ; On replace ESI en d‚but de banque - mov esi,0A0000h - - ; On restaure le nb de pixels … afficher … droite de la rupture - pop cx - - ; On effectue une copie 8/16/32 bits de la partie droite de la rupture: - shr cx,1 - jnc LULALE_VESA_BreakRight_ECX_multiple_de_2 - movsb - LULALE_VESA_BreakRight_ECX_multiple_de_2: - shr cx,1 - jnc LULALE_VESA_BreakRight_ECX_multiple_de_4 - movsw - LULALE_VESA_BreakRight_ECX_multiple_de_4: - rep movsd - - - LULALE_VESA_Fin_traitement_ligne: - - - pop edi - pop esi - - mov esp,ebp - pop ebp - - ret - -Lire_une_ligne_a_l_ecran_VESA endp - - - - - - -; Afficher une partie de l'image zoom‚e … l'‚cran - -Afficher_partie_de_l_ecran_zoomee_VESA proc near - - push ebp - mov ebp,esp - - arg Largeur:word,Hauteur:word,Largeur_image:word,Buffer:dword - - ; Largeur = Largeur non zoom‚e - ; Hauteur = Hauteur zoom‚e - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=Principal_Ecran+((Loupe_Decalage_Y*Largeur_image)+Loupe_Decalage_X) - - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_image - mov bx,Loupe_Decalage_Y - mov cx,Loupe_Decalage_X - mul ebx - mov esi,Principal_Ecran - add eax,ecx - add esi,eax - - ; On met dans DI la valeur Largeur*Facteur - mov ax,Largeur - mul Loupe_Facteur - mov di,ax - - ; On met dans EDX la ligne en cours de traitement: - xor edx,edx - - ; On met dans EBX la distance entre deux lignes d'image - xor ebx,ebx - mov bx,Largeur_image - - APDLEZ_VESA_Pour_chaque_ligne_a_zoomer: - - ; On eclate la ligne … zoomer: - push dx - mov ax,Loupe_Facteur - mov cx,Largeur - push ecx ; Largeur - push eax ; Facteur - push Buffer ; Ligne zoom‚e - push esi ; Ligne originale - call Zoomer_une_ligne - add esp,16 - pop dx - - ; On l'affiche Facteur fois … l'‚cran (sur des lignes cons‚cutives): - mov cx,Loupe_Facteur - - APDLEZ_VESA_Pour_chaque_ligne: - - ; On affiche la ligne zoom‚e - push cx - push dx - push Buffer ; Ligne - push edi ; Largeur*Facteur - push edx ; Pos_Y - mov ax,Principal_X_Zoom - push eax ; Pos_X - call Afficher_une_ligne_a_l_ecran_VESA - add esp,16 - pop dx - pop cx - - ; On passe … la ligne suivante - inc dx ; -> On v‚rifie qu'on ne soit - cmp dx,Hauteur ; pas arriv‚ … la ligne - je APDLEZ_VESA_Menu_Ordonnee_atteinte ; terminale - dec cx ; -> ou que l'on ai termin‚ de - jnz APDLEZ_VESA_Pour_chaque_ligne ; traiter la ligne … zoomer - - ; On passe … la ligne … zoomer suivante: - ; sans oublier de passer … la ligne image suivante - add esi,ebx - jmp APDLEZ_VESA_Pour_chaque_ligne_a_zoomer - - APDLEZ_VESA_Menu_Ordonnee_atteinte: - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Afficher_partie_de_l_ecran_zoomee_VESA endp - - - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - - - -; Afficher une partie de l'image tel quel sur l'‚cran - -Afficher_partie_de_l_ecran_mode_X proc near - - push ebp - mov ebp,esp - - arg Largeur:word,Hauteur:word,Largeur_image:word - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=Principal_Ecran+((Principal_Decalage_Y*Largeur_image)+Principal_Decalage_X) - - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Principal_Decalage_Y - mov bx,Largeur_image - mov cx,Principal_Decalage_X - mul ebx - mov esi,Principal_Ecran - add eax,ecx - add esi,eax - - ; On met dans EBX la distance qu'il y a entre la fin d'une ligne et le - ; d‚but de la ligne suivante … l'‚cran: - ; = DEJA FAIT - - ; On met dans CX le nø du 1er plan trait‚: - mov ecx,3 - - APDLE_mode_X_Pour_chaque_plan: - - ; On passe dans le plan en question: - mov dx,3C4h - mov ax,102h - shl ah,cl - out dx,ax - push esi - push cx - - ; On fait pointer les ESI et EDI vers leurs bonnes positions: - add esi,ecx - mov edi,0A0000h - ; Et on la garde bien au chaud dans un coin - mov MODE_X_Valeur_initiale_de_esi,esi - mov MODE_X_Valeur_initiale_de_edi,edi - - ; On lit le nombre de lignes … traiter: - mov dx,Hauteur - - APDLE_mode_X_Pour_chaque_ligne: - - ; On restaure la valeur de CX - pop cx - push cx - - APDLE_mode_X_Pour_chaque_pixel: - - ; On copie un pixel sur 4 - - mov eax,[esi] - mov [edi],al - add esi,4 - inc edi - - add cx,4 - cmp cx,Largeur - jb APDLE_mode_X_Pour_chaque_pixel - - ; On saute la partie non visible de l'‚cran: - mov esi,MODE_X_Valeur_initiale_de_esi - mov edi,MODE_X_Valeur_initiale_de_edi - add esi,ebx - add di,MODE_X_Largeur_de_ligne - mov MODE_X_Valeur_initiale_de_esi,esi - mov MODE_X_Valeur_initiale_de_edi,edi - - dec dx - jnz APDLE_mode_X_Pour_chaque_ligne - - - pop cx ; CX = nø du plan - pop esi - dec cx - jns APDLE_mode_X_Pour_chaque_plan - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Afficher_partie_de_l_ecran_mode_X endp - - - - - - - - -; Afficher une ligne … l'‚cran - -Afficher_une_ligne_a_l_ecran_mode_X proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Ligne:dword - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de EDI et le plan de d‚part dans CL: - ; - ; Valeur initiale=0A0000h+((Pos_Y*320)+Pos_X) - xor eax,eax - xor ecx,ecx - xor edx,edx - mov ax,Largeur_ecran - mov dx,Pos_Y - mov cx,Pos_X - mul edx - mov edi,0A0000h - add eax,ecx - shr eax,2 - and cx,3 - mov di,ax - mov MODE_X_Valeur_initiale_de_edi,edi - - ; On met dans BX le nø d'ordre du plan trait‚ (pas le nø de plan): - xor ebx,ebx - - AULALE_mode_X_Pour_chacun_des_plans: - - ; On met dans ESI l'adresse de la ligne … copier: - mov esi,Ligne - add esi,ebx - - ; Et dans EDI l'adresse o— recopier - mov edi,MODE_X_Valeur_initiale_de_edi - - ; On passe dans le plan en question: - mov dx,3C4h - mov ax,102h - shl ah,cl - out dx,ax - push cx - - ; On met dans CX la largeur d‚j… trait‚e: - mov cx,bx - - AULALE_mode_X_Pour_chaque_pixel_du_plan: - - ; On v‚rifie qu'on ait pas d‚bord‚: - cmp cx,Largeur - jae AULALE_mode_X_Fin_du_traitement_du_plan - - ; On copie un pixel: - mov eax,[esi] - mov [edi],al - add esi,4 - inc edi - add cx,4 - jmp AULALE_mode_X_Pour_chaque_pixel_du_plan - - AULALE_mode_X_Fin_du_traitement_du_plan: - - ; On passe au plan suivant: - pop cx ; -> Mise … jour de la - inc cx ; valeur du plan - and cx,3 ; - jnz AULALE_mode_X_Pas_de_changement_de_plan ; - inc MODE_X_Valeur_initiale_de_edi ; - AULALE_mode_X_Pas_de_changement_de_plan: ; - inc bx ; -> Mise … jour du nø d'ordre - cmp bx,4 ; du plan trait‚ - jne AULALE_mode_X_Pour_chacun_des_plans ; - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Afficher_une_ligne_a_l_ecran_mode_X endp - - - - - -; Lire une ligne … l'‚cran et la stocker dans un buffer - -Lire_une_ligne_a_l_ecran_mode_X proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Ligne:dword - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI et le plan de d‚part dans CL: - ; - ; Valeur initiale=0A0000h+((Pos_Y*Largeur_ecran)+Pos_X) - xor eax,eax - xor ecx,ecx - xor edx,edx - mov ax,Largeur_ecran - mov dx,Pos_Y - mov cx,Pos_X - mul edx - mov esi,0A0000h - add eax,ecx - shr eax,2 - and cx,3 - mov si,ax - mov MODE_X_Valeur_initiale_de_esi,esi - - ; On met dans BX le nø d'ordre du plan trait‚ (pas le nø de plan): - xor ebx,ebx - - LULALE_mode_X_Pour_chacun_des_plans: - - ; On met dans EDI l'adresse de la ligne o— copier: - mov edi,Ligne - add edi,ebx - - ; Et dans ESI l'adresse … recopier - mov esi,MODE_X_Valeur_initiale_de_esi - - ; On passe dans le plan en question: - mov dx,3CEh ; DX = Port du TS (enfin, je crois) - mov ah,cl - mov al,04h - out dx,ax - push cx - - ; On met dans CX la largeur d‚j… trait‚e: - mov cx,bx - - LULALE_mode_X_Pour_chaque_pixel_du_plan: - - ; On v‚rifie qu'on ait pas d‚bord‚: - cmp cx,Largeur - jae LULALE_mode_X_Fin_du_traitement_du_plan - - ; On copie un pixel: - mov al,[esi] - mov [edi],al - inc esi - add edi,4 - add cx,4 - jmp LULALE_mode_X_Pour_chaque_pixel_du_plan - - LULALE_mode_X_Fin_du_traitement_du_plan: - - ; On passe au plan suivant: - pop cx ; -> Mise … jour de la - inc cx ; valeur du plan - and cx,3 ; - jnz LULALE_mode_X_Pas_de_changement_de_plan ; - inc MODE_X_Valeur_initiale_de_esi ; - LULALE_mode_X_Pas_de_changement_de_plan: ; - inc bx ; -> Mise … jour du nø d'ordre - cmp bx,4 ; du plan trait‚ - jne LULALE_mode_X_Pour_chacun_des_plans ; - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Lire_une_ligne_a_l_ecran_mode_X endp - - - - - - -; Afficher une partie de l'image zoom‚e … l'‚cran - -Afficher_partie_de_l_ecran_zoomee_mode_X proc near - - push ebp - mov ebp,esp - - arg Largeur:word,Hauteur:word,Largeur_image:word,Buffer:dword - - ; Largeur = Largeur non zoom‚e - ; Hauteur = Hauteur zoom‚e - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=Principal_Ecran+((Loupe_Decalage_Y*Largeur_image)+Loupe_Decalage_X) - - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_image - mov bx,Loupe_Decalage_Y - mov cx,Loupe_Decalage_X - mul ebx - mov esi,Principal_Ecran - add eax,ecx - add esi,eax - - ; On met dans DI la valeur Largeur*Facteur - mov ax,Largeur - mul Loupe_Facteur - mov di,ax - - ; On met dans EDX la ligne en cours de traitement: - xor edx,edx - - ; On met dans EBX la distance entre deux lignes d'image - xor ebx,ebx - mov bx,Largeur_image - - APDLEZ_mode_X_Pour_chaque_ligne_a_zoomer: - - ; On eclate la ligne … zoomer: - push dx - mov ax,Loupe_Facteur - mov cx,Largeur - push ecx ; Largeur - push eax ; Facteur - push Buffer ; Ligne zoom‚e - push esi ; Ligne originale - call Zoomer_une_ligne - add esp,16 - pop dx - - ; On l'affiche Facteur fois … l'‚cran (sur des lignes cons‚cutives): - mov cx,Loupe_Facteur - - APDLEZ_mode_X_Pour_chaque_ligne: - - ; On affiche la ligne zoom‚e - push cx - push dx - push Buffer ; Ligne - push edi ; Largeur*Facteur - push edx ; Pos_Y - mov ax,Principal_X_Zoom - push eax ; Pos_X - call Afficher_une_ligne_a_l_ecran_mode_X - add esp,16 - pop dx - pop cx - - ; On passe … la ligne suivante - inc dx ; -> On v‚rifie qu'on ne soit - cmp dx,Hauteur ; pas arriv‚ … la ligne - je APDLEZ_mode_X_Menu_Ordonnee_atteinte ; terminale - dec cx ; -> ou que l'on ai termin‚ de - jnz APDLEZ_mode_X_Pour_chaque_ligne ; traiter la ligne … zoomer - - ; On passe … la ligne … zoomer suivante: - ; sans oublier de passer … la ligne image suivante - add esi,ebx - jmp APDLEZ_mode_X_Pour_chaque_ligne_a_zoomer - - APDLEZ_mode_X_Menu_Ordonnee_atteinte: - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Afficher_partie_de_l_ecran_zoomee_mode_X endp - - - - - - - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - - - - - - -; Afficher une ligne transparente en MCGA - -Afficher_une_ligne_transparente_a_l_ecran_MCGA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Ligne:dword,Couleur_transparence:byte - - push esi - push edi - - - ; On met dans ESI l'adresse de la ligne … copier: - mov esi,Ligne - - ; On calcule la valeur initiale de EDI: - ; - ; Valeur initiale=0A0000h+((Pos_Y*320)+Pos_X) - mov ax,320 - mov edi,0A0000h - mul Pos_Y - add ax,Pos_X - mov di,ax - - ; On met dans AH la couleur de transparence: - mov ah,Couleur_transparence - - ; On met dans CX le nombre de pixels … traiter: - mov cx,Largeur - - ; Pour chaque pixel de la ligne - AULTALE_Pour_chaque_pixel: - - ; On lit la source - mov al,[esi] - inc esi ; MAJ du Pointeur de source - - ; On v‚rifie qu'elle soit <> de la couleur de transparence - cmp al,ah - je AULTALE_Pas_de_copie - - ; Et on la copie dans la destination - mov [edi],al - AULTALE_Pas_de_copie: - inc edi ; MAJ du Pointeur de destination - - ; Hop! et un de moins - dec cx - jnz AULTALE_Pour_chaque_pixel - - pop edi - pop esi - - mov esp,ebp - pop ebp - - ret - -Afficher_une_ligne_transparente_a_l_ecran_MCGA endp - - - -; Afficher une ligne transparente en MCGA - -Afficher_une_ligne_transparente_mono_a_l_ecran_MCGA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Ligne:dword,Couleur_transparence:byte,Couleur:byte - - push esi - push edi - - - ; On met dans ESI l'adresse de la ligne … copier: - mov esi,Ligne - - ; On calcule la valeur initiale de EDI: - ; - ; Valeur initiale=0A0000h+((Pos_Y*320)+Pos_X) - mov ax,320 - mov edi,0A0000h - mul Pos_Y - add ax,Pos_X - mov di,ax - - ; On met dans AL la couleur de transparence: - mov al,Couleur_transparence - - ; On met dans DL la couleur … utiliser: - mov dl,Couleur - - ; On met dans CX le nombre de pixels … traiter: - mov cx,Largeur - - ; Pour chaque pixel de la ligne - AULTMALE_Pour_chaque_pixel: - - ; On v‚rifie que la source soit <> de la couleur de transparence - cmp al,[esi] - je AULTMALE_Pas_de_copie - - ; Et on copie la couleur dans la destination - mov [edi],dl - AULTMALE_Pas_de_copie: - inc esi ; MAJ du Pointeur de source - inc edi ; MAJ du Pointeur de destination - - ; Hop! et un de moins - dec cx - jnz AULTMALE_Pour_chaque_pixel - - pop edi - pop esi - - mov esp,ebp - pop ebp - - ret - -Afficher_une_ligne_transparente_mono_a_l_ecran_MCGA endp - - - - - - -; Afficher une ligne transparente … l'‚cran - -Afficher_une_ligne_transparente_a_l_ecran_VESA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Ligne:dword,Couleur_transparence:byte - - push esi - push edi - - - ; On met dans ESI l'adresse de la ligne … copier: - - mov esi,Ligne - - ; On calcule la valeur initiale de EDI: - ; - ; Valeur initiale=0A0000h+((Pos_Y*Largeur_ecran)+Pos_X) - - mov ax,Largeur_ecran - mov edi,0A0000h - mul Pos_Y - add ax,Pos_X - adc dx,0 - mov di,ax - ; Et on passe dans la banque correspondante - mov al,dl - call [VESA_Change_banque_ecriture] - - ; On met dans ECX le nombre de pixels … traiter: - xor ecx,ecx - mov cx,Largeur - - ; On regarde si la ligne loge totalement dans la banque en cours - add cx,di - jc AULTALE_VESA_Debordement_de_ligne - - ; Si c'est le cas: - mov cx,Largeur ; correction de CX … cause du test - - ; On effectue une copie de CX octets avec gestion de transparence - mov dh,Couleur_transparence - AULTALE_VESA_No_break_Pour_chaque_pixel: - mov dl,[esi] - cmp dl,dh - je AULTALE_VESA_No_break_Pas_de_copie - mov [edi],dl - AULTALE_VESA_No_break_Pas_de_copie: - inc esi - inc edi - dec cx - jnz AULTALE_VESA_No_break_Pour_chaque_pixel - - jmp AULTALE_VESA_Fin_traitement_ligne - - - ; Si ce n'est pas le cas (d‚bordement de la ligne) - AULTALE_VESA_Debordement_de_ligne: - - ; A ce stade, on sait que la ligne ne loge pas entiŠrement sur l'‚cran - - ; On m‚morise dans la pile ce qu'il restera … afficher … la droite de la - ; rupture: - push cx - - ; On met dans CX le nb de pixels affichables avant la rupture: - mov cx,di - neg cx - - ; On effectue une copie de CX octets avec gestion de transparence - mov dh,Couleur_transparence - AULTALE_VESA_BreakLeft_Pour_chaque_pixel: - mov dl,[esi] - cmp dl,dh - je AULTALE_VESA_BreakLeft_Pas_de_copie - mov [edi],dl - AULTALE_VESA_BreakLeft_Pas_de_copie: - inc esi - inc edi - dec cx - jnz AULTALE_VESA_BreakLeft_Pour_chaque_pixel - - ; On change de banque: - inc al - call [VESA_Change_banque_ecriture] - - ; On replace EDI en d‚but de banque - mov edi,0A0000h - - ; On restaure le nb de pixels … afficher … droite de la rupture - pop cx - or cx,cx - jz AULTALE_VESA_Fin_traitement_ligne - - ; On effectue une copie de CX octets avec gestion de transparence -; mov dh,Couleur_transparence ; LIGNE ECRITE PLUS HAUT, DH INCHANGE - AULTALE_VESA_BreakRight_Pour_chaque_pixel: - mov dl,[esi] - cmp dl,dh - je AULTALE_VESA_BreakRight_Pas_de_copie - mov [edi],dl - AULTALE_VESA_BreakRight_Pas_de_copie: - inc esi - inc edi - dec cx - jnz AULTALE_VESA_BreakRight_Pour_chaque_pixel - - - AULTALE_VESA_Fin_traitement_ligne: - - - pop edi - pop esi - - mov esp,ebp - pop ebp - - ret - -Afficher_une_ligne_transparente_a_l_ecran_VESA endp - - - - - -; Afficher une ligne transparente mono … l'‚cran - -Afficher_une_ligne_transparente_mono_a_l_ecran_VESA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Ligne:dword,Couleur_transparence:byte,Couleur:byte - - push esi - push edi - - - ; On met dans ESI l'adresse de la ligne … copier: - - mov esi,Ligne - - ; On calcule la valeur initiale de EDI: - ; - ; Valeur initiale=0A0000h+((Pos_Y*Largeur_ecran)+Pos_X) - - mov ax,Largeur_ecran - mov edi,0A0000h - mul Pos_Y - add ax,Pos_X - adc dx,0 - mov di,ax - ; Et on passe dans la banque correspondante - mov al,dl - call [VESA_Change_banque_ecriture] - - ; On met dans ECX le nombre de pixels … traiter: - xor ecx,ecx - mov cx,Largeur - - ; On regarde si la ligne loge totalement dans la banque en cours - add cx,di - jc AULTMALE_VESA_Debordement_de_ligne - - ; Si c'est le cas: - mov cx,Largeur ; correction de CX … cause du test - - ; On effectue une copie de CX octets avec gestion de transparence - mov dl,Couleur_transparence - mov dh,Couleur - AULTMALE_VESA_No_break_Pour_chaque_pixel: - cmp dl,[esi] - je AULTMALE_VESA_No_break_Pas_de_copie - mov [edi],dh - AULTMALE_VESA_No_break_Pas_de_copie: - inc esi - inc edi - dec cx - jnz AULTMALE_VESA_No_break_Pour_chaque_pixel - - jmp AULTMALE_VESA_Fin_traitement_ligne - - - ; Si ce n'est pas le cas (d‚bordement de la ligne) - AULTMALE_VESA_Debordement_de_ligne: - - ; A ce stade, on sait que la ligne ne loge pas entiŠrement sur l'‚cran - - ; On m‚morise dans la pile ce qu'il restera … afficher … la droite de la - ; rupture: - push cx - - ; On met dans CX le nb de pixels affichables avant la rupture: - mov cx,di - neg cx - - ; On effectue une copie de CX octets avec gestion de transparence - mov dl,Couleur_transparence - mov dh,Couleur - AULTMALE_VESA_BreakLeft_Pour_chaque_pixel: - cmp dl,[esi] - je AULTMALE_VESA_BreakLeft_Pas_de_copie - mov [edi],dh - AULTMALE_VESA_BreakLeft_Pas_de_copie: - inc esi - inc edi - dec cx - jnz AULTMALE_VESA_BreakLeft_Pour_chaque_pixel - - ; On change de banque: - inc al - call [VESA_Change_banque_ecriture] - - ; On replace EDI en d‚but de banque - mov edi,0A0000h - - ; On restaure le nb de pixels … afficher … droite de la rupture - pop cx - or cx,cx - jz AULTMALE_VESA_Fin_traitement_ligne - - ; On effectue une copie de CX octets avec gestion de transparence -; mov dl,Couleur_transparence ; LIGNE ECRITE PLUS HAUT, DL INCHANGE -; mov dh,Couleur ; LIGNE ECRITE PLUS HAUT, DH INCHANGE - AULTMALE_VESA_BreakRight_Pour_chaque_pixel: - cmp dl,[esi] - je AULTMALE_VESA_BreakRight_Pas_de_copie - mov [edi],dh - AULTMALE_VESA_BreakRight_Pas_de_copie: - inc esi - inc edi - dec cx - jnz AULTMALE_VESA_BreakRight_Pour_chaque_pixel - - - AULTMALE_VESA_Fin_traitement_ligne: - - - pop edi - pop esi - - mov esp,ebp - pop ebp - - ret - -Afficher_une_ligne_transparente_mono_a_l_ecran_VESA endp - - - - - - -; Afficher une ligne transparente … l'‚cran - -Afficher_une_ligne_transparente_a_l_ecran_mode_X proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Ligne:dword,Couleur_transparence:byte - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de EDI et le plan de d‚part dans CL: - ; - ; Valeur initiale=0A0000h+((Pos_Y*320)+Pos_X) - xor eax,eax - xor ecx,ecx - xor edx,edx - mov ax,Largeur_ecran - mov dx,Pos_Y - mov cx,Pos_X - mul edx - mov edi,0A0000h - add eax,ecx - shr eax,2 - and cx,3 - mov di,ax - mov MODE_X_Valeur_initiale_de_edi,edi - - ; On met dans BX le nø d'ordre du plan trait‚ (pas le nø de plan): - xor ebx,ebx - - AULTALE_mode_X_Pour_chacun_des_plans: - - ; On met dans ESI l'adresse de la ligne … copier: - mov esi,Ligne - add esi,ebx - - ; Et dans EDI l'adresse o— recopier - mov edi,MODE_X_Valeur_initiale_de_edi - - ; On passe dans le plan en question: - mov dx,3C4h - mov ax,102h - shl ah,cl - out dx,ax - push cx - - ; On met dans CX la largeur d‚j… trait‚e: - mov cx,bx - - ; On met dans AH la couleur de transparence - mov ah,Couleur_transparence - - AULTALE_mode_X_Pour_chaque_pixel_du_plan: - - ; On v‚rifie qu'on ai pas d‚bord‚: - cmp cx,Largeur - jae AULTALE_mode_X_Fin_du_traitement_du_plan - - ; On copie un pixel: - mov al,[esi] - cmp al,ah - je AULTALE_mode_X_Pas_de_copie - mov [edi],al - AULTALE_mode_X_Pas_de_copie: - add esi,4 - inc edi - add cx,4 - jmp AULTALE_mode_X_Pour_chaque_pixel_du_plan - - AULTALE_mode_X_Fin_du_traitement_du_plan: - - ; On passe au plan suivant: - pop cx ; -> Mise … jour de la - inc cx ; valeur du plan - and cx,3 ; - jnz AULTALE_mode_X_Pas_de_changement_de_plan ; - inc MODE_X_Valeur_initiale_de_edi ; - AULTALE_mode_X_Pas_de_changement_de_plan: ; - inc bx ; -> Mise … jour du nø d'ordre - cmp bx,4 ; du plan trait‚ - jne AULTALE_mode_X_Pour_chacun_des_plans ; - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Afficher_une_ligne_transparente_a_l_ecran_mode_X endp - - - - - - -; Afficher une ligne transparente mono … l'‚cran - -Afficher_une_ligne_transparente_mono_a_l_ecran_mode_X proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Largeur:word,Ligne:dword,Couleur_transparence:byte,Couleur:byte - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de EDI et le plan de d‚part dans CL: - ; - ; Valeur initiale=0A0000h+((Pos_Y*320)+Pos_X) - xor eax,eax - xor ecx,ecx - xor edx,edx - mov ax,Largeur_ecran - mov dx,Pos_Y - mov cx,Pos_X - mul edx - mov edi,0A0000h - add eax,ecx - shr eax,2 - and cx,3 - mov di,ax - mov MODE_X_Valeur_initiale_de_edi,edi - - ; On met dans BX le nø d'ordre du plan trait‚ (pas le nø de plan): - xor ebx,ebx - - AULTMALE_mode_X_Pour_chacun_des_plans: - - ; On met dans ESI l'adresse de la ligne … copier: - mov esi,Ligne - add esi,ebx - - ; Et dans EDI l'adresse o— recopier - mov edi,MODE_X_Valeur_initiale_de_edi - - ; On passe dans le plan en question: - mov dx,3C4h - mov ax,102h - shl ah,cl - out dx,ax - push cx - - ; On met dans CX la largeur d‚j… trait‚e: - mov cx,bx - - ; On met dans AL la couleur de transparence - mov al,Couleur_transparence - ; Et la couleur de coloriage dans AH - mov ah,Couleur - - AULTMALE_mode_X_Pour_chaque_pixel_du_plan: - - ; On v‚rifie qu'on ai pas d‚bord‚: - cmp cx,Largeur - jae AULTMALE_mode_X_Fin_du_traitement_du_plan - - ; On copie un pixel: - cmp al,[esi] - je AULTMALE_mode_X_Pas_de_copie - mov [edi],ah - AULTMALE_mode_X_Pas_de_copie: - add esi,4 - inc edi - add cx,4 - jmp AULTMALE_mode_X_Pour_chaque_pixel_du_plan - - AULTMALE_mode_X_Fin_du_traitement_du_plan: - - ; On passe au plan suivant: - pop cx ; -> Mise … jour de la - inc cx ; valeur du plan - and cx,3 ; - jnz AULTMALE_mode_X_Pas_de_changement_de_plan ; - inc MODE_X_Valeur_initiale_de_edi ; - AULTMALE_mode_X_Pas_de_changement_de_plan: ; - inc bx ; -> Mise … jour du nø d'ordre - cmp bx,4 ; du plan trait‚ - jne AULTMALE_mode_X_Pour_chacun_des_plans ; - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Afficher_une_ligne_transparente_mono_a_l_ecran_mode_X endp - - - - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - - -; Afficher une partie de la brosse zoom‚e en couleur en MCGA - -Display_brush_Color_Zoom_MCGA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Pos_Y_Fin:word,Couleur_de_transparence:byte,Largeur_brosse:word,Buffer:dword - - ; Largeur_brosse=Largeur r‚elle de la brosse - ; Largeur = Largeur non zoom‚e - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=Brosse+((Decalage_Y*Largeur_brosse)+Decalage_X) - - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_brosse - mov bx,Decalage_Y - mov cx,Decalage_X - mul ebx - mov esi,Brosse - add eax,ecx - add esi,eax - - ; On met dans DI la valeur Largeur*Facteur - mov ax,Largeur - mul Loupe_Facteur - mov di,ax - - ; On met dans DX la ligne en cours de traitement: - xor dx,Pos_Y - - DBCZ_MCGA_Pour_chaque_ligne_a_zoomer: - - ; On eclate la ligne … zoomer: - push dx - mov ax,Loupe_Facteur - mov cx,Largeur - push ecx ; Largeur - push eax ; Facteur - push Buffer ; Ligne zoom‚e - push esi ; Ligne originale - call Zoomer_une_ligne - add esp,16 - pop dx - - ; On sauve l'ancienne valeur de ESI: - push esi - - ; On place dans ESI la position courante en Y - mov esi,edx - - ; On empile … l'avance les derniers paramŠtres qui ne changent jamais le - ; long de la mˆme ligne zoom‚e: - mov al,Couleur_de_transparence - push eax ; Couleur de transparence - push Buffer ; Ligne - push edi ; Largeur*Facteur - - ; On l'affiche Facteur fois … l'‚cran (sur des lignes cons‚cutives): - mov bx,Loupe_Facteur ; BX n'est pas foutu en l'air par la routine appel‚e - - DBCZ_MCGA_Pour_chaque_ligne: - - ; On affiche la ligne zoom‚e - mov ax,Pos_X - push esi ; Pos_Y - push eax ; Pos_X - call Afficher_une_ligne_transparente_a_l_ecran_MCGA - add esp,8 ; (Pos_X+Pos_Y) - - ; On passe … la ligne suivante - inc si ; -> On v‚rifie qu'on ne soit - cmp si,Pos_Y_Fin ; pas arriv‚ … la ligne - je DBCZ_MCGA_Hauteur_atteinte ; terminale - dec bx ; -> ou que l'on ai termin‚ de - jnz DBCZ_MCGA_Pour_chaque_ligne ; traiter la ligne … zoomer - - ; On passe … la ligne … zoomer suivante: - ; sans oublier de passer … la ligne brosse suivante - - ; On commence par retirer les paramŠtres pr‚c‚demment pass‚s - add esp,12 ; (Largeur*Facteur + Ligne + Couleur de transparence) - - ; On sauve la ligne courante dans DX: - mov edx,esi - - ; On restaure l'ancienne valeur de ESI: - pop esi - - mov bx,Largeur_brosse ; En th‚orie, la partie haute de EBX est propre - add esi,ebx - jmp DBCZ_MCGA_Pour_chaque_ligne_a_zoomer - - DBCZ_MCGA_Hauteur_atteinte: - - ; On ramŠne la pile dans un ‚tat normal - add esp,16 ; (Largeur*Facteur + Ligne + Couleur de transparence + ESI) - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Display_brush_Color_Zoom_MCGA endp - - - - - - - -; Afficher une partie de la brosse zoom‚e en monochrome en MCGA - -Display_brush_Mono_Zoom_MCGA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Pos_Y_Fin:word,Couleur_de_transparence:byte,Couleur:byte,Largeur_brosse:word,Buffer:dword - - ; Largeur_brosse=Largeur r‚elle de la brosse - ; Largeur = Largeur non zoom‚e - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=Brosse+((Decalage_Y*Largeur_brosse)+Decalage_X) - - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_brosse - mov bx,Decalage_Y - mov cx,Decalage_X - mul ebx - mov esi,Brosse - add eax,ecx - add esi,eax - - ; On met dans DI la valeur Largeur*Facteur - mov ax,Largeur - mul Loupe_Facteur - mov di,ax - - ; On met dans DX la ligne en cours de traitement: - xor dx,Pos_Y - - DBMZ_MCGA_Pour_chaque_ligne_a_zoomer: - - ; On eclate la ligne … zoomer: - push dx - mov ax,Loupe_Facteur - mov cx,Largeur - push ecx ; Largeur - push eax ; Facteur - push Buffer ; Ligne zoom‚e - push esi ; Ligne originale - call Zoomer_une_ligne - add esp,16 - pop dx - - ; On sauve l'ancienne valeur de ESI: - push esi - - ; On place dans ESI la position courante en Y - mov esi,edx - - ; On empile … l'avance les derniers paramŠtres qui ne changent jamais le - ; long de la mˆme ligne zoom‚e: - mov al,Couleur - mov cl,Couleur_de_transparence - push eax ; Couleur d'affichage - push ecx ; Couleur de transparence - push Buffer ; Ligne - push edi ; Largeur*Facteur - - ; On l'affiche Facteur fois … l'‚cran (sur des lignes cons‚cutives): - mov bx,Loupe_Facteur ; BX n'est pas foutu en l'air par la routine appel‚e - - DBMZ_MCGA_Pour_chaque_ligne: - - ; On affiche la ligne zoom‚e - mov ax,Pos_X - push esi ; Pos_Y - push eax ; Pos_X - call Afficher_une_ligne_transparente_mono_a_l_ecran_MCGA - add esp,8 ; (Pos_X+Pos_Y) - - ; On passe … la ligne suivante - inc si ; -> On v‚rifie qu'on ne soit - cmp si,Pos_Y_Fin ; pas arriv‚ … la ligne - je DBMZ_MCGA_Hauteur_atteinte ; terminale - dec bx ; -> ou que l'on ai termin‚ de - jnz DBMZ_MCGA_Pour_chaque_ligne ; traiter la ligne … zoomer - - ; On passe … la ligne … zoomer suivante: - ; sans oublier de passer … la ligne brosse suivante - - ; On commence par retirer les paramŠtres pr‚c‚demment pass‚s - add esp,16 ; (Largeur*Facteur + Ligne + Couleur de transparence + Couleur) - - ; On sauve la ligne courante dans DX: - mov edx,esi - - ; On restaure l'ancienne valeur de ESI: - pop esi - - mov bx,Largeur_brosse ; En th‚orie, la partie haute de EBX est propre - add esi,ebx - jmp DBMZ_MCGA_Pour_chaque_ligne_a_zoomer - - DBMZ_MCGA_Hauteur_atteinte: - - ; On ramŠne la pile dans un ‚tat normal - add esp,20 ; (Largeur*Facteur + Ligne + Couleur de transparence + Couleur + ESI) - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Display_brush_Mono_Zoom_MCGA endp - - - - - -; Effacer une partie de la brosse zoom‚e en MCGA - -Clear_brush_Zoom_MCGA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Pos_Y_Fin:word,Couleur_de_transparence:byte,Largeur_image:word,Buffer:dword - - ; Largeur_brosse=Largeur r‚elle de la brosse - ; Largeur = Largeur non zoom‚e - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=Principal_Ecran+((Decalage_Y*Largeur_image)+Decalage_X) - - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_image - mov bx,Decalage_Y - mov cx,Decalage_X - mul ebx - mov esi,Principal_Ecran - add eax,ecx - add esi,eax - - ; On met dans DI la valeur Largeur*Facteur - mov ax,Largeur - mul Loupe_Facteur - mov di,ax - - ; On met dans DX la ligne en cours de traitement: - xor dx,Pos_Y - - CBZ_MCGA_Pour_chaque_ligne_a_zoomer: - - ; On eclate la ligne … zoomer: - push dx - mov ax,Loupe_Facteur - mov cx,Largeur - push ecx ; Largeur - push eax ; Facteur - push Buffer ; Ligne zoom‚e - push esi ; Ligne originale - call Zoomer_une_ligne - add esp,16 - pop dx - - ; On sauve l'ancienne valeur de ESI: - push esi - - ; On place dans ESI la position courante en Y - mov esi,edx - - ; On empile … l'avance les derniers paramŠtres qui ne changent jamais le - ; long de la mˆme ligne zoom‚e: - push Buffer ; Ligne - push edi ; Largeur*Facteur - - ; On l'affiche Facteur fois … l'‚cran (sur des lignes cons‚cutives): - mov bx,Loupe_Facteur ; BX n'est pas foutu en l'air par la routine appel‚e - - CBZ_MCGA_Pour_chaque_ligne: - - ; On affiche la ligne zoom‚e - mov ax,Pos_X - push esi ; Pos_Y - push eax ; Pos_X - call Afficher_une_ligne_a_l_ecran_MCGA - add esp,8 ; (Pos_X+Pos_Y) - - ; On passe … la ligne suivante - inc si ; -> On v‚rifie qu'on ne soit - cmp si,Pos_Y_Fin ; pas arriv‚ … la ligne - je CBZ_MCGA_Hauteur_atteinte ; terminale - dec bx ; -> ou que l'on ai termin‚ de - jnz CBZ_MCGA_Pour_chaque_ligne ; traiter la ligne … zoomer - - ; On passe … la ligne … zoomer suivante: - ; sans oublier de passer … la ligne brosse suivante - - ; On commence par retirer les paramŠtres pr‚c‚demment pass‚s - add esp,8 ; (Largeur*Facteur + Ligne) - - ; On sauve la ligne courante dans DX: - mov edx,esi - - ; On restaure l'ancienne valeur de ESI: - pop esi - - mov bx,Largeur_image ; En th‚orie, la partie haute de EBX est propre - add esi,ebx - jmp CBZ_MCGA_Pour_chaque_ligne_a_zoomer - - CBZ_MCGA_Hauteur_atteinte: - - ; On ramŠne la pile dans un ‚tat normal - add esp,12 ; (Largeur*Facteur + Ligne + ESI) - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Clear_brush_Zoom_MCGA endp - - - - - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - - -; Afficher une partie de la brosse zoom‚e en couleur en mode X - -Display_brush_Color_Zoom_mode_X proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Pos_Y_Fin:word,Couleur_de_transparence:byte,Largeur_brosse:word,Buffer:dword - - ; Largeur_brosse=Largeur r‚elle de la brosse - ; Largeur = Largeur non zoom‚e - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=Brosse+((Decalage_Y*Largeur_brosse)+Decalage_X) - - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_brosse - mov bx,Decalage_Y - mov cx,Decalage_X - mul ebx - mov esi,Brosse - add eax,ecx - add esi,eax - - ; On met dans DI la valeur Largeur*Facteur - mov ax,Largeur - mul Loupe_Facteur - mov di,ax - - ; On met dans DX la ligne en cours de traitement: - xor dx,Pos_Y - - DBCZ_mode_X_Pour_chaque_ligne_a_zoomer: - - ; On eclate la ligne … zoomer: - push dx - mov ax,Loupe_Facteur - mov cx,Largeur - push ecx ; Largeur - push eax ; Facteur - push Buffer ; Ligne zoom‚e - push esi ; Ligne originale - call Zoomer_une_ligne - add esp,16 - pop dx - - ; On sauve l'ancienne valeur de ESI: - push esi - - ; On place dans ESI la position courante en Y - mov esi,edx - - ; On empile … l'avance les derniers paramŠtres qui ne changent jamais le - ; long de la mˆme ligne zoom‚e: - mov al,Couleur_de_transparence - push eax ; Couleur de transparence - push Buffer ; Ligne - push edi ; Largeur*Facteur - - ; On l'affiche Facteur fois … l'‚cran (sur des lignes cons‚cutives): - mov bx,Loupe_Facteur ; BX n'est pas foutu en l'air par la routine appel‚e - - DBCZ_mode_X_Pour_chaque_ligne: - - ; On affiche la ligne zoom‚e - mov ax,Pos_X - push esi ; Pos_Y - push eax ; Pos_X - call Afficher_une_ligne_transparente_a_l_ecran_mode_X - add esp,8 ; (Pos_X+Pos_Y) - - ; On passe … la ligne suivante - inc si ; -> On v‚rifie qu'on ne soit - cmp si,Pos_Y_Fin ; pas arriv‚ … la ligne - je DBCZ_mode_X_Hauteur_atteinte ; terminale - dec bx ; -> ou que l'on ai termin‚ de - jnz DBCZ_mode_X_Pour_chaque_ligne ; traiter la ligne … zoomer - - ; On passe … la ligne … zoomer suivante: - ; sans oublier de passer … la ligne brosse suivante - - ; On commence par retirer les paramŠtres pr‚c‚demment pass‚s - add esp,12 ; (Largeur*Facteur + Ligne + Couleur de transparence) - - ; On sauve la ligne courante dans DX: - mov edx,esi - - ; On restaure l'ancienne valeur de ESI: - pop esi - - mov bx,Largeur_brosse ; En th‚orie, la partie haute de EBX est propre - add esi,ebx - jmp DBCZ_mode_X_Pour_chaque_ligne_a_zoomer - - DBCZ_mode_X_Hauteur_atteinte: - - ; On ramŠne la pile dans un ‚tat normal - add esp,16 ; (Largeur*Facteur + Ligne + Couleur de transparence + ESI) - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Display_brush_Color_Zoom_mode_X endp - - - - - - - -; Afficher une partie de la brosse zoom‚e en monochrome en mode X - -Display_brush_Mono_Zoom_mode_X proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Pos_Y_Fin:word,Couleur_de_transparence:byte,Couleur:byte,Largeur_brosse:word,Buffer:dword - - ; Largeur_brosse=Largeur r‚elle de la brosse - ; Largeur = Largeur non zoom‚e - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=Brosse+((Decalage_Y*Largeur_brosse)+Decalage_X) - - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_brosse - mov bx,Decalage_Y - mov cx,Decalage_X - mul ebx - mov esi,Brosse - add eax,ecx - add esi,eax - - ; On met dans DI la valeur Largeur*Facteur - mov ax,Largeur - mul Loupe_Facteur - mov di,ax - - ; On met dans DX la ligne en cours de traitement: - xor dx,Pos_Y - - DBMZ_mode_X_Pour_chaque_ligne_a_zoomer: - - ; On eclate la ligne … zoomer: - push dx - mov ax,Loupe_Facteur - mov cx,Largeur - push ecx ; Largeur - push eax ; Facteur - push Buffer ; Ligne zoom‚e - push esi ; Ligne originale - call Zoomer_une_ligne - add esp,16 - pop dx - - ; On sauve l'ancienne valeur de ESI: - push esi - - ; On place dans ESI la position courante en Y - mov esi,edx - - ; On empile … l'avance les derniers paramŠtres qui ne changent jamais le - ; long de la mˆme ligne zoom‚e: - mov al,Couleur - mov cl,Couleur_de_transparence - push eax ; Couleur d'affichage - push ecx ; Couleur de transparence - push Buffer ; Ligne - push edi ; Largeur*Facteur - - ; On l'affiche Facteur fois … l'‚cran (sur des lignes cons‚cutives): - mov bx,Loupe_Facteur ; BX n'est pas foutu en l'air par la routine appel‚e - - DBMZ_mode_X_Pour_chaque_ligne: - - ; On affiche la ligne zoom‚e - mov ax,Pos_X - push esi ; Pos_Y - push eax ; Pos_X - call Afficher_une_ligne_transparente_mono_a_l_ecran_mode_X - add esp,8 ; (Pos_X+Pos_Y) - - ; On passe … la ligne suivante - inc si ; -> On v‚rifie qu'on ne soit - cmp si,Pos_Y_Fin ; pas arriv‚ … la ligne - je DBMZ_mode_X_Hauteur_atteinte ; terminale - dec bx ; -> ou que l'on ai termin‚ de - jnz DBMZ_mode_X_Pour_chaque_ligne ; traiter la ligne … zoomer - - ; On passe … la ligne … zoomer suivante: - ; sans oublier de passer … la ligne brosse suivante - - ; On commence par retirer les paramŠtres pr‚c‚demment pass‚s - add esp,16 ; (Largeur*Facteur + Ligne + Couleur de transparence + Couleur) - - ; On sauve la ligne courante dans DX: - mov edx,esi - - ; On restaure l'ancienne valeur de ESI: - pop esi - - mov bx,Largeur_brosse ; En th‚orie, la partie haute de EBX est propre - add esi,ebx - jmp DBMZ_mode_X_Pour_chaque_ligne_a_zoomer - - DBMZ_mode_X_Hauteur_atteinte: - - ; On ramŠne la pile dans un ‚tat normal - add esp,20 ; (Largeur*Facteur + Ligne + Couleur de transparence + Couleur + ESI) - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Display_brush_Mono_Zoom_mode_X endp - - - - - -; Effacer une partie de la brosse zoom‚e en mode X - -Clear_brush_Zoom_mode_X proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Pos_Y_Fin:word,Couleur_de_transparence:byte,Largeur_image:word,Buffer:dword - - ; Largeur_brosse=Largeur r‚elle de la brosse - ; Largeur = Largeur non zoom‚e - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=Principal_Ecran+((Decalage_Y*Largeur_image)+Decalage_X) - - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_image - mov bx,Decalage_Y - mov cx,Decalage_X - mul ebx - mov esi,Principal_Ecran - add eax,ecx - add esi,eax - - ; On met dans DI la valeur Largeur*Facteur - mov ax,Largeur - mul Loupe_Facteur - mov di,ax - - ; On met dans DX la ligne en cours de traitement: - xor dx,Pos_Y - - CBZ_mode_X_Pour_chaque_ligne_a_zoomer: - - ; On eclate la ligne … zoomer: - push dx - mov ax,Loupe_Facteur - mov cx,Largeur - push ecx ; Largeur - push eax ; Facteur - push Buffer ; Ligne zoom‚e - push esi ; Ligne originale - call Zoomer_une_ligne - add esp,16 - pop dx - - ; On sauve l'ancienne valeur de ESI: - push esi - - ; On place dans ESI la position courante en Y - mov esi,edx - - ; On empile … l'avance les derniers paramŠtres qui ne changent jamais le - ; long de la mˆme ligne zoom‚e: - push Buffer ; Ligne - push edi ; Largeur*Facteur - - ; On l'affiche Facteur fois … l'‚cran (sur des lignes cons‚cutives): - mov bx,Loupe_Facteur ; BX n'est pas foutu en l'air par la routine appel‚e - - CBZ_mode_X_Pour_chaque_ligne: - - ; On affiche la ligne zoom‚e - mov ax,Pos_X - push esi ; Pos_Y - push eax ; Pos_X - call Afficher_une_ligne_a_l_ecran_mode_X - add esp,8 ; (Pos_X+Pos_Y) - - ; On passe … la ligne suivante - inc si ; -> On v‚rifie qu'on ne soit - cmp si,Pos_Y_Fin ; pas arriv‚ … la ligne - je CBZ_mode_X_Hauteur_atteinte ; terminale - dec bx ; -> ou que l'on ai termin‚ de - jnz CBZ_mode_X_Pour_chaque_ligne ; traiter la ligne … zoomer - - ; On passe … la ligne … zoomer suivante: - ; sans oublier de passer … la ligne brosse suivante - - ; On commence par retirer les paramŠtres pr‚c‚demment pass‚s - add esp,8 ; (Largeur*Facteur + Ligne) - - ; On sauve la ligne courante dans DX: - mov edx,esi - - ; On restaure l'ancienne valeur de ESI: - pop esi - - mov bx,Largeur_image ; En th‚orie, la partie haute de EBX est propre - add esi,ebx - jmp CBZ_mode_X_Pour_chaque_ligne_a_zoomer - - CBZ_mode_X_Hauteur_atteinte: - - ; On ramŠne la pile dans un ‚tat normal - add esp,12 ; (Largeur*Facteur + Ligne + ESI) - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Clear_brush_Zoom_mode_X endp - - - - - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - - -; Afficher une partie de la brosse zoom‚e en couleur en VESA - -Display_brush_Color_Zoom_VESA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Pos_Y_Fin:word,Couleur_de_transparence:byte,Largeur_brosse:word,Buffer:dword - - ; Largeur_brosse=Largeur r‚elle de la brosse - ; Largeur = Largeur non zoom‚e - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=Brosse+((Decalage_Y*Largeur_brosse)+Decalage_X) - - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_brosse - mov bx,Decalage_Y - mov cx,Decalage_X - mul ebx - mov esi,Brosse - add eax,ecx - add esi,eax - - ; On met dans DI la valeur Largeur*Facteur - mov ax,Largeur - mul Loupe_Facteur - mov di,ax - - ; On met dans DX la ligne en cours de traitement: - xor dx,Pos_Y - - DBCZ_VESA_Pour_chaque_ligne_a_zoomer: - - ; On eclate la ligne … zoomer: - push dx - mov ax,Loupe_Facteur - mov cx,Largeur - push ecx ; Largeur - push eax ; Facteur - push Buffer ; Ligne zoom‚e - push esi ; Ligne originale - call Zoomer_une_ligne - add esp,16 - pop dx - - ; On sauve l'ancienne valeur de ESI: - push esi - - ; On place dans ESI la position courante en Y - mov esi,edx - - ; On empile … l'avance les derniers paramŠtres qui ne changent jamais le - ; long de la mˆme ligne zoom‚e: - mov al,Couleur_de_transparence - push eax ; Couleur de transparence - push Buffer ; Ligne - push edi ; Largeur*Facteur - - ; On l'affiche Facteur fois … l'‚cran (sur des lignes cons‚cutives): - mov bx,Loupe_Facteur ; BX n'est pas foutu en l'air par la routine appel‚e - - DBCZ_VESA_Pour_chaque_ligne: - - ; On affiche la ligne zoom‚e - mov ax,Pos_X - push esi ; Pos_Y - push eax ; Pos_X - call Afficher_une_ligne_transparente_a_l_ecran_VESA - add esp,8 ; (Pos_X+Pos_Y) - - ; On passe … la ligne suivante - inc si ; -> On v‚rifie qu'on ne soit - cmp si,Pos_Y_Fin ; pas arriv‚ … la ligne - je DBCZ_VESA_Hauteur_atteinte ; terminale - dec bx ; -> ou que l'on ai termin‚ de - jnz DBCZ_VESA_Pour_chaque_ligne ; traiter la ligne … zoomer - - ; On passe … la ligne … zoomer suivante: - ; sans oublier de passer … la ligne brosse suivante - - ; On commence par retirer les paramŠtres pr‚c‚demment pass‚s - add esp,12 ; (Largeur*Facteur + Ligne + Couleur de transparence) - - ; On sauve la ligne courante dans DX: - mov edx,esi - - ; On restaure l'ancienne valeur de ESI: - pop esi - - mov bx,Largeur_brosse ; En th‚orie, la partie haute de EBX est propre - add esi,ebx - jmp DBCZ_VESA_Pour_chaque_ligne_a_zoomer - - DBCZ_VESA_Hauteur_atteinte: - - ; On ramŠne la pile dans un ‚tat normal - add esp,16 ; (Largeur*Facteur + Ligne + Couleur de transparence + ESI) - - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Display_brush_Color_Zoom_VESA endp - - - - - - - -; Afficher une partie de la brosse zoom‚e en monochrome en VESA - -Display_brush_Mono_Zoom_VESA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Pos_Y_Fin:word,Couleur_de_transparence:byte,Couleur:byte,Largeur_brosse:word,Buffer:dword - - ; Largeur_brosse=Largeur r‚elle de la brosse - ; Largeur = Largeur non zoom‚e - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=Brosse+((Decalage_Y*Largeur_brosse)+Decalage_X) - - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_brosse - mov bx,Decalage_Y - mov cx,Decalage_X - mul ebx - mov esi,Brosse - add eax,ecx - add esi,eax - - ; On met dans DI la valeur Largeur*Facteur - mov ax,Largeur - mul Loupe_Facteur - mov di,ax - - ; On met dans DX la ligne en cours de traitement: - xor dx,Pos_Y - - DBMZ_VESA_Pour_chaque_ligne_a_zoomer: - - ; On eclate la ligne … zoomer: - push dx - mov ax,Loupe_Facteur - mov cx,Largeur - push ecx ; Largeur - push eax ; Facteur - push Buffer ; Ligne zoom‚e - push esi ; Ligne originale - call Zoomer_une_ligne - add esp,16 - pop dx - - ; On sauve l'ancienne valeur de ESI: - push esi - - ; On place dans ESI la position courante en Y - mov esi,edx - - ; On empile … l'avance les derniers paramŠtres qui ne changent jamais le - ; long de la mˆme ligne zoom‚e: - mov al,Couleur - mov cl,Couleur_de_transparence - push eax ; Couleur d'affichage - push ecx ; Couleur de transparence - push Buffer ; Ligne - push edi ; Largeur*Facteur - - ; On l'affiche Facteur fois … l'‚cran (sur des lignes cons‚cutives): - mov bx,Loupe_Facteur ; BX n'est pas foutu en l'air par la routine appel‚e - - DBMZ_VESA_Pour_chaque_ligne: - - ; On affiche la ligne zoom‚e - mov ax,Pos_X - push esi ; Pos_Y - push eax ; Pos_X - call Afficher_une_ligne_transparente_mono_a_l_ecran_VESA - add esp,8 ; (Pos_X+Pos_Y) - - ; On passe … la ligne suivante - inc si ; -> On v‚rifie qu'on ne soit - cmp si,Pos_Y_Fin ; pas arriv‚ … la ligne - je DBMZ_VESA_Hauteur_atteinte ; terminale - dec bx ; -> ou que l'on ai termin‚ de - jnz DBMZ_VESA_Pour_chaque_ligne ; traiter la ligne … zoomer - - ; On passe … la ligne … zoomer suivante: - ; sans oublier de passer … la ligne brosse suivante - - ; On commence par retirer les paramŠtres pr‚c‚demment pass‚s - add esp,16 ; (Largeur*Facteur + Ligne + Couleur de transparence + Couleur) - - ; On sauve la ligne courante dans DX: - mov edx,esi - - ; On restaure l'ancienne valeur de ESI: - pop esi - - mov bx,Largeur_brosse ; En th‚orie, la partie haute de EBX est propre - add esi,ebx - jmp DBMZ_VESA_Pour_chaque_ligne_a_zoomer - - DBMZ_VESA_Hauteur_atteinte: - - ; On ramŠne la pile dans un ‚tat normal - add esp,20 ; (Largeur*Facteur + Ligne + Couleur de transparence + Couleur + ESI) - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Display_brush_Mono_Zoom_VESA endp - - - - - -; Effacer une partie de la brosse zoom‚e en VESA - -Clear_brush_Zoom_VESA proc near - - push ebp - mov ebp,esp - - arg Pos_X:word,Pos_Y:word,Decalage_X:word,Decalage_Y:word,Largeur:word,Pos_Y_Fin:word,Couleur_de_transparence:byte,Largeur_image:word,Buffer:dword - - ; Largeur_brosse=Largeur r‚elle de la brosse - ; Largeur = Largeur non zoom‚e - - push ebx - push esi - push edi - - - ; On calcule la valeur initiale de ESI: - ; - ; Valeur initiale=Principal_Ecran+((Decalage_Y*Largeur_image)+Decalage_X) - - xor eax,eax - xor ebx,ebx - xor ecx,ecx - mov ax,Largeur_image - mov bx,Decalage_Y - mov cx,Decalage_X - mul ebx - mov esi,Principal_Ecran - add eax,ecx - add esi,eax - - ; On met dans DI la valeur Largeur*Facteur - mov ax,Largeur - mul Loupe_Facteur - mov di,ax - - ; On met dans DX la ligne en cours de traitement: - xor dx,Pos_Y - - CBZ_VESA_Pour_chaque_ligne_a_zoomer: - - ; On eclate la ligne … zoomer: - push dx - mov ax,Loupe_Facteur - mov cx,Largeur - push ecx ; Largeur - push eax ; Facteur - push Buffer ; Ligne zoom‚e - push esi ; Ligne originale - call Zoomer_une_ligne - add esp,16 - pop dx - - ; On sauve l'ancienne valeur de ESI: - push esi - - ; On place dans ESI la position courante en Y - mov esi,edx - - ; On empile … l'avance les derniers paramŠtres qui ne changent jamais le - ; long de la mˆme ligne zoom‚e: - push Buffer ; Ligne - push edi ; Largeur*Facteur - - ; On l'affiche Facteur fois … l'‚cran (sur des lignes cons‚cutives): - mov bx,Loupe_Facteur ; BX n'est pas foutu en l'air par la routine appel‚e - - CBZ_VESA_Pour_chaque_ligne: - - ; On affiche la ligne zoom‚e - mov ax,Pos_X - push esi ; Pos_Y - push eax ; Pos_X - call Afficher_une_ligne_a_l_ecran_VESA - add esp,8 ; (Pos_X+Pos_Y) - - ; On passe … la ligne suivante - inc si ; -> On v‚rifie qu'on ne soit - cmp si,Pos_Y_Fin ; pas arriv‚ … la ligne - je CBZ_VESA_Hauteur_atteinte ; terminale - dec bx ; -> ou que l'on ai termin‚ de - jnz CBZ_VESA_Pour_chaque_ligne ; traiter la ligne … zoomer - - ; On passe … la ligne … zoomer suivante: - ; sans oublier de passer … la ligne brosse suivante - - ; On commence par retirer les paramŠtres pr‚c‚demment pass‚s - add esp,8 ; (Largeur*Facteur + Ligne) - - ; On sauve la ligne courante dans DX: - mov edx,esi - - ; On restaure l'ancienne valeur de ESI: - pop esi - - mov bx,Largeur_image ; En th‚orie, la partie haute de EBX est propre - add esi,ebx - jmp CBZ_VESA_Pour_chaque_ligne_a_zoomer - - CBZ_VESA_Hauteur_atteinte: - - ; On ramŠne la pile dans un ‚tat normal - add esp,12 ; (Largeur*Facteur + Ligne + ESI) - - pop edi - pop esi - pop ebx - - mov esp,ebp - pop ebp - - ret - -Clear_brush_Zoom_VESA endp - - - - - - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - - - - - - -_TEXT ENDS -END - diff --git a/Anciens fichiers/video.h b/Anciens fichiers/video.h deleted file mode 100644 index a970b920..00000000 --- a/Anciens fichiers/video.h +++ /dev/null @@ -1,109 +0,0 @@ -/* Grafx2 - The Ultimate 256-color bitmap paint program - - Copyright 1996-2001 Sunset Design (Guillaume Dorme & Karl Maritaud) - - Grafx2 is free software; you can redistribute it and/or - modify it under the terms of the GNU General Public License - as published by the Free Software Foundation; version 2 - of the License. - - Grafx2 is distributed in the hope that it will be useful, - but WITHOUT ANY WARRANTY; without even the implied warranty of - MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - GNU General Public License for more details. - - You should have received a copy of the GNU General Public License - along with Grafx2; if not, see or - write to the Free Software Foundation, Inc., - 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -*/ -#include "struct.h" - -// -- Headers des fonctions MCGA -- - -void Set_mode_MCGA (void); -void Pixel_MCGA (word X,word Y,byte Couleur); -byte Lit_pixel_MCGA (word X,word Y); -void Effacer_tout_l_ecran_MCGA (byte Couleur); -void Block_MCGA (word Debut_X,word Debut_Y,word Largeur,word Hauteur,byte Couleur); - -void Pixel_Preview_Normal_MCGA (word X,word Y,byte Couleur); -void Pixel_Preview_Loupe_MCGA (word X,word Y,byte Couleur); -void Ligne_horizontale_XOR_MCGA(word Pos_X,word Pos_Y,word Largeur); -void Ligne_verticale_XOR_MCGA (word Pos_X,word Pos_Y,word Hauteur); - -void Display_brush_Color_MCGA (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse); -void Display_brush_Mono_MCGA (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse); -void Clear_brush_MCGA (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_image); -void Remap_screen_MCGA (word Pos_X,word Pos_Y,word Largeur,word Hauteur,byte * Table_de_conversion); - - -// -- Headers des fonctions Mode X -- - -void Set_mode_X (void); -void Pixel_mode_X (word X,word Y,byte Couleur); -byte Lit_pixel_mode_X (word X,word Y); -void Effacer_tout_l_ecran_mode_X (byte Couleur); -void Block_mode_X (word Debut_X,word Debut_Y,word Largeur,word Hauteur,byte Couleur); - -void Pixel_Preview_Normal_mode_X (word X,word Y,byte Couleur); -void Pixel_Preview_Loupe_mode_X (word X,word Y,byte Couleur); -void Ligne_horizontale_XOR_mode_X(word Pos_X,word Pos_Y,word Largeur); -void Ligne_verticale_XOR_mode_X (word Pos_X,word Pos_Y,word Hauteur); - -void Display_brush_Color_mode_X(word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse); -void Display_brush_Mono_mode_X (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse); -void Clear_brush_mode_X (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_image); -void Remap_screen_mode_X (word Pos_X,word Pos_Y,word Largeur,word Hauteur,byte * Table_de_conversion); - -// -- Headers des fonctions VESA -- - -void VESA_Change_banque_Fenetre_A(void); -void VESA_Change_banque_Fenetre_B(void); -void VESA_Change_banque_Fenetre_A_et_B(void); -void VESA_Change_banque_Fenetre_A_FAST(void); -void VESA_Change_banque_Fenetre_B_FAST(void); -void VESA_Change_banque_Fenetre_A_et_B_FAST(void); -//void Support_VESA(void); -//void Mode_VESA_supporte(word Mode); -byte Initialiser_mode_video_VESA(word Mode); -void Retoucher_CRTC(void); -void Pixel_VESA(word X,word Y,byte Couleur); -byte Lit_pixel_VESA(word X,word Y); -void Effacer_tout_l_ecran_VESA(byte Couleur); -void Block_VESA(word Debut_X,word Debut_Y,word Largeur,word Hauteur,byte Couleur); - -void Pixel_Preview_Normal_VESA (word X,word Y,byte Couleur); -void Pixel_Preview_Loupe_VESA (word X,word Y,byte Couleur); -void Ligne_horizontale_XOR_VESA(word Pos_X,word Pos_Y,word Largeur); -void Ligne_verticale_XOR_VESA (word Pos_X,word Pos_Y,word Hauteur); - -void Display_brush_Color_VESA (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse); -void Display_brush_Mono_VESA (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse); -void Clear_brush_VESA (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_image); -void Remap_screen_VESA (word Pos_X,word Pos_Y,word Largeur,word Hauteur,byte * Table_de_conversion); - -// -- Nouveaux trucs -- - -void Afficher_partie_de_l_ecran_MCGA (word Largeur,word Hauteur,word Largeur_image); -void Afficher_une_ligne_a_l_ecran_MCGA (word Pos_X,word Pos_Y,word Largeur,byte * Ligne); -void Lire_une_ligne_a_l_ecran_MCGA (word Pos_X,word Pos_Y,word Largeur,byte * Ligne); -void Afficher_partie_de_l_ecran_zoomee_MCGA (word Largeur,word Hauteur,word Largeur_image,byte * Buffer); -void Afficher_partie_de_l_ecran_mode_X (word Largeur,word Hauteur,word Largeur_image); -void Afficher_une_ligne_a_l_ecran_mode_X (word Pos_X,word Pos_Y,word Largeur,byte * Ligne); -void Lire_une_ligne_a_l_ecran_mode_X (word Pos_X,word Pos_Y,word Largeur,byte * Ligne); -void Afficher_partie_de_l_ecran_zoomee_mode_X(word Largeur,word Hauteur,word Largeur_image,byte * Buffer); -void Afficher_partie_de_l_ecran_VESA (word Largeur,word Hauteur,word Largeur_image); -void Afficher_une_ligne_a_l_ecran_VESA (word Pos_X,word Pos_Y,word Largeur,byte * Ligne); -void Lire_une_ligne_a_l_ecran_VESA (word Pos_X,word Pos_Y,word Largeur,byte * Ligne); -void Afficher_partie_de_l_ecran_zoomee_VESA (word Largeur,word Hauteur,word Largeur_image,byte * Buffer); - -void Display_brush_Color_Zoom_MCGA (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_brosse,byte * Buffer); -void Display_brush_Mono_Zoom_MCGA (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse,byte * Buffer); -void Clear_brush_Zoom_MCGA (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_image,byte * Buffer); -void Display_brush_Color_Zoom_mode_X(word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_brosse,byte * Buffer); -void Display_brush_Mono_Zoom_mode_X (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse,byte * Buffer); -void Clear_brush_Zoom_mode_X (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_image,byte * Buffer); -void Display_brush_Color_Zoom_VESA (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_brosse,byte * Buffer); -void Display_brush_Mono_Zoom_VESA (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,byte Couleur,word Largeur_brosse,byte * Buffer); -void Clear_brush_Zoom_VESA (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_image,byte * Buffer);