Forum Graph100

[b]
void BpixL(int px, int py) // Met un pixel noir à (px,py)
{
    asm{
        mov bx,px         // _BX = px;    On met l’abscisse px dans _BX
        mov si,py         // _SI = py;    On met l’ordonnée py dans _SI
        shl si,4        // _SI *= 16;     Une ligne mesure 16 octet (128bit). _si pointe vers la bonne ligne
        mov cl,bl         // _CL = _BL;     _BX : [0;128[ On peut donc se contenter de _BL.
        shr bl,3          // _BL /= 8;     Pour savoir quel Bit des 8 est allumé
        and cl,7          // _CL %= 8;     On garde les 3 derniers bit de _CL, c’est le reste de la division 7 = b000 0111
        add si,bx         // _SI += _BX;     _SI pointe vers le bon octet (16*y+x)
        db 0x0F,0x14,0x0C7     // set1 _BH,_CL Allume le _CLieme bit de _BH (qui était nul jusque la)
        or es:[si],bh         //         On place _BH en mémoire vidéo (couche 1 : 1A20) en prenant soin de ne pas effacer les autres  |____>   2 Bits allumés -> Noir
        add si,0x0800        //         On passe à la 2è couche
        or es:[si],bh       //         On place _BH en mémoire vidéo (couche 2 : 1AA0) en prenant soin de ne pas effacer les autres  |    >
    }
}
void GpixL(int px, int py) // Met un pixel gris à (px,py) (sauf si (px,py) est noir)
{
    asm{
        mov bx,px         // _BX = px;    On met l’abscisse px dans _BX
        mov si,py         // _SI = py;    On met l’ordonnée py dans _SI
        shl si,4        // _SI *= 16;     Une ligne mesure 16 octet (128bit). _si pointe vers la bonne ligne
        mov cl,bl         // _CL = _BL;     _BX : [0;128[ On peut donc se contenter de _BL.
        shr bl,3          // _BL /= 8;     Pour savoir quel Bit des 8 est allumé
        and cl,7          // _CL %= 8;     On garde les 3 derniers bit de _CL, c’est le reste de la division 7 = b000 0111
        add si,bx         // _SI += _BX;     _SI pointe vers le bon octet (16*y+x)
        db 0x0F,0x14,0x0C7     // set1 _BH,_CL Allume le _CLieme bit de _BH (qui était nul jusque la)
        or es:[si],bh         //         On place _BH en mémoire vidéo (couche 1 : 1A20) en prenant soin de ne pas effacer les autres  |---->   1 Bits allumé -> Gris
    }
}

void WpixL(int px, int py) // Met un pixel blanc à (px,py)
{
    asm{
        mov bx,px         // _BX = px;    On met l’abscisse px dans _BX
        mov si,py         // _SI = py;    On met l’ordonnée py dans _SI
        shl si,4        // _SI *= 16;     Une ligne mesure 16 octet (128bit). _si pointe vers la bonne ligne
        mov cl,bl         // _CL = _BL;     _BX : [0;128[ On peut donc se contenter de _BL.
        shr bl,3          // _BL /= 8;     Pour savoir quel Bit des 8 est allumé
        and cl,7          // _CL %= 8;     On garde les 3 derniers bit de _CL, c’est le reste de la division 7 = b000 0111
        add si,bx         // _SI += _BX;     _SI pointe vers le bon octet (16*y+x)
        mov bh,0xFF        // _BL = 0xFF;  Allume tout les bits de _BL
        db 0x0F,0x12,0x0C7    // clr1 _BH,_CL éteint le _CLième bit de _BH. (qui était allumé jusque la)
        and es:[si],bh        //         On place _BH en mémoire vidéo (couche 1 : 1A20) en prenant soin de ne pas effacer les autres  |____>   0 Bits allumés -> Blanc
        add si,0x0800        //         On passe à la 2è couche
        and es:[si],bh        //         On place _BH en mémoire vidéo (couche 2 : 1AA0) en prenant soin de ne pas effacer les autres  |    >

    }
}

void GpixL2(int px, int py) // Met un pixel gris à (px,py)
{
    asm{
        mov bx,px         // _BX = px;    On met l’abscisse px dans _BX
        mov si,py         // _SI = py;    On met l’ordonnée py dans _SI
        shl si,4        // _SI *= 16;     Une ligne mesure 16 octet (128bit). _si pointe vers la bonne ligne
        mov cl,bl         // _CL = _BL;     _BX : [0;128[ On peut donc se contenter de _BL.
        shr bl,3          // _BL /= 8;     Pour savoir quel Bit des 8 est allumé
        and cl,7          // _CL %= 8;     On garde les 3 derniers bit de _CL, c’est le reste de la division 7 = b000 0111
        add si,bx         // _SI += _BX;     _SI pointe vers le bon octet (16*y+x)
        db 0x0F,0x14,0x0C7     // set1 _BH,_CL Allume le _CLieme bit de _BH (qui était nul jusque la)
        or es:[si],bh         //         On place _BH en mémoire vidéo (couche 1 : 1A20) en prenant soin de ne pas effacer les autres  |    >
        mov bh,0xFF        // _BL = 0xFF;  Allume tout les bits de _BL
        db 0x0F,0x12,0x0C7    // clr1 _BH,_CL éteint le _CLième bit de _BH. (qui était nul jusque la)                          |----> 1 Bits allumé -> Gris
        add si,0x0800        //         On passe à la 2è couche
        and es:[si],bh        //         On place _BH en mémoire vidéo (couche 2 : 1AA0) en prenant soin de ne pas effacer les autres  |    >
    }
}
int TstpixL(int px, int py) 
{
    unsigned char coul = 0;
    asm{
        mov bx,px         // _BX = px;    On met l’abscisse px dans _BX
        mov si,py         // _SI = py;    On met l’ordonnée py dans _SI
        shl si,4        // _SI *= 16;     Une ligne mesure 16 octet (128bit). _si pointe vers la bonne ligne
        mov cl,bl         // _CL = _BL;     _BX : [0;128[ On peut donc se contenter de _BL.
        shr bl,3          // _BL /= 8;     Pour savoir quel Bit des 8 est allumé
        and cl,7          // _CL %= 8;     On garde les 3 derniers bit de _CL, c’est le reste de la division 7 = b000 0111
        add si,bx         // _SI += _BX;     _SI pointe vers le bon octet (16*y+x)
        mov bh, es:[si]        // _BH = 'octetsouhaité'; 
        db 0x0F,0x010,0x0C7     // Test1 _BH,_CL Teste le _CLieme bit de _BH
        jz paplus        // Si le _CLieme bit de _BH = 0 -> Z = 1 -> Sauter l'incrémentation
        inc coul        // Si le _CLieme bit de _BH = 1 -> Z = 0 -> incrémentation de coul
}
paplus: 
    asm{
        add si,0x0800        //         On passe à la 2è couche
        mov bh, es:[si]        // _BH = 'pixelsouhaité'; 
        db 0x0F,0x010,0x0C7     //Test1 _BH,_CL Teste le _CLieme bit de _BH
        jz nonplus        // Si le _CLieme bit de _BH = 0 -> Z = 1 -> Sauter l'incrémentation
        inc coul        // Si le _CLieme bit de _BH = 1 -> Z = 0 -> incrémentation de coul
    }
nonplus:
return coul;
        
}
void InvpixL(int px, int py) // 0 -> 2 | 1 -> 1 | 2 -> 0
{
    
    asm{
        mov bx,px         // _BX = px;    On met l’abscisse px dans _BX
        mov si,py         // _SI = py;    On met l’ordonnée py dans _SI
        shl si,4        // _SI *= 16;     Une ligne mesure 16 octet (128bit). _si pointe vers la bonne ligne
        mov cl,bl         // _CL = _BL;     _BX : [0;128[ On peut donc se contenter de _BL.
        shr bl,3          // _BL /= 8;     Pour savoir quel Bit des 8 est allumé
        and cl,7          // _CL %= 8;     On garde les 3 derniers bit de _CL, c’est le reste de la division 7 = b000 0111
        add si,bx         // _SI += _BX;     _SI pointe vers le bon octet (16*y+x)
        mov bh, es:[si]        // _BH = 'octetsouhaité'; 
        db 0x0F,0x016,0x0C7     // not1 _BH,_CL Inverse le _CLieme bit de _BH
        mov es:[si], bh        // On place _BH en mémoire vidéo (couche 1 : 1A20)
        add si,0x0800        //         On passe à la 2è couche        
        mov bh, es:[si]        // _BH = 'octetsouhaité'; 
        db 0x0F,0x016,0x0C7     // not1 _BH,_CL Inverse le _CLieme bit de _BH
        mov es:[si], bh        // On place _BH en mémoire vidéo (couche 1 : 1A20)
    }
        
}
[/b]
void CpixL(int px, int py, char couleur) //Pixel de couleur 0, 1, 2 (W, G, B)
{
    switch (couleur)
    {
        case 0: WpixL(px, py); break;
        case 1: GpixL(px, py); break;
        case 2: BpixL(px, py); break;
        case 3: GpixL2(px, py); break;
    }
}