Forum Graph100

Ok chef !!!
je vais l'inclure à mon tuto

moins bien? ca tient pas la comparaison oui 

Tu veux dire quoi par "arreter le pix/pix"?? 

pour répondre à Julien:
bah oui le pixel par pixel y'a rien de plus lent!
ou au pire prends les fonctions n&b C3 les plus optimisées, ça fera déjà ça de gagné!
va zieuter le post "tuto sur la prog" de casioworld pour choper ces routines! et ce ke voulait dire 2072, c'est de ne pas appeller la fonX pixel (ou ja sais po comment tu l'appelles) dans ta fonX line! mais de l'écrire en inline! ça ira plus vite!

et si ça te dérange po 2072, c'est possible ke je mette ta routine pr effacer l'écran dans bomberman?

ok merci!
et sinon une kestion, ce ne serait pas plutot mov es:[di],ax dans la première routine?

pour répondre à Julien:
bah oui le pixel par pixel y'a rien de plus lent!
ou au pire prends les fonctions n&b C3 les plus optimisées, ça fera déjà ça de gagné!
va zieuter le post "tuto sur la prog" de casioworld pour choper ces routines! et ce ke voulait dire 2072, c'est de ne pas appeller la fonX pixel (ou ja sais po comment tu l'appelles) dans ta fonX line! mais de l'écrire en inline! ça ira plus vite!

Oui, j'avais compris, ce que je comprenais pas, c'est comment le faire...

Allez KTr et Casiomax, une ptite routine pour afficher une ligne droite allant de n'importe quel point a n'importe quel point de l'écran en une seule fois svp 
a mon avis c'est un peu chaud non? 

dsl, ms Casiomax et KTr n' ont po tout programmé !!
c po eux qui ont fait toutes les routines, meme asm !!!
Justement, pour ceux qui veulent apprendre l' asm genre MOI  , c un bon défi, non ???

Ceci a pars, je capte po ce que du desire !

 
en effet g pas tout fait!
et moi aussi je veux bien essayer de faire un algo de ce tuype! je ne m'y suis jamais essayé!

ok merci!
et sinon une kestion, ce ne serait pas plutot mov es:[di],ax dans la première routine?

Ooooh non sûrement pas, c'est 8 bits que je veux écrire pas 16, al est un registre de 8 bits qui est en fait les 8 lower bits de ax (qui fait 16 bits et qui est donc divisé en ah et al).

hihi meme moi je savais ca  :twisted:   

Ben au début moi non plus, mais ca s'apprend tout ca 

tu parles de mxdraw?
ben o début moi g fait ke débugguer!
ms c après ke g compris! toutes les histoires de décalage de sprites et tout ça je n'y captais rien! ce n'est que mntnt que j'y comprends un peu plus!

sur le site de Whyp g mis mes routines de dessin dans graphic.h
les fonctions ne fonctionne que sous du N&B en mode C3 (le mode par défaut)
quand je dessine une ligne horizontale ca va de 8 pixels par pixels au maximun
pour ce qui est des lignes verticales il y aussi une optimisation mais c pas pareil.
c ce que j'utilise pour le tarot donc ca marche.

regarde ca Julien pt que ca va te permettre d'optimiser ton programme

/*Dessine une ligne verticale
Diffère de l'ancienne méthode
Localise le premier pixel et ensuite décrémente l'indice (si).
*/
void vLigne(unsigned short int x,unsigned short int y1,unsigned short int y2,char state)
{
    asm mov cx, x;
    asm and cl, 0x7;
    asm mov si, 0x3ff;
    asm sub si, y1;
    asm and x, 0xfff8;
    asm shl x, 0x3;
    asm sub si, x;
    asm mov es, SEG1;
    if(state)
    {
        asm mov ah, 0x80;
        asm shr ah, cl;
        for(;y1<=y2;y1++)
        {
            asm or es:[si], ah; //Allume un pixel
            asm dec si; //Décrémente 'si'
        }
    }
    else
    {
        asm mov ah, 0x7f;
        asm shr ah, cl;
        for(;y1<=y2;y1++)
        {
            asm and es:[si], ah; //Eteint 1 pixel
            asm dec si;
        }
    }
}
/*Dessine une ligne horizontale
Procédure un peu plus complexe
Localise le premier pixel et ensuite se déplace de 8 pixels (car 1 octect fait 8 pixels)
*/
void hLigne(unsigned short int x1,unsigned short int y,unsigned short int x2,char state)
{
    asm mov cx, x1;
    asm and cl, 0x7;
    asm mov si, 0x3ff;
    asm sub si, y;
    asm and x1, 0xfff8;
    asm shl x1, 0x3;
    asm sub si, x1;
    asm mov es, SEG1;
    asm shr x1, 0x3;
if(state)
{
    asm mov ah, 0xff;
    asm shr ah, cl;//Recherche du masque pour le premier pixel du premier octect
    asm mov bx, x1;
    asm mov cx, x2;
boucle:    asm add bl, 0x8;
    asm cmp cl, bl;
    asm jb fin;
    asm or es:[si], ah;
    asm mov ah, 0xff;//Met 255 dans l'octect pour allumer 8 pixels d'un coup
    asm sub si, 0x40; // Se déplace de 64 (car 64 octects par colonne)
    asm jmp boucle;
fin:    asm mov bl, 0x7f;
    asm and cl, 0x7;
    asm shr bl, cl;//Recherche du masque pour le dernier pixel
    asm not bl;
    asm and ah, bl;
    asm or es:[si], ah;
}
else
{
    asm mov ah, 0xff;
    asm shr ah, cl;//Recherche du masque pour le premier pixel du premier octect
    asm not ah;
    asm mov bx, x1;
    asm mov cx, x2;
boucle2:asm add bl, 0x8;
    asm cmp cl, bl;
    asm jb fin2;
    asm and es:[si], ah;
    asm mov ah, 0x0;//Met 0 dans l'octect pour éteindre 8 pixels d'un coup
    asm sub si, 0x40;// Se déplace de 64 (car 64 octects par colonne)
    asm jmp boucle2;
fin2:   asm mov bl, 0x7f;
    asm and cl, 0x7;
    asm shr bl, cl;//Recherche du masque pour le dernier pixel
    asm or ah, bl;
    asm and es:[si], ah;
}
}