Mise en situation: je suis en Turbo C en dos, jai une affichage de 640x480 16 couleurs avec la souris activé. Ya tu un moyen pour que la couleur (de 0 a 15 ) du pixel ou jai cliqué soit transferer dans une variable.
 
Notice: je dois utiliser les interruptions et non les commandes de C

up

T'es obligé d'utiliser les IT ??
parske sans IT, sans "commande de C" c'est pas trop dur (et + rapide)
 
=> la memoire video commence à A000:0000
un pixel occupe 4 bits ...
déclare un pointeur vers A0000000 et c'est joué !
pour le pointeur, je sais plus trop, je crois que c'est (à vérifier):  
    char * Ecran = (char*)(A0000000);
mais il doit te foutre un warning et faut lui préciser que c'est un long :
    char * Ecran = (char*)(A0000000L);
 
sinon y'a une fonction de l'IT 10 qui permet ca mais j'ai oublié esolé:

ok ouais.. je comprend (a moitié), désolé je suis debutant en C.
Je ne suis pas obligé de prendre des IT, je voulais seulement dire que je peux en prendre...    mais si tu pourrais approfondir ce que tu dis.. ca risque detre tres interessant.. jy avais deja penser.. mais jetait pas sur de l'adresse de depart de la memoire video.. surtout que je suis en 640x480 donc il y a plus autant de page decran...

mais comment utilise tu les IT ...
avec de l'assembleur ou via les DOS.h ?

j'utilisais les IT via DOS.h, mais ca na plus dimportance pcq jaime beaucoup ton approche pour la memoire video... dans mon programme je fonctionne en X et Y (0,0) à (639,479), ye me reste juste a savoir si je click sur (444,333) ben ca va etre quel adresse en memoire...

Tu peux utiliser les IT sous TC :
1) tu appelles l'IT 10h pour passer ds le mode 13h (VGA):
union REGS r;
r.h.ah = 0x00;
r.h.al = 0x13; /* <- MODE 13h */
int86(0x10,&r,&r); /*<- INT 10h */
2) pour dessiner un pixel tu fais:
r.h.ah = 0x0C; /* <- Fonct° 0Ch */
r.h.al = 0; /* 0=noir, 1=bleu, ..., 15=blanc */
r.x.cx = x; /* abscisse (entre 0 et 319)  */
r.x.dx = y; /* ordonnée (entre 0 et 199)  */
int86(0x10,&r,&r); /* et hop ! */
 
Sinon tu peut comme le dit HelloWorld accéder directement à la mém. vidéo :
unsigned char far* video = (unsigned char far*)0xA0000000L; /* le ptr doit être déclaré far */
video[x + 320*y] = 0; /* 0 = noir et x+320*y = offset mém. */

[edit]--Message édité par Amadeus--[/edit]

Ouais le seul probleme c que je veux pas ecrire un pixel mais lire un pixel deja ecrit... mettons jai 4 carre de couleur.. 1 rouge 1 bleu 1 jaune et 1 vert... quand je nimporte ou.. ben ma variable couleur va etre egal au numero de la couleur ou jai cliqué...

Eh bien si tu veux lire un pixel tu shoppes ses coordonnées (via le handler de la souris) et tu lis video[offset] l'offset dans le cas vga 13h est x+320*y :
int couleur;
...
couleur = video[offset];
...
 
Sachant que la gestion de la souris se fait par l'IT 33h
(avant appel ax=0, int 0x33 puis après appel si ax=ffffh alors souris installé, ...) mais là c'est un peu plus complexe et tu peux te référer à la doc de tc ou jeter un coup d'oeuil au bios.h.

[edit]--Message édité par Amadeus--[/edit]

est-ce que ce bout de code serais bon???
 
int reponse;
char far *ptrNext;
ptrNext  = (char far *) MK_FP (0xB800, 0);
ptrNext = ptrNext x+320*y;
reponse = (char)*ptrNext;

Y'a pas mal de doc la dessus sur internet
http://antoche.alrj.org/prog/vesa/ [...] e_Principe
http://perso.wanadoo.fr/olivier.lalorette/vga.htm
 
je me rend compte que ton mode deborde des 64Ko et j'ai jamais bossé avec des modes comme ca ...
 
mais attention, t'es en 16 couleurs = 4 bits
c'est à dire que sur un octet, y'a 2 pixels ...
donc il faut distinguer tes coordonnées de pixel avec tes coordonnées en video
 
pour ton pixel (444,333)
 
faut récupérer en video sa valeur :
elle est en 222,166
 
il me semble qu'il faut manipuler des chunks non pour passer dans la bonne page
ouf, c'est plutot loin tout ca ...
j'ai un peu oublié le C ...
 
je te laisse te demerder pour etre dans le bon chunk
 
en suite fait un pointeur sur l'adresse de depart du chunk
 
char * pointeur = (char *)(adresse, par exemple A0000000)
 
puis, lis l'octet de ton pixel 222,166
 
char octet;
octet= *(pointeur+(x*640)+y)
 
si tu debutes, je detailles un peu: on récupere le caractere se situant à :
    (adresse, par exemple A0000000)+ les coordonnes de ton pixel
 
pour les coordonnes, faut les déduire en tenant compte des chunks
 
=> faut soustraire 64Ko jusqu'a quon ait une valeur < 64Ko
 
=> 222,166, ca fait une adresse de  
    222*640 + 166 = 142246
142246 > 65536
    alors on recupere le numero de chunk par une division et l'adresse dans ce chunk par un modulo :
    num_chunk = 142246 / 65536 = 2
    adr_chunk = 142246 % 65536 = 11174
 
donc active le chunk numero 2
recupere l'octet 11174 dans ce chunk
 
pour ce faire :
 
<code pour activer chunk 2 (c'est une IT)>
octet= *(A0000000+11174);
 
donc, t'as ton octet
si ton pixel 444,333 a une abscisse paire, alors sa couleur est dans les 4 bits de gauche, sinon c'est droite :
 
 pixel332   pixel333
---------------------
| 0 0 1 1 | 0 1 1 0 |  octet lu (char)
---------------------
 
pour lire les 4 pixels de gauche :
    faut les faire passer à droite !
    octet = octet >> 4; /* decalage 4 bits à droite */
à droite
    octet = octet & 15 ; /* 00001111 en binaire */
 
et octet contient enfin ta couleur !!!:sweat:
 
je pense que c'est a peu pres ca, mais je te conseille vivement de d'inspirer de ce code et pas le recopier, il doit y avoir des erreurs (pas facile comme ca )

Oui l'idée est bonne sauf que pour que ça s'éxécute tu peux faire :
int reponse;  
unsigned char far *ptrNext = (unsigned char far*)MK_FP(0xA000,0);
reponse = (int)ptrNext[x+320*y];
 

mais il est pas en 320*200
et donc ca tiend pas sur 64 Ko
et donc c'est pas aussi facile
c'est expliqué ici :
http://progzone.free.fr/graphisme/ [...] a.html#IV3
 
je corrige une erreur :
    octet= *(A0000000+11174);  
c'est evidement
    octet = *(ptr_video+11174);
ou  octet = ptr_video[11174]
 
avec
    char * ptr_video = (char *)(A0000000);
A0000000 : debut memoire mode graphique (toi)
l'adresse en Bxxxxxx c'est pour le texte (tu lis une lettre affichee et pas un pixel)

C'est vrai qu'il est en mode vesa, j'y est pas pensé. D'hab sous tc on travaille dans le mode 13h. Sinon c'est pas plus compliqué en vesa et le doc que tu donne l'explique très bien.

http://asmbeginer.com/int/10H.HTM
 
tu choisis entre bosser ce qu'on t'as proposé
ou utilise la fonction 5h ...
 
pour changer chunk, ce serait la fonction 0Dh ...

pour les pages ecran, je sais pas trop comment ca fonctionne
j'ai trouvé un peu de doc :
 
http://pascalissime.future.easyspa [...] tpgact.htm
http://www.guetali.fr/home/creole/Confirme.htm (tout en bas)
 
mais c'est en mode text et inachevé
 
apparement je me suis emballé dans mon code
c'est pas A0000000 a chaque fois (il me semble que c'est avec le VESA ça)
mais une adresse par page ecran (chunk...)
 
j'ai croisé une fonction scrolling (haut ou bas) avec l'IT 10, je me demande si ca sert pas à faire défiler la page ecran (presedente ou suivante)
 
teste donc ces 2 fonctions : 6h(scrolling haut) et 7k=h (scrolling bas)
regarde ce que ca fait ...
=> apres ca ecrit à A0000000 un pixel et regarde où il apparait
si a chaque scrolling bas il est décalé (de 64Ko ...) alors c'est bon ...
tu fait autant de scrolling que de numeros de chunks
 
sinon ben met toi au VESA et manipule les chunks comme j't'ai dit, mais ca fait petetre un peu bcp d'un coup (mais bon le VESA, c'est juste la suite du VGA ...)

si tu es debutant .. je te conseille vivement d'utiliser une librairie graphique ... !!!
c'est plus simple / rapide / ultra documenté!
 
y'en a une sur mon site
http://zoggy.free.fr/ section cours.

Bordel je m'etais jamais imaginé que cetait si compliquer de lire juste un foutu pixel dans un ecran 640x480 16 couleurs... mais finalement jai trouvé kkchose avec un int.. le seul probleme avec linteruption pour lire un point graphique est qui faut cacher le curseur de la souris sinon ca prend toujours le point noir du curseur...
 
merci a vous

 
Tu a bien raison mais moi et FealiT on doit se plier au exgience du professeur (d'ailleurs le cours s'appelle fonctionnement interne des ordinateurs...)