MATRIX(2)                                               MATRIX(2)

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

          #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)

          void adjoint(Matrix m, Matrix madj)

          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)

     Page 1                       Plan 9             (printed 7/22/24)

     MATRIX(2)                                               MATRIX(2)

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

               typedef double Matrix[4][4];

          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
          its adjoint in minv.

          The rest of the routines described here manipulate Spaces
          and transform Point3s. A Point3 is a point in three-space,
          represented by its homogeneous 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 w≠0, and a ``point at
          infinity'' if w=0.

          A Space is just a data structure describing a coordinate

               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 par-
          ent.  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

     Page 2                       Plan 9             (printed 7/22/24)

     MATRIX(2)                                               MATRIX(2)

          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 w≠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 repre-
          sents planes by Point3 structures, with (a, b, c, d) stored
          in (x, y, z, w).

          The remaining functions transform the coordinate system rep-
          resented 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 transforms by a rotation
          about an arbitrary axis, specified by Quaternion q.

          Scale scales the coordinate system by the given scale fac-
          tors in the directions of the three axes.  Move translates
          by the given displacement in the three axial directions.

          Xform transforms the coordinate system by the given Matrix.
          If the matrix'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 rotated 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 aspect ratio (dx/dy) of
          the viewport's pixels (not of the whole viewport).  The
          whole window is transformed to fit centered inside the view-
          port 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.

     Page 3                       Plan 9             (printed 7/22/24)

     MATRIX(2)                                               MATRIX(2)



     Page 4                       Plan 9             (printed 7/22/24)