Author: Laurence D. Finston.
This copyright notice applies to the text and source code of this web site, and the graphics that appear on it. The software described in this text has its own copyright notice and license, which can be found in the distribution itself.
Copyright (C) 2005, 2006 The Free Software Foundation
Permission is granted to copy, distribute, and/or modify this document under the terms of the GNU Free Documentation License, Version 1.2 or any later version published by the Free Software Foundation; with no Invariant Sections, with no Front-Cover Texts, and with no Back-Cover Texts. A copy of this license is included in the file COPYING.TXT
Last updated: April 29, 2006
| Top |
| Non-Drawable Types |
| Drawable Types |
| Declaring Variables |
| Vector Types |
| Contact |
In order to use 3DLDF in a sensible way, one must declare variables. These variables have various types. The following is an alphabetical list of the types of objects that can be declared in 3DLDF as of 2005.11.14. Types are added fairly frequently, so it may not be up-to-date.
bool_point bool_point_vector boolean boolean_vector circle circle_slice circle_slice_vector circle_vector color color_vector cone cone_vector cuboid cuboid_vector cylinder cylinder_vector dash_pattern dash_pattern_vector ellipse ellipse_slice ellipse_slice_vector ellipse_vector ellipsoid ellipsoid_vector focus focus_vector glyph glyph_vector helix helix_vector hyperbola hyperbola_vector macro macro_vector numeric numeric_vector nurb nurb_vector origami_figure origami_figure_vector parabola parabola_vector path path_vector pen pen_vector picture picture_vector plane plane_vector point point_vector polygon polygon_vector polyhedron polyhedron_slice polyhedron_slice_vector polyhedron_vector rectangle rectangle_vector reg_polygon reg_polygon_vector sphere sphere_vector string string_vector transform transform_vector triangle triangle_vector
These types can be categorized in a couple of different ways. Some of them are drawable while others are non-drawable. For example, point is drawable while boolean is not.
Another difference is that some are ordinary types, while others are vector types. Every ordinary type has a corresponding vector type. For example, path and path_vector are corresponding types.
These are the non-drawable types (leaving out the corresponding vector types):
boolean color dash_pattern focus macro numeric pen picture plane string transform
These are the drawable types (leaving out the corresponding vector types):
bool_point circle circle_slice cone cuboid cylinder ellipse ellipse_slice ellipsoid glyph helix hyperbola nurb origami_figure parabola path point polygon polyhedron polyhedron_slice rectangle reg_polygon sphere triangle
bool_point is really a combination of a non-drawable and
a drawable type.
Some of these types are not yet fully functional. This is a list of them:
circle_slice cone cylinder ellipse_slice glyph helix hyperbola nurb origami_figure polyhedron_slice
The
types _slicecircle_slice,
ellipse_slice, and polyhedron_slice, are
intended to represent the geometric figures formed by the intersections of
other geometric figures.
That leaves the following list of drawable types which can currently be used:
bool_point circle cuboid ellipse ellipsoid parabola path point polygon polyhedron rectangle reg_polygon sphere triangle
All non-vector types are declared using the same syntax.
The simplest form of declaration consists of a type name,
the name of the variable you want to declare, and a semi-colon:
point p;
Multiple variables can be declared in a single declaration. The names
should be separated by commata:
point p, q, r, s;
In addition, arrays of variables can be declared. To do
this, a generic subscript must be used in the variable
name. A generic subscript is an empty pair of square brackets:
path a[];
Now, the name a followed by a numerical subscript
refers to a path. For example, following the declaration above,
a0, a[1], and a[1.5] all refer to different
paths. When the subscript is just a number, the square brackets can
be left out, so a0 and a[0] refer to the same path,
as do a1.5 and a[1.5]. However, the numerical subscript can also be an
expression (to be explained elsewhere). For example, 3/2 = 1.5, so
a[3/2] refers to the same path as a[1.5]. In the case of
a[3/2], the square brackets must be used, or 3DLDF will think
you're trying to divide a path a3 by 2, which is an invalid operation.
A variable can have multiple subscripts:
path n[]op[];
Now n0op1 and n2.5op[7/8] refer to paths.
Ordinary and array declarations can be mixed, e.g.,
path A, B[], C[]D[], E;
As mentioned above, each of the ordinary object types defined in 3DLDF has a corresponding
vector type. Objects of these types are declared in the same way as objects of
other types, except that they shouldn't be declared as arrays.
Declaring them with a single generic subscript at the end of the name
is equivalent to declaring them with no subscript at all. Any other
use of one or more generic subscripts is invalid:
point_vector pv; % The recommended style
point_vector qv[]; % Equivalent to using no generic subscript,
but not the recommended style
point_vector r[]v; % INVALID
point_vector sv[][]; % INVALID
The declaration point_vector pv, in addition to creating an object
of type point_vector called pv, implicitly declares an
array of points with the same name plus a generic subscript.
In other words, it is as though point pv[] had also been declared.
The main reason for this is to make it possible to access all of the elements of an array in a single command. METAFONT has no vector types, so one must loop over the elements of an array. In order to do this, one must know what subscripts to use.
| PREVIOUS CHAPTER: | Introduction to the Grammar |
| NEXT CHAPTER: | Assignments |