IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Assembleur Discussion :

Utiliser la carte graphique


Sujet :

Assembleur

  1. #1
    Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mars 2014
    Messages
    183
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 23
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mars 2014
    Messages : 183
    Points : 60
    Points
    60
    Par défaut Utiliser la carte graphique
    bonjour,
    je voudrais savoir si il est possible de faire tourner un programme assembleur sur la carte graphique.
    et aussi comment afficher un pixel sur l'écran (par exemple "affiche le pixel en x: 789 y: 321 r: 12 g:132 b:94)
    enfaite je voudrais essayer de faire une sorte d'api graphique de type opengl mais qui marcherais autrement qu'avec des polygones
    merci,

  2. #2
    Expert éminent sénior
    Avatar de Kannagi
    Homme Profil pro
    cyber-paléontologue
    Inscrit en
    Mai 2010
    Messages
    3 215
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : cyber-paléontologue

    Informations forums :
    Inscription : Mai 2010
    Messages : 3 215
    Points : 10 140
    Points
    10 140
    Par défaut
    Je comprend pas trop ta démarche , su un post tu dis que tu es 'nul' et ensuite tu veux faire de la 3D en assembleur...
    Pour afficher un pixel a l'écran il faut passer obligatoirement par l'OS , et faire tourné un programme en assembleur sur la CG est a mon avis impossible sans passer par l'OS aussi et donc assembleur n'est pas le plus indiqué pour faire cela (de plus il n'y a pas de documentation tres clair pour toutes les CG).
    On t'avais conseillé OpenGL qui n'est pas une simple API mais plus une norme pour manipuler le hardware d'un carte graphique mais si tu veux utiliser la CG seulement pour tes calcul il y a OpenCL.

  3. #3
    Modérateur
    Avatar de Obsidian
    Homme Profil pro
    Développeur en systèmes embarqués
    Inscrit en
    Septembre 2007
    Messages
    7 360
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Développeur en systèmes embarqués
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2007
    Messages : 7 360
    Points : 23 600
    Points
    23 600
    Par défaut
    Citation Envoyé par RedSkidy Voir le message
    bonjour,
    je voudrais savoir si il est possible de faire tourner un programme assembleur sur la carte graphique.
    Techniquement oui, et c'est d'ailleurs une curiosité qu'on utilisait parfois sur les 8 bits justement pour mettre en évidence le fonctionnement des programmes en langage machine. Par contre, je ne suis pas sûr que ce soit exactement ce à quoi tu penses.

    Aujourd'hui, en revanche, c'est beaucoup plus difficile que sur les anciennes machines. Les cartes vidéos disposent de leur propre mémoire et quand il s'agit de cartes 3D, celle-ci n'est pas forcément directement visible par la machine hôte. En outre, celle-ci fonctionne en général en mode protégé ou assimilé. Il faudra donc obtenir les privilèges nécessaires pour avoir le droit d'y écrire.

    et aussi comment afficher un pixel sur l'écran (par exemple "affiche le pixel en x: 789 y: 321 r: 12 g:132 b:94)
    Une fois que tu as accès à la mémoire vidéo, il suffit d'écrire dedans comme s'il s'agissait de mémoire ordinaire. L'automate de ta carte vidéo va la lire de façon périodique et régulière, et la valeur de chacun de ses octets va piloter le signal vidéo de sortie et donc se traduire par un pixel à l'écran. Si tu charges un programme en langage machine dans la carte vidéo, tu verras apparaître une sorte de glitch sous la forme d'un ligne horizontale continue formée de pixels de différentes couleurs.

    enfaite je voudrais essayer de faire une sorte d'api graphique de type opengl mais qui marcherais autrement qu'avec des polygones merci,
    Oriente-toi déjà vers la SDL. En termes de fonctionnalités, d'approche et de simplicité d'utilisation, je crois que c'est exactement ce que tu veux faire.

  4. #4
    Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mars 2014
    Messages
    183
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 23
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mars 2014
    Messages : 183
    Points : 60
    Points
    60
    Par défaut
    oui la SDL je connais mais j'ai entendu dire qu'elle était plutot lente et pas très optimisé, l'optimisation est plutot importante pour ce que je veut faire

    enfaite le "programme en assembleur sur la carte graphique" se serait juste le programme qui s'occupe d'afficher les pixels avec les bons paramètres (donc pas forcément assembleur).
    pour opengl j'ai peur que se soit trop lourd et cause du lag inutile en plus est-ce qu'on est pas obligé de créer un contexte opengl pour afficher un pixel ? je préfèrerais pouvoir les afficher n'importe ou sur l'écran et gérer moi même les fenètres

  5. #5
    Responsable Systèmes


    Homme Profil pro
    Gestion de parcs informatique
    Inscrit en
    Août 2011
    Messages
    17 348
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Gestion de parcs informatique
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Août 2011
    Messages : 17 348
    Points : 42 815
    Points
    42 815
    Par défaut
    J'ai fait de l'affichage video en mode protégé mais sans OS, l'OS t'obligeant à passer par les drivers.
    Le principe, je récupérais l'adresse de la video mappée en mémoire après mise dans le mode de mon choix, ça je le faisais en mode réel.

    J'utilisais les fonctions vesa ax,4f00, 4fxx de l'int 0x10, puis en mode protégé j'accédais directement à la RAM video

    J'ai fait ça il y a longtemps.

    Utilises plutôt des bibliothèques qui seront beaucoup plus efficaces que toi.
    Ma page sur developpez.com : http://chrtophe.developpez.com/ (avec mes articles)
    Mon article sur le P2V, mon article sur le cloud
    Consultez nos FAQ : Windows, Linux, Virtualisation

  6. #6
    Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mars 2014
    Messages
    183
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 23
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mars 2014
    Messages : 183
    Points : 60
    Points
    60
    Par défaut
    justement je ne veut pas utiliser d'api mais essayer d'en faire une et c'est pour ça que j'ai besoin d'utiliser l'assembleur, c'est beaucoup plus rapide

  7. #7
    Modérateur
    Avatar de Obsidian
    Homme Profil pro
    Développeur en systèmes embarqués
    Inscrit en
    Septembre 2007
    Messages
    7 360
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Développeur en systèmes embarqués
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2007
    Messages : 7 360
    Points : 23 600
    Points
    23 600
    Par défaut
    chrtophe vient de te donner la réponse : l'interruption 10h et ses fonctions 4fxx.
    Ce que l'on essaie de te dire par ailleurs, c'est qu'il faut savoir à quel niveau tu comptes travailler :

    • As-tu déjà pratiqué l'assembleur auparavant ?
    • Si oui, sur x86 ou sur d'autres micro-processeurs ?
    • Si sur x86, est-ce que ton expérience correspond à la programmation 16 bits sous DOS ?
    • Si tu comptes travailler en 32 ou 64 bits sur les OS modernes, as-tu déjà une expérience dessus ?
    • Si tu fais tout cela juste pour l'exercice, es-tu réticent à faire un programme bootable qui s'amorcerait avant le système d'exploitation, depuis une clé USB vierge, voire une disquette si tu disposes encore d'un lecteur ?
    • Si non, dans quel environnement est censée fonctionner ton API ?

  8. #8
    Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mars 2014
    Messages
    183
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 23
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mars 2014
    Messages : 183
    Points : 60
    Points
    60
    Par défaut
    non je n'ai jamais fait d'assembleur et j'aimerais que mon api fonctionne sur toutes les machines a peu près et en 1920*1080 voir 4K mais d'après ce que j'ai compris c'est pas possible

  9. #9
    Modérateur
    Avatar de Obsidian
    Homme Profil pro
    Développeur en systèmes embarqués
    Inscrit en
    Septembre 2007
    Messages
    7 360
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Développeur en systèmes embarqués
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2007
    Messages : 7 360
    Points : 23 600
    Points
    23 600
    Par défaut
    C'est possible mais c'est un travail titanesque si tu veux qu'elle fonctionne sur vraiment TOUTES les machines : il va falloir d'un côté prendre en charge tous les systèmes d'exploitation existants (et pas seulement Windows) et, de l'autre, reconnaître TOUTES les cartes graphiques du marché. Enfin, il faudra prendre en charge les machines qui ne sont pas des PC et, au final, les ordinateurs qui ne fonctionnent pas avec des x86.

    Ensuite, ton API sera faite pour être exploitée en quel langage ? Directement en assembleur avec des CALL ? Avec des interruptions ? Avec des appels de fonctions type C (paramètres empilés) ? Avec des objets ?

  10. #10
    Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mars 2014
    Messages
    183
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 23
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mars 2014
    Messages : 183
    Points : 60
    Points
    60
    Par défaut
    bon alors réctification :
    que sur les pcs, sur windows, linux et mac (quoique je sais pas je déteste les gens qui vénèrent apple) et les cartes graphiques y'en a pas qui marchent de la même façon ? (et les plus récentes du genre a partir de 2012)
    ce seras utilisé dans un code c++

  11. #11
    Responsable Systèmes


    Homme Profil pro
    Gestion de parcs informatique
    Inscrit en
    Août 2011
    Messages
    17 348
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Gestion de parcs informatique
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Août 2011
    Messages : 17 348
    Points : 42 815
    Points
    42 815
    Par défaut
    Sur le principe, oui, elles fonctionnent de la même façon, les Macs sont équipés de cartes ATI ou NVidia.

    Par contre, elles ont chacune leurs spécificités et c'est pourquoi il faut un driver différent pour chaque carte.

    Sans API, tu vas t'amuser, et tu pourra ensuite travailler chez un constructeur de carte Video.

    Et ce que je te disais avoir fait, je suis pas sûr que je pourrais le refaire en HD 4K ( sauf si le support VESA int 0x4fxx a été implémenté en conséquence)
    Ma page sur developpez.com : http://chrtophe.developpez.com/ (avec mes articles)
    Mon article sur le P2V, mon article sur le cloud
    Consultez nos FAQ : Windows, Linux, Virtualisation

  12. #12
    Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mars 2014
    Messages
    183
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 23
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mars 2014
    Messages : 183
    Points : 60
    Points
    60
    Par défaut
    mais OpenGL par exemple comment il fait pour utiliser la carte graphique ? en plus si on prend une vieille version d'opengl elle va marccher sur des cartes graphiques qui n'éxistaient pas encore a l'époque de sa création (donc pas besoin de gérer chaque modèle de carte ou chaque driver)

  13. #13
    Membre chevronné
    Avatar de Forthman
    Homme Profil pro
    conception mécanique
    Inscrit en
    Janvier 2005
    Messages
    702
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 48
    Localisation : France, Tarn et Garonne (Midi Pyrénées)

    Informations professionnelles :
    Activité : conception mécanique
    Secteur : Industrie

    Informations forums :
    Inscription : Janvier 2005
    Messages : 702
    Points : 1 905
    Points
    1 905
    Par défaut
    Depuis 1994, les constructeurs se sont mis d'accord pour respecter un certain "standard"
    Les BIOS depuis cette année là, gèrent les modes "standard VESA"
    Par contre, ces modes sont rudimentaires, et n'exploitent pas les ressources des processeurs des cartes graphiques.
    Donc il est tout à fait possible de faire du 1900x1080 en VESA, mais ça ne sert à rien de vouloir bosser dessus (pour faire une API) car très lent.

    Du coup, suivant la carte, il te faudra un driver spécifique, et donc avoir accès aux informations... que les fabricants ne donnent pas

  14. #14
    Responsable Systèmes


    Homme Profil pro
    Gestion de parcs informatique
    Inscrit en
    Août 2011
    Messages
    17 348
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Paris (Île de France)

    Informations professionnelles :
    Activité : Gestion de parcs informatique
    Secteur : High Tech - Matériel informatique

    Informations forums :
    Inscription : Août 2011
    Messages : 17 348
    Points : 42 815
    Points
    42 815
    Par défaut
    Forthman a raison. Les fonctions int 10h 4fxx dont je parlais active le VESA dans une résolution choisie, c'est ce que j'ai oublié de préciser. Je présume que le VESA est toujours existant, mais je ne suis pas sûr de pouvoir continuer à utiliser les fonctions en mode réel, il me faudrait utiliser les fonctions en mode protégé.
    Ma page sur developpez.com : http://chrtophe.developpez.com/ (avec mes articles)
    Mon article sur le P2V, mon article sur le cloud
    Consultez nos FAQ : Windows, Linux, Virtualisation

  15. #15
    Modérateur
    Avatar de Obsidian
    Homme Profil pro
    Développeur en systèmes embarqués
    Inscrit en
    Septembre 2007
    Messages
    7 360
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Développeur en systèmes embarqués
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2007
    Messages : 7 360
    Points : 23 600
    Points
    23 600
    Par défaut
    Citation Envoyé par RedSkidy Voir le message
    bon alors réctification :
    que sur les pcs, sur windows, linux et mac (quoique je sais pas je déteste les gens qui vénèrent apple) et les cartes graphiques y'en a pas qui marchent de la même façon ? (et les plus récentes du genre a partir de 2012)
    ce seras utilisé dans un code c++
    C'est déjà plus raisonnable. C'est même faisable.

    Citation Envoyé par RedSkidy Voir le message
    mais OpenGL par exemple comment il fait pour utiliser la carte graphique ? en plus si on prend une vieille version d'opengl elle va marccher sur des cartes graphiques qui n'éxistaient pas encore a l'époque de sa création (donc pas besoin de gérer chaque modèle de carte ou chaque driver)
    Justement : il s'appuie sur les pilotes (les drivers) de ta carte, qui sont écrits directement par le fabricant de ta carte. Ceux-ci, d'un côté manipulent directement les registres hardware de ta carte selon ses spécifications propres et, de l'autre côté, dialoguent avec l'OS via une interface de programmation (API) universelle, plus ou moins normalisée, et publiée par les gens qui ont écrit le système d'exploitation. Tout l'enjeu, donc, est d'écrire non seulement une interface qui soit propre et bien conçue (même si elle reste complètement abstraite) mais qui se répande suffisamment vite pour qu'elle s'impose au dépit d'autres solutions, faute de quoi elle ne servirait à rien.

    Ceci permet à l'OS de piloter virtuellement n'importe quelle carte puisqu'elles sont toutes censées répondre aux mêmes ordres, via leur pilote… pour peu que celui-ci soit installé !

    Jadis, le hardware lui-même était normalisé : d'abord parce qu'initialement, c'était IBM qui fabriquait le PC (c'était son ordinateur) ainsi que le matériel qui allait avec. Ensuite parce que jusque dans les années 1990, il était beaucoup plus fréquent de faire de l'assembleur et de manipuler soi-même les registres matériels de sa carte. Toutes les cartes étaient étaient donc compatibles entre elles, et ce jusqu'à VGA. Tu peux en voir les registres ici : http://web.stanford.edu/class/cs140/...ga/portidx.htm , et ici : http://web.stanford.edu/class/cs140/...vga/vgareg.htm . C'est encore le cas aujourd'hui et c'est heureux parce que c'est ce qui te permet d'avoir quand même une image même quand aucun pilote n'est disponible, c'est-à-dire quand le système d'exploitation n'est pas encore chargé (au boot, messages du BIOS…) ou quand celui-ci n'a pas fini d'être installé, ou qu'il tourne en mode sans echec, etc. C'est pour cela que tu peux facilement avoir un mode 800x600 voire 1024x768 quand tu fonctionnes en mode dégradé mais jamais plus haut. C'était très utilisé par les jeux vidéos qui avaient besoin de puissance, par les demomakers (« Mode X », etc) et d'une manière générale par tous les programmeurs amateurs qui étaient déjà habitués à cela et qui avaient envie de faire la même chose que toi aujourd'hui : prendre les commandes, savoir comment ça marche, s'affranchir des couches inutiles et pousser son matériel dans ses moindres retranchements.

    Seulement, à partir de cette époque, le marché des PC en général et celui du matériel a explosé et toutes les cartes ont commencé à proposer des fonctionnalités propres en plus du minimum syndical requis par les spécifications du PC. Surtout qu'à ce moment, la 3D commençait à décoller et que certaines technologies sont devenues populaires, comme 3DFX. Bref, l'industrie s'est développée bien plus vite que l'architecture vieillissante d'un ordinateur conçu par une compagnie qui le devenait aussi, et imposer des limites matérielles obsolètes n'avait plus de sens, surtout que le produit avait le temps d'arriver en fin de vie avant que les spécifications soient publiées. Parallèlement, il est devenu difficile de trouver des ordinateurs sans OS, et spécialement un PC, entièrement trustés par Windows. Il est donc devenu normal d'exploiter une carte à travers son pilote. Mais effectivement, comme ça reste fondamental, certains OS comme Linux essaient de maintenir une gestion aussi poussée que possible des grandes familles de cartes, au moins en 2D, via des pilotes généraux et propres au noyau.

    Il en reste que tout cela concerne les changements de mode. Pour le reste (afficher quelque chose à l'écran), toutes les cartes fonctionnent de la même façon : elles disposent d'un espace mémoire assez large dans lequel il suffit d'écrire pour que ce que l'on y mette se répercute immédiament à l'écran. Il ne s'agit nullement d'envoyer un « ordre » à la carte ou de passer par un quelconque appel. Du moins pas tout de suite. Cet espace a longtemps été normalisé lui-aussi : d'abord à partir de B8000 (soit B800:0000 en mode réel), puis A0000 avec le VGA. C'est vite devenu trop peu pour évoluer, faire plusieurs plans, etc. et cela nous empêchait d'ajouter plusieurs cartes vidéos (problème commun à tous les adapteurs, d'ailleurs). Depuis le PCI, l'OS peut faire une transaction avec le bus pour demander à mapper n'importe quel périphérique où bon lui chante.

    Une fois que tu as récupéré ou mappé toi-même cette mémoire à un endroit connu, tu verras des pixels apparaître dès que tu y écriras, mais le type de pixels dépendra évidemment du mode que tu as choisi. D'autre part, tu auras accès à toute la mémoire vidéo, ce qui te fera entrer en conflit avec le mode fenêtré du système d'exploitation. En effet, les fenêtres que tu vois à l'écran sont rien d'autres que des dessins produit par le gestionnaire de fenêtres de ton OS, tels que tu pourrais les dessiner toi-même dans ton logiciel de dessin préféré. Si tu veux que ça tienne dans une fenêtre, il faut soit te contraindre à le faire toi-même, soit utiliser une API qui le fasse, soit encore utiliser un truc comme la SDL, encore elle, qui contrôlera elle-même tes accès à un certain segment de mémoire et qui se chargera de les traduire en mode et adresses compatibles avec la fenêtre en question, même si c'est lent.

    C'est pour cela que le « mode plein écran » des jeux vidéos est important : il ne s'agit pas d'étendre les marges de la fenêtre courante jusqu'aux limites du moniteur, mais de redonner le contrôle direct de la mémoire vidéo à une application donnée.

    Reste la 3D maintenant : c'est encore autre chose. Au départ, c'était purement logiciel également. Il s'agit principalement de faire des calculs pour projeter une scène 3D vers la 2D, avant de rendre cette dernière vers l'écran. Ça se faisait beaucoup dans les démos, sans framework particulier. Sur PC, c'est surtout Wolfenstein 3D et DOOM I/II qui ont rendu l'affaire aussi populaire. Dans l'industrie, c'est le succès des logiciels de CAO qui a tiré la discipline vers le haut. Le problème est qu'autant dessiner en 2D est trivial puisque cela se résume à des mathématiques de collège et qu'il suffit d'une simple règle de trois pour trouver l'adresse en mémoire d'un pixel à l'écran à partir de ses coordonnées, la 3D est grosse consommatrice de fonctions trigonométriques et a besoin de structures bien définies pour pouvoir exprimer ce que l'on veut faire. En particulier, elle s'appuie fortement sur les matrices.

    C'est Silicon Graphics qui a défini l'interface OpenGL et écrit sa bibliothèque. Il s'agit donc d'une solution logicielle, basée sur IrisGL (produite par les mêmes acteurs). C'était avant tout une API, voire presque une sorte de langage, pour permettre aux logiciels de dessiner en 3D facilement, mais elle était surtout faite pour être exploitées sur leur matériel, les fameuses stations de travail SGI, futuristes et extrêmement puissantes (mais aussi hors de prix) pour l'époque. Il s'agit donc d'un logiciel propriétaire et conçu pour fonctionner sur du matériel spécifique, mais elle est très bien conçue (appréciable quand on sait le temps qu'il faut y consacrer pour la maîtriser) et surtout, SGI a choisi depuis de rendre publique à chaque fois les spécifications de l'avant-dernière version de sa bibliothèque. Ça permet à des gens d'écrire depuis zéro une bibliothèque entièrement compatible, éventuellement libre, auxquels les programmes OpenGL peuvent être liés sans même avoir à recompiler. C'est notamment le cas de Mesa, qui est lente parce tout est rendu par le microprocesseur sans forme d'accélération, mais qui honore toutes les requêtes quand même.

    Avec l'explosion du marché des cartes 3D, OpenGL est devenue l'interface privilégiée pour « parler 3D » et, donc, un standard de fait. Microsoft a essayé de concurrencer, voire casser cela, avec DirectX et Direct3D. Ils ont pratiquement réussi mais la norme a continué à évoluer et l'effort consenti par Microsoft s'est affaibli (un peu comme pour Internet Explorer). En plus, OpenGL restait incontournable, voire se renforçait, sur les plateformes non Microsoft.

    La dernière pièce du puzzle est apportée par les cartes graphiques 3D elles-mêmes : il s'agit d'un adaptateur graphique ordinaire mais à hautes performances et qui, surtout, est dotée d'une puce sur laquelle va se trouver un grand nombre (entre 100 et 1000) d'unités de calculs rudimentaires mais extrêmement rapides, montées en parallèle, et faites pour balancer leur résultat directement dans la mémoire vidéo. Il est donc facile de les programmer pour qu'elles tracent automatiquement un segment ou fassent des calculs mathématiques généraux. Et ce sont les fabricants de ces cartes qui, en même temps qu'ils proposent un pilote pour le système d'exploitation, fournissent également leur propre implémentation de la bibliothèque OpenGL ! Tu la vois notamment être mise en place lorsque tu installes le pilote nVidia sous Linux. Cette bibliothèque, elle, proposent exactement la même interface que les autres également, ce qui permet là encore aux programmes existants de s'y lier sans modification particulière, mais ne fait aucun calcul : elle se contente de passer le tout aux processeurs de la carte graphique qui se chargent alors de faire les calculs et le rendu directement à l'écran.

    Ce qui permet de répondre à ta question initiale : ce n'est pas une bibliothèque OpenGL unique qui, de proche en proche, pilotent toutes les cartes graphiques, mais ce sont les fabricants de toutes les cartes graphiques qui « remontent » depuis le hardware jusqu'à deux ou trois standards populaires.


    Voici comment sont agencées, sous X-Window en particulier, les différentes couches impliquées dans tout ce qui a trait au DRI :
    http://en.wikipedia.org/wiki/Direct_...Infrastructure
    http://en.wikipedia.org/wiki/File:Li...Stack_2013.svg

  16. #16
    Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mars 2014
    Messages
    183
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 23
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mars 2014
    Messages : 183
    Points : 60
    Points
    60
    Par défaut
    merci pour cette énorme pavé qui résume l'histoire de la 3D (et que tu à dus mettre 3 jours a rédiger ^^) je me disait que ça passait surement par les pilotes mais dans ce cas ma quastion serais plutot : comment utiliser les drivers ?

  17. #17
    Modérateur
    Avatar de Obsidian
    Homme Profil pro
    Développeur en systèmes embarqués
    Inscrit en
    Septembre 2007
    Messages
    7 360
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 47
    Localisation : France, Essonne (Île de France)

    Informations professionnelles :
    Activité : Développeur en systèmes embarqués
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Septembre 2007
    Messages : 7 360
    Points : 23 600
    Points
    23 600
    Par défaut
    Citation Envoyé par RedSkidy Voir le message
    merci pour cette énorme pavé qui résume l'histoire de la 3D (et que tu à dus mettre 3 jours a rédiger ^^)
    Pas trois jours, mais une bonne partie de l'après-midi, en effet.

    je me disait que ça passait surement par les pilotes
    Pas tout-à-fait : tu vas être obligé d'utiliser les pilotes pour changer de mode vidéo et utiliser les formats récents. Une fois que c'est fait, il faudra également passer un appel système (plus générique) pour obtenir un pointeur vers l'adresse de la mémoire vidéo. Une fois que tu l'as, tu peux écrire dedans directement, sans faire un seul appel système ou à une bibliothèque. En tout cas, en ce qui concerne la 2D.

    mais dans ce cas ma quastion serais plutot : comment utiliser les drivers ?
    Tes pilotes sont faits pour prendre place au sein d'un système d'exploitation. Et ce système d'exploitation définit à la base une ou plusieurs API que les pilotes en question doivent respecter. C'est donc cette API qu'il faut déterminer et ça va dépendre à la fois de ton système d'exploitation et de l'environnement graphique que tu utilises (par exemple, X-Window sous Unix).

    Regarde le graphique que je t'ai donné en dernier lien du précédent commentaire pour voir où se situent les différents composants et comment ils communiquent entre eux. Ensuite, si tu t'intéresse au DRI en particulier, tu peux jeter un œil à ceci : http://dri.freedesktop.org/wiki/Documentation/

  18. #18
    Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mars 2014
    Messages
    183
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 23
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mars 2014
    Messages : 183
    Points : 60
    Points
    60
    Par défaut
    ha oui merci en effet j'avais louper les 3 dernières lignes

    en gros si j'ai bien compris DRI est un framework qui permet d'utiliser presque directement la carte graphique c'est ça ?

  19. #19
    Membre du Club
    Homme Profil pro
    Étudiant
    Inscrit en
    Mars 2014
    Messages
    183
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 23
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Mars 2014
    Messages : 183
    Points : 60
    Points
    60
    Par défaut
    mais ça marche sur autre chose que linux parce-que je viens de trouver une mini api sympa : pixel toaster apparament c'est exactement fait pour ce que je veut faire

  20. #20
    Expert éminent sénior
    Avatar de Kannagi
    Homme Profil pro
    cyber-paléontologue
    Inscrit en
    Mai 2010
    Messages
    3 215
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 35
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : cyber-paléontologue

    Informations forums :
    Inscription : Mai 2010
    Messages : 3 215
    Points : 10 140
    Points
    10 140
    Par défaut
    Je me demande pourquoi on t'explique des choses si c'est pour l'ignoré...
    Pixel Toaster ne fait rien de plus que la SDL , il fait des pixel coté software (comme la SDL) peut être même plus longue vu que la SDL est plutôt optimisé pour afficher des pixels.
    Sinon la SDL n'est pas lente fondamentalement , ça dépend de ce qu'on fait mais il est sur que faire des grosse résolutions avec la SDL est assez longue , pour des basses résolution elle est plus rapide , si on utilise de l'alpha ect.

    Et du coup ça redevient redondant vu qu'on t'explique depuis un bon moment soit tu fait des pixel cote CPU (avec la SDL par exemple) , soit cote GPU (avec OpenGL et les shaders) , donc fait ton choix.
    Après je trouve mes collègue assez sympa , personnellement je t'aurais conseille d’approfondir la programmation au lieu de faire un projet qui est hors de ta portée.

Discussions similaires

  1. Réponses: 4
    Dernier message: 15/11/2011, 21h38
  2. Comment utiliser la carte graphique
    Par Ikit dans le forum Windows Presentation Foundation
    Réponses: 0
    Dernier message: 03/11/2009, 11h58
  3. Mesurer l'utilisation mémoire d'une carte graphique
    Par Harry dans le forum Composants
    Réponses: 1
    Dernier message: 26/02/2007, 18h20
  4. [carte graphique] utiliser entree s-video
    Par nicoarrf dans le forum Composants
    Réponses: 11
    Dernier message: 17/11/2006, 14h08
  5. Réponses: 4
    Dernier message: 06/02/2006, 19h16

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo