RaZ
-
Posts
402 -
Joined
-
Last visited
Posts posted by RaZ
-
-
Mis à part avoir nom à coucher dehors
, il fait quoi de beau le monsieur (ou la demoiselle, on est pas sectaire) ? -
\o/ Un game-designer/chef de projet !
On va peut être me prendre au sérieux maintenant !
-
La seule chose que je voie pour les cookies est que vous vous connecté au site via l'adresse http://www.jagware.org qui est différente de http://jagware.org, la seconde étant l'adresse de travail du site et celle du domaine des cookies.
-
Je ne suis pas vraiment sur de comprendre.
Le mot de passe est sauvegardable via cookie par simple cochage d'une case à la connexion, c'est peut être cela dont tu parles.
Maintenant, j'ai poussé la durée de la session à 12h, elle était d'une heure avant.
Et sur LDU, c'était la durée du cookie que l'on pouvait moduler.
-
Il est mignon mais une news pour chaque anniversaire, c'est sûr ca fait famille mais ça fait aussi limite. Un post dans le forum Formalisme, qui sert de toute façon de forum de discussion général par extension, pas de problème, mais une news...
Je laisse celle là parce que tu est passé au travers de la modération due à un oubli de configuration, au moins j'ai pu le remarquer, mais les suivantes, ben, y'en aura pas.
Le prend pas perso, SebRmv, passe un excellent anniversaire, juste de l'affinage au niveau du fond et de la forme.
-
J'y crois pas, il en a fait une news...
Joyeux anniversaire Sébastien !
-
Le channel #Jagware vient de pondre en communauté une idée toute simple, disons une adaptation d'un "vieux" concept.
Celui de bust a groove, ces jeux musicaux ou il fait reproduire une séquence de touches à la manette au rythme d'une musique.
L'intérêt de la Jag est son pad de 12 touches, les possibilités sont énormes avec ça.
-
-
-
-
-
-
Les Jagpads et comment les traiter :
------------------------------------
Pour les traiter, traiter les bien !!!
Trève de plaisanterie(stupide), cet article va vous expliquer comment récuperer les valeurs des pads (0 et 1) et aussi ceux des autres pads (Team Tap), pour une raison simple c'est pas plus difficile voire c'est exactement pareil !!!
En premiere partie, on va vous expliquer comment faire, sur la seconde partie, comment optimiser tout cela et oui sur ce site on vous dit même comment faire des vrais jeux Jag !!! YES !!!
Et on envoie la sauce :
Pour faire cela c'est tres simple, sisi !!
On dispose de deux registres :
Appelation officiel Atari, adresse
JOYSTICK ,$f14000
JOYBUTS ,$f14002
Vu le nombre de pad et le nombre de possibilités (comptez les touches d'un pad multiplié par 8 (Pour deux team taps !)), Atari a prévu un truc beaucoup plus simple coté gestion. Un registre permet d'indiquer les infos qu'il nous faut, suivant
le pad. Ces infos sont divisés en deux parties, d'abord suivant le pad qu'on veut interroger et ensuite la colonne. Non pas d'erreur les pads son divisés en colonnes, 4 pour etre exact, 3 du keypad et 1 pour les directions (Les fire et pause, Option sont traités un peu a part, vous verrez).
Pour résumer on va mettre une valeur dans le registre JOYSTICK et la Jag va nous renvoyer notre valeur dans ce meme registre, c'est cool non ? Quel valeur mettre ? Vu que c'est un peu la berezina dans la doc je vous ais fait un tableau qui va bien.
Mais avant de passer au tableau, il faut savoir comment sont organisé ces 4 colonnes (allant de 0 a 3)
Si on demande la colonne 3, on va récup les touches :
# 9 6 3
Si on demande la colonne 2, on va récup les touches :
0 8 5 2
Si on demande la colonne 1, on va récup les touches :
* 7 4 1
Si on demande la colonne 0, on va récup les touches :
Up Down Left Right (La position du jagpad)
+--------+-------+-------+-------+-------+ |Colonne | Pad 0 | Pad 1 | Pad 2 | Pad 3 | +--------+-------+-------+-------+-------+ | 3 | $7 | $3 | $8 | $f | +--------+-------+-------+-------+-------+ | 2 | $b | $2 | $6 | $c | +--------+-------+-------+-------+-------+ | 1 | $d | $1 | $5 | $a | +--------+-------+-------+-------+-------+ | 0 | $e | $0 | $4 | $9 | +--------+-------+-------+-------+-------+
Ceci est pour soit le joypad 0, soit le premier pad sur le team tap 1, si vous accedez au pad 0, que le team tap soit branché ou pas, cela ne change rien.
Et je mets donc cette valeur ou et comment ?
On va écrire cette valeur dans JOYSTICK ($f14000), sous la forme :
$810x : x étant la valeur du tableau que vous voulez.
(Le 81 n'y faites pas gaffe, cela permet de garder la sortie son active et sélectionner les joy, le zéro c'est pour faire une sélection sur l'autre port) donc en 68000 si vous voulez lire la colonne zéro (position du pad), du pad 0 (On regarde dans le tableau Pad 0, colonne 0 : $e) donc vous faites un :
move.w #$810e,JOYSTICK (ou move.w #$810e,$f14000 comme vous voulez)
(Vous pouvez utilise JOYSTICK si vous incluez le fichier d'include d'Atari)
et maintenant on fait cela :
move.w JOYSTICK,d0 (ou move.w $f14000,d0 comme vous voulez)
et donc vous avez donc d0 la donnée demandé. Par contre pour ce joy le données sont renvoyés en position 8-11 (4 bit), donc il faut faire un
and.w #$0f00,d0
pour nettoyer les trucs indésirables, après vous en faites ce que vous voulez !!
Petite note, les bits fonctionnent a l'envers, cela veut dire que si le bit vaut zéro la touche est appuyé, cela n'est pas une grande gêne, vous pouvez faire cela pour remettre tout cela en ordre :
not.w d0
Qui inverse d0, sinon vous adaptez votre code en conséquence, inversez les tests (!) vous faites exactement pareil pour les autres valeurs.
Cela va toujours ?
et on recommence avec l'autre joy, vous savez tout, donc juste le petit tableau qui va vous simplifié la vie :
+--------+-------+-------+-------+-------+ |Colonne | Pad 0 | Pad 1 | Pad 2 | Pad 3 | +--------+-------+-------+-------+-------+ | 3 | $e | $c | $1 | $f | +--------+-------+-------+-------+-------+ | 2 | $d | $4 | $6 | $3 | +--------+-------+-------+-------+-------+ | 1 | $b | $8 | $a | $5 | +--------+-------+-------+-------+-------+ | 0 | $7 | $0 | $2 | $9 | +--------+-------+-------+-------+-------+
Ces valeurs (en binaire) sont les mêmes que le joy 1 mais lu dans l'autre sens :
exemple : %0010 devient %0100 pour le joy 2.
ATTENTION ! Mettez vous bien en tete une chose, sur la Jag on a deux ports pour les pads : le 0 et le 1, sur chaque port on peut aller jusqu'a 4 jagpads.
Ce qui fait un total de 8. Donc si je parles du pad 1 sur le port 1, cela correspond au second joy sur le team tap du second port. N'oublies pas qu'on a pris la (sale ?) habitude de compter les zéros en info. Donc a partir de maintenant quand je parles du joy 2, cela concerne le 3 joy branche sur le team tap dans le second port de la Jag (Parce que maintenant on parle que du second port Pad)
Donc pour le port 2 en 68000 si vous voulez lire la colonne 1 (*741), du pad 3 (On regarde dans le tableau Pad 3, colonne 1 : $5) donc vous faites un :
move.w #$8150,JOYSTICK (ou move.w #$8150,$f14000 comme vous voulez)
(Vous pouvez utilise JOYSTICK si vous incluez le fichier d'include d'Atari)
et maintenant on fait cela :
move.w JOYSTICK,d0 (ou move.w $f14000,d0 comme vous voulez)
et donc vous avez donc d0 la donnée demandé. Par contre pour ce joy les données sont renvoyes en position 12-15 (4 bit), donc il faut faire un :
and.w #$f000,d0
pour nettoyer les trucs indesirables, après vous en faites ce que vous voulez !!
Still alive ?
Le plus dur est passé, les bouttons ca sert a rien !! Non on va faire un rapide passage sur les bouttons, le principe est exactement le même que pour les touches, Une sélection par JOYSTICK mais par contre la relecture des données se fait par JOYBUTS ($F14002).
On va rajoute un truc dans notre tableau (Premier tableau) :
+--------+-------+-------+-------+-------+---------------+ |Colonne | Pad 0 | Pad 1 | Pad 2 | Pad 3 | Boutton 10 | +--------+-------+-------+-------+-------+---------------+ | 3 | $7 | $3 | $8 | $f | xO | +--------+-------+-------+-------+-------+---------------+ | 2 | $b | $2 | $6 | $c | xC | +--------+-------+-------+-------+-------+---------------+ | 1 | $d | $1 | $5 | $a | xB | +--------+-------+-------+-------+-------+---------------+ | 0 | $e | $0 | $4 | $9 | PA | +--------+-------+-------+-------+-------+---------------+
O=Option, C B A Sont les 3 fires, P=Pause x=sans importance
Le 1 et le 0 designe les bit 1 et 0 de JOYBUTS.
Donc quand vous lisez la colonne 0 d'un joy (Position du pad), après avoir lu JOYSTICK, vous lisez directement en JOYBUTS les 2 premiers bits et vous obtenez P(ause) et (Fire) A, exemple :
move.w #$810e,JOYSTICK ; (Selection colonne 0)
move.w JOYSTICK,d0 ; (Recup les donnees)
move.w JOYBUTS, d1 ; recup P(ause) et A (Fire)
Donc si vous testez le bit 0 de d1, vous pousez savoir si A est pressé. La même règle s'applique pour les bits, ils sont inverses de ce qu'on a l'habitude, donc vous pouvez revenir a la 'normale' par un :
not.w d1
Pour le second port :
+--------+-------+-------+-------+-------+---------------+ |Colonne | Pad 0 | Pad 1 | Pad 2 | Pad 3 | Boutton 32 | +--------+-------+-------+-------+-------+---------------+ | 3 | $7 | $3 | $8 | $f | xO | +--------+-------+-------+-------+-------+---------------+ | 2 | $b | $2 | $6 | $c | xC | +--------+-------+-------+-------+-------+---------------+ | 1 | $d | $1 | $5 | $a | xB | +--------+-------+-------+-------+-------+---------------+ | 0 | $e | $0 | $4 | $9 | PA | +--------+-------+-------+-------+-------+---------------+
Exactement pareil pour le second port, sauf c'est les bit 3 et 2. Pas d'exemple, je penses que vous etes assez grand pour l'écrire vous même...
Et voila !! Vous savez tout sur les joys, puisse cet article, faire qu'on puisse avoir beaucoup plus de jeux multijoueurs sur Jag, on devrait presque imposer les deux joueurs minimun quand le jeu le permet, vous pensez pas ?
La seconde partie est la !!!
Deux petits trucs pour récuperer quelques cyles. La premiere, regardez bien le registre JOYSTICK, j'ai pas fait gaffe au début, mais la selection est séparé pour les 2 ports, donc vous pouvez lire les deux ports en même temps !!
Exemple :
move.w #$81e7,JOYSTICK
Sélectionne les colonnes 0 des deux ports, pour le traitement :
move.w JOYSTICK,d0
move.w d0,d1
and.w #$0f00,d0
and.w #$f000,d1
(Si on revient a la normale cela donne :
move.w #$8107,JOYSTICK
move.w JOYSTICK,d0
and.w #$0f00,d0
move.w #$81e0,JOYSTICK
move.w JOYSTICK,d0
and.w #$f000,d0
Il y a pas photo !!)
Voila dans d0 vous avez les données du premier port et dans d1 les données du second port. Ce qui fait 1 accès exterieur pour deux joys, ce qui évite de trop squatter le bus. Pour 8 pads, cela nous fait que 4 accès au lieu de 8, c'est bon hein !!! C'est pareil pour les bouttons.
La seconde technique ?
Regardez bien JOYSTICK ET JOYBUTS, mais pas les appelations officielles d'Atari les adresses même : $f14000 et $f14002 elles se suivent et elles font chacune 1 mot (2 octets) ce qui fait un total de 4 octets, vous voyez ou je veux en venir ? Non et bien regardez bien cela :
move.l JOYSTICK,d0
Je lis JOYSTICK ET JOYBUT d'une seule traite, donc vous avez les touches et les bouttons pressés d'une seule traite. Si vous voulez traiter les bouttons (Fire ABC, Option et Pause) normalement vous faites ceci :
move.w #$810e,JOYSTICK
move.l JOYSTICK,d0
move.l d0,d1
swap d1
Et ceci remplace :
move.w #$810e,JOYSTICK
move.w JOYSTICK,D0
move.w JOYBUTS,D1
Au nombre de lignes, je perds sur mon optim et bien gagné mais je gagnes en vitesse et en taille !! Si on comptes les cyles, voila le resultat :
move.w #$810e,JOYSTICK ; 20 cycles 8 octets
move.l JOYSTICK,d0 ; 20 cycles 6 octets
move.l d0,d1 ; 4 cycles 2 octets
swap d1 ; 4 cycles 2 octets
Ce qui nous fait un total de 48 cycles et 18 octets
Et pour l'autre :
move.w #$810e,JOYSTICK ; 20 cycles
move.w JOYSTICK,D0 ; 16 cycles
move.w JOYBUTS,D1 ; 16 cycles (Total de 52)
Total de 52 cycles, 16 octets
On gagne 4 cycles et 2 octets, ce n'est pas grand chose, mais il y a une chose très importante, dans la version non optimisé on a un total de 3 accès en extérieur, donc au bus, dans la version optim on a 2 accès au bus, cela evite de squatté le bus, et le laisse plus libre pour afficher des sprites, c'est plus efficace.
Et donc dans la version optim vous avez dans d1 JOYBUTS comme si vous l'aviez lu comme cela :
move.w JOYBUTS,d1
Il existe peut etre d'autres moyens d'optimiser, si vous trouvez faites moi s'en part.
J'ai trouvé une technique encore plus efficace, écrire la routine Pad au Gpu ou Dsp, cela marche j'ai une routine qui tourne. Je stocke le résultat dans la ram interne du Gpu, ceci pour des raisons de vitesse. Et chaque Vbl on va relire dans la ram interne avec le 68000, par :
lea Adr_joy,a0
move.l (a0)+,Joy_0
move.l (a0)+,Joy_1
move.l (a0)+,Joy_2
move.l (a0)+,Joy_3
move.l (a0)+,Joy_4
move.l (a0)+,Joy_5
move.l (a0)+,Joy_6
move.l (a0)+,Joy_7
Ou plus efficace :
movem.l Adr_joy,d0-d7
movem.l d0-d7,Joy_0
Ca va vous avez tout compris ? Sinon TANT PIS !!
Voili, voila c'est fini pour les joys, un truc pas compris, des idées des bugs (C'est pas possible car avec Atari on est .............. !)
Contactez moi sur ce forum, on en discutera.
GT Turbo (C.V.S.D. Membre de la Jagware Team)
P.S. : En lisant ces registres on peut aussi savoir quel type de joy est branché mais vu le nombre de possesseurs de Joy genre Tempest Controller, on s'en passera. Si vous désirez l'info vous savez ou me trouvé
-
Vous trouverez dans les 3 chapitres ci dessous, le nécessaire de survie quand le Gpu est attaqué, le Dsp est pratiquement pareil (Jeux d'instrucions, lancement de code, etc...) les instructions ne fonctionnant que sur l'un ou l'autre sont indiqués. Mais j'ai écrit ceci car j'ai fait un petit paquet d'essais et autant en faire profité tout le monde.
Bon code.
Gpu in da face !!! (Et le Dsp aussi dans ta face !)
(Sur un petit air de 'Techno is not dead ')
Bienvenue ici, vous trouverez dans les milliers (Hein !?!) de ligne après plein de truc sur le Gpu de la Jag, le Dsp étant presque pareil, vous ferez d'une pierre, deux coups !! C'est un microprocesseur plein d'avenir, moi je vous le dis !!! Pourquoi parlez de cette puce alors que vous voulez juste dvper un shoot ? Alors que je n'ais pas de besoin de calcul ou de trucs super sophistiqués pour mon jeu. Si vous répondez cela c'est que vous êtes un ane et un de compétition !!
Le couple Gpu / Dsp c'est un peu la carte accélératrice de la Jag, faire un trait dessus c'est permettre aux autres dvpeurs de faire un jeu 'beaucoup beaucoup plus meilleur que le votre !' (Et faites moi confiance je ne ferais pas dans la dentelle, je suis un gros bourrin ! Donc mes codes mangeront vos productions comme apéritif !).
Oui mais c'est dur et puis truc et machin !!! NON NON et RENON !!
Ce qui ont déjà écrit en assembleur une fois dans leur vie, vont apprécier ces puces pleines de surprise et surtout de puissance !!! C'est ultra simple de codé avec, ceux qui ont fait du 68000 auront l'impression de trouvé son cousin, ceux qui ont fait du code Dsp (Sur un Falcon) vont avoir l'impression de faire du basic (C'est un peu poussé vais vous verrez que le transfert d'un code Gpu dans sa ram est 10 fois plus simple qu'avec le Falcon).
Le Gpu de de la Jag est un RISC, en clair, peu d'instructions mais qui arrache (C'est tout ce qu'il nous faut !). Il est d'après Atari, là pour faire de l'aide au copro vidéo, mais vu la puissance de la puce et son jeu d'instruction (Pas si réduit que cela !) on peut faire beaucoup de choses avec (Je lis les jagpads avec ! SCPCD fait ces liste de sprite avec !)
Je vais vous expliqué le jeu d'instruction et quelques trucs a savoir pour écrire vos propres codes Gpu pour écrire Native II.
Ce qui n'ont jamais fait d'assembleur de leur vie, passez votre chemin, je ne suis pas la pour vous faire une initiation mais une explication de cette puce. Les rois du 68000, mangeur de nop en puissance, restez ici ca va vous plaire tout cela, vous verrez !!
Petit détail techniques :
- processeur 32 bits (Attachez les ceintures !)
- presque toutes les instruction en un cycle, vu la vitesse de ce chip (26 Mhz) cela laisse rèveur a ce qui ont codé sur un ST...
- 64 registres (En utilisation normale c'est 32, meme un peu
moins (Ca sent l'arnaque !), parce que certains sont utilisé en interne) mais on peut accèder‚ a 64 ca c'est sur)
- 4 Kilos de ram interne, cela peut faire peu mais en assembleur et juste pour du code pure on peut en mettre des trucs interressants. Le Dsp quand a lui dispose de 8 Kilos (Ca va p‚ter moi je vous le dit !!)
- Il peut lire / écrire une phrase (8 octets) en une instruction)
Les registres sont ici appellés Rx (x=0 a 31, soit R0 … R31)
Voili, voila passons aux jeu d'instructions, n'oubliez pas c'est un proc 32 bits, donc quand on peut pas préciser, c'est les 32 bits du registres qui sont concernés.
Cela peut déboussoler‚ au début, mais très peu d'instruction autorise l'immédiat, c'est pour 90% du temps, reg sur reg, pour passer cela la technique est simple, mise de l'immédiat dans un registre et ensuite, votre instruction avec le registre ou se trouve votre immédiat. Cela peut ètre lourd, mais on s'en fou un peu tant que cela va vite !!!
Le Gpu dispose bien sur des flag pour les tests, il n'y a que trois flags
- Z(ero) placés bien sur si le résultat est nul.
- N(égatif) placés biens sur si le résultat est positif (Je rigoles je voulais voir ce qui suivait, c'est bien sur négatif)
- C(arry) retenue.
Pour les flags :
F signifié‚ fixé‚ (Donc modifié suivant le résultat)
0 signifié‚ mis a 0 quelque soit le résultat
1 signifié‚ mis a 1 quelque soit le résultat
I signifié‚ indéfini, pas modifié ou valeur inutilisable.
Rn désigne constamment un registre (r0-r31)
Les instructions du Gpu / Dsp.
Les instructions :
- Abs rn : donne la valeur absolue de rn (Registre)
(Flags : Z(F), N(0), C(placé si opérande négative)
- Add rn,rn : additionne rn sur rn et oui !!
(Flags : Z(F), N(F), C(F))
- Addc rn,rn : additionne rn sur rn et en plus rajoute la retenue !!
(Flags : Z(F), N(F), C(F))
- Addq #n,rn : additionne n sur rn, immédiat, n entre 1 et 32
(Flags : Z(F), N(F), C(F))
- Addqmod #n,rn : additionne n sur rn, immédiat.
(Dsp seulement, 1a particularité, intègre un modulo, permet de faire du buffer circulaire.)
(Flags : Z(F), N(F), C(F))
- Addqt #n,rn : additionne n sur rn, immédiat, n entre 1 et 32
(particularité‚ ne modifie pas les flags, le t est la pour transparent)
- And rn,rn : et logique
(Flags : Z(F), N(F), C(I))
- Bclr #n,rn : efface le bit n dans rn, n immédiat (0-31)
(Flags : Z(F si le résultat est maintenant égal a zéro)
N(Valeur du bit 31), C(I))
- Bset #n,rn : place le bit n dans rn, n immédiat (0-31)
(Flags : Z(F si le résultat est égal a zéro,N(F), C(I))
- Btst #n,rn : teste le bit n dans rn, n immédiat (0-31)
(Flags : Z(F si le bit est égal a zéro,N(I), C(I))
- Cmp rn,rn : compare rn a rn
(Flags : Z(F si ‚gal),N(F, source>destination)), C(F))
- Cmpq #n,rn : compare n (immédiat) a rn (n entre -16 a +15)
(Flags : Z(F si ‚gal),N(F, source>destination)), C(F))
- Div rn,rn : division non signé (32/32)
(Flags non affecté)
- Imacn rn,rn : multiplication / accumulation, signé
rn est multiplié par rn, le résultat est inscrit dans un registre interne (Voir resmac)
(Flags non affecté)
- Imult rn,rn : multiplication signé 16 bits (résultat 32)
(Flags : Z(F),N(F), C(I))
- Imultn rn,rn : multiplication signé 16 bits mais le résultat est sauvé en interne (Plus rapide que la précedente du fait de la non réecriture du résultat dans rn)
(Flags : Z(F),N(F), C(I))
- Jr cc, n : saut relatif conditionnel
cc : condition (voir tableau après)
n : offset du saut, additionné a l'adresse de l'instruction suivante
(Flags non affecté)
- Jump cc,(rn) : saut absolu conditionnel
cc : condition (voir tableau après)
rn : adresse du saut
(Flags non affecté)
- Load (rn),rn : charge le contenu de rn dans rn, équivaut a un move.l (a0),Dn (68000) ou lea (a0),a0 (Ne pas oubliez reg de données et d'adresse sont pareil sur le Gpu)
l'adresse doit ètre aligné sur un mot long.
Flags non affecté
- Load (R14+n),rn charge rn avec ce qu'on trouve en r14+n
- Load (R15+n),rn : équivaut a un move.l N(a0),Dn (68000) n immédiat (1-32) attention n est exprimé en mots long et pas en octet donc load (r14+1),rn est égal a move.l 4(a0),Dn
Flags non affecté
- Load (R14+rn),rn pareil qu'avant mais avec un registre
- Load (R15+rn),rn : équivaut a un move.l 0(a0,d0.l),Dn l'adresse obtenu doit etre aligné sur un mot long.
Flags non affecté
- Loadb (rn),rn : move.b (a0),d0 (68000)
lit un octet en mémoire, octet chargé dans les bit 0-7, le reste du registre est effacé. Attention : accès en ram extérieur pas de soucis, en cas d'accès
de ram interne lecture d'un mot long
- Loadw (rn),rn : move.w (a0),d0 (68000)
lit un mot en mémoire, mot chargé dans les bit 0-15, le reste du registre est effacé.
Attention : accès en ram extérieur pas de soucis, en cas d'accès de ram interne lecture d'un mot long
- Loadp (rn),rn : lit une phrase en mémoire, la partie basse est chargé dans le registre spécifié, le reste est placé dans un registre spécial (Voir après)
(Gpu seulement)
Attention : accès en ram extérieur pas de soucis, en cas d'accès de ram interne lecture d'un mot long
- Mirror rn : 'miroite' le registre (retourne le registre)
(Dsp seulement) (le bit 0 est échangé avec le 31, le bit 1 échangé avec le 30, etc..)
(Flags : Z(F), N(F), C(I))
- Mmult rn,rn : lance le calcul matriciel, le premier registre indique l'adresse de la matrice de départ, le second registre récupere le résultat.
(Des d‚tails dans un prochain registre)
(Flags : Z(F), N(F), C(F))
- Move rn,rn : sans commentaire ! (move.l dn,dn (68000))
Copie d'un registre vers un registre
- Move pc,rn : copie le PC, le pc est recalculé pour prendre compte du pipe lining et tout le toutim pour donné le bon PC.
(Flags non affect‚)
- Movefa rn,rn : permet de transféré un registre vers un registre de l'autre banque de registre (Voir notes)
- Movei #n,rn : charge rn avec l'immédiat (mot long)
(Flags non affecté)
- Moveq #n,rn : chargement avec l'immédiat n (0-31)
(Flags non affect‚)
- Moveta rn,rn : permet de transférer un registre de l'autre banque vers un registre de notre banque de registre (Voir notes)
(Flags non affecté)
- Mtoi rn,rn : extrait la mantisse, et signe le nombre 32 IEEE 32 bit flottant dans la destination, plus de détail quand on aura fait des essais.
- Mult rn,rn : multiplication 16 bit non signé de rn par rn, résultat sur 32 bits placé dans la destination.
- Neg rn : négation, 'negate' rn, cela veut dire rn=8 après rn=-8, etc.. Si vous comprenez pas allez vous faire....
- [red]Nop[/red] : l'instruction a connaitre, le top du top, l'exclu, l'instruction universelle des assembleurs, le Nop qui ne fait rien du tout !!!
(Flags non affecté)
- Normi rn,rn : donne un nombre 'entier normalisé', plus de détail une autre fois.
- Not rn : Non logique
(Flags : Z(F), N(F), C(I))
- Or rn,rn : Ou logique
(Flags : Z(F), N(F), C(I))
- Pack rn : Compacte un pixel au format cry : les bits 22-25 passent en 12-16, les 13-16 en 8-11 et les 0-7 en 0-7 !!! Quand j'aurais compris quoi faire avec on fera des trucs tous ensemble !!! Promis !!
(Gpu seulement)
(Flags non affecté)
- Resmac rn : récupère le résultat des multiplications précédentes, recopie le registre de multiplication dans rn.
(Flags non affect‚)
- Ror rn,rn : rotation par la droite. Valeur autorisé 1 a 32, seules les 5 bits de rn (source) sont pris en considération.
(Flags : Z(F), N(F), valeur du bit 31 avant la rotation)
- Rorq #n,rn : rotation par la droite en usant d'un immédiat. Valeur autorisé 1 a 32
(Flags : Z(F), N(F), valeur du bit 31 avant la rotation)
Arrive les instructions de saturation, what it is ? Ces instructions permettent de réduire un registre en utilisant deux règles. Pour vous expliquer ces règles, il faut juste savoir deux choses sur les instructions après seront données‚ deux chiffres et peut etre un 'S' optionnel. Le premier chiffre indique la taille de votre registre au départ, le second après 'Saturation'. Exemple :
Sat8 rn : 32->8 Cela veut dire que votre registre 32 va ètre réduit a 8 bits, en appliquant que si votre reg 32 est supérieur a 255 (2^8-1), il sera égal a 255, si il est inférieur a 255, il restera comme il est, si il est négatif il vaudra 0 (Si il n'y a pas de 'S' car sinon le résultat est signé donc non modifié si il était négatif)
- Sat8 rn : 32-> 8
(Gpu seulement)
(Flags : Z(F), N(0), C(I))
- Sat16 rn : 32-> 16 (La limite est donc 65535 (2^16-1))
(Gpu seulement)
(Flags : Z(F), N(0), C(I))
- Sat16S rn : 32->16 (Attention résultat peut ètre signé)
(Dsp seulement)
(Flags : Z(F), N(0), C(I))
- Sat24 rn : 32->24 bits (Limite 2^24-1)
(Gpu seulement)
(Flags : Z(F), N(0), C(I))
- Sat32S rn : 40->32 bits (Les 8 bits manquant sont récupéré du registre interne de multiplication / accumulation) et son considérés comme les 8 bits haut.
(Dsp seulement)
(Flags : Z(F), N(0), C(I))
- Sh rn,rn : décalage gauche ou droite, donnée par la valeur de rn. Valeur positive décalage a droite.
- Sha rn,rn : décalage arithmétique, le reste pareil que Sh
(Flags : Z(F), N(F), C(bit 0 des données non décalés.))
- Sharq #n, rn : décalage arithmétique droit avec un immédiat.
(Flags : Z(F), N(F), C(bit 0 des données non décalés.))
- Shlq #n, rn : décalage a gauche avec un immédiat.
(Flags : Z(F), N(F), C(bit 31 des données non décalés.))
- Shrq #n, rn : décalage a droite avec un immédiat.
(Flags : Z(F), N(F), C(bit 31 des données non décalés.))
- Store rn,(rn) : Ecrit un long (move.l d0,(a0) 68000)
L'adresse doit etre aligné sur un long (4 octets)
(Flags non affect‚)
- Store rn,(R14+n) : Comme le load mais en écriture
- Store rn,(R15+n) (N est calcul‚ en long n=1 (déplacement de 4))
(Flags non affect‚)
- Store rn,(R14+rn) : Comme le load mais en écriture
- Store rn,(R15+rn) (l'adresse doit ètre aligné sur un long)
(Flags non affecté)
- Storeb rn,(rn) : Ecrit un octet. Cela s'applique qu'au écriture extérieures, en interne c'est toujours un mot long
(Flags non affecté)
- Storew rn,(rn) : Ecrit un mot, cela s'applique qu'au écriture extérieures, en interne c'est toujours un mot long. Adresse aligné sur un mot long.
(Flags non affecté)
- Storep rn,(rn) Ecrit une phrase (8 octets). Le mot long manquant est récupéré dans un registre spécial, l'adresse doit ètre aligné sur un phrase.
(Gpu seulement)
(Flags non affecté)
- Sub rn,rn : soustrait rn de rn et oui !!
(Flags : Z(F), N(F), C(F))
- Subc rn,rn : soustrait rn de rn et en plus retire la retenue !!
(Flags : Z(F), N(F), C(F))
- subq #n,rn : soustrait n de rn, immédiat, n entre 1 et 32
(Flags : Z(F), N(F), C(F))
- Subqmod #n,rn : soustrait n sur rn, immédiat.
(Dsp seulement, 1 particularité, intègre un modulo, permet de faire du buffer circulaire.)
(Flags : Z(F), N(F), C(F))
- Subqt #n,rn : soustrait n sur rn, immédiat, n entre 1 et 32 (particularité ne modifie pas les flags,le t est la pour transparent)
- Unpack Rn : l'inverse de Pack...
- Xor rn,rn : Ou exclusif
(Flags : Z(F), N(F), C(I))
Notes :
loadp et storep lisent et écrivent des phrases (8 octets) mais les registres font 32 bits, donc on en utilisent 2 ? Pas tout a fait j'ai cherché quelques minutes, danc la doc est écrit que la partie haute est lu ou écrite depuis le 'high half register', c'est mignon mais cela veut dire quoi en clair, au début j'ai voulu commencé (Enfin non j'ai commencé...) a essayer tous les registres, mais après une dizaine cela devient lourd et en fin de compte en cherchant on trouve en $f02118 un registre appellé : High Data register et oui c'est lui qui sert de registre de stockage pour les phrases.
Moveta et Movefa ont une fonction particulière ils permettent de transférer un registre d'une banque vers une autre. Explication : vous vous souvenez, au début j'ai écrit qu'il avait 64 registres. Ceux ci sont divisés en deux banques de 32 registres, le seul moyen de selection des banques est masqués par le Gpu donc on y a pas accès en direct, alors ceux deux instructions sont la pour nous aider, moveta permet de transférer un registre de la première banque (La standard) vers l'autre (Celle qui se cache), exemple :
moveta r4,r4
Une personne qui ne connait pas pense que vous simulez un Nop ! Mais non, mais non cela transfert le premier r4 dans le second r4 et movefa fait l'inverse.
Attention, Atari précise qu'il faut initialisé la pile du Gpu mais la vous cherchez comme un ane et bien sur c'est écrit nulle part, j'ai cherché pour vous et apparement cela serait r27 a prendre avec des pincettes, j'ai fait des tours dans différents sources pour cela, donc zéro assurance. R31 est la pile pour les routines d'interruption et attention en cas de routine d'interruption r30 peut ètre 'plombé‚', donc vous savez qu'elle registre vous avez a éviter...
Conditions pour les instructions de saut :
C=flag de retenue
N=flag de négation
Z=flag de zero (!)
- : rien, branche toujours
- NZ : branche si Z=0
- Z : branche si Z=1
- NC : branche si C=0
- NC NZ : branche si C=0, Z=0
- NC Z : branche si C=0, Z=1
- C : branche si C=1
- C NZ : branche si C=1, Z=0
- CZ : branche si C=1, Z=1
- NN : branche si N=0
- NN NZ : branche si N=0 et Z=0
- NN Z : branche si N=0 et Z=1
- N : branche si N=1
- NN Z : branche si N=1 et Z=0
- N Z : branche si N=1 et Z=1
- : rien, branche jamais (Dite rien je cherches...)
Lancer un code Gpu
Avalez le jeu d'instruction ? Donc on attaque les choses sérieuse.
Comment faire pour écrire mon premier programme et le lancer ?
'Ca en etre une question qu'elle est bonne ?'
Premier point, MadMac l'assembleur fait le code 68000 / Gpu / Dsp donc il va falloir lui préciser que c'est un code Gpu ou Dsp donc pour prévenir le mossieur, vous faites sur votre premiere ligne de code :
. gpu (ou dsp suivant la puce)
C'est dur hein !
Second point, le code Gpu / Dsp est absolu, cela signifie qu'il est assemblé que pour fonctionner a une seule adresse. Pour fixer cela au début de votre source, vous devrez faire cela :
org $f03000 (Adresse de début de la ram Gpu)
L'adresse cité peut etre n'importe quoi tant qu'elle se situe dans la ram du Gpu ($f03000-$f03fff, 4 kilos) ou la ram Dsp ($f1b000-$f1cfff, 8 kilos), ces deux ram sont des rams a accès très rapide.
L'entrée est passé ? Les choses ultra simple commencent (Hein !?!)
Voici un code bidon pour démonstration :
.gpu
org $f03000
movei #Boucle,r0 ; Adresse pour faire notre boucle
Boucle: ; Début de notre boucle sans fin
nop ; l'instruction qui est 'jouli !'
jump (r0) ; on boucle sans fin, histoire 2 !
Passez ce truc dans MadMac vous allez récuperé un splendide
'votrenomdefichier'+.'o'. Et on en fait quoi ce celui la ?
C'est simple, vous le recopiez comme un barbare dans la ram du Gpu, comme par exemple :
lea Fin_code_dsp,a0
lea Debut_code_dsp,a1
move.l a0,a2
sub.l a1,a2 (Calcule la taille du code !)
lea $f03000,a3
move.w a2,d0
lsr.w #1,d0 (Divise par 2, car on va transférer des mots)
subq.w #1,d0 (-1 pour le dbra)
Copy_code_dsp:
move.w (a0)+,(a3)+
dbra d0,Copy_code_dsp
.....
Debut_code_dsp:
INCBIN "VOTRENOMDEFICHIER.O"
EVEN (Assure la parité au cas ou !)
Fin_code_dsp:
Dur n'est ce pas (Sans commentaire...)
Et maintenant on le lance comment ?
D'abord le PC (Program Counter) n'est pas initialisé, donc on le met en place :
move.l #$f03000,G_PC ($f02110)
Ensuite ? Ben on envoie la sauce !
move.l #1,G_CTRL ($f02114)
(Ne pas oublié d'adresser les registres sur 32 bits, meme si il ne comporte que 15 bits, d'ou le long au dessus !)
Place le bit 0 de $f02114, ce bit démarre le Gpu ou le stoppe.
Et voila votre code Gpu tourne ! C'est dur la vie d'artiste.
Note : le Gpu / Dsp pipe line a mort, ce qui fait que presque tout le temps, une instruction est en cours d'execution et pendant ce temps la suivante est commencé. Ce qui fait que dans certains cas un résultat a pas fini d'ètre calculer avant que l'instruction suivante soit executé, donc si vous écrivez cela :
moveq #0,r0
addq #1,r0
addq #4,r0
Le résultat ne sera peut etre pas 5 !! Donc soit vous inserez des nops, soit vous entrelacez votre code de manière a ce qu'une instruction qui utilise un résultat, n'utilise pas celui du calcul‚ juste avant :
moveq #0,r0
moveq #0,r1
addq #1,r0
subq #4,r1
addq #4,r0
Cela a plus de chance de marché !! Dans certains cas vous etes pas obligé d'entrelacer, le Gpu attend (comme un con !) que le résultat soit calculé si vous etes dans le cas du premier exemple mais dans certains cas non, donc méfiez vous, ne dites pas que je vous aurais pas prévenus.
Voila vous en savez beaucoup sur ces petites betes, le Dsp c'est exactement pareil, il dispose de quelques trucs en plus en rom (Différentes tables sonores) vu qu'a la base il est censé faire du son (Mais vu la taille de la ram cela doit etre possible de mettre la routine son et ....)
J'ai passer certains trucs, car je n'ais pas encore fait les essais ou ceci sont en cours au moment ou cet article est écrit.
Prenez note d'une chose, ces deux puces dispose de ram, vous pouvez les utiliser comme mémoire cache, vu leur vitesse d'accès. Quand j'ai écrit ma routine Jagpad au Gpu, j'avais un petit doute, mais en fin de compte les résultats des joys sont stockés dans la ram Gpu (Tout en haut !)et cela marche très bien, le 68000 n'a plus qu'a lire le résultat quand il le souhaite.
La routine souris qui se 'ballade' pour la Jag est chouette mais il est préciser qu'il faut faire une lecture 1000 fois par seconde (Du fait qu'on peut pas savoir quand elle a été déplacé car aucune interruption est géneré pour les ports joy !) au 68000 c'est marrant un moment, mais vous croyez pas que cela peut ralentir un peu tout ce mic mac ? Autant l'écrire au Gpu, faut bien qu'il serve a quelque chose....
Voila, vous en savez assez pour nous faire de jolis codes Dsp / Gpu, et surtout de vrais productions Jag, production amateur d'accord mais le résultat DOIT ètre pro, c'est une vrai console, pas un simulateur d'Atari St...... Elle est capable de superbes jeux, elle a un potentiel plus souvent 'inexploité qu'exploité', donc attrapez votre courage (Il y en a besoin ?) et cassez la baraque, meme si on peut pas faire du Gran Turismo 4 sur Jag, les jeux 2d sont l'apanage de cette chouette console, le seul jeu qui avait l'air de poussé est Native, apparement Rayman mais je l'ai pas encore vu (RaZ en a trouvé un donc on l'attend donc de pied ferme !)
Allez salut !
Pour les instructions je n'ais fait qu'une traduction (avec les pieds) de la doc officielle Atari (Merci a Vince), j'ai pu faire des erreurs, (Voire en rajouté !!), donc si vous avez un doute, votre code ne fonctionne pas tout a fait, faites signe !!!!
Pour certains 'trucs' spéciaux, multiplication de matrice, certains trucs spécifiques au Dsp, un autre article sera écrit.
GT Turbo (C.V.S.D.) Membre de la Jagware Team
-
Article en construction
Dans cette partie vous trouverez différentes techniques ou astuce pour le code 68000, pour ceux qui ont du mal a utiliser le Gpu / Dsp ou les ont déjà chargés a mort !!
Ces techniques proviennent d'un paquet d'années passés sur le St en developement de démo, ceci proviendront aussi bien de recherches persos que de trucs ultra connu dans la communauté 68000.
C'est parti !!
Quelques bases utiles :
D'un point de vue binaire, une multiplication par 2 d'une valeur consiste a décaler cette valeur vers la gauche de un :
lsl.w #1,d0
multiplie d0 par 2, le lsl.w fait 8+2n cycles, n étant le nombre de décalages.
Et tout les multiples des puissances de deux sont possibles, par exemple multiplier par 4,8,16,32,64,128, etc... toute ces multiplications sont transformables en décalage. Exemple multiplication par 32 de d4 :
lsl.w #5,d4 (2^5=32)
Ce qui est beaucoup plus rapide. Il y a encore plus rapide pour la multiplication par 2 c'est
add.w d0,d0
Qui fait pareil et est encore plus rapide !!
si vous devez faire des multiplications, essayez de voir si vous pouvez pas la réduire en différents décalages, exemple une multiplication par 160 peut ètre décomposé en deux multiplications, une de 128 et une 32 (128+32=160)
move.w d0,d1
lsl.w #8,d0
lsl.w #5,d1
add.w d1,d0
et voila votre multiplication faite a coup de décalages et c'est beaucoup plus rapide !!
Division par les multiples de puissance de 2 c'est exactement pareil mais decalage a droite :
lsr.w #x,d0 (X etant bien sur le nombre de decalages !)
.....
Et maintenant 2 techniques bien puissantes :
Code automodifiant
Code automodifiant ? C'est quoi ce truc ?
C'est simple c'est un code qui peut modifier un ou plusieurs instructions durant son déroulement, on dirait un truc de science fiction et bien non.
Cela n'est possible qu'en assembleur, car vous savez exactement ou se trouvent les instructions et comment elles sont codées.
L'adresse d'une instruction est simple a obtenir :
Adresse_instruction:
nop
Je sais un nop c'est pas le truc du futur mais c'est pour comprendre. Imaginons que maintenant vous voulez transformez cette instruction en addition par exemple add.w d0,d1, comment qu'on va faire ? Prenez votre assembleur, tapez votre instruction : add.w d0,d1 affichez l'assemblage a l'‚cran, vous allez obtenir le code hexa de l'instruction qui est : $d240, marrant hein ?! Sinon vous pouvez prendre une doc 68000 et assemblez l'instruction a la main, mais c'est pas très marrant, après un moment a pratiquer cela, certaines instructions
on connait par coeur leur valeur hexa !!
Maintenant baguette magique hop un nop en addition, c'est simple on fait :
move.w #$d240,Adresse_instruction
c'était dur n'est ce pas !!!! A quoi cela peut servir ? A mettre un peu de patate dans votre code, imaginons que vous voulez remplir une zone mémoire avec 4 mots différents suivant une couleur, avant vous faisiez comme cela :
Boucle :
si couleur=1
écrire un mot x
sinon écrire un mot y
end si
si couleur=2
écrire un mot x
sinon écrire un mot y
end si
(Encore 2 fois)
..............
boucler jusqu'a truc
On peut faire cela de façon beaucoup plus rapide, vous testez votre valeur en dehors et vous modifiez vos instructions dans la boucle suivant la couleur, votre boucle devient alors cela :
Boucle :
écrire mot a
écrire mot b
écrire mot c
écrire mot d
boucler jusqu'a truc
C'est plus court et beaucoup plus rapide, certains vont dire ont peu utiliser 4 registres et mettre les bonnes valeurs en dehors de la boucle, d'abord faudrait déjà avoir 4 registre de libre et ensuite ceci n'est qu'un exemple, a vous de choisir quand faudra l'utiliser.
Faites gaffe au taille des instructions quand meme, remplacez une de 2 par une de 4 peut poser quelque soucis....
Code généré
Ca c'est une technique de bourrin, un truc a ne pas oublier, un truc de mangeur de ram.
Vous faites du 68000 depuis 1784 (Hein !), vous connaissez les dbra dans tous les sens et les utilisez a toutes les sauces, mais vous savez aussi que pour manger des cycles ca va etre dur de le battre (exception faite de truc ultra lent) !!! 12 Cycles la bete, ca fait mal la boucle, prenons un exemple, une boucle de 200 un truc assez courant 200*12=2400 cycles, ces cyles il y a moyen de les récuperer.
On va écrire un morceau de code qui va 'générer‚' 200 fois le bout de code a repeter mais sans le dbra, on va gagner 2400 cycles et un registre, mais la contrepartie cela mange un peu de ram mais pas de quoi tuer un chat. Il existe plusieurs techniques pour generer 200 fois un code, certains vont utiliser les directives de compilation :
REPT 200
add.w d0,d1
lsl.w #8,d7
ENDR
Cela est pas terrible, et peut être lent suivant la machine utilisée pour assembler ou suivant l'assembleur. Perso je fais comme cela :
Vous écrivez votre bout de code quelque part ou il dérange pas :
Debut_code:
nop
add.w d0,d0
lea 160(a0),a0
Fin_code:
Vous allez en section bss et envoyez ceci :
Code_genere: ds.b 200*(Fin_code-Debut_code)
ds.b 2
Voila vous avez reserve la place necessaire a votre code+2 octets qui vont servir a...
Ensuite dans les inits on envoie cela :
lea Code_genere,a0
move.w #200-1,d7
Copy_gen_code:
lea Debut_code,a1
move.w #(Fin_code-Debut_code-1),d6
lsr.w #1,d6 ; on divise par 2, les instructions
; sont obligatoirement paire
subq.w #1,d6 ; -1 pour le dbra
Copy_le_bout_de_code:
move.w (a1)+,(a0)+
dbra d6,Copy_le_bout_de_code
dbra d7,Copy_gen_code
Et voila vous venez de générer 200 fois votre code, il manque un truc, aprês ceci faut rajouter un :
move.w #$4e75,(a0)
C'est quoi cela ? Un 'Rts' est rajouté a la fin du code généré, donc maintenant quand vous voulez utiliser votre code généré :
jsr Code_genere
La classe, le programme est plus leger (a la lecture), plus rapide.
Cette technique est une technique de bourrin, c'est sur mais quand on a pas de cycle de libre on 'ram' oui je sais je sors.......
Une technique combinatoire est possible, générer du code mais d'aprês certains critêres, cela permet d'avoir du code ultra spécifique sans dbra.
Pour ceux qui connaissent, par exemple le Flexiscroll de Griff (Electronic Images) dans la Decade démo, a utiliser ces deux techniques pour générer pour chaque lettre un code spécifique.
Ces techniques m'ont permis de faire des effets qui n'aurait pas été possible a cette vitesse la, ces techniques ne sont plus utilisées actuellement car maintenant pour accelerer un code, on accelere sa carte mêre, et surtout a savoir, un (micro) processeur avec un cache n'apprécies pas toujours le code auto modifiant, car dans certains cas il va modifier les données dans le cache et pas dans la ram ce qui peut faire planter la chose voire des résultats aléatoires !!!! Par contre ce sont des techniques qui peuvent servir pour tout ceux qui font du retro-gaming, toutes les consoles passé‚s sans cache, c'est utilisable.
Dans le cas de la Jag vous pouvez y aller comme vous voulez ca craint rien !!! Mais n'utilisez le 68000 quand dernier recours, quand le Gpu et le Dsp sont bloqués et peuvent plus rien faire, les deux processeurs sont três três rapides, et vous avez peut être pas besoin de ce genre de code (Quoi que je ferais bien du code automodifiant dessus) mais faites gaffe, les procs n'ont pas de cache mais decode les instructions 'beaucoup en avance', au moment ou vous changez l'instruction il aura peut être déjà décodé l'instruction et votre modification ne prendra lieu qu'au prochain passage, donc a utiliser quand vous savez ce qu vous faites.
En ésperant que vous ayez appris quelque chose avec ceci, pour l'instant retournez donc faire du code, ca fera avancez tout le monde !!!
GT Turbo
-
En attendant la terrible Evo II de SCPCD (Classe comme intro, trouvez pas ?)
Comment développer des productions Jag sur une config Atari :
------------------------------------------------------------
Beaucoup de personnes developpent du programme Jag sur Pc, mais c'est tout a fait possible avec un Atari (Du Stf au Falcon) et a une vitesse qui va faire passer votre copain dvpeur d'à coté pour un mangeur de spaghettis carbonara a la menthe (Beurk !!)
Comment faire cela ? En transformant Devpac en Shell !!!
Allez on ouvre les hostilités !!
Ce que j'utilises et comment :
Ma config perso est un Falcon 030 mais on peut utiliser un ST(E/F), le loader (Programme de transfert Atari->Jag) est compatible (C'est ce qui est écrit, j'ai pas essayé !! Mais vu que le transfert se fait par le port centronic (Imprimante) cela devrait tourner sans soucis, le prog lui meme étant du code 68000 (J'ai vérifié !)).
Une Jag avec une puce Bjl et le cable de transfert.
Comme prog de dvp sur l'Atari il vous faut principalement, trois trucs :
- Devpac (Version supérieur au 1.99 (Oui je sais ...... !))
- MadMac (Assembleur Gpu / Dsp)
- Loader Bjl.
Vous avez tout ? Donc détails.
Chargez Devpac, a droite une barre d'outils est présente (Tools) dedans vous pouvez placer des progs, pour cela allez dans le menu (Dérouler le) avant de cliquez sur une case, gardez 'Control' enfoncé et cliqué, un formulaire s'ouvre.
En haut vous mettez le nom qui doit apparaitre dans le menu, par exemple : 'Bjl uploader' pour le prog de transfert.
En dessous le type de prog (Tos dans le cas du Bjl, si vous savez pas trop cliquez sur Gem, meme si c'est un prog Tos cela plantera pas (Normallement pas !))
Après la ligne de commande, il y a un petit truc pour accélérer tout cela. Quand vous assemblez votre prog, vous le faites sur disque toujours avec le meme nom de fichier, par exemple quand j'assembles un code à envoyer à la Jag, je le fais toujours avec ce nom E:TRY.TOS. Pourquoi faire cela ?
Pour allez très vite !! Dans la ligne de commande vous cliquez sur This et vous rentrez 'E:TRY.TOS' ou le nom de votre prog.
Comme cela chaque fois que vous cliquerez (sans 'Control') dans le menu sur Bjl Uploader, le loader sera lancé et le nom de fichier envoyé au loader sera 'TRY.TOS' se trouvant sur le lecteur E:, votre code sera chargé et lancé sur la Jag sans rien faire de plus, cela va beaucoup plus vite !!!
Ensuite vous cliques sur Fsel et selectionnez le loader, et voilà on continue.
Vous retournez dans le menu outils (Tools) choisissez maintenant une autre ligne, cliquez dessus (Control enfoncé) et on refait pareil pour l'assembleur MadMac, vous pouvez aussi préciser un nom de fichier comme avant, par contre une chose, vous avez une option pause, cliquez sur 'on', par ce que quand vous lancez MadMac il quitte dès qu'il a fini, donc on peut pas voir si il y a des erreurs (Ca vous arrive ?!?) ou et lequels !!!
Ensuite menu Tools et vous sauvez tout cela 'Save tool info'.
Voila mon menu à moi :
(Oubliez Devpac Dsp et le RCS (Ou si vous les avez tant mieux !), c'est pour le dvp Falcon et les utilitaires dvpé pour la Jag.)
Comme cela quand vous lancez Devpac a chaque fois tout est en place, faudra juste indiquer une fois le nom du fichier quand vous assemblez, car ceci n'est pas sauvé (Du moins avec une version 2.xx), faites le direct quand vous lancez Devpac, car je me suis fait avoir plusieurs fois.
Donc si je veux coder un truc.
Je charges Devpac, j'écris mon morceau de code et je l'assemble normalement (Alt A puis return). Puis au retour je vais lancer le loader (Car bien sur vous n'avez pas d'erreur, avec Atari on est tous des dieux !) menu Tools et un clique sur Bjl Uploader et hop tout est envoyé et lancé sur la Jag, qui dit mieux !!!
Vous pouvez laissé tourné votre code sur la Jag, pour voir certains détails et en profiter pour modifier votre code sur votre Atari, c'est nickel.
Comment faire pour les codes Gpu / Dsp ?
C'est ultra simple (Avec Atari on est tous....) Vous écrivez votre code Gpu (Le Gpu est mon ami, le Dsp aussi !) sous Devpac, vous le sauvez en 'powercode.s' (Nom choisi arbitrairement...) direction menu Tools, on clique sur MadMac et soit vous avez déjà prédéfini votre ligne de commande et cela part tout feu tout flamme, soit vous rentrez le nom de fichier et return. Et hop retour a Devpac !!
C'est pas beau !!! Pour utilisé un code Gpu je fais un
Code_dsp: INCBIN "E:POWERCODE.O"
EVEN (Etre sur de la parité zau caz ou !)
Avec Devpac l'avantage, c'est plusieurs fenêtres simultanément, j'écris le code 68000 dans une fenêtre et le code Gpu dans une autre, si mon code 68000 tourne correctement, mais le code Gpu a des soucis, c'est top moumoutte, exemple.
Alt 1 (Fenetre 1 devant) : pour avoir ma fenetre avec mon code Gpu en premier plan je modifies mon code et clique sur MadMac, retour je fais
Alt 2 (Fenetre 2 vous savez maintenant !) : retour a mon code 68000, je fais Alt A lance l'assemblage et clique sur Bjl loader. Cela va très vite, je vous le dis je suis tombé amoureux de la Jag, de cette manière de dvp, l'essayer c'est l'adopter.
Ceux qui utilise toute les m... officielles d'Atari (Librairie ou ce qui y ressemble), linker et tout le toutim, est ce que vous dvp aussi vite sur un PC ? Malgré votre Gigahertz de vitesse ? Mon 68030 a 16 Mhz est il plus rapide pour dvper ? Ca c'est une bonne question... La technique Atari, meilleure ? Qui oserait en douté.....
En passant, vous pouvez faire assembler votre code complet par MadMac (68000 et Gpu), mais c'est moins marrant, et perso certaines directives sont pas completes ou fonctionne pas (Apparement pas d' ORG en section 68000 !) et comme cela vous n'assemblez que le code que vous avez modifié (68000, Gpu) et si cela plante vous savez quel code déconne !!!! Héhé !!
Enfin bon, voila cet article arrive à sa fin. J'espère que vous avez tout compris et que cela vous aidera.
Certains préfereront Assemble, mais il dispose pas de menu Tools et sur un Falcon il est déjà lent, donc le choix est fait.
Si vous avez besoin d'une puce Bjl, du cable de transfert, de Devpac, de l'assembleur MadMac (Enfin tout quoi !) adressez vous a Fredifredo sur ce même forum ou allez en liens et cliquez sur son site (Que j'aime beaucoup pour la présentation !)
GT Turbo (C.V.S.D. Membre de la Jagware Team) :8)
P.S. : On peut encore accélérer un peu la chose, si vous avez un peu de ram (Enfin vu la taille du loader et de MadMac !) sur les versions 'récentes' de Devpac (Celle que vous pouvez trouvé sur le CD a Fredifredo), quand vous définissez vos outils, il y a une case 'make resident', si vous cliquez la dessus, Depac va gardé les outils en mémoire, conclusion plus d'accès disque a part votre code !!!
Cet article peut etre librement utilisé et recopié, traduit, vous avez juste obligation de citer qu'il provient de Jagware.org
-
En résumé, et comme dans toutes communautés, il faut savoir réfléchir avant d'agir et donc se modérer en tout. Le respect de l'autre est la base évidente pour pouvoir fonctionner en groupe. Voici donc deux trois règles de simple bon sens à appliquer ici en général :
- Je tourne sept fois mes mains autour de mon clavier avant d'écrire quoi que ce soit, surtout si j'ai l'intention d'insulter quelqu'un. D'autant plus que je suis pleinement responsable de tout mes propos.
- Je sais me servir d'une recherche et ça tombe bien celle ci est très bien. Ca m'évitera de passer pour un âne à redemander ce qui existe déjà.
- Je n'abuse pas des services qui me sont proposés, les PM (par exemple) n'étant pas des boites mail, je n'en conserve pas une centaines juste pour le plaisir de grever les ressources qui me sont aloué.
- Je suis conscient que même si les décision se font de concert autant que faire se peut, les responsables en places restent seul juges au final. Et concernant les inscriptions, je commence comme simple membre et doit prouver mon intérêt pour pouvoir accéder à un rang supérieur ou voir mon compte disparaitre (mais rien ne presse).
- Je n'ai aucun intérêt à chercher la petite bête ou la faille dans le système, qu'elle soit technique ou morale.
Et en voici le moto :
Jagware est tout simplement le premier site communautaire de développement Jaguar français. Mis en place par une poignée d'amateur Atari avertis. Il vise une saine émulation et une entraide complète entre toutes les personnes désireuses de produire du matériel pour la 64bits aux yeux félins.
Nous voulons ce site comme une réserve pertinente et aussi complète que précise de méthodes, techniques, codes, débats, et reflexions globales pour faciliter et encourager les sorties futures.
Le site vient d'ouvrir, le contenu y est encore léger mais comme toutes communautés, elle n'attend que d'autres membres pour la faire vivre.
Certes reservés en priorité aux francophones, le site n'en est pas moins ouvert à tout développeurs international via une section du forum en anglais.
L'équipe Jagware.
Cette charte n'est pas exhaustive et n'est là que pour rappeller l'engagement de groupe et les règles sous jacentes qu'impliquent l'inscription.
English version :
In a few words, and like in every community, you have to think, at least, twice before doing anything and therefore moderate yourself in everything. Mutual respect is the obvious base to be able to work together. So here we go with a few common sense rules to follow :
- I turn seven times my hands around my keyboard before writing anything, especially if i'm willing to insult someone. Knowing that i'm responsible for all my messages and talks.
- I know how to use a search engine which is great because this one is really efficient. So, i won't be taken for an idiot because i asked for something that already exist.
- I won't abuse services that are available on this site, PM (for instance) are not mailboxes, i won't keep a hundred of them just for the pleasure of overusing ressources that are allocated to me.
- I am conscious that even if decision are made all together as much as possible, responsible peoples in place (site owners) are the only final judges. Concerning inscription, i start as a simple member and must prove my interest to get a higher rank or see my account be deleted (but i have time before that).
- I have no interest in finding loopholes in the system, be it technical or moral.
These terms of service are not exhaustive (and are probably written in a poor english...) and are only here to remind you of the commitment and underlying rules implyed by your inscription.
-
Comment calculer une valeur approchée de cosinus et sinus ? Disons qu'on désire avoir une table de cosinus et sinus par incrément de 1 degré avec une
"précision" n=8192
Nous utiliserons pour générer la table de consinus et sinus les formules :
cos(a+
=cos(a)*cos(-sin(a)*sin(sin(a+
=sin(a)*cos(+cos(a)*sin(ou
cos(a-
=cos(a)*cos(+sin(a)*sin(sin(a-
=sin(a)*cos(-cos(a)*sin(avec a="l'angle à calculer" et b=1
cos_1=cos(1)*8192 et vaut 8190
sin_1=sin(1)*8192 et vaut 143
Le meilleur angle pour commencer à calculer et ne pénaliser aucune des deux tables pour le manque de précision aux angles 0, 90, 180 et 270 degrés est a=45.
Pour générer les tables aux angles entre 0 et 45 degrés :
n=8192 table_cos(45)=5792 table_sin(45)=5792 table_cos(01)=8190 table_sin(01)=0143 pour i allant de 44 à 1 table_cos(i)=(table_cos(i+1)*table_cos(1)+table_sin(i)*table_sin(1))/n table_sin(i)=(table_sin(i+1)*table_cos(1)-table_cos(i)*table_sin(1))/n fin boucle sur i table_cos(00)=8192 table_sin(00)=0000
Pour le reste, je vous renvois à vos souvenirs de première pour compléter les tables par symétrie
Une routine asm est disponible sur le site de DHS ici dans la section Misc sources and routines
Azrael
-
This is the method i use to separate bloc of pixels from others one, so being able to, as an example, extract logos from background. But its quite limitated. It's usually only possible if background and logo are in different colors of the palette. But you can use this technique with every paint program you can find even if this tutorial has been made using the great Neochrome Master.
This is our working pic. Let's take a self explanatory example, you made this great logo and showed it to your coder, he then said it could be used in your next production but you'll have to remove the red background !!
You have only a few solutions left. You kill him : no good in a long term thinking. You kill yourself : being dead is not that funny at all. You chose pencil in Neo master and start a long night of rework : and what else !? Or you remind yourself of that funny guy from this crew with a sadly long name and its technique.
This method is simple, take your bucket tool, choose the color that approach the most the one close to your filling point, and click.
Easy ! Then go on, select your next color and click again.
Definitely not that hard. And it just goes like this, so let me put a few more images to show how it works and then explain how to finish the work.
You got the basic method. As you can see it's not finished yet, on a picture like this you may have to redo the whole technique a few more times. You can select your colors from the first to the last again or just go back and forth, it merely depends on the way the picture is made. If you want to speed up the process, you can roughly erase (shortcut D for Disk) around the block you want to keep and start to fill afterwards.
Okay, after you managed to fully repaint the part you want to erase, just give it a black and last fill and you're done.
Voila !!
As i stated in the beginning, before using this technique, be sure to double check you could use it, if your part to erase is mixed with the remaining one (i mean colors of both are mixed), you better not use it and start use some old good elbow grease.
This technique is provided as is and no guaranty and stuff is provided. Let's say if you messed up something, it's all your fault. But if you use it, i want you to do your most wackiest smile when you start your work.
RaZ -
Les invités, plus maintenant (un reste de configuration douteuse).
Fredifredo, check tes mails.
-
Deux bières, beaucoup de bonne musique, un putain de mal de dos, un brin de sadomasochisme.
Voilà ce qu'il a fallu pour finaliser cette migration.
Le site est ouvert, il reste une ou deux choses à faire (modifier le message à l'inscription entre autre) mais c'est plus que fonctionnel (si j'ai correctement parametré le bousin en fait
).Ce que vous devez savoir :
- Les PM n'ont PAS été transferé (ils seront disponibles sur l'autre site encore pour quelques temps).
- Les images interne n'ont pas pu être tranferé correctement, tant pis pour elles.
- Les news aussi sont passé à la trappe (un best of est néanmoins prévu).
- Les signatures ont été oublié (presque volontairement
).- Vous allez tous recevoir un mail avec votre nouveau mot de passe temporaire. Un peu de patience donc.
P.S. : Le sujets actifs sont dispo sous le lien Today's Active Topics
[English] The new Jagware is up and running, there still is one or two things to do (registration message for example) but it's more than usable (if i configured the whole 'thinggy' well
).What you have to know :
- PMs have NOT been transfered (they will be available in the old site for some time).
- Internal pictures could not be transfered properly...
- News have been lost (a best of is on its way).
- Signatures have been forgotten (almost on purpose
).- You will all receive an email with your new temporary password. Just be patient.
P.S. : You could see recent active topics by following this link Today's Active Topics
-
Ce CMS déjà, et là il attend un peu que j'ai fini ma semaine de boulot et comme on est un peu dans les cartons (enfin, surtout moi), il passe en second plan.
-
OK OK, vu votre locacité voici venir le chat !
D'ici 24h au pire vous pourrez y accèder par cette adresse http://chat.jagware.org/
Mais en attendant que le sous domaine soit activé vous pourrez y aller par ici : http://bombscars.net/blab/, cette adresse n'est pas à conserver, elle pourrait ne plus fonctionner sous peu.
Je clos le topic et écrit direct une news.
-
Alors, RaZ 29 ans. Je bosses comme grouillot dans l'informatique avec des horaires qui rendraient neurasthénique n'importe quelle carthésien (d'ou le fait que j'attaque ce message à 2h30 au boulot).
Ce que je sais faire, de tout, mais mal ou disons moyennement. Du graph, du design, de l'ergonomie, du PHP/MySQL (gestion/création de sites webs et tout le toutim), un peu de musique (a base de sample), photos et j'ai aussi mis les mains dans Macromedia Flash.
Ajouté à cela le fait que je suis surement un des mecs d'ici qui s'intéresse le plus aux jeux vidéos, pas seulement aux jeux en eux même mais à tout ce qui les touchent de près ou de loin. Les personnes qui les font, les idées qu'ils véhiculent, les messages qu'ils transmettent, toutes leurs philosophie, les approches créatives, etc...
Cotoyant quelques bon gros gamers, je pense donc disposé d'une bonne vision globale de ce que peut être un jeu vidéo, de ce qu'il lui faut et pleins d'autres trucs très chiant.
C'est donc une tendance à s'interesser à tout le coté artistique du jeu vidéo. Je peux citer comme jeu pour vous faire cerner l'idée, Psychonauts, Ico, Rez, Shadow of the colossus (qui arrive enfin en Europe), Meteos (le summum du concept juste après Tetris).
Et contrairement à GT (dont je suis le frère à titre informatif), je suis capable d'écrire un message en structurant en paragraphe sans sauter deux lignes entre chaque groupes de cinq mots.
Analphabète de tous poils, à vos lunettes !
in Miscellaneous
Posted
Un lien vers un article en anglais un peu technique qui explique comment on peut faire pour réaliser certaines techniques que l'on croyait impossible sur une console que l'on pense dépasser.
On y parle de HDR, de tone mapping, de Fur shader, de self-shadowing, et tout ça sur une console old-gen pour un jeu absolument unique qu'il vous faudra essayer un jour ou l'autre.
Comme quoi la technique et la poésie ne sont pas antinomique.
Making of Shadow of the Colossus