Origine et principe du starfield

Il est difficile d’identifier précisément l’origine du concept de starfield. Cet effet graphique repose sur une idée simple : simuler un déplacement dans l’espace à l’aide de points lumineux représentant des étoiles. On distingue principalement deux approches.

La première consiste à créer un starfield en deux dimensions. Les étoiles se déplacent alors latéralement à l’écran, sans notion de profondeur. Le mouvement est limité à l’axe horizontal ou vertical et ne donne pas d’impression de distance.

La seconde approche introduit la perspective. Les étoiles apparaissent au centre ou au fond de l’écran et se rapprochent progressivement de l’observateur. Cette technique donne une réelle sensation de déplacement dans l’espace. Un exemple bien connu est l’économiseur d’écran de Windows. Certaines variantes remplacent les simples points par des sprites qui grandissent à mesure qu’ils s’approchent.

Dans ce chapitre, nous allons mettre en œuvre un starfield en trois dimensions utilisant la perspective, avec des points simples pour représenter les étoiles.

Présentation du code et des fichiers nécessaires

Le code assembleur présenté ici ne peut pas être compilé directement. Il s’agit du programme principal, qui dépend de fichiers externes. Pour obtenir un programme fonctionnel, il est nécessaire de décompresser l’archive fournie, laquelle contient l’image de fond, le code complet ainsi qu’un fichier COM déjà compilé.

Les explications détaillées sont données après le code afin de faciliter la compréhension globale du fonctionnement du programme.

Initialisation graphique et mise en place des étoiles

Le programme commence par le passage en mode graphique 13h, correspondant à une résolution de 320×200 pixels en 256 couleurs. Le segment mémoire vidéo est ensuite configuré afin de permettre l’écriture directe des pixels à l’écran.

Une image de fond est affichée avant de lancer l’animation. Le programme initialise ensuite les données des étoiles. Chaque étoile est définie par trois coordonnées : X et Y pour la position dans l’espace, et Z pour la profondeur. Les coordonnées X et Y sont générées aléatoirement dans les limites de l’écran, tandis que la coordonnée Z représente la distance par rapport à l’observateur. Toutes les étoiles commencent à une distance identique afin de simplifier les calculs.

Transformation des coordonnées et affichage à l’écran

Dans la boucle principale, le programme transforme les coordonnées tridimensionnelles de chaque étoile en coordonnées bidimensionnelles affichables. Cette transformation permet de simuler la perspective. Les positions calculées sont ensuite recentrées par rapport à l’écran.

Des vérifications sont effectuées pour s’assurer que les coordonnées obtenues se trouvent bien dans la zone visible. Si l’étoile est affichable, un pixel est tracé directement dans la mémoire vidéo à la position correspondante.

Après l’affichage, la valeur de Z est diminuée, ce qui donne l’impression que l’étoile se rapproche de l’observateur. Lorsqu’une étoile atteint une distance nulle, elle est réinitialisée à sa valeur de départ afin de recommencer le cycle.

Organisation du programme à l’aide de procédures

Le code est structuré à l’aide de procédures. Une procédure est un bloc d’instructions destiné à effectuer une tâche précise et réutilisable. Elle est appelée à l’aide de l’instruction CALL et se termine par RET, qui permet de revenir à l’instruction suivante du programme principal.

Les procédures facilitent la lecture du code, améliorent sa maintenance et évitent les répétitions inutiles. Il est important de comprendre que l’instruction RET ne met pas fin au programme : elle rend simplement la main au code appelant. Pour quitter le programme et revenir au système, une interruption spécifique doit être utilisée.

Principe mathématique de la perspective

L’illusion de profondeur repose sur une règle simple : plus un objet est éloigné, plus il apparaît petit. Pour simuler cet effet, chaque étoile possède une coordonnée Z qui indique sa distance par rapport à l’observateur.

La conversion des coordonnées 3D en coordonnées 2D s’effectue en multipliant X et Y par un facteur, généralement une puissance de deux afin d’optimiser les calculs, puis en divisant le résultat par Z. Cette opération permet d’obtenir les positions finales à l’écran.

Il est essentiel d’éliminer les cas où Z est nul ou négatif, car ils conduiraient à des divisions invalides et à des résultats incohérents.

Calcul de l’adresse en mémoire vidéo

Une fois les coordonnées X et Y calculées, l’adresse du pixel dans la mémoire vidéo est déterminée à partir de la largeur de l’écran. Ce calcul permet d’accéder directement à l’emplacement mémoire correspondant au point à afficher, où la couleur du pixel est ensuite écrite.

Intégration et affichage d’une image de fond

Plutôt que d’effacer l’écran à chaque itération, le programme utilise une image de fond fixe. Cette image occupe toute la surface de l’écran et améliore le rendu visuel du starfield.

L’image est stockée au format binaire brut, ce qui signifie que les valeurs des pixels sont enregistrées directement, sans compression. Pour être exploitée par l’assembleur, elle est convertie en directives de données puis incluse dans le programme principal. Une fois intégrée, elle peut être copiée en mémoire vidéo comme n’importe quelle autre donnée.

Contraintes liées au format COM

Les programmes au format COM sont limités à 64 kilo-octets et ne peuvent utiliser qu’un seul segment mémoire. Cette contrainte limite la taille des images et des données intégrées. Les formats EXE permettent de dépasser cette limite, mais leur gestion est plus complexe. Une alternative consiste à utiliser des outils de compression ou à passer à des modes de fonctionnement plus avancés.

Utilisation de l’instruction DUP pour les données

L’instruction DUP permet de réserver rapidement de grandes quantités de mémoire pour des tableaux de données. Elle est particulièrement utile pour définir des structures répétitives, comme les coordonnées des étoiles, sans avoir à écrire chaque élément manuellement.

Cette instruction rend le code plus lisible et plus propre, sans modifier la taille réelle du fichier généré, puisque l’assembleur développe automatiquement les données lors de l’assemblage.