Scroll ecran partir d'une mosaique de bitmap avec directx

Soyez le premier à donner votre avis sur cette source.

Snippet vu 3 781 fois - Téléchargée 37 fois

Contenu du snippet

permet de faire defiler une zone ecran a partir d'une mosaique de bitmap contigues, utilise DirectX7 pour les transferts

Source / Exemple :


// cette routine permet de gerer un scroll cran  partir d images stockees 
// dans un tableau de surfaces directdraw => lpBackIndex[IMGX][IMGY]
// les images utilisees doivent avoir les dimensions de l ecran
// il faut un nbre identique d images verticales et horizontales NBIMGX et NBIMGY
// deux index nommes g_scrollx et g_scrolly  indiquent la position du scroll
// lorsque les index sont  a 0, on se trouve avec le premier ecran composant le fond
//entirement affiche
// les images sont affichees via un Blt de DirectDraw

void CDoomMFCView::ScrollBackground()
{

//	LI=largeur d'image composant le fond
//	HI=hauteur d'image composant le fond

	HRESULT hr;	
	RECT rc_src,rc_dest;		// rectangles de source et destination du transfert
		
	int situation;		// indique le cas de figure correpondant aux images affiches  l'cran

	int index_x,index_y;		// index de placement sur les images

	int IMGX=1;		// position de l'image en X
	int IMGY=1;		// idem en Y	

	// en divisant les coordonnes du scroll par largeur et hauteur des images de fond
	// on dtermine dans quelles images se trouve affich le rectangle demand 

	index_x=g_scrollx/LI;	// dtermine cran affich en x
	index_y=g_scrolly/HI;	// dtermine cran affich en y

	// dtermine l'image  utiliser pour restaurer la zone demande
	IMGX=g_scrollx/LI;
	IMGY=g_scrolly/HI;

	Dtermine lalignement des images visibles  l'cran

	BOOL xalign=FALSE;
	BOOL yalign=FALSE;
	int i;
	
	// detecte l'alignement de l'cran avec une image composant le fond
	for (i=0;i<NBIMGX;i++)
	{
		if (g_scrollx==LI*i) { xalign=TRUE;}
	}

	for (i=0;i<NBIMGY;i++)
	{
		if (g_scrolly==HI*i) { yalign=TRUE;}
	}

	// test alignement horizontal ET vertical -> image plein cran
	if ( (xalign==TRUE)&&(yalign==TRUE) )	{situation=1;}

	// test alignement vertical ET non horizontal 
	// -> intersection de 2 images  l'cran sens horizontal
	if ( (xalign==FALSE)&&(yalign==TRUE) )	{situation=2;}

	// test alignement horizontal  ET NON vertical  
	// -> intersection de 2 images  l'cran sens vertical
	if ( (xalign==TRUE)&&(yalign==FALSE) )	{situation=3;}

	// test alignement NON horizontal  ET NON vertical  
	// -> intersection de 4 images  l'cran
	if ( (xalign==FALSE)&&(yalign==FALSE) )	{situation=4;}

	// calcul des zones sources pour la zone de restauration demande
	// et transfert des images vers l'cran
	switch(situation)
	{			
	case 1: // images  plein cran
		
		// balayage des crans et correction des coordonnes en x
		rc_src.left=0;
		rc_src.right=LI;
		
		rc_dest.left=0;
		rc_dest.right=LI;
		
		// balayage des crans et correction des coordonnes en y
		rc_src.top=0;
		rc_src.bottom=HI;
		
		rc_dest.top=0;
		rc_dest.bottom=HI;
		
		hr=lpDDSPrimary->Blt(&rc_dest,lpBackIndex[IMGX][IMGY],&rc_src,DDBLTFAST_WAIT,NULL);
		
		if (hr==DDERR_SURFACELOST)
		{
			RestoreSurfaces();
			hr=lpDDSPrimary->Blt(&rc_dest,lpBackIndex[IMGX][IMGY],&rc_src,DDBLTFAST_WAIT,NULL);
		}
		break;
		
	case 2:	// intersection de deux images sens horizontal
		
		// traitement des coordonnes verticales
		rc_src.top=0;
		rc_src.bottom=HI;
		rc_dest.top=0;
		rc_dest.bottom=HI;
		
		//traitement des coordonnes horizontales
		
		//  image de gauche			
		rc_src.left=LI-(((index_x+1)*LI)-g_scrollx);					
		rc_src.right=LI;
		
		rc_dest.left=0;			
		rc_dest.right=((index_x+1)*LI)-g_scrollx;				
		
		hr=lpDDSPrimary->Blt(&rc_dest,lpBackIndex[IMGX][IMGY],&rc_src,DDBLTFAST_WAIT,NULL);
		
		
		// image de droite
		rc_src.left=0;					
		rc_src.right=g_scrollx-((index_x)*LI);
		
		rc_dest.left=((index_x+1)*LI)-g_scrollx;			
		rc_dest.right=LI;
		
		hr=lpDDSPrimary->Blt(&rc_dest,lpBackIndex[IMGX+1][IMGY],&rc_src,DDBLTFAST_WAIT,NULL);
		break;

	case 3:	// intersection de deux images sens vertical
		
		// traitement des coordonnes horizontales
		rc_src.left=0;
		rc_src.right=LI;
		rc_dest.left=0;
		rc_dest.right=LI;
		
		//traitement des coordonnes verticales
		
		// image suprieure
		rc_src.top=HI-(((index_y+1)*HI)-g_scrolly);					
		rc_src.bottom=HI;
		
		rc_dest.top=0;			
		rc_dest.bottom=((index_y+1)*HI)-g_scrolly;
		
		hr=lpDDSPrimary->Blt(&rc_dest,lpBackIndex[IMGX][IMGY],&rc_src,DDBLTFAST_WAIT,NULL);
		
		// image infrieure
		rc_src.top=0;					
		rc_src.bottom=g_scrolly-(index_y*HI);
		
		rc_dest.top=((index_y+1)*HI)-g_scrolly;			
		rc_dest.bottom=HI;
		
		hr=lpDDSPrimary->Blt(&rc_dest,lpBackIndex[IMGX][IMGY+1],&rc_src,DDBLTFAST_WAIT,NULL);
		
		break;

  

	case 4:	// intersection de 4 images

		// image gauche suprieure
		rc_src.top=HI-(((index_y+1)*HI)-g_scrolly);					
		rc_src.bottom=HI;
	
		rc_dest.top=0;			
		rc_dest.bottom=((index_y+1)*HI)-g_scrolly;

		rc_src.left=LI-(((index_x+1)*LI)-g_scrollx);					
		rc_src.right=LI;
		
		rc_dest.left=0;			
		rc_dest.right=((index_x+1)*LI)-g_scrollx;				

		hr=lpDDSPrimary->Blt(&rc_dest,lpBackIndex[IMGX][IMGY],&rc_src,DDBLTFAST_WAIT,NULL);

		//image droite suprieure

		rc_src.top=HI-(((index_y+1)*HI)-g_scrolly);					
		rc_src.bottom=HI;
	
		rc_dest.top=0;			
		rc_dest.bottom=((index_y+1)*HI)-g_scrolly;

		rc_src.left=0;					
		rc_src.right=g_scrollx-((index_x)*LI);
		
		rc_dest.left=((index_x+1)*LI)-g_scrollx;			
		rc_dest.right=LI;

		hr=lpDDSPrimary->Blt(&rc_dest,lpBackIndex[IMGX+1][IMGY],&rc_src,DDBLTFAST_WAIT,NULL);

		//image infrieure gauche		

		rc_src.left=LI-(((index_x+1)*LI)-g_scrollx);					
		rc_src.right=LI;
		
		rc_dest.left=0;			
		rc_dest.right=((index_x+1)*LI)-g_scrollx;				

		rc_src.top=0;					
		rc_src.bottom=g_scrolly-(index_y*HI);
		
		rc_dest.top=((index_y+1)*HI)-g_scrolly;			
		rc_dest.bottom=HI;

		hr=lpDDSPrimary->Blt(&rc_dest,lpBackIndex[IMGX][IMGY+1],&rc_src,DDBLTFAST_WAIT,NULL);

		// image infrieure droite
		rc_src.top=0;					
		rc_src.bottom=g_scrolly-(index_y*HI);
		
		rc_dest.top=((index_y+1)*HI)-g_scrolly;			
		rc_dest.bottom=HI;

		rc_src.left=0;					
		rc_src.right=g_scrollx-((index_x)*LI);
		
		rc_dest.left=((index_x+1)*LI)-g_scrollx;			
		rc_dest.right=LI;

		hr=lpDDSPrimary->Blt(&rc_dest,lpBackIndex[IMGX+1][IMGY+1],&rc_src,DDBLTFAST_WAIT,NULL);
			
			break;

		default:
			break;

	} // fin de switch
	return;
}

Conclusion :


// j'ai adapte cette routine la restauration de n importe quel rect ecran, quelque soit la position du scroll, envoyez vos idees

A voir également

Ajouter un commentaire Commentaire
Messages postés
527
Date d'inscription
vendredi 14 septembre 2001
Statut
Membre
Dernière intervention
6 octobre 2008
3
ton source est intéréssant mais précise qu'il utilise DirectX le titre général

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.