|  | 
 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) 
    
    
    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) 
 | 
 DESCRIPTION     
 |  |  |  | These routines manipulate 3-space affine and projective transformations,
    represented as 4×4 matrices, thus: 
 Ident stores an identity matrix in its argument. Matmul stores
    a×b in a. Matmulr stores b×a 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 double Matrix[4][4]; 
 | 
 
 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 system:|  |  |  | typedef struct Point3 Point3; struct Point3{
 };
 
 | 
 
 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 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 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 transforms 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
    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 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.|  |  |  | typedef struct Space Space; struct Space{
 
 };|  |  |  | Matrix t; Matrix tinv;
 Space *next;
 
 | 
 
 | 
 
 | 
 SOURCE     
 SEE ALSO     
 |  |