m/grafX2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Fixed stricter compilation warnings, deleted unused asm code

Browse Source 
git-svn-id: svn://pulkomandy.tk/GrafX2/trunk@288 416bcca6-2ee7-4201-b75f-2eb2f807beb1
This commit is contained in:
Yves Rizoud 2008-10-18 19:23:35 +00:00
parent 20537fd58a
commit b488ec9272
19 changed files with 49 additions and 515 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile
View File

@ -24,7 +24,7 @@ ifdef COMSPEC
DELCOMMAND = del DELCOMMAND = del
BIN = grafx2.exe BIN = grafx2.exe
CFGBIN = gfxcfg.exe CFGBIN = gfxcfg.exe
COPT = -Wall -O -g -ggdb `sdl-config --cflags` COPT = -W -Wall -O -g -ggdb `sdl-config --cflags`
LOPT = `sdl-config --libs` LOPT = `sdl-config --libs`
CC = gcc CC = gcc
else else
@ -50,7 +50,7 @@ endif
OBJ = main.o init.o graph.o sdlscreen.o divers.o special.o boutons.o palette.o \ OBJ = main.o init.o graph.o sdlscreen.o divers.o special.o boutons.o palette.o \
aide.o operatio.o pages.o loadsave.o readline.o moteur.o files.o op_c.o \ aide.o operatio.o pages.o loadsave.o readline.o moteur.o files.o op_c.o \
linux.o op_asm.o readini.o saveini.o shade.o clavier.o io.o version.o linux.o readini.o saveini.o shade.o clavier.o io.o version.o
CFGOBJ = gfxcfg.o SFont.o clavier.o io.o CFGOBJ = gfxcfg.o SFont.o clavier.o io.o
OBJDIR = obj/ OBJDIR = obj/

3
Makefile.dep
View File

@ -30,9 +30,8 @@ moteur.o: moteur.c const.h struct.h global.h loadsave.h graph.h divers.h \
special.h boutons.h operatio.h shade.h erreurs.h linux.h sdlscreen.h special.h boutons.h operatio.h shade.h erreurs.h linux.h sdlscreen.h
files.o: files.c const.h struct.h global.h loadsave.h graph.h divers.h \ files.o: files.c const.h struct.h global.h loadsave.h graph.h divers.h \
erreurs.h linux.h erreurs.h linux.h
op_c.o: op_c.c op_c.h struct.h const.h op_asm.h erreurs.h op_c.o: op_c.c op_c.h struct.h const.h erreurs.h
linux.o: linux.c linux.o: linux.c
op_asm.o: op_asm.c op_c.h struct.h const.h graph.h
readini.o: readini.c const.h global.h struct.h loadsave.h graph.h readini.o: readini.c const.h global.h struct.h loadsave.h graph.h
saveini.o: saveini.c const.h global.h struct.h loadsave.h readini.h \ saveini.o: saveini.c const.h global.h struct.h loadsave.h readini.h \
files.h erreurs.h graph.h files.h erreurs.h graph.h

4
aide.c
View File

@ -67,7 +67,7 @@ void Afficher_aide(void)
short Largeur; // Largeur physique d'une ligne de texte short Largeur; // Largeur physique d'une ligne de texte
char TypeLigne; // N: Normale, T: Titre, S: Sous-titre char TypeLigne; // N: Normale, T: Titre, S: Sous-titre
// -: Ligne inférieur de sous-titre // -: Ligne inférieur de sous-titre
const unsigned char * Ligne; const char * Ligne;
Pos_Reel_X=Fenetre_Pos_X+(13*Menu_Facteur_X); Pos_Reel_X=Fenetre_Pos_X+(13*Menu_Facteur_X);
Pos_Reel_Y=Fenetre_Pos_Y+(19*Menu_Facteur_Y); Pos_Reel_Y=Fenetre_Pos_Y+(19*Menu_Facteur_Y);
@ -391,7 +391,7 @@ void Bouton_Stats(void)
// Affichage du nombre de couleur utilisé // Affichage du nombre de couleur utilisé
Print_dans_fenetre(18,91,"Colors used:",STATS_COULEUR_TITRES,CM_Noir); Print_dans_fenetre(18,91,"Colors used:",STATS_COULEUR_TITRES,CM_Noir);
bzero(Utilisation_couleur,256*sizeof(Utilisation_couleur[0])); memset(Utilisation_couleur,0,sizeof(Utilisation_couleur));
sprintf(Buffer,"%d",Palette_Compter_nb_couleurs_utilisees(Utilisation_couleur)); sprintf(Buffer,"%d",Palette_Compter_nb_couleurs_utilisees(Utilisation_couleur));
Print_dans_fenetre(122,91,Buffer,STATS_COULEUR_DONNEES,CM_Noir); Print_dans_fenetre(122,91,Buffer,STATS_COULEUR_DONNEES,CM_Noir);

2
boutons.c
View File

@ -331,7 +331,7 @@ void Bouton_Choix_backcolor(void)
//---------------------- Cacher ou réafficher le menu ------------------------ //---------------------- Cacher ou réafficher le menu ------------------------
void Pixel_dans_barre_d_outil_cachee(word X,word Y,byte Couleur) void Pixel_dans_barre_d_outil_cachee(__attribute__((unused)) word X,__attribute__((unused)) word Y,__attribute__((unused)) byte Couleur)
{ {
// C'est fait exprès que ce soit vide... // C'est fait exprès que ce soit vide...
// C'est parce que y'a rien du tout à afficher vu que la barre d'outil est // C'est parce que y'a rien du tout à afficher vu que la barre d'outil est

2
clavier.c
View File

@ -447,7 +447,7 @@ const char * Nom_touche(word Touche)
} }
// Touches au libellé connu // Touches au libellé connu
for (Indice=0; Indice < sizeof(Table_touches)/sizeof(S_Libelle_touche);Indice++) for (Indice=0; Indice < (long)sizeof(Table_touches)/(long)sizeof(S_Libelle_touche);Indice++)
{ {
if (Touche == Table_touches[Indice].Sym) if (Touche == Table_touches[Indice].Sym)
{ {

2
divers.c
View File

@ -135,7 +135,7 @@ void Effacer_image_courante(byte Couleur)
); );
} }
void Sensibilite_souris(word X,word Y) void Sensibilite_souris(__attribute__((unused)) word X,__attribute__((unused)) word Y)
{ {
puts("Sensibilite_souris non implémenté!"); puts("Sensibilite_souris non implémenté!");
} }

4
gfxcfg.c
View File

@ -239,7 +239,7 @@ char * Interpretation_du_fichier_config()
// Si la config contenait des touches, on les initialise: // Si la config contenait des touches, on les initialise:
if (Chunk[CHUNK_TOUCHES].Taille) if (Chunk[CHUNK_TOUCHES].Taille)
{ {
int Indice_config; unsigned int Indice_config;
Ptr = ChunkData[CHUNK_TOUCHES]; Ptr = ChunkData[CHUNK_TOUCHES];
for (Indice_config=0; Indice_config<Chunk[CHUNK_TOUCHES].Taille / sizeof(struct Config_Infos_touche) ; Indice_config++) for (Indice_config=0; Indice_config<Chunk[CHUNK_TOUCHES].Taille / sizeof(struct Config_Infos_touche) ; Indice_config++)
{ {
@ -646,7 +646,7 @@ void Enregistrer_config()
/*** Main program ***/ /*** Main program ***/
int main(int argc, char * argv[]) int main(__attribute__((unused)) int argc, __attribute__((unused)) char *argv[])
{ {
if (Verifier_ecriture_possible()) if (Verifier_ecriture_possible())

9
global.h
View File

@ -166,7 +166,6 @@ GLOBAL short Pinceau_Decalage_Y;
GLOBAL fonction_afficheur Pixel; // Affiche un point à l'écran GLOBAL fonction_afficheur Pixel; // Affiche un point à l'écran
GLOBAL fonction_afficheur Pixel_dans_menu;// Affiche un point dans le menu (ou pas si le menu est invisible) GLOBAL fonction_afficheur Pixel_dans_menu;// Affiche un point dans le menu (ou pas si le menu est invisible)
GLOBAL fonction_lecteur Lit_pixel; // Teste la couleur d'un pixel dans l'écran GLOBAL fonction_lecteur Lit_pixel; // Teste la couleur d'un pixel dans l'écran
GLOBAL fonction_effaceur Clear_screen; // Efface rapidement tout l'écran (en faisant attention de ne pas effacer le menu)
GLOBAL fonction_display Display_screen; // Affiche rapidement tout l'écran (en faisant attention de ne pas effacer le menu) GLOBAL fonction_display Display_screen; // Affiche rapidement tout l'écran (en faisant attention de ne pas effacer le menu)
GLOBAL fonction_block Block; // Affiche rapidement un bloc à l'écran GLOBAL fonction_block Block; // Affiche rapidement un bloc à l'écran
GLOBAL fonction_afficheur Pixel_Preview_Normal; // Affiche un point de l'image à l'écran en mode normal (pas en mode loupe) GLOBAL fonction_afficheur Pixel_Preview_Normal; // Affiche un point de l'image à l'écran en mode normal (pas en mode loupe)
@ -418,10 +417,10 @@ GLOBAL byte Stencil[256]; // Tableau des couleurs prot
// Mode grille: // Mode grille:
GLOBAL byte Snap_Mode; // Le mode grille est enclenché GLOBAL byte Snap_Mode; // Le mode grille est enclenché
GLOBAL short Snap_Largeur; // Largeur entre 2 points de la grille GLOBAL word Snap_Largeur; // Largeur entre 2 points de la grille
GLOBAL short Snap_Hauteur; // Hauteur entre 2 points de la grille GLOBAL word Snap_Hauteur; // Hauteur entre 2 points de la grille
GLOBAL short Snap_Decalage_X; // Position en X du point le + à gauche GLOBAL word Snap_Decalage_X; // Position en X du point le + à gauche
GLOBAL short Snap_Decalage_Y; // Position en Y du point le + en haut GLOBAL word Snap_Decalage_Y; // Position en Y du point le + en haut
// Mode trame: // Mode trame:

15
graph.c
View File

@ -1048,7 +1048,6 @@ void Initialiser_mode_video(int Largeur, int Hauteur, int Fullscreen)
case MODE_SDL: case MODE_SDL:
Pixel = Pixel_SDL; Pixel = Pixel_SDL;
Lit_pixel= Lit_Pixel_SDL; Lit_pixel= Lit_Pixel_SDL;
Clear_screen = Effacer_Tout_l_Ecran_SDL;
Display_screen = Afficher_partie_de_l_ecran_SDL; Display_screen = Afficher_partie_de_l_ecran_SDL;
Block = Block_SDL; Block = Block_SDL;
Pixel_Preview_Normal = Pixel_Preview_Normal_SDL; Pixel_Preview_Normal = Pixel_Preview_Normal_SDL;
@ -1632,14 +1631,14 @@ void Print_nom_fichier(void)
// -- Aucun effet en cours -- // -- Aucun effet en cours --
byte Aucun_effet(word X,word Y,byte Couleur) byte Aucun_effet(__attribute__((unused)) word X,__attribute__((unused)) word Y,byte Couleur)
{ {
return Couleur; return Couleur;
} }
// -- Effet de Shading -- // -- Effet de Shading --
byte Effet_Shade(word X,word Y,byte Couleur) byte Effet_Shade(word X,word Y,__attribute__((unused)) byte Couleur)
{ {
return Shade_Table[Lit_pixel_dans_ecran_feedback(X,Y)]; return Shade_Table[Lit_pixel_dans_ecran_feedback(X,Y)];
} }
@ -1693,7 +1692,7 @@ byte Effet_Quick_shade(word X,word Y,byte Couleur)
// -- Effet de Tiling -- // -- Effet de Tiling --
byte Effet_Tiling(word X,word Y,byte Couleur) byte Effet_Tiling(word X,word Y,__attribute__((unused)) byte Couleur)
{ {
return Lit_pixel_dans_brosse((X+Brosse_Largeur-Tiling_Decalage_X)%Brosse_Largeur, return Lit_pixel_dans_brosse((X+Brosse_Largeur-Tiling_Decalage_X)%Brosse_Largeur,
(Y+Brosse_Hauteur-Tiling_Decalage_Y)%Brosse_Hauteur); (Y+Brosse_Hauteur-Tiling_Decalage_Y)%Brosse_Hauteur);
@ -1701,7 +1700,7 @@ byte Effet_Tiling(word X,word Y,byte Couleur)
// -- Effet de Smooth -- // -- Effet de Smooth --
byte Effet_Smooth(word X,word Y,byte Couleur) byte Effet_Smooth(word X,word Y,__attribute__((unused)) byte Couleur)
{ {
int R,V,B; int R,V,B;
byte C; byte C;
@ -4145,7 +4144,7 @@ void Remplir(byte Couleur_de_remplissage)
fonction_afficheur Pixel_figure; fonction_afficheur Pixel_figure;
// Affichage d'un point de façon définitive (utilisation du pinceau) // Affichage d'un point de façon définitive (utilisation du pinceau)
void inline Pixel_figure_Definitif(word Pos_X,word Pos_Y,byte Couleur) inline void Pixel_figure_Definitif(word Pos_X,word Pos_Y,byte Couleur)
{ {
Afficher_pinceau(Pos_X,Pos_Y,Couleur,0); Afficher_pinceau(Pos_X,Pos_Y,Couleur,0);
} }
@ -4161,7 +4160,7 @@ void Remplir(byte Couleur_de_remplissage)
} }
// Affichage d'un point pour une preview en xor // Affichage d'un point pour une preview en xor
void Pixel_figure_Preview_xor(word Pos_X,word Pos_Y,byte Couleur) void Pixel_figure_Preview_xor(word Pos_X,word Pos_Y,__attribute__((unused)) byte Couleur)
{ {
if ( (Pos_X>=Limite_Gauche) && if ( (Pos_X>=Limite_Gauche) &&
(Pos_X<=Limite_Droite) && (Pos_X<=Limite_Droite) &&
@ -4172,7 +4171,7 @@ void Remplir(byte Couleur_de_remplissage)
} }
// Effacement d'un point de preview // Effacement d'un point de preview
void Pixel_figure_Effacer_preview(word Pos_X,word Pos_Y,byte Couleur) void Pixel_figure_Effacer_preview(word Pos_X,word Pos_Y,__attribute__((unused)) byte Couleur)
{ {
if ( (Pos_X>=Limite_Gauche) && if ( (Pos_X>=Limite_Gauche) &&
(Pos_X<=Limite_Droite) && (Pos_X<=Limite_Droite) &&

14
init.c
View File

@ -72,7 +72,7 @@ void Chercher_repertoire_du_programme(char * Chaine)
} }
// Ajouter un lecteur à la liste de lecteurs // Ajouter un lecteur à la liste de lecteurs
void Ajouter_lecteur(byte Numero, char Lettre, byte Type) void Ajouter_lecteur(char Lettre, byte Type)
{ {
Drive[Nb_drives].Lettre=Lettre; Drive[Nb_drives].Lettre=Lettre;
Drive[Nb_drives].Type =Type; Drive[Nb_drives].Type =Type;
@ -89,8 +89,8 @@ void Rechercher_drives(void)
//Sous linux, il n'y a pas de lecteurs, on va juste mettre //Sous linux, il n'y a pas de lecteurs, on va juste mettre
// un disque dur qui pointera vers la racine, // un disque dur qui pointera vers la racine,
// et un autre vers le home directory de l'utilisateur. // et un autre vers le home directory de l'utilisateur.
Ajouter_lecteur(0,'/', LECTEUR_HDD); Ajouter_lecteur('/', LECTEUR_HDD);
Ajouter_lecteur(1,'~', LECTEUR_HDD); Ajouter_lecteur('~', LECTEUR_HDD);
#else #else
int DriveBits = GetLogicalDrives(); int DriveBits = GetLogicalDrives();
int IndiceLecteur; int IndiceLecteur;
@ -125,7 +125,7 @@ void Rechercher_drives(void)
TypeLecteur=LECTEUR_NETWORK; TypeLecteur=LECTEUR_NETWORK;
break; break;
} }
Ajouter_lecteur(IndiceBit, 'A'+IndiceBit, TypeLecteur); Ajouter_lecteur('A'+IndiceBit, TypeLecteur);
IndiceLecteur++; IndiceLecteur++;
} }
} }
@ -1591,7 +1591,7 @@ int Charger_CFG(int Tout_charger)
if ((Handle=fopen(Nom_du_fichier,"rb"))==NULL) if ((Handle=fopen(Nom_du_fichier,"rb"))==NULL)
return ERREUR_CFG_ABSENT; return ERREUR_CFG_ABSENT;
if ( (Taille_fichier<sizeof(CFG_Header)) if ( (Taille_fichier<(long)sizeof(CFG_Header))
|| (!read_bytes(Handle, &CFG_Header.Signature, 3)) || (!read_bytes(Handle, &CFG_Header.Signature, 3))
|| memcmp(CFG_Header.Signature,"CFG",3) || memcmp(CFG_Header.Signature,"CFG",3)
|| (!read_byte(Handle, &CFG_Header.Version1)) || (!read_byte(Handle, &CFG_Header.Version1))
@ -1624,7 +1624,7 @@ int Charger_CFG(int Tout_charger)
case CHUNK_TOUCHES: // Touches case CHUNK_TOUCHES: // Touches
if (Tout_charger) if (Tout_charger)
{ {
for (Indice=0; Indice<(Chunk.Taille/sizeof(CFG_Infos_touche)); Indice++) for (Indice=0; Indice<(long)(Chunk.Taille/sizeof(CFG_Infos_touche)); Indice++)
{ {
if (!read_word_le(Handle, &CFG_Infos_touche.Numero) || if (!read_word_le(Handle, &CFG_Infos_touche.Numero) ||
!read_word_le(Handle, &CFG_Infos_touche.Touche) || !read_word_le(Handle, &CFG_Infos_touche.Touche) ||
@ -1666,7 +1666,7 @@ int Charger_CFG(int Tout_charger)
} }
break; break;
case CHUNK_MODES_VIDEO: // Modes vidéo case CHUNK_MODES_VIDEO: // Modes vidéo
for (Indice=0; Indice<(Chunk.Taille/sizeof(CFG_Mode_video)); Indice++) for (Indice=0; Indice<(long)(Chunk.Taille/sizeof(CFG_Mode_video)); Indice++)
{ {
if (!read_byte(Handle, &CFG_Mode_video.Etat) || if (!read_byte(Handle, &CFG_Mode_video.Etat) ||
!read_word_le(Handle, &CFG_Mode_video.Largeur) || !read_word_le(Handle, &CFG_Mode_video.Largeur) ||

44
loadsave.c
View File

@ -391,8 +391,7 @@ void Nom_fichier_complet(char * Nom_du_fichier, byte Sauve_Colorix)
void Lire_octet(FILE * Fichier, byte *Octet) void Lire_octet(FILE * Fichier, byte *Octet)
{ {
// FIXME : Remplacer les appelants par read_bytes(), et gérer les retours d'erreur. // FIXME : Remplacer les appelants par read_bytes(), et gérer les retours d'erreur.
if (!read_byte(Fichier, Octet)) read_byte(Fichier, Octet);
;// Erreur_fichier = 2;
} }
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@ -426,23 +425,8 @@ void Close_ecriture(FILE *Fichier)
} }
///////////////////////////////////////////////////////////////////////////// /////////////////////////////////////////////////////////////////////////////
void (/*__interrupt __near*/ *Ancien_handler_clavier)(void);
void /*__interrupt __near*/ Nouveau_handler_clavier(void)
{
/* A revoir ...
_disable();
if (!Erreur_fichier)
Erreur_fichier=-1;
_enable();
_chain_intr(Ancien_handler_clavier);
*/
;
}
// -------- Modifier la valeur du code d'erreur d'accès à un fichier -------- // -------- Modifier la valeur du code d'erreur d'accès à un fichier --------
// On n'est pas obligé d'utiliser cette fonction à chaque fois mais il est // On n'est pas obligé d'utiliser cette fonction à chaque fois mais il est
// important de l'utiliser dans les cas du type: // important de l'utiliser dans les cas du type:
@ -495,25 +479,11 @@ void Charger_image(byte Image)
// Si on a su déterminer avec succès le format du fichier: // Si on a su déterminer avec succès le format du fichier:
if (!Erreur_fichier) if (!Erreur_fichier)
{ {
// Installer le handler d'interruption du clavier pour stopper une preview
if (Pixel_de_chargement==Pixel_Chargement_dans_preview)
{
/* A revoir ...
Ancien_handler_clavier=_dos_getvect(9);
_dos_setvect(9,Nouveau_handler_clavier);
*/;
}
// On peut charger le fichier: // On peut charger le fichier:
Image_24b=0; Image_24b=0;
Format_Load[Format](); Format_Load[Format]();
// Désinstaller le handler d'interruption du clavier
if (Pixel_de_chargement==Pixel_Chargement_dans_preview)
/*A revoir ...
_dos_setvect(9,Ancien_handler_clavier);
*/;
if (Erreur_fichier>0) if (Erreur_fichier>0)
Erreur(0); Erreur(0);
@ -1658,7 +1628,7 @@ void Load_LBM(void)
read_dword_be(LBM_Fichier,&Nb_couleurs); read_dword_be(LBM_Fichier,&Nb_couleurs);
Nb_couleurs/=3; Nb_couleurs/=3;
if (((int)1<<Header.BitPlanes)!=Nb_couleurs) if (((dword)1<<Header.BitPlanes)!=Nb_couleurs)
{ {
if ((Nb_couleurs==32) && (Header.BitPlanes==6)) if ((Nb_couleurs==32) && (Header.BitPlanes==6))
{ // Ce n'est pas une image HAM mais une image 64 coul. { // Ce n'est pas une image HAM mais une image 64 coul.
@ -3422,7 +3392,7 @@ void Test_PCX(void)
// -- Lire un fichier au format PCX ----------------------------------------- // -- Lire un fichier au format PCX -----------------------------------------
// -- Afficher une ligne PCX codée sur 1 seul plan avec moins de 256 c. -- // -- Afficher une ligne PCX codée sur 1 seul plan avec moins de 256 c. --
void Draw_PCX_line(short Pos_Y, short Vraie_taille_ligne, byte Depth) void Draw_PCX_line(short Pos_Y, byte Depth)
{ {
short Pos_X; short Pos_X;
byte Couleur; byte Couleur;
@ -3646,7 +3616,7 @@ void Load_PCX(void)
if (PCX_Header.Depth==1) if (PCX_Header.Depth==1)
Draw_ILBM_line(Pos_Y,Vraie_taille_ligne); Draw_ILBM_line(Pos_Y,Vraie_taille_ligne);
else else
Draw_PCX_line(Pos_Y,Vraie_taille_ligne,PCX_Header.Depth); Draw_PCX_line(Pos_Y,PCX_Header.Depth);
} }
} }
@ -3666,7 +3636,7 @@ void Load_PCX(void)
if (PCX_Header.Depth==1) if (PCX_Header.Depth==1)
Draw_ILBM_line(Pos_Y,Vraie_taille_ligne); Draw_ILBM_line(Pos_Y,Vraie_taille_ligne);
else else
Draw_PCX_line(Pos_Y,Vraie_taille_ligne,PCX_Header.Depth); Draw_PCX_line(Pos_Y,PCX_Header.Depth);
} }
} }
else else
@ -3996,8 +3966,8 @@ void Load_CEL(void)
if (read_bytes(Fichier,&Header1,sizeof(T_CEL_Header1))) if (read_bytes(Fichier,&Header1,sizeof(T_CEL_Header1)))
{ {
Taille_du_fichier=Informations_Fichier.st_size; Taille_du_fichier=Informations_Fichier.st_size;
if ( (Taille_du_fichier>sizeof(T_CEL_Header1)) if ( (Taille_du_fichier>(long int)sizeof(T_CEL_Header1))
&& ( (((Header1.Width+1)>>1)*Header1.Height)==(Taille_du_fichier-sizeof(T_CEL_Header1)) ) ) && ( (((Header1.Width+1)>>1)*Header1.Height)==(Taille_du_fichier-(long int)sizeof(T_CEL_Header1)) ) )
{ {
// Chargement d'un fichier CEL sans signature (vieux fichiers) // Chargement d'un fichier CEL sans signature (vieux fichiers)
Principal_Largeur_image=Header1.Width; Principal_Largeur_image=Header1.Width;

279
op_asm.c
View File

@ -1,279 +0,0 @@
/* Grafx2 - The Ultimate 256-color bitmap paint program
Copyright 2007 Adrien Destugues
Copyright 1996-2001 Sunset Design (Guillaume Dorme & Karl Maritaud)
Grafx2 is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; version 2
of the License.
Grafx2 is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Grafx2; if not, see <http://www.gnu.org/licenses/> or
write to the Free Software Foundation, Inc.,
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
#include "op_c.h"
#include <stdio.h>
#include "graph.h"
/*************************************************************************************
* Diffusion d'erreur avec l'algorithme de Floyd-Steinberg pour conversion 24b > 256c
* Pour chaque pixel de la source :
* 1) On fait une recherche dans la palette pour trouver la couleurs plus proche
* 2) On calcule la différence avec la vraie couleur
* 3) On répartit cette différence entre les pixels autours avec les coefs:
* - 7/16 pour le pixel de droite
* - 3/16 pour le pixel en bas à gauche
* - 5/16 pour le pixel en dessous
* - 1/16 pour le pixel en bas à droite
* Cette différence est appliquée directement à la source, et sera prise en compte
* lors du traitement des pixels suivants (on ne touche pas aux pixels qui sont au
* dessus ou à gauche de celui en cours !)
************************************************************************************/
void OPASM_DitherFS_6123(
Bitmap256 Destination, // Pointeur sur le 1er pixel de la ligne
Bitmap24B Source, // Idem mais sur la source
int Largeur, // Largeur à traiter, =(largeur_image-2), (>0)
struct Composantes * Palette, // Palette de l'image destination
byte * TableC, // Table de conversion 24b->8b
byte ReducR, // 8-Nb_bits_rouges
byte ReducV, // 8-Nb_bits_verts
byte ReducB, // 8-Nb_bits_bleus
byte NbbV, // Nb_bits_verts
byte NbbB) // Nb_bits_bleus
{
byte DSFRouge,DSFVert,DSFBleu=0,DSFRougeAD,DSFVertAD,DSFBleuAD;
int VarA;
Bitmap24B PixelCourant, Cible;
// Pour chaque pixel sur la largeur
for(VarA=0;VarA<Largeur;VarA++)
{
PixelCourant = Source + VarA;
// On regarde la meilleure couleur d'après la table de conversion 24b>8b
DSFRougeAD = PixelCourant->R - ReducR;
DSFVertAD = PixelCourant->V - ReducV;
DSFBleuAD = PixelCourant->B - ReducB;
*Destination = *(TableC + DSFRougeAD*256*256 + DSFVertAD*256 + DSFBleu);
// On calcule l'erreur
DSFRouge = PixelCourant->R - Palette[*Destination].R;
DSFVert = PixelCourant->V - Palette[*Destination].V;
DSFBleu = PixelCourant->B - Palette[*Destination].B;
// On diffuse l'erreur sur le pixel de droite (6)
DSFRougeAD = (DSFRouge*7)/16;
DSFVertAD = (DSFVert*7)/16;
DSFBleuAD = (DSFBleu*7)/16;
// Diffusion de l'erreur dans la source
Cible = PixelCourant + 1; // "Pixel à droite"
Cible->R = Max(Cible->R + DSFRougeAD,255);
Cible->V = Max(Cible->V + DSFVertAD,255);
Cible->B = Max(Cible->B + DSFBleuAD,255);
// On diffuse sur le pixel en bas à gauche (1)
DSFRougeAD = (DSFRouge*3)/16;
DSFVertAD = (DSFVert*3)/16;
DSFBleuAD = (DSFBleu*3)/16;
Cible = PixelCourant + Largeur; // "Pixel en bas à gauche"
Cible->R = Max(Cible->R + DSFRougeAD,255);
Cible->V = Max(Cible->V + DSFVertAD,255);
Cible->B = Max(Cible->B + DSFBleuAD,255);
// On diffuse sur le pixel en dessous (2)
DSFRougeAD = (DSFRouge*5)/16;
DSFVertAD = (DSFVert*5)/16;
DSFBleuAD = (DSFBleu*5)/16;
Cible ++; // "Pixel en dessous"
Cible->R = Max(Cible->R + DSFRougeAD,255);
Cible->V = Max(Cible->V + DSFVertAD,255);
Cible->B = Max(Cible->B + DSFBleuAD,255);
// On diffuse sur le pixel en dessous (2)
DSFRougeAD = (DSFRouge*1)/16;
DSFVertAD = (DSFVert*1)/16;
DSFBleuAD = (DSFBleu*1)/16;
Cible ++; // "Pixel en bas à droite"
Cible->R = Max(Cible->R + DSFRougeAD,255);
Cible->V = Max(Cible->V + DSFVertAD,255);
Cible->B = Max(Cible->B + DSFBleuAD,255);
Destination++;
}
}
/* Les fonctions ci-dessous servent pour les pixels des bords et des coins, car on ne peut pas les traiter normalement
* (segfault ou dithering sur l'autre bout de l'image) */
void OPASM_DitherFS_623(
Bitmap256 Destination, // Pointeur sur le 1er pixel de la ligne
Bitmap24B Source, // Idem mais sur la source
int Largeur, // Largeur à traiter, =(largeur_image-2), (>0)
struct Composantes * Palette, // Palette de l'image destination
byte * TableC, // Table de conversion 24b->8b
byte ReducR, // 8-Nb_bits_rouges
byte ReducV, // 8-Nb_bits_verts
byte ReducB, // 8-Nb_bits_bleus
byte NbbV, // Nb_bits_verts
byte NbbB) // Nb_bits_bleus
{
puts("OPASM_DitherFS_623 non implémenté!");
}
void OPASM_DitherFS_12(
Bitmap256 Destination, // Pointeur sur le 1er pixel de la ligne
Bitmap24B Source, // Idem mais sur la source
int Largeur, // Largeur à traiter, =(largeur_image-2), (>0)
struct Composantes * Palette, // Palette de l'image destination
byte * TableC, // Table de conversion 24b->8b
byte ReducR, // 8-Nb_bits_rouges
byte ReducV, // 8-Nb_bits_verts
byte ReducB, // 8-Nb_bits_bleus
byte NbbV, // Nb_bits_verts
byte NbbB) // Nb_bits_bleus
{
puts("OPASM_DitherFS_12 non implémenté!");
}
void OPASM_DitherFS_6(
Bitmap256 Destination, // Pointeur sur le 1er pixel de la ligne
Bitmap24B Source, // Idem mais sur la source
int Largeur, // Largeur à traiter, =(largeur_image-1), (>0)
struct Composantes * Palette, // Palette de l'image destination
byte * TableC, // Table de conversion 24b->8b
byte ReducR, // 8-Nb_bits_rouges
byte ReducV, // 8-Nb_bits_verts
byte ReducB, // 8-Nb_bits_bleus
byte NbbV, // Nb_bits_verts
byte NbbB) // Nb_bits_bleus
{
puts("OPASM_DitherFS_6 non implémenté!");
}
void OPASM_DitherFS(
Bitmap256 Destination, // Pointeur sur le pixel
Bitmap24B Source, // Idem mais sur la source
byte * TableC, // Table de conversion 24b->8b
byte ReducR, // 8-Nb_bits_rouges
byte ReducV, // 8-Nb_bits_verts
byte ReducB, // 8-Nb_bits_bleus
byte NbbV, // Nb_bits_verts
byte NbbB) // Nb_bits_bleus
{
puts("OPASM_DitherFS non implémenté!");
}
void OPASM_DitherFS_2(
Bitmap256 Destination, // Pointeur sur le 1er pixel de la colonne
Bitmap24B Source, // Idem mais sur la source
int Hauteur, // Hauteur à traiter, =(hauteur_image-1), (>0)
struct Composantes * Palette, // Palette de l'image destination
byte * TableC, // Table de conversion 24b->8b
byte ReducR, // 8-Nb_bits_rouges
byte ReducV, // 8-Nb_bits_verts
byte ReducB, // 8-Nb_bits_bleus
byte NbbV, // Nb_bits_verts
byte NbbB) // Nb_bits_bleus
{
puts("OPASM_DitherFS_2 non implémenté!");
}
void OPASM_Split_cluster_Rouge(
int * tableO, // Table d'occurences
int rmin, // rmin << rdec
int vmin, // vmin << vdec
int bmin, // bmin << bdec
int rmax, // rmax << rdec
int vmax, // vmin << vdec
int bmax, // bmin << bdec
int rinc, // Incrémentation sur les rouges 1 << rdec
int vinc, // Incrémentation sur les verts 1 << vdec
int binc, // Incrémentation sur les bleus 1 << bdec
int limite, // Nombre d'occurences minimales
int rdec, // rdec
int * rouge) // Valeur du rouge atteignant la limite
{
puts("OPASM_Split_cluster_Rouge non implémenté!");
}
void OPASM_Split_cluster_Vert(
int * tableO, // Table d'occurences
int rmin, // rmin << rdec
int vmin, // vmin << vdec
int bmin, // bmin << bdec
int rmax, // rmax << rdec
int vmax, // vmin << vdec
int bmax, // bmin << bdec
int rinc, // Incrémentation sur les rouges 1 << rdec
int vinc, // Incrémentation sur les verts 1 << vdec
int binc, // Incrémentation sur les bleus 1 << bdec
int limite, // Nombre d'occurences minimales
int vdec, // vdec
int * vert) // Valeur du vert atteignant la limite
{
puts("OPASM_Split_cluster_Vert non implémenté!");
}
void OPASM_Split_cluster_Bleu(
int * tableO, // Table d'occurences
int rmin, // rmin << rdec
int vmin, // vmin << vdec
int bmin, // bmin << bdec
int rmax, // rmax << rdec
int vmax, // vmin << vdec
int bmax, // bmin << bdec
int rinc, // Incrémentation sur les rouges 1 << rdec
int vinc, // Incrémentation sur les verts 1 << vdec
int binc, // Incrémentation sur les bleus 1 << bdec
int limite, // Nombre d'occurences minimales
int bdec, // bdec
int * bleu) // Valeur du bleu atteignant la limite
{
puts("OPASM_Split_cluster_Bleu non implémenté!");
}
void OPASM_Compter_occurences(
int * Destination, // Pointeur sur la table d'occurences
Bitmap24B Source, // Pointeur sur l'image
int Taille, // Nombre de pixels dans l'image
byte ReducR, // 8-Nb_bits_rouges
byte ReducV, // 8-Nb_bits_verts
byte ReducB, // 8-Nb_bits_bleus
byte NbbV, // Nb_bits_verts
byte NbbB) // Nb_bits_bleus
{
puts("OPASM_Compter_occurences non implémenté!");
}
void OPASM_Analyser_cluster(
int * TableO, // Table d'occurences
int * rmin, // rmin << rdec
int * vmin, // vmin << vdec
int * bmin, // bmin << bdec
int * rmax, // rmax << rdec
int * vmax, // vmax << vdec
int * bmax, // bmax << bdec
int rdec, // rdec
int vdec, // vdec
int bdec, // bdec
int rinc, // Incrémentation sur les rouges 1 << rdec
int vinc, // Incrémentation sur les verts 1 << vdec
int binc, // Incrémentation sur les bleus 1 << bdec
int * Nbocc) // Nombre d'occurences
{
puts("OPASM_Analyser_cluster non implémenté!");
}

147
op_asm.h
View File

@ -1,147 +0,0 @@
#ifndef _OP_ASM_H_
#define _OP_ASM_H_
void OPASM_DitherFS_6123(
Bitmap256 Destination, // Pointeur sur le 1er pixel de la ligne
Bitmap24B Source, // Idem mais sur la source
int Largeur, // Largeur à traiter, =(largeur_image-2), (>0)
struct Composantes * Palette, // Palette de l'image destination
byte * TableC, // Table de conversion 24b->8b
byte ReducR, // 8-Nb_bits_rouges
byte ReducV, // 8-Nb_bits_verts
byte ReducB, // 8-Nb_bits_bleus
byte NbbV, // Nb_bits_verts
byte NbbB); // Nb_bits_bleus
void OPASM_DitherFS_623(
Bitmap256 Destination, // Pointeur sur le 1er pixel de la ligne
Bitmap24B Source, // Idem mais sur la source
int Largeur, // Largeur à traiter, =(largeur_image-2), (>0)
struct Composantes * Palette, // Palette de l'image destination
byte * TableC, // Table de conversion 24b->8b
byte ReducR, // 8-Nb_bits_rouges
byte ReducV, // 8-Nb_bits_verts
byte ReducB, // 8-Nb_bits_bleus
byte NbbV, // Nb_bits_verts
byte NbbB); // Nb_bits_bleus
void OPASM_DitherFS_12(
Bitmap256 Destination, // Pointeur sur le 1er pixel de la ligne
Bitmap24B Source, // Idem mais sur la source
int Largeur, // Largeur à traiter, =(largeur_image-2), (>0)
struct Composantes * Palette, // Palette de l'image destination
byte * TableC, // Table de conversion 24b->8b
byte ReducR, // 8-Nb_bits_rouges
byte ReducV, // 8-Nb_bits_verts
byte ReducB, // 8-Nb_bits_bleus
byte NbbV, // Nb_bits_verts
byte NbbB); // Nb_bits_bleus
void OPASM_DitherFS_6(
Bitmap256 Destination, // Pointeur sur le 1er pixel de la ligne
Bitmap24B Source, // Idem mais sur la source
int Largeur, // Largeur à traiter, =(largeur_image-1), (>0)
struct Composantes * Palette, // Palette de l'image destination
byte * TableC, // Table de conversion 24b->8b
byte ReducR, // 8-Nb_bits_rouges
byte ReducV, // 8-Nb_bits_verts
byte ReducB, // 8-Nb_bits_bleus
byte NbbV, // Nb_bits_verts
byte NbbB); // Nb_bits_bleus
void OPASM_DitherFS(
Bitmap256 Destination, // Pointeur sur le pixel
Bitmap24B Source, // Idem mais sur la source
byte * TableC, // Table de conversion 24b->8b
byte ReducR, // 8-Nb_bits_rouges
byte ReducV, // 8-Nb_bits_verts
byte ReducB, // 8-Nb_bits_bleus
byte NbbV, // Nb_bits_verts
byte NbbB); // Nb_bits_bleus
void OPASM_DitherFS_2(
Bitmap256 Destination, // Pointeur sur le 1er pixel de la colonne
Bitmap24B Source, // Idem mais sur la source
int Hauteur, // Hauteur à traiter, =(hauteur_image-1), (>0)
struct Composantes * Palette, // Palette de l'image destination
byte * TableC, // Table de conversion 24b->8b
byte ReducR, // 8-Nb_bits_rouges
byte ReducV, // 8-Nb_bits_verts
byte ReducB, // 8-Nb_bits_bleus
byte NbbV, // Nb_bits_verts
byte NbbB); // Nb_bits_bleus
void OPASM_Compter_occurences(
int * Destination, // Pointeur sur la table d'occurences
Bitmap24B Source, // Pointeur sur l'image
int Taille, // Nombre de pixels dans l'image
byte ReducR, // 8-Nb_bits_rouges
byte ReducV, // 8-Nb_bits_verts
byte ReducB, // 8-Nb_bits_bleus
byte NbbV, // Nb_bits_verts
byte NbbB); // Nb_bits_bleus
void OPASM_Analyser_cluster(
int * TableO, // Table d'occurences
int * rmin, // rmin << rdec
int * vmin, // vmin << vdec
int * bmin, // bmin << bdec
int * rmax, // rmax << rdec
int * vmax, // vmax << vdec
int * bmax, // bmax << bdec
int rdec, // rdec
int vdec, // vdec
int bdec, // bdec
int rinc, // Incrémentation sur les rouges 1 << rdec
int vinc, // Incrémentation sur les verts 1 << vdec
int binc, // Incrémentation sur les bleus 1 << bdec
int * Nbocc); // Nombre d'occurences
void OPASM_Split_cluster_Rouge(
int * tableO, // Table d'occurences
int rmin, // rmin << rdec
int vmin, // vmin << vdec
int bmin, // bmin << bdec
int rmax, // rmax << rdec
int vmax, // vmin << vdec
int bmax, // bmin << bdec
int rinc, // Incrémentation sur les rouges 1 << rdec
int vinc, // Incrémentation sur les verts 1 << vdec
int binc, // Incrémentation sur les bleus 1 << bdec
int limite, // Nombre d'occurences minimales
int rdec, // rdec
int * rouge); // Valeur du rouge atteignant la limite
void OPASM_Split_cluster_Vert(
int * tableO, // Table d'occurences
int rmin, // rmin << rdec
int vmin, // vmin << vdec
int bmin, // bmin << bdec
int rmax, // rmax << rdec
int vmax, // vmin << vdec
int bmax, // bmin << bdec
int rinc, // Incrémentation sur les rouges 1 << rdec
int vinc, // Incrémentation sur les verts 1 << vdec
int binc, // Incrémentation sur les bleus 1 << bdec
int limite, // Nombre d'occurences minimales
int vdec, // vdec
int * vert); // Valeur du vert atteignant la limite
void OPASM_Split_cluster_Bleu(
int * tableO, // Table d'occurences
int rmin, // rmin << rdec
int vmin, // vmin << vdec
int bmin, // bmin << bdec
int rmax, // rmax << rdec
int vmax, // vmin << vdec
int bmax, // bmin << bdec
int rinc, // Incrémentation sur les rouges 1 << rdec
int vinc, // Incrémentation sur les verts 1 << vdec
int binc, // Incrémentation sur les bleus 1 << bdec
int limite, // Nombre d'occurences minimales
int bdec, // bdec
int * bleu); // Valeur du bleu atteignant la limite
#endif

5
op_c.c
View File

@ -25,7 +25,6 @@
#include <fcntl.h> #include <fcntl.h>
#include <sys/stat.h> #include <sys/stat.h>
#include "op_c.h" #include "op_c.h"
#include "op_asm.h"
#include "erreurs.h" #include "erreurs.h"
#undef OPTIMISATIONS_ASSEMBLEUR #undef OPTIMISATIONS_ASSEMBLEUR
@ -790,7 +789,7 @@ void CS_Trier_par_luminance(ClusterSet * cs)
cs->clusters=nc; cs->clusters=nc;
} }
void CS_Generer_TC_et_Palette(ClusterSet * cs,Table_occurence * to,Table_conversion * tc,struct Composantes * palette) void CS_Generer_TC_et_Palette(ClusterSet * cs,Table_conversion * tc,struct Composantes * palette)
{ {
int indice; int indice;
int r,v,b; int r,v,b;
@ -957,7 +956,7 @@ Table_conversion * Optimiser_palette(Bitmap24B image,int taille,struct Composant
CS_Trier_par_chrominance(cs); CS_Trier_par_chrominance(cs);
// Enfin on génère la palette et la table de correspondance entre chaque couleur 24b et sa couleur palette associée. // Enfin on génère la palette et la table de correspondance entre chaque couleur 24b et sa couleur palette associée.
CS_Generer_TC_et_Palette(cs,to,tc,palette); CS_Generer_TC_et_Palette(cs,tc,palette);
CS_Delete(cs); CS_Delete(cs);
TO_Delete(to); TO_Delete(to);

2
op_c.h
View File

@ -184,7 +184,7 @@ void CS_Get(ClusterSet * cs,Cluster * c);
void CS_Set(ClusterSet * cs,Cluster * c); void CS_Set(ClusterSet * cs,Cluster * c);
void CS_Generer(ClusterSet * cs,Table_occurence * to); void CS_Generer(ClusterSet * cs,Table_occurence * to);
void CS_Calculer_teintes(ClusterSet * cs,Table_occurence * to); void CS_Calculer_teintes(ClusterSet * cs,Table_occurence * to);
void CS_Generer_TC_et_Palette(ClusterSet * cs,Table_occurence * to,Table_conversion * tc,struct Composantes * palette); void CS_Generer_TC_et_Palette(ClusterSet * cs,Table_conversion * tc,struct Composantes * palette);

8
pages.c
View File

@ -511,7 +511,7 @@ void Creer_nouvelle_page(S_Page * Nouvelle_page,S_Liste_de_pages * Liste_courant
( (Liste_courante->Taille_liste==Liste_courante->Nb_pages_allouees) ( (Liste_courante->Taille_liste==Liste_courante->Nb_pages_allouees)
// ou qu'il ne reste plus assez de place pour allouer la Nouvelle_page // ou qu'il ne reste plus assez de place pour allouer la Nouvelle_page
|| ( (Memoire_libre()-QUANTITE_MINIMALE_DE_MEMOIRE_A_CONSERVER)< || ( (Memoire_libre()-QUANTITE_MINIMALE_DE_MEMOIRE_A_CONSERVER)<
(Nouvelle_page->Hauteur*Nouvelle_page->Largeur) ) ); (unsigned long)(Nouvelle_page->Hauteur*Nouvelle_page->Largeur) ) );
if (!Il_faut_liberer) if (!Il_faut_liberer)
{ {
@ -578,7 +578,7 @@ void Creer_nouvelle_page(S_Page * Nouvelle_page,S_Liste_de_pages * Liste_courant
// On regarde s'il faut continuer à libérer de la place // On regarde s'il faut continuer à libérer de la place
Il_faut_liberer=(Memoire_libre()-QUANTITE_MINIMALE_DE_MEMOIRE_A_CONSERVER) Il_faut_liberer=(Memoire_libre()-QUANTITE_MINIMALE_DE_MEMOIRE_A_CONSERVER)
<(Nouvelle_page->Hauteur*Nouvelle_page->Largeur); <(unsigned long)(Nouvelle_page->Hauteur*Nouvelle_page->Largeur);
// S'il ne faut pas, c'est qu'on peut allouer un bitmap // S'il ne faut pas, c'est qu'on peut allouer un bitmap
// pour la Nouvelle_page // pour la Nouvelle_page
@ -990,7 +990,7 @@ void * Emprunter_memoire_de_page(int taille)
{ {
// On regarde s'il faut libérer des pages: // On regarde s'il faut libérer des pages:
Il_faut_liberer= Il_faut_liberer=
(Memoire_libre()-QUANTITE_MINIMALE_DE_MEMOIRE_A_CONSERVER)<taille; (Memoire_libre()-QUANTITE_MINIMALE_DE_MEMOIRE_A_CONSERVER)<(unsigned long)taille;
if (!Il_faut_liberer) if (!Il_faut_liberer)
{ {
@ -1039,7 +1039,7 @@ void * Emprunter_memoire_de_page(int taille)
// On regarde s'il faut continuer à libérer de la place // On regarde s'il faut continuer à libérer de la place
Il_faut_liberer= Il_faut_liberer=
(Memoire_libre()-QUANTITE_MINIMALE_DE_MEMOIRE_A_CONSERVER)<taille; (Memoire_libre()-QUANTITE_MINIMALE_DE_MEMOIRE_A_CONSERVER)<(unsigned long)taille;
// S'il ne faut pas, c'est qu'on peut allouer un bitmap // S'il ne faut pas, c'est qu'on peut allouer un bitmap
// pour la Nouvelle_page // pour la Nouvelle_page

2
readline.c
View File

@ -85,7 +85,7 @@ int CaractereValide(int Caractere)
return 0; return 0;
int Position; int Position;
for (Position=0; Position<sizeof(CaracteresInterdits); Position++) for (Position=0; Position<(long)sizeof(CaracteresInterdits); Position++)
if (Caractere == CaracteresInterdits[Position]) if (Caractere == CaracteresInterdits[Position])
return 0; return 0;
return 1; return 1;

7
sdlscreen.c
View File

@ -57,11 +57,6 @@ byte Lit_Pixel_SDL (word X,word Y)
return *( Ecran + Y * Largeur_ecran + X ); return *( Ecran + Y * Largeur_ecran + X );
} }
void Effacer_Tout_l_Ecran_SDL (byte Couleur)
{
UNIMPLEMENTED
}
void Afficher_partie_de_l_ecran_SDL (word Largeur,word Hauteur,word Largeur_image) void Afficher_partie_de_l_ecran_SDL (word Largeur,word Hauteur,word Largeur_image)
/* Afficher une partie de l'image telle quelle sur l'écran */ /* Afficher une partie de l'image telle quelle sur l'écran */
{ {
@ -429,7 +424,7 @@ void Display_brush_Mono_zoom_SDL (word Pos_X, word Pos_Y,
} }
} }
void Clear_brush_zoom_SDL (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,byte Couleur_de_transparence,word Largeur_image,byte * Buffer) void Clear_brush_zoom_SDL (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Pos_Y_Fin,__attribute__((unused)) byte Couleur_de_transparence,word Largeur_image,byte * Buffer)
{ {
// En fait on va recopier l'image non zoomée dans la partie zoomée ! // En fait on va recopier l'image non zoomée dans la partie zoomée !
byte* ESI = Principal_Ecran + Decalage_Y * Largeur_image + Decalage_X; byte* ESI = Principal_Ecran + Decalage_Y * Largeur_image + Decalage_X;

1
sdlscreen.h
View File

@ -27,7 +27,6 @@
void Pixel_SDL (word X,word Y,byte Couleur); void Pixel_SDL (word X,word Y,byte Couleur);
byte Lit_Pixel_SDL (word X,word Y); byte Lit_Pixel_SDL (word X,word Y);
void Effacer_Tout_l_Ecran_SDL (byte Couleur);
void Block_SDL (word Debut_X,word Debut_Y,word Largeur,word Hauteur,byte Couleur); void Block_SDL (word Debut_X,word Debut_Y,word Largeur,word Hauteur,byte Couleur);
void Block_SDL_Fast (word Debut_X,word Debut_Y,word Largeur,word Hauteur,byte Couleur); void Block_SDL_Fast (word Debut_X,word Debut_Y,word Largeur,word Hauteur,byte Couleur);
void Pixel_Preview_Normal_SDL (word X,word Y,byte Couleur); void Pixel_Preview_Normal_SDL (word X,word Y,byte Couleur);