INTERFACE 2D½ (STYLE DIABLO) L'ABC (EN COURS) [VISUAL C++, MFC, SDI]

/****************************************************************************
//BOOL CFake3DView::PreCreateWindow(CREATESTRUCT& cs)
//
//Fonction: c'est un évènement qui survient à la création de la fenêtre
//je l'ai choisi par défaut comme ça mais le code qui suit doit simplement
//être fait une fois AVANT le premier affichage
*****************************************************************************/
BOOL CFake3DView::PreCreateWindow(CREATESTRUCT& cs)
{
	COLORREF OldBackColor;
   BITMAP bm;
   
   //on charge notre permier bitmap
   cMur.LoadBitmap(IDB_BITMAP4);
   //on va chercher ses caractéristiques
   cMur.GetBitmap(&bm);

   
   //on crée un monochrome bitmap de même dimension qiu va contenir le masque
   cMask_Mur.CreateBitmap(bm.bmWidth,bm.bmHeight,1,1,NULL);

   //on crée nos device context (on les gardes en passant... pourquoi refaire ce qui est fait)
   DcPict.CreateCompatibleDC(NULL);
   DcMask.CreateCompatibleDC(NULL);

   /****travail de DC******/

   //on charge nos images dans nos DC  
   DcPict.SelectObject(&cMur);
   DcMask.SelectObject(&cMask_Mur);
   
   //on change la couleur de fond de notre image et on met la valeur de la couleur
   //que l'on veut transparente
   OldBackColor = DcPict.SetBkColor(DcPict.GetPixel(0,0));
   
   //ensuite on copie notre image dans le monochrome bitmap le résultat est:
   //Pour toute couleur différente de la couleur de fond, la couleur est 
   //noir
   //pour la couleur = à la couleur de fond, c'est blanc.
   //donc on se retrouve avec une copie de notre image en noir, un peu comme l'ombre
   //de notre image
   DcMask.BitBlt(0,0,bm.bmWidth,bm.bmHeight,&DcPict,0,0,SRCCOPY);
   
   //maintenant on fait l'inverse... on va mettre notre masque par dessus notre
   //image, le but étant que l'on veut mettre au noir tout ce qui ne fait pas 
   //parti de notre image, qui représente le background suivez la recette
   DcPict.SetTextColor(RGB(255,255,255));//mettre la couleur de texte à blanc
   DcPict.SetBkColor(RGB(0,0,0));//mettre la couleur de fond à noir

   //avec l'operation AND, pour tout ce qui a été marqué en blanc dans notre mask
   //et qui représente le fond, notre image résultante sera marqué de noir
   //pour le reste, intouché
   DcPict.BitBlt(0,0,bm.bmWidth,bm.bmHeight,&DcMask,0,0,SRCAND);

   /****image 2****/
   //on fait pareil qu'avec la tuile
   cTuile.LoadBitmap(IDB_BITMAP3);
   cTuile.GetBitmap(&bm);

   //on crée un monochrome bitmap qui va fitter avec
   cMask_Tuile.CreateBitmap(bm.bmWidth,bm.bmHeight,1,1,NULL);

   /****travail de DC******/
   DcPict.SelectObject(&cTuile);
   DcMask.SelectObject(&cMask_Tuile);
   
   OldBackColor = DcPict.SetBkColor(DcPict.GetPixel(0,0));
   DcMask.BitBlt(0,0,bm.bmWidth,bm.bmHeight,&DcPict,0,0,SRCCOPY);
   
   DcPict.SetTextColor(RGB(255,255,255)); 
   DcPict.SetBkColor(RGB(0,0,0));

   DcPict.BitBlt(0,0,bm.bmWidth,bm.bmHeight,&DcMask,0,0,SRCAND);

   DcPict.SetBkColor(OldBackColor);

   return CView::PreCreateWindow(cs);
}
/****************************************************************************
//void CFake3DView::OnPaint() 
//
//Fonction: C'est un évènement qui survient de temps à autres et qui réclame 
//un rafraichissement immédiat de la fenêtre.  Bon prince nous redessinons 
//alors la totalité de la fenêtre (pour le moment aucune optimisation de 
//l'affichage) 
*****************************************************************************/
void CFake3DView::OnPaint() 
{

   CPaintDC dc(this); // device context for painting

   //ici c'est le dessinage comme tel.. on a rien a faire alors on en fait un bidon
   //on verra plus tard quoi faire avec ça
   Dessiner_Mur(dc,175,190,0);
   Dessiner_Tuile(dc,150,200,0);
   Dessiner_Mur(dc,200,200,0);
   Dessiner_Tuile(dc,175,210,0);
   Dessiner_Tuile(dc,225,210,0);
   Dessiner_Tuile(dc,200,220,0);

   Dessiner_Tuile(dc,125,210,0);
   Dessiner_Tuile(dc,150,220,0);
   Dessiner_Tuile(dc,175,230,0);
   Dessiner_MurTransparent(dc,150,240,0);
   Dessiner_MurTransparent(dc,200,240,0);
   Dessiner_MurTransparent(dc,175,250,0);

}
/****************************************************************************
//void CFake3DView::Dessiner_Mur(CDC &dc,int x,int y,int No_Mur)
//
//Fonction: Cette méthode a pour fonction de dessiner un mur, les coordonées
//x et y qu'elle reçoit en paramètre représente le coin inférieur droit de 
//l'image (même pas celle du mur puisque qu'une partie est transparente).  Celà
//vient du fait que nous considèrons le plancher comme étant plat et donc, en 
//référençant les "éléments graphiques" par le bas on a pas vraiement à 
//s'occuper de leurs dimensions (ils ont tous la même largeur aussi)
*****************************************************************************/
void CFake3DView::Dessiner_Mur(CDC &dc,int x,int y,int /*No_Mur*/)
{
   BITMAP bm;
   //on va chercher les dimension de l'image, que l'on va soustraire aux coordonnées
   //de façon à aligner le bas des images
   cMur.GetBitmap(&bm); 

   //on commence par dessiner avec un AND notre masque ce qui a pour effet de faire
   //un gros trou noir qui a la même forme que l'image, (on dessine l'ombre)
   DcMask.SelectObject(&cMask_Mur);
   dc.BitBlt(x-bm.bmWidth,y-bm.bmHeight,bm.bmWidth,bm.bmHeight,&DcMask,0,0,SRCAND);     

   //puis avec un OR on dessine ensuite notre image
   DcPict.SelectObject(&cMur);
   dc.BitBlt(x-bm.bmWidth,y-bm.bmHeight,bm.bmWidth,bm.bmHeight,&DcPict,0,0,SRCPAINT);    
}
/****************************************************************************
//void CFake3DView::Dessiner_MurTransparent(CDC &dc,int x,int y,int No_Mur)
//
//Fonction:  Cette fonction est amusante, elle dessine le même mur que la 
//fonction précédente mais elle à la place fait une moyenne entre la couleur 
//déjà mise à l'écran et la couleur du mur a afficher, ainsi, on a l'impression
//de voir au travers du mur, ce qui permet de voir tout le sol, même si nous 
//sommes derrière un mur
*****************************************************************************/
void CFake3DView::Dessiner_MurTransparent(CDC &dc,int x,int y,int /*No_Mur*/)
{
   BITMAP bm;

   //on va lire les dimensions comme toujours
   cMur.GetBitmap(&bm); 
   
   //on va avoir besoin du masque comme d'habitude
   DcMask.SelectObject(&cMask_Mur);
   //on va chercher l'objet à dessiner
   DcPict.SelectObject(&cMur);
 
   //notre matériel de survie
   int i,j;
   COLORREF coul_1;
   COLORREF coul_2;
   long Result;
   long Var_temp;
   
   
   //on boucle dans une boucle pour parcourir tout les pixels
   for(i=x-bm.bmWidth;i<x;i++)
   {
      for(j=y-bm.bmHeight;j<y;j++)
      {
         //on regarde dans le masque pour savoir si on doit ou non dessiner à cet endroit
         //(si c'est noir ça veut dire que l'on doit dessiner, sinon (c'est blanc) ça veut dire
         //que c'est le fond on fait rien
         if(DcMask.GetPixel(i-(x-bm.bmWidth),j-(y-bm.bmHeight)) == 0)
         {
            //on va lire les deux couleurs
            coul_1 = dc.GetPixel(i,j);
            coul_2 = DcPict.GetPixel(i-(x-bm.bmWidth),j-(y-bm.bmHeight) ) ;

            //on fait la moyenne pour les deux valeurs de bleu
            //j'utilise un ratio 3/4de transparence 1/4 d'opacité donc (3*couleur_1 + couleur_mur) / 4 = couleur_voulue
            Var_temp = ((coul_1 & 0x00FF0000)+(coul_1 & 0x00FF0000)+(coul_1 & 0x00FF0000)+(coul_2 & 0x00FF0000))/4;
            Var_temp &= 0x00FF0000; //je masque pour enlever les parties qui ont pu déborder vers la droite
            Result = Var_temp; 
            
            //ensuite le vert
            Var_temp = ((coul_1 & 0x0000FF00)+(coul_1 & 0x0000FF00)+(coul_1 & 0x0000FF00)+(coul_2 & 0x0000FF00))/4;
            Var_temp &= 0x0000FF00;
            Result |= Var_temp;
            
            //puis le rouge
            Var_temp = ((coul_1 & 0x000000FF)+(coul_1 & 0x000000FF)+(coul_1 & 0x000000FF)+(coul_2 & 0x000000FF))/4;
            Var_temp &= 0x000000FF;
            Result |= Var_temp;
            
            //dans le Result on a donc notre couleur selon un ratio de 3/4
            dc.SetPixelV(i,j,Result);  
         }
      }
   }
   //fin de la fonction, ce que je recherche donc c'est une fonction qui va faire
   //exactement ça mais plus rapidement, tout est le bien venu.
}
/****************************************************************************
//void CFake3DView::OnPaint() 
//
//Fonction: 
*****************************************************************************/
void CFake3DView::Dessiner_Tuile(CDC &dc,int x,int y,int /*No_Tuile*/)
{
   BITMAP bm;
   
   cTuile.GetBitmap(&bm); 

   //on commence par dessiner notre image en noir
   DcMask.SelectObject(&cMask_Tuile);
   dc.BitBlt(x-bm.bmWidth,y-bm.bmHeight,bm.bmWidth,bm.bmHeight,&DcMask,0,0,SRCAND);     

   //puis on dessine avec un OR sur tout ce qui est noir
   DcPict.SelectObject(&cTuile);
   dc.BitBlt(x-bm.bmWidth,y-bm.bmHeight,bm.bmWidth,bm.bmHeight,&DcPict,0,0,SRCPAINT);    
}