Ici, on trouvera un tutoriel concernant l’affichage des arrière-plans à l’aide de PAlib.

De la même manière que nous avons décrit les possibilités de la DS concernant les sprites, nous allons maintenant voir ce que peut faire la DS concernant les arrière-plans ... Les possibilités sont plus diversifiées, peut être même trop :p Je suppose que PAlib ne couvre pas réellement toutes les combinaisons possibles, mais plutôt les plus communes et les plus utiles ...

• La DS peut afficher 4 arrière-plans différents sur chaque écran, chacun ayant sa propre palette de 256 couleurs. Tout arrière-plan est composé de 2 parties :
  • Un ‘tileset’ qui est un ensemble de blocs de 8×8 pixels qui compose l’image globale.
  • Une ‘tile map’ qui est une petite carte alignant de 256×256 à 512×512 pixels, en détaillant comment les tiles sont alignés sur l’écran.

• Ceci est vrai pour les tiled map ... Mais vous pouvez également remplacer une ‘tiled map’ par un arrière-plan dessinable de 8 ou 16 bits, sur lequel vous pouvez charger un bitmap, bmp, gif ou même jpeg, et redessiner dessus... Cependant, n’oubliez jamais que ce type d’arrière-plan est limité à un par écran, et nécessite beaucoup de RAM (3/8ème pour 8bit, 6/8ème pour 16 bit !!)

La DS peut également afficher jusqu’à 2 arrière plans avec des effets de rotation/distorsion. Ils ne sont pas vraiment utilisés, mais ils sont là pour votre seul plaisir

Dans le premier tutoriel d’arrière-plan, nous allons simplement voir comment utiliser des arrière-plans normaux et pleinement ‘dallé’, et vous verrez que cela offre déjà un bon résultat ...

Voici un petit schéma montrant les dimension d’un écran DS, avec les dalles et tout le reste :

Voici un joli petit schéma réalisé par Bennyboo, qui, une fois de plus, pourrait être utile...

Utiliser les arrière-plans dans les frontend est globalement le même que pour les sprites... Se référer donc au tutoriel des sprites. La seule différence est que vous devez cliquer sur l’onglet background pour accéder aux arrière-plans... Pour les différents modes d’arrière-plans disponibles, se référer aux explications du PAGfx.ini suivantes...

C’est la même méthode pour les sprites. La syntaxe est fichierimage BgMode palette. Si vous ne nommez pas la palette, le nom de l’arrière-plan sera utilisé et ce sera encore plus facile de la charger...

#TranspColor Magenta
 
#Sprites :
 
#Backgrounds :
C:\test.bmp TileBg
 
#Textures :

Les modes d’arrière-plans disponibles sont:

• 8bit pour les images 8 bit ...
• 16bit pour les images 16 bit...
• TileBg pour les arrière-plans pleins et normaux et que vous utiliserez le plus souvent... les tailles 256×256, 512×256, 256×512, 512×512.
• LargeMap, similaire à TileBg, mais utilisant les fonctions LargeMap de PAlib. Permet dutiliser des arrière-plans de toute taille(1024×2048)
• RotBg pour les arrière-plans rotatifs, avec les tailles 128×128, 256×256, 512×512, et 1024×1024

Durant la conversion, PAGfx devrait vous dire combien de tiles il utilise (moins de 1024 pour que ça fonctionne!), quelle palette, etc... Tout devrait fonctionner... Passons maintenant au chargement d’arrière-plans avec PAlib !

Nous allons commencer avec les arrières plans morcelés complets, car c’est le type le plus commun que vous utiliserez. Comme dit auparavant, vous pouvez en charger jusqu’à 4 d’un coup, chacun avec sa propre palette...

Les arrières plans morcelés doivent être convertis, dans PAGfx, en utilisant le mode ‘TileBg’...

Il existe 2 façons de charger un arrière-plan, une facile, et une autre moins facile... Vous savez quoi ? Nous allons commencer avec la facile !

Cette fonction est très simple à utiliser, mais nécessite que votre arrière-plan ait été converti en utilisant PAGfx... Les arguments sont comme suit : PA_LoadTiledBg(écran, numéro d’arrière-plan, nom d’arrière-plan);

La DS a 4 arrières-plans possibles par écran, donc utilisez des numéros d’arrière-plan de 0 à 3... Plus le nombre est petit, plus l’arrière-plan est prioritaire (comme pour les sprites... ) → arrière-plan 0 devant arrière-plan 1, etc...

Je vais coller tout le code de l’exemple PAlibExamples/backgrounds/LoadBg, car c’est le premier tuto sur les arrières plans...

// Charge un arrière-plan, très simple...
 
// Includes
#include <PA9.h>       // Include pour PA_Lib
 
// Converti par PAGfxConverter
#include "gfx/all_gfx.c"
#include "gfx/all_gfx.h"
 
// Fonction: main()
int main(int argc, char ** argv)
{
	PA_Init();    // Initialise PA_Lib
	PA_InitVBL(); // Initialise un VBL standard
	
	// Charge les arrières-plans avec leurs palettes !
	PA_LoadTiledBg(0, // ecran
			3, // numéro d'arrière-plan (0-3)
			bg0); // nom d'arrière-plan, utilisé dans PAGfx...
	PA_LoadTiledBg(1, 0, bg0);	
 
	// Boucle infinie pour maintenir le programme en fonction
	while (1)
	{
		PA_WaitForVBL();
	}
	
	return 0;
} // Fin du main()

Il est vraiment très simple de charger un arrière-plan avec sa palette sur les 2 écrans... Rien de plus à dire, je pense. Vous pouvez également regarder l’exemple LoadBgs, qui charge 4 arrières-plans sur un seul écran...

Cette fonction est utilisée si vous chargez des arrières-plans qui n’ont pas été convertis avec PAGfx, généralement en utilisant

PA_LoadSimpleBg(ecran,bg_number,bg_Tiles,bg_Map,bg_Size,wraparound,color_mode);

Pour utiliser cette fonction, nous avons besoin de créer 3 fichiers avec ces infos pour chaque arrière-plan :

• Tiles.
• Map.
• Palette.

Maintenant, je vais vous expliquer comment convertir 4 arrières-plans dans gfx2gba, puis comment les inclure dans votre code.

Imaginez-vous à l’intérieur du répertoire source, vous en trouvez un autre, nommé gfx, contenant 4 arrières-plans de taille 256 X 256 pixels. BG1.bmp BG2.bmp BG3.bmp BG4.bmp

Ok, si la couleur des 4 arrières-plans peut être sauvée dans une seule palette de 256 couleurs, vous pouvez taper cette commande pour tous les convertir :

 
gfx2gba -fsrc -m -pbg.pal -t8 *.bmp
 

Explication :

• -fsrc → pour sauver les fichiers en .c
• -m → pour sauver les ‘map info’ ou infos de mappage
• -p*.pal → sauve les infos de palette en utilisant le nom entré à la place de *
• -t8 → Infos de taille de morceaux.
• *.bmp → fichiers bmp à convertir (* signifie convertir tous les bmp du répertoire)

Ok, ceci va créer 2 fichiers pour chaque arrière-plan, ‘map’ et ‘tiles’, et une palette commune, bg.pal.c Maintenant, nous avons tout le nécessaire pour inclure nos arrières-plans dans le code.

Ok, maintenant que nous avons converti tous nos arrières-plan, nous avons besoin de les inclure :

//Chargement des arrières-plans simples qui n'ont pas été convertis avec PAGfx
 
#include <PA9.h>
//inclusion de tous les arriéres-plans
#include "gfx/BG1.raw.c"
#include "gfx/BG1.map.c"
 
#include "gfx/BG2.raw.c"
#include "gfx/BG2.map.c"
 
#include "gfx/BG3.raw.c"
#include "gfx/BG3.map.c" 
 
#include "gfx/BG4.raw.c"
#include "gfx/BG4.map.c"
 
// inclusion de la palette
 
#include "gfx/bg.pal.c"
 
//fonction main
int main(int argc, char ** argv)
{
 PA_Init();
 PA_InitVBL();
 
 PA_LoadPal(PAL_BG0,bg_Palette); //Pour charger la palette dans bg 0
 
 PA_LoadSimpleBg(0,3,BG4_Tiles,BG4_Map,BG_256X256,0,1); // Charge BG4 dans bg 3 
 PA_LoadSimpleBg(0,2,BG3_Tiles,BG3_Map,BG_256X256,0,1); // Charge BG3 dans bg 2
 PA_LoadSimpleBg(0,1,BG2_Tiles,BG2_Map,BG_256X256,0,1); // Charge BG2 dans bg 1
 PA_LoadSimpleBg(0,0,BG1_Tiles,BG1_Map,BG_256X256,0,1); // Charge BG1 dans bg 0 
 
 while(1){
  
  PA_WaitForVBL();
 }
 return 0;
}

Ceci va charger les 4 arrières plans sur l’écran du bas.

Avec PALib, vous pouvez créer des des arrière-plans complexes en utilisant seulement quelques motifs (tiles). Je vais vous montrer comment créer les motifs pour faire une bulle de texte type “BD”.

Imaginons que vous ayez un arrière-plan, avec des motifs de 8×8, avec ces indexs (j’ajouterai une image plus tard ...)

• 0 = Vide
• 1 = Haut
• 2 = Gauche
• 3 = Haut-gauche
• 4 = Carré blanc (centre)

Appelons le tile_speech.

Pour le charger, nous allons utiliser PA_LoadSimpleBg() mais avec une astuce.

En fait, cela marche comme PA_LoadSimpleBg(ecran,bg_select,bg_tiles,bg_map,bg_size,wraparound,color_mode). (Revoyez la fonction si vous ne vous en souvenez plus)

PA_LoadSimpleBg(1,1,tile_speech_Tiles,Blank,BG_256X256,0,1)

Vous avez surement remarqué qu’au lieu de tile_speech, nous avons mit Blank (vide). Blank est un arrière plan dont tous les motifs ont l’index 0. Celà veut dire que le premier motif(0) devra être vide si vous ne voulez rien d’affiché.

Note : On a utilisé l’arrière plan 1 car le texte doit se trouver devant.

Maintenant, pour charger vos magnifiques motifs, utilisez cette méthode :

PA_SetMapTileEx(ecran, bg_select, x, y, numero_de_motif, hflip, vflip, palette_number)

Il y a une chose à laquelle il faut faire attention malgré tout. Pour le numéro du motif (tile_number), vous ne pouvez pas vous contenter de mettre l’index et d’ésperer que celà fonctionne.

L’Index 5 peut en réalité correspondre au motif numero 3 etc... . Donc pour utiliser le motif avec l’index index, utilisez plutôt ceci :

tile_speech_Map[index]

Ceci à cause du fait que PAGfx optimise les motifs, donc vous DEVEZ utiliser la Map (carte), qui donne les index dans le bon ordre.

Pour le numéro de palette, mettez 0. hflip et vflip sont des booléens qui disent si il faut appliquer une symétrie au motif.

Voici la fonction qui devrait afficher la bulle (si vous trouvez une erreur, corrigez la !)

void displaySpeechBubble(bool screen,u8 bg,s16 x1,s16 y1,s16 x2,s16 y2)
{
    //load the tiles
    PA_LoadSimpleBg(screen,bg,tile_speech_Tiles,Blank,BG_256X256,0,1);
 
    //Load the palette
    PA_LoadBgPal(screen,bg,tile_speech_Pal);
 
    //load the corners
    PA_SetMapTileEx(screen,bg,x1,y1,tile_speech_Map[3],0,0,0);//top left
    PA_SetMapTileEx(screen,bg,x2,y1,tile_speech_Map[3],1,0,0);//top right
    PA_SetMapTileEx(screen,bg,x1,y2,tile_speech_Map[3],0,1,0);//bottom left
    PA_SetMapTileEx(screen,bg,x2,y2,tile_speech_Map[3],1,1,0);//bottom right
 
    u8 height, length;
 
    //load left and right side
    for(height = y1+1; height < y2; height++)
    { 
        PA_SetMapTileEx(screen,bg,x1,height,tile_speech_Map[2],0,0,0);//left
        PA_SetMapTileEx(screen,bg,x2,height,tile_speech_Map[2],1,0,0);//right
    } 
 
    //load top, down, and middle
    for(length = x1+1; length < x2; length++)
    {
        PA_SetMapTileEx(screen,bg,length,y1,tile_speech_Map[1],0,0,0);//top
        PA_SetMapTileEx(screen,bg,length,y2,tile_speech_Map[1],0,1,0);//bottom
       
        //load middle
        for(height = y1+1; height < y2; height++)
        {
            PA_SetMapTileEx(screen,bg,length,height,tile_speech_Map[4],0,0,0);//middle
        }
    } 
}

Déplacer un arrière-plan est simple comme déplacer un sprite ! Cela n’utilise qu’une simple fonction, et le code d’exemple peut être trouvé dans PAlibExamples/ScrollBg :

PA_InitText(1, 0); // Initialisation du texte sur l'écran du haut, arrière-plan 0...
	
// Chargement des arrières-plans et leurs palettes...
PA_LoadTiledBg(0, 3, BG3);	
PA_LoadTiledBg(1, 3, BG3);	
	
s32 scrollx = 0; // Pas de déplacement en X par défaut...
s32 scrolly = 0; // Pas de déplacement en Y par défaut...
 
// Boucle infinie pour maintenir le programme en activité
while (1)
{
	// Nous allons modifier scrollx et scrolly en fonction des touches pressées
	scrollx += (Pad.Held.Left - Pad.Held.Right) * 4; // Deplacement de 4 pixels par pression
	scrolly += (Pad.Held.Up - Pad.Held.Down) * 4; // Deplacement de 4 pixels par pression
 
	// Deplacement de l'arriére-plan comme indiqué par scrollx et scrolly...
	PA_BGScrollXY(0, // Ecran
			3, // Numéro d'arriére-plan
			scrollx, // Deplacement en X
			scrolly); // Deplacement en Y
		
	// Afficher les deplacement en X et Y :
	PA_OutputText(1, 0, 0, "x : %d   \ny : %d   ", scrollx, scrolly);
	
	PA_WaitForVBL();
}

L’arrière-plan est chargé comme d’habitude, et dans cet exemple, le texte est initialisé... Nous allons l’utiliser pour afficher des informations concernant le déplacement de l’arrière-plan. Tant qu’on y est, petite revue de la fonction d’initialisation du texte : vous choisissez un numéro d’arrière-plan dans lequel charger le texte... Cela peut être 0 à 3... Si vous chargé un arrière-plan sur un arrière-plan utilisé pour le texte, cela niquera (pas d’autres mots... Désolé !) votre texte... Et si vous afficher le texte sur un arrière-plan ‘image’, le texte écrasera l’image... Vous ne pouvez pas mixer vos propres arrières-plans et du texte...

• scrollx += (Pad.Held.Left - Pad.Held.Right) * 4; C’est pratiquement la même chose que ce que nous avons fait pour les sprites, 4 étant la vitesse de déplacement ! (vous vous souvenez ?)

• PA_BGScrollXY(Ecran, Numéro d’arrière-plan, X scroll, Y scroll); Cela s’explique de soi-même, j’espère... Cela déplace l’arrière-plan VERS une position donnée... Donc mettre 128, 128 revient à déplacer l’arrière-plan vers cette position.

• L’affichage texte suivant affiche la position courante de l’arrière-plan...

Que se passe-t-il quand un arrière-plan sort de l’écran ? Il fait le tour, ce qui signifie que vous n’aurez pas de ‘blanc’, mais toujours votre fond d’écran... Donc, si vous déplacé l’arrière-plan à fond à gauche, la partie disparaissant réapparait à droite si l’arrière-plan avait une largeur de juste 256 pixels...

Le Défilement Parallax(en) est une technique qui donne une vitesse de défilement différente sur tout le fond, donnant ainsi une impression de profondeur et une sorte d’effet 3d... Ca rend bien, et c’est tellement simple à mettre en place que ca serait idiot de ne pas l’utiliser ! Il est employé dans beaucoup de jeux, dans les shoot’em up (les étoiles proches défilent plus rapidement que les lointaines) ou encore les jeux de plateforme (Les blocs sous Marios vont à une vitesse, les montagnes vont plus lentement, et les nuages vont à une autre vitesse), etc... Le défilement Parallax peut être employé dans beaucoup de situations. Et comme une image vaut mieux qu’un long discours : démonstration

PAlib a quelques fonctions sympa pour que le défilement, une pour le lancer, et une dpour l’utiliser... Cet exemple correspond à un jeu dans l’espace :

// Charge les 4 arrière-plans sur l'écran du bas...
PA_LoadTiledBg(0, 1, BG1);	//écran, numéro de l'arrière-plan, nom de l'arrière-plan
PA_LoadTiledBg(0, 2, BG2);	
PA_LoadTiledBg(0, 3, BG3);	
 
// Démarrer parallax verticalement (axe Y) pour l'ensemble des arrière-plans
// 256 est la vitesse normal, 128 2 fois plus lent, 512 deux fois plus rapide
PA_InitParallaxY(0, //écran
				0, //vitesse de parallax  pour l'arrière-plan 0. Le 0 n'est pas parallax (défilera indépendamment avec BGScroll)
				256, // vitesse normal pour Bg1
				192, //   3/4 vitesse
				128); // 1/2 vitesse
PA_InitParallaxY(1, 0, 256, 192, 128);	// la meme chose, mais pour l'écran 1...
	
s32 scroll = 0;
 
	
// Boucle infinie pour garder le programme en exécution
while (1)
{
	scroll += 1; // Défile par un pixel
	// Les arrière-plans avec une vitesse de parallax de 256 feront défiler 1 Pixel, 192 feront défiler 0.75, et 128 0.5
	// Nous pourrions également avoir mis une vitesse négative de parallaxe
pour avoir le défilement de quelques arrière-plans défilant dans différentes
directions
		
	PA_ParallaxScrollY(0, -scroll);  // Fait défiler à l'écran 0 arrière-plans. 
 
	PA_WaitForVBL();
}

Tout d’abord, vous devez charger quelques arrières-plans, au moins 2... Vous ne pouvez pas faire défiler différentes vitesses si vous en avez juste un !

Ensuite, Vous devez initialiser le défilement parallax : PA_InitParallaxY(écran, vitesse bg0, vitesse bg1, vitesse bg2, vitesse bg3);. Vous donnerez différentes vitesse à chaque arrière-plan. Alors, 256 c’est pour une vitesse de 1 pixel, 512 veut dire deux fois plus vite, 128 deux fois moins vite, etc... Vous ferez un petit test et des erreurs pour trouver la vitesse qui parait la mieux pour dans votre jeu, je pense, mais ce n’est pas dur. Normalement, vous mettrez votre arrière-plan principal, le plus près, à une vitesse de 256, et plus vous allez plus loin, plus la valeur devrait diminuer. Si vous ne voulez pas qu’un arrière plan défile (pour l’afficahge des scores par exemple) mettez le simplement à zéro.

scroll += 1; c’est pour que ca défile tout seul, Mais on aurait pu le faire avec les boutons.

PA_ParallaxScrollY(screen, scroll); C’est la fonction qui s’occupe du défilement Paralax. Ici, on met -scroll parce qu’on veut que ca défile dans cette direction là...

Compliez, testez, ça marche même avec DualiS ! Vous devriez obtenir un effet de défilement dans l’espace Qu’est ce que vous en pensez ? Sympa non ?

Bon alors là ca défile verticalement, pour Mario ca devrait être horizontalement... C’est simple à modifier. Vous avez remarqué que les fonctions parallax avaient pour dernière lettre Y ? Rempalcez simplement Y par X et ca défilera horizontalement ! Ouais, c’est simple. On peut même mélanger défilement horizontal et vertical si on veut.

Pour le moment ca ne vous dit rien, mais le défilement parallaxmarche aussi pour les arrières plans LargeMap, Que nous verrons bienôt !

Les arrières-plans LargeMap (Grande Carte en français) doivent être converties en utilisant le mode “arrière-plan LargeMap”... Je sais, vous l’avez probablement déjà deviné... Les LargeMap n’ont pas de véritable signification hardware sur DS, mais sont en fait une utilisation particulière des Tiles Backgrounds (arrières-plans morcelés) par PAlib, vous permettant de dépasser la taille limite de 512×512... Pour ce faire, il change la tile map (carte des tuiles) à chaque image en fonction du défilement. Ceci a 2 conséquences :

• Il utilise une fonction différente, aussi bien pour le chargement que pour le défilement. Même si la fonction est différente, veuillez notez que PAlib est intelligent, et que le défilement de type parallax devrait aussi fonctionner avec les largemap (il prend la bonne fonction de défilement automatiquement).
• Il prend du temps de calcul CPU, alors que le défilement des arrières-plans morcelés (tiles background) sont générés au niveau hardware, donc quasi instantanné... De plus, il y a 2 différentes fonctions de défilement, je les détaillerai juste après...

Le code se trouve dans Backgrounds/LargeMap :

// Charge un arrière-plan large de défilement converti avec PAGfx... 
PA_LoadPAGfxLargeBg(0, //screen
		    3, //background number (0-3)
		    Large); // Name
		
// Ensuite, nous initialisation les variables pour le défilement...
s32 scrollx = 0; 
s32 scrolly = 0;
	
// Boucle infinie pour laisser le programme tourner
while (1){
 
	// Nous devons changer le défilement en fonctions des touches appuyées...
	scrollx += (Pad.Held.Right - Pad.Held.Left)*4; // fait défiler 4 pixels en X à la fois
	scrolly += (Pad.Held.Down - Pad.Held.Up)*4; // Idem pout Y
	
	PA_LargeScrollXY(0, // écran
			3, // numéro d'arrière-plan
			scrollx, // Défilement suivant X
			scrolly); // et défilement suivant Y
 
	PA_WaitForVBL();
}

Il y a simplement 2 fonctions à regarder, le reste étant indentique à l’exemple BGScroll...

• PA_LoadPAGfxLargeBg(screen, background number (0-3), background name); Ce sont exactement les mêmes arguments que ceux des TiledBg...
• PA_LargeScrollXY(screen, background number, scrollx, scrolly); est le fonction utilisée pour le défilement, qui est identique aux fonctions de défilement normal... Cette fonction agit sur X et Y, mais vous pouvez avoir une fonction uniquement X ou pour Y si vous voulez...

Et oui, c’est tout ! Ce défilement ne bouclera pas sur lui-même, il sera juste limité par l’image que vous utilisez et ne défilera pas au-delà... Notez que cette fonction est assez rapide...

Aussi, vous pouvez testez sur Dualis, mais le résultat est plutôt surprenant, pas aussi parfait qu’il devrait être...

Il existe une autre version de la fonction de scrolling pour les largemaps, elle ressemble beaucoup à l’autre, mais permet de faire du wrapping (NdT : permet de faire défiler une seule image en la reproduisant à chaque bout pour donner l’illusion d’une image infinie) Pourquoi le wrapping n’est pas présent par défaut ? Parce que cette fonction est TRES lente... oui c’est bête, mais je ne pouvais pas le faire d’une autre manière (Ou alors il aurait fallu ajouter une limite en taille, avec seulement certaines tailles possibles). Si vous n’avez pas besoin de défilement infini, utilisez PA_LargeScrollXY...

Il y a un exemple de défilement infini dans Backgrounds/InfiniteLargeMaps...

La fonction est :

PA_InfLargeScrollXY(0, // écran
			3, // numéro de background
			scrollx, // X scroll
			scrolly); // Y scroll

PA_InfLargeScrollXY(écran, numéro de background, scrollx, scrolly); pareil que l’autre fonction, mais avec le préfixe Inf... Notez que le background est chargé de la même façon...

Les Rotating backgrounds sont cool mais moins faciles à utiliser que les background normaux... Utilisez le mode RotBg background pour les convertir...

L’exemple suivant est tiré de Backgrounds/RotBackgrounds... Voici presque tout le code :

PA_SetVideoMode(0, 2);  //écran, mode
	
PA_LoadPAGfxRotBg(0, //écran
		  3, // numéro de background
		  Rot, // nom du background en PAGfx
		  1); // wraparound !
	
PA_InitText(1, 0);
	
// Infinite loop to keep the program running
s32 scrollx = 0;
s32 scrolly = 0;
s32 rotcenterx = 0;
s32 rotcentery = 0;
s16 angle = 0;
s32 zoom = 256;
	
PA_OutputSimpleText(1, 2, 2, "Zoom       : Start/Select");
PA_OutputSimpleText(1, 2, 3, "ScrollX    : Gauche/Droite");
PA_OutputSimpleText(1, 2, 4, "Scrolly    : Haut/Bas");
PA_OutputSimpleText(1, 2, 5, "RotCenterX : A/Y");
PA_OutputSimpleText(1, 2, 6, "RotCenterY : B/X");
PA_OutputSimpleText(1, 2, 7, "Angle      : R/L");
 
while (1){
	zoom += Pad.Held.Start - Pad.Held.Select;
	scrollx += Pad.Held.Right - Pad.Held.Left;
	scrolly += Pad.Held.Down - Pad.Held.Up;
	rotcenterx += Pad.Held.A - Pad.Held.Y;
	rotcentery += Pad.Held.B - Pad.Held.X;	
	angle += Pad.Held.R - Pad.Held.L;
		
	PA_SetBgRot(0, 3, scrollx, scrolly, rotcenterx, rotcentery, angle, zoom);
		
	PA_WaitForVBL();
}

Comme vous pouvez le constater, Il y a 2 différences principales entre le chargement de backgrounds à motifs et celui des RotBackgrounds :

• PA_SetVideoMode(écran, mode vidéo); indispensable pour les RotBackgrounds...
  • mode vidéo 0 : met les 4 backgrounds en mode normal (ou large map)... C’est le mode par défaut.
  • mode vidéo 1 : met les 3 premiers backgrounds en mode normal (ou large map...), et le background 3 (le 4ème) en rotating background...
  • mode vidéo 2 : les background 0 et 1 en normal ou large map, 2 et 3 en rotating.

C’est à peu près tout ce qu’il y a à savoir sur les modes vidéos. Ici on le met à 2, mais c’aurait marché aussi avec 1. Comme vous devriez maintenant l’avoir compris, les rotating backgrounds ne peuvent pas utiliser n’importe quel background, mais seulement le 2 ou 3, selon le mode vidéo...

• PA_LoadPAGfxRotBg(écran, numéro de background, nom de background en PAGfx, wraparound (0/1 = OFF/ON)); Presque pareil que les autres fonctions de chargement de background : charge le background et la palette, s’ils ont été convertis avec PAGfx...

Ensuite les variables de rotation, dimensions(scaling) et déplacement(moving), il n’y a pas grand chose à expliquer là-dessus... La dernière chose intéressante c’est :

• PA_SetBgRot(écran, background, scrollx, scrolly, rotcenterx, rotcentery, angle, zoom); Assez proche des fonction de rotation/scaling (redimensionnement) des sprites : elle prend les mêmes valeurs (un zoom de 256 pour 100%, etc...). Par contre il y a plus d’options :
  • scrollx and and scrolly, pour positionner le background...
  • rotcenterx and rotcentery Pour changer le centre de rotation, oui c’est possible !
  • angle, comme pour les sprites.
  • zoom, Le zoom est le même pour les X et Y. Je pourrais le séparer si quelqu’un en a besoin mais pour le moment je laisse ca comme ca.

Je vous conseille de compiler et d’essayer (sur DS, ca ne fonctionne pas sur un émulateur), les touches sont indiquées sur l’écran, juste pour voir comment ca marche. Le background est en wraparound, il est donc ‘infini’, Vous pouvez mettre le wraparound à 0 pour voir...

Nous verrons les backgrounds 8bits et 16bits dans le même tutoriel, ils fonctionnent à peu près pareil autant matériellement que dans l’utilisation des fonctions PAlib ... Quelle est la différence entre les background 8bits, 16bits et ceux que nous avons vu avant ? Si vous vous rappelez bien, les background précédents étaient fait de motifs de 8×8 pixels, ce qui n’est pas le cas de ces background en bitmap ! Hé non, sur ces derniers, on peut dessiner pixel par pixel...

Je pense qu’avant de commencer, nous devrions faire le point sur les avantages et les inconvénients de ces background bitmap, et voir à quelle occasion ils peuvent nous servir :

• Ils prennent BEAUCOUP plus de mémoire video que les autres backgrounds... Un background 8bit prend jusqu’à 3/8 de la mémoire pour un écran, et un 16bit prend 2 fois plus : 6/8 ! Donc avec les 16bit, on peut mettre au maximum 2 autres backgrounds,s’ils ne sont pas trop complexes : C’est assez limité...
• Dessiner dessus est TRES long... les background motifs sont de blocs de 8×8, pour les bitmap, c’est du pixel par pixel... Changer un bloc de 8×8 consiste donc à effectuer 64 manipulations au lieu d’une... De plus, les background 8bits ont une limite spécifique qui rend le dessin pixel par pixel encore plus lent que sur du 16bits (mais c’est plus rapide pour copier 2 à 4 pixels à la fois)
• Dans la même idée : c’est très lent d’effacer un background bitmap, alors que c’est presque instantanné pour ceux à motifs
• On ne peut les placer que sur le background numéro 3... Ce n’est pas vraiment un problème puisqu’on peut modifier l’ordre des background, Mais souvenez vous que vous ne pourrez pas charger un background en tant que numéro 3 après ca. (il reste tout de même les background 0, 1 et 2)

• Il est possible de dessiner directement sur l’écran ! PAlib donne par exemple des fonctions pour dessiner avec le stylet (utilisée dans nDoS’s paint app), et on peut faire d’autre choses comme ça !
• Il est possible de charger certain formats d’images sur les background de 8 ou 16bits (selon le format), sans avoir à les convertir ! Même si c’est lent, ces images sont assez petites pour les inclure dans une rom, c’est donc idéal pour les splash screensou les arrière-plans statiques, pour lesquels le temps n’est pas un problème... Les formats supportés : jpeg (16bits), gif (8/16bits), bmp (16bits), et raw (8/16bits).
• les backgrounds 16bits sont en... 16 bits... ce qui veut dire une palette ‘infinie’, pas de limite dans les couleurs ! C’est pas mal à utiliser avec les jpeg par exemple.

Voyons pour quel type d’application, ou à quel moment du jeu un background 8/16bits peut-être utilisé...

• les Splash screens (écran de chargement/fond) : vraiment très adapté... Vous pouvez charger un jpeg en background 16bit pour en faire un splash, il sera donc beau, et prendra peu de place sur la rom ...
• Les écrans de Menu peuvent aussi utiliser un background 8/16bits (en jpeg encore une fois), et vous pouvez utiliser des sprites pour les différents choix du menu...
• Vous pouvez utiliser un Gif animé pour faire une séquence animée ! C’est plutôt cool car ca ne prend pas beaucoup de place (mais c’est plus adapté à un stylé dessin animé qu’à un style photoréaliste)...
• Durant le jeu, il n’y a pas vraiment de moment propice aux backgrounds bitmap, sauf si vous voulez dessiner au stylet...
• Vous pourriez remplacer les classiques initiales du highscore par un dessin au stylet, un peu comme Polarium le fait!

Créer des backgrounds de 8bits ou 16bits avec PA_lib ne demande que quelque lignes de code. Les 8bits sont légèrement plus compliqués parce qu’il requièrent un étape en plus pour charger la palette, mais sinon, les 8 et 16bits sont vraiment très proches.

Pour créer un background 8bits ou 16bits, Il faut créer l’image dans un éditeur d’image (MS Paint etc.). Votre image doit faire 256×192 Sinon elle sera déformée à l’écran. Enregistrez votre image. Si c’est un background 16bits, mettez le nom, 16bit et aucune palette. Pour le 8bits, mettez le nom de l’image, 8bit et ensuite le nom de la palette. Utilisez PAGfx converter et vos backgrounds sont convertis.

Voici les lignes de code à utilisez pour un background 8bits :

 PA_Init8bitBg(0,3);
 PA_Load8bitBgPal(0,(void*)bmp_Pal);
 PA_Load8bitBitmap(0,background_Bitmap);

PA_Init8bitBg(0,3); initialise l’écran 0 pour mettre un background 8bits avec une priorité de 3. la priorité peut varier de 0 à 4.
PA_LoadNormalBgPal(0,(void*)bmp_Pal); charge la palette utilisée par le background.
Enfin, PA_Load8bitBitmap(0,background_Bitmap); affiche l’image à l’écran. 0 est le numéro d’écran et background_Bitmap est le nom de fichier suivi de _Bitmap (si vous avez utilisé du bitmap...).

Les backgrounds de 16bits sont encore plus simples à utiliser :

PA_Init16bitBg(0, 3);
PA_Load16bitBitmap(0,background_Bitmap);

Ces deux lignes ressemblent beaucoup à celles au dessus, ca devrait être assez évident à comprendre. Notez bien que les background 16bits n’utilisent pas de palette.

Prochain → Jour 6 - Les maths adaptées au dev DS

Warning :

PA_LoadNormalBgPal(0,(void*)bmp_Pal);

N’existe plus. Utiliser la fonction :

PA_Load8bitBgPal(0,(void*)bmp_Pal);

Q1.Peut-on supprimer un fond d’écran après l’avoir fait apparaître grâce à une fonction ? PA_DeleteBg(écran,numéro du fond);