amiga/dev/grfabs_reg.h

/*
 * Copyright (c) 1994 Christian E. Hopps
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by Christian E. Hopps.
 * 4. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 *	$Id: grfabs_reg.h,v 1.1 1994/02/13 21:10:36 chopps Exp $
 */

#if ! defined (_GRFABS_REG_H)
#define _GRFABS_REG_H

typedef struct point {
    long x;
    long y;
} point_t;

typedef struct dimension {
    u_long width;
    u_long height;
} dimen_t;

typedef struct box {
    long x;
    long y;
    u_long width;
    u_long height;
} box_t;

typedef struct rectangle {
    long left;
    long top;
    long right;
    long bottom;
} rect_t;

typedef struct bitmap bmap_t;
typedef struct colormap colormap_t;
typedef struct view view_t;
typedef struct display_mode dmode_t;
typedef struct monitor monitor_t;

/*
 * Bitmap stuff.
 */

/* Note structure is 5 long words big.  This may come in handy for
 * contiguous allocations
 *
 * Please do fill in everything correctly this is the main input for
 * all other programs.  In other words all problems with RTG start here.
 * If you do not mimic everyone else exactly problems will appear.
 * If you need a template look at alloc_bitmap() in grf_cc.c.
 *
 * WARNING: the plane array is only for convience, all data for bitplanes
 *          MUST be contiguous.  This is for mapping purposes.  The reason
 *          for the plane pointers and row_mod is to support interleaving
 *          on monitors that wish to support this.
 *
 * 2nd Warning: Also don't get funky with these pointers you are expected
 *              to place the start of mappable plane data in ``hardware_address'',
 *              ``hardware_address'' is the only thing that /dev/view checks and it expects
 *              the planes to follow with no padding in between.  If you have
 *              special alignment requirements make use of the given fields
 *              so that the entire contiguous plane data is exactly:
 *              bytes_per_row*height*depth long starting at the physical address
 *              contained within hardware_address.
 *
 * Final Warning: Plane data must begin on a PAGE address and the allocation must
 *                be ``n'' PAGES big do to mapping requirements (otherwise the
 *                user could write over non-allocated memory.
 *
 */
struct bitmap {
    u_short   bytes_per_row;			  /* number of bytes per display row. */
    u_short   row_mod;				  /* number of bytes to reach next row. */
    u_short   rows;				  /* number of display rows. */
    u_short   depth;				  /* depth of bitmap. */
    u_short   flags;				  /* flags. */
    u_short   pad;
    u_char  *blit_temp;				  /* private monitor buffer. */
    u_char **plane;				  /* plane data for bitmap. */
    u_char  *hardware_address;			  /* mappable bitplane pointer. */
};

enum bitmap_flag_bits {
    BMB_CLEAR,					  /* init only. */
    BMB_INTERLEAVED,				  /* init/read. */
};

enum bitmap_flags {
    BMF_CLEAR = 1 << BMB_CLEAR,			  /* init only. */
    BMF_INTERLEAVED = 1 << BMB_INTERLEAVED,	  /* init/read. */
};

/* Use these macros to find misc. sizes of actual bitmap */
#define BM_WIDTH(b)        (b->bytes_per_row << 3)
#define BM_HEIGHT(b)	   (b->rows)
#define BM_ROW(b,p,l)	   (b->plane[p] + ((b->bytes_per_row+b->row_mod)*l))

/*
 * Colormap stuff.
 */

/* valid masks are a bitfield of zeros followed by ones that indicate
 * which mask are valid for each component.  The ones and zeros will
 * be contiguous so adding one to this value yields the number of
 * levels for that component.
 * -ch
 */

struct colormap {
    u_char type;	/* what type of entries these are. */
    union {
        /* CM_GREYSCALE */
        u_char grey;
#define grey_mask  valid_mask.grey
        /* CM_COLOR */
        struct {
            u_char red;
#define red_mask   valid_mask.rgb_mask.red
            u_char green;
#define green_mask valid_mask.rgb_mask.green
            u_char blue;
#define blue_mask  valid_mask.rgb_mask.blue
        } rgb_mask;
    } valid_mask;
    u_short first;	/* what color register does entry[0] refer to. */
    u_short size;	/* number of entries */
    u_long *entry;/* the table of actual color values. */
};

enum colormap_type {
    CM_MONO,			/* only on or off allowed */
    CM_GREYSCALE,		/* grey vals. */
    CM_COLOR			/* RGB vals. */
};

#define CM_FIXVAL(x) (0xff&x)

/* these macros are for creating entries */
#define MAKE_COLOR_ENTRY(r,g,b) (CM_FIXVAL(r) << 16 | CM_FIXVAL(g) << 8 | CM_FIXVAL(b))
#define MAKE_MONO_ENTRY(x)	(x ? 1 : 0)
#define MAKE_GREY_ENTRY(l)      CM_FIXVAL(l)

#define CM_LTOW(v) (((0x000F0000&v)>>8)|((0x00000F00&v)>>4)|(0xF&v))
#define CM_WTOL(v) (((0xF00&v)<<8)|((0x0F0&v)<<4)|(0xF&v))

/*
 * View stuff.
 */
typedef void remove_view_func (view_t *v);
typedef void free_view_func (view_t *v);
typedef void display_view_func (view_t *v);
typedef dmode_t *get_mode_func (view_t *v);
typedef int get_colormap_func (view_t *v, colormap_t *);
typedef int use_colormap_func (view_t *v, colormap_t *);

struct view {
    bmap_t  *bitmap;				  /* bitmap. */
    box_t    display;				  /* viewable area. */
    void    *data;				  /* view specific data. */

    /* functions */
    display_view_func *display_view;		  /* make this view active */
    remove_view_func  *remove_view;		  /* remove this view if active */
    free_view_func    *free_view;		  /* free this view */
    get_mode_func     *get_display_mode;	  /* get the mode this view belongs to */
    get_colormap_func *get_colormap;		  /* get a color map for registers */
    use_colormap_func *use_colormap;		  /* use color map to load registers */
};

#define VDISPLAY_LINE(v, p, l) ((v)->bitmap->plane[p] +\
	(((v)->bitmap->bytes_per_row+(v)->bitmap->row_mod)*l))

/*
 * Mode stuff
 */

typedef view_t *alloc_view_func (dmode_t *mode, dimen_t *dim, u_char depth);
typedef view_t *get_current_view_func (dmode_t *);
typedef monitor_t  *get_monitor_func (dmode_t *);

struct display_mode {
    dll_node_t node;				  /* a link into a monitor's mode list. */
    u_char    *name;				  /* logical name for mode. */
    dimen_t    nominal_size;			  /* best fit. */
    void      *data;				  /* mode specific flags. */

    /* mode functions */
    alloc_view_func       *alloc_view;		  /* allocate a view for this mode. */
    get_current_view_func *get_current_view;	  /* get active view. */
    get_monitor_func      *get_monitor;		  /* get monitor that mode belongs to */
};

/*
 * Monitor stuff.
 */
typedef void     vbl_handler_func (void *);
typedef dmode_t *get_next_mode_func (dmode_t *);
typedef dmode_t *get_current_mode_func (void);
typedef dmode_t *get_best_mode_func (dimen_t *size, u_char depth);
typedef bmap_t *alloc_bitmap_func (u_short w, u_short h, u_short d, u_short f);
typedef void    free_bitmap_func (bmap_t *bm);

struct monitor {
    dll_node_t  node;				  /* a link into the database. */
    u_char     *name;				  /* a logical name for this monitor. */
    void       *data;				  /* monitor specific data. */

    /* funciton interface to this monitor. */
    vbl_handler_func       *vbl_handler;	  /* gets called on every vbl if not NULL */
    get_next_mode_func     *get_next_mode;	  /* return next mode in list */
    get_current_mode_func  *get_current_mode;	  /* return active mode or NULL */
    get_best_mode_func     *get_best_mode;	  /* return mode that best fits */

    alloc_bitmap_func      *alloc_bitmap;	  /* allocate a bitmap for use with this monitor */
    free_bitmap_func       *free_bitmap;	  /* free a bitmap */
};

/*
 * Misc draw related macros.
 */

#define BOX_2_RECT(b,r) do { \
			     (r)->left = (b)->x; (r)->top = (b)->y; \
			     (r)->right = (b)->x + (b)->width -1; \
			     (r)->bottom = (b)->y + (b)->height -1; \
		       } while (0)

#define RECT_2_BOX(r,b) do { \
			     (b)->x = (r)->left; \
			     (b)->y = (r)->top; \
		             (b)->width = (r)->right - (r)->left +1; \
			     (b)->height = (r)->bottom - (r)->top +1; \
		       } while (0)

#define INIT_BOX(b,xx,yy,ww,hh) do{(b)->x = xx; (b)->y = yy; (b)->width = ww; (b)->height = hh;}while (0)
#define INIT_RECT(rc,l,t,r,b) do{(rc)->left = l; (rc)->right = r; (rc)->top = t; (rc)->bottom = b;}while (0)
#define INIT_POINT(p,xx,yy) do {(p)->x = xx; (p)->y = yy;} while (0)
#define INIT_DIM(d,w,h) do {(d)->width = w; (d)->height = h;} while (0)


/*
 * Prototypes
 */

#if defined (__STDC__)
/* views */
view_t * grf_alloc_view (dmode_t *d, dimen_t *dim, u_char depth);
void grf_display_view (view_t *v);
void grf_remove_view (view_t *v);
void grf_free_view (view_t *v);
dmode_t *grf_get_display_mode (view_t *v);
int grf_get_colormap (view_t *v, colormap_t *cm);
int grf_use_colormap (view_t *v, colormap_t *cm);
/* modes */
view_t *grf_get_current_view (dmode_t *d);
monitor_t *grf_get_monitor (dmode_t *d);
/* monitors */
dmode_t * grf_get_next_mode (monitor_t *m, dmode_t *d);
dmode_t * grf_get_current_mode (monitor_t *);
dmode_t * grf_get_best_mode (monitor_t *m, dimen_t *size, u_char depth);
bmap_t  * grf_alloc_bitmap (monitor_t *m, u_short w, u_short h, u_short d, u_short f);
void grf_free_bitmap (monitor_t *m, bmap_t *bm);
#endif /* __STDC__ */

#endif /* _GRFABS_REG_H */