C'est quand même de la merde la programmation Windows avec gestion de bitmap ! 300000 fonctions a connaitre par coeur pour esperer pretendre faire un programme potable.
Je ne suis pas d'accord avec toi. Pour travailler avec des bitmaps, voici ce qu'il suffit de faire:
1) Créer un DC (device context) pour y placer tes objets graphiques (comme la bitmap)
2) Créer une bitmap (DIB de préférence, plus lente à blitter mais avec un accès par tableau comme sur TI) et la sélectionner dans ton DC.
3) Blitter (copier la bitmap) vers ta fenêtre à partir du HDC en question.
Voici un petit exemple:
//Déclarations
HDC hdc2;
HBITMAP hbm2;
unsigned char *Bits;
[...]
//Création d'un HDC et d'une DIB
hdc2=CreateCompatibleDC(GetDC(NULL));
hbm2=CreateCompatibleBitmap(hdc2,256,224);
CreeDIB(hdc2,256,224,24,&hbm2,(void**)&bits);
[...]
//Tests
unsigned char *ptr;
//Copie le sommet de l'écran (256x224) vers ta DIB
BitBlt(hdc2,0,0,256,224,GetDC(NULL),0,0,SRCCOPY);
//Accède à la DIB par pixel (prend chaque pixel+celui d'à côté/2)
for (j=0;j<223;j++)
for (i=0;i<255;i++) {
//Optimisable en un accès séquentiel et deux pointeurs, mais plus facile à
//comprendre ainsi, car les lignes de DIB sont inversées (la première est en bas,
//la dernière en haut). Cf la doc MSDN sur les DIBs.
ptr=(bits+256*3*(223-j)+3*i);
//(Pixel1+Pixel2)/2
*ptr++=(*(ptr+3)+(*ptr))>>1;
*ptr++=(*(ptr+3)+(*ptr))>>1;
*ptr++=(*(ptr+3)+(*ptr))>>1;
}
//Etire le buffer et le dessine sur la fenêtre (hWnd)
StretchBlt(GetDC(hWnd),0,0,512,448,hdc2,0,0,256,224,SRCCOPY);Le seul truc compliqué est la fonction CreeDIB. Mais tu n'as qu'à l'écrire une fois pour tous tes projets
. Je te la donne:
BITMAPINFOHEADER BIH; //Bitmapinfoheader de la DIB. Important!
//Crée une DIB de taille "cx" et "cy" pour pouvoir y dessiner en l'utilisant comme un
//bloc de mémoire de "ibitcount" bits par pixel. La sélectionne dans "hdc" et la stocke
//dans "hbm". Le pointeur sur les bits de cette bitmap sera écrit dans "bits".
int CreeDIB(HDC hdc, int cx, int cy, int ibitcount, HBITMAP *hbm, void **bits)
{
// Crée une structure BITMAPINFOHEADER pour décrire la DIB.
int iSize = sizeof(BITMAPINFOHEADER);
//Vide la bitmapinfoheader
memset(&BIH, 0, iSize);
// Remplit les infos de l'en-tête
BIH.biSize = iSize;
BIH.biWidth = cx;
BIH.biHeight = cy;
BIH.biPlanes = 1;
BIH.biBitCount = ibitcount;
BIH.biCompression = BI_RGB;
// Crée une DIBSection
*hbm = CreateDIBSection(hdc,
(BITMAPINFO*) &BIH,
DIB_RGB_COLORS,
(void**)bits,
NULL,
0);
// Selectionne la bitmap dans le DC
if (*hbm && *bits) {
SelectObject(hdc,*hbm);
return 1;
}
else
return 0;
}J'espère que ça t'aidera à te décider si un jour tu veux t'y mettre... parce que GDI bouffe quand même moins de ressources, est bien meilleur dans un environnement multitâche et est en général beaucoup plus rapide que DirectX pour blitter (cependant ça dépend de ta carte graphique, mais c'est valide même avec les dernières ATI/nVidia/Intel).
Par contre, tu dois utiliser les fonctions GDI (plus lentes) ou coder tes routines toi-même (en général tu peux atteindre une bonne vitesse, et la différence avec l'accélération matérielle est compensée par le temps de blit final gagné et les avantages d'avoir directement un accès rapide à chacun des pixels). De plus GDI est plus lent en plein écran (meilleur pour les fenêtres).
?
c'était y a plus de 8 mois
) et mon Advanced Quest System (AQS) ça plantait :/
derrière mon PC :/)
euphémisme 
. Je te la donne:
