MODE VESA HAUTE RESOLUTION [DJGPP]

// 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;
}