|
|
|
|
|
Le site de Steph : Le CPC |
|
|
|
|
|
Dessiner en mode 1 optimisation
On vient de voire comment dessiner sur CPC avec les fonctions PutPixelModeX. On vas les améliorer un peut, le but de ces fonctions est d'afficher un pixel le plus rapidement possible en fait.
Mais notre fonction fait beaucoup de choses, elle calcule l'adresse du pixel en mémoire, elle crée un masque binaire en fonction de la couleur, elle met à jour en mémoire l'octet contenant le pixel avec le masque.
Déjà quand on dessine, c'est "rare" (du moins sur CPC) que l'on change de couleur pour chaque point, donc le calcule du masque de couleur peut être fait dans une autre fonction qui s'occuperas de cela.
unsigned char gl_color = 0; // variable pour la couleur en cour
unsigned char gl_cMasque = 0; // variable pour le masque de couleur en cour
void SetColorMode1( unsigned char nColor )
{
unsigned char RealColor = nColor % 4;
// si la couleur est la même que celle déja en cour, inutil de faire quoi que ce soit.
if ( RealColor == gl_color )
{
return;
}
// mémorise la couleur en cour
gl_color = RealColor;
// on crée le masque
gl_cMasque = 0;
// dans se masque on met la valeur pour le pixel 0 (le plus à gauche dans l'octet)
// pour les autres pixel de l'octet on feras un décalage au moment de l'affichage
if(nColor & 1)
gl_cMasque += 128;
if(nColor & 2)
gl_cMasque += 8;
}
Il faut donc changer dans la fonction PutPixelMode1 l'utilisation du masque, on en profite pour faire une petite modification dans le calcule de l'adresse du point, on vas changer les divisions par des décalages de bit.
En effet dans notre calcule on a (nY / 8) que l'ont peut changer par (nY >> 3), oui un décalage de 3 vers la droite revient à faire une division par 8, idem pour (nX / 4) qui devient (nX >> 2).
Le plus gros changement dans la fonction cela vas être l'utilisation pour créer la valeur de la couleur pour l'octet en mémoire des masque et décalage de bit.
Cela vas donc nous évité de faire tout un tas de IF pour mettre la bonne valeur.
Voici donc la fonction PutPixelMode1 modifié :
void PutPixelMode1(int nX, unsigned char nY)
{
int nPixel = nX % 4;
unsigned char *pAddress = (unsigned char *)((unsigned int)(0xC000 + ((nY >> 3) * 80) + ((nY % 8) * 2048) + (nX >> 2)));
// on met les bit du pixel voulus à 0
*pAddress &= ~(136 >> nPixel);
// on met la couleur du pixel
*pAddress |= (gl_cMasque >> nPixel );
}
Je vous rappel qu'n C l'opérateur bit à bit NOT c'est "~", le "!" c'est l'opérateur logiques
On pourrais gagner encore un peut de temps en modifiant les fonctions lineBresenham et Cercle, mais bon, on verras peut être cela plus tard.
Ces modification vous monter aussi que quand on développe en C sur CPC il faut tout de même faire attention a ce que l'on fait, cela peut avoir un impacte énorme sur le résultat.
Je vous rappelle que sur notre Z80, gagner une centaine d'instructions dans une fonction n'est pas négligeable ;-)
Voici la comparaison entre les deux fonctions avec ce que cela donne à l'écran
L'animation est fidèle en temps vis à vis d'un CPC
On voie que finalement on n'a pas gagné temps que cela, sur le dessin des carrés et cercle on a gagné 20*(1/300) ce qui n'est pas beaucoup !
Vous trouverais dans se ZIP le fichier C et de quoi compiler le tout.
|
|
|
|
|