COMPRENDRE LES BASES
Votre yaroze vient juste d'arriver, et vous mordez
d impatience pour commencer à la programmer. Vous
avez feuilleté le
guide de l'utilisateur mais vous ne comprenez pas la
moindre chose.
Alors vous vous dites : "ouais on va se mater le
code d'une démo je vais mieux comprendre"
Mais non c'est encore PIRE!!!!
Aussi j'espère que ce pseudo-tutorial vous aidera
àmieux comprendre le mécanisme de la programmation
sur psx.
Dans ce document mon but est de développer un programme-squelette
le plus basic à partir duquel
de prochains développements pourront etre fait.
Les suggestions et critiques sont les bien venus.
--------------------------------------------------------------------------------------------------------------------------------
Vue d'ensemble de la mémoire vidéo
La PSX possède 1 Mb de mémoire vidéo
qui est représenté comme un espace d'adresse de 1024
* 512 (16 bits)
On le connait aussi sous le nom de frame buffer.
Nous devons indiquer un endroit du frame buffer qui correspondra au buffer d'affichage.
Il sera utilisé pour afficher vos sprites, ect....à l'écran.
La taille actuelle d'affichage est restreinte aux résolutions indiqués
dans le guide de l'utilisateur.( les ecrire )
Double buffering
Un des problèmes avec l'affichage est l'important phénomène de saut d'image ( appelé flickering ). Ainsi à chaque image l'écran est effacé provoquant ce phénomène de clignotement. Pour éviter cela nous utiliserons 2 buffers pour dessiner ce qui va etre afficher sur la télé. Pendant qu'un buffer est affiché sur l'écran , l'autre buffer sert à dessiner ( on parle alors de "drawing on off-screen "). Quand ce même buffer a finit , nous permutons simplement les 2 buffers afin que le buffer qui servait à l'affichage devienne le buffer "dessinable" et que le buffer "dessinable" soit maintenant affiché à l'écran.
Mécanisme d'affichage du faisceau
Le faisceau dans une télé part du haut-gauche de
l'écran jusqu'à atteindre l'extrémité droite de
l'écran. Puis ce faisceau se stoppe et descend d'un pixel, retourne à
l'extrémité gauche pour recommencer le mécanisme décrit
precedemment jusqu'à arriver jusqu'au coin bas-droit de l'écran.
Quand le faisceau atteind cet endroit de l'écran , se déclenche
alors le balayage vertical du faisceau qui part du coin bas-droit jusqu'à
atteindre le coin haut-gauche de l'écran( avec bien sur un sens de bas
en haut ).
Lorsque le balayage vertical est fini les 2 buffers permutent.
Tables d'ordennancement ( ordering tables)
Comme de nombreux programmeurs en graphisme 3d
vous le diront , la clé d'un affichage rapide d'objets 3D , est d'affiché
les objets qui sont les plus éloignés derrière ceux qui
sont les plus proches du joueur. Si nous n'utilisons pas un type de données
approprié autre que les routines d''affichage classique, nous ne pourrions
qu'utiliser peu d'objets avant que le CPU (Central Process Unit ) bug en ce
qui concerne l'affichage. Ce type de données évitant ce problème
s'appelle LES TABLES D'ORDENNANCEMENT ( dans votre
code vous utilisez la notion anglaise : Ordering
Tables ).
Le principe de base est d'utiliser un nombre défini de T.O.
Lorsque que les routines graphiques sont appelées pour un objet, une
valeur qui repésente la valeur z de l'objet
( profondeur ) est fournise. Les routines graphiques entrent alors dans la T.O.
appropriée. Quand le système est prêt, les T.O. sont traversées
de la fin au début , affichant la scène correctement.
C'est pourquoi elles sont nécessaires même si vous travaillez en
2D. En effet ce type de données étant inclus dans la librairie
de la Yaroze, il serait idiot de développer un nouveau type de données
simplement pour travailler en 2D.Une autre bonne raison est que même en
travaillant en 2D, il se peut que l'on veuille représenter l'impression
de profondeur. Imaginer une scène contenant des avions. Les avions proches
du joueur bougent plus vite que ceux qui se situent plus loin.
Bien sur il y a des désavantages. Le nombre de T.O. est limité
à un maximum de 14 bits, c'est à
dire 2^14 = 16384, et le minimum est de 1 bits,
c'est à dire 2^1 = 2. Plus le nombre de T.O. est grand, plus le temps
de calcul des routines graphiques est important. Ainsi je vous conseille d'utiliser
beaucoup de T.O. seulement si votre programme contient de nombreux objets. D'un
autre côté, il se peut que vos objets ne soit afficher correctement
si vous utilisez un petit nombre de T.O. pour dessiner les objets avec de nombreuses
variations de profondeur. Par exemple un objet qui devait se trouver en arrière-plan
est dessiné avant d'autres objets qui devraient se trouver en avant-plan.
La T.O. qui représente le plan le plu proche du joueur est affecté
à la valeur 0. Ainsi les objets qui sont
de plus en plus éloignés se voit ranger dans l'ordre croissant.
0 ----------> n-ième T.O.
T.O. le + proche ------------> T.O. le + éloigné
Grâce à cette petite présentation des instructions
de base de la programmation sur NetYaroze, nous pouvons maintenant écrire
une "routine de base". Cette routine devra alors être quasiment
tout le temps être inclus à votre code.
On peut résumer l'implémentation de cette routine de base :
1. Initialise le système
et les différentes types de données
2. Réactualise les
données du jeu
3. Implémente les
routines graphiques et les lient aux Tables d'ordennancements ( T.O.)
4. Permute les 2 buffers
5. Réaliser l'affichage par l'intermédiaire des T.O.
Nous voici enfin à la partie la plus intéressante : Le Code .
Il est disponible en fichier source ( bases.c ) et est commenté. Si vous avez la moindre question sur ces sources mailez-moi ( stevox ) je suis à votre disposition