Mode graphique vesa avec djgpp en c

Soyez le premier à donner votre avis sur cette source.

Vue 4 175 fois - Téléchargée 258 fois

Description

Présentation de ma bibliotheque graphique VESA en utilisant DJGPP :
Gère l'affichage graphique directe, un ou plusieurs tampons graphiques, couleur en hexadecimal (0xFFFFFF), Obtenir des infos sur les différents modes VESA...

Source / Exemple :


#ifndef INCLUDE_go32
#define INCLUDE_go32
#include <go32.h>
#endif

#ifndef INCLUDE_dpmi
#define INCLUDE_dpmi
#include <dpmi.h>
#endif

#ifndef INCLUDE_farptr
#define INCLUDE_farptr
#include <sys\farptr.h>
#endif

#ifndef INCLUDE_movedata
#define INCLUDE_movedata
#include <sys\movedata.h>
#endif

#ifndef INCLUDE_pc
#define INCLUDE_pc
#include <pc.h>
#endif

typedef struct t_vesa_info//table d'information sur VESA
{
  unsigned char  vesa_signature[4]            __attribute__ ((packed));
  unsigned char  version_secondaire           __attribute__ ((packed));
  unsigned char  version_principale           __attribute__ ((packed));
  unsigned long  ptr_nom_fabricant            __attribute__ ((packed));
  unsigned long  performance                  __attribute__ ((packed));
  unsigned long  ptr_modes_video              __attribute__ ((packed));
  unsigned short memoire_64k                  __attribute__ ((packed));
  char          reserve[484]                  __attribute__ ((packed));
} t_vesa_info;

typedef struct t_vesa_info_mode//table d'information sur le mode VESA en cours
{
  unsigned short attribut_du_mode             __attribute__ ((packed));
  unsigned char  attribut_fenetre_A           __attribute__ ((packed));
  unsigned char  attribut_fenetre_B           __attribute__ ((packed));
  unsigned short pas_fenetre                  __attribute__ ((packed));
  unsigned short taille_fenetre               __attribute__ ((packed));
  unsigned short segment_fenetre_A            __attribute__ ((packed));
  unsigned short segment_fenetre_B            __attribute__ ((packed));
  unsigned long  pointeur_proc_fenetre        __attribute__ ((packed));
  unsigned short octets_par_ligne             __attribute__ ((packed));
  unsigned short resolution_horizontale       __attribute__ ((packed));
  unsigned short resolution_verticale         __attribute__ ((packed));
  unsigned char  taille_caractere_horizontale __attribute__ ((packed));
  unsigned char  taille_caractere_verticale   __attribute__ ((packed));
  unsigned char  nombre_de_plans              __attribute__ ((packed));
  unsigned char  bits_par_points              __attribute__ ((packed));
  unsigned char  nombre_de_banques            __attribute__ ((packed));
  unsigned char  modele_memoire               __attribute__ ((packed));
  unsigned char  taille_des_banques           __attribute__ ((packed));
  unsigned char  nombre_de_pages              __attribute__ ((packed));
  unsigned char  reserve                      __attribute__ ((packed));
  unsigned char  masques_taille_rouge         __attribute__ ((packed));
  unsigned char  masques_pos_rouge            __attribute__ ((packed));
  unsigned char  masques_taille_vert          __attribute__ ((packed));
  unsigned char  masques_pos_vert             __attribute__ ((packed));
  unsigned char  masques_taille_bleu          __attribute__ ((packed));
  unsigned char  masques_pos_bleu             __attribute__ ((packed));
  unsigned char  masques_taille_res           __attribute__ ((packed));
  unsigned char  masques_pos_res              __attribute__ ((packed));
  unsigned char  info_couleur_directe         __attribute__ ((packed));
  unsigned long  adresse_lineaire             __attribute__ ((packed));
  unsigned long  offset                       __attribute__ ((packed));
  unsigned long  memoire_off                  __attribute__ ((packed));
  unsigned char  reserve_bis[206]             __attribute__ ((packed));
} t_vesa_info_mode;

unsigned long ptr_mode_en_cours;
long dos_buffer;
t_vesa_info_mode table_mode;
t_vesa_info table_vesa;
__dpmi_regs registres;

char vesa_info(t_vesa_info *table)//Remplir la table d'information VESA
{
	_farsetsel(_dos_ds);
	dos_buffer=__tb & 0xFFFFF;
	dosmemput("VESA",4,dos_buffer);
	registres.x.ax=0x4F00;
	registres.x.di=dos_buffer & 0xF;
	registres.x.es=dos_buffer >> 4;
	__dpmi_int(0x10,&registres);
	if (registres.x.ax=0x004F)
		dosmemget(dos_buffer,sizeof(t_vesa_info),table);
	ptr_mode_en_cours=((table->ptr_modes_video & 0xFFFF0000) >> 12)+(table->ptr_modes_video & 0xFFFF);

	return(registres.x.ax==0x004F);
}

char vesa_info_mode(t_vesa_info_mode *table, unsigned short mode)//Remplir la table d'information sur le mode en cours
{
	registres.x.ax=0x4F01;
	registres.x.cx=mode;
	registres.x.di=dos_buffer & 0xF;
	registres.x.es=dos_buffer >> 4;
	__dpmi_int(0x10,&registres);
	if (registres.x.ax=0x004F)
		dosmemget(dos_buffer,sizeof(t_vesa_info_mode),table);

	return(registres.x.ax==0x004F);
}

unsigned short vesa_first_mode(void)//Obtenir le premier mode VESA disponible
{
	return(_farnspeekw(ptr_mode_en_cours));
}

unsigned short vesa_next_mode(void)//Obtenir un autre mode disponible
{
	ptr_mode_en_cours+=2;
	return(_farnspeekw(ptr_mode_en_cours));
}

char vesa_mode(unsigned short mode)//Activer le mode VESA
{
	registres.x.ax=0x4F02;
	registres.x.bx=mode;
	__dpmi_int(0x10,&registres);

	return(registres.x.ax==0x004F);
}

unsigned int numero_de_fenetre, taille_fenetre_octets, octets_par_point, quelle_fenetre;
unsigned short numero_de_fenetre_actuelle, segment_fenetre, increment_fenetre;

void recherche_fenetre(unsigned short mode_en_cours)//Rechercher le "port" d'écriture
{
	quelle_fenetre=0;
	if ((table_mode.attribut_fenetre_A & 5)==5 )
		segment_fenetre=table_mode.segment_fenetre_A;
	else if ((table_mode.attribut_fenetre_B & 5)==5)
	{
		segment_fenetre=table_mode.segment_fenetre_B;
		quelle_fenetre=1;
	}
	else
	if ((table_mode.attribut_du_mode & 16) == 0)
	{
		segment_fenetre=0xB800;
		exit(1);
	}
	else
		segment_fenetre=0xA000;

	numero_de_fenetre_actuelle=0xFFFF;
	octets_par_point=(table_mode.bits_par_points+7) >> 3;
	increment_fenetre=table_mode.taille_fenetre / table_mode.pas_fenetre;
	taille_fenetre_octets=table_mode.taille_fenetre;
	taille_fenetre_octets=taille_fenetre_octets << 10;
	if(!(vesa_mode(mode_en_cours)))
	{
		printf("Le mode n'est pas support? !\n");
		getch();
		exit(1);
	}
}

void affiche_pixel(int x, int y,unsigned int couleur)//afficher un pixel directement sur l'écran
{	
	int i;
	unsigned int offset_point;
	offset_point=y*table_mode.octets_par_ligne+x*octets_par_point;
	for (i=0;i<octets_par_point;i++) 
	{
          
		numero_de_fenetre=(offset_point+i) / taille_fenetre_octets;
		if (numero_de_fenetre!=numero_de_fenetre_actuelle)
		{ 
			numero_de_fenetre_actuelle=numero_de_fenetre; 
			registres.x.ax=0x4F05; 
			registres.x.bx=quelle_fenetre;
			registres.x.dx=numero_de_fenetre*increment_fenetre;
			__dpmi_int(0x10,&registres);
		}
          	_farnspokeb((segment_fenetre << 4)+(offset_point+i) % taille_fenetre_octets,(couleur >> (i << 3)) &0xFF);
	}
}

void affiche_pix(unsigned char * buffer,int x, int y, unsigned long int couleur)//Mettre en memoire un pixel dans un tampon
{
	unsigned int offset_point;
	offset_point = y*table_mode.octets_par_ligne + x * octets_par_point;
	switch (octets_par_point)
	{
		case 2:
			buffer[offset_point+1] = (couleur >> 8)&0x0FF;
			buffer[offset_point] = (couleur & 0x0FF);
			break;
		case 3:
		case 4:
			buffer[offset_point+3] = (couleur >> 24) & 0x00FF;
			buffer[offset_point+2] = (couleur >> 16) & 0x00FF;
			buffer[offset_point+1] = (couleur >> 8) & 0x00FF;
			buffer[offset_point] = (couleur & 0x00FF);
			break;
	}	
}

void affiche_tampon(unsigned char * buffer)//Afficher un tampon memoire
{	
	int i;
	unsigned int offset_point;
	for(offset_point = 0; offset_point<table_mode.octets_par_ligne*table_mode.resolution_verticale; offset_point += octets_par_point)
	{
		for (i=0;i<octets_par_point;i++) 
		{
          
			numero_de_fenetre=(offset_point+i) / taille_fenetre_octets;
			if (numero_de_fenetre!=numero_de_fenetre_actuelle)
			{ 
				numero_de_fenetre_actuelle=numero_de_fenetre; 
				registres.x.ax=0x4F05; 
				registres.x.bx=quelle_fenetre;
				registres.x.dx=numero_de_fenetre*increment_fenetre;
				__dpmi_int(0x10,&registres);
			}
        		_farnspokeb((segment_fenetre << 4)+(offset_point+i) % taille_fenetre_octets, (buffer[offset_point+i]) &0xFF);
		}
	}
}

Conclusion :


Fonctionne avec les modes 15, 16, 24, 32 bits. Le 8 bits doit etre testé !

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
9
Date d'inscription
mardi 11 mars 2003
Statut
Membre
Dernière intervention
26 juin 2003

ceci est un test
Messages postés
249
Date d'inscription
mardi 16 juillet 2002
Statut
Membre
Dernière intervention
7 août 2003
1
Continues à rajouter des primitives de dessins et rajoutes des fonctions pour gérer les sprites.

Je te conseil de faire une structure ou une classe BITMAP car je n'en ai pas vu.

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.