92c4340dbd
-Easily change the number of video modes in the list (i'd like to use my 1440x900 screen at full resoluution !) -Maybe add a resizeable window mode, but that would require more work, so i'd like to keep that for 2.0 . In the meantime, i've made the list symetric, ie, mode are loaded from the cfg file and when the list is processed, each mode is copied to a fullscreen equivalent. Note this way of doing things will prevent the config file to save the selected video mode properly, so the program will switch to the default 800x600 windowed. When you load an image, Grafx2 will switch back to windowed mode when selecting the appropriate resolution for that image. The NB_MODES_VIDEO constant is also only the HALF of the actually available video modes git-svn-id: svn://pulkomandy.tk/GrafX2/trunk@183 416bcca6-2ee7-4201-b75f-2eb2f807beb1
449 lines
14 KiB
C
449 lines
14 KiB
C
#include <string.h>
|
|
#include <SDL/SDL.h>
|
|
#include "global.h"
|
|
#include "sdlscreen.h"
|
|
#include "divers.h"
|
|
#include "erreurs.h"
|
|
|
|
void Pixel_SDL (word X,word Y,byte Couleur)
|
|
/* Affiche un pixel de la Couleur aux coords X;Y à l'écran */
|
|
{
|
|
*(Ecran + X + Y * Largeur_ecran)=Couleur;
|
|
}
|
|
|
|
byte Lit_Pixel_SDL (word X,word Y)
|
|
/* On retourne la couleur du pixel aux coords données */
|
|
{
|
|
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)
|
|
/* Afficher une partie de l'image telle quelle sur l'écran */
|
|
{
|
|
byte* Dest=Ecran; //On va se mettre en 0,0 dans l'écran (EDI)
|
|
byte* Src=Principal_Decalage_Y*Largeur_image+Principal_Decalage_X+Principal_Ecran; //Coords de départ ds la source (ESI)
|
|
int dx;
|
|
|
|
for(dx=Hauteur;dx!=0;dx--)
|
|
// Pour chaque ligne
|
|
{
|
|
// On fait une copie de la ligne
|
|
memcpy(Dest,Src,Largeur);
|
|
|
|
// On passe à la ligne suivante
|
|
Src+=Largeur_image;
|
|
Dest+=Largeur_ecran;
|
|
}
|
|
SDL_UpdateRect(Ecran_SDL,0,0,Largeur,Hauteur);
|
|
}
|
|
|
|
void Block_SDL (word Debut_X,word Debut_Y,word Largeur,word Hauteur,byte Couleur)
|
|
/* On affiche un rectangle de la couleur donnée */
|
|
{
|
|
SDL_Rect rectangle;
|
|
rectangle.x=Debut_X;
|
|
rectangle.y=Debut_Y;
|
|
rectangle.w=Largeur;
|
|
rectangle.h=Hauteur;
|
|
SDL_FillRect(Ecran_SDL,&rectangle,Couleur);
|
|
SDL_UpdateRect(Ecran_SDL,Debut_X,Debut_Y,Largeur,Hauteur);
|
|
}
|
|
|
|
void Block_SDL_Fast (word Debut_X,word Debut_Y,word Largeur,word Hauteur,byte Couleur)
|
|
/* On affiche un rectangle de la couleur donnée */
|
|
{
|
|
SDL_Rect rectangle;
|
|
rectangle.x=Debut_X;
|
|
rectangle.y=Debut_Y;
|
|
rectangle.w=Largeur;
|
|
rectangle.h=Hauteur;
|
|
SDL_FillRect(Ecran_SDL,&rectangle,Couleur);
|
|
}
|
|
|
|
void Pixel_Preview_Normal_SDL (word X,word Y,byte Couleur)
|
|
/* Affichage d'un pixel dans l'écran, par rapport au décalage de l'image
|
|
* dans l'écran, en mode normal (pas en mode loupe)
|
|
* Note: si on modifie cette procédure, il faudra penser à faire également
|
|
* la modif dans la procédure Pixel_Preview_Loupe_SDL. */
|
|
{
|
|
// if(X-Principal_Decalage_X >= 0 && Y - Principal_Decalage_Y >= 0)
|
|
Pixel_SDL(X-Principal_Decalage_X,Y-Principal_Decalage_Y,Couleur);
|
|
}
|
|
|
|
void Pixel_Preview_Loupe_SDL (word X,word Y,byte Couleur)
|
|
{
|
|
// Affiche le pixel dans la partie non zoomée
|
|
Pixel_SDL(X-Principal_Decalage_X,Y-Principal_Decalage_Y,Couleur);
|
|
|
|
// Regarde si on doit aussi l'afficher dans la partie zoomée
|
|
if (Y >= Limite_Haut_Zoom && Y <= Limite_visible_Bas_Zoom
|
|
&& X >= Limite_Gauche_Zoom && X <= Limite_visible_Droite_Zoom)
|
|
{
|
|
// On est dedans
|
|
int hauteur;
|
|
int Y_Zoom = Table_mul_facteur_zoom[Y-Loupe_Decalage_Y];
|
|
|
|
if (Menu_Ordonnee - Y_Zoom < Loupe_Facteur)
|
|
// On ne doit dessiner qu'un morceau du pixel
|
|
// sinon on dépasse sur le menu
|
|
hauteur = Menu_Ordonnee - Y_Zoom;
|
|
else
|
|
hauteur = Loupe_Facteur;
|
|
|
|
Block_SDL_Fast(
|
|
Table_mul_facteur_zoom[X-Loupe_Decalage_X]
|
|
+ Principal_X_Zoom,
|
|
Y_Zoom, Loupe_Facteur, hauteur, Couleur
|
|
);
|
|
}
|
|
}
|
|
|
|
void Ligne_horizontale_XOR_SDL(word Pos_X,word Pos_Y,word Largeur)
|
|
{
|
|
//On calcule la valeur initiale de EDI:
|
|
byte* edi=Pos_Y*Largeur_ecran+Pos_X+Ecran;
|
|
|
|
int ecx;
|
|
|
|
for (ecx=0;ecx<Largeur;ecx++)
|
|
*(edi+ecx)=~*(edi+ecx);
|
|
}
|
|
|
|
void Ligne_verticale_XOR_SDL (word Pos_X,word Pos_Y,word Hauteur)
|
|
{
|
|
int i;
|
|
byte color;
|
|
for (i=Pos_Y;i<Pos_Y+Hauteur;i++)
|
|
{
|
|
color=*(Ecran+Pos_X+i*Largeur_ecran);
|
|
*(Ecran+Pos_X+i*Largeur_ecran)=~color;
|
|
}
|
|
}
|
|
|
|
void Display_brush_Color_SDL (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_brosse)
|
|
{
|
|
// EDI = Position à l'écran
|
|
byte* EDI = Ecran + Pos_Y * Largeur_ecran + Pos_X;
|
|
// ESI = Position dans la brosse
|
|
byte* ESI = Brosse + Decalage_Y * Largeur_brosse + Decalage_X;
|
|
|
|
word DX,CX;
|
|
|
|
// Pour chaque ligne
|
|
for(DX = Hauteur;DX > 0; DX--)
|
|
{
|
|
// Pour chaque pixel
|
|
for(CX = Largeur;CX > 0; CX--)
|
|
{
|
|
// On vérifie que ce n'est pas la transparence
|
|
if(*ESI != Couleur_de_transparence)
|
|
{
|
|
*EDI = *ESI;
|
|
}
|
|
|
|
// Pixel suivant
|
|
ESI++; EDI++;
|
|
}
|
|
|
|
// On passe à la ligne suivante
|
|
EDI = EDI + Largeur_ecran - Largeur;
|
|
ESI = ESI + Largeur_brosse - Largeur;
|
|
}
|
|
SDL_UpdateRect(Ecran_SDL,Pos_X,Pos_Y,Largeur,Hauteur);
|
|
}
|
|
|
|
void Display_brush_Mono_SDL (word Pos_X, word Pos_Y,
|
|
word Decalage_X, word Decalage_Y, word Largeur, word Hauteur,
|
|
byte Couleur_de_transparence, byte Couleur, word Largeur_brosse)
|
|
/* On affiche la brosse en monochrome */
|
|
{
|
|
byte* Dest=Pos_Y*Largeur_ecran+Pos_X+Ecran; // EDI = adr destination à
|
|
// l'écran
|
|
byte* Src=Largeur_brosse*Decalage_Y+Decalage_X+Brosse; // ESI = adr ds
|
|
// la brosse
|
|
int dx,cx;
|
|
|
|
for(dx=Hauteur;dx!=0;dx--)
|
|
//Pour chaque ligne
|
|
{
|
|
for(cx=Largeur;cx!=0;cx--)
|
|
//Pour chaque pixel
|
|
{
|
|
if (*Src!=Couleur_de_transparence)
|
|
*Dest=Couleur;
|
|
|
|
// On passe au pixel suivant
|
|
Src++;
|
|
Dest++;
|
|
}
|
|
|
|
// On passe à la ligne suivante
|
|
Src+=Largeur_brosse-Largeur;
|
|
Dest+=Largeur_ecran-Largeur;
|
|
}
|
|
SDL_UpdateRect(Ecran_SDL,Pos_X,Pos_Y,Largeur,Hauteur);
|
|
}
|
|
|
|
void Clear_brush_SDL (word Pos_X,word Pos_Y,word Decalage_X,word Decalage_Y,word Largeur,word Hauteur,byte Couleur_de_transparence,word Largeur_image)
|
|
{
|
|
byte* Dest=Ecran+Pos_X+Pos_Y*Largeur_ecran; //On va se mettre en 0,0 dans l'écran (EDI)
|
|
byte* Src = ( Pos_Y + Principal_Decalage_Y ) * Largeur_image + Pos_X + Principal_Decalage_X + Principal_Ecran; //Coords de départ ds la source (ESI)
|
|
int dx;
|
|
|
|
for(dx=Hauteur;dx!=0;dx--)
|
|
// Pour chaque ligne
|
|
{
|
|
// On fait une copie de la ligne
|
|
memcpy(Dest,Src,Largeur);
|
|
|
|
// On passe à la ligne suivante
|
|
Src+=Largeur_image;
|
|
Dest+=Largeur_ecran;
|
|
}
|
|
SDL_UpdateRect(Ecran_SDL,Pos_X,Pos_Y,Largeur,Hauteur);
|
|
}
|
|
|
|
void Remap_screen_SDL (word Pos_X,word Pos_Y,word Largeur,word Hauteur,byte * Table_de_conversion)
|
|
{
|
|
// EDI = coords a l'écran
|
|
byte* EDI = Ecran + Pos_Y * Largeur_ecran + Pos_X;
|
|
int dx,cx;
|
|
|
|
// Pour chaque ligne
|
|
for(dx=Hauteur;dx>0;dx--)
|
|
{
|
|
// Pour chaque pixel
|
|
for(cx=Largeur;cx>0;cx--)
|
|
{
|
|
*EDI = Table_de_conversion[*EDI];
|
|
EDI ++;
|
|
}
|
|
|
|
EDI = EDI + Largeur_ecran - Largeur;
|
|
}
|
|
|
|
SDL_UpdateRect(Ecran_SDL,Pos_X,Pos_Y,Largeur,Hauteur);
|
|
}
|
|
|
|
void Afficher_une_ligne_ecran_SDL (word Pos_X,word Pos_Y,word Largeur,byte * Ligne)
|
|
/* On affiche toute une ligne de pixels. Utilisé pour les textes. */
|
|
{
|
|
memcpy(Ecran+Pos_X+Pos_Y*Largeur_ecran,Ligne,Largeur);
|
|
//SDL_UpdateRect(Ecran_SDL,Pos_X,Pos_Y,Largeur,1);
|
|
}
|
|
|
|
void Afficher_une_ligne_transparente_mono_a_l_ecran_SDL(
|
|
word Pos_X, word Pos_Y, word Largeur, byte* Ligne,
|
|
byte Couleur_transparence, byte Couleur)
|
|
// Affiche une ligne à l'écran avec une couleur + transparence.
|
|
// Utilisé par les brosses en mode zoom
|
|
{
|
|
byte* Dest = Ecran+ Pos_Y * Largeur_ecran + Pos_X;
|
|
int Compteur;
|
|
// Pour chaque pixel
|
|
for(Compteur=0;Compteur<Largeur;Compteur++)
|
|
{
|
|
if (Couleur_transparence!=*Ligne)
|
|
*Dest = Couleur;
|
|
Ligne ++; // Pixel suivant
|
|
Dest++;
|
|
}
|
|
}
|
|
|
|
void Lire_une_ligne_ecran_SDL (word Pos_X,word Pos_Y,word Largeur,byte * Ligne)
|
|
{
|
|
memcpy(Ligne,Largeur_ecran * Pos_Y + Pos_X + Ecran,Largeur);
|
|
}
|
|
|
|
void Afficher_partie_de_l_ecran_zoomee_SDL(
|
|
word Largeur, // Largeur non zoomée
|
|
word Hauteur, // Hauteur zoomée
|
|
word Largeur_image,byte * Buffer)
|
|
{
|
|
byte* ESI = Principal_Ecran + Loupe_Decalage_Y * Largeur_image
|
|
+ Loupe_Decalage_X;
|
|
int EDX = 0; // Ligne en cours de traitement
|
|
|
|
// Pour chaque ligne à zoomer
|
|
while(1)
|
|
{
|
|
int CX;
|
|
|
|
// On éclate la ligne
|
|
Zoomer_une_ligne(ESI,Buffer,Loupe_Facteur,Largeur);
|
|
// On l'affiche Facteur fois, sur des lignes consécutives
|
|
CX = Loupe_Facteur;
|
|
// Pour chaque ligne
|
|
do{
|
|
// On affiche la ligne zoomée
|
|
Afficher_une_ligne_ecran_SDL(
|
|
Principal_X_Zoom, EDX, Largeur*Loupe_Facteur,
|
|
Buffer
|
|
);
|
|
// On passe à la suivante
|
|
EDX++;
|
|
if(EDX==Hauteur)
|
|
{
|
|
SDL_UpdateRect(Ecran_SDL,Principal_X_Zoom,0,
|
|
Largeur*Loupe_Facteur,Hauteur);
|
|
return;
|
|
}
|
|
CX--;
|
|
}while (CX > 0);
|
|
ESI += Largeur_image;
|
|
}
|
|
// ATTENTION on n'arrive jamais ici !
|
|
}
|
|
|
|
void Afficher_une_ligne_transparente_a_l_ecran_SDL(word Pos_X,word Pos_Y,word Largeur,byte* Ligne,byte Couleur_transparence)
|
|
{
|
|
byte* ESI = Ligne;
|
|
byte* EDI = Ecran + Pos_Y * Largeur_ecran + Pos_X;
|
|
|
|
byte cx;
|
|
|
|
// Pour chaque pixel de la ligne
|
|
for(cx = Largeur;cx > 0;cx--)
|
|
{
|
|
if(*ESI!=Couleur_transparence)
|
|
*EDI = *ESI;
|
|
ESI++;
|
|
EDI++;
|
|
}
|
|
}
|
|
|
|
// Affiche une partie de la brosse couleur zoomée
|
|
void Display_brush_Color_zoom_SDL (word Pos_X,word Pos_Y,
|
|
word Decalage_X,word Decalage_Y,
|
|
word Largeur, // Largeur non zoomée
|
|
word Pos_Y_Fin,byte Couleur_de_transparence,
|
|
word Largeur_brosse, // Largeur réelle de la brosse
|
|
byte * Buffer)
|
|
{
|
|
byte* ESI = Brosse+Decalage_Y*Largeur_brosse + Decalage_X;
|
|
word DX = Pos_Y;
|
|
byte bx;
|
|
|
|
// Pour chaque ligne
|
|
while(1)
|
|
{
|
|
Zoomer_une_ligne(ESI,Buffer,Loupe_Facteur,Largeur);
|
|
// On affiche facteur fois la ligne zoomée
|
|
for(bx=Loupe_Facteur;bx>0;bx--)
|
|
{
|
|
Afficher_une_ligne_transparente_a_l_ecran_SDL(Pos_X,DX,Largeur*Loupe_Facteur,Buffer,Couleur_de_transparence);
|
|
DX++;
|
|
if(DX==Pos_Y_Fin)
|
|
{
|
|
SDL_UpdateRect(Ecran_SDL,Pos_X,Pos_Y,Largeur*Loupe_Facteur,Pos_Y_Fin-Pos_Y+1);
|
|
return;
|
|
}
|
|
}
|
|
ESI += Largeur_brosse;
|
|
|
|
}
|
|
// ATTENTION zone jamais atteinte
|
|
}
|
|
|
|
void Display_brush_Mono_zoom_SDL (word Pos_X, word Pos_Y,
|
|
word Decalage_X, word Decalage_Y,
|
|
word Largeur, // Largeur non zoomée
|
|
word Pos_Y_Fin,
|
|
byte Couleur_de_transparence, byte Couleur,
|
|
word Largeur_brosse, // Largeur réelle de la brosse
|
|
byte * Buffer
|
|
)
|
|
|
|
{
|
|
byte* ESI = Brosse + Decalage_Y * Largeur_brosse + Decalage_X;
|
|
int DX=Pos_Y;
|
|
|
|
//Pour chaque ligne à zoomer :
|
|
while(1)
|
|
{
|
|
int BX;
|
|
// ESI = Ligne originale
|
|
// On éclate la ligne
|
|
Zoomer_une_ligne(ESI,Buffer,Loupe_Facteur,Largeur);
|
|
|
|
// On affiche la ligne Facteur fois à l'écran (sur des
|
|
// lignes consécutives)
|
|
BX = Loupe_Facteur;
|
|
|
|
// Pour chaque ligne écran
|
|
do
|
|
{
|
|
// On affiche la ligne zoomée
|
|
Afficher_une_ligne_transparente_mono_a_l_ecran_SDL(
|
|
Pos_X, DX, Largeur * Loupe_Facteur,
|
|
Buffer, Couleur_de_transparence, Couleur
|
|
);
|
|
// On passe à la ligne suivante
|
|
DX++;
|
|
// On vérifie qu'on est pas à la ligne finale
|
|
if(DX == Pos_Y_Fin)
|
|
{
|
|
SDL_UpdateRect(Ecran_SDL, Pos_X, Pos_Y,
|
|
Largeur * Loupe_Facteur, Pos_Y_Fin - Pos_Y );
|
|
return;
|
|
}
|
|
BX --;
|
|
}
|
|
while (BX > 0);
|
|
|
|
// Passage à la ligne suivante dans la brosse aussi
|
|
ESI+=Largeur_brosse;
|
|
}
|
|
}
|
|
|
|
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)
|
|
{
|
|
// 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;
|
|
int DX = Pos_Y;
|
|
int bx;
|
|
|
|
// Pour chaque ligne à zoomer
|
|
while(1){
|
|
Zoomer_une_ligne(ESI,Buffer,Loupe_Facteur,Largeur);
|
|
|
|
bx=Loupe_Facteur;
|
|
|
|
// Pour chaque ligne
|
|
do{
|
|
Afficher_une_ligne_ecran_SDL(Pos_X,DX,
|
|
Largeur * Loupe_Facteur,Buffer);
|
|
|
|
// Ligne suivante
|
|
DX++;
|
|
if(DX==Pos_Y_Fin)
|
|
{
|
|
SDL_UpdateRect(Ecran_SDL,Pos_X,Pos_Y,
|
|
Largeur*Loupe_Facteur,Pos_Y_Fin-Pos_Y);
|
|
return;
|
|
}
|
|
bx--;
|
|
}while(bx!=0);
|
|
|
|
ESI+= Largeur_image;
|
|
}
|
|
}
|
|
|
|
void Set_Mode_SDL()
|
|
/* On règle la résolution de l'écran */
|
|
{
|
|
Ecran_SDL=SDL_SetVideoMode(Largeur_ecran,Hauteur_ecran,8,SDL_FULLSCREEN*Plein_ecran);
|
|
if(Ecran_SDL != NULL)
|
|
Ecran=Ecran_SDL->pixels;
|
|
else
|
|
DEBUG("Erreur changement de mode video !!",0);
|
|
|
|
SDL_ShowCursor(0); // Cache le curseur SDL, on le gère en soft
|
|
}
|
|
|