1. Accueil
  2. C / C++ / C++.NET
  3. Sources C / C++ / C++.NET
  4. Sources Graphique
  5. Mode vesa haute resolution [djgpp]

Mode vesa haute resolution [djgpp]

Soyez le premier à donner votre avis sur cette source.

Vue 7 447 fois - Téléchargée 247 fois

Télécharger le projet
Commenter

Description

Petit programme qui affiche un cube en rotation en 1024x768 pixels 256 couleurs.
Pour ceux qui comme moi en ont marre du mode VGA 13h et qui ne veulent pas utiliser de librairies graphiques.

Source / Exemple : 


// Dans les modes hautes resolutions VESA, la memoire video est sectionnee
// en plusieurs 'banques' ou 'plans' de 64 ko. Pour une resolution de 1024x768,
// il y a donc 12 banques, et il faut changer de banques selon la zone de
// l'ecran ou l'on veut afficher des pixels. C'est donc un peu plus lent et
// complique que pour le mode VGA 13h. Normalement, il y a moyen d'utiliser
// le Linear Frame Buffer (a partir de la version 2.0 de VESA) qui permet
// d'acceder a la memoire comme pour le mode VGA 13h, c'est donc beaucoup
// plus rapide et pratique, seulement je n'ai jamais reussi a activer le
// Linear Frame Buffer avec DJGPP...

#include			<assert.h>
#include			<conio.h>
#include			<dpmi.h>
#include			<go32.h>
#include			<pc.h>
#include			<stdio.h>
#include			<stdlib.h>
#include			<string.h>
#include			<sys/farptr.h>
#include			<sys/movedata.h>
#include			<time.h>

char*				buffer;

typedef struct
{
	double x;
	double y;
	double z;
} VERTEX;

//
//	POUR TRACER UNE LIGNE
//
void				line(VERTEX a,VERTEX b,unsigned char color)
{
	int			fx=(int)((a.x*256.0)/(a.z+300.0)+512.0);
	int			fy=(int)((a.y*256.0)/(a.z+300.0)+384.0);
	int			lx=(int)((b.x*256.0)/(b.z+300.0)+512.0);
	int			ly=(int)((b.y*256.0)/(b.z+300.0)+384.0);
	int			x1;
	int			y1;
	int			x2;
	int			y2;
	int			dx;
	int			dy;
	int			sub;
	int			remain;
	int			error;
	int			inc1;
	int			inc2;

	if (fx>lx)
	{
		x1=lx;
		x2=fx;
		y1=ly;
		y2=fy;
	}
	else
	{
		x1=fx;
		x2=lx;
		y1=fy;
		y2=ly;
	}
	dx=x2-x1;
	dy=y2-y1;
	if ((!dx)&&(!dy)) return;
	if (dy<0) 
	{
		dy=-dy;
		inc1=-1;
		inc2=1;
	}
	else 
	{
		inc1=1;
		inc2=1;
	}
	if (dx>dy)
	{	
		sub=dx-dy;
		error=dy-(dx>>1);
		remain=(dx+1)>>1;

		do
		{
			buffer[x1+(y1<<10)]=color;
			buffer[x2+(y2<<10)]=color;
			x1+=inc2;
			x2-=inc2;
			if (error>=0)
			{
				y1+=inc1;
				y2-=inc1;
				error-=sub;
			}
			else error+=dy;
		} while (--remain>0);
		if (!(dx&1)) buffer[x1+(y1<<10)]=color;
	}
	else
	{	
		sub=dy-dx;
		error=dx-(dy>>1);
		remain=(dy+1)>>1;

		do
		{
			buffer[x1+(y1<<10)]=color;
			buffer[x2+(y2<<10)]=color;
			y1+=inc1;
			y2-=inc1;
			if (error>=0)
			{
				x1+=inc2;
				x2-=inc2;
				error-=sub;
			}
			else error+=dx;
		} while (--remain>0);
		if (!(dy&1)) buffer[x1+(y1<<10)]=color;
	}
}

//
//	CORPS DU PROGRAMME
//
int				main()
{
	__dpmi_regs		regs;
	int			n;
	unsigned char		color=2;
	unsigned long		i;
	VERTEX			cube[8];
	VERTEX			v;

	/* --- INITIALISE LE MODE GRAPHIQUE --- */
	regs.x.ax=0x4F02;		// fonction 4F02h
	regs.x.bx=0x105;		// mode 105h - 1024x768 256 couleurs
	__dpmi_int(0x10,&regs);		// INT 10h
	buffer=(char*)malloc(1024*768);	// alloue de la memoire pour le buffer
	// apparemment, il n'est pas possible de creer normalement un tableau de
	// plus de 65536 elements (chez moi le programme plante quand j'essaie),
	// donc je cree un pointeur et j'alloue de la memoire 'manuellement'

	/* --- CREATION DE LA PALETTE --- */
	n=2;
	for (i=0 ; i<64 ; i++) {	outportb(0x03C8,n++);	outportb(0x03C9,63);	outportb(0x03C9,i);	outportb(0x03C9,0);	}
	for (i=1 ; i<64 ; i++) {	outportb(0x03C8,n++);	outportb(0x03C9,63-i);	outportb(0x03C9,63);	outportb(0x03C9,0);	}
	for (i=1 ; i<64 ; i++) {	outportb(0x03C8,n++);	outportb(0x03C9,0);	outportb(0x03C9,63-i);	outportb(0x03C9,i);	}
	for (i=1 ; i<63 ; i++) {	outportb(0x03C8,n++);	outportb(0x03C9,i);	outportb(0x03C9,0);	outportb(0x03C9,63-i);	}
	outportb(0x03C8,0);	outportb(0x03C9,63);	outportb(0x03C9,63);	outportb(0x03C9,63);
	outportb(0x03C8,1);	outportb(0x03C9,0);	outportb(0x03C9,0);	outportb(0x03C9,0);

	/* --- CREATION DU CUBE --- */
	cube[0].x=-100.0;	cube[0].y=-100.0;	cube[0].z=-100.0;
	cube[1].x= 100.0;	cube[1].y=-100.0;	cube[1].z=-100.0;
	cube[2].x= 100.0;	cube[2].y= 100.0;	cube[2].z=-100.0;
	cube[3].x=-100.0;	cube[3].y= 100.0;	cube[3].z=-100.0;
	cube[4].x=-100.0;	cube[4].y=-100.0;	cube[4].z= 100.0;
	cube[5].x= 100.0;	cube[5].y=-100.0;	cube[5].z= 100.0;
	cube[6].x= 100.0;	cube[6].y= 100.0;	cube[6].z= 100.0;
	cube[7].x=-100.0;	cube[7].y= 100.0;	cube[7].z= 100.0;

	/* --- PREPARE LA PARTIE DE L'ECRAN QUI NE SERA JAMAIS RAFRAICHIE --- */
	for (i=3*64*1024 ; i<9*64*1024 ; i++) buffer[i]=1;	// centre en noir
	gotoxy(32,5);	printf("Les parties en blanc ne doivent jamais etre actualisees, elles");
	gotoxy(32,6);	printf("ne sont donc affichees qu'une fois et jamais rafraichies afin");
	gotoxy(32,7);	printf("de gagner du temps de calcul et avoir une rotation plus rapide.");

	/* --- QUITTE QUAND UNE TOUCHE EST PRESSEE --- */
	while (!kbhit())
	{
		/* --- DESSINE LE CUBE --- */
		for (i=3*64*1024 ; i<9*64*1024 ; i++) buffer[i]=1;	// centre en noir
		line(cube[0],cube[1],color);
		line(cube[1],cube[2],color);
		line(cube[2],cube[3],color);
		line(cube[3],cube[0],color);
		line(cube[4],cube[5],color);
		line(cube[5],cube[6],color);
		line(cube[6],cube[7],color);
		line(cube[7],cube[4],color);
		line(cube[0],cube[4],color);
		line(cube[1],cube[5],color);
		line(cube[2],cube[6],color);
		line(cube[3],cube[7],color);
		color++;
		if (color==254) color=2;

		/* --- AFFICHAGE --- */
		while (!(inportw(0x03DA)&8));	// synchronise avec l'ecran
		while (inportw(0x03DA)&8);
		for (n=3 ; n<9 ; n++)		// banques 3 a 9 seulement, le reste de
		{				// l'ecran n'a pas besoin d'etre actualise
			regs.x.ax=0x4F05;	// fonction 4F05h
			regs.x.bx=0;		// fenetre A
			regs.x.dx=n;		// numero de la banque
			__dpmi_int(0x10,&regs);	// INT 10h
			dosmemput(buffer+(n<<16),65536L,0xA0000);	// affichage
		}

		/* --- ROTATION --- */
		for (i=0 ; i<8 ; i++)
		{
			v=cube[i];
			cube[i].y=v.y*0.9998476951-v.z*0.0174524064;
			cube[i].z=v.y*0.0174524064+v.z*0.9998476951;
			v=cube[i];
			cube[i].x=v.x*0.9998476951-v.z*0.0174524064;
			cube[i].z=v.z*0.9998476951+v.x*0.0174524064;
			v=cube[i];
			cube[i].x=v.x*0.9998476951+v.y*0.0174524064;
			cube[i].y=v.y*0.9998476951-v.x*0.0174524064;
			// 0.0174524064 = sinus de 1 degre
			// 0.9998476951 = cosinus de 1 degre
			// si vous ne comprenez pas revisez vos cours de trigonometrie
		}
	}
	free(buffer);		// on libere ma memoire
	regs.h.ah=0x00;		// fonction 00h
	regs.h.al=0x03;		// mode 03h - mode texte normal
	__dpmi_int(0x10,&regs);	// INT 10h

	return 0;
}
Télécharger le projet

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Signaler
Messages postés
1267
Date d'inscription
mercredi 1 janvier 2003
Statut
Membre
Dernière intervention
28 février 2007
 3
C'est une source qui ne compile que sous DJGPP et ces fichiers sont spécifiques à ce compilo.
Si t'es sous Visual C++ ou Dev-C++, n'espère même pas; ce sont des compilos pour Windows et la source est pour DOS (ce qui est différent, malgré ce qu'on pourrait penser ^^)
Signaler
Messages postés
1
Date d'inscription
mercredi 13 octobre 2004
Statut
Membre
Dernière intervention
15 octobre 2004
Je sais que je suis un newbie mais...

#include
#include <conio.h>
#include <dpmi.h>
#include <go32.h>
#include
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/farptr.h>
#include <sys/movedata.h>
#include <time.h>

Cela implique qu'il est nécessaire d'avoir ces fichiers (et la bonne version) pour la compilation. Mais quand on ne les a pas, comment fait-ton? Où les trouve-t-on?

Thx d'avance....
Signaler
Messages postés
158
Date d'inscription
samedi 31 janvier 2004
Statut
Membre
Dernière intervention
12 mars 2009
ça marche pas :

void main(void)
{
int tm;


clrscr();

tm=clock();
gotoxy(1,1);printf("a= %d",tm);

for(int i=0;i<100;i++) y++;
tm=clock()-tm;
tm=(tm*1000)/CLOCKS_PER_SEC;
gotoxy(1,2);printf("b= %d",tm);

getch();

}

ou alors ça marche pas ou bien aucun n'est passé pendant la boucle for et le gotoxy() + le printf.
Signaler
Messages postés
158
Date d'inscription
samedi 31 janvier 2004
Statut
Membre
Dernière intervention
12 mars 2009
Merci c'est cool pais je vais un peu prendre pn temps pour tester je suis un peu pris c'est temps si.
ça ne te derange pas si je tarde à te donner les resultat du test ?
Signaler
Messages postés
37
Date d'inscription
samedi 16 mars 2002
Statut
Membre
Dernière intervention
21 février 2015
OK si j'ai bien compris tu veux pas attendre mais compter les microsecondes. Alors c'est simple, en fait la fonction clock() renvoie le nombre de tics du processeur actuel (comme pour la fonction time() sauf que c'est des 'tics' et pas des secondes). et 'CLOCKS_PER_SEC' est le nombre de tics dans une seconde.
Autrement dit il te suffit de faire :

tmp=clock(); // mémorise le nombre de tics actuel

...
ici tu met ton code, ce que tu veux
...

tmp=clock()-tmp; // calcule le nombre de tics actuel moins le nombre de tics de la derniere fois, autrement dit 'tmp' va contenir le nombre de tics passé

tmp=(tmp*1000)/CLOCKS_PER_SEC; // et maintenant convertit le nombre de tics en microsecondes !

Voila, puis après tu fais ce que tu veux avec 'tmp' qui contient le nombre de microsecondes passées.
Afficher les 10 commentaires
S'inscrire maintenant

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.

Du même auteur (cs_gorgonzola)