r3d {rgl} | R Documentation

## Generic 3D interface

### Description

Generic 3D interface for 3D rendering and computational geometry.

### Details

R3d is a design for an interface for 3d rendering and computation without dependency on a specific rendering implementation. R3d includes a collection of 3D objects and geometry algorithms. All r3d interface functions are named `*3d`. They represent generic functions that delegate to implementation functions.

The interface can be grouped into 8 categories: Scene Management, Primitive Shapes, High-level Shapes, Geometry Objects, Visualization, Interaction, Transformation, Subdivision.

The rendering interface gives an abstraction to the underlying rendering model. It can be grouped into four categories:

Scene Management:

  A 3D scene consists of shapes, lights and background environment.

Primitive Shapes:

  Generic primitive 3D graphics shapes such as points, lines, triangles, quadrangles and texts.

High-level Shapes:

  Generic high-level 3D graphics shapes such as spheres, sprites and terrain.

Interaction:

  Generic interface to select points in 3D space using the pointer device.

In this package we include an implementation of r3d using the underlying `rgl.*` functions.

3D computation is supported through the use of object structures that live entirely in R.

Geometry Objects:

  Geometry and mesh objects allow to define high-level geometry for computational purpose such as triangle or quadrangle meshes (see `mesh3d`).

Transformation:

  Generic interface to transform 3d objects.

Visualization:

  Generic rendering of 3d objects such as dotted, wired or shaded.

Computation:

  Generic subdivision of 3d objects.

At present, the main practical differences between the r3d functions and the `rgl.*` functions are as follows.

The r3d functions call `open3d` if there is no device open, and the `rgl.*` functions call `rgl.open`. By default `open3d` sets the initial orientation of the coordinate system in 'world coordinates', i.e. a right-handed coordinate system in which the x-axis increases from left to right, the y-axis increases with depth into the scene, and the z-axis increases from bottom to top of the screen. `rgl.*` functions, on the other hand, use a right-handed coordinate system similar to that used in OpenGL. The x-axis matches that of r3d, but the y-axis increases from bottom to top, and the z-axis decreases with depth into the scene. Since the user can manipulate the scene, either system can be rotated into the other one.

The r3d functions also preserve the `rgl.material` setting across calls (except for texture elements, in the current implementation), whereas the `rgl.*` functions leave it as set by the last call.

The example code below illustrates the two coordinate systems.

### See Also

`points3d`, `lines3d`, `segments3d`, `triangles3d`, `quads3d`, `text3d`, `spheres3d`, `sprites3d`, `terrain3d`, `select3d`, `dot3d`, `wire3d`, `shade3d`, `transform3d`, `rotate3d`, `subdivision3d`, `mesh3d`, `cube3d`, `rgl`

### Examples

         x <- c(0, 1, 0, 0)
         y <- c(0, 0, 1, 0)
         z <- c(0, 0, 0, 1)
         labels <- c("Origin", "X", "Y", "Z")
         i <- c(1, 2, 1, 3, 1, 4)

         # rgl.* interface

         rgl.open()
         rgl.texts(x, y, z, labels)
         rgl.texts(1, 1, 1, "rgl.* coordinates")
         rgl.lines(x[i], y[i], z[i])

         # *3d interface

         open3d()
         text3d(x, y, z, labels)
         text3d(1, 1, 1, "*3d coordinates")
         segments3d(x[i], y[i], z[i])

[Package rgl version 0.100.19 Index]