d_font_t *d_font_load(char *filename)
{
d_font_t *fnt;
d_file_t *fp;
fnt = d_memory_new(sizeof(d_font_t));
if(fnt == NULL) return NULL;
fp = d_file_open(filename);
if(fp == NULL) return NULL;
if(d_file_getbyte(fp) != 'F' ||
d_file_getbyte(fp) != 'N' ||
d_file_getbyte(fp) != 'T') {
d_error_push("d_font_load: bad magic.");
return NULL;
}
switch(d_file_getbyte(fp)) {
case 0: /* version 0 -- bitmapped font */
if(loadv0font(fp, fnt) != success)
return NULL;
break;
default:
d_error_push("d_font_load: unsupported font version.");
return NULL;
}
d_file_close(fp);
return fnt;
}
d_rasterdescription_t *d_raster_getmodes(int *nmodes)
{
d_rasterdescription_t *modes;
vga_modeinfo *minf;
int i;
modes = NULL;
*nmodes = 0;
for(i = 1; i < vga_lastmodenumber(); i++) {
if(vga_hasmode(i) == 0) continue;
(*nmodes)++;
modes = d_memory_resize(modes, *nmodes*sizeof(d_rasterdescription_t));
if(modes == NULL) {
d_error_push("d_raster_getmodes: d_memory_resize failed.");
return NULL;
}
minf = vga_getmodeinfo(i);
modes[*nmodes-1].w = minf->width;
modes[*nmodes-1].h = minf->height;
modes[*nmodes-1].bpp = log2(minf->colors);
modes[*nmodes-1].alpha = 0;
if(modes[*nmodes-1].bpp == 8)
modes[*nmodes-1].paletted = true;
else
modes[*nmodes-1].paletted = false;
modes[*nmodes-1].cspace = RGB;
}
return modes;
}
bool d_raster_setmode(d_rasterdescription_t mode)
{
vga_modeinfo *minf;
int i, ret;
if(mode.cspace == grayscale) {
d_error_push(__FUNCTION__": grayscale modes are not supported "
"with this driver.");
return failure;
}
for(i = 1; i < vga_lastmodenumber(); i++) {
if(vga_hasmode(i) == 0) continue;
minf = vga_getmodeinfo(i);
if(minf->width == mode.w &&
minf->height == mode.h &&
minf->colors == 1<<mode.bpp) {
ret = vga_setmode(i);
if(ret != 0) {
d_error_push(__FUNCTION__": vga_setmode failed.");
return failure;
}
raster_curmode = mode;
if(raster_vbuf != NULL)
d_memory_delete(raster_vbuf);
raster_vbuf = d_memory_new((mode.w*mode.h*mode.bpp+7)/8);
if(raster_vbuf == NULL) {
d_error_push(__FUNCTION__": memory allocation failed for "
"raster_vbuf.");
return failure;
}
return success;
}
}
d_error_push(__FUNCTION__": no such mode available.");
return failure;
}
bool d_raster_new(void)
{
int ret;
ret = vga_init();
if(ret != 0) {
d_error_push(__FUNCTION__": vga_init failed.");
return failure;
}
raster_vbuf = NULL;
return success;
}
void d_sprite_setcuranim(d_sprite_t *p_, word curanim)
{
sprite_t *p;
p = p_;
MAGICCHECK(p, /* void */);
if(curanim >= p->nanims) {
d_error_push("invalid animation.");
return;
}
if(curanim != p->curanim)
p->curframe = 0;
p->curanim = curanim;
p->looped = false;
return;
}
void d_sprite_addframe(d_sprite_t *p_, int anim, d_image_t *frame)
{
sprite_t *p;
p = p_;
MAGICCHECK(p, /* void */);
if(anim >= p->nanims) {
d_error_push("invalid animation.");
return;
}
p->nframes[anim]++;
p->frames[anim] = d_memory_resize(p->frames[anim],
p->nframes[anim]*sizeof(d_image_t *));
p->frames[anim][p->nframes[anim]-1] = frame;
return;
}
d_sprite_t *d_sprite_new(void)
{
sprite_t *p;
p = d_memory_new(sizeof(sprite_t));
if(p == NULL) {
d_error_push("failed to allocate sprite structure.");
return NULL;
}
p->magic = SPRITEMAGIC;
p->curanim = 0;
p->curframe = 0;
p->framelag = 1;
p->nanims = 0;
p->frames = NULL;
p->nframes = NULL;
p->looped = false;
return (d_sprite_t *)p;
}
dword d_set_getunusedkey(d_set_t *p_)
{
set_t *p = (set_t *)p_;
int i;
CHECKMAGIC(p, D_SET_INVALIDKEY);
for(i = 0; i < p->tablesize; i++)
if(chainfind(p->elements[hash(p, i)], i) == failure)
return i;
/* There are no valid keys remaining without collisions.
Try and find some key. FIXME: This should try and find
a key which hashes to the least-deep bucket. */
for(; i < D_SET_INVALIDKEY; i++)
if(chainfind(p->elements[hash(p, i)], i) == failure)
return i;
d_error_push("d_set_getunusedkey: no free keyspace exists.");
return D_SET_INVALIDKEY;
}
