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)