Derniers sujets
Qui est en ligne ?
Il y a en tout 3 utilisateurs en ligne :: 0 Enregistré, 0 Invisible et 3 Invités Aucun
Le record du nombre d'utilisateurs en ligne est de 29 le Mer 25 Fév 2015 - 14:01
Connexion
Statistiques
Nous avons 241 membres enregistrésL'utilisateur enregistré le plus récent est ben_frog
Nos membres ont posté un total de 8921 messages dans 811 sujets
afficher un sprite au pixel près, quelle méthode optimale ?
+2
Jede
goyo
6 participants
Forum Oric :: Forums :: Forum Public :: Assembleur
Page 1 sur 1
afficher un sprite au pixel près, quelle méthode optimale ?
Je souhaiterais afficher un sprite de 4 octets de large au pixel près. Pour cela j'utilise l'opcode ROR avec un shift = décalage de 0 à 5 pixel.
Le problème est que suivant le décalage en cours, la vitesse d'affichage sera très différente . Puisque si shift = 0 l'affichage sera rapide car dans ce cas pas de traitement au niveau des pixels, mais si le décalage est de 5 ce sera beaucoup plus lent car il exécutera 5 x la boucle avec l'instruction ROR pour l'octet courant du sprite + ROR de l'octet précédent pour récupérer ses bits.
Quelle est donc la meilleurs méthode pour afficher un sprite au pixel près ? et pour équilibrer le timing suivant le décalage du sprite... ??
Le problème est que suivant le décalage en cours, la vitesse d'affichage sera très différente . Puisque si shift = 0 l'affichage sera rapide car dans ce cas pas de traitement au niveau des pixels, mais si le décalage est de 5 ce sera beaucoup plus lent car il exécutera 5 x la boucle avec l'instruction ROR pour l'octet courant du sprite + ROR de l'octet précédent pour récupérer ses bits.
Quelle est donc la meilleurs méthode pour afficher un sprite au pixel près ? et pour équilibrer le timing suivant le décalage du sprite... ??
- Code:
....
cpx #0 ; less than 1 = 0 so branch
beq no_shift
loop_shift
ror byte ; shift the current byte of the sprite to the right C-> b7 b0 -> C
lda byteprev ; previous current byte of the sprite
bit bitflag ; check the 1rst bit of prev byte
beq bitelse ;IF BIT0 !=1 then Branch to ELSE
; else put 1 in bit 5
lda byte
ora #32
sta byte
jmp bit1end
bitelse: ; ELSE
lda byte
and #223 ; clear bit n°5
sta byte
bit1end
clc
ror byteprev
dex
cpx #0
bne loop_shift
no_shift
lda byte
ora #64 ; set bit 64 BITMAP mode
and #127 ; clear bit 127 No Inverse
sta byte
...
- Fichiers joints
goyo- Messages : 199
Date d'inscription : 02/05/2014
Age : 52
Localisation : Massy
Re: afficher un sprite au pixel près, quelle méthode optimale ?
goyo a écrit:Je souhaiterais afficher un sprite de 4 octets de large au pixel près. Pour cela j'utilise l'opcode ROR avec un shift = décalage de 0 à 5 pixel.
Le problème est que suivant le décalage en cours, la vitesse d'affichage sera très différente . Puisque si shift = 0 l'affichage sera rapide car dans ce cas pas de traitement au niveau des pixels, mais si le décalage est de 5 ce sera beaucoup plus lent car il exécutera 5 x la boucle avec l'instruction ROR pour l'octet courant du sprite + ROR de l'octet précédent pour récupérer ses bits.
Quelle est donc la meilleurs méthode pour afficher un sprite au pixel près ? et pour équilibrer le timing suivant le décalage du sprite... ??
- Code:
....
cpx #0 ; less than 1 = 0 so branch
beq no_shift
loop_shift
ror byte ; shift the current byte of the sprite to the right C-> b7 b0 -> C
lda byteprev ; previous current byte of the sprite
bit bitflag ; check the 1rst bit of prev byte
beq bitelse ;IF BIT0 !=1 then Branch to ELSE
; else put 1 in bit 5
lda byte
ora #32
sta byte
jmp bit1end
bitelse: ; ELSE
lda byte
and #223 ; clear bit n°5
sta byte
bit1end
clc
ror byteprev
dex
cpx #0
bne loop_shift
no_shift
lda byte
ora #64 ; set bit 64 BITMAP mode
and #127 ; clear bit 127 No Inverse
sta byte
...
Le plus rapide est de faire le précalcul des shifts. C'est à dire que le décalage se fait avant avec un logiciel (en natif, il y a un soft de Twilighte qui le fait) Sinon, avec un soft de dessin sur PC.). Les images sont stockées dans le code et en fonction de la position, l'offset de lecture du sprite change.
Cela mange un peu de ram, mais c'est ce qu'il y a de plus rapide.
Jede- Messages : 308
Date d'inscription : 20/04/2016
Localisation : Var
Re: afficher un sprite au pixel près, quelle méthode optimale ?
La meilleur méthode est celle donnée par Jede, une alternative est d'utiliser des tables pour les parties gauches/droites de rotation qui prennent en compte directement les valeurs a conserver.
_________________
Dbug- Messages : 248
Date d'inscription : 06/01/2013
Re: afficher un sprite au pixel près, quelle méthode optimale ?
Si je vous ai bien compris c'est mieux avec des tableaux d'octets en rotation pré calculés qui contiennent toutes les combinaisons d'octets sur 6 bits ...
un peu comme dans le code suivant : ?
un peu comme dans le code suivant : ?
- Code:
lda SprByte
.
.
tay
ldx bitshift ; get shift value from bitshiftable indexed from posX
cpx #0
bcc jumpShift0
lda STableShift0,y
jumpShift0
cpx #1
bcc jumpShift1
lda STableShift1,y
jumpShift1
cpx #2
bcc jumpShift2
lda STableShift2,y
jumpShift2
cpx 3
bcc jumpShift3
lda STableShift3,y
jumpShift3
cpx #4
bcc jumpShift4
lda STableShift4,y
jumpShift4
cpx #5
bcc jumpShift5
lda STableShift5,y
jumpShift5
.
.
.
STableShift0 ; shift tables of 64 first values of byte
.byt %00000000,%00000001,%00000010,%00000011
.byt %00000100,%00000101,%00000110,%00000111
.byt %00001000,%00001001,%00001010,%00001011
.byt %00001100,%00001101,%00001110,%00001111
.byt %00010000,%00010001,%00010010,%00010011
.byt %00010100,%00010101,%00010110,%00010111
.byt %00011000,%00011001,%00011010,%00011011
.byt %00011100,%00011101,%00011110,%00011111
.byt %00100000,%00100001,%00100010,%00100011
.byt %00100100,%00100101,%00100110,%00100111
.byt %00101000,%00101001,%00101010,%00101011
.byt %00101100,%00101101,%00101110,%00101111
.byt %00110000,%00110001,%00110010,%00110011
.byt %00110100,%00110101,%00110110,%00110111
.byt %00111000,%00111001,%00111010,%00111011
.byt %00111100,%00111101,%00111110,%00111111
STableShift1 ; same than previous table with a shift of 1
.byt %00000000,%00000000,%00000001,%00000001
.byt %00000010,%00000010,%00000011,%00000011
.byt %00000100,%00000100,%00000101,%00000101
.byt %00000110,%00000110,%00000111,%00000111
.byt %00001000,%00001000,%00001001,%00001001
.byt %00001010,%00001010,%00001011,%00001011
.byt %00001100,%00001100,%00001101,%00001101
.byt %00001110,%00001110,%00001111,%00001111
.byt %00010000,%00010000,%00010001,%00010001
.byt %00010010,%00010010,%00010011,%00010011
.byt %00010100,%00010100,%00010101,%00010101
.byt %00010110,%00010110,%00010111,%00010111
.byt %00011000,%00011000,%00011001,%00011001
.byt %00011010,%00011010,%00011011,%00011011
.byt %00011100,%00011100,%00011101,%00011101
.byt %00011110,%00011110,%00011111,%00011111
STableShift2
.byt %00000000,%00000000,%00000000,%00000000
.byt %00000001,%00000001,%00000001,%00000001
.byt %00000010,%00000010,%00000010,%00000010
.byt %00000011,%00000011,%00000011,%00000011
.byt %00000100,%00000100,%00000100,%00000100
.byt %00000101,%00000101,%00000101,%00000101
.byt %00000110,%00000110,%00000110,%00000110
.byt %00000111,%00000111,%00000111,%00000111
.byt %00001000,%00001000,%00001000,%00001000
.byt %00001001,%00001001,%00001001,%00001001
.byt %00001010,%00001010,%00001010,%00001010
.byt %00001011,%00001011,%00001011,%00001011
.byt %00001100,%00001100,%00001100,%00001100
.byt %00001101,%00001101,%00001101,%00001101
.byt %00001110,%00001110,%00001110,%00001110
.byt %00001111,%00001111,%00001111,%00001111
STableShift3
.byt %00000000,%00000000,%00000000,%00000000
.byt %00000000,%00000000,%00000000,%00000000
.byt %00000001,%00000001,%00000001,%00000001
.byt %00000001,%00000001,%00000001,%00000001
.byt %00000010,%00000010,%00000010,%00000010
.byt %00000010,%00000010,%00000010,%00000010
.byt %00000011,%00000011,%00000011,%00000011
.byt %00000011,%00000011,%00000011,%00000011
.byt %00000100,%00000100,%00000100,%00000100
.byt %00000100,%00000100,%00000100,%00000100
.byt %00000101,%00000101,%00000101,%00000101
.byt %00000101,%00000101,%00000101,%00000101
.byt %00000110,%00000110,%00000110,%00000110
.byt %00000110,%00000110,%00000110,%00000110
.byt %00000111,%00000111,%00000111,%00000111
.byt %00000111,%00000111,%00000111,%00000111
STableShift4
.byt %00000000,%00000000,%00000000,%00000000
.byt %00000000,%00000000,%00000000,%00000000
.byt %00000000,%00000000,%00000000,%00000000
.byt %00000000,%00000000,%00000000,%00000000
.byt %00000001,%00000001,%00000001,%00000001
.byt %00000001,%00000001,%00000001,%00000001
.byt %00000001,%00000001,%00000001,%00000001
.byt %00000001,%00000001,%00000001,%00000001
.byt %00000010,%00000010,%00000010,%00000010
.byt %00000010,%00000010,%00000010,%00000010
.byt %00000010,%00000010,%00000010,%00000010
.byt %00000010,%00000010,%00000010,%00000010
.byt %00000011,%00000011,%00000011,%00000011
.byt %00000011,%00000011,%00000011,%00000011
.byt %00000011,%00000011,%00000011,%00000011
.byt %00000011,%00000011,%00000011,%00000011
STableShift5
.byt %00000000,%00000000,%00000000,%00000000
.byt %00000000,%00000000,%00000000,%00000000
.byt %00000000,%00000000,%00000000,%00000000
.byt %00000000,%00000000,%00000000,%00000000
.byt %00000000,%00000000,%00000000,%00000000
.byt %00000000,%00000000,%00000000,%00000000
.byt %00000000,%00000000,%00000000,%00000000
.byt %00000000,%00000000,%00000000,%00000000
.byt %00000001,%00000001,%00000001,%00000001
.byt %00000001,%00000001,%00000001,%00000001
.byt %00000001,%00000001,%00000001,%00000001
.byt %00000001,%00000001,%00000001,%00000001
.byt %00000001,%00000001,%00000001,%00000001
.byt %00000001,%00000001,%00000001,%00000001
.byt %00000001,%00000001,%00000001,%00000001
.byt %00000001,%00000001,%00000001,%00000001
bitshiftable
.byt 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5
.byt 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5
.byt 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5
.byt 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5
.byt 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5
.byt 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5
.byt 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5
.byt 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5
goyo- Messages : 199
Date d'inscription : 02/05/2014
Age : 52
Localisation : Massy
Re: afficher un sprite au pixel près, quelle méthode optimale ?
Le code peut être plus simple que cela.
Il faut faire une table qui va pointer sur les données du sprite (le code suivant peut être fait de différente manière, et surtout l'affichage peut se faire en code déroulé ou pas, en fonction de ce qu'on veut ):
L'exemple ci dessous c'est juste pour montrer l'utilisation de tables.
Il faut faire une table qui va pointer sur les données du sprite (le code suivant peut être fait de différente manière, et surtout l'affichage peut se faire en code déroulé ou pas, en fonction de ce qu'on veut ):
L'exemple ci dessous c'est juste pour montrer l'utilisation de tables.
- Code:
; Y contient la position à afficher
lda table_shift_sprites_low,y
sta $00
lda table_shift_sprites_high,y
sta $01
; et ici on peut commencer à afficher avec la page 0
ldy #$00
lda ($00),y
...
table_shift_sprites_high:
.byt >sprite_shift0
.byt >sprite_shift1
table_shift_sprites_low:
.byt <sprite_shift0
.byt <sprite_shift1
sprite_shift0:
.byt XX
sprite_shift1:
.byt XX
Dernière édition par Jede le Mar 17 Sep 2019 - 22:57, édité 4 fois
Jede- Messages : 308
Date d'inscription : 20/04/2016
Localisation : Var
Re: afficher un sprite au pixel près, quelle méthode optimale ?
Dbug a écrit:La meilleur méthode est celle donnée par Jede, une alternative est d'utiliser des tables pour les parties gauches/droites de rotation qui prennent en compte directement les valeurs a conserver.
C'est tout bete comme solution et ... très efficace. je ne programme vraiment plus assez pour avoir le réflexe des tables pré-programmées.
Il est loin le temps des demos sur st et amiga, boostées à coups de tables de sinus
Dernière édition par didierv le Mer 18 Sep 2019 - 21:58, édité 1 fois
_________________
DidierV - CEO Mag
alias coco.oric sur Defence-Force
Re: afficher un sprite au pixel près, quelle méthode optimale ?
Hoooo !! un amigaiste !!! Le monde est petit.....
Oric1-Atmos- Messages : 102
Date d'inscription : 08/03/2017
Localisation : 49
Moonchild- Messages : 51
Date d'inscription : 05/08/2014
Age : 51
Localisation : Albigny Sur Saône
Re: afficher un sprite au pixel près, quelle méthode optimale ?
Merci Jede.
En fait je suis débutant en assembleur (avec un petit peu 40 ans de retard pour m'y mettre), je suis loin d'avoir ton niveau, je vais essayer comprendre ton exemple.
Je n'ai pas encore utilisé la page 0 pour l'affichage mais le mode "patch".
J'ai l'impression que tu utilises un tableau de tableau ?
Je ne comprends pas à quoi correspond shift high et shift low ?
En fait je suis débutant en assembleur (avec un petit peu 40 ans de retard pour m'y mettre), je suis loin d'avoir ton niveau, je vais essayer comprendre ton exemple.
Je n'ai pas encore utilisé la page 0 pour l'affichage mais le mode "patch".
J'ai l'impression que tu utilises un tableau de tableau ?
Je ne comprends pas à quoi correspond shift high et shift low ?
Jede a écrit:Le code peut être plus simple que cela.
Il faut faire une table qui va pointer sur les données du sprite (le code suivant peut être fait de différente manière, et surtout l'affichage peut se faire en code déroulé ou pas, en fonction de ce qu'on veut ):
L'exemple ci dessous c'est juste pour montrer l'utilisation de tables.
- Code:
; Y contient la position à afficher
lda table_shift_sprites_low,y
sta $00
lda table_shift_sprites_high,y
sta $01
; et ici on peut commencer à afficher avec la page 0
ldy #$00
lda ($00),y
...
table_shift_sprites_high:
.byt >sprite_shift0
.byt >sprite_shift1
table_shift_sprites_low:
.byt <sprite_shift0
.byt <sprite_shift1
sprite_shift0:
.byt XX
sprite_shift1:
.byt XX
goyo- Messages : 199
Date d'inscription : 02/05/2014
Age : 52
Localisation : Massy
Re: afficher un sprite au pixel près, quelle méthode optimale ?
Pour mes besoins persos, en général j'y vais bien plus simple, et je me fait une image avec mon sprite dans les 6 positions et je laisse PictConv me convertir ca comme il faut.
Par exemple dans Quantum FX, le sprite du joueur avec tous les décalages c'est ca: (j'ai mis la couleur gris pour mettre en valeur mais normalement c'est tout noir.)
Par exemple dans Quantum FX, le sprite du joueur avec tous les décalages c'est ca: (j'ai mis la couleur gris pour mettre en valeur mais normalement c'est tout noir.)
_________________
Dbug- Messages : 248
Date d'inscription : 06/01/2013
Forum Oric :: Forums :: Forum Public :: Assembleur
Page 1 sur 1
Permission de ce forum:
Vous ne pouvez pas répondre aux sujets dans ce forum
Jeu 21 Mar 2024 - 8:51 par Dom50
» carte mère Oric (re)tracée
Mar 5 Mar 2024 - 18:54 par kenneth
» Meurtre à Grande Vitesse
Dim 25 Fév 2024 - 5:09 par Iurius
» ORIC-1 sur LE BON COIN
Ven 23 Fév 2024 - 23:01 par Mcar
» ORIC ATMOS sur LE BON COIN
Dim 4 Fév 2024 - 12:06 par kiwilevrai
» Problème d'affichage des couleurs avec un Oric Atmos
Sam 27 Jan 2024 - 1:26 par pierbail
» Bienvenue dans le Forum des Oriciens
Mar 9 Jan 2024 - 12:33 par Dom50
» Rencontre avec Laurant Weill, co-fondateur de Loriciel, et mon garçon de 12 ans
Ven 29 Déc 2023 - 14:13 par Arcade-des-Monts
» Bonnes fêtes
Mar 26 Déc 2023 - 10:21 par Dom50
» Murders in Venice / Meutres à Venise
Sam 18 Nov 2023 - 22:44 par retroric
» Un clavier PS/2 pour tester un ORIC
Dim 27 Aoû 2023 - 9:49 par Voyageur
» Disquette 3" Sedoric
Mar 1 Aoû 2023 - 14:22 par AtomeX
» faire un 6502 avec des phototransistor
Dim 16 Juil 2023 - 17:26 par Voyageur
» Oricutron linux et DSK
Jeu 29 Juin 2023 - 18:34 par Voyageur
» No Problem !
Dim 25 Juin 2023 - 17:53 par Voyageur