vroman/edivc
SHA256
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

graphics limpiada y documentada ;)

Browse source
This commit is contained in:
Gabriel Lorenzo 2003-06-01 23:03:22 +00:00
parent 1b0c6bd06d
commit 3955659b94
15 changed files with 1839 additions and 1263 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

62
dlls/src/edivstd/edivstd.c
View file

@ -30,8 +30,9 @@
unsigned int tiempo; unsigned int tiempo;
unsigned int ultimo_tiempo; unsigned int ultimo_tiempo;
#else #else
#error ¡adapta las rutinas de timer a Linux! #error ¡adapta las rutinas de timer a Linux! (edivstd no debe usar SDL)
#endif #endif
#include <limits.h>
#include <assert.h> #include <assert.h>
#include <stdio.h> #include <stdio.h>
@ -42,6 +43,7 @@
int last_type ; int last_type ;
int last_proc ; int last_proc ;
#ifdef _DEBUG
int DEBUG_PROCESOS(FUNCTION_PARAMS) int DEBUG_PROCESOS(FUNCTION_PARAMS)
{ {
int i,n; int i,n;
@ -56,6 +58,7 @@ int DEBUG_PROCESOS(FUNCTION_PARAMS)
fclose(f); fclose(f);
return 0; return 0;
} }
#endif
int ExportaFuncs(EXPORTAFUNCS_PARAMS) int ExportaFuncs(EXPORTAFUNCS_PARAMS)
{ {
@ -93,8 +96,8 @@ int ExportaFuncs(EXPORTAFUNCS_PARAMS)
CONST("false",0); CONST("false",0);
/* Rango de INT */ /* Rango de INT */
CONST("max_int",2147483647); CONST("max_int",INT_MAX);
CONST("min_int",-2147483648); CONST("min_int",INT_MIN);
/* Señales entre procesos */ /* Señales entre procesos */
CONST("s_kill",0); CONST("s_kill",0);
@ -159,28 +162,17 @@ int ExportaFuncs(EXPORTAFUNCS_PARAMS)
/* Variables locales varias */ /* Variables locales varias */
LOCAL("priority",0); LOCAL("priority",0);
LOCAL("ctype",0); LOCAL("ctype",0);
LOCAL("x",0);
LOCAL("y",0);
LOCAL("z",0);
LOCAL("graph",0);
LOCAL("size",0);
LOCAL("angle",0);
LOCAL("region",0);
LOCAL("file",0);
LOCAL("xgraph",0);
LOCAL("height",1); LOCAL("height",1);
LOCAL("cnumber",0); LOCAL("cnumber",0);
LOCAL("resolution",0);
LOCAL("flags",0);
LOCAL("transparency",128) ;
FUNCTION("exit",2,eDIV_Exit); FUNCTION("exit",2,eDIV_Exit);
FUNCTION("get_id",1,eDiv_GetId) ; FUNCTION("get_id",1,eDiv_GetId) ;
FUNCTION("define_region",5,eDiv_DefineRegion) ;
FUNCTION("signal",2,eDIV_Signal); FUNCTION("signal",2,eDIV_Signal);
FUNCTION("let_me_alone",0,eDIV_Let_Me_Alone); FUNCTION("let_me_alone",0,eDIV_Let_Me_Alone);
#ifdef _DEBUG
FUNCTION("debug_procesos",0,DEBUG_PROCESOS); FUNCTION("debug_procesos",0,DEBUG_PROCESOS);
#endif
ENTRYPOINT(first_load) ; ENTRYPOINT(first_load) ;
ENTRYPOINT(frame); ENTRYPOINT(frame);
@ -243,29 +235,6 @@ int eDiv_GetId(FUNCTION_PARAMS)
return 0 ; return 0 ;
} }
int eDiv_DefineRegion(FUNCTION_PARAMS)
{
int n , x , y , w , h ;
h = getparm() ;
w = getparm() ;
y = getparm() ;
x = getparm() ;
n = getparm() ;
if ( n > 31 || n < 1 ) {
fp->Runtime_Error(108); /* nº de región inválido */
return 0;
}
regions[n].x = x ;
regions[n].y = y ;
regions[n].w = w ;
regions[n].h = h ;
return 1 ;
}
void signal_tree(int proc, int signal, FUNCTION_PARAMS) void signal_tree(int proc, int signal, FUNCTION_PARAMS)
{ {
int id2; int id2;
@ -334,26 +303,11 @@ int eDIV_Let_Me_Alone(FUNCTION_PARAMS)
*/ */
void first_load(FUNCTION_PARAMS) void first_load(FUNCTION_PARAMS)
{ {
int i ;
#ifdef _WIN32 #ifdef _WIN32
struct timeb tiempob; struct timeb tiempob;
ftime(&tiempob); ftime(&tiempob);
ultimo_tiempo=tiempob.time*100+tiempob.millitm/10; ultimo_tiempo=tiempob.time*100+tiempob.millitm/10;
#endif #endif
for ( i = 0 ; i < 32 ; i++ )
{
regions[i].x = 0 ;
regions[i].y = 0 ;
regions[i].w = 0 ;
regions[i].h = 0 ;
}
fp->regions = regions ;
fp->existe.regions = 1 ;
} }
void frame(FUNCTION_PARAMS) void frame(FUNCTION_PARAMS)

3
dlls/src/edivstd/edivstd.h
View file

@ -1,12 +1,9 @@
#ifndef __EDIV_EDIVSTD_H_ #ifndef __EDIV_EDIVSTD_H_
#define __EDIV_EDIVSTD_H_ #define __EDIV_EDIVSTD_H_
struct _regions regions[32] ;
/* Prototipos */ /* Prototipos */
int eDIV_Exit(FUNCTION_PARAMS); int eDIV_Exit(FUNCTION_PARAMS);
int eDiv_GetId(FUNCTION_PARAMS) ; int eDiv_GetId(FUNCTION_PARAMS) ;
int eDiv_DefineRegion(FUNCTION_PARAMS) ;
int eDIV_Signal(FUNCTION_PARAMS); int eDIV_Signal(FUNCTION_PARAMS);
int eDIV_Let_Me_Alone(FUNCTION_PARAMS); int eDIV_Let_Me_Alone(FUNCTION_PARAMS);

49
dlls/src/graphics/advance.c Normal file
View file

@ -0,0 +1,49 @@
/*! \file advance.c
* \brief Contiene las funciones advance() y xadvance() para el movimiento en 2D.
* \todo Hacer que les afecte la local resolution
*/
#include <math.h>
#include <SDL/SDL.h>
#include "export.h"
#include "graphics.h"
/*! \brief Avanza 'a' unidades según el ángulo del proceso.
* @param a Distancia que se quiere avanzar
* @return 1
* @see eDIV_XADVANCE()
*/
int eDIV_ADVANCE(FUNCTION_PARAMS)
{
int a , id1 , x , y , angulo ;
a = getparm() ;
id1 = fp->procs_s[ fp->proc_orden[ *fp->proceso_actual ] ].id ;
angulo = local("angle",id1) ;
x = (int) ((double)a * cos( (angulo/1000) * PIOVER180 )) ;
y = (int) ((double)a * sin( (angulo/1000) * PIOVER180 )) ;
local("x",id1) += x;
local("y",id1) += y ;
return 1 ;
}
/*! \brief Avanza 'b' unidades según el ángulo 'a'
* @param a Ángulo
* @param b Distancia que se quiere avanzar
* @return 1
* @see eDIV_ADVANCE()
*/
int eDIV_XADVANCE(FUNCTION_PARAMS)
{
int a , b , id1 , x , y , angulo ;
b = getparm() ;
a = getparm() ;
id1 = fp->procs_s[ fp->proc_orden[ *fp->proceso_actual ] ].id ;
angulo = a ;
x = (int) ((double)b * cos( (angulo/1000) * PIOVER180 )) ;
y = (int) ((double)b * sin( (angulo/1000) * PIOVER180 )) ;
local("x",id1) += x ;
local("y",id1) += y ;
return 1 ;
}

151
dlls/src/graphics/carga.c Normal file
View file

@ -0,0 +1,151 @@
/*
** carga.c
** Incluye las funciones de carga y descarga de recursos gráficos
** (bmp, fpg, map, pcx, pal, png...)
*/
#include <SDL/SDL.h>
#include "export.h"
#include "graphics.h"
/*
**
** eDIV_LOAD_BMP(filename);
**
** Carga un BMP donde 'filename' es el fichero a cargar.
**
** Retorna: El numero de Mapa.
** -1 : Si no se ha podido cargar el mapa.
**
*/
int eDIV_LOAD_BMP(FUNCTION_PARAMS)
{
int i ;
const char *filename=getstrparm(); /* Fichero a cargar */
for ( i = 1000 ; i < files[0].num ; i++ )
{
if ( files[0].mapa[i].existe == 0 )
{
files[0].mapa[i].Surface = SDL_LoadBMP( filename ) ;
if(files[0].mapa[i].Surface == NULL)
fp->Runtime_Error(143); /* "No se pudo cargar el mapa, archivo no encontrado." */
files[0].mapa[i].existe = 1 ;
files[0].mapa[i].cpoint[0].x = (int)files[0].mapa[i].Surface->w / 2 ;
files[0].mapa[i].cpoint[0].y = (int)files[0].mapa[i].Surface->h / 2 ;
SDL_SetColorKey( files[0].mapa[i].Surface , SDL_SRCCOLORKEY | SDL_RLEACCEL , color_transparente ) ;
if ( i > last_map[0] )
last_map[0] = i ;
return i ;
}
}
return -1 ;
}
/*
**
** eDIV_LOAD_FPG(filename);
**
** Carga un FPG, de cualquier bpp.
**
** Retorna: El numero de FPG.
**
*/
int eDIV_LOAD_FPG(FUNCTION_PARAMS)
{
char * archivo ;
FILE *f;
FPGHEADER8 cabecera8;
FPGHEADER cabecera;
FPGMAPINFO infomapa;
int tamano;
int cont=0,num,i;
int bpp;
char* graphic;
SDL_Color p[256];
archivo = getstrparm() ;
f=fopen(archivo,"rb");
if(f==NULL) {
fp->Runtime_Error(ERR_FILENOTFOUND);
}
fseek(f,0,SEEK_END);
tamano=ftell(f);
fseek(f,0,SEEK_SET);
fread(&cabecera,1,sizeof(FPGHEADER),f);
/*
* TODO: optimizar esto ligeramente (comprobar primero los bytes comunes y luego
* leer "pg","16","24","32")
*/
if(strcmp(cabecera.header,"fpg\x1A\x0D\x0A")) {
if(strcmp(cabecera.header,"f16\x1A\x0D\x0A")) {
if(strcmp(cabecera.header,"f24\x1A\x0D\x0A")) {
if(strcmp(cabecera.header,"f32\x1A\x0D\x0A")) {
fp->Runtime_Error(ERR_INVALIDFPGHEADER);
}
else {
bpp=32;
}
}
else {
bpp=24;
}
}
else {
bpp=16;
}
}
else {
bpp=8;
fseek(f,0,SEEK_SET);
fread(&cabecera8,1,sizeof(FPGHEADER8),f);
for(i=0;i<256;i++) {
p[i].r=cabecera8.palette[i].r*4;
p[i].g=cabecera8.palette[i].g*4;
p[i].b=cabecera8.palette[i].b*4;
}
SDL_SetPalette(screen,SDL_LOGPAL|SDL_PHYSPAL,p,0,256);
}
while(ftell(f)<tamano) {
fread(&infomapa,1,sizeof(FPGMAPINFO),f);
num=infomapa.code;
if(num>999 || num<0) {
fp->Runtime_Error(ERR_INVALIDMAPCODE);
}
if ( files[0].mapa[num].existe == 1 )
return -1 ;
files[0].mapa[num].existe = 1 ;
if(infomapa.number_of_points==0) {
files[0].mapa[num].cpoint[0].x = (int) infomapa.wide/2 ;
files[0].mapa[num].cpoint[0].y = (int) infomapa.height/2 ;
} else {
fread(files[0].mapa[num].cpoint,2,2*infomapa.number_of_points,f) ;
}
graphic = (char*)malloc(infomapa.wide*infomapa.height*bpp/8);
fread(graphic,1,infomapa.wide*infomapa.height*bpp/8,f);
files[0].mapa[num].Surface = SDL_CreateRGBSurfaceFrom(graphic,infomapa.wide,infomapa.height,bpp,infomapa.wide*bpp/8,0,0,0,0) ;
cont++;
if(bpp==8) {
SDL_SetPalette(files[0].mapa[num].Surface,SDL_LOGPAL|SDL_PHYSPAL,p,0,256);
}
SDL_SetColorKey(files[0].mapa[num].Surface,SDL_SRCCOLORKEY|SDL_RLEACCEL,0);
}
fclose(f);
return 0;
}

125
dlls/src/graphics/collision.c Normal file
View file

@ -0,0 +1,125 @@
/*
** collision.c
** Incluye las rutinas de detección de colisiones entre sprites
*/
#include <SDL/SDL.h>
#include "export.h"
#include "graphics.h"
/*
** int IntersectionRR(int rc1left,int rc1top,int rc1right,int rc1bottom,int rc2left,int rc2top,int rc2right,int rc2bottom)
** Comprueba si hay colisión entre dos regiones rectangulares.
**
** Devuelve:
** 0 - No hay colisión
** 1 - Hay colisión
*/
int IntersectionRR(int rc1left,int rc1top,int rc1right,int rc1bottom,int rc2left,int rc2top,int rc2right,int rc2bottom)
{
if(rc1left==rc2left || rc1top==rc2top || rc1right==rc2right || rc1bottom==rc2bottom)
return 1;
return ((Miedzy(rc1left,rc2left,rc2right) || Miedzy(rc1right,rc2left,rc2right) ||
Miedzy(rc2left,rc1left,rc1right) || Miedzy(rc2right,rc1left,rc1right)) &&
(Miedzy(rc1top,rc2top,rc2bottom) || Miedzy(rc1bottom,rc2top,rc2bottom) ||
Miedzy(rc2top,rc1top,rc1bottom) || Miedzy(rc2bottom,rc1top,rc1bottom)));
}
/*
** eDIV_COLLISION (id)
**
** Detecta si el proceso actual está colisionando con el del id indicado, o, si
** se le indica un type, si colisiona con algún proceso de ese tipo
**
** Devuelve: - el ID del proceso con el que se está colisionando (si se indica
** un type y se está colisionando a la vez con varios procesos de
** ese type, en sucesivas llamadas se irán devolviendo sus respec-
** tivos IDs, hasta devolver 0 cuando ya no queden más).
** - 0 si no se colisiona con ningún proceso del ID o type indicado.
*/
int eDIV_COLLISION(FUNCTION_PARAMS)
{
int g1 , g2 ;
int f1 , f2 ;
int id1, id2 ;
int a, i ;
SDL_Rect r1 , r2 ;
int _status=reservedptr("status");
a = getparm() ;
id1 = fp->procs_s[ fp->proc_orden[ *fp->proceso_actual ] ].id ;
g1 = local("graph",id1) ;
f1 = local("file",id1) ;
if ( files[f1].existe == 0 || files[f1].mapa[g1].existe == 0 )
return 0;
/* Si se le pasa un ID */
if (a<fp->imem_max)
{
if(a==id1 || (fp->mem[id1+_status]!=2 && fp->mem[id1+_status]!=4))
return 0;
r1.x = local("x",id1) ;
r1.y = local("y",id1) ;
r1.w = files[f1].mapa[g1].Surface->w ;
r1.h = files[f1].mapa[g1].Surface->h ;
id2 = a ;
g2 = local("graph",id2) ;
f2 = local("file",id2);
if ( files[f2].existe == 0 || files[f2].mapa[g2].existe == 0 )
return 0;
r2.x = local("x",id2) ;
r2.y = local("y",id2) ;
r2.w = files[f2].mapa[g2].Surface->w ;
r2.h = files[f2].mapa[g1].Surface->h ;
/* Colision barata :P */
if(IntersectionRR(r1.x,r1.y,r1.x+r1.w-1,r1.x+r1.h-1,r2.x,r2.y,r2.x+r2.w-1,r2.y+r2.h-1))
return id2;
}
else {
int* type_scan=&reserved("type_scan",id1);
int* id_scan=&reserved("id_scan",id1);
/* Si se le pasa un type */
if(*type_scan!=a) {
*id_scan=0;
*type_scan=a;
}
for ( i = *id_scan+1 ; i < *fp->num_procs ; i++ )
{
id2 = fp->procs_s[ fp->proc_orden[ i ] ].id;
if(id2==id1 || (fp->mem[id1+_status]!=2 && fp->mem[id1+_status]!=4))
continue;
/* Si el proceso se corresponde con el type */
if ( reserved("process_type",id2) == a )
{
r1.x = local("x",id1) ;
r1.y = local("y",id1) ;
r1.w = files[f1].mapa[g1].Surface->w ;
r1.h = files[f1].mapa[g1].Surface->h ;
g2 = local("graph",id2) ;
f2 = local("file",id2) ;
if ( files[f2].existe == 0 || files[f2].mapa[g2].existe == 0 )
continue;
r2.x = local("x",id2) ;
r2.y = local("y",id2) ;
r2.w = files[f2].mapa[g2].Surface->w ;
r2.h = files[f2].mapa[g1].Surface->h ;
/* Colision barata :P */
if(IntersectionRR(r1.x,r1.y,r1.x+r1.w-1,r1.x+r1.h-1,r2.x,r2.y,r2.x+r2.w-1,r2.y+r2.h-1)) {
*id_scan=i;
return id2;
}
}
}
*type_scan=0;
}
return 0 ;
}

71
dlls/src/graphics/default_palette.h Normal file
View file

@ -0,0 +1,71 @@
/*! \file default_palette.h
* \brief Contiene la definición de la paleta por defecto
*
* Este fichero contiene la definición de #default_palette, que es un array
* de bytes que contienen la información RGBA de los colores de la paleta que
* se inicializa por defecto (ya que el modo por defecto es de 8 bits).
*/
#ifndef __EDIV_DEFAULT_PALETTE_H_
#define __EDIV_DEFAULT_PALETTE_H_
#include <SDL/SDL.h>
/*! esta es la paleta ke usa por defecto el DIV2, asi k el eDIV tambien xD */
byte default_palette[]={
0,0,0,0,16,16,16,0,32,32,32,0,48,48,48,0,64,64,64,0,
84,84,84,0,100,100,100,0,116,116,116,0,132,132,132,0,148,148,148,0,
168,168,168,0,184,184,184,0,200,200,200,0,216,216,216,0,232,232,232,0,
252,252,252,0,40,0,0,0,72,0,0,0,108,0,0,0,144,0,0,0,
180,0,0,0,216,0,0,0,252,0,0,0,252,32,0,0,252,64,0,0,
252,96,0,0,252,128,0,0,252,160,0,0,252,180,56,0,252,200,112,0,
252,220,168,0,252,240,224,0,0,40,0,0,0,60,0,0,0,84,0,0,
0,108,0,0,0,132,0,0,0,156,0,0,0,180,0,0,0,204,0,0,
0,228,0,0,0,252,0,0,48,252,32,0,96,252,64,0,144,252,96,0,
192,252,132,0,216,252,176,0,240,252,220,0,0,0,40,0,0,0,72,0,
0,0,104,0,0,0,140,0,0,0,172,0,0,0,208,0,0,0,252,0,
0,48,252,0,0,100,252,0,0,148,252,0,0,200,252,0,0,252,252,0,
56,252,252,0,112,252,252,0,168,252,252,0,224,252,252,0,28,28,0,0,
52,52,0,0,76,76,0,0,100,100,0,0,124,124,0,0,152,152,0,0,
176,176,0,0,200,200,0,0,224,224,0,0,252,252,0,0,252,252,36,0,
252,252,72,0,252,252,108,0,252,252,144,0,252,252,180,0,252,252,220,0,
28,0,28,0,52,0,52,0,76,0,76,0,100,0,100,0,124,0,124,0,
152,0,152,0,176,0,176,0,200,0,200,0,224,0,224,0,252,0,252,0,
252,36,252,0,252,72,252,0,252,112,252,0,252,148,252,0,252,184,252,0,
252,224,252,0,0,20,20,0,0,40,40,0,0,60,60,0,0,80,80,0,
0,104,100,0,0,124,120,0,0,144,144,0,0,164,164,0,0,188,184,0,
0,208,204,0,0,228,224,0,0,252,248,0,44,252,248,0,92,252,248,0,
140,252,248,0,188,252,248,0,24,12,0,0,44,24,0,0,64,36,0,0,
84,48,0,0,108,60,0,0,128,72,0,0,148,84,0,0,168,96,0,0,
192,112,0,0,196,128,28,0,204,144,60,0,212,160,92,0,216,180,120,0,
224,196,152,0,232,212,184,0,240,232,216,0,24,12,12,0,40,20,20,0,
60,32,32,0,80,44,44,0,96,52,52,0,116,64,64,0,136,76,76,0,
156,88,88,0,176,104,104,0,196,120,120,0,216,136,136,0,240,152,152,0,
240,168,168,0,244,188,188,0,244,204,204,0,248,224,224,0,24,20,12,0,
44,36,24,0,68,52,36,0,88,72,48,0,112,88,60,0,132,104,72,0,
156,124,88,0,172,140,100,0,188,156,112,0,204,176,124,0,220,192,136,0,
240,212,152,0,240,216,168,0,244,224,188,0,244,232,204,0,248,240,224,0,
32,8,0,0,60,16,0,0,88,28,0,0,120,36,0,0,148,48,0,0,
176,56,0,0,208,68,0,0,216,88,0,0,224,112,0,0,232,136,0,0,
240,160,0,0,252,184,0,0,252,200,56,0,252,216,112,0,252,232,168,0,
252,252,224,0,20,12,12,0,36,24,24,0,56,36,36,0,72,48,48,0,
92,64,64,0,108,76,76,0,128,88,88,0,144,100,100,0,164,116,116,0,
172,132,132,0,184,148,148,0,192,164,164,0,204,180,180,0,212,196,196,0,
224,212,212,0,236,232,232,0,12,20,12,0,24,36,24,0,36,56,36,0,
48,72,48,0,64,92,64,0,76,108,76,0,88,128,88,0,100,144,100,0,
116,164,116,0,132,172,132,0,148,184,148,0,164,192,164,0,180,204,180,0,
196,212,196,0,212,224,212,0,232,236,232,0,12,12,16,0,24,24,32,0,
36,36,48,0,48,48,64,0,64,64,80,0,76,76,96,0,88,88,112,0,
100,100,128,0,116,116,148,0,132,132,160,0,148,148,172,0,164,164,184,0,
180,180,196,0,196,196,208,0,212,212,220,0,232,232,236,0,40,0,0,0,
80,0,0,0,124,0,0,0,164,0,0,0,208,0,0,0,252,0,0,0,
252,40,0,0,252,84,0,0,252,124,0,0,252,168,0,0,252,208,0,0,
252,252,0,0,252,252,44,0,252,252,92,0,252,252,140,0,252,252,188,0,
0,0,0,0,0,0,88,0,0,0,128,0,0,0,168,0,0,0,208,0,
0,0,248,0,40,0,248,0,84,0,248,0,124,0,248,0,168,0,248,0,
208,0,248,0,252,0,252,0,252,52,252,0,252,108,252,0,252,164,252,0,
252,220,252,0
};
#endif /* __EDIV_DEFAULT_PALETTE_H_ */

162
dlls/src/graphics/draw.c Normal file
View file

@ -0,0 +1,162 @@
/*! \file draw.c
* \brief Funciones de dibujo de figuras 2D (draw's)
*/
#include <SDL/SDL.h>
#include "export.h"
#include "graphics.h"
/*! \brief Crea un nuevo draw
* \todo Permitir más tipos de figuras, y hacer que se dibujen en tiempo real, para que sean más rápidos y no consuman memoria
* @param t Tipo de figura (1=línea, 2=rectángulo, 3=rectángulo relleno, 4=elipse, 5=elipse rellena)
* @param c Color
* @param o Opacidad (0..15)
* @param r Región
* @param x0 Coordenada X inicial
* @param y0 Coordenada Y inicial
* @param x1 Coordenada X final
* @param y1 Coordenada Y final
* @return El identificador del draw, o -1 si hubo un error
* @see eDIV_MOVE_DRAW(), eDIV_DELETE_DRAW(), #draws, frame()
*/
int eDIV_DRAW(FUNCTION_PARAMS)
{
int i ;
int t , c , o , r , x0, y0 , x1 , y1 ;
SDL_Rect dstrect ;
y1 = getparm() ;
x1 = getparm() ;
y0 = getparm() ;
x0 = getparm() ;
r = getparm() ;
o = getparm() ;
c = getparm() ;
t = getparm() ;
for ( i = 0 ; i < 1024 ; i++ )
{
if ( draws[i].existe == 0 )
{
draws[i].Surface = SDL_CreateRGBSurface( SDL_HWSURFACE , x1 - x0 , y1 - y0 , screen->format->BitsPerPixel , 0xFF0000 , 0x00FF00 , 0x0000FF , 0x000000 ) ;
switch ( t )
{
case 3:
dstrect.x = 0 ;
dstrect.y = 0 ;
dstrect.w = x1 - x0 ;
dstrect.h = y1 - y0 ;
SDL_FillRect( draws[i].Surface , &dstrect , c ) ;
break ;
}
draws[i].region = r ;
draws[i].x = x0 ;
draws[i].y = y0 ;
draws[i].t = t ;
draws[i].c = c ;
if ( o < 15 && o > -1 )
SDL_SetAlpha( draws[i].Surface , SDL_SRCALPHA | SDL_RLEACCEL , 17 * (o) ) ;
draws[i].existe = 1 ;
if ( i > last_draw )
last_draw = i ;
return i ;
}
}
return -1 ;
}
/*! \brief Cambia los atributos de un draw
* @param id Identificador del draw a modificar
* @param c Color
* @param o Opacidad (0..15)
* @param x0 Coordenada X inicial
* @param y0 Coordenada X inicial
* @param x1 Coordenada Y final
* @param y1 Coordenada X final
* @return 1 si todo fue bien, -1 si hubo un error
* @see eDIV_DRAW(), eDIV_DELETE_DRAW(), #draws
*/
int eDIV_MOVE_DRAW(FUNCTION_PARAMS)
{
SDL_Rect dstrect ;
int id , c , o , x0 , y0 , x1 , y1 ;
y1 = getparm() ;
x1 = getparm() ;
y0 = getparm() ;
x0 = getparm() ;
o = getparm() ;
c = getparm() ;
id = getparm() ;
if ( !draws[id].existe )
return -1 ;
if ( x1 - x0 != draws[id].Surface->w || y1 - y0 != draws[id].Surface->h || c != draws[id].c )
{
if ( x1 - x0 != draws[id].Surface->w || y1 - y0 != draws[id].Surface->h )
{
SDL_FreeSurface( draws[id].Surface ) ;
draws[id].Surface = SDL_CreateRGBSurface( SDL_HWSURFACE , x1 - x0 , y1 - y0 , screen->format->BitsPerPixel , 0xFF0000 , 0x00FF00 , 0x0000FF , 0x000000 ) ;
}
switch ( draws[id].t )
{
case 3:
dstrect.x = 0 ;
dstrect.y = 0 ;
dstrect.w = x1 - x0 ;
dstrect.h = y1 - y0 ;
SDL_FillRect( draws[id].Surface , &dstrect , c ) ;
break ;
}
}
draws[id].x = x0 ;
draws[id].y = y0 ;
draws[id].c = c ;
if ( o < 15 && o > -1 )
SDL_SetAlpha( draws[id].Surface , SDL_SRCALPHA | SDL_RLEACCEL , 17 * (o) ) ;
else
if ( o == 15 )
SDL_SetAlpha( draws[id].Surface , 0 , 255 ) ;
return 1 ;
}
/*! \brief Elimina un draw
* @param n Identificador del draw o \a all_drawing (-1).
* @return 1 si todo fue bien, -1 si hubo un error
* @see eDIV_DRAW(), eDIV_MOVE_DRAW(), #draws
*/
int eDIV_DELETE_DRAW(FUNCTION_PARAMS)
{
int n ;
n = getparm() ;
if(n==-1) {
for(n=0;n<MAX_DRAWS;n++) {
if(draws[n].existe) {
SDL_FreeSurface( draws[n].Surface );
draws[n].existe = 0;
}
}
last_draw=0;
return 1;
}
if ( !draws[n].existe )
return -1 ;
SDL_FreeSurface( draws[n].Surface ) ;
draws[n].existe = 0 ;
for ( ; last_draw > 0 ; last_draw-- )
{
if ( draws[last_draw].existe )
break ;
}
return 1 ;
}

1317
dlls/src/graphics/graphics.c
View file

File diff suppressed because it is too large Load diff

157
dlls/src/graphics/graphics.h
View file

@ -1,44 +1,175 @@
/*! \file graphics.h
* \brief Cabecera principal de la librería
*
* Este fichero, aparte de otras cosas, contiene los prototipos de todos los .c
* (excepto de SDL_rotozoom.c).
* \todo hacer video_modes[] y num_video_modes
*/
#ifndef __EDIV_GRAPHICS_H_ #ifndef __EDIV_GRAPHICS_H_
#define __EDIV_GRAPHICS_H_ #define __EDIV_GRAPHICS_H_
#include <SDL/SDL.h> #include <SDL/SDL.h>
#define PIOVER180 0.017453292519943295769236907684886
SDL_Surface *screen; /* Constantes */
SDL_Surface *fondo;
#define PIOVER180 0.017453292519943295769236907684886 /*!< Constante para pasar de grados a radianes y viceversa */
#define ERR_FILENOTFOUND 105
#define ERR_INVALIDFPGHEADER 106
#define ERR_INVALIDMAPCODE 110
#define MAX_DRAWS 1024 /*!< Número máximo de objetos que soporta draw() (en el DIV2 eran 256) */
#define MAX_REGIONS 32 /*!< Número máximo de regiones de pantalla (en el DIV2 eran 32) */
/* Macros */
/*! Se usa para la colisión por bounding-box */
#define Miedzy(x,a,b) (((x) >= (a)) && ((x) <= (b)))
/*! Asigna a una superficie la paleta de otra superficie */
#define PaletteCopy(dst,src) SDL_SetPalette(dst,SDL_LOGPAL|SDL_PHYSPAL,src->format->palette->colors,0,256);
/* Globales */
/*! Color en la paleta de un MAP, FPG, etc */
typedef struct {
unsigned char r,g,b;
} pal_t;
/*! Cabecera de los FPG de 8 bits */
typedef struct _FPGHEADER8{
char header[8];
pal_t palette[256];
/* char palette[768]; */
char colorbars[576];
}FPGHEADER8;
/*! Cabecera de los FPG no paletizados */
typedef struct _FPGHEADER{
char header[8];
/* pal_t palette[256]; */
/* char palette[768]; */
/* char colorbars[576]; */
}FPGHEADER;
/*! Cabecera de un mapa dentro de un FPG */
typedef struct _FPGMAPINFO{
int code;
int lenght;
char description[32];
char filename[12];
int wide;
int height;
int number_of_points;
}FPGMAPINFO;
//char *graphic; /* wide*height */
/*! Tabla de objetos creados con draw()
* @see eDIV_DRAW(), frame()
*/
struct{
int existe ;
int region ;
int x , y ;
int t , c ; /* requerido para move_draw() */
SDL_Surface *Surface ;
} draws[MAX_DRAWS] ;
int last_draw ;
/*! Tabla de blits
* @see Dibuja(), frame(), ordena_por_z()
*/
struct _blits {
SDL_Surface *src ;
SDL_Rect srcrect ;
SDL_Surface *dst ;
SDL_Rect dstrect ;
int z ;
int trans ;
} blits[0xFFFF] , *orden[0xFFFF];
struct _regions regions[MAX_REGIONS]; /*!< Tabla de regiones */
SDL_Surface *screen; /*!< Superficie del backbuffer */
SDL_Surface *fondo; /*!< Superficie del fondo */
SDL_Color activepal[256]; /*!< Paleta activa (fades, etc) */
BOOL adaptar_paleta; /*!< Para el force_pal() */
struct _files files[ 0xFF ] ; /*!< Tabla de FPG's */
SDL_Surface *Mapa[0xFFF] ;
struct _file file0[0xFFF] ;
int last_map[0xFF] ;
int color_transparente ; /*!< Color transparente actual (por defecto, 0) */
int define_region ;
BOOL primer_frame; /*!< Indica a frame() si es la primera vez que se ejecuta */
int last_blit ;
int gamma[3] ;
int smooth; /*!< Indica si se desea suavizar los gráficos @see xput() */
/*
** Prototipos
*/
/* Carga/descarga */
int eDIV_LOAD_BMP(FUNCTION_PARAMS); int eDIV_LOAD_BMP(FUNCTION_PARAMS);
int eDIV_LOAD_FPG(FUNCTION_PARAMS) ;
/* Colisiones */
int eDIV_COLLISION(FUNCTION_PARAMS); int eDIV_COLLISION(FUNCTION_PARAMS);
/* Paleta */
int eDIV_SET_TRANSPARENT_COLOR(FUNCTION_PARAMS); int eDIV_SET_TRANSPARENT_COLOR(FUNCTION_PARAMS);
int eDIV_GET_TRANSPARENT_COLOR(FUNCTION_PARAMS); int eDIV_GET_TRANSPARENT_COLOR(FUNCTION_PARAMS);
int eDIV_RGB(FUNCTION_PARAMS); int eDIV_RGB(FUNCTION_PARAMS);
int eDIV_FIND_COLOR(FUNCTION_PARAMS);
int eDIV_GET_RGB(FUNCTION_PARAMS); int eDIV_GET_RGB(FUNCTION_PARAMS);
int eDIV_FADE(FUNCTION_PARAMS) ;
/* Advance y xadvance*/
int eDIV_ADVANCE(FUNCTION_PARAMS); int eDIV_ADVANCE(FUNCTION_PARAMS);
int eDIV_XADVANCE(FUNCTION_PARAMS) ; int eDIV_XADVANCE(FUNCTION_PARAMS) ;
int eDIV_MAP_BLOCK_COPY(FUNCION_PARMAS) ;
int eDIV_MAP_GET_PIXEL(FUNCION_PARMAS) ; /* Operaciones con mapas */
int eDIV_MAP_PUT(FUNCION_PARMAS) ; int eDIV_MAP_BLOCK_COPY(FUNCTION_PARAMS) ;
int eDIV_MAP_GET_PIXEL(FUNCTION_PARAMS) ;
int eDIV_MAP_PUT(FUNCTION_PARAMS) ;
int eDIV_MAP_PUT_PIXEL(FUNCTION_PARAMS); int eDIV_MAP_PUT_PIXEL(FUNCTION_PARAMS);
int eDIV_PUT(FUNCTION_PARAMS); int eDIV_PUT(FUNCTION_PARAMS);
int eDIV_PUT_PIXEL(FUNCTION_PARAMS); int eDIV_PUT_PIXEL(FUNCTION_PARAMS);
int eDIV_PUT_SCREEN(FUNCION_PARAMS); int eDIV_PUT_SCREEN(FUNCTION_PARAMS);
int eDIV_CLEAR_SCREEN(FUNCTION_PARAMS); int eDIV_CLEAR_SCREEN(FUNCTION_PARAMS);
int eDIV_GET_PIXEL(FUNCTION_PARAMS); int eDIV_GET_PIXEL(FUNCTION_PARAMS);
int eDIV_NEW_MAP(FUNCTION_PARAMS) ; int eDIV_NEW_MAP(FUNCTION_PARAMS) ;
int eDIV_SCREEN_COPY(FUNCTION_PARAMS) ; int eDIV_SCREEN_COPY(FUNCTION_PARAMS) ;
int eDIV_OUT_REGION(FUNCTION_PARAMS) ;
int eDIV_DRAW(FUNCTION_PARAMS) ;
int eDIV_MOVE_DRAW(FUNCTION_PARAMS) ;
int eDIV_DELETE_DRAW(FUNCTION_PARAMS) ;
int eDIV_LOAD_FPG(FUNCTION_PARAMS) ;
int eDIV_GET_POINT(FUNCTION_PARAMS) ; int eDIV_GET_POINT(FUNCTION_PARAMS) ;
int eDIV_GET_REAL_POINT(FUNCTION_PARAMS) ; int eDIV_GET_REAL_POINT(FUNCTION_PARAMS) ;
int eDIV_GRAPHIC_INFO(FUNCTION_PARAMS) ; int eDIV_GRAPHIC_INFO(FUNCTION_PARAMS) ;
int eDIV_FADE(FUNCTION_PARAMS) ;
int eDIV_XPUT(FUNCTION_PARAMS); int eDIV_XPUT(FUNCTION_PARAMS);
/* Regiones */
int eDIV_DEFINE_REGION(FUNCTION_PARAMS) ;
int eDIV_OUT_REGION(FUNCTION_PARAMS) ;
/* Draws */
int eDIV_DRAW(FUNCTION_PARAMS) ;
int eDIV_MOVE_DRAW(FUNCTION_PARAMS) ;
int eDIV_DELETE_DRAW(FUNCTION_PARAMS) ;
/* Otras */
int eDIV_SET_MODE(FUNCTION_PARAMS); int eDIV_SET_MODE(FUNCTION_PARAMS);
/* Funciones internas */
int Dibuja(SDL_Surface *src , SDL_Rect srcrect , SDL_Rect dstrect , int z , int trans,int size,int angle); int Dibuja(SDL_Surface *src , SDL_Rect srcrect , SDL_Rect dstrect , int z , int trans,int size,int angle);
SDL_Surface *xput(SDL_Surface *src,double size,double angle); SDL_Surface *xput(SDL_Surface *src,double size,double angle);

602
dlls/src/graphics/map_ops.c Normal file
View file

@ -0,0 +1,602 @@
/*! \file map_ops.c
* \brief Funciones de operaciones con mapas
*
* Este fichero contiene las funciones para las operaciones con mapas
* (modificación, obtención de información, bliteos, etc).
*
* \todo Falta respetar el centro del gráfico, y soporte para FLAGS 1 y 2
*/
#include <SDL/SDL.h>
#include "export.h"
#include "graphics.h"
/*! \brief Copia un trozo de mapa y lo pega en otro mapa
*
* Esta función sólo permite operaciones en el mismo FPG.
* \todo ¿sobrecargar para permitir operaciones entre FPG's?
* @param f FPG donde se encuentran los dos mapas
* @param g2 Gráfico de destino
* @param x2 Coordenada X destino
* @param y2 Coordenada Y destino
* @param g1 Gráfico de origen
* @param x1 Coordenada X origen
* @param y1 Coordenada Y origen
* @param w Anchura del bloque a copiar
* @param h Altura del bloque a copiar
* @return 1
* @see eDIV_MAP_PUT(), eDIV_MAP_XPUT()
*/
int eDIV_MAP_BLOCK_COPY(FUNCTION_PARAMS)
{
int f , g2 , x2 , y2 , g1 , x1 , y1 , w , h ;
SDL_Rect srcrect , dstrect ;
h = getparm() ;
w = getparm() ;
y1 = getparm() ;
x1 = getparm() ;
g1 = getparm() ;
y2 = getparm() ;
x2 = getparm() ;
g2 = getparm() ;
f = getparm() ;
srcrect.x = x1 ;
srcrect.y = y1 ;
srcrect.w = w ;
srcrect.h = h ;
dstrect.x = x2 ;
dstrect.y = y2 ;
dstrect.w = srcrect.w ;
dstrect.h = srcrect.h ;
if ( !files[f].existe || !files[f].mapa[g1].existe || !files[f].mapa[g2].existe )
return -1 ;
SDL_BlitSurface( files[f].mapa[g1].Surface , &srcrect , files[f].mapa[g2].Surface , &dstrect ) ;
return 1 ;
}
/*! \brief Obtiene el color del pixel, en las coordenadas (x,y), de un mapa.
* @param f Fichero (FPG) donde se encuentra el mapa
* @param g Código del gráfico dentro del FPG.
* @param x Coordenada X del pixel
* @param y Coordenada Y del pixel
* @return El color del píxel.
* @see eDIV_MAP_PUT_PIXEL(), eDIV_PUT_PIXEL(), eDIV_GET_PIXEL()
*/
int eDIV_MAP_GET_PIXEL(FUNCTION_PARAMS)
{
int f , g , x , y , bpp ;
Uint8 *p ;
y = getparm() ;
x = getparm() ;
g = getparm() ;
f = getparm() ;
if ( !files[f].existe || !files[f].mapa[g].existe )
return -1 ;
if ( x > files[f].mapa[g].Surface->w || y > files[f].mapa[g].Surface->h || x < 0 || y < 0 )
return -2 ;
bpp = files[f].mapa[g].Surface->format->BytesPerPixel;
p = (Uint8 *)files[f].mapa[g].Surface->pixels + y * files[f].mapa[g].Surface->pitch + x * bpp;
switch(bpp) {
case 1:
return *p;
case 2:
return *(Uint16 *)p;
case 3:
if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
{
return p[0] << 16 | p[1] << 8 | p[2];
}else
{
return p[0] | p[1] << 8 | p[2] << 16;
}
case 4:
return *(Uint32 *)p;
}
return 0;
}
/*! \brief Blitea un mapa dentro de otro mapa
*
* Esta función sólo permite operaciones en el mismo FPG.
* \todo ¿sobrecargar para permitir operaciones entre FPG's?
* @param f Fichero (FPG) donde se encuentran los dos mapas.
* @param g2 Gráfico de destino
* @param g1 Gráfico de origen
* @param x Coordenada X
* @param y Coordenada Y
* @return 1
* @see eDIV_MAP_BLOCK_COPY(), eDIV_XPUT()
*/
int eDIV_MAP_PUT(FUNCTION_PARAMS)
{
int f , g2 , g1 , x , y ;
SDL_Rect dstrect ;
y = getparm() ;
x = getparm() ;
g1 = getparm() ;
g2 = getparm() ;
f = getparm() ;
if ( !files[f].existe || !files[f].mapa[g1].existe || !files[f].mapa[g2].existe )
return -1 ;
dstrect.x = x ;
dstrect.y = y ;
dstrect.w = 0 ; /* Se ignora */
dstrect.h = 0 ; /* Se ignora */
SDL_BlitSurface( files[f].mapa[g1].Surface , NULL , files[f].mapa[g2].Surface , &dstrect ) ;
return 1 ;
}
/*! \brief Cambia el color de un píxel determinado de un mapa
* @param fichero Fichero (FPG) donde se encuentra el mapa
* @param grafico Código del mapa dentro del FPG
* @param x Coordenada X del píxel
* @param y Coordenada y del píxel
* @param color Color
* @return 1
* @see eDIV_MAP_GET_PIXEL(), eDIV_PUT_PIXEL(), eDIV_GET_PIXEL()
*/
int eDIV_MAP_PUT_PIXEL(FUNCTION_PARAMS)
{
int f , g , x , y , c , bpp ;
Uint8 *p ;
c = getparm() ;
y = getparm() ;
x = getparm() ;
g = getparm() ;
f = getparm() ;
if ( !files[f].existe || !files[0].mapa[g].existe )
return -1 ;
if ( x > files[f].mapa[g].Surface->w || y > files[f].mapa[g].Surface->h || x < 0 || y < 0 )
return -2 ;
if ( SDL_MUSTLOCK( files[f].mapa[g].Surface ) ) {
if ( SDL_LockSurface( files[f].mapa[g].Surface ) < 0 ) {
return -3;
}
}
bpp = files[f].mapa[g].Surface->format->BytesPerPixel ;
p = (Uint8 *)files[f].mapa[g].Surface->pixels + y * files[f].mapa[g].Surface->pitch + x * bpp ;
switch(bpp) {
case 1:
*p = c;
break;
case 2:
*(Uint16 *)p = c;
break;
case 3:
if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
p[0] = (c >> 16) & 0xff;
p[1] = (c >> 8) & 0xff;
p[2] = c & 0xff;
} else {
p[0] = c & 0xff;
p[1] = (c >> 8) & 0xff;
p[2] = (c >> 16) & 0xff;
}
break;
case 4:
*(Uint32 *)p = c;
break;
}
if ( SDL_MUSTLOCK( files[f].mapa[g].Surface ) ) {
SDL_UnlockSurface( files[f].mapa[g].Surface );
}
return 1 ;
}
/*! \brief Blitea un mapa sobre el buffer del fondo
* @param fichero Fichero (FPG) donde se encuentra el gráfico
* @param grafico Código del mapa dentro del FPG
* @param x Coordenada X destino
* @param y Coordenada Y destino
* @return 1
* @see eDIV_MAP_PUT(), eDIV_XPUT()
*/
int eDIV_PUT(FUNCTION_PARAMS)
{
int f , g , x , y ;
SDL_Rect dstrect ;
y = getparm() ;
x = getparm() ;
g = getparm() ;
f = getparm() ;
if ( !files[f].existe || !files[f].mapa[g].existe )
return -1 ;
dstrect.x = x - files[f].mapa[g].cpoint[0].x ;
dstrect.y = y - files[f].mapa[g].cpoint[0].y ;
dstrect.w = 0 ; /* Se ignora */
dstrect.h = 0 ; /* Se ignora */
SDL_BlitSurface( files[f].mapa[g].Surface , NULL , fondo , &dstrect ) ;
return 1 ;
}
/*! \brief Como eDIV_PUT() pero permitiendo indicar ángulo, tamaño y flags.
* \todo Falta soporte para flags. Revisar y añadir fp->Runtime_Error()
* @param fichero Fichero (FPG) donde se encuentra el gráfico
* @param grafico Código del mapa dentro del FPG
* @param x Coordenada X destino
* @param y Coordenada Y destino
* @param angle Ángulo (en milésimas de grado)
* @param zoom Tamaño (en porcentaje)
* @return 1 si se ha colocado correctamente, -1 si el mapa no existe.
* @see eDIV_PUT(), eDIV_MAP_XPUT(), eDIV_MAP_PUT()
*/
int eDIV_XPUT(FUNCTION_PARAMS)
{
int f , g , x , y ;
double zoom,angle;
SDL_Surface *map;
SDL_Rect dstrect ;
zoom = getparm();
angle = getparm();
y = getparm() ;
x = getparm() ;
g = getparm() ;
f = getparm() ;
if ( !files[f].existe || !files[f].mapa[g].existe )
return -1 ;
dstrect.x = x - files[f].mapa[g].cpoint[0].x ;
dstrect.y = y - files[f].mapa[g].cpoint[0].y ;
dstrect.w = 0 ; /* Se ignora */
dstrect.h = 0 ; /* Se ignora */
map=xput(files[f].mapa[g].Surface,zoom,angle);
SDL_BlitSurface(map , NULL , fondo , &dstrect ) ;
SDL_FreeSurface (map);
return 1 ;
}
/*! \brief Blitea un mapa sobre el buffer del fondo en la ESQUINA SUPERIOR IZQUIERDA de la pantalla
* @param fichero Fichero (FPG) donde se encuentra el gráfico
* @param grafico Código del mapa dentro del FPG
* @return 1
* @see eDIV_PUT(), eDIV_LOAD_SCREEN()
*/
int eDIV_PUT_SCREEN(FUNCTION_PARAMS)
{
int f , g ;
g = getparm() ;
f = getparm() ;
if ( !files[f].existe || !files[f].mapa[g].existe )
return -1 ;
SDL_BlitSurface( files[f].mapa[g].Surface , NULL , fondo , NULL ) ;
return 1 ;
}
/*! \brief Cambia el color del pixel, en las coordenadas (x,y), del fondo.
* @param x Coordenada X del pixel
* @param y Coordenada Y del pixel
* @param color Color
* @return 1
* @see eDIV_MAP_PUT_PIXEL(), eDIV_GET_PIXEL()
*/
int eDIV_PUT_PIXEL(FUNCTION_PARAMS)
{
int x , y , c , bpp ;
Uint8 *p ;
c = getparm() ;
y = getparm() ;
x = getparm() ;
if ( x > fondo->w || y > fondo->h || x < 0 || y < 0 )
return -1 ;
if ( SDL_MUSTLOCK(fondo) ) {
if ( SDL_LockSurface(fondo) < 0 ) {
return -2;
}
}
bpp = fondo->format->BytesPerPixel ;
p = (Uint8 *)fondo->pixels + y * fondo->pitch + x * bpp ;
switch(bpp) {
case 1:
*p = c;
break;
case 2:
*(Uint16 *)p = c;
break;
case 3:
if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
p[0] = (c >> 16) & 0xff;
p[1] = (c >> 8) & 0xff;
p[2] = c & 0xff;
} else {
p[0] = c & 0xff;
p[1] = (c >> 8) & 0xff;
p[2] = (c >> 16) & 0xff;
}
break;
case 4:
*(Uint32 *)p = c;
break;
}
if ( SDL_MUSTLOCK(fondo) ) {
SDL_UnlockSurface(fondo);
}
return 1 ;
}
/*! \brief Rellena el buffer del fondo con el color 0.
* @return 1
*/
int eDIV_CLEAR_SCREEN(FUNCTION_PARAMS)
{
SDL_FillRect( fondo , NULL , 0 ) ;
return 1;
}
/*! \brief Obtiene el color del pixel, en las coordenadas (x,y), del buffer del fondo.
* @param x Coordenada X del pixel
* @param y Coordenada Y del pixel
* @return El color del píxel.
* @see eDIV_PUT_PIXEL(), eDIV_MAP_GET_PIXEL()
*/
int eDIV_GET_PIXEL(FUNCTION_PARAMS)
{
int x , y , bpp;
Uint8 *p ;
y = getparm() ;
x = getparm() ;
if ( x > fondo->w || y > fondo->h || x < 0 || y < 0 )
return -1 ;
bpp = fondo->format->BytesPerPixel;
p = (Uint8 *)fondo->pixels + y * fondo->pitch + x * bpp;
switch(bpp) {
case 1:
return *p;
case 2:
return *(Uint16 *)p;
case 3:
if(SDL_BYTEORDER == SDL_BIG_ENDIAN)
{
return p[0] << 16 | p[1] << 8 | p[2];
}else
{
return p[0] | p[1] << 8 | p[2] << 16;
}
case 4:
return *(Uint32 *)p;
}
return 0;
}
/*! \brief Crea un nuevo mapa con las características indicadas.
*
* El nuevo mapa se creará en el fichero 0, como si se hubiera cargado con
* \link eDIV_LOAD_MAP() load_map() \endlink.
* @param w Anchura del mapa
* @param h Altura del mapa
* @param cx Coordenada X del centro del mapa
* @param cy Coordenada Y del centro del mapa
* @param c Color con el que se rellenará el nuevo mapa
* @return El código del nuevo gráfico, o -1 si ocurrió un error
* @see eDIV_LOAD_MAP(), eDIV_UNLOAD_MAP()
*/
int eDIV_NEW_MAP(FUNCTION_PARAMS)
{
int i ;
int w , h , cx , cy , c ;
c = getparm() ;
cy = getparm() ;
cx = getparm() ;
h = getparm() ;
w = getparm() ;
for ( i = 1000 ; i < files[0].num ; i++ )
{
if ( !files[0].mapa[i].existe )
{
files[0].mapa[i].Surface = SDL_CreateRGBSurface( SDL_HWSURFACE , w , h , screen->format->BitsPerPixel , 0xFF0000 , 0x00FF00 , 0x0000FF , 0x000000 ) ;
files[0].mapa[i].existe = 1 ;
files[0].mapa[i].cpoint[0].x = cx ;
files[0].mapa[i].cpoint[0].y = cy ;
SDL_FillRect( files[0].mapa[i].Surface , NULL , c ) ;
SDL_SetColorKey( files[0].mapa[i].Surface , SDL_SRCCOLORKEY | SDL_RLEACCEL , color_transparente ) ;
if ( i > last_map[0] )
last_map[0] = i ;
return i ;
}
}
return -1 ;
}
/*! \brief Copia una región de la pantalla en un mapa
* \todo La región copiada debe ESTIRARSE para adaptarse a la región destino
* @param r Región de la pantalla
* @param f Fichero del mapa destino
* @param g Gráfico destino
* @param x Coordenada X destino
* @param y Coordenada Y destino
* @param w Ancho de la región destino dentro del mapa
* @param h Alto de la región destino dentro del mapa
* @return 1
* @see eDIV_DEFINE_REGION(), eDIV_MAP_BLOCK_COPY()
*/
int eDIV_SCREEN_COPY(FUNCTION_PARAMS)
{
SDL_Rect srcrect , dstrect ;
int r, f, g , x, y , w , h ;
h = getparm() ;
w = getparm() ;
y = getparm() ;
x = getparm() ;
g = getparm() ;
f = getparm() ;
r = getparm() ;
if ( !files[f].existe || !files[f].mapa[g].existe )
return -1 ;
srcrect.x = 0 ;
srcrect.y = 0 ;
srcrect.w = w ;
srcrect.h = h ;
dstrect.x = x ;
dstrect.y = y ;
dstrect.w = 0 ;
dstrect.h = 0 ;
SDL_BlitSurface( screen, &srcrect , files[f].mapa[g].Surface , &dstrect ) ;
return 1 ;
}
/*! \brief Obtiene las coordenadas de un punto de control de un mapa
* @param f Fichero en el que se encuentra el mapa
* @param g Código del mapa dentro del FPG
* @param n Número del punto de control
* @param offset_x Offset de la variable donde guardar la coordenada X
* @param offset_y Offset de la variable donde guardar la coordenada Y
* @return 0 si todo va bien, -1 si el mapa no existe
* @see eDIV_GET_REAL_POINT()
*/
int eDIV_GET_POINT(FUNCTION_PARAMS)
{
int f , g , n , dx , dy ;
dy = getparm() ;
dx = getparm() ;
n = getparm() ;
g = getparm() ;
f = getparm() ;
if ( !files[f].existe || !files[f].mapa[g].existe )
return -1 ;
if(dx) fp->mem[ dx ] = files[f].mapa[g].cpoint[n].x ;
if(dy) fp->mem[ dy ] = files[f].mapa[g].cpoint[n].y ;
return 0 ;
}
/*! \brief Obtiene las coordenadas en pantalla de un punto de control del proceso actual
* \todo Tener en cuenta angle, size, etc
* @param n Número del punto de control
* @param offset_x Offset de la variable donde guardar la coordenada X
* @param offset_y Offset de la variable donde guardar la coordenada Y
* @return 0 si todo va bien, -1 si el mapa no existe
* @see eDIV_GET_POINT()
*/
int eDIV_GET_REAL_POINT(FUNCTION_PARAMS)
{
int f , g , n , dx , dy , x , y , id;
dy = getparm() ;
dx = getparm() ;
n = getparm() ;
id = fp->procs_s[ fp->proc_orden[ *fp->proceso_actual ] ].id;
f = local("file",id) ;
g = local("graph",id) ;
x = local("x",id) ;
y = local("y",id) ;
if ( !files[f].existe || !files[f].mapa[g].existe )
return -1 ;
if(dx) fp->mem[ dx ] = files[f].mapa[g].cpoint[n].x - files[f].mapa[g].cpoint[0].x + x ;
if(dy) fp->mem[ dy ] = files[f].mapa[g].cpoint[n].y - files[f].mapa[g].cpoint[0].y + y ;
return 0 ;
}
/*! \brief Obtiene información sobre un mapa
* @param f Fichero donde se encuentra el mapa
* @param g Código del gráfico dentro del FPG
* @param i Indica qué información quiere extraerse del mapa, puede ser uno de:
* \a g_wide (0), \a g_height (1), \a g_x_center (2) ó \a g_y_center (3).
* @return La información solicitada, o -1 si hubo un error.
* @see eDIV_GET_POINT()
*/
int eDIV_GRAPHIC_INFO(FUNCTION_PARAMS)
{
int f , g , i ;
i = getparm() ;
g = getparm() ;
f = getparm() ;
if ( !files[f].existe || !files[f].mapa[g].existe )
return -1 ;
switch (i)
{
case 0:
return files[f].mapa[g].Surface->w ;
case 1:
return files[f].mapa[g].Surface->h ;
case 2:
return files[f].mapa[g].cpoint[0].x ;
case 3:
return files[f].mapa[g].cpoint[0].y ;
}
return -1;
}

81
dlls/src/graphics/misc.c Normal file
View file

@ -0,0 +1,81 @@
/*! \file misc.c
* \brief Funciones varias
*/
#include <SDL/SDL.h>
#include "export.h"
#include "graphics.h"
#include "default_palette.h"
/*! \brief Cambia el modo de la pantalla
* \todo ¿más flags?
*
* Esta función permite distintas sintaxis:
* - Sintaxis de DIV2:
* @param modo Modo de pantalla indicado por una constante tipo mWWWxHHH ó por un identificador de video_modes[]
*
* - Sintaxis de eDIV:
* @param anchura Ancho de la nueva resolución
* @param altura Alto de la nueva resolución
* @param [bpp] Profundidad de color, puede ser 8, 16, 24 ó 32 (por defecto es 8)
* @param [flags] Flags de la ventana del juego, puede ser una combinación de:
* _fullscreen (1), ... ya veremos si añadimos más xD
* .
*
* @return 0
*/
int eDIV_SET_MODE(FUNCTION_PARAMS)
{
int modo;
switch(fp->num_params) {
case 4:
fp->graphics->flags=getparm();
case 3:
fp->graphics->bpp=getparm();
fp->graphics->alto=getparm();
fp->graphics->ancho=getparm();
break;
case 1:
modo=getparm();
if(modo>1280960) {
fp->graphics->ancho=modo/10000;
fp->graphics->alto=modo%10000;
}
else {
fp->graphics->ancho=modo/1000;
fp->graphics->alto=modo%1000;
}
fp->graphics->bpp=8;
fp->graphics->flags=0;
}
/* Esto avisa a las DLLs */
fp->graphics->resflags|=GR_CHANGED;
SDL_FreeSurface(fondo);
SDL_FreeSurface(screen);
screen=SDL_SetVideoMode(fp->graphics->ancho,fp->graphics->alto,fp->graphics->bpp,SDL_HWSURFACE|SDL_DOUBLEBUF|SDL_HWACCEL|((fp->graphics->flags&GR_FULLSCREEN)?SDL_FULLSCREEN:0)|((fp->graphics->bpp==8)?SDL_HWPALETTE:0));
fp->graphics->buffer=screen->pixels;
if(fp->graphics->bpp==8)
SDL_SetPalette(screen,SDL_LOGPAL|SDL_PHYSPAL,(SDL_Color*)default_palette,0,256);
if ( screen == NULL ) {
fp->Critical_Error(7); /* No se pudo inicializar SDL */
return 0;
}
fondo=SDL_CreateRGBSurface(SDL_HWSURFACE,fp->graphics->ancho,fp->graphics->alto,fp->graphics->bpp,0,0,0,0);
fp->graphics->background=fondo->pixels;
if(fp->graphics->bpp==8)
PaletteCopy(fondo,screen);
regions[0].w=fp->graphics->ancho;
regions[0].h=fp->graphics->alto;
return 0;
}

126
dlls/src/graphics/paleta.c Normal file
View file

@ -0,0 +1,126 @@
/*! \file paleta.c
* \brief Funciones relacionadas con el manejo de la paleta y los colores
*/
#include <SDL/SDL.h>
#include "export.h"
#include "graphics.h"
/*! \brief Cambia el color transparente (colorkey) actual
* @param a Color que desea usarse como transparente.
* @return El antiguo color transparente.
* @see color_transparente
*/
int eDIV_SET_TRANSPARENT_COLOR(FUNCTION_PARAMS)
{
int b , i;
int a = getparm() ;
b = color_transparente ;
color_transparente = a ;
for ( i = 1 ; i <= last_map[0] ; i++ )
{
if ( files[0].mapa[i].existe )
SDL_SetColorKey( files[0].mapa[i].Surface , SDL_SRCCOLORKEY | SDL_RLEACCEL , color_transparente ) ;
}
return b ;
}
/*! \brief Obtiene el color transparente actual
* @return El color transparente.
* @see color_transparente
*/
int eDIV_GET_TRANSPARENT_COLOR(FUNCTION_PARAMS)
{
return color_transparente ;
}
/*! \brief Crea un color a partir de las componentes RGB dadas.
*
* Esta función devuelve el color más próximo posible a las componentes RGB
* dadas. En modos de color paletizado (8 bits) puede devolver un color muy
* distinto al esperado si no se encuentra otro mejor en la paleta.
* Esta función difiere de \link eDIV_FIND_COLOR() find_color() \endlink en
* que recibe los parámetros en un rango de 0..255 en vez de 0..63.
* @param r Componente roja (red)
* @param g Componente verde (green)
* @param b Componente azul (blue)
* @return El color generado.
* @see eDIV_FIND_COLOR()
*/
int eDIV_RGB(FUNCTION_PARAMS)
{
int r,g,b ;
b = getparm() ;
g = getparm() ;
r = getparm() ;
return SDL_MapRGB(screen->format,r,g,b);
}
/*! \brief Crea un color a partir de las componentes RGB dadas.
*
* Esta función devuelve el color más próximo posible a las componentes RGB
* dadas. En modos de color paletizado (8 bits) puede devolver un color muy
* distinto al esperado si no se encuentra otro mejor en la paleta.
* Esta función difiere de \link eDIV_RGB() RGB() \endlink en que recibe los
* parámetros en un rango de 0..63 en vez de 0..255. Se ha incluido para
* mantener la compatibilidad con DIV2.
* @param r Componente roja (red)
* @param g Componente verde (green)
* @param b Componente azul (blue)
* @return El color generado.
* @see eDIV_RGB()
*/
int eDIV_FIND_COLOR(FUNCTION_PARAMS)
{
int r,g,b ;
b = getparm() ;
g = getparm() ;
r = getparm() ;
return SDL_MapRGB(screen->format,r*4,g*4,b*4);
}
/*! \brief Obtiene las componentes RGB de un color dado.
*
* Esta función recibe un color y almacena en las variables indicadas sus
* componentes RGB (siempre en un rango de 0..255). Si en lugar de un offset
* se recibe un 0, se ignorará esa componente.
* @param color Color del que se quiere obtener la información
* @param offset_r Offset de la variable donde se quiere guardar el valor de la componente roja (red)
* @param offset_g Offset de la variable donde se quiere guardar el valor de la componente verde (green)
* @param offset_b Offset de la variable donde se quiere guardar el valor de la componente azul (blue)
* @return 1
* @see eDIV_SET_COLOR()
*/
int eDIV_GET_RGB(FUNCTION_PARAMS)
{
unsigned int color,roff,goff,boff;
unsigned char r,g,b;
boff=getparm();
goff=getparm();
roff=getparm();
color=getparm();
SDL_GetRGB(color,screen->format,&r,&g,&b);
if(roff) fp->mem[roff]=(int)r;
if(goff) fp->mem[goff]=(int)g;
if(boff) fp->mem[boff]=(int)b;
return 1;
}
/*! \brief Hace un fundido de pantalla
*
* \todo ¡¡función sin acabar!!
*/
int eDIV_FADE(FUNCTION_PARAMS)
{
int r , g , b , v ;
v = getparm() ;
b = getparm() ;
g = getparm() ;
r = getparm() ;
return SDL_SetGamma( 1.0f , 1.0f , 1.0f ) ;
return 1 ;
}

71
dlls/src/graphics/regiones.c Normal file
View file

@ -0,0 +1,71 @@
/*! \file regiones.c
* \brief Funciones para manejo de regiones de pantalla
*/
#include <SDL/SDL.h>
#include "export.h"
#include "graphics.h"
/*! \brief Define una región de pantalla
* \todo Añadir un poco de comprobación de errores
* @param n Número de la región a definir (1..31)
* @param x Coordenada X de la esquina superior izquierda de la región
* @param y Coordenada Y de la esquina superior izquierda de la región
* @param w Anchura de la región
* @param h Altura de la región
* @return 1 si todo fue bien o 0 si hubo un error
* @see eDIV_OUT_REGION(), eDIV_SCREEN_COPY()
*/
int eDIV_DEFINE_REGION(FUNCTION_PARAMS)
{
int n , x , y , w , h ;
h = getparm() ;
w = getparm() ;
y = getparm() ;
x = getparm() ;
n = getparm() ;
if ( n > 31 || n < 1 ) {
fp->Runtime_Error(108); /* nº de región inválido */
return 0;
}
fp->regions[n].x = x ;
fp->regions[n].y = y ;
fp->regions[n].w = w ;
fp->regions[n].h = h ;
return 1 ;
}
/*! \brief Indica si un proceso está fuera de la región indicada
* @param id Identificador del proceso
* @param r Región
* @return 1 si el proceso está fuera de la región o 0 en caso contrario
* @see eDIV_DEFINE_REGION()
*/
int eDIV_OUT_REGION(FUNCTION_PARAMS)
{
int id , r ;
int f, g , x , y ;
r = getparm() ;
id = getparm() ;
f = local("file",id) ;
g = local("graph",id) ;
if ( !files[f].existe || !files[f].mapa[g].existe )
return -1 ;
x = local("x",id) ;
y = local("y",id) ;
if ( x < fp->regions[r].x + fp->regions[r].w && x + files[f].mapa[g].Surface->w > fp->regions[r].x &&
y < fp->regions[r].y + fp->regions[r].h && y + files[f].mapa[g].Surface->h > fp->regions[r].y )
return 0 ;
else
return 1 ;
}

24
dlls/src/graphics/win32/graphics.vcproj
View file

@ -123,9 +123,33 @@
<File <File
RelativePath="..\SDL_rotozoom.c"> RelativePath="..\SDL_rotozoom.c">
</File> </File>
<File
RelativePath="..\advance.c">
</File>
<File
RelativePath="..\carga.c">
</File>
<File
RelativePath="..\collision.c">
</File>
<File
RelativePath="..\draw.c">
</File>
<File <File
RelativePath="..\graphics.c"> RelativePath="..\graphics.c">
</File> </File>
<File
RelativePath="..\map_ops.c">
</File>
<File
RelativePath="..\misc.c">
</File>
<File
RelativePath="..\paleta.c">
</File>
<File
RelativePath="..\regiones.c">
</File>
</Filter> </Filter>
<Filter <Filter
Name="cabeceras" Name="cabeceras"

85
dlls/src/include/export.h
View file

@ -1,8 +1,7 @@
/* /*
* eDiv Compiler * eDIV Compiler
* Copyleft (C) 2000-2002 Sion Entertainment * Copyleft (C) 2000-2003 Sion Ltd.
* http://www.sion-e.com * http://www.sionhq.com
* *
* This program is free software; you can redistribute it and/or modify * This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by * it under the terms of the GNU General Public License as published by
@ -28,6 +27,13 @@
* notifíquelo a Sion Entertainment en bugs@edivcentral.com * notifíquelo a Sion Entertainment en bugs@edivcentral.com
*/ */
/*! \file export.h
* \brief Cabecera del SDK para DLL's de eDIV
*/
/*! \defgroup sdk SDK
* @{
*/
#ifndef __EDIV_EXPORT_H_ #ifndef __EDIV_EXPORT_H_
#define __EDIV_EXPORT_H_ #define __EDIV_EXPORT_H_
@ -46,13 +52,18 @@ extern "C" {
#endif #endif
/* VARINDEX */ /* VARINDEX */
/*! \defgroup varindex Acceso a variables indexadas */
/*! @{ */
/*! Para usar con las funciones o macros de acceso a variables indexadas */
typedef enum { v_global, v_reserved, v_local } tipo_t; typedef enum { v_global, v_reserved, v_local } tipo_t;
/*! Estructura de variables indexadas */
typedef struct { typedef struct {
unsigned char hash; unsigned char hash; /*!< Hash del nombre de la variable, para acelerar su búsqueda */
tipo_t tipo; tipo_t tipo; /*!< Tipo de variable (global, reservada o local) */
char* nombre; char* nombre; /*!< Nombre de la variable */
int offset; int offset; /*!< offset en mem[] (relativo al proceso si es local o reservada) */
} varindex_t; } varindex_t;
#define global(nombre) fp->mem[fp->GetVarOffset(v_global,nombre)] #define global(nombre) fp->mem[fp->GetVarOffset(v_global,nombre)]
@ -61,6 +72,8 @@ typedef struct {
#define globalptr(nombre) fp->GetVarOffset(v_global,nombre) #define globalptr(nombre) fp->GetVarOffset(v_global,nombre)
#define reservedptr(nombre) fp->GetVarOffset(v_reserved,nombre) #define reservedptr(nombre) fp->GetVarOffset(v_reserved,nombre)
#define localptr(nombre) fp->GetVarOffset(v_local,nombre) #define localptr(nombre) fp->GetVarOffset(v_local,nombre)
/*! @} */
/* FIN DE VARINDEX */ /* FIN DE VARINDEX */
@ -89,22 +102,23 @@ typedef int (TYPEOF_Call_Entrypoint)(int ep, ...);
typedef int (TYPEOF_Dibuja)(SDL_Surface *, SDL_Rect, SDL_Rect, int, int, int, int); typedef int (TYPEOF_Dibuja)(SDL_Surface *, SDL_Rect, SDL_Rect, int, int, int, int);
/* Errores */ /* Errores */
typedef enum { /* Tipos de error para custom_error() */ /*! Tipos de error para custom_error() */
_runtime_error=1, typedef enum {
_critical_error=2 _runtime_error=1, /*!< Error normal (se puede depurar y/o ignorar) */
_critical_error=2 /*!< Error crítico (interrumpe obligatoriamente el programa) */
} tipoerror; } tipoerror;
typedef void (TYPEOF_Runtime_Error)(int, ...); typedef void (TYPEOF_Runtime_Error)(int, ...);
typedef void (TYPEOF_Critical_Error)(int, ...); typedef void (TYPEOF_Critical_Error)(int, ...);
typedef void (TYPEOF_Custom_Error)(tipoerror,char*); typedef void (TYPEOF_Custom_Error)(tipoerror,char*);
/* Obtiene offset de variable indexada dinámicamente */ /*! Obtiene offset de variable indexada dinámicamente */
typedef int (TYPEOF_GetVarOffset)(tipo_t tipo,char* nombre); typedef int (TYPEOF_GetVarOffset)(tipo_t tipo,char* nombre);
/* Finaliza el stub (exit) */ /*! Finaliza el stub (exit) */
typedef void (TYPEOF_Stub_Quit)(int n); typedef void (TYPEOF_Stub_Quit)(int n);
/* EXPORTAFUNCS_PARAMS deben usarse como parámetros para ExportaFuncs */ /*! EXPORTAFUNCS_PARAMS deben usarse como parámetros para ExportaFuncs */
#define EXPORTAFUNCS_PARAMS \ #define EXPORTAFUNCS_PARAMS \
TYPEOF_EDIV_Export *EDIV_Export ,\ TYPEOF_EDIV_Export *EDIV_Export ,\
TYPEOF_EDIV_Export_Const *EDIV_Export_Const ,\ TYPEOF_EDIV_Export_Const *EDIV_Export_Const ,\
@ -130,8 +144,10 @@ TYPEOF_EDIV_Export_Priority *EDIV_Export_Priority
* a las correspondientes rutinas de las dll's, ordenadas por prioridad) * a las correspondientes rutinas de las dll's, ordenadas por prioridad)
*/ */
// Constantes para EDIV_Export_Entrypoint /* Constantes para EDIV_Export_Entrypoint */
/*! \defgroup entrypoints Entrypoints */
/*! @{ */
#define EDIV_set_video_mode 1 /* Al activar un nuevo modo de vídeo */ #define EDIV_set_video_mode 1 /* Al activar un nuevo modo de vídeo */
#define EDIV_process_palette 2 /* Al cargar una paleta */ #define EDIV_process_palette 2 /* Al cargar una paleta */
#define EDIV_process_active_palette 3 /* Al modificar la paleta activa (usada en los fades) */ #define EDIV_process_active_palette 3 /* Al modificar la paleta activa (usada en los fades) */
@ -155,7 +171,7 @@ TYPEOF_EDIV_Export_Priority *EDIV_Export_Priority
#define EDIV_debug 21 /* Invocar al trazador - sentencia debug (solo en debug) */ #define EDIV_debug 21 /* Invocar al trazador - sentencia debug (solo en debug) */
#define EDIV_first_load 22 /* Se ejecuta al cargar la DLL en ejecucion */ #define EDIV_first_load 22 /* Se ejecuta al cargar la DLL en ejecucion */
#define EDIV_quit 23 /* Llamado por stub_quit() */ #define EDIV_quit 23 /* Llamado por stub_quit() */
/*! @} */
/* #defines para que la declaración de datos sea un poco más BASIC... :p */ /* #defines para que la declaración de datos sea un poco más BASIC... :p */
#ifdef CONST #ifdef CONST
@ -176,13 +192,13 @@ TYPEOF_EDIV_Export_Priority *EDIV_Export_Priority
#define ENTRYPOINT(e) EDIV_Export_Entrypoint(EDIV_##e,e) #define ENTRYPOINT(e) EDIV_Export_Entrypoint(EDIV_##e,e)
#define PRIORITY EDIV_Export_Priority #define PRIORITY EDIV_Export_Priority
/*!
/*
* FUNCTION_PARAMS deben usarse como parametros para TODAS las funciones * FUNCTION_PARAMS deben usarse como parametros para TODAS las funciones
* ¡ojo! debe ser igual en extern.h * ¡OJO! debe ser igual en extern.h
*/ */
#define FUNCTION_PARAMS struct _fun_params * fp #define FUNCTION_PARAMS struct _fun_params * fp
/*! Estructura de una entrada de la tabla de procesos */
struct _procs_s{ struct _procs_s{
int id ; /* offset de los datos locales del proceso */ int id ; /* offset de los datos locales del proceso */
int tipo ; /* tipo de proceso */ int tipo ; /* tipo de proceso */
@ -194,15 +210,18 @@ struct _procs_s{
int graph ; int graph ;
}; };
struct _regions /*! Estructura de una región de pantalla */
{ struct _regions {
int x , y , w , h ; int x , y , w , h ;
}; };
/*! Permite asegurarnos de que ciertos recursos están cargados */
struct _existe { struct _existe {
int regions ; int regions ;
int dibuja ; int dibuja ;
}; };
/*! Mapa dentro de un FPG */
struct _file struct _file
{ {
SDL_Surface *Surface; SDL_Surface *Surface;
@ -215,6 +234,7 @@ struct _file
} cpoint[ 20 ] ; } cpoint[ 20 ] ;
}; };
/*! Vector de FPG's */
struct _files struct _files
{ {
int num ; int num ;
@ -222,6 +242,13 @@ struct _files
struct _file *mapa ; struct _file *mapa ;
}; };
/*! Datos de la paleta en la estructura _graphics */
struct _palette {
byte r,g,b;
byte unused;
};
/*! Estructura graphics, permite acceder a la pantalla */
typedef struct { typedef struct {
int ancho; int ancho;
int alto; int alto;
@ -230,8 +257,11 @@ typedef struct {
int resflags; int resflags;
byte* buffer; byte* buffer;
byte* background; byte* background;
struct _palette* palette;
struct _palette* activepal;
} _graphics; } _graphics;
/*! Parámetros para las funciones exportadas */
struct _fun_params{ struct _fun_params{
int *pila ; int *pila ;
int *sp ; int *sp ;
@ -265,6 +295,9 @@ struct _fun_params{
#define GR_ACTIVE 0x01 #define GR_ACTIVE 0x01
#define GR_CHANGED 0x02 #define GR_CHANGED 0x02
/* Valores para PRIORITY() */
#define P_SIEMPRE 512
#define P_NUNCA -512
/* Se usa igual que el getparm() de DIV */ /* Se usa igual que el getparm() de DIV */
#define getparm() fp->pila[(*fp->sp)--] #define getparm() fp->pila[(*fp->sp)--]
@ -274,7 +307,12 @@ struct _fun_params{
#define retval(a) return (a) #define retval(a) return (a)
/* Prototipos de los entrypoints */ /*
* Prototipos de los entrypoints
*/
/*! \addtogroup entrypoints */
/*! @{ */
void set_video_mode(void); void set_video_mode(void);
void process_palette(void); void process_palette(void);
void process_active_palette(void); void process_active_palette(void);
@ -299,9 +337,12 @@ void trace(int imem, char* nombreprg, int* lin, void* dbg);
void debug(int imem, char* nombreprg, int* lin, void* dbg); void debug(int imem, char* nombreprg, int* lin, void* dbg);
void first_load(FUNCTION_PARAMS) ; void first_load(FUNCTION_PARAMS) ;
void quit(void); void quit(void);
/*! @} */
#ifdef __cplusplus #ifdef __cplusplus
} }
#endif #endif
#endif /* __EDIV_EXPORT_H_ */ #endif /* __EDIV_EXPORT_H_ */
/*! @} */