void set_color_depth(int depth);
Sets the pixel format to be used by subsequent calls to set_gfx_mode()
and create_bitmap(). Valid depths are 8 (the default), 15, 16, 24, and 32
bits. Note that you can retrieve the pixel format currently in use by
calling bitmap_color_depth() on the 'screen' bitmap, once a graphics mode
has been set.
void request_refresh_rate(int rate);
Requests that the next call to set_gfx_mode() try to use the specified
refresh rate, if possible. Not all drivers are able to control this at
all, and even when they can, not all rates will be possible on all
hardware, so the actual settings may differ from what you requested.
After you call set_gfx_mode(), you can use get_refresh_rate() to find out
what was actually selected. At the moment only the DOS VESA 3.0, X DGA 2.0
and some Windows DirectX drivers support this function. The speed is
specified in Hz, eg. 60, 70. To return to the normal default selection,
pass a rate value of zero.
int get_refresh_rate(void);
Returns the current refresh rate, if known (not all drivers are able to
report this information). Returns zero if the actual rate is unknown.
GFX_MODE_LIST *get_gfx_mode_list(int card);
Attempts to create a list of all the supported video modes for a certain
graphics driver. This function returns a pointer to a list structure of
the type GFX_MODE_LIST which has the following definition:
typedef struct GFX_MODE_LIST {
int num_modes;
GFX_MODE *mode;
} GFX_MODE_LIST;
If this function returns NULL, it means the call failed. The mode entry
points to the actual list of video modes.
typedef struct GFX_MODE {
int width, height, bpp;
} GFX_MODE;
This list is terminated with an { 0, 0, 0 } entry.
Note that the card parameter must refer to a _real_ driver. This function fails if you pass GFX_SAFE, GFX_AUTODETECT, or any other "magic" driver.
void destroy_gfx_mode_list(GFX_MODE_LIST *mode_list);
Removes the mode list created by get_gfx_mode_list() from memory.
int set_gfx_mode(int card, int w, int h, int v_w, int v_h);
Switches into graphics mode. The card parameter should usually be
GFX_AUTODETECT, GFX_AUTODETECT_FULLSCREEN or GFX_AUTODETECT_WINDOWED, or
see the platform specific documentation for a list of the available
drivers. The w and h parameters specify what screen resolution you want.
The v_w and v_h parameters specify the minimum virtual screen size, in case you need a large virtual screen for hardware scrolling or page flipping. You should set them to zero if you don't care about the virtual screen size. Virtual screens can cause a lot of confusion, but they are really quite simple. Warning: patronising explanation coming up, so you may wish to skip the rest of this paragraph :-) Think of video memory as a rectangular piece of paper which is being viewed through a small hole (your monitor) in a bit of cardboard. Since the paper is bigger than the hole you can only see part of it at any one time, but by sliding the cardboard around you can alter which portion of the image is visible. You could just leave the hole in one position and ignore the parts of video memory that aren't visible, but you can get all sorts of useful effects by sliding the screen window around, or by drawing images in a hidden part of video memory and then flipping across to display them.
For example, you could select a 640x480 mode in which the monitor acts as a window onto a 1024x1024 virtual screen, and then move the visible screen around in this larger area. Initially, with the visible screen positioned at the top left corner of video memory, this setup would look like:
(0,0)------------(640,0)----(1024,0)
| | |
| visible screen | |
| | |
(0,480)----------(640,480) |
| |
| the rest of video memory |
| |
(0,1024)--------------------(1024,1024)
What's that? You are viewing this with a proportional font? Hehehe.
When you call set_gfx_mode(), the v_w and v_h parameters represent the minimum size of virtual screen that is acceptable for your program. The range of possible sizes is usually very restricted, and Allegro is likely to end up creating a virtual screen much larger than the one you request. On an SVGA card with one megabyte of vram you can count on getting a 1024x1024 virtual screen (256 colors) or 1024x512 (15 or 16 bpp), and with 512k vram you can get 1024x512 (256 color). Other sizes may or may not be possible: don't assume that they will work. In mode-X the virtual width can be any multiple of eight greater than or equal to the physical screen width, and the virtual height will be set accordingly (the VGA has 256k of vram, so the virtual height will be 256*1024/virtual_width).
After you select a graphics mode, the physical and virtual screen sizes can be checked with the macros SCREEN_W, SCREEN_H, VIRTUAL_W, and VIRTUAL_H.
If Allegro is unable to select an appropriate mode, set_gfx_mode() returns a negative number and stores a description of the problem in allegro_error. Otherwise it returns zero.
As a special case, if you use the magic driver code GFX_SAFE, Allegro will guarantee that the mode will always be set correctly. It will try to select the resolution that you request, and if that fails, it will fall back upon whatever mode is known to be reliable on the current platform (this is 320x200 VGA mode under DOS, a 640x480 resolution under Windows, the actual framebuffer's resolution under Linux if it's supported, etc). If it absolutely cannot set any graphics mode at all, it will return negative as usual, meaning that there's no possible video output on the machine, and that you should abort your program immediately, possibly after notifying this to the user with allegro_message. This fake driver is useful for situations where you just want to get into some kind of workable display mode, and can't be bothered with trying multiple different resolutions and doing all the error checking yourself. Note however, that after a successful call to set_gfx_mode with this driver, you cannot make any assumptions about the width, height or color depth of the screen: your code will have to deal with this little detail.
Finally, GFX_TEXT is another magic driver which usually closes any previously opened graphic mode, making you unable to use the global variable screen, and in those environments that have text modes, sets one previously used or the closest match to that (usually 80x25). With this driver the size parameters of set_gfx_mode don't mean anything, so you can leave them all to zero or any other number you prefer.
int set_display_switch_mode(int mode);
Sets how the program should handle being switched into the background,
if the user tabs away from it. Not all of the possible modes will be
supported by every graphics driver on every platform: you must call this
routine after initializing the graphics driver and if you request a mode
that isn't currently possible, it will return -1. The available modes are:
int set_display_switch_callback(int dir, void (*cb)());
Installs a notification callback for the switching mode that was
previously selected by calling set_display_switch_mode(). The direction
parameter can either be SWITCH_IN or SWITCH_OUT, depending whether you
want to be notified about switches away from your program or back to your
program. You can sometimes install callbacks for both directions at the
same time, but not every platform supports this, so this function may
return -1 if your request is impossible. You can install several switch
callbacks at the same time.
void remove_display_switch_callback(void (*cb)());
Removes a notification callback that was previously installed by calling
set_display_switch_callback(). All the callbacks will automatically be
removed when you call set_display_switch_mode().
int get_display_switch_mode();
Returns the current display switching mode, in the same format passed to
set_display_switch_mode().
extern int gfx_capabilities;
Bitfield describing the capabilities of the current graphics driver and
video hardware. This may contain combination any of the flags:
GFX_CAN_SCROLL:
Indicates that the scroll_screen() function may be used with this
driver.
GFX_CAN_TRIPLE_BUFFER:
Indicates that the request_scroll() and poll_scroll() functions may be
used with this driver. If this flag is not set, it is possible that
the enable_triple_buffer() function may be able to activate it.
GFX_HW_CURSOR:
Indicates that a hardware mouse cursor is in use. When this flag is
set, it is safe to draw onto the screen without hiding the mouse
pointer first. Note that not every cursor graphic can be implemented
in hardware: in particular VBE/AF only supports 2-color images up to
32x32 in size, where the second color is an exact inverse of the
first. This means that Allegro may need to switch between hardware and
software cursors at any point during the execution of your program, so
you should not assume that this flag will remain constant for long
periods of time. It only tells you whether a hardware cursor is in use
at the current time, and may change whenever you hide/redisplay the
pointer.
GFX_HW_HLINE:
Indicates that the normal opaque version of the hline() function is
implemented using a hardware accelerator. This will improve the
performance not only of hline() itself, but also of many other
functions that use it as a workhorse, for example circlefill(),
triangle(), and floodfill().
GFX_HW_HLINE_XOR:
Indicates that the XOR version of the hline() function, and any other
functions that use it as a workhorse, are implemented using a hardware
accelerator.
GFX_HW_HLINE_SOLID_PATTERN:
Indicates that the solid and masked pattern modes of the hline()
function, and any other functions that use it as a workhorse, are
implemented using a hardware accelerator (see note below).
GFX_HW_HLINE_COPY_PATTERN:
Indicates that the copy pattern mode of the hline() function, and any
other functions that use it as a workhorse, are implemented using a
hardware accelerator (see note below).
GFX_HW_FILL:
Indicates that the opaque version of the rectfill() function, the
clear_bitmap() routine, and clear_to_color(), are implemented using a
hardware accelerator.
GFX_HW_FILL_XOR:
Indicates that the XOR version of the rectfill() function is
implemented using a hardware accelerator.
GFX_HW_FILL_SOLID_PATTERN:
Indicates that the solid and masked pattern modes of the rectfill()
function are implemented using a hardware accelerator (see note below).
GFX_HW_FILL_COPY_PATTERN:
Indicates that the copy pattern mode of the rectfill() function is
implemented using a hardware accelerator (see note below).
GFX_HW_LINE:
Indicates that the opaque mode line() and vline() functions are
implemented using a hardware accelerator.
GFX_HW_LINE_XOR:
Indicates that the XOR version of the line() and vline() functions are
implemented using a hardware accelerator.
GFX_HW_TRIANGLE:
Indicates that the opaque mode triangle() function is implemented
using a hardware accelerator.
GFX_HW_TRIANGLE_XOR:
Indicates that the XOR version of the triangle() function is
implemented using a hardware accelerator.
GFX_HW_GLYPH:
Indicates that monochrome character expansion (for text drawing) is
implemented using a hardware accelerator.
GFX_HW_VRAM_BLIT:
Indicates that blitting from one part of the screen to another is
implemented using a hardware accelerator. If this flag is set,
blitting within the video memory will almost certainly be the fastest
possible way to display an image, so it may be worth storing some of
your more frequently used graphics in an offscreen portion of the
video memory.
GFX_HW_VRAM_BLIT_MASKED:
Indicates that the masked_blit() routine is capable of a hardware
accelerated copy from one part of video memory to another, and that
draw_sprite() will use a hardware copy when given a sub-bitmap of the
screen or a video memory bitmap as the source image. If this flag is
set, copying within the video memory will almost certainly be the
fastest possible way to display an image, so it may be worth storing
some of your more frequently used sprites in an offscreen portion of
the video memory.
Warning: if this flag is not set, masked_blit() and draw_sprite() will not work correctly when used with a video memory source image! You must only try to use these functions to copy within the video memory if they are supported in hardware.
GFX_HW_MEM_BLIT:
Indicates that blitting from a memory bitmap onto the screen is being
accelerated in hardware.
GFX_HW_MEM_BLIT_MASKED:
Indicates that the masked_blit() and draw_sprite() functions are being
accelerated in hardware when the source image is a memory bitmap and
the destination is the physical screen.
GFX_HW_SYS_TO_VRAM_BLIT:
Indicates that blitting from a system bitmap onto the screen is being
accelerated in hardware. Note that some acceleration may be present
even if this flag is not set, because system bitmaps can benefit from
normal memory to screen blitting as well. This flag will only be set
if system bitmaps have further acceleration above and beyond what is
provided by GFX_HW_MEM_BLIT.
GFX_HW_SYS_TO_VRAM_BLIT_MASKED:
Indicates that the masked_blit() and draw_sprite() functions are being
accelerated in hardware when the source image is a system bitmap and
the destination is the physical screen. Note that some acceleration
may be present even if this flag is not set, because system bitmaps
can benefit from normal memory to screen blitting as well. This flag
will only be set if system bitmaps have further acceleration above and
beyond what is provided by GFX_HW_MEM_BLIT_MASKED.
Note: even if the capabilities information says that patterned drawing is supported by the hardware, it will not be possible for every size of pattern. VBE/AF only supports patterns up to 8x8 in size, so Allegro will fall back on the original non-accelerated drawing routines whenever you use a pattern larger than this.
Note2: these hardware acceleration features will only take effect when you are drawing directly onto the screen bitmap, a video memory bitmap, or a sub-bitmap thereof. Accelerated hardware is most useful in a page flipping or triple buffering setup, and is unlikely to make any difference to the classic "draw onto a memory bitmap, then blit to the screen" system.
int enable_triple_buffer();
If the GFX_CAN_TRIPLE_BUFFER bit of the gfx_capabilities field is not
set, you can attempt to enable it by calling this function. In particular
if you are running in mode-X in a clean DOS environment, this routine
will enable the timer retrace simulator, which will activate the triple
buffering functions. Returns zero if triple buffering is enabled.
int scroll_screen(int x, int y);
Attempts to scroll the hardware screen to display a different part of the
virtual screen (initially it will be positioned at 0, 0, which is the top
left corner). Returns zero on success: it may fail if the graphics driver
can't handle hardware scrolling or the virtual screen isn't large enough.
You can use this to move the screen display around in a large virtual
screen space, or to page flip back and forth between two non-overlapping
areas of the virtual screen. Note that to draw outside the original
position in the screen bitmap you will have to alter the clipping
rectangle: see below.
Mode-X scrolling is reliable and will work on any card. Unfortunately most VESA implementations can only handle horizontal scrolling in four pixel increments, so smooth horizontal panning is impossible in SVGA modes. This is a shame, but I can't see any way round it. A significant number of VESA implementations seem to be very buggy when it comes to scrolling in truecolor video modes, so I suggest you don't depend on this routine working correctly in the truecolor resolutions unless you can be sure that SciTech Display Doctor is installed.
Allegro will handle any necessary vertical retrace synchronisation when scrolling the screen, so you don't need to call vsync() before it. This means that scroll_screen() has the same time delay effects as vsync().
int request_scroll(int x, int y);
This function is used for triple buffering. It requests a hardware scroll
to the specified position, but returns immediately rather than waiting
for a retrace. The scroll will then take place during the next vertical
retrace, but you can carry on running other code in the meantime and use
the poll_scroll() routine to detect when the flip has actually taken
place (see examples/ex3buf.c). Triple buffering is only possible on
certain hardware: it will work in any mode-X resolution if the timer
retrace simulator is active (but this doesn't work correctly under
win95), plus it is supported by the VBE 3.0 and VBE/AF drivers for a
limited number of high-end graphics cards. You can look at the
GFX_CAN_TRIPLE_BUFFER bit in the gfx_capabilities flag to see if it will
work with the current driver. This function returns zero on success.
int poll_scroll();
This function is used for triple buffering. It checks the status of a
hardware scroll previously initiated by the request_scroll() routine,
returning non-zero if it is still waiting to take place, and zero if it
has already happened.
int show_video_bitmap(BITMAP *bitmap);
Attempts to page flip the hardware screen to display the specified video
bitmap object, which must be the same size as the physical screen, and
should have been obtained by calling the create_video_bitmap() function.
Returns zero on success and non-zero on failure.
Allegro will handle any necessary vertical retrace synchronisation when page flipping, so you don't need to call vsync() before it. This means that show_video_bitmap() has the same time delay effects as vsync().
int request_video_bitmap(BITMAP *bitmap);
This function is used for triple buffering. It requests a page flip to
display the specified video bitmap object, but returns immediately rather
than waiting for a retrace. The flip will then take place during the next
vertical retrace, but you can carry on running other code in the meantime
and use the poll_scroll() routine to detect when the flip has actually
taken place. Triple buffering is only possible on certain hardware: see
the comments about request_scroll(). Returns zero on success.