Simuler une simple carte graphique

Question

Ok.I peut trouver des modèles de simulation pour simples architectures (Modifier: certainement comme non x86).

Par exemple, utilisez un int que le compteur de programme, utilisez un byte array comme la mémoire et bientôt.

Mais comment puis-je simuler la fonctionnalité de la carte graphique (la carte la plus simple imaginable)?

comme array pour représenter chaque pixel et "peindre" chaque pixel un par un.
Mais quand peindre - synchronisé avec la CPU ou de manière asynchrone? Qui stocke graphic data dans ce tableau? Y a-t-il une instruction pour stocker un pixel et peindre un pixel?

Veuillez considérer tous les points d'interrogation ('?') Ne veut pas dire "vous posez beaucoup de questions" mais explique le problème lui-même - Comment simuler une carte graphique?

Edit:LINK à une conception de la mise en œuvre de base pour la simulation CPU + mémoire

Answer 1

cartes graphiques en général portent un certain nombre de kilo-octets ou Mo de mémoire qui stocke les couleurs de pixels individuels qui sont ensuite affichés sur l'écran. La carte scanne cette mémoire un certain nombre de fois par seconde en transformant la représentation numérique des couleurs de pixels en signaux vidéo (analogiques ou numériques) que l'affichage comprend et visualise.

La CPU a accès à cette mémoire et à chaque fois qu'elle la change, la carte traduit finalement les nouvelles données de couleur en signaux vidéo appropriés et l'affichage montre l'image mise à jour. La carte effectue tout le traitement de manière asynchrone et n'a pas besoin de beaucoup d'aide de la part du CPU. Du point de vue de la CPU, c'est comme écrire la nouvelle couleur de pixel dans la mémoire de la carte graphique à l'emplacement correspondant aux coordonnées du pixel et l'oublier. Il peut être un peu plus complexe dans la réalité (en raison d'artefacts de synchronisation pauvres tels que tearing, snow et similaires), mais c'est l'essentiel de celui-ci.

Lorsque vous simulez une carte graphique, vous devez en quelque sorte refléter la mémoire de la carte simulée dans la mémoire de la carte graphique physique. Si dans l'OS vous pouvez avoir un accès direct à la mémoire de la carte graphique physique, c'est une tâche facile. mettre en œuvre tout simplement écrire à la mémoire de votre ordinateur quelque chose émulé comme ceci:

void MemoryWrite(unsigned long Address, unsigned char Value) 
{ 
    if ((Address >= SimulatedCardVideoMemoryStart) && 
     (Address - SimulatedCardVideoMemoryStart < SimulatedCardVideoMemorySize)) 
    { 
    PhysicalCard[Address - SimulatedCardVideoMemoryStart] = Value; 
    } 

    EmulatedComputerMemory[Address] = Value; 
} 

qui précède, bien sûr, suppose que la carte simulée a exactement la même résolution (par exemple, 1024x768) et la représentation de pixels (par exemple, 3 octets par pixel, premier octet pour le rouge, deuxième pour le vert et troisième pour le bleu) comme carte physique. Dans la vie réelle, les choses peuvent être un peu plus complexes, mais encore une fois, c'est l'idée générale. Vous pouvez accéder à la mémoire de la carte physique directement au MSDOS ou sur un simple ordinateur x86 sans système d'exploitation si le code du BIOS de l'ordinateur permet de le démarrer et de le limiter aux fonctions de service du BIOS (interruptions) et à l'accès direct au matériel pour tous les autres périphériques PC. Btw, il sera probablement très facile d'implémenter votre émulateur en tant que programme DOS et de l'exécuter directement dans Windows XP (Vista et 7 ont un support extrêmement limité pour les applications DOS en éditions 32 bits et aucune en éditions 64 bits). , vous pouvez, cependant, installer XP Mode, qui est XP dans une VM en 7) ou mieux encore dans quelque chose comme DOSBox, qui semble être disponible pour plusieurs systèmes d'exploitation.

Si vous implémentez le programme en tant que programme Windows, vous devrez utiliser GDI ou DirectX pour dessiner quelque chose à l'écran. Sauf erreur de ma part, aucune de ces deux options ne vous permet d'accéder directement à la mémoire de la carte physique, de sorte que les modifications qu'elle contient seraient automatiquement affichées. Dessiner des pixels individuels sur l'écran en utilisant GDI ou DirectX peut être coûteux s'il y a beaucoup de rendu. Redessiner tous les pixels de la carte simulée chaque fois que l'un d'entre eux est modifié équivaut au même problème de performance. La meilleure solution est probablement de mettre à jour l'écran 25 à 50 fois par seconde et de ne mettre à jour que les parties qui ont changé depuis le dernier rafraîchissement. Subdiviser le tampon de la carte simulée en tampons plus petits représentant des zones rectangulaires de 64x64 pixels, marquer ces tampons comme "sales" chaque fois que l'émulateur leur écrit et les marquer comme "clean" quand ils ont été dessinés sur l'écran. Vous pouvez configurer un écran de conduite de minuterie périodique et les faire dans un fil séparé. Vous devriez être capable de faire quelque chose de similaire sous Linux, mais je ne connais pas grand-chose à la programmation graphique.