[raphzore]

Testé sur le hardware: Ca a de la gueule !

En espérant que le jeu en fera bon usage et déchirera .

[Zombie]

Parfait, merci bcp, je le saurai pour les prochaines fois


Une fois de plus, je ne le dirai jamais assez mais un grand merci à vous 2 (Mollusk, raphzore) pour votre aide.
Je vais me coucher avec plein d'idées en tête pour mon projet en cours 

[Zombie]

Alors... Si tu faisais pour toute une image, genre tout l'écran, tu peux le faire en fat en allant cherchant la bonne image, etc... Mais pas pour les sprites, parce que si pour chaque sprite il fallait copier de FAT à RAM la frame à afficher, je pense que ça ralentirait pas mal, et c'est pas trop fait pour ça
Et sinon, c'est le .bin qu'il te faudra mettre, pas le .c

Petite question pour le FAT ...
Si je veux chargé un mémoire un sprite, tu me dis que je dois prendre le ".bin", mais quel .bin ? 
Où je le trouve ce .bin, c'est ceux qui se trouve dans le répertoire "bin" après décompression avec PAGfx ?
C'est par exemple "toto_Sprite.bin" ? Je le charge simplement un mémoire et je l'affiche ou il y a une astuce à faire ?
Je dois charger le "toto_Pal.bin" aussi je suppose pour charger le Palette ?

C'est bêtement ca ou c'est + complexe ?

[Pouer]

Pour les sprites tu utilise un gif (il y a un exemple de chargement) et ensuite tu utilise PA_GifToTiles(...) pour le transformer en sprite, il y a aussi un exemple pour cette fonction (GIF/GIFSprite).

[Zombie]

Ca prendra en compte ma couleur de transparence
Et j'aimerais faire la même chose pour mettre 2 background donc un au dessus de l'autre (transparence aussi)...
Convertir de gif vers sprite gardera ca ?

[Mollusk]

Tu peux faire avec les bin aussi, ouais

[Zombie]

Je dois prendre quel bin ?
J'ai :
R0BG0_Info.bin
R0BG0_Map.bin
R0BG0_Pal.bin
R0BG0_Tiles.bin

J'ai essayé de chargé de FAT à la mémoire dans un buffer le fichier "R0BG0_Tiles.bin" mais la fonction :
PA_LoadTiledBg(1, 2, (void*)buffer[1]);

ne passe pas... j'ai droit à tout ca pour une seule ligne :

Code:

main.c:475:1: error: pasting "]" and "_Pal" does not give a valid preprocessing token
main.c: In function 'Room0':
main.c:475: error: expected ')' before '_Pal'
main.c:475:1: error: pasting "]" and "_Tiles" does not give a valid preprocessing token
main.c:475:1: error: pasting "]" and "_Map" does not give a valid preprocessing token
main.c:475:1: error: pasting "]" and "_Info" does not give a valid preprocessing token
main.c:475:1: error: pasting "]" and "_Info" does not give a valid preprocessing token
main.c:475: error: expected ')' before '_Tiles'
main.c:475: error: too few arguments to function 'PA_LoadBgTilesEx'
main.c:475: error: expected ')' before '_Map'
main.c:475: error: too few arguments to function 'PA_LoadBgMap'
main.c:475: error: expected ')' before '_Info'
main.c:475: warning: passing argument 1 of 'PA_GetPAGfxBgSize' makes integer from pointer without a cast
main.c:475: error: too few arguments to function 'PA_GetPAGfxBgSize'

Ca fait bcp... lol

[raphzore]

Je vais tenter de t'aider, mais j'ai aucune idée de comment marchent les background/palettes. T'es prévenu !

Once again, revenons à nos fondamentaux mes frères .
Voici le saint code :

Code

(c):
#define PA_LoadTiledBg(screen, bg_number, bg_name){\
	PA_LoadBgPal(screen, bg_number, (void*)bg_name##_Pal); \
	PA_LoadSimpleBg(screen, bg_number, bg_name##_Tiles, bg_name##_Map, PA_GetPAGfxBgSize(bg_name##_Info[1], bg_name##_Info[2]), 0, 1);}
 

On voit ici que PA_LoadTiledBg(...) n'est pas une fonction, mais une macro ! D'où tes erreurs imcompréhensibles.

Cette chose là : "bg_name##_Pal" fait deux choses. Elle tente de "stringuifier" l'argument bg_name et de le concaténer à _Pal. Seulement c'est pas possible, (void*)buffer[1] ça l'inspire pas des masses .

Alors qu'est-ce que "stringuifier" et qu'est-ce que fait exactement une macro ?

Mettons que tu fasses cet appel (valide) :

Code

(c):
PA_LoadTiledBg(1, 6, "kingOfZeStrings")

Le préprocesseur du compilateur va construire ce code :

Code

(c):
{PA_LoadBgPal(1, 6, (void*)kingOfZeStrings_Pal);
PA_LoadSimpleBg(1, 6, kingOfZeStrings_Tiles, kingOfZeStrings_Map, PA_GetPAGfxBgSize(kingOfZeStrings_Info[1], kingOfZeStrings_Info[2]), 0, 1);}
 

Le préprocesseur ne touche qu'à la forme de ton texte (un peu comme un "remplacer X par Y" dans ton IDE).

Au final, l'adresse mémoire de ta palette est le contenu de la variable kingOfZeStrings_Pal. Si tu veux t'en convaincre, suis les appels de PA_LoadBgPal et regarde ce que devient kingOfZeStrings_Pal: elle te mènera à un DMACopy en bonne et due forme.

Pour la solution (passablement satisfaisante) maintenant :

Déclare 4 variables, et initialise les comme cela :

Code

(c):
(void *) R0BG0_Info = &buffer[0];
(void *) R0BG0_Map = &buffer[1];
(void *) R0BG0_Pal = &buffer[2];
(void *) R0BG0_Tiles = &buffer[3];

En supposant que tu as loadé "R0BG0_Info.bin" dans buffer[0], ....

Ensuite appelle la macro comme cela :

Code

(c):
PA_LoadTiledBg(1, 2, "R0BG0");

Et normalement ça devrait marcher.

Deuxième option, tu peux aussi tricher et appeler directement :

Code

(c):
{PA_LoadBgPal(1, 6, (void*)buffer[X]);
PA_LoadSimpleBg(1, 6, buffer[X'], buffer[X''], PA_GetPAGfxBgSize(buffer[X'''][1], buffer[X'''][2]), 0, 1);}

En espérant ne pas avoir dit de bétises et que tu aies compris ce qui se passait derrière tout ça.

[Mollusk]

Alors, c'est presque ça En fait, je crois qu'il y a encore une macro derrière qui fait sizeof pour avoir la taille des tiles, donc on peut pas s'en tirer si 'facilement'

Je pense que la meilleure solution serait de ripper la fonction pour charger les fonds depuis PAFS et l'adapter pour FAT :

Code

(c):
extern inline void PA_FSBgLoad(u8 screen, u8 bg_number, u32 filenumber)  {  
	PA_EasyBgLoadEx(screen, bg_number, (u32*)PA_PAFSFile(filenumber), PA_PAFSFile(filenumber+3), PA_FSFile[filenumber+3].Length, PA_PAFSFile(filenumber+1), PA_FSFile[filenumber+1].Length, (void*)(PA_PAFSFile(filenumber+2)));
}

Ca prend filenumber+1 et tout parce que PAFS classe dans l'ordre alphabétique, donc après faut regarder (truc_Pal avant truc_Tiles, mais après truc_Map, etc...). Là, tu peux refiler les buffers et la taille des fichiers (pour les tiles il est très possible que ce soit taille/2 car taille en u16, il faudra vérifier :s pour le savoir, tu charges avec taille/2, si tu vois qu'il manque des tiles c'est pas bon, sinon c'est que c'est bon    )

[raphzore]

J'avoue que j'ai pas regardé toute l'arborescence d'appels de la fonction . Je me suis contenté de PA_FSBgLoad.

J'ai été négligeant .

[Mollusk]

Nan mais c'est pas ta faute, tu peux pas savoir que j'ai foutu des trucs malsains tout le long Parce que bon, les macros comme ça, ça simplifie la vie, mais globalement c'est pas ce que je conseille le plus, dès qu'on a besoin de pointeurs ou autre ça chie

[Zombie]

Bon, alors...

J'ai compris ton explication raphzore mais pas tout à fait la rectification de Mollusk 
Enfin, plus ou moins quand même...

Mais pourquoi la macro derrière ne saurais pas faire le sizeof en utilisant la méthode décrite par raphzore ?

Sinon, dites moi si j'ai capté si je dois adapter la fonction PAFS pour le faire en FAT...
J'ai trouvé dans la lib, la fonction PA_EasyBgLoadEx qui donne :

Code

(c):
void PA_EasyBgLoadEx(u8 screen, u8 bg_number, u32 *Infos, void *Tiles, u32 TileSize, void *Map, u32 MapSize, void *Palette);
 

Donc en reprenant ceci :

Code

(c):
void * buffer[50];
u32 * bufferInfo;
 
(u32 *) R0BG0_Info = &bufferInfo;
(void *) R0BG0_Map = &buffer[1];
(void *) R0BG0_Pal = &buffer[2];
(void *) R0BG0_Tiles = &buffer[3];
 

Ca donnera donc ca :

Code

(c):
PA_EasyBgLoadEx(1, 3, R0BG0_Info, R0BG0_Tiles, size of R0BG0_Tiles, R0BG0_Map, size of R0BG0_Map, R0BG0_Pal);
 

les size of étant récupérés lors du chargements des fichiers bin.

On est d'accord ? 

[Pouer]

Déjà merci raphzore j'ai pas fini de lire toutes les réponses mais tu vient de m'apprendre un truc que je ne connaissait pas et qui me bloquer dans le tonc c'est les ##_Pal ... en faite cela permet de rajouter quelque chose au nom de la variable c'est bien cela ?
Sinon une petite question __attribute__ ((aligned (4))) apre la declaration d'un tableau ca sert a quoi ?

[Mollusk]

Le truc align, c'est pour s'assurérer que l'adresse d'un tableau sera bien un multiple de 4. En fait, tu pourrais avoir un tableau à n'importe qu'elle adresse, mais si tu dois pour une raison X ou Y lire 16bits par 16 ou 32 par 32, la DS a besoin que les données soient correctement alignées.

Pour le ##_Pal, tout a fait

Zombie, en fait le sizeof c'est pas magique du tout Ca permet d'avoir la taille au moment de la compilation, mais ça ne permet pas d'avoir la taille quand tu malloc ou autre, donc ça ira pas pour le FAT non plus. Par contre, la fonction EasyBgLoadEx utilise, comme tu le vois, une structure nommée Info, qui elle contient des infos clés : le type de fond (parce qu'en fait sous l'appellation simplifiée EasyBg tu peux avoir 3 types : fond normal (limité à 512x512 et 1024 tiles), fond avec grande map (1024 tiles, mais plus de 512x512), ou freestyle (tiles infinies (dans la limite finie du possible) et grandes maps). Il te faut donc le truc info qui donne à la fois le type, et les dimensions de la map (genre 256x192).

Ensuite, donc, pas de sizeof possible, mais tu peux avoir la taille du fichier truc_Tiles.bin, donc en l'utilisant ça devrait aller.

L'idéal, ça serait de faire une fonction toute belle à qui tu passerais le nom de ton fond, qui chercherait les fichiers _Tiles.bin, etc..., ferait des mallocs pour copier ça en ram, chargerait le tout, puis libèrerait la mémoire . La seule limite étant que dans le cas des maps de plus de 512x512 (qui sont en partie software car la DS, par défaut, ne gère que 512x512 pour un fond en tiles non rotatif), il faut les avoir en mémoire tant qu'on utilise le fond pour pouvoir scroller au-delà des limites de la DS :/
Donc en fait, une fonction qui libèrerait la mémoire si possible (Info[0] = 2) et qui sinon renverrait le pointeur vers la map pour qu'on puisse libérer à la main quand on a finit.
Ou encore Pareil, mais tu stockes les données dans un tableau de pointeurs, genre mesmaps[2][4] pour couvrir les 4 fonds possibles et les 2 écrans, tu fous le pointeur des données de la map dedans, et quand tu charges une map, tu fais regarder si déjà alloué ou pas

[Zombie]

J'ai juste 2 fonds à chargés. Les 2 font 256x192, tout simplement

Et un des 2 (celui qui est superposé au 1er) doit bouger de gauche à droite en boucle...

Donc, pas de problème pour la mémoire et la limite

Donc, la solution de mon précédent message irait finalement ? (je n'ai l'occasion de tester que ce soir)
Ai-je vraiment besoin de connaître les infos dont tu me parles ? Je suppose que mon fond se situe dans la catégorie "fond normal"... Et en passant le truc info a la fonction comme je le fais là, elle aura les infos du type et de la map non ? Du coup, je met quoi à la place de u32 MapSize ?