195 lines
8.3 KiB
C
Executable file
195 lines
8.3 KiB
C
Executable file
|
|
// ****************************************************************************
|
|
//
|
|
// VGA layers
|
|
//
|
|
// ****************************************************************************
|
|
|
|
#ifndef _VGA_LAYER_H
|
|
#define _VGA_LAYER_H
|
|
|
|
// base layer commands
|
|
#define VGADARK(num,col) (((u32)(vga_offset_dark+BASE_OFFSET)<<27) | ((u32)(num)<<8) | (u32)(col)) // assemble control word of "dark" command
|
|
#define VGACMD(jmp,num) (((u32)(jmp)<<27) | (u32)(num)) // assemble control word
|
|
|
|
// --- overlapped layer init word (delay: use number of offset pixels * Vmode.cpp, num: number of pixels)
|
|
|
|
// init word of key color layer LAYERPROG_KEY
|
|
#define VGAKEY(delay,num,col) (((u32)((delay)+1)<<19) | ((u32)(col)<<11) | (u32)((num)-1))
|
|
|
|
// init word of mono layer LAYERPROG_MONO
|
|
#define VGAMONO(delay,num,col) (((u32)((delay)+0)<<20) | ((u32)(col)<<12) | ((u32)((num)-1)<<1) | B0)
|
|
|
|
// init word of color layer LAYERPROG_MONO
|
|
#define VGACOLOR(delay,num) (((u32)((delay)+2)<<20) | ((u32)0xff<<12) | ((u32)((num)-1)<<1) | 0)
|
|
|
|
// init word of black color layer LAYERPROG_BLACK
|
|
#define VGABLACK(delay,num) (((u32)((delay)+3)<<16) | (u32)((num)-1))
|
|
|
|
// init word of white color layer LAYERPROG_WHITE
|
|
#define VGAWHITE(delay,num) (((u32)((delay)+3)<<16) | (u32)((num)-1))
|
|
|
|
// init word of RLE layer LAYERPROG_RLE
|
|
#define VGARLE(delay) ((delay)+1)
|
|
|
|
// swap bytes of command
|
|
#define BYTESWAP(n) ((((n)&0xff)<<24)|(((n)&0xff00)<<8)|(((n)&0xff0000)>>8)|(((n)&0xff000000)>>24))
|
|
|
|
// align to multiple of 4
|
|
#define ALIGN4(x) ((x) & ~3)
|
|
|
|
// layer program descriptor
|
|
typedef struct {
|
|
const u16* ins; // pointer to program instructions (NULL=layers is OFF)
|
|
const struct pio_program* prg; // pointer to program descriptor
|
|
u8 length; // program length (number of instructions)
|
|
u8 wrap_target; // offset of wrap target
|
|
u8 wrap; // offset of wrap end
|
|
u8 idle; // offset of idle
|
|
u8 entry; // offset of entry
|
|
u8 maxidle; // max. offset of idle to detect end of job
|
|
u8 extranum; // number of extra offsets
|
|
u8 extra[2*16]; // extra offsets, pairs: offset, CPP-correction
|
|
} sLayerProg;
|
|
|
|
// layer program descriptors
|
|
extern const sLayerProg LayerProg[LAYERPROG_NUM];
|
|
|
|
// current layer program of overlapped layers
|
|
extern u8 LayerProgInx; // index of current layer program (LAYERPROG_*, LAYERPROG_BASE = overlapped layers are OFF)
|
|
extern sLayerProg CurLayerProg; // copy of current layer program
|
|
|
|
// layer mode descriptor
|
|
typedef struct {
|
|
u8 prog; // layer program (LAYERPROG_*)
|
|
u8 mincpp; // minimal clock cycles per pixel
|
|
u8 maxcpp; // maximal clock cycles per pixel
|
|
} sLayerMode;
|
|
|
|
// layer mode descriptors
|
|
extern const sLayerMode LayerMode[LAYERMODE_NUM];
|
|
|
|
// current layer mode of layers
|
|
extern u8 LayerModeInx[LAYERS]; // index of current layer mode (LAYERMODE_*)
|
|
extern sLayerMode CurLayerMode[LAYERS]; // copy of current layer mode
|
|
|
|
// layer screen descriptor (on change update SLAYER_* in define.h)
|
|
typedef struct {
|
|
const u8* img; // pointer to image in current layer format, or sprite list
|
|
const void* par; // additional parameter (RLE index table, integer transformation matrix)
|
|
u32 init; // init word sent on start of scanline (start X coordinate)
|
|
u32 keycol; // key color
|
|
u16 trans; // trans count
|
|
s16 x; // start X coordinate
|
|
s16 y; // start Y coordinate
|
|
u16 w; // width in pixels
|
|
u16 h; // height
|
|
u16 wb; // image width in bytes (pitch of lines)
|
|
u8 mode; // layer mode
|
|
s8 horiz; // horizon of perspective projection/4 (only with LAYERMODE_PERSP* modes, 0=no perspecitve, <0 ceilling)
|
|
u8 xbits; // number of bits of width of source image (only with LAYERMODE_PERSP* modes)
|
|
u8 ybits; // number of bits of height of source image (only with LAYERMODE_PERSP* modes)
|
|
u16 spritenum; // number of sprites
|
|
Bool on; // layer is ON
|
|
u8 cpp; // current clock pulses per pixel (used to calculate X coordinate)
|
|
} sLayer;
|
|
|
|
// sprite (on change update SSPRITE_* in define.h)
|
|
typedef struct {
|
|
u8* img; // SSPRITE_IMG pointer to image data
|
|
u8* x0; // SSPRITE_X0 pointer to array of start of lines, or fast sprite start of lines/4
|
|
u8* w0; // SSPRITE_W0 pointer to array of length of lines, or fast sprite length of lines/4
|
|
u32 keycol; // SSPRITE_KEYCOL key color
|
|
s16 x; // SSPRITE_X sprite X-coordinate on the screen
|
|
s16 y; // SSPRITE_Y sprite Y-coordinate on the screen
|
|
u16 w; // SSPRITE_W sprite width (slow sprite: max. width 255)
|
|
u16 h; // SSPRITE_H sprite height
|
|
u16 wb; // SSPRITE_WB sprite pitch (number of bytes between lines)
|
|
u16 res; // ...reserved, structure align
|
|
} sSprite;
|
|
|
|
// current layer screens
|
|
extern sLayer LayerScreen[LAYERS]; // layer screens
|
|
|
|
extern u8 LayerMask; // mask of active layers
|
|
|
|
// index of first pin of layer (base layer should stay VGA_GPIO_FIRST)
|
|
extern u8 LayerFirstPin[LAYERS_MAX];
|
|
|
|
// number of pins of overlapped layer (base layer should stay VGA_GPIO_OUTNUM)
|
|
extern u8 LayerNumPin[LAYERS_MAX];
|
|
|
|
// set overlapped layer 1..3 ON
|
|
void LayerOn(u8 inx);
|
|
|
|
// set overlapped layer 1..3 OFF
|
|
void LayerOff(u8 inx);
|
|
|
|
// set coordinate X of overlapped layer
|
|
void LayerSetX(u8 inx, s16 x);
|
|
|
|
// set coordinate Y of overlapped layer
|
|
void LayerSetY(u8 inx, s16 y);
|
|
|
|
// set width of image of overlapped layer
|
|
// Uses auto pitch wb (full line). Set custom wb after calling this function.
|
|
void LayerSetW(u8 inx, u16 w);
|
|
|
|
// set height of image of overlapped layer
|
|
void LayerSetH(u8 inx, u16 h);
|
|
|
|
// setup overlapped layer 1..3 (not for sprites and not for perspective mode)
|
|
// inx ... layer index 1..3
|
|
// img ... pointer to image data
|
|
// vmode ... pointer to initialized video configuration
|
|
// w ... image width in pixels (must be multiple of 4)
|
|
// h ... image height
|
|
// col ... key color (needed for LAYERMODE_KEY and LAYERMODE_MONO layer mode)
|
|
// par ... additional data (RLE index table, integer transformation matrix)
|
|
// Use these functions after layer setup: LayerSetX, LayerSetY, LayerOn
|
|
void LayerSetup(u8 inx, const u8* img, const sVmode* vmode, u16 w, u16 h, u8 col = 0, const void* par = NULL);
|
|
|
|
// setup overlapped layer 1..3 for LAYERMODE_PERSP* modes
|
|
// inx ... layer index 1..3
|
|
// img ... pointer to source image data (image width and height must be power of 2)
|
|
// vmode ... pointer to initialized video configuration
|
|
// w ... destination image width in pixels (must be multiple of 4)
|
|
// h ... destination image height
|
|
// xbits ... number of bits of width of source image
|
|
// ybits ... number of bits of height of source image
|
|
// horiz ... horizon of perspective projection/4 (0=no perspecitve, <0 ceilling)
|
|
// mat ... integer transformation matrix
|
|
// col ... key color (needed for LAYERMODE_PERSPKEY layer mode)
|
|
// Use these functions after layer setup: LayerSetX, LayerSetY, LayerOn
|
|
void LayerPerspSetup(u8 inx, const u8* img, const sVmode* vmode, u16 w, u16 h, u8 xbits, u8 ybits,
|
|
s8 horiz, const int* mat, u8 col = 0);
|
|
|
|
// setup overlapped layer 1..3 for LAYERMODE_SPRITE* and LAYERMODE_FASTSPRITE* modes
|
|
// inx ... layer index 1..3
|
|
// sprite ... pointer to list of sprites (array of pointers to sprites; sorted by X on LAYERMODE_FASTSPRITE* modes)
|
|
// spritenum ... number of sprites in the list (to turn sprite off, you can set its coordinate Y out of the screen)
|
|
// vmode ... pointer to initialized video configuration
|
|
// x ... start coordinate X of area with sprites
|
|
// y ... start coordinate Y of area with sprites
|
|
// w ... width of area with sprites (must be multiple of 4)
|
|
// h ... height of area with sprites
|
|
// col ... key color (needed for LAYERMODE_SPRITEKEY and LAYERMODE_FASTSPRITEKEY layer mode)
|
|
// Use functions LayerOn after layer setup.
|
|
void LayerSpriteSetup(u8 inx, sSprite** sprite, u16 spritenum, const sVmode* vmode,
|
|
s16 x, s16 y, u16 w, u16 h, u8 col = 0);
|
|
|
|
// prepare array of start and length of lines (detects transparent pixels)
|
|
// img ... image
|
|
// x0 ... array of start of lines
|
|
// w0 ... array of length of lines
|
|
// w ... sprite width (slow sprite: max. width 255)
|
|
// h ... sprite height
|
|
// wb ... sprite pitch (bytes between lines)
|
|
// col ... key color
|
|
// fast ... fast sprite, divide start and length of line by 4
|
|
void SpritePrepLines(const u8* img, u8* x0, u8* w0, u16 w, u16 h, u16 wb, u8 col, Bool fast);
|
|
|
|
// sort fast sprite list by X coordinate
|
|
void SortSprite(sSprite** list, int num);
|
|
|
|
#endif // _VGA_LAYER_H
|