gfx_capabilities

gfx_capabilities(3alleg4)        Allegro manual        gfx_capabilities(3alleg4)



NAME
       gfx_capabilities - Bitfield describing video hardware capabilities.
       Allegro game programming library.

SYNOPSIS
       #include <allegro.h>


       extern int gfx_capabilities;

DESCRIPTION
       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_SYSTEM_CURSOR Indicates that the mouse cursor is the default system
       cursor, not Allegro's custom cursor.

       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.

       GFX_HW_VRAM_STRETCH_BLIT: Indicates that stretched blitting of video
       bitmaps onto the screen is implemented using hardware acceleration.

       GFX_HW_SYS_STRETCH_BLIT: Indicates that stretched blitting of system
       bitmaps onto the screen is implemented using hardware acceleration.

       GFX_HW_VRAM_STRETCH_BLIT_MASKED: Indicates that masked stretched blitting
       (including stretch_sprite) of video bitmaps onto the screen is
       implemented using hardware acceleration.  NOTE: some display drivers may
       show artifacts when this function is used.  If the image does not look
       correct try updating your video drivers.

       GFX_HW_SYS_STRETCH_BLIT_MASKED: Indicates that masked stretched blitting
       (including stretch_sprite) of system bitmaps onto the screen is
       implemented using hardware acceleration.  NOTE: some display drivers may
       show artefact's when this function is used.  If the image does not look
       correct try updating your video drivers.

       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.


SEE ALSO
       screen(3alleg4), create_video_bitmap(3alleg4), scroll_screen(3alleg4),
       request_scroll(3alleg4), show_mouse(3alleg4),
       enable_triple_buffer(3alleg4), ex3buf(3alleg4), exaccel(3alleg4),
       exsyscur(3alleg4), exupdate(3alleg4)



Allegro                           version 4.4.3        gfx_capabilities(3alleg4)