From fb7887f535d85b802b2906df76b7de5add6c48c8 Mon Sep 17 00:00:00 2001 From: Adrien Destugues Date: Sat, 14 Apr 2007 20:19:08 +0000 Subject: [PATCH] First upload of the code. git-svn-id: svn://pulkomandy.tk/GrafX2/trunk@3 416bcca6-2ee7-4201-b75f-2eb2f807beb1 --- Anciens fichiers/divers.asm | 3943 +++++++++++++++++++ Anciens fichiers/oper_bak.c | 4000 ++++++++++++++++++++ Anciens fichiers/vesahigh.c | 202 + Anciens fichiers/vesalfb.asm | 2301 ++++++++++++ Anciens fichiers/vesalfb.h | 113 + Anciens fichiers/video.asm | 6903 ++++++++++++++++++++++++++++++++++ Anciens fichiers/video.h | 90 + GrafX.cbp | 365 ++ GrafX.depend | 333 ++ GrafX.layout | 31 + aide.c | 289 ++ 11 files changed, 18570 insertions(+) create mode 100644 Anciens fichiers/divers.asm create mode 100644 Anciens fichiers/oper_bak.c create mode 100644 Anciens fichiers/vesahigh.c create mode 100644 Anciens fichiers/vesalfb.asm create mode 100644 Anciens fichiers/vesalfb.h create mode 100644 Anciens fichiers/video.asm create mode 100644 Anciens fichiers/video.h create mode 100644 GrafX.cbp create mode 100644 GrafX.depend create mode 100644 GrafX.layout create mode 100644 aide.c diff --git a/Anciens fichiers/divers.asm b/Anciens fichiers/divers.asm new file mode 100644 index 00000000..55ce9a71 --- /dev/null +++ b/Anciens fichiers/divers.asm @@ -0,0 +1,3943 @@ +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/oper_bak.c b/Anciens fichiers/oper_bak.c new file mode 100644 index 00000000..77646277 --- /dev/null +++ b/Anciens fichiers/oper_bak.c @@ -0,0 +1,4000 @@ +#include +#include "const.h" +#include "struct.h" +#include "global.h" +#include "divers.h" +#include "moteur.h" +#include "graph.h" +#include "operatio.h" + +#include +#include + +void Demarrer_pile_operation(word Operation_demandee) +{ + // On m‚morise l'op‚ration pr‚c‚dente si on d‚marre une interruption + switch(Operation_demandee) + { + case OPERATION_LOUPE : + case OPERATION_PIPETTE : + case OPERATION_PRISE_BROSSE : + case OPERATION_POLYBROSSE : + case OPERATION_ETIRER_BROSSE: + Operation_avant_interruption=Operation_en_cours; + // On passe … l'operation demand‚e + Operation_en_cours=Operation_demandee; + break; + default : + // On passe … l'operation demand‚e + Operation_en_cours=Operation_demandee; + Operation_avant_interruption=Operation_en_cours; + } + + // On sp‚cifie si l'op‚ration autorise le changement de couleur au clavier + switch(Operation_demandee) + { + case OPERATION_DESSIN_CONTINU: + case OPERATION_DESSIN_DISCONTINU: + case OPERATION_SPRAY: + case OPERATION_LIGNES_CENTREES: + Autoriser_changement_de_couleur_pendant_operation=1; + break; + default : + Autoriser_changement_de_couleur_pendant_operation=0; + } + + // Et on passe au curseur qui va avec + Forme_curseur=CURSEUR_D_OPERATION[Operation_demandee]; + Operation_Taille_pile=0; +} + + +void Initialiser_debut_operation(void) +{ + Operation_dans_loupe=(Mouse_X>=Principal_X_Zoom); + Smear_Debut=1; +} + + +void Operation_PUSH(short Valeur) +{ + Operation_Pile[++Operation_Taille_pile]=Valeur; +} + + +void Operation_POP(short * Valeur) +{ + *Valeur=Operation_Pile[Operation_Taille_pile--]; +} + + +byte Pinceau_Forme_avant_operation; +byte Cacher_pinceau_avant_operation; + + + +short Distance(short X1, short Y1, short X2, short Y2) +{ + short X2_moins_X1=X2-X1; + short Y2_moins_Y1=Y2-Y1; + + return Round( sqrt( (X2_moins_X1*X2_moins_X1) + (Y2_moins_Y1*Y2_moins_Y1) ) ); +} + + +void Aff_coords_rel_ou_abs(short Debut_X, short Debut_Y) +{ + char Chaine[6]; + + if (Config.Coords_rel) + { + if (Menu_visible) + { + if (Pinceau_X>Debut_X) + { + Num2str(Pinceau_X-Debut_X,Chaine,5); + Chaine[0]='+'; + } + else if (Pinceau_XDebut_Y) + { + Num2str(Pinceau_Y-Debut_Y,Chaine,5); + Chaine[0]='+'; + } + else if (Pinceau_Y>1); + Loupe_Decalage_Y=Mouse_Y-(Loupe_Hauteur>>1); + + // Calcul du coin haut_gauche de la fenˆtre devant ˆtre zoom‚e DANS L'ECRAN + if (Loupe_Decalage_X+Loupe_Largeur>=Limite_Droite-Principal_Decalage_X) + Loupe_Decalage_X=Limite_Droite-Loupe_Largeur-Principal_Decalage_X+1; + if (Loupe_Decalage_Y+Loupe_Hauteur>=Limite_Bas-Principal_Decalage_Y) + Loupe_Decalage_Y=Limite_Bas-Loupe_Hauteur-Principal_Decalage_Y+1; + + // Calcul des coordonn‚es absolues de ce coin DANS L'IMAGE + Loupe_Decalage_X+=Principal_Decalage_X; + Loupe_Decalage_Y+=Principal_Decalage_Y; + + if (Loupe_Decalage_X<0) + Loupe_Decalage_X=0; + if (Loupe_Decalage_Y<0) + Loupe_Decalage_Y=0; + + // On calcule les bornes visibles dans l'‚cran + Recadrer_ecran_par_rapport_au_zoom(); + Calculer_limites(); + Afficher_ecran(); + + // Repositionner le curseur en fonction des coordonn‚es visibles + Calculer_coordonnees_pinceau(); + + // On fait de notre mieux pour restaurer l'ancienne op‚ration: + Demarrer_pile_operation(Operation_avant_interruption); +} + +/////////////////////////////////////////////////// OPERATION_RECTANGLE_????? + +void Rectangle_12_0(void) +// Op‚ration : OPERATION_RECTANGLE_VIDE / OPERATION_RECTANGLE_PLEIN +// Click Souris: 1 ou 2 +// Taille_Pile : 0 +// +// Souris effac‚e: Oui +{ + Initialiser_debut_operation(); + + if ((Config.Coords_rel) && (Menu_visible)) + Print_dans_menu("\035: 1 \022: 1",0); + // On laisse une trace du curseur … l'‚cran + Afficher_curseur(); + + if (Mouse_K==A_GAUCHE) + { + Shade_Table=Shade_Table_gauche; + Operation_PUSH(Fore_color); + } + else + { + Shade_Table=Shade_Table_droite; + Operation_PUSH(Back_color); + } + + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); +} + + +void Rectangle_12_5(void) +// Op‚ration : OPERATION_RECTANGLE_VIDE / OPERATION_RECTANGLE_PLEIN +// Click Souris: 1 ou 2 +// Taille_Pile : 5 +// +// Souris effac‚e: Non +{ + short Debut_X; + short Debut_Y; + short Ancien_X; + short Ancien_Y; + char Chaine[5]; + + Operation_POP(&Ancien_Y); + Operation_POP(&Ancien_X); + + if ((Pinceau_X!=Ancien_X) || (Pinceau_Y!=Ancien_Y)) + { + Operation_POP(&Debut_Y); + Operation_POP(&Debut_X); + + if ((Config.Coords_rel) && (Menu_visible)) + { + Num2str(((Debut_XCentre_X)?Tangente_X-Centre_X + :Centre_X-Tangente_X; + Rayon_vertical =(Tangente_Y>Centre_Y)?Tangente_Y-Centre_Y + :Centre_Y-Tangente_Y; + Effacer_ellipse_vide_Preview(Centre_X,Centre_Y,Rayon_horizontal,Rayon_vertical); + + Rayon_horizontal=(Pinceau_X>Centre_X)?Pinceau_X-Centre_X + :Centre_X-Pinceau_X; + Rayon_vertical =(Pinceau_Y>Centre_Y)?Pinceau_Y-Centre_Y + :Centre_Y-Pinceau_Y; + Tracer_ellipse_vide_Preview(Centre_X,Centre_Y,Rayon_horizontal,Rayon_vertical,Couleur); + + Afficher_curseur(); + } + + Operation_PUSH(Couleur); + Operation_PUSH(Centre_X); + Operation_PUSH(Centre_Y); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); +} + + +void Ellipse_vide_0_5(void) +// +// Op‚ration : OPERATION_ELLIPSE_VIDE +// Click Souris: 0 +// Taille_Pile : 5 (Couleur, X_Centre, Y_Centre, X_Tangente, Y_Tangente) +// +// Souris effac‚e: Oui +// +{ + short Tangente_X; + short Tangente_Y; + short Centre_X; + short Centre_Y; + short Couleur; + short Rayon_horizontal; + short Rayon_vertical; + + Operation_POP(&Tangente_Y); + Operation_POP(&Tangente_X); + Operation_POP(&Centre_Y); + Operation_POP(&Centre_X); + Operation_POP(&Couleur); + + Rayon_horizontal=(Tangente_X>Centre_X)?Tangente_X-Centre_X + :Centre_X-Tangente_X; + Rayon_vertical =(Tangente_Y>Centre_Y)?Tangente_Y-Centre_Y + :Centre_Y-Tangente_Y; + Effacer_ellipse_vide_Preview(Centre_X,Centre_Y,Rayon_horizontal,Rayon_vertical); + + Pinceau_Forme=Pinceau_Forme_avant_operation; + + Tracer_ellipse_vide_Definitif(Centre_X,Centre_Y,Rayon_horizontal,Rayon_vertical,Couleur); + + if ( (Config.Coords_rel) && (Menu_visible) ) + { + Print_dans_menu("X: Y: ",0); + Print_coordonnees(); + } +} + + +void Ellipse_pleine_0_5(void) +// +// Op‚ration : OPERATION_ELLIPSE_PLEINE +// Click Souris: 0 +// Taille_Pile : 5 (Couleur, X_Centre, Y_Centre, X_Tangente, Y_Tangente) +// +// Souris effac‚e: Oui +// +{ + short Tangente_X; + short Tangente_Y; + short Centre_X; + short Centre_Y; + short Couleur; + short Rayon_horizontal; + short Rayon_vertical; + + Operation_POP(&Tangente_Y); + Operation_POP(&Tangente_X); + Operation_POP(&Centre_Y); + Operation_POP(&Centre_X); + Operation_POP(&Couleur); + + Rayon_horizontal=(Tangente_X>Centre_X)?Tangente_X-Centre_X + :Centre_X-Tangente_X; + Rayon_vertical =(Tangente_Y>Centre_Y)?Tangente_Y-Centre_Y + :Centre_Y-Tangente_Y; + Effacer_ellipse_vide_Preview(Centre_X,Centre_Y,Rayon_horizontal,Rayon_vertical); + + Pinceau_Forme=Pinceau_Forme_avant_operation; + + Tracer_ellipse_pleine(Centre_X,Centre_Y,Rayon_horizontal,Rayon_vertical,Couleur); + + if ( (Config.Coords_rel) && (Menu_visible) ) + { + Print_dans_menu("X: Y: ",0); + Print_coordonnees(); + } +} + + +////////////////////////////////////////////////////////////// OPERATION_FILL + + +void Fill_1_0(void) +// +// Op‚ration : OPERATION_FILL +// Click Souris: 1 +// Taille_Pile : 0 +// +// Souris effac‚e: Oui +// +{ + // Pas besoin d'initialiser le d‚but d'op‚ration car le Smear n'affecte pas + // le Fill, et on se fout de savoir si on est dans la partie gauche ou + // droite de la loupe. + // On ne s'occupe pas de faire un Backup: c'est "Remplir" qui s'en charge. + Shade_Table=Shade_Table_gauche; + Remplir(Fore_color); + Attendre_fin_de_click(); +} + + +void Fill_2_0(void) +// +// Op‚ration : OPERATION_FILL +// Click Souris: 2 +// Taille_Pile : 0 +// +// Souris effac‚e: Oui +// +{ + // Pas besoin d'initialiser le d‚but d'op‚ration car le Smear n'affecte pas + // le Fill, et on se fout de savoir si on est dans la partie gauche ou + // droite de la loupe. + // On ne s'occupe pas de faire un Backup: c'est "Remplir" qui s'en charge. + Shade_Table=Shade_Table_droite; + Remplir(Back_color); + Attendre_fin_de_click(); +} + + +///////////////////////////////////////////////////////// OPERATION_REMPLACER + + +void Remplacer_1_0(void) +// +// Op‚ration : OPERATION_REMPLACER +// Click Souris: 1 +// Taille_Pile : 0 +// +// Souris effac‚e: Oui +// +{ + // Pas besoin d'initialiser le d‚but d'op‚ration car le Smear n'affecte pas + // le Replace, et on se fout de savoir si on est dans la partie gauche ou + // droite de la loupe. + Backup(); +// Shade_Table=Shade_Table_gauche; + Remplacer(Fore_color); + Attendre_fin_de_click(); +} + + +void Remplacer_2_0(void) +// +// Op‚ration : OPERATION_REMPLACER +// Click Souris: 2 +// Taille_Pile : 0 +// +// Souris effac‚e: Oui +// +{ + // Pas besoin d'initialiser le d‚but d'op‚ration car le Smear n'affecte pas + // le Replace, et on se fout de savoir si on est dans la partie gauche ou + // droite de la loupe. + Backup(); +// Shade_Table=Shade_Table_droite; + Remplacer(Back_color); + Attendre_fin_de_click(); +} + + +/////////////////////////////////////////////////////////// OPERATION_PIPETTE + + +void Pipette_12_0(void) +// +// Op‚ration : OPERATION_PIPETTE +// Click Souris: 1 ou 2 +// Taille_Pile : 0 +// +// Souris effac‚e: Oui +// +{ + Initialiser_debut_operation(); + + if (Mouse_K==A_GAUCHE) + { + Encadrer_couleur_menu(CM_Noir); + Fore_color=Pipette_Couleur; + Recadrer_palette(); + Afficher_foreback(); + Encadrer_couleur_menu(CM_Blanc); + } + else + { + Back_color=Pipette_Couleur; + Afficher_foreback(); + } + Operation_PUSH(Mouse_K); +} + + +void Pipette_1_1(void) +// +// Op‚ration : OPERATION_PIPETTE +// Click Souris: 1 +// Taille_Pile : 1 +// +// Souris effac‚e: Non +// +{ + char Chaine[4]; + + if ( (Pinceau_X>=0) && (Pinceau_Y>=0) + && (Pinceau_X=0) && (Pinceau_Y>=0) + && (Pinceau_X=Limite_Gauche+3) + Debut_X=0; + else + Debut_X=3-(Pos_X-Limite_Gauche); + + if (Pos_Y>=Limite_Haut+3) + Debut_Y=0; + else + Debut_Y=3-(Pos_Y-Limite_Haut); + + if (Pos_X<=Limite_visible_Droite-3) + Fin_X=6; + else + Fin_X=3+(Limite_visible_Droite-Pos_X); + + if (Pos_Y<=Limite_visible_Bas-3) + Fin_Y=6; + else + Fin_Y=3+(Limite_visible_Bas-Pos_Y); + + for (i=Debut_X; i<=Fin_X; i++) + { + Temp=Pos_X+i-3; + Pixel_Preview(Temp,Pos_Y,~Lit_pixel(Temp -Principal_Decalage_X, + Pos_Y-Principal_Decalage_Y)); + } + for (i=Debut_Y; i<=Fin_Y; i++) + { + Temp=Pos_Y+i-3; + Pixel_Preview(Pos_X,Temp,~Lit_pixel(Pos_X-Principal_Decalage_X, + Temp -Principal_Decalage_Y)); + } +} + + +void Courbe_34_points_1_0(void) +// +// Op‚ration : OPERATION_COURBE_?_POINTS +// Click Souris: 1 +// Taille_Pile : 0 +// +// Souris effac‚e: Oui +// +{ + Initialiser_debut_operation(); + Backup(); + Shade_Table=Shade_Table_gauche; + + Cacher_pinceau=1; + + Pixel_figure_Preview(Pinceau_X,Pinceau_Y,Fore_color); + + if ((Config.Coords_rel) && (Menu_visible)) + Print_dans_menu("X:ñ 0 Y:ñ 0",0); + + Operation_PUSH(Fore_color); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); +} + +void Courbe_34_points_2_0(void) +// +// Op‚ration : OPERATION_COURBE_?_POINTS +// Click Souris: 2 +// Taille_Pile : 0 +// +// Souris effac‚e: Oui +// +{ + Initialiser_debut_operation(); + Backup(); + Shade_Table=Shade_Table_droite; + + Cacher_pinceau=1; + + Pixel_figure_Preview(Pinceau_X,Pinceau_Y,Back_color); + + if ((Config.Coords_rel) && (Menu_visible)) + Print_dans_menu("X:ñ 0 Y:ñ 0",0); + + Operation_PUSH(Back_color); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); +} + + +void Courbe_34_points_1_5(void) +// +// Op‚ration : OPERATION_COURBE_?_POINTS +// Click Souris: 1 +// Taille_Pile : 5 +// +// Souris effac‚e: Non +// +{ + short X1,X2,Y1,Y2; + + Operation_POP(&Y2); + Operation_POP(&X2); + Operation_POP(&Y1); + Operation_POP(&X1); + + if ( (Y2!=Pinceau_Y) || (X2!=Pinceau_X) ) + { + Effacer_curseur(); + Aff_coords_rel_ou_abs(X1,Y1); + + Effacer_ligne_Preview(X1,Y1,X2,Y2); + Pixel_figure_Preview (X1,Y1,Fore_color); + Tracer_ligne_Preview (X1,Y1,Pinceau_X,Pinceau_Y,Fore_color); + + Afficher_curseur(); + } + + Operation_PUSH(X1); + Operation_PUSH(Y1); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); +} + +void Courbe_34_points_2_5(void) +// +// Op‚ration : OPERATION_COURBE_?_POINTS +// Click Souris: 2 +// Taille_Pile : 5 +// +// Souris effac‚e: Non +// +{ + short X1,X2,Y1,Y2; + + Operation_POP(&Y2); + Operation_POP(&X2); + Operation_POP(&Y1); + Operation_POP(&X1); + + if ( (Y2!=Pinceau_Y) || (X2!=Pinceau_X) ) + { + Effacer_curseur(); + Aff_coords_rel_ou_abs(X1,Y1); + + Effacer_ligne_Preview(X1,Y1,X2,Y2); + Pixel_figure_Preview (X1,Y1,Back_color); + Tracer_ligne_Preview (X1,Y1,Pinceau_X,Pinceau_Y,Back_color); + + Afficher_curseur(); + } + + Operation_PUSH(X1); + Operation_PUSH(Y1); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); +} + + +byte Cacher_curseur_avant_courbe; + +void Courbe_4_points_0_5(void) +// +// Op‚ration : OPERATION_COURBE_4_POINTS +// Click Souris: 0 +// Taille_Pile : 5 +// +// Souris effac‚e: Oui +// +{ + short X1,Y1,X2,Y2,X3,Y3,X4,Y4; + short Tiers_X,Tiers_Y; + short Couleur; + + Operation_POP(&Y4); + Operation_POP(&X4); + Operation_POP(&Y1); + Operation_POP(&X1); + Operation_POP(&Couleur); + + Tiers_X=Round_div(abs(X4-X1),3); + Tiers_Y=Round_div(abs(Y4-Y1),3); + + if (X1B=(8/3) * C->P + *X3=Round((BX+X4)/2.0); // ú _/úú P3 P2=milieu de [P1,B] + *Y3=Round((BY+Y4)/2.0); // P4*-- P3=milieu de [P4,B] +} + + +void Courbe_3_points_0_5(void) +// +// Op‚ration : OPERATION_COURBE_3_POINTS +// Click Souris: 0 +// Taille_Pile : 5 +// +// Souris effac‚e: Oui +// +{ + short X1,Y1,X2,Y2,X3,Y3,X4,Y4; + short Couleur; + + Operation_POP(&Y4); + Operation_POP(&X4); + Operation_POP(&Y1); + Operation_POP(&X1); + Operation_POP(&Couleur); + + Calculer_courbe_3_points(X1,Y1,X4,Y4,&X2,&Y2,&X3,&Y3); + + Effacer_ligne_Preview(X1,Y1,X4,Y4); + Tracer_courbe_Preview(X1,Y1,X2,Y2,X3,Y3,X4,Y4,Couleur); + + if ( (Config.Coords_rel) && (Menu_visible) ) + { + Print_dans_menu("X: Y: ",0); + Print_coordonnees(); + } + + Operation_PUSH(Couleur); + Operation_PUSH(X1); + Operation_PUSH(Y1); + Operation_PUSH(X2); + Operation_PUSH(Y2); + Operation_PUSH(X3); + Operation_PUSH(Y3); + Operation_PUSH(X4); + Operation_PUSH(Y4); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); +} + + +void Courbe_3_points_0_11(void) +// +// Op‚ration : OPERATION_COURBE_3_POINTS +// Click Souris: 0 +// Taille_Pile : 11 +// +// Souris effac‚e: Non +// +{ + short X1,Y1,X2,Y2,X3,Y3,X4,Y4; + short Old_X,Old_Y; + short Couleur; + + Operation_POP(&Old_Y); + Operation_POP(&Old_X); + + if ( (Pinceau_X!=Old_X) || (Pinceau_Y!=Old_Y) ) + { + Operation_POP(&Y4); + Operation_POP(&X4); + Operation_POP(&Y3); + Operation_POP(&X3); + Operation_POP(&Y2); + Operation_POP(&X2); + Operation_POP(&Y1); + Operation_POP(&X1); + Operation_POP(&Couleur); + + Effacer_curseur(); + Print_coordonnees(); + + Effacer_courbe_Preview(X1,Y1,X2,Y2,X3,Y3,X4,Y4,Couleur); + Calculer_courbe_3_points(X1,Y1,X4,Y4,&X2,&Y2,&X3,&Y3); + Tracer_courbe_Preview (X1,Y1,X2,Y2,X3,Y3,X4,Y4,Couleur); + Afficher_curseur(); + + Operation_PUSH(Couleur); + Operation_PUSH(X1); + Operation_PUSH(Y1); + Operation_PUSH(X2); + Operation_PUSH(Y2); + Operation_PUSH(X3); + Operation_PUSH(Y3); + Operation_PUSH(X4); + Operation_PUSH(Y4); + } + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); +} + + +void Courbe_3_points_12_11(void) +// +// Op‚ration : OPERATION_COURBE_3_POINTS +// Click Souris: 1 ou 2 +// Taille_Pile : 11 +// +// Souris effac‚e: Oui +// +{ + short X1,Y1,X2,Y2,X3,Y3,X4,Y4; + short Old_X,Old_Y; + short Couleur; + + Operation_POP(&Old_Y); + Operation_POP(&Old_X); + Operation_POP(&Y4); + Operation_POP(&X4); + Operation_POP(&Y3); + Operation_POP(&X3); + Operation_POP(&Y2); + Operation_POP(&X2); + Operation_POP(&Y1); + Operation_POP(&X1); + Operation_POP(&Couleur); + + Cacher_pinceau=0; + + Effacer_courbe_Preview (X1,Y1,X2,Y2,X3,Y3,X4,Y4,Couleur); + Calculer_courbe_3_points(X1,Y1,X4,Y4,&X2,&Y2,&X3,&Y3); + Tracer_courbe_Definitif(X1,Y1,X2,Y2,X3,Y3,X4,Y4,Couleur); + + Attendre_fin_de_click(); +} + + +///////////////////////////////////////////////////////////// OPERATION_SPRAY + + +void Spray_1_0(void) +// +// Op‚ration : OPERATION_SPRAY +// Click Souris: 1 +// Taille_Pile : 0 +// +// Souris effac‚e: Non +// +{ + Initialiser_debut_operation(); + Backup(); + Shade_Table=Shade_Table_gauche; + Aerographe(A_GAUCHE); + + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + Operation_PUSH(A_GAUCHE); +} + +void Spray_2_0(void) +// +// Op‚ration : OPERATION_SPRAY +// Click Souris: 2 +// Taille_Pile : 0 +// +// Souris effac‚e: Non +// +{ + Initialiser_debut_operation(); + Backup(); + Shade_Table=Shade_Table_droite; + Aerographe(A_DROITE); + + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + Operation_PUSH(A_DROITE); +} + +void Spray_12_3(void) +// +// Op‚ration : OPERATION_SPRAY +// Click Souris: 1 ou 2 +// Taille_Pile : 1 +// +// Souris effac‚e: Non +// +{ + short Bouton_clicke; + short Ancien_X,Ancien_Y; + + Operation_POP(&Bouton_clicke); + Operation_POP(&Ancien_Y); + Operation_POP(&Ancien_X); + + if ( (Menu_visible) && ((Pinceau_X!=Ancien_X) || (Pinceau_Y!=Ancien_Y)) ) + { + Effacer_curseur(); + Print_coordonnees(); + Afficher_curseur(); + } + + Aerographe(Bouton_clicke); + + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + Operation_PUSH(Bouton_clicke); +} + +void Spray_0_3(void) +// +// Op‚ration : OPERATION_SPRAY +// Click Souris: 0 +// Taille_Pile : 3 +// +// Souris effac‚e: Non +// +{ + Operation_Taille_pile-=3; +} + + +////////////////////////////////////////////////////////// OPERATION_POLYGONE + + +void Polygone_12_0(void) +// Op‚ration : OPERATION_POLYGONE +// Click Souris: 1 ou 2 +// Taille_Pile : 0 +// +// Souris effac‚e: Oui +{ + byte Couleur; + + Initialiser_debut_operation(); + Backup(); + Shade_Table=(Mouse_K==A_GAUCHE)?Shade_Table_gauche:Shade_Table_droite; + Pinceau_Forme_avant_operation=Pinceau_Forme; + Pinceau_Forme=FORME_PINCEAU_POINT; + + Couleur=(Mouse_K==A_GAUCHE)?Fore_color:Back_color; + + // On place temporairement le d‚but de la ligne qui ne s'afficherait pas sinon + Pixel_figure_Preview(Pinceau_X,Pinceau_Y,Couleur); + + if ((Config.Coords_rel) && (Menu_visible)) + Print_dans_menu("X:ñ 0 Y:ñ 0",0); + + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + Operation_PUSH(Mouse_K | 0x80); + Operation_PUSH(Couleur); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + // Taille de pile 8 : phase d'appui, non interruptible +} + + + +void Polygone_12_9(void) +// Op‚ration : OPERATION_POLYGONE +// Click Souris: 1 ou 2 +// Taille_Pile : 9 +// +// Souris effac‚e: Oui +{ + short Debut_X; + short Debut_Y; + short Fin_X; + short Fin_Y; + short Couleur; + short Direction; + + Operation_POP(&Fin_Y); + Operation_POP(&Fin_X); + Operation_POP(&Debut_Y); + Operation_POP(&Debut_X); + Operation_POP(&Couleur); + Operation_POP(&Direction); + Operation_POP(&Direction); + + if (Direction==Mouse_K) + { + Operation_PUSH(Direction); + Operation_PUSH(Couleur); + Operation_PUSH(Debut_X); + Operation_PUSH(Debut_Y); + Operation_PUSH(Fin_X); + Operation_PUSH(Fin_Y); + // Taille de pile 8 : phase d'appui, non interruptible + } + else + { + // La s‚rie de ligne est termin‚e, il faut donc effacer la derniŠre + // preview de ligne et relier le dernier point avec le premier + Pixel_figure_Preview (Debut_X,Debut_Y,Lit_pixel_dans_ecran_courant(Debut_X,Debut_Y)); + Effacer_ligne_Preview (Debut_X,Debut_Y,Fin_X,Fin_Y); + Operation_POP(&Fin_Y); + Operation_POP(&Fin_X); + Pinceau_Forme=Pinceau_Forme_avant_operation; + // Le pied aurait ‚t‚ de ne pas repasser sur le 1er point de la 1Šre ligne + // mais c'est pas possible :( + Tracer_ligne_Definitif(Debut_X,Debut_Y,Fin_X,Fin_Y,Couleur); + Pinceau_Forme=FORME_PINCEAU_POINT; + + Afficher_curseur(); + Attendre_fin_de_click(); + Effacer_curseur(); + + if ( (Config.Coords_rel) && (Menu_visible) ) + { + Print_dans_menu("X: Y: ",0); + Print_coordonnees(); + } + + Pinceau_Forme=Pinceau_Forme_avant_operation; + } +} + + +////////////////////////////////////////////////////////// OPERATION_POLYFILL + +short * Polyfill_Table_de_points; +int Polyfill_Nombre_de_points; + +void Polyfill_12_0(void) +// Op‚ration : OPERATION_POLYFILL +// Click Souris: 1 ou 2 +// Taille_Pile : 0 +// +// Souris effac‚e: Oui +{ + byte Couleur; + + Initialiser_debut_operation(); + Backup(); + Shade_Table=(Mouse_K==A_GAUCHE)?Shade_Table_gauche:Shade_Table_droite; + Cacher_pinceau=1; + + Couleur=(Mouse_K==A_GAUCHE)?Fore_color:Back_color; + + Polyfill_Table_de_points=(short *) malloc((Config.Nb_max_de_vertex_par_polygon<<1)*sizeof(short)); + Polyfill_Table_de_points[0]=Pinceau_X; + Polyfill_Table_de_points[1]=Pinceau_Y; + Polyfill_Nombre_de_points=1; + + // On place temporairement le d‚but de la ligne qui ne s'afficherait pas sinon + Pixel_figure_Preview_xor(Pinceau_X,Pinceau_Y,0); + + if ((Config.Coords_rel) && (Menu_visible)) + Print_dans_menu("X:ñ 0 Y:ñ 0",0); + + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + Operation_PUSH(Mouse_K | 0x80); + Operation_PUSH(Couleur); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + // Taille de pile 8 : phase d'appui, non interruptible +} + + +void Polyfill_0_8(void) +// Op‚ration : OPERATION_POLYFILL +// Click Souris: 0 +// Taille_Pile : 8 +// +// Souris effac‚e: Oui +{ + short Debut_X; + short Debut_Y; + short Fin_X; + short Fin_Y; + short Couleur; + short Direction; + + Operation_POP(&Fin_Y); + Operation_POP(&Fin_X); + Operation_POP(&Debut_Y); + Operation_POP(&Debut_X); + Operation_POP(&Couleur); + Operation_POP(&Direction); + + if ((Config.Coords_rel) && (Menu_visible)) + Print_dans_menu("X:ñ 0 Y:ñ 0",0); + + Tracer_ligne_Preview_xor(Debut_X,Debut_Y,Fin_X,Fin_Y,0); + + if (Direction & 0x80) + Direction=(Direction & 0x7F); + + Operation_PUSH(Direction); // Valeur bidon servant de nouvel ‚tat de pile + Operation_PUSH(Direction); + Operation_PUSH(Couleur); + + Tracer_ligne_Preview_xor(Debut_X,Debut_Y,Pinceau_X,Pinceau_Y,0); + + if (Polyfill_Nombre_de_points1)?Debut_X+(Brosse_Largeur>>1)-1:1; + Hauteur=(Brosse_Hauteur>1)?Debut_Y+(Brosse_Hauteur>>1)-1:1; + break; + case 'X': // Moiti‚ X + Largeur=(Brosse_Largeur>1)?Debut_X+(Brosse_Largeur>>1)-1:1; + Hauteur=Debut_Y+Brosse_Hauteur-1; + break; + case 'Y': // Moiti‚ Y + Largeur=Debut_X+Brosse_Largeur-1; + Hauteur=(Brosse_Hauteur>1)?Debut_Y+(Brosse_Hauteur>>1)-1:1; + break; + case 'n': // Normal + Largeur=Debut_X+Brosse_Largeur-1; + Hauteur=Debut_Y+Brosse_Hauteur-1; + break; + default : + Changement_de_taille=0; + } + } + else + Changement_de_taille=0; + + if (Changement_de_taille) + { + Operation_Taille_pile-=2; + Operation_PUSH(Largeur); + Operation_PUSH(Hauteur); + Operation_PUSH(Debut_X); + Operation_PUSH(Debut_Y); + Operation_PUSH(Largeur); + Operation_PUSH(Hauteur); + } + else + { + Operation_PUSH(Debut_X); + Operation_PUSH(Debut_Y); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + Operation_Taille_pile++; + } +} + + +void Etirer_brosse_12_8(void) +// +// Op‚ration : OPERATION_ETIRER_BROSSE +// Click Souris: 0 +// Taille_Pile : 8 +// +// Souris effac‚e: Oui +// +{ + short Calcul_X; + short Calcul_Y; + short Debut_X; + short Debut_Y; + + + Operation_Taille_pile--; + + if (Mouse_K==A_DROITE) + { + Operation_Taille_pile-=2; + Operation_POP(&Debut_Y); + Operation_POP(&Debut_X); + Operation_POP(&Calcul_Y); + Operation_POP(&Calcul_X); + Operation_Taille_pile--; + + // On efface la preview de la brosse (et la croix) + Afficher_ecran(); + + // Et enfin on stocke pour de bon la nouvelle brosse ‚tir‚e + Etirer_Brosse(Debut_X,Debut_Y,Calcul_X,Calcul_Y); + + // Simuler l'appui du bouton "Dessin" + + // Comme l'enclenchement du bouton efface le curseur, il faut l'afficher au + // pr‚alable: + Afficher_curseur(); + // !!! Efface la croix puis affiche le viseur !!! + Enclencher_bouton(BOUTON_DESSIN,A_GAUCHE); // D‚senclenche au passage le bouton brosse + if (Config.Auto_discontinuous) + { + // On se place en mode Dessin discontinu … la main + while (Operation_en_cours!=OPERATION_DESSIN_DISCONTINU) + Enclencher_bouton(BOUTON_DESSIN,A_DROITE); + } + // Maintenant, il faut r‚effacer le curseur parce qu'il sera raffich‚ en fin + // d'appel … cette action: + Effacer_curseur(); + + // On passe en brosse couleur: + Changer_la_forme_du_pinceau(FORME_PINCEAU_BROSSE_COULEUR); + + if ((Config.Coords_rel) && (Menu_visible)) + Print_dans_menu("X: Y:",0); + Print_coordonnees(); + } +} + + +//////////////////////////////////////////////////////////// OPERATION_SCROLL + + +byte Cacher_curseur_avant_scroll; + +void Scroll_12_0(void) +// +// Op‚ration : OPERATION_SCROLL +// Click Souris: 1 ou 2 +// Taille_Pile : 0 +// +// Souris effac‚e: Oui +// +{ + Initialiser_debut_operation(); + Backup(); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + Cacher_curseur_avant_scroll=Cacher_curseur; + Cacher_curseur=1; + if ((Config.Coords_rel) && (Menu_visible)) + Print_dans_menu("X:ñ 0 Y:ñ 0",0); +} + + +void Scroll_12_4(void) +// +// Op‚ration : OPERATION_SCROLL +// Click Souris: 1 ou 2 +// Taille_Pile : 4 +// +// Souris effac‚e: Non +// +{ + short Centre_X; + short Centre_Y; + short Pos_X; + short Pos_Y; + short Decalage_X; + short Decalage_Y; + char Chaine[5]; + + Operation_POP(&Pos_Y); + Operation_POP(&Pos_X); + Operation_POP(&Centre_Y); + Operation_POP(&Centre_X); + + if ( (Pinceau_X!=Pos_X) || (Pinceau_Y!=Pos_Y) ) + { + // L'utilisateur a boug‚, il faut scroller l'image + + if (Pinceau_X>=Centre_X) + Decalage_X=(Pinceau_X-Centre_X)%Principal_Largeur_image; + else + Decalage_X=Principal_Largeur_image-((Centre_X-Pinceau_X)%Principal_Largeur_image); + + if (Pinceau_Y>=Centre_Y) + Decalage_Y=(Pinceau_Y-Centre_Y)%Principal_Hauteur_image; + else + Decalage_Y=Principal_Hauteur_image-((Centre_Y-Pinceau_Y)%Principal_Hauteur_image); + + Aff_coords_rel_ou_abs(Centre_X,Centre_Y); + + Scroll_picture(Decalage_X,Decalage_Y); + + Afficher_ecran(); + } + + Operation_PUSH(Centre_X); + Operation_PUSH(Centre_Y); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); +} + +void Scroll_0_4(void) +// +// Op‚ration : OPERATION_SCROLL +// Click Souris: 0 +// Taille_Pile : 4 +// +// Souris effac‚e: Oui +// +{ + Operation_Taille_pile-=4; + Cacher_curseur=Cacher_curseur_avant_scroll; + if ((Config.Coords_rel) && (Menu_visible)) + { + Print_dans_menu("X: Y: ",0); + Print_coordonnees(); + } +} + + +//////////////////////////////////////////////////// OPERATION_CERCLE_DEGRADE + + +void Cercle_degrade_12_0(void) +// +// Op‚ration : OPERATION_CERCLE_DEGRADE +// Click Souris: 1 ou 2 +// Taille_Pile : 0 +// +// Souris effac‚e: Oui +{ + byte Couleur; + + Initialiser_debut_operation(); + Backup(); + + Shade_Table=(Mouse_K==A_GAUCHE)?Shade_Table_gauche:Shade_Table_droite; + Couleur=(Mouse_K==A_GAUCHE)?Fore_color:Back_color; + + Cacher_pinceau_avant_operation=Cacher_pinceau; + Cacher_pinceau=1; + + Pixel_figure_Preview(Pinceau_X,Pinceau_Y,Couleur); + + if ((Config.Coords_rel) && (Menu_visible)) + Print_dans_menu("Radius: 0 ",0); + + Operation_PUSH(Mouse_K); + Operation_PUSH(Couleur); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); +} + + +void Cercle_degrade_12_6(void) +// +// Op‚ration : OPERATION_CERCLE_DEGRADE +// Click Souris: 1 ou 2 +// Taille_Pile : 6 (Mouse_K, Couleur, X_Centre, Y_Centre, X_Tangente, Y_Tangente) +// +// Souris effac‚e: Non +// +{ + short Tangente_X; + short Tangente_Y; + short Centre_X; + short Centre_Y; + short Couleur; + short Rayon; + char Chaine[5]; + + Operation_POP(&Tangente_Y); + Operation_POP(&Tangente_X); + Operation_POP(&Centre_Y); + Operation_POP(&Centre_X); + Operation_POP(&Couleur); + + if ( (Tangente_X!=Pinceau_X) || (Tangente_Y!=Pinceau_Y) ) + { + Effacer_curseur(); + if ((Config.Coords_rel) && (Menu_visible)) + { + Num2str(Distance(Centre_X,Centre_Y,Pinceau_X,Pinceau_Y),Chaine,4); + Print_dans_menu(Chaine,7); + } + else + Print_coordonnees(); + + Cercle_Limite=((Tangente_X-Centre_X)*(Tangente_X-Centre_X))+ + ((Tangente_Y-Centre_Y)*(Tangente_Y-Centre_Y)); + Rayon=sqrt(Cercle_Limite); + Effacer_cercle_vide_Preview(Centre_X,Centre_Y,Rayon); + + Cercle_Limite=((Pinceau_X-Centre_X)*(Pinceau_X-Centre_X))+ + ((Pinceau_Y-Centre_Y)*(Pinceau_Y-Centre_Y)); + Rayon=sqrt(Cercle_Limite); + Tracer_cercle_vide_Preview(Centre_X,Centre_Y,Rayon,Couleur); + + Afficher_curseur(); + } + + Operation_PUSH(Couleur); + Operation_PUSH(Centre_X); + Operation_PUSH(Centre_Y); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); +} + + +void Cercle_degrade_0_6(void) +// +// Op‚ration : OPERATION_CERCLE_DEGRADE +// Click Souris: 0 +// Taille_Pile : 6 (Mouse_K, Couleur, X_Centre, Y_Centre, X_Tangente, Y_Tangente) +// +// Souris effac‚e: Oui +// +{ + short Tangente_X; + short Tangente_Y; + short Centre_X; + short Centre_Y; + short Couleur; + short Click; + short Rayon; + + Operation_POP(&Tangente_Y); + Operation_POP(&Tangente_X); + Operation_POP(&Centre_Y); + Operation_POP(&Centre_X); + + Operation_POP(&Couleur); + Operation_POP(&Click); + + if (Click==A_GAUCHE) + { + Operation_PUSH(Click); + Operation_PUSH(Couleur); + + Operation_PUSH(Centre_X); + Operation_PUSH(Centre_Y); + Operation_PUSH(Tangente_X); + Operation_PUSH(Tangente_Y); + + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + + // On change la forme du curseur + Forme_curseur=FORME_CURSEUR_CIBLE_XOR; + + // On affiche une croix XOR au centre du cercle + Courbe_Tracer_croix(Centre_X,Centre_Y); + + if (Menu_visible) + { + if (Config.Coords_rel) + Print_dans_menu("X: Y:",0); + else + Print_dans_menu("X: Y: ",0); + Aff_coords_rel_ou_abs(Centre_X,Centre_Y); + } + } + else + { + Cercle_Limite=((Tangente_X-Centre_X)*(Tangente_X-Centre_X))+ + ((Tangente_Y-Centre_Y)*(Tangente_Y-Centre_Y)); + Rayon=sqrt(Cercle_Limite); + Effacer_cercle_vide_Preview(Centre_X,Centre_Y,Rayon); + + Cacher_pinceau=Cacher_pinceau_avant_operation; + Forme_curseur=FORME_CURSEUR_CIBLE; + + Tracer_cercle_plein(Centre_X,Centre_Y,Rayon,Back_color); + + if ((Config.Coords_rel) && (Menu_visible)) + { + Print_dans_menu("X: Y: ",0); + Print_coordonnees(); + } + } +} + + +void Cercle_degrade_12_8(void) +// +// Op‚ration : OPERATION_CERCLE_DEGRADE +// Click Souris: 0 +// Taille_Pile : 8 (Mouse_K, Couleur, X_Centre, Y_Centre, X_Tangente, Y_Tangente, Ancien_X, Ancien_Y) +// +// Souris effac‚e: Oui +// +{ + short Tangente_X; + short Tangente_Y; + short Centre_X; + short Centre_Y; + short Couleur; + short Ancien_Mouse_K; + + short Rayon; + + Operation_Taille_pile-=2; // On fait sauter les 2 derniers ‚lts de la pile + Operation_POP(&Tangente_Y); + Operation_POP(&Tangente_X); + Operation_POP(&Centre_Y); + Operation_POP(&Centre_X); + Operation_POP(&Couleur); + Operation_POP(&Ancien_Mouse_K); + + // On efface la croix XOR au centre du cercle + Courbe_Tracer_croix(Centre_X,Centre_Y); + + Cercle_Limite=((Tangente_X-Centre_X)*(Tangente_X-Centre_X))+ + ((Tangente_Y-Centre_Y)*(Tangente_Y-Centre_Y)); + Rayon=sqrt(Cercle_Limite); + Effacer_cercle_vide_Preview(Centre_X,Centre_Y,Rayon); + + Cacher_pinceau=Cacher_pinceau_avant_operation; + Forme_curseur=FORME_CURSEUR_CIBLE; + + if (Mouse_K==Ancien_Mouse_K) + Tracer_cercle_degrade(Centre_X,Centre_Y,Rayon,Pinceau_X,Pinceau_Y); + + Attendre_fin_de_click(); + + if ((Config.Coords_rel) && (Menu_visible)) + { + Print_dans_menu("X: Y: ",0); + Print_coordonnees(); + } +} + + +void Cercle_ou_ellipse_degrade_0_8(void) +// +// Op‚ration : OPERATION_{CERCLE|ELLIPSE}_DEGRADE +// Click Souris: 0 +// Taille_Pile : 8 +// +// Souris effac‚e: Non +// +{ + short Debut_X; + short Debut_Y; + short Tangente_X; + short Tangente_Y; + short Ancien_X; + short Ancien_Y; + + Operation_POP(&Ancien_Y); + Operation_POP(&Ancien_X); + + if ((Pinceau_X!=Ancien_X) || (Pinceau_Y!=Ancien_Y)) + { + Operation_POP(&Tangente_Y); + Operation_POP(&Tangente_X); + Operation_POP(&Debut_Y); + Operation_POP(&Debut_X); + Aff_coords_rel_ou_abs(Debut_X,Debut_Y); + Operation_PUSH(Debut_X); + Operation_PUSH(Debut_Y); + Operation_PUSH(Tangente_X); + Operation_PUSH(Tangente_Y); + } + + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); +} + + +////////////////////////////////////////////////// OPERATION_ELLIPSE_DEGRADEE + + +void Ellipse_degradee_12_0(void) +// +// Op‚ration : OPERATION_ELLIPSE_DEGRADEE +// Click Souris: 1 ou 2 +// Taille_Pile : 0 +// +// Souris effac‚e: Oui +{ + byte Couleur; + + Initialiser_debut_operation(); + Backup(); + + Shade_Table=(Mouse_K==A_GAUCHE)?Shade_Table_gauche:Shade_Table_droite; + Couleur=(Mouse_K==A_GAUCHE)?Fore_color:Back_color; + + Cacher_pinceau_avant_operation=Cacher_pinceau; + Cacher_pinceau=1; + + Pixel_figure_Preview(Pinceau_X,Pinceau_Y,Couleur); + + if ((Config.Coords_rel) && (Menu_visible)) + Print_dans_menu("X:ñ 0 Y:ñ 0",0); + + Operation_PUSH(Mouse_K); + Operation_PUSH(Couleur); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); +} + + +void Ellipse_degradee_12_6(void) +// +// Op‚ration : OPERATION_ELLIPSE_DEGRADEE +// Click Souris: 1 ou 2 +// Taille_Pile : 6 (Mouse_K, Couleur, X_Centre, Y_Centre, X_Tangente, Y_Tangente) +// +// Souris effac‚e: Non +// +{ + short Tangente_X; + short Tangente_Y; + short Centre_X; + short Centre_Y; + short Couleur; + short Rayon_horizontal; + short Rayon_vertical; + + Operation_POP(&Tangente_Y); + Operation_POP(&Tangente_X); + Operation_POP(&Centre_Y); + Operation_POP(&Centre_X); + Operation_POP(&Couleur); + + if ( (Tangente_X!=Pinceau_X) || (Tangente_Y!=Pinceau_Y) ) + { + Effacer_curseur(); + Aff_coords_rel_ou_abs(Centre_X,Centre_Y); + + Rayon_horizontal=(Tangente_X>Centre_X)?Tangente_X-Centre_X + :Centre_X-Tangente_X; + Rayon_vertical =(Tangente_Y>Centre_Y)?Tangente_Y-Centre_Y + :Centre_Y-Tangente_Y; + Effacer_ellipse_vide_Preview(Centre_X,Centre_Y,Rayon_horizontal,Rayon_vertical); + + Rayon_horizontal=(Pinceau_X>Centre_X)?Pinceau_X-Centre_X + :Centre_X-Pinceau_X; + Rayon_vertical =(Pinceau_Y>Centre_Y)?Pinceau_Y-Centre_Y + :Centre_Y-Pinceau_Y; + Tracer_ellipse_vide_Preview(Centre_X,Centre_Y,Rayon_horizontal,Rayon_vertical,Couleur); + + Afficher_curseur(); + } + + Operation_PUSH(Couleur); + Operation_PUSH(Centre_X); + Operation_PUSH(Centre_Y); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); +} + + +void Ellipse_degradee_0_6(void) +// +// Op‚ration : OPERATION_ELLIPSE_DEGRADEE +// Click Souris: 0 +// Taille_Pile : 6 (Mouse_K, Couleur, X_Centre, Y_Centre, X_Tangente, Y_Tangente) +// +// Souris effac‚e: Oui +// +{ + short Tangente_X; + short Tangente_Y; + short Centre_X; + short Centre_Y; + short Couleur; + short Click; + short Rayon; + short Rayon_horizontal; + short Rayon_vertical; + + Operation_POP(&Tangente_Y); + Operation_POP(&Tangente_X); + Operation_POP(&Centre_Y); + Operation_POP(&Centre_X); + + Operation_POP(&Couleur); + Operation_POP(&Click); + + if (Click==A_GAUCHE) + { + Operation_PUSH(Click); + Operation_PUSH(Couleur); + + Operation_PUSH(Centre_X); + Operation_PUSH(Centre_Y); + Operation_PUSH(Tangente_X); + Operation_PUSH(Tangente_Y); + + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + + // On change la forme du curseur + Forme_curseur=FORME_CURSEUR_CIBLE_XOR; + + // On affiche une croix XOR au centre du cercle + Courbe_Tracer_croix(Centre_X,Centre_Y); + + if (Menu_visible) + { + if (Config.Coords_rel) + Print_dans_menu("X: Y:",0); + else + Print_dans_menu("X: Y: ",0); + Aff_coords_rel_ou_abs(Centre_X,Centre_Y); + } + } + else + { + Rayon_horizontal=(Tangente_X>Centre_X)?Tangente_X-Centre_X + :Centre_X-Tangente_X; + Rayon_vertical =(Tangente_Y>Centre_Y)?Tangente_Y-Centre_Y + :Centre_Y-Tangente_Y; + Effacer_ellipse_vide_Preview(Centre_X,Centre_Y,Rayon_horizontal,Rayon_vertical); + + Cacher_pinceau=Cacher_pinceau_avant_operation; + Forme_curseur=FORME_CURSEUR_CIBLE; + + Tracer_ellipse_pleine(Centre_X,Centre_Y,Rayon_horizontal,Rayon_vertical,Back_color); + + if ((Config.Coords_rel) && (Menu_visible)) + { + Print_dans_menu("X: Y: ",0); + Print_coordonnees(); + } + } +} + + +void Ellipse_degradee_12_8(void) +// +// Op‚ration : OPERATION_ELLIPSE_DEGRADEE +// Click Souris: 0 +// Taille_Pile : 8 (Mouse_K, Couleur, X_Centre, Y_Centre, X_Tangente, Y_Tangente, Ancien_X, Ancien_Y) +// +// Souris effac‚e: Oui +// +{ + short Tangente_X; + short Tangente_Y; + short Centre_X; + short Centre_Y; + short Couleur; + short Rayon_horizontal; + short Rayon_vertical; + short Ancien_Mouse_K; + + Operation_Taille_pile-=2; // On fait sauter les 2 derniers ‚lts de la pile + Operation_POP(&Tangente_Y); + Operation_POP(&Tangente_X); + Operation_POP(&Centre_Y); + Operation_POP(&Centre_X); + Operation_POP(&Couleur); + Operation_POP(&Ancien_Mouse_K); + + // On efface la croix XOR au centre de l'ellipse + Courbe_Tracer_croix(Centre_X,Centre_Y); + + Rayon_horizontal=(Tangente_X>Centre_X)?Tangente_X-Centre_X + :Centre_X-Tangente_X; + Rayon_vertical =(Tangente_Y>Centre_Y)?Tangente_Y-Centre_Y + :Centre_Y-Tangente_Y; + Effacer_ellipse_vide_Preview(Centre_X,Centre_Y,Rayon_horizontal,Rayon_vertical); + + Cacher_pinceau=Cacher_pinceau_avant_operation; + Forme_curseur=FORME_CURSEUR_CIBLE; + + if (Mouse_K==Ancien_Mouse_K) + Tracer_ellipse_degradee(Centre_X,Centre_Y,Rayon_horizontal,Rayon_vertical,Pinceau_X,Pinceau_Y); + + Attendre_fin_de_click(); + + if ((Config.Coords_rel) && (Menu_visible)) + { + Print_dans_menu("X: Y: ",0); + Print_coordonnees(); + } +} + + +/////////////////////////////////////////////////// OPERATION_LIGNES_CENTREES + + +void Lignes_centrees_12_0(void) +// Op‚ration : OPERATION_LIGNES_CENTREES +// Click Souris: 1 ou 2 +// Taille_Pile : 0 +// +// Souris effac‚e: Oui +{ + Initialiser_debut_operation(); + Backup(); + Shade_Table=(Mouse_K==A_GAUCHE)?Shade_Table_gauche:Shade_Table_droite; + + if ((Config.Coords_rel) && (Menu_visible)) + Print_dans_menu("X:ñ 0 Y:ñ 0",0); + + Operation_PUSH(Mouse_K); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); +} + + +void Lignes_centrees_12_3(void) +// Op‚ration : OPERATION_LIGNES_CENTREES +// Click Souris: 1 ou 2 +// Taille_Pile : 3 +// +// Souris effac‚e: Non +{ + short Debut_X; + short Debut_Y; + + Operation_POP(&Debut_Y); + Operation_POP(&Debut_X); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); +} + + +void Lignes_centrees_0_3(void) +// Op‚ration : OPERATION_LIGNES_CENTREES +// Click Souris: 0 +// Taille_Pile : 3 +// +// Souris effac‚e: Oui +{ + short Debut_X; + short Debut_Y; + short Bouton; + short Couleur; + + Operation_POP(&Debut_Y); + Operation_POP(&Debut_X); + Operation_POP(&Bouton); + + Couleur=(Bouton==A_GAUCHE)?Fore_color:Back_color; + + Pixel_figure_Preview(Pinceau_X,Pinceau_Y,Couleur); + Pinceau_Forme_avant_operation=Pinceau_Forme; + Pinceau_Forme=FORME_PINCEAU_POINT; + + Operation_PUSH(Bouton); + Operation_PUSH(Pinceau_X); // Nouveau d‚but X + Operation_PUSH(Pinceau_Y); // Nouveau d‚but Y + Operation_PUSH(Pinceau_X); // Nouvelle derniŠre fin X + Operation_PUSH(Pinceau_Y); // Nouvelle derniŠre fin Y + Operation_PUSH(Pinceau_X); // Nouvelle derniŠre position X + Operation_PUSH(Pinceau_Y); // Nouvelle derniŠre position Y +} + + +void Lignes_centrees_12_7(void) +// Op‚ration : OPERATION_LIGNES_CENTREES +// Click Souris: 1 ou 2 +// Taille_Pile : 7 +// +// Souris effac‚e: Non +{ + short Bouton; + short Debut_X; + short Debut_Y; + short Fin_X; + short Fin_Y; + short Dernier_X; + short Dernier_Y; + short Couleur; + + Operation_POP(&Dernier_Y); + Operation_POP(&Dernier_X); + Operation_POP(&Fin_Y); + Operation_POP(&Fin_X); + Operation_POP(&Debut_Y); + Operation_POP(&Debut_X); + Operation_POP(&Bouton); + + if (Mouse_K==Bouton) + { + if ( (Fin_X!=Pinceau_X) || (Fin_Y!=Pinceau_Y) || + (Dernier_X!=Pinceau_X) || (Dernier_Y!=Pinceau_Y) ) + { + Effacer_curseur(); + + Couleur=(Bouton==A_GAUCHE)?Fore_color:Back_color; + + Pinceau_Forme=Pinceau_Forme_avant_operation; + + Pixel_figure_Preview (Debut_X,Debut_Y,Lit_pixel_dans_ecran_courant(Debut_X,Debut_Y)); + Effacer_ligne_Preview (Debut_X,Debut_Y,Dernier_X,Dernier_Y); + + Smear_Debut=1; + Afficher_pinceau (Debut_X,Debut_Y,Couleur,0); + Tracer_ligne_Definitif(Debut_X,Debut_Y,Pinceau_X,Pinceau_Y,Couleur); + + Pinceau_Forme=FORME_PINCEAU_POINT; + Pixel_figure_Preview(Pinceau_X,Pinceau_Y,Couleur); + Tracer_ligne_Preview(Debut_X,Debut_Y,Pinceau_X,Pinceau_Y,Couleur); + + Afficher_curseur(); + } + + Operation_PUSH(Bouton); + Operation_PUSH(Debut_X); + Operation_PUSH(Debut_Y); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); + } + else + { + Effacer_curseur(); + + Pinceau_Forme=Pinceau_Forme_avant_operation; + + Pixel_figure_Preview (Debut_X,Debut_Y,Lit_pixel_dans_ecran_courant(Debut_X,Debut_Y)); + Effacer_ligne_Preview (Debut_X,Debut_Y,Dernier_X,Dernier_Y); + + if ( (Config.Coords_rel) && (Menu_visible) ) + { + Print_dans_menu("X: Y: ",0); + Print_coordonnees(); + } + + Afficher_curseur(); + + Attendre_fin_de_click(); + } +} + + +void Lignes_centrees_0_7(void) +// Op‚ration : OPERATION_LIGNES_CENTREES +// Click Souris: 0 +// Taille_Pile : 7 +// +// Souris effac‚e: Non +{ + short Bouton; + short Debut_X; + short Debut_Y; + short Fin_X; + short Fin_Y; + short Dernier_X; + short Dernier_Y; + short Couleur; + + Operation_POP(&Dernier_Y); + Operation_POP(&Dernier_X); + Operation_POP(&Fin_Y); + Operation_POP(&Fin_X); + + if ((Pinceau_X!=Dernier_X) || (Pinceau_Y!=Dernier_Y)) + { + Effacer_curseur(); + Operation_POP(&Debut_Y); + Operation_POP(&Debut_X); + Operation_POP(&Bouton); + + Couleur=(Bouton==A_GAUCHE)?Fore_color:Back_color; + + Aff_coords_rel_ou_abs(Debut_X,Debut_Y); + + Effacer_ligne_Preview(Debut_X,Debut_Y,Dernier_X,Dernier_Y); + + Pixel_figure_Preview(Debut_X,Debut_Y,Couleur); + Tracer_ligne_Preview(Debut_X,Debut_Y,Pinceau_X,Pinceau_Y,Couleur); + + Operation_PUSH(Bouton); + Operation_PUSH(Debut_X); + Operation_PUSH(Debut_Y); + Afficher_curseur(); + } + + Operation_PUSH(Fin_X); + Operation_PUSH(Fin_Y); + Operation_PUSH(Pinceau_X); + Operation_PUSH(Pinceau_Y); +} + + diff --git a/Anciens fichiers/vesahigh.c b/Anciens fichiers/vesahigh.c new file mode 100644 index 00000000..811a8665 --- /dev/null +++ b/Anciens fichiers/vesahigh.c @@ -0,0 +1,202 @@ +#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 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 new file mode 100644 index 00000000..43a805e6 --- /dev/null +++ b/Anciens fichiers/vesalfb.h @@ -0,0 +1,113 @@ + +#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 new file mode 100644 index 00000000..7430aeed --- /dev/null +++ b/Anciens fichiers/video.asm @@ -0,0 +1,6903 @@ +.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 new file mode 100644 index 00000000..6790f8e9 --- /dev/null +++ b/Anciens fichiers/video.h @@ -0,0 +1,90 @@ +#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); diff --git a/GrafX.cbp b/GrafX.cbp new file mode 100644 index 00000000..154462db --- /dev/null +++ b/GrafX.cbp @@ -0,0 +1,365 @@ + + + + + + diff --git a/GrafX.depend b/GrafX.depend new file mode 100644 index 00000000..2891d316 --- /dev/null +++ b/GrafX.depend @@ -0,0 +1,333 @@ +# depslib dependency file v1.0 +1176573750 source:/home/pulkomandy/Projects/GFX2_SRC/aide.c + + "const.h" + "struct.h" + "global.h" + "divers.h" + "graph.h" + "moteur.h" + + + +1176566963 /home/pulkomandy/Projects/GFX2_SRC/const.h + +1176561067 /home/pulkomandy/Projects/GFX2_SRC/struct.h + "const.h" + +1176580114 /home/pulkomandy/Projects/GFX2_SRC/global.h + + "struct.h" + "loadsave.h" + +940692956 /home/pulkomandy/Projects/GFX2_SRC/loadsave.h + +898300360 /home/pulkomandy/Projects/GFX2_SRC/divers.h + +1176563251 /home/pulkomandy/Projects/GFX2_SRC/graph.h + +1176549546 /home/pulkomandy/Projects/GFX2_SRC/moteur.h + +1176573039 source:/home/pulkomandy/Projects/GFX2_SRC/boutons.c + "const.h" + "struct.h" + "global.h" + "divers.h" + "graph.h" + "moteur.h" + "readline.h" + "files.h" + "loadsave.h" + "init.h" + + + "boutons.h" + "operatio.h" + + + + + "shade.c" + +898300360 /home/pulkomandy/Projects/GFX2_SRC/readline.h + +1176552986 /home/pulkomandy/Projects/GFX2_SRC/files.h + +1176553118 /home/pulkomandy/Projects/GFX2_SRC/init.h + "readini.h" + "saveini.h" + +898300360 /home/pulkomandy/Projects/GFX2_SRC/readini.h + +898300360 /home/pulkomandy/Projects/GFX2_SRC/saveini.h + +1176554162 /home/pulkomandy/Projects/GFX2_SRC/boutons.h + +945641428 /home/pulkomandy/Projects/GFX2_SRC/operatio.h + +1176579600 /home/pulkomandy/Projects/GFX2_SRC/shade.c + "global.h" + "graph.h" + +1176556780 source:/home/pulkomandy/Projects/GFX2_SRC/files.c + "const.h" + "struct.h" + "global.h" + "graph.h" + "divers.h" + + + + + + + + + + "linux.h" + +1176552205 /home/pulkomandy/Projects/GFX2_SRC/linux.h + +1176571401 source:/home/pulkomandy/Projects/GFX2_SRC/graph.c + "sdlscreen.h" + "graph.h" + "divers.h" + + + + + + "moteur.h" + "boutons.h" + "pages.h" + "global.h" + "pages.c" + +1176559031 /home/pulkomandy/Projects/GFX2_SRC/video.h + "struct.h" + +1176548808 /home/pulkomandy/Projects/GFX2_SRC/vesalfb.h + "struct.h" + "global.h" + +1176561017 /home/pulkomandy/Projects/GFX2_SRC/pages.h + +1176561064 /home/pulkomandy/Projects/GFX2_SRC/pages.c + + + + "linux.h" + "global.h" + "pages.h" + "graph.h" + +1176568608 source:/home/pulkomandy/Projects/GFX2_SRC/init.c + + "const.h" + "struct.h" + "global.h" + "modesvdo.h" + "graph.h" + "boutons.h" + "palette.h" + "aide.h" + "operatio.h" + + + + + + + + "divers.h" + "readini.c" + "saveini.c" + +898300360 /home/pulkomandy/Projects/GFX2_SRC/modesvdo.h + +898300360 /home/pulkomandy/Projects/GFX2_SRC/palette.h + +941312106 /home/pulkomandy/Projects/GFX2_SRC/aide.h + +1176548158 /home/pulkomandy/Projects/GFX2_SRC/readini.c + + "const.h" + "global.h" + +1176555965 /home/pulkomandy/Projects/GFX2_SRC/saveini.c + + "const.h" + "global.h" + +1176539011 source:/home/pulkomandy/Projects/GFX2_SRC/linux.c + + +1176562607 source:/home/pulkomandy/Projects/GFX2_SRC/loadsave.c + "const.h" + "struct.h" + "global.h" + "graph.h" + "divers.h" + "pages.h" + "op_c.h" + + + + + + + "boutons.h" + +944346298 /home/pulkomandy/Projects/GFX2_SRC/op_c.h + "struct.h" + +1176571151 source:/home/pulkomandy/Projects/GFX2_SRC/main.c + "const.h" + "struct.h" + "global.h" + "graph.h" + "divers.h" + "init.h" + "boutons.h" + "moteur.h" + + + + + + + + "linux.h" + "pages.h" + "files.h" + "loadsave.h" + "sdlscreen.h" + +1176562163 /home/pulkomandy/Projects/GFX2_SRC/vesahigh.c + + "vesalfb.h" + +1176562627 source:/home/pulkomandy/Projects/GFX2_SRC/moteur.c + "const.h" + "struct.h" + "global.h" + "graph.h" + "divers.h" + "special.h" + + + + "linux.h" + "boutons.h" + "operatio.h" + "shade.h" + +898300360 /home/pulkomandy/Projects/GFX2_SRC/special.h + +1176553647 /home/pulkomandy/Projects/GFX2_SRC/shade.h + +1176546236 source:/home/pulkomandy/Projects/GFX2_SRC/op_c.c + + + + + "op_c.h" + "op_asm.h" + +944346460 /home/pulkomandy/Projects/GFX2_SRC/op_asm.h + "op_c.h" + +976376552 source:/home/pulkomandy/Projects/GFX2_SRC/operatio.c + + "const.h" + "struct.h" + "global.h" + "divers.h" + "moteur.h" + "graph.h" + "operatio.h" + +1176561064 source:/home/pulkomandy/Projects/GFX2_SRC/pages.c + + + + "linux.h" + "global.h" + "pages.h" + "graph.h" + +940768894 source:/home/pulkomandy/Projects/GFX2_SRC/palette.c + + "const.h" + "struct.h" + "global.h" + "divers.h" + "graph.h" + "moteur.h" + "readline.h" + +1176548158 source:/home/pulkomandy/Projects/GFX2_SRC/readini.c + + "const.h" + "global.h" + +898300360 source:/home/pulkomandy/Projects/GFX2_SRC/readline.c + "const.h" + "struct.h" + "global.h" + "graph.h" + "divers.h" + +1176555965 source:/home/pulkomandy/Projects/GFX2_SRC/saveini.c + + "const.h" + "global.h" + +1176579600 source:/home/pulkomandy/Projects/GFX2_SRC/shade.c + "global.h" + "graph.h" + +898300360 source:/home/pulkomandy/Projects/GFX2_SRC/special.c + "const.h" + "struct.h" + "global.h" + "graph.h" + "moteur.h" + + +1176552028 source:/home/pulkomandy/Projects/GFX2_SRC/testvesa/testvesa.c + + + + "vesa.h" + +870946826 /home/pulkomandy/Projects/GFX2_SRC/testvesa/vesa.h + +1176562163 source:/home/pulkomandy/Projects/GFX2_SRC/vesahigh.c + + "vesalfb.h" + +1176564725 source:/home/pulkomandy/Projects/GFX2_SRC/vesalfb.c + +1176579529 /home/pulkomandy/Projects/GFX2_SRC/sdlscreen.h + + "struct.h" + +1176551535 source:/home/pulkomandy/Projects/GFX2_SRC/oper_bak.c + + "const.h" + "struct.h" + "global.h" + "divers.h" + "moteur.h" + "graph.h" + "operatio.h" + + + +1176579531 source:/home/pulkomandy/Projects/GFX2_SRC/divers.c + + "struct.h" + "sdlscreen.h" + "global.h" + diff --git a/GrafX.layout b/GrafX.layout new file mode 100644 index 00000000..5de9dddb --- /dev/null +++ b/GrafX.layout @@ -0,0 +1,31 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/aide.c b/aide.c new file mode 100644 index 00000000..3ecf4c8f --- /dev/null +++ b/aide.c @@ -0,0 +1,289 @@ +#include +#include "const.h" +#include "struct.h" +#include "global.h" +#include "divers.h" +#include "graph.h" +#include "moteur.h" + +#include + +#include + +// -- Menu d'aide ----------------------------------------------------------- + +void Afficher_aide(void) +{ + byte * Curseur; + byte * Curseur_initial; + word Debut_de_fonte; + short X; // Indices d'affichage d'un caractŠre + short Y; + short Position_X; // Parcours de remplissage du buffer de ligne + short Indice_de_ligne; // 0-15 (16 lignes de textes) + short Indice_de_caractere; // Parcours des caractŠres d'une ligne + short Ligne_de_depart=Position_d_aide_en_cours; + short Longueur_de_ligne; // Longueur en char d'une ligne de texte + short Repeat_Menu_Facteur_X; + short Repeat_Menu_Facteur_Y; + short Pos_Reel_X; + short Pos_Reel_Y; + short Largeur; // Largeur physique d'une ligne de texte + + Pos_Reel_X=Fenetre_Pos_X+(13*Menu_Facteur_X); + Pos_Reel_Y=Fenetre_Pos_Y+(19*Menu_Facteur_Y); + + for (Curseur=Table_d_aide[Section_d_aide_en_cours].Debut_de_la_liste; + Ligne_de_depart>0; + Ligne_de_depart--) + Curseur+=( (*Curseur) & 0x7F )+1; + + for (Indice_de_ligne=0;Indice_de_ligne<16;Indice_de_ligne++) + { + // On affiche la ligne + Debut_de_fonte =((*Curseur) & 0x80)?147:0; + Indice_de_caractere=((*Curseur) & 0x7F); + Curseur++; + + Curseur_initial=Curseur; + Longueur_de_ligne=Indice_de_caractere; + Largeur=Longueur_de_ligne*Menu_Facteur_X*6; + + // Pour chaque ligne dans la fenˆtre: + for (Y=0;Y<8;Y++) + { + Curseur=Curseur_initial; + Position_X=0; + + // On cr‚e une nouvelle ligne … splotcher + for (Indice_de_caractere=0;Indice_de_caracterePosition=Position_d_aide_en_cours; + Calculer_hauteur_curseur_jauge(Fenetre_Liste_boutons_scroller); + Fenetre_Dessiner_jauge(Fenetre_Liste_boutons_scroller); + Afficher_aide(); + Afficher_curseur(); +} + + +void Bouton_Aide(void) +{ + short Bouton_clicke; + short Nb_lignes=Table_d_aide[Section_d_aide_en_cours].Nombre_de_lignes; + + Ouvrir_fenetre(310,175,"Help / About..."); + + // dessiner de la fenˆtre o— va d‚filer le texte + Fenetre_Afficher_cadre_creux(8,17,274,132); + Block(Fenetre_Pos_X+(Menu_Facteur_X*9), + Fenetre_Pos_Y+(Menu_Facteur_Y*18), + Menu_Facteur_X*272,Menu_Facteur_Y*130,CM_Noir); + + Fenetre_Definir_bouton_normal(266,153,35,14,"Exit",0,1,0x0001); // 1 + Fenetre_Definir_bouton_scroller(290,18,130,Nb_lignes, + 16,Position_d_aide_en_cours); // 2 + + Fenetre_Definir_bouton_normal( 9,154, 59,14,"Credits" ,1,1,0x002E); // 3 + Fenetre_Definir_bouton_normal( 71,154, 75,14,"Register?",1,1,0x0013); // 4 + Fenetre_Definir_bouton_normal(149,154, 75,14,"Greetings",1,1,0x0022); // 5 + + Afficher_aide(); + + Afficher_curseur(); + + do + { + Bouton_clicke=Fenetre_Bouton_clicke(); + + switch (Bouton_clicke) + { + case -1: + case 0: + case 1: + break; + default: + Effacer_curseur(); + if (Bouton_clicke>2) + { + Section_d_aide_en_cours=Bouton_clicke-3; + Position_d_aide_en_cours=0; + Nb_lignes=Table_d_aide[Section_d_aide_en_cours].Nombre_de_lignes; + Fenetre_Liste_boutons_scroller->Position=0; + Fenetre_Liste_boutons_scroller->Nb_elements=Nb_lignes; + Calculer_hauteur_curseur_jauge(Fenetre_Liste_boutons_scroller); + Fenetre_Dessiner_jauge(Fenetre_Liste_boutons_scroller); + } + else + Position_d_aide_en_cours=Fenetre_Attribut2; + + Afficher_aide(); + Afficher_curseur(); + } + + + // Gestion des touches de d‚placement dans la liste + switch (Touche) + { + case 0x0048 : // Haut + if (Position_d_aide_en_cours>0) + Position_d_aide_en_cours--; + Scroller_aide(); + break; + case 0x0050 : // Bas + if (Position_d_aide_en_cours15) + Position_d_aide_en_cours-=15; + else + Position_d_aide_en_cours=0; + Scroller_aide(); + break; + case 0x0051 : // PageDown + if (Position_d_aide_en_coursf_bfree; + if (Taille>=0) + { + sprintf(Buffer,"%d bytes",Taille); + Print_dans_fenetre(146,51,Buffer,STATS_COULEUR_DONNEES,CM_Noir); + } + else + Print_dans_fenetre(146,51,"* Error *",STATS_COULEUR_DONNEES,CM_Noir); + + // Affichage des informations sur l'image + Print_dans_fenetre(10,67,"Picture info.:",STATS_COULEUR_TITRES,CM_Noir); + + // Affichage des dimensions de l'image + Print_dans_fenetre(18,75,"Dimensions :",STATS_COULEUR_TITRES,CM_Noir); + sprintf(Buffer,"%dx%d",Principal_Largeur_image,Principal_Hauteur_image); + Print_dans_fenetre(122,75,Buffer,STATS_COULEUR_DONNEES,CM_Noir); + + // Affichage du nombre de couleur utilis‚ + Print_dans_fenetre(18,83,"Colors used:",STATS_COULEUR_TITRES,CM_Noir); + sprintf(Buffer,"%d",Palette_Compter_nb_couleurs_utilisees(Utilisation_couleur)); + Print_dans_fenetre(122,83,Buffer,STATS_COULEUR_DONNEES,CM_Noir); + + // Affichage des dimensions de l'‚cran + Print_dans_fenetre(10,99,"Resolution:",STATS_COULEUR_TITRES,CM_Noir); + sprintf(Buffer,"%dx%d",Largeur_ecran,Hauteur_ecran); + Print_dans_fenetre(106,99,Buffer,STATS_COULEUR_DONNEES,CM_Noir); + + // Affichage des infos VESA + Print_dans_fenetre(10,115,"VESA info.:",STATS_COULEUR_TITRES,CM_Noir); + if (((VESA_Version_Unite*10)+VESA_Version_Decimale)>=12) + { + Print_dans_fenetre(18,123,"Version :",STATS_COULEUR_TITRES,CM_Noir); + sprintf(Buffer,"%d.%d",VESA_Version_Unite,VESA_Version_Decimale); + Print_dans_fenetre(106,123,Buffer,STATS_COULEUR_DONNEES,CM_Noir); + + Print_dans_fenetre(18,131,"Manufact.:",STATS_COULEUR_TITRES,CM_Noir); + strncpy(Buffer,VESA_Constructeur,TAILLE_NOM_CONSTRUCTEUR); + Buffer[TAILLE_NOM_CONSTRUCTEUR]='\0'; + Print_dans_fenetre(106,131,Buffer,STATS_COULEUR_DONNEES,CM_Noir); + + Print_dans_fenetre(18,139,"Memory :",STATS_COULEUR_TITRES,CM_Noir); + sprintf(Buffer,"%d Kb",VESA_Taille_memoire*64); + Print_dans_fenetre(106,139,Buffer,STATS_COULEUR_DONNEES,CM_Noir); + } + else + Print_dans_fenetre(106,115,"* No VESA support *",STATS_COULEUR_DONNEES,CM_Noir); + + + Afficher_curseur(); + + do + { + Bouton_clicke=Fenetre_Bouton_clicke(); + } + while ( (Bouton_clicke!=1) && (Touche!=0x001C) ); + + Fermer_fenetre(); + Desenclencher_bouton(BOUTON_AIDE); + Afficher_curseur(); +}