# FreeBSD Manual Pages

```MATRIX(3)		   Library Functions Manual		     MATRIX(3)

NAME
ident,  matmul,	matmulr,  determinant, adjoint,	invertmat, xformpoint,
xformpointd, xformplane,	 pushmat,  popmat,  rot,  qrot,	 scale,	 move,
xform, ixform, persp, look, viewport - Geometric	transformations

SYNOPSIS
#include	<draw.h>

#include	<geometry.h>

void ident(Matrix m)

void matmul(Matrix a, Matrix b)

void matmulr(Matrix a, Matrix b)

double determinant(Matrix m)

double invertmat(Matrix m, Matrix inv)

Point3 xformpoint(Point3	p, Space *to, Space *from)

Point3 xformpointd(Point3 p, Space *to, Space *from)

Point3 xformplane(Point3	p, Space *to, Space *from)

Space *pushmat(Space *t)

Space *popmat(Space *t)

void rot(Space *t, double theta,	int axis)

void qrot(Space *t, Quaternion q)

void scale(Space	*t, double x, double y,	double z)

void move(Space *t, double x, double y, double z)

void xform(Space	*t, Matrix m)

void ixform(Space *t, Matrix m, Matrix inv)

int persp(Space *t, double fov, double n, double	f)

void look(Space *t, Point3 eye, Point3 look, Point3 up)

void viewport(Space *t, Rectangle r, double aspect)

DESCRIPTION
These  routines	manipulate  3-space  affine and	projective transforma-
tions, represented as 4x4 matrices, thus:

typedef double Matrix;

Ident stores an identity	matrix in its argument.	 Matmul	stores axb  in
a.   Matmulr  stores  bxa in b.	Determinant returns the	determinant of
matrix m.  Adjoint stores the adjoint (matrix of	 cofactors)  of	 m  in
madj.   Invertmat stores	the inverse of matrix m	in minv, returning m's
determinant.  Should m be singular (determinant zero), invertmat	stores

The rest	of the routines	described here manipulate Spaces and transform
Point3s.	 A Point3 is a point in	three-space, represented by its	 homo-
geneous coordinates:

typedef struct Point3 Point3;
struct Point3{
double x, y, z, w;
};

The  homogeneous	coordinates (x,	y, z, w) represent the Euclidean point
(x/w, y/w, z/w) if wa 0,	and a ``point at infinity'' if w=0.

A Space is just a data structure	describing a coordinate	system:

typedef struct Space Space;
struct Space{
Matrix t;
Matrix tinv;
Space *next;
};

It contains a pair of transformation matrices  and  a  pointer  to  the
Space's	parent.	  The matrices transform points	to and from the	``root
coordinate system,'' which is represented by a null Space pointer.

Pushmat creates a new Space.  Its argument is a pointer to  the	parent
space.	Its  result  is	a newly	allocated copy of the parent, but with
its next	pointer	pointing at the	parent.	  Popmat  discards  the	 Space
that  is	 its  argument,	 returning a pointer to	the stack.  Nominally,
these two functions define a stack of transformations, but pushmat  can
be  called  multiple times on the same Space multiple times, creating a
transformation tree.

Xformpoint and Xformpointd both transform points	from the Space pointed
to  by from to the space	pointed	to by to.  Either pointer may be null,
indicating the root coordinate system.  The difference between the  two
functions  is  that  xformpointd	 divides x, y, z, and w	by w, if wa 0,
making (x, y, z)	the Euclidean coordinates of the point.

Xformplane transforms planes or normal vectors.	A plane	 is  specified
by the coefficients (a, b, c, d)	of its implicit	equation ax+by+cz+d=0.
Since this representation is dual to the	homogeneous representation  of
points, libgeometry represents planes by	Point3 structures, with	(a, b,
c, d) stored in (x, y, z, w).

The remaining functions transform the coordinate	system represented  by
a  Space.   Their Space * argument must be non-null -- you can't	modify
the root	Space.	Rot rotates by angle  theta  (in  radians)  about  the
given  axis,  which  must be one	of XAXIS, YAXIS	or ZAXIS.  Qrot	trans-
forms by	a rotation about an arbitrary axis, specified by Quaternion q.

Scale scales the	coordinate system by the given scale  factors  in  the
directions  of  the three axes.	Move translates	by the given displace-
ment in the three axial directions.

Xform transforms	the coordinate system by the given Matrix.  If the ma-
trix's  inverse is known	a priori, calling ixform will save the work of
recomputing it.

Persp does a perspective	transformation.	 The transformation  maps  the
frustum with apex at the	origin,	central	axis down the positive y axis,
and apex	angle fov and clipping planes y=n and y=f into the double-unit
cube.  The plane	y=n maps to y'=-1, y=f maps to y'=1.

Look  does  a  view-pointing transformation.  The eye point is moved to
the origin.  The	line through the eye and look points is	 aligned  with
the y axis, and the plane containing the	eye, look and up points	is ro-
tated into the x-y plane.

Viewport	maps the unit-cube window into the given screen	viewport.  The
viewport	 rectangle  r has r.min	at the top left-hand corner, and r.max
just outside the	lower right-hand corner.  Argument aspect is  the  as-
pect  ratio  (dx/dy)  of	 the viewport's	pixels (not of the whole view-
port).  The whole window	is transformed	to  fit	 centered  inside  the
viewport	 with  equal  slop on either top and bottom or left and	right,
depending on the	viewport's aspect ratio.  The window  is  viewed  down
the y axis, with	x to the left and z up.	 The viewport has x increasing
to the right and	y increasing down.  The	 window's  y  coordinates  are
mapped, unchanged, into the viewport's z	coordinates.

SOURCE
/src/libgeometry/matrix.c