Primitives Addon

High Level Drawing Routines

al_draw_line

void al_draw_line(float x1, float y1, float x2, float y2,
   ALLEGRO_COLOR color, float thickness)

Draws a line segment between two points.

Parameters:

x1, y1, x2, y2 - Start and end points of the line
color - Color of the line
thickness - Thickness of the line, pass <= 0 to draw hairline lines

al_draw_triangle

void al_draw_triangle(float x1, float y1, float x2, float y2,
   float x3, float y3, ALLEGRO_COLOR color, float thickness)

Draws an outlined triangle.

Parameters:

x1, y1, x2, y2, x3, y3 - Three points of the triangle
color - Color of the triangle
thickness - Thickness of the lines, pass <= 0 to draw hairline lines

al_draw_filled_triangle

void al_draw_filled_triangle(float x1, float y1, float x2, float y2,
   float x3, float y3, ALLEGRO_COLOR color)

Draws a filled triangle.

Parameters:

x1, y1, x2, y2, x3, y3 - Three points of the triangle
color - Color of the triangle

al_draw_rectangle

void al_draw_rectangle(float x1, float y1, float x2, float y2,
   ALLEGRO_COLOR color, float thickness)

Draws an outlined rectangle.

Parameters:

x1, y1, x2, y2 - Upper left and lower right points of a rectangle
color - Color of the rectangle
thickness - Thickness of the lines, pass <= 0 to draw hairline lines

al_draw_filled_rectangle

void al_draw_filled_rectangle(float x1, float y1, float x2, float y2,
   ALLEGRO_COLOR color)

Draws a filled rectangle.

Parameters:

x1, y1, x2, y2 - Upper left and lower right points of a rectangle
color - Color of the rectangle

al_draw_rounded_rectangle

void al_draw_rounded_rectangle(float x1, float y1, float x2, float y2,
   float rx, float ry, ALLEGRO_COLOR color, float thickness)

Draws an outlined rounded rectangle.

Parameters:

x1, y1, x2, y2 - Upper left and lower right points of a rectangle
color - Color of the rectangle
rx, ry - The radii of the round
thickness - Thickness of the lines, pass <= 0 to draw hairline lines

al_draw_filled_rounded_rectangle

void al_draw_filled_rounded_rectangle(float x1, float y1, float x2, float y2,
   float rx, float ry, ALLEGRO_COLOR color)

Draws an filled rounded rectangle.

Parameters:

x1, y1, x2, y2 - Upper left and lower right points of a rectangle
color - Color of the rectangle
rx, ry - The radii of the round

al_calculate_arc

void al_calculate_arc(float* dest, int stride, float cx, float cy,
   float rx, float ry, float start_theta, float delta_theta, float thickness,
   int num_segments)

Calculates an elliptical arc, and sets the vertices in the destination to the calculated positions. If thickness <= 0, then num_points of points are required in the destination, otherwise twice as many are needed. The destination buffer should consist of regularly spaced (by distance of stride bytes) doublets of floats, corresponding to x and y coordinates of the vertices.

Parameters:

dest - Pointer to the destination buffer
stride - Distance (in bytes) between successive pairs of coordinates
cx, cy - Center of the arc
rx, ry - Radii of the arc
start_theta - The initial angle from which the arc is calculated
delta_theta - Angular span of the arc (pass a negative number to switch direction)
thickness - Thickness of the arc
num_points - The number of points to calculate

al_draw_ellipse

void al_draw_ellipse(float cx, float cy, float rx, float ry,
   ALLEGRO_COLOR color, float thickness)

Draws an outlined ellipse.

Parameters:

cx, cy - Center of the ellipse
rx, ry - Radii of the ellipse
color - Color of the ellipse
thickness - Thickness of the ellipse, pass <= 0 to draw hairline ellipse

al_draw_filled_ellipse

void al_draw_filled_ellipse(float cx, float cy, float rx, float ry,
   ALLEGRO_COLOR color)

Draws a filled ellipse.

Parameters:

cx, cy - Center of the ellipse
rx, ry - Radii of the ellipse
color - Color of the ellipse

al_draw_circle

void al_draw_circle(float cx, float cy, float r, ALLEGRO_COLOR color,
   float thickness)

Draws an outlined circle.

Parameters:

cx, cy - Center of the circle
r - Radius of the circle
color - Color of the circle
thickness - Thickness of the circle, pass <= 0 to draw hairline circle

al_draw_filled_circle

void al_draw_filled_circle(float cx, float cy, float r, ALLEGRO_COLOR color)

Draws a filled circle.

Parameters:

cx, cy - Center of the circle
r - Radius of the circle
color - Color of the circle

al_draw_arc

void al_draw_arc(float cx, float cy, float r, float start_theta,
   float delta_theta, ALLEGRO_COLOR color, float thickness)

Draws an arc.

Parameters:

cx, cy - Center of the arc
r - Radius of the arc
color - Color of the arc
start_theta - The initial angle from which the arc is calculated
delta_theta - Angular span of the arc (pass a negative number to switch direction)
thickness - Thickness of the circle, pass <= 0 to draw hairline circle

al_calculate_spline

void al_calculate_spline(float* dest, int stride, float points[8],
   float thickness, int num_segments)

Calculates a spline given 4 control points. If thickness <= 0, then num_segments of points are required in the destination, otherwise twice as many are needed. The destination buffer should consist of regularly spaced (by distance of stride bytes) doublets of floats, corresponding to x and y coordinates of the vertices.

Parameters:

dest - Pointer to the destination buffer
stride - Distance (in bytes) between successive pairs of coordinates
points - An array of 4 pairs of coordinates of the 4 control points
thickness - Thickness of the spline ribbon
num_segments - The number of points to calculate

al_draw_spline

void al_draw_spline(float points[8], ALLEGRO_COLOR color, float thickness)

Draws a spline given 4 control points.

Parameters:

points - An array of 4 pairs of coordinates of the 4 control points
color - Color of the spline
thickness - Thickness of the spline, pass <= 0 to draw hairline spline

al_calculate_ribbon

void al_calculate_ribbon(float* dest, int dest_stride, const float *points,
   int points_stride, float thickness, int num_segments)

Calculates a ribbon given an array of points. The ribbon will go through all of the passed points. If thickness <= 0, then num_segments of points are required in the destination buffer, otherwise twice as many are needed. The destination and the points buffer should consist of regularly spaced doublets of floats, corresponding to x and y coordinates of the vertices.

Parameters:

dest - Pointer to the destination buffer
dest_stride - Distance (in bytes) between successive pairs of coordinates in the destination buffer
points - An array of pairs of coordinates for each point
points_stride - Distance (in bytes) between successive pairs of coordinates in the points buffer
thickness - Thickness of the spline ribbon
num_segments - The number of points to calculate

al_draw_ribbon

void al_draw_ribbon(const float *points, int points_stride, ALLEGRO_COLOR color,
   float thickness, int num_segments)

Draws a ribbon given given an array of points. The ribbon will go through all of the passed points.

Parameters:

points - An array of pairs of coordinates for each point
color - Color of the spline
thickness - Thickness of the spline, pass <= 0 to draw hairline spline

Low Level Drawing Routines

al_draw_prim

int al_draw_prim(ALLEGRO_VERTEX* vtxs, ALLEGRO_BITMAP* texture,
   int start, int end, int type)

Draws a subset of the passed vertex buffer. It is recommended for the texture to have its dimensions be a power of 2 for maximum portability with older video cards.

Parameters:

texture - Texture to use, pass 0 to use only shaded primitves
vtxs - Pointer to an array of vertices
start, end - Start and end of the subset of the vertex buffer to draw
type - Primitive type to draw

Returns: Number of primitives drawn

al_draw_indexed_prim

int al_draw_indexed_prim(ALLEGRO_VERTEX* vtxs, ALLEGRO_BITMAP* texture,
   const int* indices, int num_vtx, int type)

Draws a subset of the passed vertex buffer. This function uses an index array to specify which vertices to use. It is recommended for the texture to have its dimensions be a power of 2 for maximum portability with older video cards.

Parameters:

texture - Texture to use, pass 0 to use only shaded primitves
vtxs - Pointer to an array of vertices
indices - An array of indices into the vertex buffer
num_vtx - Number of indices from the indices array you want to draw
type - Primitive type to draw

Returns: Number of primitives drawn

al_get_allegro_color

Converts an ALLEGRO_COLOR into a ALLEGRO_PRIM_COLOR.

Parameters:

col - ALLEGRO_COLOR to convert

Returns: Converted ALLEGRO_PRIM_COLOR

al_get_prim_color

Converts an ALLEGRO_PRIM_COLOR into a ALLEGRO_COLOR.

Parameters:

col - ALLEGRO_PRIM_COLOR to convert

Returns: Converted ALLEGRO_COLOR

al_draw_soft_triangle

void al_draw_soft_triangle(
   ALLEGRO_VERTEX* v1, ALLEGRO_VERTEX* v2, ALLEGRO_VERTEX* v3, uintptr_t state,
   void (*init)(uintptr_t, ALLEGRO_VERTEX*, ALLEGRO_VERTEX*, ALLEGRO_VERTEX*),
   void (*first)(uintptr_t, int, int, int, int),
   void (*step)(uintptr_t, int), 
   void (*draw)(uintptr_t, int, int, int))

Draws a triangle using the software rasterizer and user supplied pixel functions. For help in understanding what these functions do, see the implementation of the various shading routines in addons/primitives/tri_soft.c. The triangle is drawn in two segments, from top to bottom. The segments are deliniated by the vertically middle vertex of the triangle. One of each segment may be absent if two vertices are horizontally collinear.

Parameters:

v1, v2, v3 - The three vertices of the triangle
state - A pointer to a user supplied struct, this struct will be passed to all the pixel functions
init - This function is called once, before any drawing is done. The three points passed to it may be altered by clipping.
first - The function is called twice, once per triangle segment. It is passed 4 parameters, the first two are the coordinates of the initial pixel drawn in the segment. The second two are the left minor and the left major steps, respectively. They represent the sizes of two steps taken by the rasterizer as it walks on the left side of the triangle. From then on, the each step will either be classified as a minor or a major step, corresponding to the above values.
step - Called once per scanline. The last parameter is set to 1 if the step is a minor step, and 0 if it is a major step.
draw - Called once per scanline. The function is expected to draw the scanline starting with a point specified by the first two parameters (corresponding to x and y values) going to the right until it reaches the value of the third parameter (the x value of the end point). All coordinates are inclusive.

al_draw_soft_line

void al_draw_soft_line(ALLEGRO_VERTEX* v1, ALLEGRO_VERTEX* v2, uintptr_t state,
   void (*first)(uintptr_t, int, int, ALLEGRO_VERTEX*, ALLEGRO_VERTEX*),
   void (*step)(uintptr_t, int),
   void (*draw)(uintptr_t, int, int))

Draws a line using the software rasterizer and user supplied pixel functions. For help in understanding what these functions do, see the implementation of the various shading routines in addons/primitives/line_soft.c. The line is drawn top to bottom.

Parameters:

v1, v2 - The two vertices of the line
state - A pointer to a user supplied struct, this struct will be passed to all the pixel functions
first - The function is called before drawing the first pixel of the line. It is passed the coordinates of this pixel, as well as the two vertices above. The passed vertices may have been altered by clipping.
step - Called once per pixel. The second parameter is set to 1 if the step is a minor step, and 0 if this step is a major step. Minor steps are taken only either in x or y directions. Major steps are taken in both directions diagonally. In all cases, the the absolute value of the change in coordinate is at most 1 in either direction.
draw - Called once per pixel. The function is expected to draw the pixel at the two coordinates passed to it.

Transformations

al_copy_transform

void al_copy_transform(ALLEGRO_TRANSFORM* src, ALLEGRO_TRANSFORM* dest)

Makes a copy of a transformation.

Parameters:

src - Source transformation
dest - Destination transformation

al_use_transform

void al_use_transform(ALLEGRO_TRANSFORM* trans)

Sets the transformation to be used for the primitive drawing operations. Every drawing operation after this call will be transformed using this transformation. Call this function with the identity before using non-primitive drawing functions (e.g. drawing bitmaps), otherwise the behaviour of those functions will not be defined.

Parameters:

trans - Transformation to use

al_identity_transform

void al_identity_transform(ALLEGRO_TRANSFORM* trans)

Sets the transformation to be the identity transformation.

Parameters:

trans - Transformation to alter

al_build_transform

void al_build_transform(ALLEGRO_TRANSFORM* trans, float x, float y,
   float sx, float sy, float theta)

Builds a transformation given some parameters. This call is equivalent to calling the transformations in this order: make identity, scale, rotate, translate. This method is faster, however.

Parameters:

trans - Transformation to alter
x, y - Translation
sx, sy - Scale
theta - Rotation angle

al_translate_transform

void al_translate_transform(ALLEGRO_TRANSFORM* trans, float x, float y)

Apply a translation to a transformation.

Parameters:

trans - Transformation to alter
x, y - Translation

al_rotate_transform

void al_rotate_transform(ALLEGRO_TRANSFORM* trans, float theta)

Apply a rotation to a transformation.

Parameters:

trans - Transformation to alter
theta - Rotation angle

al_scale_transform

void al_scale_transform(ALLEGRO_TRANSFORM* trans, float sx, float sy)

Apply a scale to a transformation.

Parameters:

trans - Transformation to alter
sx, sy - Scale

al_transform_vertex

void al_transform_vertex(ALLEGRO_TRANSFORM* trans, ALLEGRO_VERTEX* vtx)

Transform a vertex.

Parameters:

trans - Transformation to use
vtx - Vertex to transform

al_transform_transform

void al_transform_transform(ALLEGRO_TRANSFORM* trans, ALLEGRO_TRANSFORM* trans2)

Transform a transformation.

Parameters:

trans - Transformation to use
trans2 - Transformation to transform

Structures and Types

ALLEGRO_PRIM_COLOR

typedef struct {

A special structure that defines a color in a way that understandable to both OpenGL and Direct3D backends. You should never access internal fields, instead using the two conversion functions to convert between it and ALLEGRO_COLOR structure.

ALLEGRO_VERTEX

typedef struct {

Defines the generic vertex type, with a 2D position, color and texture coordinates for a single texture.

x, y - Position of the vertex.
color - ALLEGRO_PRIM_COLOR structure
u, v - Texture coordinates

See Also: ALLEGRO_PRIM_COLOR

ALLEGRO_TRANSFORM

typedef float ALLEGRO_TRANSFORM[4][4];

Defines the generic transformation type, a 4x4 matrix. 2D transforms use only a small subsection of this matrix, namely the top left 2x2 matrix, and the right most 2x1 matrix, for a total of 6 values.

Constants

ALLEGRO_PRIM_TYPE

enum ALLEGRO_PRIM_TYPE {

Enumerates the types of primitives this addon can draw.

ALLEGRO_PRIM_LINE_LIST - A list of lines, sequential pairs of vertices define disjointed lines
ALLEGRO_PRIM_LINE_STRIP - A strip of lines, sequential vertices define a strip of lines
ALLEGRO_PRIM_LINE_LOOP - Like a line strip, except at the end the first and the last vertices are also connected by a line
ALLEGRO_PRIM_TRIANGLE_LIST - A list of triangles, sequential triplets of vertices define disjointed triangles
ALLEGRO_PRIM_TRIANGLE_STRIP - A strip of triangles, sequential vertices define a strip of triangles
ALLEGRO_PRIM_TRIANGLE_FAN - A fan of triangles, all triangles share the first vertex

ALLEGRO_VERTEX_CACHE_SIZE

#define ALLEGRO_VERTEX_CACHE_SIZE 256

Defines the size of the transformation vertex cache for the software renderer. If you pass less than this many vertices to the primitive rendering functions you will get a speed boost. This also defines the size of the cache vertex buffer, used for the high-level primitives. This corresponds to the maximum number of line segments that will be used to form them.

ALLEGRO_PRIM_QUALITY

#define ALLEGRO_PRIM_QUALITY 10

Defines the quality of the quadratic primitives. At 10, this roughly corresponds to error < 0.5 pixel.