Scrolling, aidez moi !!! - Page 1

qq'un pourait me dire comment faire un scrolling pixel par pixel , fluide si possible (ou si il connait un site qui propose ce genre d'explication [en frensh si possible ])
Merci

je te conseille de tout réafficher à chaque cycle: il faut que ton plan à scroller soit découpé en sprites (16*16 ou 32*32 par ex) et que tu aies des routines d'affichage clippées. A partir de là, tu fais deux boucles for imbriquées qui te permettront de recouvrir l'écran à chaque cycle, tu auras juste à décaler tes coordonnées d'affichage correctement, pour que l'utilisateur aie l'illusion de défilement d'un décor.

Extgraph intègre des routines de scrolling rapides., ainsi que GraphX (mais je pense qu'extgraph sera plus adapté à ton cas).
Sinon, si ton image est décomposée en tiles, tu peux utiliser n'importe quelle lib graphique (ExtGraph, GraphX, xlib ou Genlib), sachant que la plus rapide (mais aussi la plus grosse) est Xlib.

C assez rapide ?? (au fait Nerick, C quand la premiere beta Rayman ??? STP dis moi)

Au niveau de la rapidité, si tu utilises la technique de Nerick, c'est intéressant que si tu scrolles par pas de 2 pixels (en imaginant que tu aies tout un jeu autour qui bouffe un peu de ressources).

Au fait, j'avais fait un code qui marchait pas ca donnez ça, j'avait un tableau ou j'avais enregistré les tiles, puis, deux boucles for lisaient la Map du niveau et affichez le Sprite selon son numero
//
for (...)
{
for (...)
{
i=Map[y][x];
Sprite16 (X,Y,16,NumTile[i],GetPlane(0),SPRT_OR);
Sprite16 (X,Y,16,NumTile[i],GetPlane(1),SPRT_OR);
}
}

mais il m'archait pô

Tu voulais que ça scrolles ou bien juste que ça affiche ta map ?
Et puis il faudrait qu'on voie ce qu'il y a dans les for(...)

je voulai juste que ca lise la carte, je souvint plus ce que j'avais mis dans les for.
Je crois que j'avais mis une valeur pour qu'il affiche juste le nombre de tile voulu, etj'avais fait un autre essai avec une valeur dans les for pour qu'il aille jusqu'au bord de la carte (les deux marche pô)

Il faut faire ça :

for(x=0;x<10;x++)
 for(y=0;y<6;y++)
  Sprite16(x*16,y*16,16,sprt,LCD_MEM,A_NORMAL);

for(x=0;x<10;x++)
for(y=0;y<6;y++)
Sprite16(x*16,y*16,16,sprt,LCD_MEM,A_NORMAL);

j'avais aussi fait comme ça et ça marchait pô, l'ecrn restait vide

Si par hasard tu veux faire un scrolling qui ne serait pas pixel par pixel (ça n'est pas ce que tu veux faire, mais je te le signale car il pourrait t'intéresser si tu changes de méthodes, ou dans un autre projet), il y a aussi FastScroll de Scott Noveck. Cependant, pour le scrolling pixel par pixel, FastScroll est beaucoup plus lent:
// SPEED ANALYSIS
//
// Each shift requires 8+6 = 14 clocks (including effective address calculation)
// for a TOTAL of 210*n clocks to scroll one line by n pixels


// COMPARISON - for all 128 lines:
// Note that the method varies larger shifts -- don't make assumptions from the first few comparisons
// These numbers are valid for the 92+/v200 only; the results must be adjusted for the 89
//
// To scroll ONE pixel:
// Method 1: Simple Scroll (from ExtGraph) Approx. 26,880 clocks
// Method 2: Advanced Scroll (above) Approx. 60,160 clocks
// Result - use Simple Scroll
//
// To scroll TWO pixels:
// Method 1: Simple Scroll Approx. 53,760 clocks
// Method 2: Advanced Scroll Approx. 62,208 clocks
// Result - use Simple Scroll
//
// To scroll THREE pixels:
// Method 1: Simple Scroll Approx. 80,640 clocks
// Method 2: Advanced Scroll Approx. 64,256 clocks
// Result - use Advanced Scroll
//
// To scroll FOUR pixels:
// Method 1: Simple Scroll Approx. 107,520 clocks
// Method 2: Advanced Scroll Approx. 66,304 clocks
// Result - use Advanced Scroll
//
// To scroll FIVE pixels:
// Method 1: Shift screen by a full byte (8 pixels), [46,080 clocks]
// then Simple Scroll 3 px in opposite direction Approx. 128,700 clocks
// Method 2: Advanced Scroll Approx. 68,352 clocks
// Result - use Advanced Scroll
//
// To scroll SIX pixels:
// Method 1: Shift screen by a full byte (8 pixels), [46,080 clocks]
// then Simple Scroll 2 px in opposite direction Approx. 99,840 clocks
// Method 2: Advanced Scroll Approx. 70,400 clocks
// Result - use Advanced Scroll
//
// To scroll SEVEN pixels:
// Method 1: Shift screen by a full byte (8 pixels), [46,080 clocks]
// then Simple Scroll 1 px in opposite direction Approx. 72,960 clocks
// Method 2: Advanced Scroll Approx. 72,448 clocks
// Result - use Advanced Scroll
//
// To scroll EIGHT pixels:
// Shift the screen by a full byte 46,080 clocks
//
// To scroll NINE pixels:
// Method 1: Shift screen by a full byte (8 pixels), [46,080 clocks]
// then Simple Scroll 1 px in same direction Approx. 72,960 clocks
// Method 2: Advanced Scroll Approx. 76,544 clocks
// Result - shift by a full byte, then use Simple Scroll
//
// To scroll TEN pixels:
// Method 1: Shift screen by a full byte (8 pixels), [46,080 clocks]
// then Simple Scroll 2 px in same direction Approx. 99,840 clocks
// Method 2: Advanced Scroll Approx. 78,592 clocks
// Result - use Advanced Scroll
//
// To scroll ELEVEN pixels:
// Method 1: Shift screen by a full byte (8 pixels), [46,080 clocks]
// then Simple Scroll 3 px in same direction Approx. 128,700 clocks
// Method 2: Advanced Scroll Approx. 80,640 clocks
// Result - use Advanced Scroll
//
// To scroll TWELVE pixels:
// Method 1: Shift screen by a full word (16 pixels), [23,040 clocks]
// then Simple Scroll 4 px in opposite direction Approx. 130,560 clocks
// Method 2: Advanced Scroll Approx. 82,688 clocks
// Result - use Advanced Scroll
//
// To scroll THIRTEEN pixels:
// Method 1: Shift screen by a full word (16 pixels), [23,040 clocks]
// then Simple Scroll 3 px in opposite direction Approx. 103,680 clocks
// Method 2: Advanced Scroll Approx. 84,736 clocks
// Result - use Advanced Scroll
//
// To scroll FOURTEEN pixels:
// Method 1: Shift screen by a full word (16 pixels), [23,040 clocks]
// then Simple Scroll 3 px in opposite direction Approx. 76,800 clocks
// Method 2: Advanced Scroll Approx. 86,784 clocks
// Result - shift by a full word, then use Simple Scroll
//
// To scroll FIFTEEN pixels:
// Method 1: Shift screen by a full word (16 pixels), [23,040 clocks]
// then Simple Scroll 3 px in opposite direction Approx. 49,920 clocks
// Method 2: Advanced Scroll Approx. 88,832 clocks
// Result - shift by a full word, then use Simple Scroll
//
// To scroll SIXTEEN pixels:
// Shift the screen by a full word 23,040 clocks
//
//
// So, for the fastest possible scrolling:
//
// 1 pixel - Simple Scroll
// 2 pixels - Simple Scroll
// 3 pixels - Advanced Scroll
// 4 pixels - Advanced Scroll
// 5 pixels - Advanced Scroll
// 6 pixels - Advanced Scroll
// 7 pixels - Advanced Scroll
// 8 pixels - Shift by a full byte
// 9 pixels - Shift by a full byte, then use Simple Scroll
// 10 pixels - Advanced Scroll
// 11 pixels - Advanced Scroll
// 12 pixels - Advanced Scroll
// 13 pixels - Advanced Scroll
// 14 pixels - Shift by a full word, then use Simple Scroll in opposite direction
// 15 pixels - Shift by a full word, then use Simple Scroll in opposite direction
// 16 pixels - Shift by a full word

Je n'ai pas de lien (c'est sur scott.ticalc.org, mais je n'ai pas le lien exact). Kevin ?

Je ne sais plus le lien par cœur, et je n'arrive pas à retrouver le topic avec le moteur de recherche de ezBoard. Il faudra probablement rechercher avec Board Reader.

Bon, j'ai essayé de deviner l'URL et j'ai trouvé du premier coup:
http://scott.ticalc.org/fastscroll.zip

merci beaucoup

Au fait, si G bien compris, pour une map avec des tiles, il suffit que je redessine tout les tiles a chaques fois. OK,
mais si je veux faire scroller une image, comment je fait ??? je prend une image plus grand que l'ecran et je l'affiche morceau par morceau???

Moi aussi j'aimerai faire un scrolling de map mais on me parle de tiles...Je peux paraître chian mais y'a un truc que j'ai pas compris, c'est quoi un tile? C'est une partie d'image qu'on enregistre? Ya pas une doc quelque part pour comprendre?
Aussi ya pas une source qui montre comment utiliser les fonction de scrolling des libs comme extgraph, graphx...

be en fait un tile C un petit sprite, t'a ta map
map[size][size] = {{0,0,0,0,1,1,0,1,0},
{0,0,0,0,0,0,0,0,0}};
...etc, un tile C un des sprites qui constitue la map, quand tu lira un 1 dans la map, tu affichera le sprite qui correspond au 1 etc...
C comme ca que sont fait les map, par plusieurs petites sprites, ta de bon exemples avec Mario, Zelda ... et autre jeux. Si tu regarde attentivement, tu verra que l'herbe (pour Zela) n'est faite que par succession d'un même tile (ou sprite);
N'empeche je suis d'accord avec toi pour avoir une source explicative de comment utiliser les fonction scrolling de EsxtGraph ...

Je pense que tu devrais tout redessiner c plus efficace
et pour le scrolling, tu fais juste un decalage.

ban ca dépend de ce qu'il veut faire ... et de ce qu'il utilise comme libaririe graphique

j'utilise ExtGraph (qui gere le scrolling je crois)

De toute façon tu arriveras pas à tout réafficher correctement si t'as pas de routine de sprites clippées. Or celles d'Extgraph ne le sont pas.
Donc tu peux soit utiliser le scrolling d'Extgraph (mais c'est très limité, c bon si tu n'as pas de collisions à gérer avec le plan que tu scrolles), soit faire tes propres routines de sprites, soit changer de lib.
Je te conseille la dernière solution, et d'utiliser Genlib. Elle est très puissante, rapide et très simple d'utilisation (une fois que tu as lu la doc traduite en français par Ximoon).

Moi, je te déconseille complètement d'utiliser genlib. C'est une librairie dynamique, donc moins pratique qu'une librairie statique, et elle est aussi moins flexible, plus grosse et moins simple d'utilisation que ExtGraph.

Nerick
a écrit : Je te conseille la dernière solution, et d'utiliser Genlib. Elle est très puissante, rapide et très simple d'utilisation (une fois que tu as lu la doc traduite en français par Ximoon).

Kevin Kofler a écrit :
Moi, je te déconseille complètement d'utiliser genlib. C'est une librairie dynamique, donc moins pratique qu'une librairie statique, et elle est aussi moins flexible, plus grosse et moins simple d'utilisation que ExtGraph.

Vous avez deux points de vue complètement différents.
Essaie les deux et prends celle que tu préfères (genlib est plus puissante, quand même, mais extgraph prendra probablement moins de place).

Oui mais elle ne gère pas ce dont il a besoin pour "scroller" sa map.

>Or celles d'Extgraph ne le sont pas.
Celles d'ExtGraph, non. Mais il y a des routines clippées dans le GCK de TICT.

>(mais c'est très limité, c bon si tu n'as pas de collisions à gérer avec le plan que tu scrolles)
Pareil, il y a des routines de collisions, au pixel, dans le GCK de TICT.

Le GCK peut être trouvé en bêta à (j'espère) http://ftp.ticalc.org/tict/beta/gck035_src.zip

Non, le lien ne marche pas... Peut-être http://ftp.ticalc.org/beta/gck035_src.zip

Non, toujours pas...

bah en tt cas, il peut se demerder tout seul pour le scroll avec les fcts d'EXTgraph, nan ?

il suffit alors de modifier les routines de EXTgraph pour intégrer les collisions (de EXTgraph toujours ...)