gfx.h

Go to the documentation of this file.

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

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.H : main library functions (header)

/* === 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 == */

#ifndef GFX_H
#define GFX_H

#include "defs.h"

// --- library functions / enums



enum video_mode {
        mode_0 = 0x6C,
        mode_1 = 0x6F,
        mode_2 = 0x72,
        mode_3 = 0x75
};

enum screen_map {
        place_1 = 1,
        place_2 = 2,
        place_3 = 4,
        place_all = 255
};

#define MODE2_MAX       (256 * 24)

#define MODE2_ATTR      (8192)

#define MODE2_WIDTH     256

#define MODE2_HEIGHT    192

// VDP and VRAM functions

extern void set_mode(u_int mode);

extern void set_mangled_mode();

extern void set_color(u_char front, u_char back, u_char border);

extern void fill(u_int addr, u_char value, u_int count);

extern void vpoke(u_int addr, u_char value);

extern u_char vpeek(u_int addr);

extern void vmerge(u_int addr, u_char value);

extern void vwrite(void* source, u_int dest, u_int count);

extern void vread(u_int source, void* dest, u_int count);

extern void set_vdp(u_char reg, u_char value);

extern u_char get_vdp(u_char reg);

extern void locate(u_char x, u_char y);


// primitives (not many yet :))

extern void fill_v(u_int addr, u_char value, u_char count);

extern void pset(int x, int y);


// mangled mode chars

void set_char_form(char c, void* form, u_char place);

void set_char_attr(char c, void *attr, u_char place);

void set_char_color(char c, u_char color, u_char place);

// set char \a c shape, attributes and color, all in one
void set_char(char c, void* form, void *attr, u_char color, u_char place);





typedef struct {
        u_char y;       
        u_char x;       
        u_char handle;  
        u_char color;   
} sprite_t;

enum sprite_mode {
        sprite_default = 0,
        sprite_scaled = 1,
        sprite_large = 2
};

extern void set_sprite_mode(u_char mode);

/*

// this is not compiling... I suggest some #define's instead

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

extern void set_sprite_8(u_char handle, void* data);

extern void set_sprite_16(u_char handle, void* data);

extern void put_sprite_8(u_char id, int x, int y, u_char handle, u_char color);

extern void put_sprite_16(u_char id, int x, int y, u_char handle, u_char color);



// surface
// FIXME: this is not usable right now

typedef struct {
        int width;
        int height;
        int type;
        union {
                u_char* ram;    
                u_int vram;
        } data;
} surface_t;

enum surface_type {
        surface_ram,
        surface_vram    
};

typedef struct {
        int x, y;
        int width, height;
} rect_t; 

extern void blit(surface_t *source, surface_t *dest, rect_t *from, rect_t *to);
extern void blit_ram_vram(u_char* source, u_int dest, u_char w, u_char h, int sjmp, int djmp);
extern void blit_fill_vram(u_int dest, u_char value, u_char w, u_char h, int djmp);




enum stick_direction {
        st_up = 1,
        st_right = 2,
        st_down = 4,
        st_left = 8
};

extern u_char st_dir[];

extern u_char get_stick(u_char id);

extern bool get_trigger(u_char id);





extern void seed_rnd(int seed);

extern u_char get_rnd();




#define sound(reg, value)       psg_set(reg, value)

#define psgT(hz)                ((int)(111760.0 / (hz)))

enum {  
        chanNone = 0,   
        chan0 = 1,      
        chan1 = 2,      
        chan2 = 4,      
        chanAll = 7     
};

enum {
        envD = 0,       
        envU = 4,       
        envDD = 8,      
        envDUD = 10,    
        envDH = 11,     
        envUU = 12,     
        envUH = 13,     
        envUDUD = 14    
};

void psg_set(u_char reg, u_char value);

u_char psg_get(u_char reg);

void psg_init();

void psg_tone(u_char channel, int period);

void psg_noise(u_char period);

void psg_volume(u_char channel, u_char volume);

void psg_envelope(u_char waveform, int period, u_char channels);

void psg_channels(u_char tone_channels, u_char noise_channels);

u_char psg_tone_channels();

u_char psg_noise_channels();


#endif

---