Simuler une simple carte graphique

Question

Ok.I peut trouver des modèles de simulation pour simples architectures ( Modifier : certainement pas comme x86).
Par exemple, utilisez un int que le programme contre, utilisez un byte array comme la mémoire et ainsi de suite.
Mais comment puis-je simuler la carte graphique de (l'imaginable de la carte graphique la plus simple) fonctionnalité?
comme utiliser un array pour représenter chaque pixel et « peindre » chacun des pixels par un.
Mais quand PEINTURE- synchronisé avec CPU ou de manière asynchrone? Qui stocke graphic data dans ce tableau? Y at-il une instruction pour stocker un pixel et un pixel peinture?

S'il vous plaît examiner tous les points d'interrogation (?) Ne signifie pas « vous demandez beaucoup de questions », mais explique le problème lui-même - Comment simuler une carte graphique

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

Answer 1

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

La CPU a accès à cette mémoire et à chaque fois qu'il change, la carte se traduit par la suite les nouvelles données de couleur en signaux vidéo appropriés et l'écran affiche l'image mise à jour. La carte fait tout le traitement de manière asynchrone et n'a pas besoin de beaucoup d'aide de la CPU. Du point de vue de la CPU, il est à peu près 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, etc.), mais c'est l'essentiel.

Lorsque vous simulez une carte graphique, vous devez miroir en quelque sorte la mémoire de la carte simulée dans la mémoire de la carte graphique physique. Si dans le système d'exploitation, vous pouvez avoir un accès direct à la mémoire de la carte graphique physique, il 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;
}

Ce 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, la deuxième pour le vert et troisième pour le bleu) comme carte physique. Dans la vraie vie, les choses peuvent être un peu plus complexe, mais encore une fois, qui est l'idée générale.

Vous pouvez accéder à la mémoire de la carte physique directement MSDOS ou sur un PC nu x86 sans OS si vous faites votre démarrage de code par le BIOS du PC et de limiter à en utilisant uniquement les fonctions de service 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 à mettre en œuvre votre émulateur comme un programme DOS et exécuter directement dans Windows XP (Vista et 7 ont extrêmement support limité pour les applications DOS dans les éditions 32 bits et aucun dans les éditions 64 bits; vous pouvez toutefois installer XP mode , qui est XP dans une machine virtuelle à 7) ou mieux encore quelque chose comme DOSBox , qui semble être disponible pour plusieurs systèmes d'exploitation.

Si vous implémentez la chose comme un programme Windows, vous devrez utiliser soit GDI ou DirectX afin d'en tirer quelque chose sur l'écran. À moins que je ne me trompe, aucune de ces deux options vous permet d'accéder à la mémoire de la carte physique directement tels que les changements dans ce seraient automatiquement affichées.

Dessin pixels sur l'écran en utilisant GDI ou DirectX peut être coûteux s'il y a beaucoup de rendu. Redessinant tous les pixels de la carte simulée à chaque fois que l'un d'entre eux se change revient au même problème de performance. La meilleure solution est sans doute de mettre à jour l'écran 25-50 fois par seconde et mettre à jour uniquement les parties qui ont changé depuis la dernière redessiner. Lotir le tampon de la carte simulée en petits tampons représentant des zones rectangulaires, par exemple, 64x64 pixels, marquer ces tampons comme « sale » à chaque fois que l'émulateur écrit pour eux et les marquer comme « propre » quand ils ont été dessinés sur l'écran. Vous pouvez configurer un redessine écran d'entraînement périodique et minuterie les faire dans un thread séparé. Vous devriez être en mesure de faire quelque chose de similaire à ce sous Linux, mais je ne sais pas beaucoup sur les graphiques de programmation il.