All Identifiers

This is a pointer to the Allegro X11 icon, which is in the format of standard .xpm bitmap data.

When Allegro cannot find a glyph it needs in a font, it will instead output the character given in this variable.

Shortcut version of al_acquire_bitmap (screen);

When a menu callback procedure is triggered, this will be set to the menu item that was selected, so your routine can determine where it was called from.

Alters the parameters of a sample while it is playing (useful for manipulating looped sounds).

Like al_alert, but with three buttons.

Multiplies the point (x, y, z) by the transformation matrix m, storing the result in (xout, yout, zout).

Multiplies the point x, y, z by the quaternion q, storing the result in xout, yout, zout.

Searches the specified palette for the closest match to the requested color, which are specified in the VGA hardware 0-63 format.

Pointer to AL_BITMAP.

Returns the mask color for the specified bitmap (the value which is skipped when drawing sprites).

Blits from a Windows device context to an Allegro memory bitmap, using the same parameters as the al_blit procedure.

Another bool type, used if C's declaration is byte sized.

Give the number of ticks each minute to al_install_int_ex.

Broadcasts a message to all the objects in the active dialog.

Most joysticks need to be calibrated before they can provide full analogue input.

Moves an array of dialog objects so that it is centered in the screen.

Pointer to signed 8bit integer values.

Draws a circle with the specified centre and radius.

Clears the bitmap to color 0.

Initializes a scene.

Writes z into the given Z-buffer (0 means far away).

Clips the polygon given in vtx.

Define color conversion modes.

Clolor map.

Pointer to the color mapping table.

Creates an Allegro memory bitmap from a Windows DDB.

Converts an Allegro palette to a Windows palette and returns a handle to it.

Contains the CPU type, where applicable.

CPU families - PC

Contains the CPU submodel, where applicable.

486

AMD/586

Intel/686

On Intel PCs, contains the CPU vendor name if known.

Creates a bitmap in a specific color depth (8, 15, 16, 24 or 32 bits per pixel).

Fills the specified color mapping table with lookup data for doing customised effects with the specified palette, calling the blend function to determine the results of each color combination.

Fills the specified RGB mapping table with lookup data for the specified palette.

Allocates memory for a scene, nedge and npoly are your estimates of how many edges and how many polygons you will render (you cannot get over the limit specified here).

Creates a sub-z-buffer, ie.

Fills the specified color mapping table with lookup data for doing translucency effects with the specified palette.

Creates a Z-buffer using the size of the AL_BITMAP you are planning to draw on.

Same as al_cross_product but using floats instead than fixed.

Pointer to AL_DATAFILE.

Pointer to AL_DATAFILE_OBJECT.

(AL_ID ('BMP '))

(AL_ID ('DATA'))

(AL_ID ('FILE'))

(AL_ID ('FONT'))

(AL_ID ('MIDI'))

(AL_ID ('PAL '))

(AL_ID ('prop'))

(AL_ID ('SAMP'))

Frees a soundcard voice, stopping it from playing and releasing whatever resources it is using.

Finds out the currently selected desktop color depth.

Destroys a memory bitmap, sub-bitmap, video memory bitmap, or system bitmap when you are finished with it.

Removes the mode list created by al_get_gfx_mode_list from memory.

Destroys an RLE sprite structure previously returned by al_get_rle_sprite.

Deallocate memory previously allocated by create_scene.

Detects whether the specified digital sound device is available.

This is the structure which contains a GUI object.

Sends a message to all the objects in an array.

Dialog function object.

aRts (Analog Real-Time Synthesizer).

Use DirectSound device n (zero-based) with Allegro mixing.

Enlightened Sound Daemon.

Identifier to pass to al_install_sound.

Max number of digital voices.

After calling this function, Allegro will be responsible for drawing the mouse cursor rather than the operating system.

Same as al_dot_product but using floats instead than fixed.

Calculates all the points in a circular arc around point (x, y) with radius r, calling the supplied function for each one.

The basic dialog manager function.

Calculates all the points along a line from point (x1, y1) to (x2, y2), calling the supplied function for each one.

Sets the graphics drawing mode.

Tinted version of al_draw_rle_sprite.

Flag for al_drawing_mode.

Flag for al_drawing_mode.

Flag for al_drawing_mode.

Draws an RLE sprite onto a bitmap at the specified position.

Draws the sprite image onto the destination bitmap using the specified mode argument, optionally flipping the sprite in the orientation specified by flip argument.

This is like al_draw_sprite, but it additionally flip the image vertically and horizontally.

Draws an entire Allegro bitmap to a Windows device context, using the same parameters as the al_draw_sprite procedure.

Uses the global al_color_table table or truecolor blender functions to overlay the sprite on top of the existing image.

Just draws a box.

This is an example of how you can derive objects from other objects.

request to close the dialog

Object needs to be redrawn

this object does not want mouse focus

Object makes the dialog exit

Mouse is on top of object

A bitmap button.

This is an invisible object for implementing keyboard shortcuts.

This object is a menu bar which will drop down child menus when it is clicked or if an alt+key corresponding to one of the shortcuts in the menu is pressed.

A radio button object.

request to redraw this object

Draws text right aligned onto the screen.

Just draws a box with a shadow.

A text box object.

Draws text onto the screen.

From here on is free for your own use

An invisible helper object that yields time slices for the scheduler (if the system supports it) when the GUI has nothing to do but waiting for user actions.

Draws a filled ellipse with the specified centre and radius.

Enables triple buffering.

Text string used by al_set_gfx_mode, al_install_sound and other functions to report error messages.

Extracts a range of characters from a font.

Gradually fades a part of the palette from the source palette to the dest palette.

Calculates a temporary palette part way between source and dest, returning it in the aOutput parameter.

Gradually fades from the current palette to a black screen.

Faster version of the previous function.

Searches an already loaded datafile for an object with the specified name.

This function finds the inverse cosine of a value using a lookup table.

This function finds the inverse sine of a value using a lookup table.

This is a fixed point version of the libc atan2 () routine.

A fixed point value can be divided by an integer with the normal `/' and DIV operators.

Pointer to AL_FIXED.

A fixed point value can be multiplied or divided by an integer with the normal `*' and `/' operators.

This function finds the sine of a value using a lookup table.

Safe function to subtract fixed point numbers clamping underflow.

Converts fixed point to floating point.

This constant gives a ratio which can be used to convert a fixed point number in binary angle format to a fixed point number in radians.

These variables are set by al_next_fli_frame to indicate which part of the al_fli_bitmap has changed since the last call to al_reset_fli_variables.

Global variable containing the current frame number in the FLI file.

These variables are set by al_next_fli_frame to indicate which part of the al_fli_palette has changed since the last call to al_reset_fli_variables.

Global variable for timing FLI playback.

Pointer to float values.

Writes the current config file to disk if the contents have changed since it was loaded or since the latest call to the function.

A pointer to a structure holding an Allegro font, usually created beforehand with the grabber tool or Allegro's default font.

Converts a floating point value to fixed point.

magic number for autodetect

Constructs a fake truecolor palette, using three bits for red and green and two for the blue.

Given a color in the format being used by the current video mode, this function extracts the alpha chanel value (ranging 0-255), calling the preceding 8, 15, 16, 24, or 32-bit get functions as appropriate.

Given a color in the format being used by the current video mode, this function extracts the blue component (ranging 0-255), calling the preceding 8, 15, 16, 24, or 32-bit get functions as appropriate.

Given a color in the format being used by the current video mode, this function extracts the green component (ranging 0-255), calling the preceding 8, 15, 16, 24, or 32-bit get functions as appropriate.

Reads a pixel from point (x, y) in the bitmap.

Given a color in the format being used by the specified color depth, this functions extract the red component (ranging 0-255).

Same as al_get_align_matrix but in floating point.

Same as al_get_camera_matrix but in floating point.

Returns the clipping state.

Returns the current color conversion mode.

Reads a floating point variable from the current config file.

Reads a 4-letter driver ID variable from the current config file.

Retrieves a string variable from the current config file.

Returns the current display switching mode, in the same format passed to al_set_display_switch_mode.

Returns the start of a character range in a font.

Lets you determine which graphics driver is currently set by allegro.

Lets you determine the types of operating modes that a specific graphics card driver operates in.

This function will simulate playing the given MIDI, from start to end, to determine how long it takes to play.

Returns the number of samples per channel in the mixer buffer.

Returns the mixer frequency, in Hz.

Returns the number of voices allocated to the mixer.

Retrieves the entire palette of 256 colors.

Returns the current refresh rate, if known (not all drivers are able to report this information).

Constructs a transformation matrix which will rotate points around all three axes by the specified amounts (given in binary, 256 degrees to a circle format).

Constructs a quaternion that will rotate points around all three axes by the specified amounts (given in binary, 256 degrees to a circle format).

Same as al_get_scaling_matrix but in floating point.

Same as al_get_transformation_matrix but in floating point.

Same as al_get_translation_matrix but in floating point.

Constructs a transformation matrix which will rotate points around the specified x,y,z vector by the specified angle (given in binary, 256 degrees to a circle format).

Constructs a quaternion that will rotate points around the especified x,y,z vector by the specified amounts (given in binary, 256 degrees to a circle format).

Constructs X axis rotation matrices, storing them in m.

Construct axis rotation quaternion, storing it in q.

Same as al_get_y_rotate_matrix but in floating point.

Constructs Z axis rotation matrices, storing them in m.

Construct axis rotation quaternion, storing it in q.

Allegro will try to set the specified resolution with the current color depth in fullscreen mode.

Indicates that the al_scroll_screen function may be used with this driver.

Bitfield describing the capabilities of the current graphics driver and video hardware.

The regular fullscreen DirectX driver, running with hardware acceleration enabled.

Simplified fullscreen DirectX driver that doesn't support any hardware acceleration, video or system bitmaps, etc.

The regular windowed DirectX driver, running in color conversion mode when the color depth doesn't match that of the Windows desktop.

Uses the framebuffer device (eg.

Indicates that a hardware mouse cursor is in use.

Indicates that the copy pattern mode of the al_rectfill function is implemented using a hardware accelerator (see AL_GFX_HW_FILL).

Indicates that the XOR version of the al_rectfill function is implemented using a hardware accelerator (see AL_GFX_HW_FILL).

Indicates that the normal opaque version of the al_hline function is implemented using a hardware accelerator.

Indicates that the solid and masked pattern modes of the al_hline function, and any other functions that use it as a workhorse, are implemented using a hardware accelerator (see AL_GFX_HW_HLINE).

Indicates that the opaque mode al_line and al_vline functions are implemented using a hardware accelerator.

Indicates that blitting from a memory bitmap onto the screen is being accelerated in hardware.

Indicates that blitting from a system bitmap onto the screen is being accelerated in hardware.

Indicates that blitting from one part of the screen to another is implemented using a hardware accelerator.

Graphics mode description.

Uses direct hardware access to set standard but not documented Mode-X resolutions, supporting the same modes as in the DOS version of this driver.

Pointer to AL_GFX_MODE_LIST.

Extended version of the graphics mode selection dialog, which allows the user to select the color depth as well as the resolution and hardware driver.

No graphics mode.

Callback to be used by al_gfx_mode_select_filter.

Indicates that the mouse cursor is the default system cursor, not Allegro's custom cursor.

Uses a VBE/AF driver (vbeaf.drv), assuming that you have installed one which works under Linux (currently only two of the FreeBE/AF project drivers are capable of this: I don't know about the SciTech ones).

Uses new DGA 2.0 extension provided by XFree86 4.0.x.

The standard X graphics driver.

This function is the work-horse of al_load_bitmap_font, and can be used to grab a font from a bitmap in memory.

If set, this function will be used by the standard Allegro dialogs.

If set, this function will be used by the standard Allegro dialogs.

If set to a non-zero value, adjusts the keyboard shortcut underscores to account for the height of the descenders in your font.

If set, this function will be used by the standard Allegro dialogs.

If set, this function will be called whenever a menu needs to be drawn, so you can change how menus look.

Hook function, used by the GUI routines whenever they need to access the mouse state.

Hook function, used by the GUI routines whenever they need to access the mouse state.

Hook function, used by the GUI routines whenever they need to access the mouse state.

If set, this function will be used by the standard Allegro dialogs.

Helper function for use by the GUI routines.

Draws a horizontal line onto the bitmap, from point (x1, y) to (x2, y).

This function can be used to create a packed 32 bit integer from 8 bit characters, on both 32 and 64 bit machines.

Global variable containing the do nothing identity matrix.

Text string containing a date and version number for the library, in case you want to display these somewhere.

This function provides lower level access to the same functionality as al_do_dialog, but allows you to combine a dialog box with your own program control structures.

Initialises the Allegro library.

Adds a function to the list of user timer handlers or, if it is already installed, retroactively adjusts its speed (i.e makes as though the speed change occurred precisely at the last tick).

Installs the Allegro keyboard interrupt handler.

Like al_install_int, but the callback routine will be passed a copy of the specified void pointer parameter.

Initialises the sound module.

Signed 32bit integer values.

Signed 32bit integer values.

Signed 8bit integer values.

This is used to define call-back parameters or pointers to call-back procedures.

This function compares the two fonts, which you can use to find out if Allegro is capable of merging them.

This function checks if the given font is a mono font, as opposed to a color font.

Returns True if bmp is the screen bitmap, or a sub-bitmap of the screen.

Returns True if bmp is a system bitmap object, or a sub-bitmap of one.

Returns True if bmp is the screen bitmap, a video memory bitmap, or a sub-bitmap of either.

Converts an integer to fixed point.

joystick status flags.

information about a joystick button.

Pointer to AL_JOYSTICK_INFO.

information about one or more axis (a slider or directional control)

Use DirectInput to access the joystick.

Dummy driver for machines without any joystick.

Shift keys flags.

If set, this function is called by the keyboard handler in response to every keyboard event, both presses (including keyboard repeat rate) and releases.

Returns True if there are keypresses waiting in the input buffer.

MacOS X

By default, the capslock, numlock, and scroll-lock keys toggle the keyboard LED indicators when they are pressed.

MacOS X

MacOS X

Loads a bitmap from a file.

Loads an 8-bit, 16-bit, 24-bit or 32-bit Windows or OS/2 BMP file.

Loads a datafile into memory in one go.

Loads a font from a file.

Loads a 256-color IFF ILBM/PBM file.

Forces the MIDI driver to load the entire set of patches ready for use.

A version of al_load_pcx which reads a PCX file from a packfile.

Loads a 256-color, 15-bit hicolor, 24-bit truecolor, or 32-bit truecolor+alpha TGA file.

Loads a font script.

A version of al_load_voc which reads from a packfile.

A version of al_load_wav which reads from a packfile.

Convert RGBA colors into display dependent pixel formats.

Converts colors from a hardware independent format (red, green, and blue values ranging 0-255) to the pixel format required by the current video mode, calling the preceding 8, 15, 16, 24, or 32-bit makecol functions as appropriate.

Converts colors from a hardware independent format (red, green, and blue values ranging 0-255) to the pixel format required by the specified color depth.

Like al_blit, but skips transparent pixels, which are marked by a zero in 256-color modes or bright pink for truecolor data (maximum red and blue, zero green), and requires the source and destination bitmaps to be of the same color depth.

Fixed point matrix structure.

Floating point matrix structure.

Multiplies two matrices, storing the result in outM (this may be a duplicate of one of the input matrices, but it is faster when the inputs and output are all different).

Constructs a quaternion from a rotation matrix.

Pointer to AL_MENU.

A structure which holds GUI data used internally by Allegro.

Merges two fonts into one font.

A structure holding MIDI data.

ALSA RawMIDI driver.

Identifier to pass to al_install_sound.

The loop start point, set by the al_play_looped_midi function.

Used by al_midi_msg_callback.

Open Sound System.

Pauses the MIDI player.

Resumes playback of a paused MIDI file.

Contains the position in seconds in the currently playing midi.

Max number of MIDI voices.

Use win32 MIDI mapper.

Selects the custom Allegro cursor, i.e.

The operating system default `busy' cursor (hourglass).

Indicates that the mouse cursor is the default system cursor, not Allegro's custom cursor.

Returns True if the current mouse driver is operating in polling mode.

Global variable containing the current mouse position.

Global variable containing the current mouse position.

Global variable containing the current mouse focus point.

Global variable containing the current mouse focus point.

Give the number of milliseconds between each tick to al_install_int_ex.

mouse click on the object

draw the object

got the input focus

update any background stuff

lost the input focus

mouse left button pressed

mouse middle button pressed

clear radio buttons

mouse right button released

unicode keyboard input

does object want the input focus?

mouse wheel moved

Reads the next frame of the current animation file.

Same as al_normalize_vector but using floats instead than fixed.

Sends a message to an object and returns the answer it has generated.

Open FLI files ready for playing, reading the data from disk.

Identifies Operating System.

Set by al_init to either True or False depending on whether your Operating System is multitasking or not.

Identifies the Operating System.

Version of al_override_config_file which uses a block of data that has already been read into memory.

To be used to identify an opened file.

Packfile vtable structure, for custom packfiles.

Closes the stream f previously opened with al_pack_fopen.

Finds out if you have reached the end of the file.

Reads a line from the stream f and returns it.

Opens a sub-chunk of a file.

Writes a string to the stream f.

Moves the position indicator of the stream f.

Returns the next character from the stream `f', or EOF if the end of the file has been reached.

Like al_pack_getc, but reads a 16-bit word from a file, using Intel byte ordering (least significant byte first, a.k.a.

Like al_pack_putc, but writes a 16-bit word to a file, using Intel byte ordering (least significant byte first, a.k.a.

Like al_pack_getc, but reads a 16-bit word from a file, using Motorola byte ordering (most significant byte first, a.k.a.

Like al_pack_putc, but writes a 16-bit word from a file, using Motorola byte ordering (most significant byte first, a.k.a.

Puts a character back to the file's input buffer.

Pointer to a AL_PALETTE.

To be used by al_palette_color.

To know the palette size.

Defined to TRUE if current version is a BETA version.

Defined to a text string containing all version numbers and maybe some additional text.

Same as al_persp_project_f but using floats instead than fixed.

Rotates and stretches a sprite.

Like al_rotate_scaled_sprite_v_flip, but aligns the point in the sprite given by cx, cy to x, y in the bitmap, then rotates and scales around this point.

Rotates and stretches a sprite.

Rotates a sprite.

Like al_rotate_sprite_v_flip, but aligns the point in the sprite given by cx, cy to x, y in the bitmap, then rotates around this point.

Rotates and flips a sprite around a specified point.

When used in combination with the loop flag, causes the sample to change direction each time it reaches one of the loop points, so it alternates between playing forwards and in reverse.

Loops repeatedly through the sample, jumping back to the loop start position upon reaching the loop end.

Plays an Autodesk Animator FLI or FLC animation file on the specified AL_BITMAP, reading the data from disk as it is required.

Plays an Autodesk Animator FLI or FLC animation on the specified AL_BITMAP, reading the data from a copy of the file which is held in memory.

Triggers a sample at the specified volume, pan position, and frequency.

This is used to define call-back procedures for some drawing procedures.

Wherever possible, Allegro will read the keyboard input asynchronously (ie.

Checks the status of a scroll request with triple buffering.

Draw 3d polygons onto the specified bitmap, using the specified rendering mode.

Same as al_polygon_z_normal_f but using fixed instead than floats.

Returns the sign of the z normal of the polygon.

Like AL_POLYTYPE_ATEX, but the global al_color_table (for 256-color modes) or blender function (for non-MMX truecolor modes) is used to blend the texture with a light level taken from the `c' value in the vertex structure.

Like AL_POLYTYPE_ATEX_LIT, but al_bitmap_mask_color texture map pixels are skipped, allowing parts of the texture map to be transparent.

Render translucent textures.

A single-color gouraud shaded polygon.

Like AL_POLYTYPE_PTEX, but the global al_color_table (for 256-color modes) or blender function (for non-MMX truecolor modes) is used to blend the texture with a light level taken from the `c' value in the vertex structure.

Like AL_POLYTYPE_PTEX_LIT, but al_bitmap_mask_color texture map pixels are skipped, allowing parts of the texture map to be transparent.

Render translucent textures.

Like al_do_dialog, but it stores the data on the screen before drawing the dialog and restores it when the dialog is closed.

Moves an array of dialog objects to the specified screen position (specified as the top left corner of the dialog).

Sets the horizontal mouse wheel position variable to the specified value.

Pushes the current configuration state (filename, variable values, etc).

Optimised routine for scaling an already generated matrix: this simply adds in the scale factor, so there is no need to build two temporary matrices and then multiply them together.

Optimised routine for translating an already generated matrix: this simply adds in the translation offset, so there is no need to build two temporary matrices and then multiply them together.

Draw 3D quads, using fixed point vertex structures.

Quaternion.

Constructs a quaternion that represents a rotation between aFrom and aTo.

The same as al_quat_interpolate, but allows more control over how the rotation is done.

This constant gives a ratio which can be used to convert a fixed point number in radians to a fixed point number in binary angle format.

Switches an already-allocated voice to use a different sample.

Draws a solid, filled rectangle with the two points as its opposite corners.

Releases a bitmap that was previously locked by calling al_acquire_bitmap.

Releases a soundcard voice, indicating that you are no longer interested in manipulating it.

Removes a function from the list of user interrupt routines.

Removes the keyboard handler, returning control to the operating system.

Like al_remove_int, but for use with timer callbacks that have parameter values.

Removes the Allegro timer handler.

Requests that the next call to al_set_gfx_mode try to use the specified refresh rate, if possible.

Requests a page flip to display the specified video bitmap object, but returns immediately rather than waiting for a retrace.

Once you have done whatever you are going to do with the al_fli_bitmap and al_fli_palette, call this function to reset the (al_fli_bmp_dirty_* )and al_fli_pal_dirty_* variables.

Like al_rest, but for non-zero values continually calls the specified function while it is waiting for the required time to elapse.

Palette entry.

Stores an rgb map to accelerate conversions.

To speed up reducing RGB values to 8-bit paletted colors, Allegro uses a 32k lookup table (5 bits for each color component).

An RLE compressed sprite.

Like al_rotate_sprite, but stretches or shrinks the image at the same time as rotating it.

Rotates and stretches a sprite.

Rotates and stretches a sprite.

Draws the sprite image onto the bitmap.

Rotates a sprite.

Rotates a sprite.

A sample structure, which holds sound data, used by the digital sample routines.

Used by al_register_sample_file_type.

Writes a bitmap into a file, using the specified palette, which should be an AL_PALETTE structure.

A version of al_save_bmp which reads a BMP file from a packfile.

Writes a bitmap into a 256-color or 24-bit truecolor PCX file.

Writes a sample into a file.

A version of al_save_tga which reads a TGA file from a packfile.

This function returns a string pointer containing the name of they key with the given scancode.

Like al_scare_mouse, but will only hide the cursor if it is inside the specified rectangle.

Puts a polygon in the rendering list.

Screen bitmap

Screen size.

Give the number of seconds between each tick to al_install_int_ex.

Ugly hack for use in various dodgy situations where you need to convert between paletted and truecolor image formats.

Enables the special alpha-channel blending mode, which is used for drawing 32-bit RGBA sprites.

Like al_set_blender_mode, but allows you to specify a more complete set of blender routines.

Each bitmap has an associated clipping rectangle, which is the area of the image that it is OK to draw onto.

On platforms that have a close button, this routine installs a callback function to handle the close event.

Enables a color blender mode for combining translucent or lit truecolor pixels.

Sets the pixel format to be used by subsequent calls to al_set_gfx_mode and al_create_bitmap.

Sets the configuration file to be used by all subsequent config functions.

Writes an integer variable to the current config file, in hexadecimal format.

Writes an integer variable to the current config file.

Sets the foreground and background colors of an array of dialog objects.

Enables a difference blender mode for combining translucent or lit truecolor pixels.

Sets how the program should handle being switched into the background, if the user tabs away from it.

Enables a dodge blender mode for combining translucent or lit truecolor pixels.

Switches into graphics mode.

Enables a hue blender mode for combining translucent or lit truecolor pixels.

Sets the keyboard repeat rate.

Enables a luminance blender mode for combining translucent or lit truecolor pixels.

Sets the resampling quality of the mixer.

You don't like Allegro's mouse pointer? No problem.

Enables a multiply blender mode for combining translucent or lit truecolor pixels.

Sets the palette entries between aFrom and aTo (inclusive: pass 0 and 255 to set the entire palette).

Sets the viewport used to scale the output of the al_persp_project function.