gfx.c

/*=========================================================================

GFX - a small graphics library 

Copyright (C) 2004  Rafael de Oliveira Jannone

This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.

This library 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
Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

Contact the author:
        by e-mail : rafael AT jannone DOT org
        homepage  : http://jannone.org/gfxlib
        ICQ UIN   : 10115284

See the License at http://www.gnu.org/copyleft/lesser.txt

=========================================================================*/

// GFX.C : main library functions

/* === WARNING ==

        This is a work-in-progress, meaning that most of this code is unstable
        and it's subject to future changes.  Also, most of it is very hackish,
        not properly cleaned up nor tested.

   === WARNING == */

#include "gfx.h"

// do a interslot call to BIOS

#asm

psect text

;callbios: ld (callbios0), ix
;       defb 0CDh
;callbios0:
;       defw 0000h
;       ret

callbios:
        ld      (callbios1), ix
        rst     030h
callbios0:
        defb    0
callbios1:
        defw    0
        ret

psect data
global _st_dir
_st_dir:
        defb 0000B ; 0
        defb 0001B ; 1
        defb 0011B ; 2
        defb 0010B ; 3
        defb 0110B ; 4
        defb 0100B ; 5
        defb 1100B ; 6
        defb 1000B ; 7
        defb 1001B ; 8

#endasm

static int rnd = 0;

void seed_rnd(int seed) {
        rnd = seed;
}

u_char get_rnd() {
        rnd = ((rnd + 1) & 0x0FFF);
        return *(u_char*)rnd;
}

void init() {
#asm
        ;in a, (0A8h)
        ;and 0FCh
        ;out (0A8h), a
#endasm
}

/*

// this is not currently compiling... must investigate

void *set_sprite(u_char, void*);
void *put_sprite(u_char, int, int, u_char, u_char);

void _init_sprites() {
        u_char m = get_vdp(1);
        if (m & sprite_large) {
                set_sprite = set_sprite_16;
                put_sprite = put_sprite_16;
        } else {
                set_sprite = set_sprite_8;
                put_sprite = put_sprite_8;
        }
}
*/
#define _init_sprites()

void set_vdp(u_char reg, u_char value) {
#asm
        f_wrtvdp equ 047h

        push bc
        push ix

        ld c, (ix+6)
        ld b, (ix+8)

        ld ix, f_wrtvdp
        call callbios
        
        pop ix
        pop bc
#endasm
}

u_char get_vdp(u_char reg) {
        return *(u_char*)(0xF3DF + reg);
}

void set_mode(u_int mode) {
#asm
        push bc
        push ix
        ld c, (ix+6)
        ld b, (ix+7)
        push bc
        pop ix
        call callbios
        pop ix
        pop bc
#endasm
        _init_sprites();
}

void set_mangled_mode() {
        set_mode(mode_1);
        set_mode(0x7E);
        vwrite((void*)0x1BBF, 0x0800, 0x800);   
        vwrite((void*)0x1BBF, 0x1000, 0x800);   
        fill(MODE2_ATTR, 0xF0, 0x17FF);
        fill(0xFF8, 0xFF, 8);
        fill(0x17F8, 0xFF, 8);

        _init_sprites();
}

void set_color(u_char front, u_char back, u_char border) {
        *(u_char*)0xf3e9 = front;
        *(u_char*)0xf3ea = back;
        *(u_char*)0xf3eb = border;
#asm
        f_chgclr equ 062h

        push ix
        ld ix, f_chgclr
        call callbios
        pop ix  
#endasm
}

void fill(u_int addr, u_char value, u_int count) {
#asm
        f_filvrm equ 056h

        push hl
        push bc
        push ix

        ld l, (ix+6)
        ld h, (ix+7)
        ld c, (ix+10)
        ld b, (ix+11)
        ld a, (ix+8)

        ld ix, f_filvrm
        call callbios
        pop ix
        pop bc
        pop hl
#endasm
}

void vpoke(u_int addr, u_char value) {
#asm
        f_wrtvrm equ 04Dh

        ;push hl
        ;push ix

        ;ld l, (ix+6)
        ;ld h, (ix+7)
        ;ld a, (ix+8)
        
        ;ld ix, f_wrtvrm
        ;call callbios

        ;pop ix
        ;pop hl

        p_vdp_data equ 098H
        p_vdp_cmd  equ 099H

        ; enter vdp address pointer

        ld a, (ix+6)
        di
        out (p_vdp_cmd), a
        ld a, (ix+7)
        and 00111111B
        or  01000000B
        ei
        out (p_vdp_cmd), a

        ; enter data

        ld a, (ix+8)
        out (p_vdp_data), a
                
#endasm
}

u_char vpeek(u_int addr) {
#asm
        f_rdvrm equ 04Ah

        ;push hl
        ;push ix
        ;ld l, (ix+6)
        ;ld h, (ix+7)
        ;ld ix, f_rdvrm
        ;call callbios
        ;pop ix
        ;pop hl
        ;ld l, a

        ; enter vdp address pointer

        ld a, (ix+6)
        di
        out (p_vdp_cmd), a
        ld a, (ix+7)
        and 00111111B
        ei
        out (p_vdp_cmd), a

        ; read data

        in a, (p_vdp_data)
        ld l, a
#endasm
}

void vmerge(u_int addr, u_char value) {
#asm
        ;f_wrtvrm equ 04Dh
        ;f_rdvrm equ 04Ah

        ;push hl
        ;push ix

        ;ld l, (ix+6)
        ;ld h, (ix+7)
        ;ld ix, f_rdvrm
        ;call callbios

        ;pop ix
        ;push ix

        ;or (ix+8)
        ;ld ix, f_wrtvrm
        ;call callbios

        ;pop ix
        ;pop hl

        ; enter vdp address pointer

        ld l, (ix+6)
        ld h, (ix+7)
        ld c, p_vdp_cmd
        ld b, c

        di
        out (c), l
        ld a, h
        and 00111111B
        ei
        out (c), a

        ; read data

        ld c, p_vdp_data
        in h, (c)
        ld c, b

        ; enter same address

        di
        out (c), l
        or  01000000B
        ei
        out (c), a

        ld a, (ix+8)
        out (p_vdp_data), a
#endasm
}

void vwrite(void *source, u_int dest, u_int count) {
#asm
        f_ldirvm equ 05Ch

        push hl
        push bc
        push de
        push ix

        ld l, (ix+6)
        ld h, (ix+7)
        ld e, (ix+8)
        ld d, (ix+9)
        ld c, (ix+10)
        ld b, (ix+11)

        ld ix, f_ldirvm
        call callbios

        pop ix
        pop de
        pop bc
        pop hl
#endasm
}

void vread(u_int source, void* dest, u_int count) {
#asm
        f_ldirmv equ 056h

        push hl
        push bc
        push de
        push ix

        ld l, (ix+6)
        ld h, (ix+7)
        ld e, (ix+8)
        ld d, (ix+9)
        ld c, (ix+10)
        ld b, (ix+11)

        ld ix, f_ldirmv
        call callbios

        pop ix
        pop de
        pop bc
        pop hl
#endasm
}

void locate(u_char x, u_char y) {
#asm
        f_posit equ 0C6h
        
        push hl
        push ix

        ld h, (ix+6)
        ld l, (ix+8)
        
        ld ix, f_posit
        call callbios

        pop ix
        pop hl
#endasm
}

void pset(int x, int y) {
        vmerge(map_pixel(x,y), map_subpixel(x));
}

void set_char_form(char c, void* form, u_char place) {
        u_int addr = c;
        addr <<= 3;
        if (place & place_1) vwrite(form, addr, 8);
        if (place & place_2) vwrite(form, (256 * 8) + addr, 8);
        if (place & place_3) vwrite(form, (256 * 8 * 2) + addr, 8);
}

void set_char_attr(char c, void *attr, u_char place) {
        u_int addr = c;
        addr <<= 3;
        addr += MODE2_ATTR;

        if (place & place_1) vwrite(attr, addr, 8);
        if (place & place_2) vwrite(attr, (256 * 8) + addr, 8);
        if (place & place_3) vwrite(attr, (256 * 8 * 2) + addr, 8);
}

void set_char_color(char c, u_char color, u_char place) {
        u_int addr = c;
        addr <<= 3;
        addr += MODE2_ATTR;

        if (place & place_1) fill(addr, color, 8);
        if (place & place_2) fill((256 * 8) + addr, color, 8);
        if (place & place_3) fill((256 * 8 * 2) + addr, color, 8);
}

void set_char(char c, void* form, void *attr, u_char color, u_char place) {
        set_char_form(c, form, place);
        if (attr)
                set_char_attr(c, attr, place);
        else
                set_char_color(c, color, place);
}

void fill_v(u_int addr, u_char value, u_char count) {
        u_char diff;

        diff = addr & 7;
        if (diff) {
                diff = 8 - diff;
                if (diff > count)
                        diff = count;
                fill(addr, value, diff);
                addr = (addr & ~(7)) + 256;
                count -= diff;
        }

        diff = count >> 3;
        while (diff--) {
                fill(addr, value, 8);
                addr += 256;
                count -= 8;     
        }

        if (count > 0)
                fill(addr, value, count);

}

u_char get_stick(u_char id) {
#asm
        f_gtstck equ 0D5h

        push hl
        push de
        push bc
        push ix

        ld a, (ix+6)
        ld ix, f_gtstck
        call callbios

        pop ix
        pop bc
        pop de
        pop hl
        
        ld l, a
#endasm
}

bool get_trigger(u_char id) {
#asm
        f_gttrig equ 0D8h

        push ix
        ld a, (ix+6)

        ld ix, f_gttrig
        call callbios
        pop ix
        ld l, a 
#endasm
}

void set_sprite_mode(u_char mode) {
        u_char m = get_vdp(1);
        set_vdp(1, (m & 0xFC) | mode);

        _init_sprites();
}

void set_sprite_8(u_char handle, void* data) {
        vwrite(data, 14336 + (handle << 3), 8);
}

void set_sprite_16(u_char handle, void* data) {
        vwrite(data, 14336 + (handle << 5), 32);
}

void put_sprite_8(u_char id, int x, int y, u_char handle, u_char color) {
        sprite_t sp;
        if (x < 0) {
                x += 32;
                color |= 128;
        }
        sp.y = y - 1;
        sp.x = x;
        sp.handle = handle;
        sp.color = color;
        vwrite(&sp, 6912 + (id << 2), 4);
}

void put_sprite_16(u_char id, int x, int y, u_char handle, u_char color) {
        sprite_t sp;
        if (x < 0) {
                x += 32;
                color |= 128;
        }
        sp.y = y - 1;
        sp.x = x;
        sp.handle = (handle << 2);
        sp.color = color;
        vwrite(&sp, 6912 + (id << 2), 4);
}

void blit_ram_vram(u_char* source, u_int dest, u_char w, u_char h, int sjmp, int djmp) {
        while (h--) {
                vwrite(source, dest, w);
                source += sjmp;
                dest += djmp;           
        }
}

void blit_fill_vram(u_int dest, u_char value, u_char w, u_char h, int djmp) {
        while (h--) {
                fill(dest, value, w);
                dest += djmp;           
        }
}

/* unfinished
void blit_ram_vram(surface_t *source, surface_t *dest, rect_t *from, rect_t *to) {

        int s_jmp, d_jmp, h;
        u_char* s_addr;
        u_int   d_addr;

        s_jmp = source->width - from->width;
        d_jmp = dest->width - from->width;
        h = from->height;

        s_addr = 0; // ?
        d_addr = 0; // ?
}

void blit(surface_t *source, surface_t *dest, rect_t *from, rect_t *to) {
        // one can always dream :)      
}

*/

void psg_init() {
#asm
        f_gicini equ 090h

        push ix
        ld ix, f_gicini
        call callbios
        pop ix
#endasm
}

void psg_set(u_char reg, u_char value) {
#asm
        f_wrtpsg equ 093h

        push de
        push ix
        ld a, (ix + 8)
        ld e, a
        ld a, (ix + 6)
        ld ix, f_wrtpsg
        call callbios
        pop ix
        pop de
#endasm
}

u_char psg_get(u_char reg) {
#asm
        f_rdpsg equ 096h

        push ix
        ld a, (ix + 6)
        ld ix, f_rdpsg
        call callbios
        pop ix
#endasm
}

void psg_tone(u_char channel, int period) {
        channel <<= 1;
        psg_set(channel, period & 255);
        psg_set(channel + 1, period >> 8);
}

void psg_noise(u_char period) {
        psg_set(6, period & 31);
}

void psg_volume(u_char channel, u_char volume) {
        psg_set(channel + 8, volume & 15);
}

void psg_envelope(u_char waveform, int period, u_char channels) {
        psg_set(13, waveform);
        psg_set(11, period & 255);
        psg_set(12, period >> 8);
        if (channels & 1)
                psg_set(8, 16);
        if (channels & 2)
                psg_set(9, 16);
        if (channels & 4)
                psg_set(10, 16);
        // FIXME: perhaps we should mute all others?
}

void psg_channels(u_char tone_channels, u_char noise_channels) {
        psg_set(7, (tone_channels << 3) | noise_channels);
}

u_char psg_noise_channels() {
        return psg_get(7) & 7;
}

u_char psg_tone_channels() {
        return (psg_get(7) >> 3) & 7;
}

---