These functions construct 4x4 matrices for transformations in the homogeneous coordinate system used by OpenGL, and translate vectors between homogeneous and Euclidean coordinates.

1 2 3 4 5 6 7 8 9 10 11 12 | ```
identityMatrix()
scaleMatrix(x, y, z)
translationMatrix(x, y, z)
rotationMatrix(angle, x, y, z, matrix)
asHomogeneous(x)
asEuclidean(x)
scale3d(obj, x, y, z, ...)
translate3d(obj, x, y, z, ...)
rotate3d(obj, angle, x, y, z, matrix, ...)
transform3d(obj, matrix, ...)
``` |

`x, y, z, angle, matrix` |
See details |

`obj` |
An object to be transformed |

`...` |
Additional parameters to be passed to methods |

OpenGL uses homogeneous coordinates to handle perspective and affine
transformations. The homogeneous point `(x, y, z, w)`

corresponds
to the Euclidean point `(x/w, y/w, z/w)`

. The matrices produced by
the functions `scaleMatrix`

, `translationMatrix`

, and `rotationMatrix`

are to be left-multiplied by a row vector
of homogeneous coordinates; alternatively, the transpose of the result
can be right-multiplied by a column vector. The generic functions
`scale3d`

, `translate3d`

and `rotate3d`

apply these transformations
to the `obj`

argument. The `transform3d`

function is a synonym
for `rotate3d(obj, matrix = matrix)`

.

By default, it is assumed that `obj`

is a row vector
(or a matrix of row vectors) which will be multiplied on the right by
the corresponding matrix, but users may write methods for these generics
which operate differently. Methods are supplied for `mesh3d`

objects.

To compose transformations, use matrix multiplication. The effect is to apply the matrix on the left first, followed by the one on the right.

`identityMatrix`

returns an identity matrix.

`scaleMatrix`

scales each coordinate by the given factor. In Euclidean
coordinates, `(u, v, w)`

is transformed to `(x*u, y*v, z*w)`

.

`translationMatrix`

translates each coordinate by the given translation, i.e.
`(u, v, w)`

is transformed to `(u + x, v + y, w + z)`

.

`rotationMatrix`

can be called in three ways. With
arguments `angle, x, y, z`

it represents a rotation
of `angle`

radians about the axis
`x, y, z`

. If `matrix`

is a 3x3 rotation matrix,
it will be converted into the corresponding matrix in 4x4 homogeneous
coordinates. Finally, if a 4x4 matrix is given, it will be returned unchanged.
(The latter behaviour is used to allow `transform3d`

to act like a
generic function, even though it is not.)

Use `asHomogeneous(x)`

to convert the Euclidean vector `x`

to
homogeneous coordinates, and `asEuclidean(x)`

for the reverse transformation.

`identityMatrix`

,
`scaleMatrix`

, `translationMatrix`

, and `rotationMatrix`

produce
a 4x4 matrix representing the requested transformation
in homogeneous coordinates.

`scale3d`

, `translate3d`

and `rotate3d`

transform the object
and produce a new object of the same class.

Duncan Murdoch

`par3d`

for a description of how rgl uses matrices in
rendering.

1 2 3 4 5 6 7 8 9 10 11 12 13 | ```
# A 90 degree rotation about the x axis:
rotationMatrix(pi/2, 1, 0, 0)
# Find what happens when you rotate (2, 0, 0) by 45 degrees about the y axis:
x <- asHomogeneous(c(2, 0, 0))
y <- x
asEuclidean(y)
# or more simply...
rotate3d(c(2, 0, 0), pi/4, 0, 1, 0)
``` |

Questions? Problems? Suggestions? Tweet to @rdrrHQ or email at ian@mutexlabs.com.

All documentation is copyright its authors; we didn't write any of that.