Description Usage Arguments Details Value See Also Examples

3D triangle and quadrangle mesh object creation and a collection of sample objects.

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | ```
qmesh3d(vertices, indices, homogeneous = TRUE, material = NULL,
normals = NULL, texcoords = NULL)
tmesh3d(vertices, indices, homogeneous = TRUE, material = NULL,
normals = NULL, texcoords = NULL)
as.mesh3d(x, ...)
cube3d(trans = identityMatrix(), ...)
tetrahedron3d(trans = identityMatrix(), ...)
octahedron3d(trans = identityMatrix(), ...)
icosahedron3d(trans = identityMatrix(), ...)
dodecahedron3d(trans = identityMatrix(), ...)
cuboctahedron3d(trans = identityMatrix(), ...)
oh3d(trans = identityMatrix(), ...) # an 'o' object
dot3d(x, ...) # draw dots at the vertices of an object
## S3 method for class 'mesh3d'
dot3d(x, override = TRUE, ...)
wire3d(x, ...) # draw a wireframe object
## S3 method for class 'mesh3d'
wire3d(x, override = TRUE, meshColor, ...)
shade3d(x, ...) # draw a shaded object
## S3 method for class 'mesh3d'
shade3d(x, override = TRUE, meshColor, ...)
``` |

`x` |
a |

`vertices` |
3- or 4-component vector of coordinates |

`indices` |
4-component vector of vertex indices |

`homogeneous` |
logical indicating if homogeneous (four component) coordinates are used. |

`material` |
material properties for later rendering |

`normals` |
normals at each vertex |

`texcoords` |
texture coordinates at each vertex |

`trans` |
transformation to apply to objects; see below for defaults |

`...` |
additional rendering parameters |

`override` |
should the parameters specified here override those stored in the object? |

`meshColor` |
how should colours be interpreted? See details below |

These functions create and work with `mesh3d`

objects, which consist of a matrix
of vertex coordinates together with a matrix of indices indicating which vertex is
part of which face. Such objects may have triangular faces,
planar quadrilateral faces, or both.

The `as.mesh3d`

function is generic; currently
the only method defined is `as.mesh3d.deldir`

.

The sample objects optionally take a matrix transformation `trans`

as
an argument. This transformation is applied to all vertices of the default shape.
The default is an identity transformation.

The `"shape3d"`

class is a general class for shapes that can be plotted
by `dot3d`

, `wire3d`

or `shade3d`

.

The `"mesh3d"`

class is a class of objects that form meshes: the vertices
are in member `vb`

, as a 3 or 4 by `n`

matrix. Meshes with triangular
faces will contain `it`

, a `3 * n`

matrix giving the indices of the
vertices in each face. Quad meshes will have vertex indices in `ib`

,
a `4 * n`

matrix. Individual meshes may have both types
of faces.

The `meshColor`

argument to `wire3d`

and `shade3d`

controls how material colours are interpreted. This parameter
was added in rgl version 0.100.1. Possible values are:

`"vertices"`

Colours are applied by vertex, in the order they appear in the

`vb`

matrix.`"edges"`

Colours are applied to each edge: first to the 3 edges of each triangle in the

`it`

matrix, then the 4 edges of each quad in the`ib`

matrix.`"faces"`

Colours are applied to each face: first to the triangles in the

`it`

matrix, then to the quads in the`ib`

matrix.`"legacy"`

Colours are applied in the same way as in rgl versions earlier than 0.100.1.

Unique partial matches of these values will be recognized.

If colours are specified but `meshColor`

is not,
currently a warning will by default be given that their
interpretation may have changed. This warning can be
suppressed by setting
`options(rgl.meshColorWarning = FALSE)`

. In some future
release of rgl, the default
will change to no warning.

Note that the `shade3d`

function doesn't support `meshColor = "edges"`

, and the `wire3d`

function will draw
edges twice if they are common edges between two faces; which
copy is visible depends on the `material3d("depth_test")`

setting.

`qmesh3d`

, `cube3d`

, `oh3d`

, `tmesh3d`

,
`tetrahedron3d`

, `octahedron3d`

, `icosahedron3d`

and
`dodecahedron3d`

return objects of class ```
c("mesh3d",
"shape3d")
```

. The first three of these are quad meshes, the rest are
triangle meshes.

`dot3d`

, `wire3d`

, and `shade3d`

are called for their side effect
of drawing an object into the scene; they return an object ID (or vector of IDs, for some
classes) invisibly.

See `rgl.primitive`

for a discussion of texture coordinates.

`r3d`

, `par3d`

, `shapelist3d`

for multiple shapes

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 | ```
# generate a quad mesh object
vertices <- c(
-1.0, -1.0, 0, 1.0,
1.0, -1.0, 0, 1.0,
1.0, 1.0, 0, 1.0,
-1.0, 1.0, 0, 1.0
)
indices <- c( 1, 2, 3, 4 )
open3d()
wire3d( qmesh3d(vertices, indices) )
# render 4 meshes vertically in the current view
open3d()
bg3d("gray")
l0 <- oh3d(tran = par3d("userMatrix"), color = "green" )
shade3d( translate3d( l0, -6, 0, 0 ))
l1 <- subdivision3d( l0 )
shade3d( translate3d( l1 , -2, 0, 0 ), color = "red", override = FALSE )
l2 <- subdivision3d( l1 )
shade3d( translate3d( l2 , 2, 0, 0 ), color = "red", override = TRUE )
l3 <- subdivision3d( l2 )
shade3d( translate3d( l3 , 6, 0, 0 ), color = "red" )
# render all of the Platonic solids
open3d()
shade3d( translate3d( tetrahedron3d(col = "red"), 0, 0, 0) )
shade3d( translate3d( cube3d(col = "green"), 3, 0, 0) )
shade3d( translate3d( octahedron3d(col = "blue"), 6, 0, 0) )
shade3d( translate3d( dodecahedron3d(col = "cyan"), 9, 0, 0) )
shade3d( translate3d( icosahedron3d(col = "magenta"), 12, 0, 0) )
``` |

rgl documentation built on Oct. 28, 2018, 3 p.m.

Embedding an R snippet on your website

Add the following code to your website.

For more information on customizing the embed code, read Embedding Snippets.