ggl.h

Go to the documentation of this file.

//& *** (c) 2006-2011 The HPGCC3 Team ***
//& Claudio Lapilli
//& Ingo Blank
//&
//& This file is licensed under the terms and conditions of the
//& HPGCC3 license that is included with the source distribution.
//& *** (c) 2006-2011 The HPGCC3 Team ***

#ifdef __cplusplus
extern "C" {
#endif



#ifndef GGL_H_
#define GGL_H_





#define STATEBUFSIZE ((11+6)*4)

#define LCD_H 80

#define LCD_W 160

#define SCREENBUFSIZE ((LCD_W>>2)*(LCD_H)*2)

// data types/structures

// surface used for bitblt operations
// notes:
// a surface is infinite in both width and height, there are no memory limits
// .addr must be a word aligned address
// .width is used only to find a new scanline, and can be changed at will
//        the width is given in pixels and it can be arbitrary (no alignement needed)
// for normal drawing primitives, (0,0) is the word-aligned address pointed by .addr,
// disregarding of the values in .x and .y
// for bitblt operations, .x and .y give the origin (top-left corner) of the region to use
// the surface is nibble-aligned, so a 1 pixel wide surface will contain 8
// rows of pixels per word

typedef struct {
    int *addr;  
    int width;  
    int x,y;    
} gglsurface;

typedef unsigned int (*gglfilter)(unsigned int pixels,int param);

typedef unsigned int (*ggloperator)(unsigned int dest,unsigned int source,int param);


// general routines

void ggl_initscr(gglsurface *srf);    // allocate screen buffer


void ggl_freescr();        // FREE SCREEN BUFFER



void ggl_gethpgscreen(gglsurface *srf);

#define ggl_setmode(framebuf) sys_lcdsetmode(MODE_16GRAY,framebuf);


#define ggl_save(buf) sys_lcdsave(buf)

#define ggl_restore(buf) sys_lcdrestore(buf)

/*
 * \brief Causes a different GGL surface to be displayed.
 *
 * This function allows the use of several GGL surfaces as the main screen
 * in an application. It causes the LCD controller to begin displaying a
 * different screen.  No VSYNC is performed, so some tearing is possible 
 * unless external VSYNC is checked before calling this function.
 *
 * This function should be used by applications that use GGL exclusively.  If
 * HPG is in use, the application should use hpg_flip to accomplish page
 * flipping.
 *
 * \param framebuf A pointer to the new LCD screen's frame buffer.  This is
 *                 generally found in the gglsurface::addr field of a
 *                 ::gglsurface.
 */
void ggl_show(int *buffer);    // display buffer, no vertical sync

// drawing primitives
// general pixel set/read routines

void ggl_pltnib(int *buff,int off,int color);    // poke a pixel (off in nibbles)

int  ggl_getnib(int *buff,int off);                // peek a pixel (off in nibbles)

// general drawing primitives

// note: the argument color is a 32-bit value containing a different
//       color for each pixel. For solid colors, set color to contain the same value
//       on every nibble (for color 8, color=0x88888888)
//       or call ggl_mkcolor for that purpose

void ggl_hline(gglsurface *srf,int y,int xl,int xr, int color); // fast low-level horizontal line

void ggl_vline(gglsurface *srf,int x,int yt,int yb, int color); // fast low-level vertical line

void ggl_rect(gglsurface *srf,int x1,int y1,int x2,int y2,int color); // low-level rectangle

void ggl_rectp(gglsurface *srf,int x1,int y1,int x2,int y2,int *color); // low-level rectangle with 8x8 pattern

// rectangle blt
// note: see gglsurface above for complete understanding of the behavior of these routines
// ggl_bitblt loops from top to bottom

void ggl_bitblt(gglsurface *dest,gglsurface *src,int width, int height); // copy a rectangular region

// ggl_revblt loops from bottom to top, for overlapping zones
void ggl_revblt(gglsurface *dest,gglsurface *src,int width, int height); // copy a rectangular region, reverse loop
// ggl_ovlblt chooses to use normal/reverse loop based on the addresses
// use it when the direcction of movement is unknown
void ggl_ovlblt(gglsurface *dest,gglsurface *src,int width, int height); // copy overlapped regions
// ggl_bitbltmask behaves exactly as ggl_bitblt but using tcol as a transparent color


#define ggl_bitbltmask(dest,src,width,height,tcol)  ggl_bitbltoper(dest,src,width,height,tcol,&ggl_opmask)


// rectangle scrolling routines
// dest contains the surface to scroll, and width and height define the rectangle
// the area that needs to be redrawn after the scroll is not erased or modified by these routines 
void ggl_scrollup(gglsurface *dest,int width, int height, int npixels); // scroll npixels up
void ggl_scrolldn(gglsurface *dest,int width, int height, int npixels); // scroll npixels dn

void ggl_scrolllf(gglsurface *dest,int width, int height, int npixels); // scroll npixels left
void ggl_scrollrt(gglsurface *dest,int width, int height, int npixels); // scroll npixels right

// custom filters and operators

// bitmap filtering routine
void ggl_filter(gglsurface *dest,int width, int height, int param, gglfilter filterfunc);

// bitblt operator routine
void ggl_bitbltoper(gglsurface *dest,gglsurface *src,int width, int height,int param,ggloperator filterfunc);

// predefined filters and operators

// filters (unary operators)
// ligthens an image by subtracting param from all pixels

unsigned ggl_fltlighten(unsigned word,int param);
// darkens an image by adding param to all pixels

unsigned ggl_fltdarken(unsigned word,int param);

// operators (between two surfaces)
// standard mask, tcolor in src is considered transparent


unsigned ggl_opmask(unsigned dest,unsigned src,int tcolor);
// transparency blend, weight is 0 = src is opaque, 16 = src is fully transparent

unsigned ggl_optransp(unsigned dest,unsigned src,int weight);




// miscellaneous

// ggl_mkcolor repeats the same color on every nibble
// ggl_mkcolor(2) will return 0x22222222
int ggl_mkcolor(int color); // solid color generator

// ggl_mkcolor32 creates virtual 32-colors by using 8x8 patterns
// col32 is a value from 0 to 30, being 30=black, 0=white
// note: the user is responsible to provide a valid int[8] buffer in the
// pattern argument
void ggl_mkcolor32(int col32, int *pattern);    // 50% dither pattern generator for 31 colors
    
// ANTIALIAS INITIALIZATION

// ggl_initaline initializes tables needed for antialiased lines
void ggl_initaline();

// for antialiased lines, call first ggl_initaline and call ggl_endaline for cleanup
// notice that ggl_init/ggl_exit do NOT call ggl_initaline
// anitaliased lines are always 3 pixels wide
void ggl_aline(gglsurface *srf,int x1,int y1,int x2,int y2);    // ANTIALIASED LINES

// ggl_endaline cleans up the memory allocated by ggl_initaline
void ggl_endaline();

#endif

#ifdef __cplusplus
}
#endif