Voila j'ai fait moi même cette routine pour afficher des sprites car il n'en existe pas des comme celles là dans extgraph.
c'est pour afficher un sprite en niveaux de gris, avec mask, clippée par des valeurs constantes définies et dont la taille horizontale est un multiple de 8 quelconque.
Vu que je connais pas assez l'asm pour la faire en asm, je l'ai faite en C.
void grayclipspriteX8_mask(short Xscreen, short Yscreen, short width, short height,
unsigned char * img0, unsigned char * img1, unsigned char * mask,
unsigned char *Plane0, unsigned char *Plane1)
{
register short i, j;
short width2, width3;
short offset = (Yscreen * 30);
short clippedup, clippeddown;
unsigned short shift = Xscreen % 8, hmshift;
BYTE byteMask;
BYTE byteImg0;
BYTE byteImg1;
if (Xscreen < 0)
{
shift = (8 + shift) % 8;
offset += (Xscreen-7) / 8;
clippeddown = (CLIP_DOWN - 1) * 30;
clippedup = (CLIP_UP - 1) * 30;
}
else
{
offset += (Xscreen / 8);
clippeddown = CLIP_DOWN*30;
clippedup = CLIP_UP*30;
}
if (shift)
width2 = width + 1;
else
width2 = width;
hmshift = 8 - shift;
width3 = width2 - 1;
for (i=0; (i<height) && (offset < clippeddown); i++)
{
if (offset >= clippedup)
{
j=0;
if ((offset + j - ((Yscreen+i) * 30)) < CLIP_RIGHT)
{
if ((offset + j - ((Yscreen+i) * 30)) >= CLIP_LEFT)
{
if (shift)
{
byteMask = (*mask >> shift) | (0xFF << (hmshift));
byteImg0 = (*img0 >> shift);
byteImg1 = (*img1 >> shift);
}
else
{
byteMask = *mask;
byteImg0 = *img0;
byteImg1 = *img1;
mask++;
img0++;
img1++;
}
Plane0[offset + j] &= byteMask;
Plane0[offset + j] |= byteImg0;
Plane1[offset + j] &= byteMask;
Plane1[offset + j] |= byteImg1;
}
else
{
if (!shift)
{
mask++;
img0++;
img1++;
}
}
}
else
{
mask++;
img0++;
img1++;
}
for (j=1; j<width3; j++)
{
if ((offset + j - ((Yscreen+i) * 30)) < CLIP_RIGHT)
{
if ((offset + j - ((Yscreen+i) * 30)) >= CLIP_LEFT)
{
if (shift)
{
byteMask = (*mask << (hmshift)) | (*(mask+1) >> shift);
byteImg0 = (*img0 << (hmshift)) | (*(img0+1) >> shift);
byteImg1 = (*img1 << (hmshift)) | (*(img1+1) >> shift);
}
else
{
byteMask = *mask;
byteImg0 = *img0;
byteImg1 = *img1;
}
mask++;
img0++;
img1++;
Plane0[offset + j] &= byteMask;
Plane0[offset + j] |= byteImg0;
Plane1[offset + j] &= byteMask;
Plane1[offset + j] |= byteImg1;
}
else
{
mask++;
img0++;
img1++;
}
}
else
{
mask++;
img0++;
img1++;
}
}
if (j == width3)
{
if ((offset + j - ((Yscreen+i) * 30)) < CLIP_RIGHT)
{
if ((offset + j - ((Yscreen+i) * 30)) >= CLIP_LEFT)
{
if (shift)
{
byteMask = (*mask << (hmshift)) | (0xFF >> shift);
byteImg0 = (*img0 << (hmshift));
byteImg1 = (*img1 << (hmshift));
}
else
{
byteMask = *mask;
byteImg0 = *img0;
byteImg1 = *img1;
}
mask++;
img0++;
img1++;
Plane0[offset + j] &= byteMask;
Plane0[offset + j] |= byteImg0;
Plane1[offset + j] &= byteMask;
Plane1[offset + j] |= byteImg1;
}
else
{
mask++;
img0++;
img1++;
}
}
else
{
mask++;
img0++;
img1++;
}
}
}
else
{
mask+=width;
img0+=width;
img1+=width;
}
offset+=30;
}
}
Les constantes CLIP_DOWN et CLIP_UP sont données en pixels et CLIP_LEFT et CLIP_RIGHT sont par pas de 8
Y'a t'il moyen de la faire (avec exactement le meme comportement) et qui soit plus perfomante (en asm ?) ?
Merci d'avance
et pardon car y'a pas de commentaires 
. (Si tu connais bien le C et le fonctionnement de la machine, apprendre l'assembleur n'est pas très long 
