-
Notifications
You must be signed in to change notification settings - Fork 109
CheatSheet
slop = get_slop();
Constants: LEFT
RIGHT
FRONT
FWD
FORWARD
BACK
BOTTOM
BOT
DOWN
TOP
UP
CENTER
CTR
CENTRE
move(v) CHILDREN;
pts = move(v, p);
pts = move(STRING, p);
mat = move(v);
rot(a, [cp=], [reverse=]) CHILDREN;
rot([X,Y,Z], [cp=], [reverse=]) CHILDREN;
rot(a, v, [cp=], [reverse=]) CHILDREN;
rot(from=, to=, [a=], [reverse=]) CHILDREN;
pts = rot(a, p=, [cp=], [reverse=]);
pts = rot([X,Y,Z], p=, [cp=], [reverse=]);
pts = rot(a, v, p=, [cp=], [reverse=]);
pts = rot([a], from=, to=, p=, [reverse=]);
M = rot(a, [cp=], [reverse=]);
M = rot([X,Y,Z], [cp=], [reverse=]);
M = rot(a, v, [cp=], [reverse=]);
M = rot(from=, to=, [a=], [reverse=]);
xrot(a, [cp=]) CHILDREN;
rotated = xrot(a, p, [cp=]);
mat = xrot(a, [cp=]);
yrot(a, [cp=]) CHILDREN;
rotated = yrot(a, p, [cp=]);
mat = yrot(a, [cp=]);
zrot(a, [cp=]) CHILDREN;
rotated = zrot(a, p, [cp=]);
mat = zrot(a, [cp=]);
tilt(to=, [reverse=], [cp=]) CHILDREN;
pts = tilt(to=, p=, [reverse=], [cp=]);
M = tilt(to=, [reverse=], [cp=]);
scale(SCALAR) CHILDREN;
scale([X,Y,Z]) CHILDREN;
pts = scale(v, p, [cp=]);
mat = scale(v, [cp=]);
xscale(x, [cp=]) CHILDREN;
scaled = xscale(x, p, [cp=]);
mat = xscale(x, [cp=]);
yscale(y, [cp=]) CHILDREN;
scaled = yscale(y, p, [cp=]);
mat = yscale(y, [cp=]);
zscale(z, [cp=]) CHILDREN;
scaled = zscale(z, p, [cp=]);
mat = zscale(z, [cp=]);
xflip([x=]) CHILDREN;
pt = xflip(p, [x]);
mat = xflip([x=]);
yflip([y=]) CHILDREN;
pt = yflip(p, [y]);
mat = yflip([y=]);
zflip([z=]) CHILDREN;
pt = zflip(p, [z]);
mat = zflip([z=]);
frame_map(v1, v2, v3, [reverse=]) CHILDREN;
transformed = frame_map(v1, v2, v3, p=points, [reverse=]);
map = frame_map(v1, v2, v3, [reverse=]);
map = frame_map(x=VECTOR1, y=VECTOR2, [reverse=]);
map = frame_map(x=VECTOR1, z=VECTOR2, [reverse=]);
map = frame_map(y=VECTOR1, z=VECTOR2, [reverse=]);
skew([sxy=]|[axy=], [sxz=]|[axz=], [syx=]|[ayx=], [syz=]|[ayz=], [szx=]|[azx=], [szy=]|[azy=]) CHILDREN;
pts = skew(p, [sxy=]|[axy=], [sxz=]|[axz=], [syx=]|[ayx=], [syz=]|[ayz=], [szx=]|[azx=], [szy=]|[azy=]);
mat = skew([sxy=]|[axy=], [sxz=]|[axz=], [syx=]|[ayx=], [syz=]|[ayz=], [szx=]|[azx=], [szy=]|[azy=]);
pts = apply(transform, points);
PARENT() position(at) CHILDREN;
PARENT() orient(anchor, [spin]) CHILDREN;
PARENT() align(anchor, [align], [inside=], [inset=], [shiftout=], [overlap=]) CHILDREN;
PARENT() attach(parent, child, [align=], [spin=], [overlap=], [inside=], [inset=], [shiftout=]) CHILDREN;
PARENT() attach(parent, [overlap=], [spin=]) CHILDREN;
PARENT() force_tag([tag]) CHILDREN;
PARENT() default_tag(tag) CHILDREN;
tag_scope([scope]) CHILDREN;
diff([remove], [keep]) PARENT() CHILDREN;
tag_diff(tag, [remove], [keep]) PARENT() CHILDREN;
tag_intersect(tag, [intersect], [keep]) PARENT() CHILDREN;
conv_hull([keep]) CHILDREN;
tag_conv_hull(tag, [keep]) CHILDREN;
hide(tags) CHILDREN;
show_only(tags) CHILDREN;
show_int(tags) CHILDREN;
PARENT() face_mask(faces) CHILDREN;
PARENT() edge_mask([edges], [except]) CHILDREN;
PARENT() corner_mask([corners], [except]) CHILDREN;
PARENT() face_profile(faces, r|d=, [convexity=]) CHILDREN;
PARENT() edge_profile([edges], [except], [convexity]) CHILDREN;
PARENT() edge_profile([edges], [except], [convexity=], [flip=], [corner_type=]) CHILDREN;
PARENT() corner_profile([corners], [except], [r=|d=], [convexity=]) CHILDREN;
attachable(anchor, spin, two_d=true, size=, [size2=], [shift=], [override=], ...) {OBJECT; children();}
attachable(anchor, spin, two_d=true, r=|d=, ...) {OBJECT; children();}
attachable(anchor, spin, two_d=true, path=, [extent=], ...) {OBJECT; children();}
attachable(anchor, spin, two_d=true, region=, [extent=], ...) {OBJECT; children();}
attachable(anchor, spin, [orient], size=, [size2=], [shift=], [override=], ...) {OBJECT; children();}
attachable(anchor, spin, [orient], r=|d=, l=, [axis=], ...) {OBJECT; children();}
attachable(anchor, spin, [orient], r1=|d1=, r2=|d2=, l=, [axis=], ...) {OBJECT; children();}
attachable(anchor, spin, [orient], r=|d=, ...) {OBJECT; children();}
attachable(anchor, spin, path=, l=|h=, [extent=], ...) {OBJECT; children();}
attachable(anchor, spin, region=, l=|h=, [extent=], ...) {OBJECT; children();}
attachable(anchor, spin, [orient], vnf=, [extent=], ...) {OBJECT; children();}
attachable(anchor, spin, [orient], geom=) {OBJECT; children();}
mat = reorient(anchor, spin, [orient], two_d=true, size=, [size2=], [shift=], ...);
pts = reorient(anchor, spin, [orient], two_d=true, size=, [size2=], [shift=], p=, ...);
mat = reorient(anchor, spin, [orient], two_d=true, r=|d=, ...);
pts = reorient(anchor, spin, [orient], two_d=true, r=|d=, p=, ...);
mat = reorient(anchor, spin, [orient], two_d=true, path=, [extent=], ...);
pts = reorient(anchor, spin, [orient], two_d=true, path=, [extent=], p=, ...);
mat = reorient(anchor, spin, [orient], two_d=true, region=, [extent=], ...);
pts = reorient(anchor, spin, [orient], two_d=true, region=, [extent=], p=, ...);
mat = reorient(anchor, spin, [orient], size=, [size2=], [shift=], ...);
vnf = reorient(anchor, spin, [orient], size=, [size2=], [shift=], p=, ...);
mat = reorient(anchor, spin, [orient], r=|d=, l=, [axis=], ...);
vnf = reorient(anchor, spin, [orient], r=|d=, l=, [axis=], p=, ...);
mat = reorient(anchor, spin, [orient], r1=|d1=, r2=|d2=, l=, [axis=], ...);
vnf = reorient(anchor, spin, [orient], r1=|d1=, r2=|d2=, l=, [axis=], p=, ...);
mat = reorient(anchor, spin, [orient], r|d=, ...);
vnf = reorient(anchor, spin, [orient], r|d=, p=, ...);
mat = reorient(anchor, spin, [orient], path=, l=|h=, [extent=], ...);
vnf = reorient(anchor, spin, [orient], path=, l=|h=, [extent=], p=, ...);
mat = reorient(anchor, spin, [orient], region=, l=|h=, [extent=], ...);
vnf = reorient(anchor, spin, [orient], region=, l=|h=, [extent=], p=, ...);
mat = reorient(anchor, spin, [orient], vnf, [extent], ...);
vnf = reorient(anchor, spin, [orient], vnf, [extent], p=, ...);
a = named_anchor(name, pos, [orient], [spin]);
a = named_anchor(name, [pos], rot=, [flip=]);
geom = attach_geom(...);
geom = attach_geom(two_d=true, size=, [size2=], [shift=], ...);
geom = attach_geom(two_d=true, r=|d=, ...);
geom = attach_geom(two_d=true, region=, [extent=], ...);
geom = attach_geom(size=, [size2=], [shift=], ...);
geom = attach_geom(r=|d=, l=|h=, [axis=], ...);
geom = attach_geom(r1|d1=, r2=|d2=, l=, [axis=], ...);
geom = attach_geom(r=|d=, ...);
geom = attach_geom(region=, l=|h=, [extent=], [shift=], [scale=], [twist=], ...);
geom = attach_geom(vnf=, [extent=], ...);
PARENT() show_anchors([s], [std=], [custom=]);
anchor_arrow([s], [color], [flag], [anchor=], [orient=], [spin=]) [ATTACHMENTS];
anchor_arrow2d([s], [color]);
expose_anchors(opacity) {child1() show_anchors(); child2() show_anchors(); ...}
show_transform_list(tlist, [s]);
show_transform_list(tlist) {CHILDREN};
generic_airplane([s]);
frame_ref(s, opacity);
square(size, [center], ...);
square(size, [center], ...) [ATTACHMENTS];
path = square(size, [center], ...);
rect(size, [rounding], [chamfer], ...) [ATTACHMENTS];
path = rect(size, [rounding], [chamfer], ...);
circle(r|d=, ...) [ATTACHMENTS];
circle(points=) [ATTACHMENTS];
circle(r|d=, corner=) [ATTACHMENTS];
path = circle(r|d=, ...);
path = circle(points=);
path = circle(r|d=, corner=);
ellipse(r|d=, [realign=], [circum=], [uniform=], ...) [ATTACHMENTS];
path = ellipse(r|d=, [realign=], [circum=], [uniform=], ...);
regular_ngon(n, r|d=|or=|od=, [realign=]) [ATTACHMENTS];
regular_ngon(n, ir=|id=, [realign=]) [ATTACHMENTS];
regular_ngon(n, side=, [realign=]) [ATTACHMENTS];
pentagon(or|od=, [realign=], [align_tip=|align_side=]) [ATTACHMENTS];
pentagon(ir=|id=, [realign=], [align_tip=|align_side=]) [ATTACHMENTS];
pentagon(side=, [realign=], [align_tip=|align_side=]) [ATTACHMENTS];
path = pentagon(...);
hexagon(r/or, [realign=], <align_tip=|align_side=>, [rounding=], ...) [ATTACHMENTS];
hexagon(d=/od=, ...) [ATTACHMENTS];
hexagon(ir=/id=, ...) [ATTACHMENTS];
hexagon(side=, ...) [ATTACHMENTS];
path = hexagon(...);
octagon(r/or, [realign=], [align_tip=|align_side=], [rounding=], ...) [ATTACHMENTS];
octagon(d=/od=, ...) [ATTACHMENTS];
octagon(ir=/id=, ...) [ATTACHMENTS];
octagon(side=, ...) [ATTACHMENTS];
path = octagon(...);
right_triangle(size, [center], ...) [ATTACHMENTS];
path = right_triangle(size, [center], ...);
trapezoid(h, w1, w2, [shift=], [rounding=], [chamfer=], [flip=], ...) [ATTACHMENTS];
trapezoid(h, w1, ang=, [rounding=], [chamfer=], [flip=], ...) [ATTACHMENTS];
trapezoid(h, w2=, ang=, [rounding=], [chamfer=], [flip=], ...) [ATTACHMENTS];
trapezoid(w1=, w2=, ang=, [rounding=], [chamfer=], [flip=], ...) [ATTACHMENTS];
path = trapezoid(...);
star(n, r/or, ir, [realign=], [align_tip=], [align_pit=], ...) [ATTACHMENTS];
star(n, r/or, step=, ...) [ATTACHMENTS];
path = star(n, r/or, ir, [realign=], [align_tip=], [align_pit=], ...);
path = star(n, r/or, step=, ...);
jittered_poly(path, [dist]);
teardrop2d(r/d=, [ang], [cap_h]) [ATTACHMENTS];
path = teardrop2d(r|d=, [ang], [cap_h]);
egg(length, r1|d1=, r2|d2=, R|D=) [ATTACHMENTS];
path = egg(length, r1|d1=, r2|d2=, R|D=);
region=ring(n, r1=|d1=, r2=|d2=, [full=], [angle=], [start=]);
region=ring(n, ring_width, r=|d=, [full=], [angle=], [start=]);
region=ring(n, [ring_width], [r=,d=], points=[P0,P1,P2], [full=]);
region=ring(n, [ring_width], corner=[P0,P1,P2], [r=,d=], [r1|d1=], [r2=|d2=], [full=]);
region=ring(n, [ring_width], [r=|d=], width=, thickness=, [full=]);
ring(...) [ATTACHMENTS];
glued_circles(r/d=, [spread], [tangent], ...) [ATTACHMENTS];
path = glued_circles(r/d=, [spread], [tangent], ...);
keyhole(l/length=, r1/d1=, r2/d2=, [shoulder_r=], ...) [ATTACHMENTS];
path = keyhole(l/length=, r1/d1=, r2/d2=, [shoulder_r=], ...);
supershape([step],[n=], [m1=], [m2=], [n1=], [n2=], [n3=], [a=], [b=], [r=/d=]) [ATTACHMENTS];
path = supershape([step], [n=], [m1=], [m2=], [n1=], [n2=], [n3=], [a=], [b=], [r=/d=]);
reuleaux_polygon(n, r|d=, ...) [ATTACHMENTS];
path = reuleaux_polygon(n, r|d=, ...);
round2d(r) [ATTACHMENTS];
round2d(or=) [ATTACHMENTS];
round2d(ir=) [ATTACHMENTS];
round2d(or=, ir=) [ATTACHMENTS];
shell2d(thickness, [or], [ir])
cube(size, [center]);
cube(size, [center], [anchor=], [spin=], [orient=]) [ATTACHMENTS];
vnf = cube(size, ...);
cuboid(size, [anchor=], [spin=], [orient=]);
cuboid(size, p1=, ...);
cuboid(p1=, p2=, ...);
cuboid(size, [chamfer=], [edges=], [except=], [trimcorners=], ...);
cuboid(size, [rounding=], [teardrop=], [edges=], [except=], [trimcorners=], ...);
cuboid(...) ATTACHMENTS;
prismoid(size1, size2, [h|l|height|length], [shift], [xang=], [yang=], ...) [ATTACHMENTS];
prismoid(size1, size2, h|l|height|length, [chamfer=], [rounding=]...) [ATTACHMENTS];
prismoid(size1, size2, h|l|height|length, [chamfer1=], [chamfer2=], [rounding1=], [rounding2=], ...) [ATTACHMENTS];
vnf = prismoid(...);
octahedron(size, ...) [ATTACHMENTS];
vnf = octahedron(size, ...);
regular_prism(n, h|l=|height=|length=, r, [center=], [realign=]) [ATTACHMENTS];
regular_prism(n, h|l=|height=|length=, d=|id=|od=|ir=|or=|side=, ...) [ATTACHMENTS];
regular_prism(n, h|l=|height=|length=, r1=|d1=|id1=|od1=|ir1=|or1=|side1=,r2=|d2=|id2=|od2=|ir2=|or2=|side2=, ...) [ATTACHMENTS];
regular_prism(n, h, r, chamfer=, [chamfang=], [from_end=], ...);
regular_prism(n, h, r, chamfer1=, [chamfang1=], [from_end=], ...);
regular_prism(n, h, r, chamfer2=, [chamfang2=], [from_end=], ...);
regular_prism(n, h, r, chamfer1=, chamfer2=, [chamfang1=], [chamfang2=], [from_end=], ...);
regular_prism(n, h, r, rounding=, ...);
regular_prism(n, h, r, rounding1=, ...);
regular_prism(n, h, r, rounding2=, ...);
regular_prism(n, h, r, rounding1=, rounding2=, ...);
regular_prism(n, h, r, texture=, [tex_size=]|[tex_reps=], [tex_depth=], [tex_rot=], [tex_samples=], [style=], [tex_inset=], ...);
vnf = rounded_prism(...);
rect_tube(h, size, isize, [center], [shift]);
rect_tube(h, size, wall=, [center=]);
rect_tube(h, isize=, wall=, [center=]);
rect_tube(h, size1=, size2=, wall=, ...);
rect_tube(h, isize1=, isize2=, wall=, ...);
rect_tube(h, size1=, size2=, isize1=, isize2=, ...);
rect_tube(h, size, isize, chamfer=, ...);
rect_tube(h, size, isize, chamfer1=, chamfer2= ...);
rect_tube(h, size, isize, ichamfer=, ...);
rect_tube(h, size, isize, ichamfer1=, ichamfer2= ...);
rect_tube(h, size, isize, chamfer=, ichamfer=, ...);
rect_tube(h, size, isize, rounding=, ...);
rect_tube(h, size, isize, rounding1=, rounding2= ...);
rect_tube(h, size, isize, irounding=, ...);
rect_tube(h, size, isize, irounding1=, irounding2= ...);
rect_tube(h, size, isize, rounding=, irounding=, ...);
rect_tube(...) ATTACHMENTS;
wedge(size, [center], ...) [ATTACHMENTS];
vnf = wedge(size, [center], ...);
cylinder(h, r=/d=, [center=]);
cylinder(h, r1/d1=, r2/d2=, [center=]);
cylinder(h, r=/d=, [center=], [anchor=], [spin=], [orient=]) [ATTACHMENTS];
cylinder(h, r1/d1=, r2/d2=, [center=], [anchor=], [spin=], [orient=]) [ATTACHMENTS];
vnf = cylinder(h, r=/d=, ...);
vnf = cylinder(h, r1/d1=, r2/d2=, ...);
cyl(l|h|length|height, r, [center], [circum=], [realign=]) [ATTACHMENTS];
cyl(l|h|length|height, d=, ...) [ATTACHMENTS];
cyl(l|h|length|height, r1=, r2=, ...) [ATTACHMENTS];
cyl(l|h|length|height, d1=, d2=, ...) [ATTACHMENTS];
cyl(l|h|length|height, r|d, chamfer=, [chamfang=], [from_end=], ...);
cyl(l|h|length|height, r|d, chamfer1=, [chamfang1=], [from_end=], ...);
cyl(l|h|length|height, r|d, chamfer2=, [chamfang2=], [from_end=], ...);
cyl(l|h|length|height, r|d, chamfer1=, chamfer2=, [chamfang1=], [chamfang2=], [from_end=], ...);
cyl(l|h|length|height, r|d, rounding=, ...);
cyl(l|h|length|height, r|d, rounding1=, ...);
cyl(l|h|length|height, r|d, rounding2=, ...);
cyl(l|h|length|height, r|d, rounding1=, rounding2=, ...);
cyl(l|h|length|height, r|d, texture=, [tex_size=]|[tex_reps=], [tex_depth=], [tex_rot=], [tex_samples=], [style=], [tex_taper=], [tex_inset=], ...);
cyl(l|h|length|height, r1=, r2=, texture=, [tex_size=]|[tex_reps=], [tex_depth=], [tex_rot=], [tex_samples=], [style=], [tex_taper=], [tex_inset=], ...);
cyl(l|h|length|height, d1=, d2=, texture=, [tex_size=]|[tex_reps=], [tex_depth=], [tex_rot=], [tex_samples=], [style=], [tex_taper=], [tex_inset=], ...);
vnf = cyl(...);
xcyl(l|h|length|height, r|d=, [anchor=], ...) [ATTACHMENTS];
xcyl(l|h|length|height, r1=|d1=, r2=|d2=, [anchor=], ...) [ATTACHMENTS];
ycyl(l|h|length|height, r|d=, [anchor=], ...) [ATTACHMENTS];
ycyl(l|h|length|height, r1=|d1=, r2=|d2=, [anchor=], ...) [ATTACHMENTS];
zcyl(l|h|length|height, r|d=, [anchor=],...) [ATTACHMENTS];
zcyl(l|h|length|height, r1=|d1=, r2=|d2=, [anchor=],...);
tube(h|l, or, ir, [center], [realign=], [anchor=], [spin=],[orient=]) [ATTACHMENTS];
tube(h|l, od=, id=, ...) [ATTACHMENTS];
tube(h|l, or|od=|ir=|id=, wall=, ...) [ATTACHMENTS];
tube(h|l, ir1=|id1=, ir2=|id2=, or1=|od1=, or2=|od2=, ...) [ATTACHMENTS];
tube(h|l, or1=|od1=, or2=|od2=, wall=, ...) [ATTACHMENTS];
pie_slice(l|h=|height=|length=, r, ang, [center]);
pie_slice(l|h=|height=|length=, d=, ang=, ...);
pie_slice(l|h=|height=|length=, r1=|d1=, r2=|d2=, ang=, ...);
vnf = pie_slice(l|h=|height=|length=, r, ang, [center]);
vnf = pie_slice(l|h=|height=|length=, d=, ang=, ...);
vnf = pie_slice(l|h=|height=|length=, r1=|d1=, r2=|d2=, ang=, ...);
pie_slice(l|h, r, ang, ...) ATTACHMENTS;
sphere(r|d=);
sphere(r|d=, [anchor=], [spin=], [orient=]) [ATTACHMENTS];
vnf = sphere(r|d=, [anchor=], [spin=], [orient=]) [ATTACHMENTS];
spheroid(r|d, [circum], [style]) [ATTACHMENTS];
vnf = spheroid(r|d, [circum], [style]);
torus(r_maj|d_maj, r_min|d_min, [center], ...) [ATTACHMENTS];
torus(or|od, ir|id, ...) [ATTACHMENTS];
torus(r_maj|d_maj, or|od, ...) [ATTACHMENTS];
torus(r_maj|d_maj, ir|id, ...) [ATTACHMENTS];
torus(r_min|d_min, or|od, ...) [ATTACHMENTS];
torus(r_min|d_min, ir|id, ...) [ATTACHMENTS];
vnf = torus(r_maj|d_maj, r_min|d_min, [center], ...);
vnf = torus(or|od, ir|id, ...);
vnf = torus(r_maj|d_maj, or|od, ...);
vnf = torus(r_maj|d_maj, ir|id, ...);
vnf = torus(r_min|d_min, or|od, ...);
vnf = torus(r_min|d_min, ir|id, ...);
teardrop(h|l=|length=|height=, r, [ang], [cap_h], [chamfer=], ...) [ATTACHMENTS];
teardrop(h|l=|length=|height=, d=, [ang=], [cap_h=], [chamfer=], ...) [ATTACHMENTS];
teardrop(h|l=|height=|length=, r1=, r2=, [ang=], [cap_h1=], [cap_h2=], ...) [ATTACHMENTS];
teardrop(h|l=|height=|length=, d1=, d2=, [ang=], [cap_h1=], [cap_h2=], ...) [ATTACHMENTS];
vnf = teardrop(h|l=|height=|length=, r|d=, [ang=], [cap_h=], ...);
vnf = teardrop(h|l=|height=|length=, r1=|d1=, r2=|d2=, [ang=], [cap_h=], ...);
vnf = teardrop(h|l=|height=|length=, r1=|d1=, r2=|d2=, [ang=], [cap_h1=], [cap_h2=], ...);
onion(r|d=, [ang=], [cap_h=], [circum=], [realign=], ...) [ATTACHMENTS];
vnf = onion(r|d=, [ang=], [cap_h=], [circum=], [realign=], ...);
text3d(text, [h], [size], [font], [language=], [script=], [direction=], [atype=], [anchor=], [spin=], [orient=]);
path_text(path, text, [size], [thickness], [font], [lettersize=], [offset=], [reverse=], [normal=], [top=], [textmetrics=], [kern=])
fillet(l|h=|length=|height=, r|d=, [ang=], [excess=]) [ATTACHMENTS];
fillet(l|h=|length=|height=, r1=|d1=, r2=|d2=, [ang=], [excess=]) [ATTACHMENTS];
heightfield(data, [size], [bottom], [maxz], [xrange], [yrange], [style], [convexity], ...) [ATTACHMENTS];
vnf = heightfield(data, [size], [bottom], [maxz], [xrange], [yrange], [style], ...);
vnf = cylindrical_heightfield(data, l|length=|h=|height=, r|d=, [base=], [transpose=], [aspect=]);
cylindrical_heightfield(data, l|length=|h=|height=, r|d=, [base=], [transpose=], [aspect=]) [ATTACHMENTS];
ruler(length, width, [thickness=], [depth=], [labels=], [pipscale=], [maxscale=], [colors=], [alpha=], [unit=], [inch=]) [ATTACHMENTS];
stroke(path, [width], [closed], [endcaps], [endcap_width], [endcap_length], [endcap_extent], [trim]);
stroke(path, [width], [closed], [endcap1], [endcap2], [endcap_width1], [endcap_width2], [endcap_length1], [endcap_length2], [endcap_extent1], [endcap_extent2], [trim1], [trim2]);
dashed_stroke(path, dashpat, [width=], [closed=]);
dashes = dashed_stroke(path, dashpat, [closed=]);
path=arc(n, r|d=, angle);
path=arc(n, r|d=, angle=[START,END]);
path=arc(n, r|d=, start=, angle=);
path=arc(n, width=, thickness=);
path=arc(n, cp=, points=[P0,P1], [long=], [cw=], [ccw=]);
path=arc(n, points=[P0,P1,P2]);
path=arc(n, corner=[P0,P1,P2], r=);
path=arc(wedge=true,...)
arc(...) [ATTACHMENTS];
path = catenary(width, droop=|angle=, n=);
path = helix(l|h, [turns=], [angle=], r=|r1=|r2=, d=|d1=|d2=);
path = turtle(commands, [state], [full_state=], [repeat=])
debug_polygon(points, paths, [vertices=], [edges=], [convexity=], [size=]);
mask2d_roundover(r|d=|h=|height=|cut=|joint=, [inset], [mask_angle], [excess], [flat_top=], [quarter_round=]) [ATTACHMENTS];
path = mask2d_roundover(r|d=|h=|height=|cut=|joint=, [inset], [mask_angle], [excess], [flat_top=], [quarter_round=]);
mask2d_teardrop(r|d=, [angle], [inset] [mask_angle], [excess], [cut=], [joint=], [h=|height=]) [ATTACHMENTS];
path = mask2d_teardrop(r|d=, [angle], [inset], [mask_angle], [excess], [cut=], [joint=], [h=|height=]);
mask2d_cove(r|d=|h=|height=, [inset], [mask_angle], [excess], [bulge=], [flat_top=], [quarter_round=]) [ATTACHMENTS];
path = mask2d_cove(r|d=|h=, [inset], [mask_angle], [excess], [bulge=], [flat_top=]);
mask2d_chamfer(edge, [angle], [inset], [excess]) [ATTACHMENTS];
mask2d_chamfer(y=, [angle=], [inset=], [excess=]) [ATTACHMENTS];
mask2d_chamfer(x=, [angle=], [inset=], [excess=]) [ATTACHMENTS];
path = mask2d_chamfer(edge, [angle], [inset], [excess]);
path = mask2d_chamfer(y=, [angle=], [inset=], [excess=]);
path = mask2d_chamfer(x=, [angle=], [inset=], [excess=]);
mask2d_rabbet(size, [mask_angle], [excess]) [ATTACHMENTS];
path = mask2d_rabbet(size, [mask_angle], [excess]);
mask2d_dovetail(edge, angle, [inset], [shelf], [excess], ...) [ATTACHMENTS];
mask2d_dovetail(width=, angle=, [inset=], [shelf=], [excess=], ...) [ATTACHMENTS];
mask2d_dovetail(height=, angle=, [inset=], [shelf=], [excess=], ...) [ATTACHMENTS];
mask2d_dovetail(width=, height=, [inset=], [shelf=], [excess=], ...) [ATTACHMENTS];
path = mask2d_dovetail(edge, [angle], [inset], [shelf], [excess]);
mask2d_ogee(pattern, [excess], ...) [ATTAHCMENTS];
path = mask2d_ogee(pattern, [excess], ...);
chamfer_edge_mask(l|h=|length=|height=, chamfer, [excess]) [ATTACHMENTS];
chamfer_corner_mask(chamfer) [ATTACHMENTS];
chamfer_cylinder_mask(r|d=, chamfer, [ang], [from_end]) [ATTACHMENTS];
rounding_edge_mask(l|h=|length=|height=, r|d=, [ang], [excess=]) [ATTACHMENTS];
rounding_edge_mask(l|h=|length=|height=, r1=|d1=, r2=|d2=, [ang=], [excess=]) [ATTACHMENTS];
rounding_corner_mask(r|d, [ang], [excess=], [style=]) [ATTACHMENTS];
rounding_cylinder_mask(r|d=, rounding);
rounding_hole_mask(r|d, rounding, [excess]) [ATTACHMENTS];
teardrop_edge_mask(l|h=|length=|height=, r|d=, [angle], [excess], [anchor], [spin], [orient]) [ATTACHMENTS];
teardrop_corner_mask(r|d=, [angle], [excess], [anchor], [spin], [orient]) [ATTACHMENTS];
move_copies(a) CHILDREN;
copies = move_copies(a, p=);
mats = move_copies(a);
xcopies(spacing, [n], [sp=]) CHILDREN;
xcopies(l=, [n=], [sp=]) CHILDREN;
xcopies(LIST) CHILDREN;
copies = xcopies(spacing, [n], [sp=], p=);
copies = xcopies(l=, [n=], [sp=], p=);
copies = xcopies(LIST, p=);
mats = xcopies(spacing, [n], [sp=]);
mats = xcopies(l=, [n=], [sp=]);
mats = xcopies(LIST);
ycopies(spacing, [n], [sp=]) CHILDREN;
ycopies(l=, [n=], [sp=]) CHILDREN;
ycopies(LIST) CHILDREN;
copies = ycopies(spacing, [n], [sp=], p=);
copies = ycopies(l=, [n=], [sp=], p=);
copies = ycopies(LIST, p=);
mats = ycopies(spacing, [n], [sp=]);
mats = ycopies(l=, [n=], [sp=]);
mats = ycopies(LIST);
zcopies(spacing, [n], [sp=]) CHILDREN;
zcopies(l=, [n=], [sp=]) CHILDREN;
zcopies(LIST) CHILDREN;
copies = zcopies(spacing, [n], [sp=], p=);
copies = zcopies(l=, [n=], [sp=], p=);
copies = zcopies(LIST, p=);
mats = zcopies(spacing, [n], [sp=]);
mats = zcopies(l=, [n=], [sp=]);
mats = zcopies(LIST);
line_copies(spacing, [n], [p1=]) CHILDREN;
line_copies(spacing, [l=], [p1=]) CHILDREN;
line_copies([n=], [l=], [p1=]) CHILDREN;
line_copies([n=], [p1=], [p2=]) CHILDREN;
line_copies([spacing], [p1=], [p2=]) CHILDREN;
copies = line_copies([spacing], [n], [p1=], p=);
copies = line_copies([spacing], [l=], [p1=], p=);
copies = line_copies([n=], [l=], [p1=], p=);
copies = line_copies([n=], [p1=], [p2=], p=);
copies = line_copies([spacing], [p1=], [p2=], p=);
mats = line_copies([spacing], [n], [p1=]);
mats = line_copies([spacing], [l=], [p1=]);
mats = line_copies([n=], [l=], [p1=]);
mats = line_copies([n=], [p1=], [p2=]);
mats = line_copies([spacing], [p1=], [p2=]);
grid_copies(spacing, size=, [stagger=], [scale=], [inside=]) CHILDREN;
grid_copies(n=, size=, [stagger=], [scale=], [inside=]) CHILDREN;
grid_copies(spacing, [n], [stagger=], [scale=], [inside=]) CHILDREN;
grid_copies(n=, inside=, [stagger], [scale]) CHILDREN;
copies = grid_copies(spacing, size=, [stagger=], [scale=], [inside=], p=);
copies = grid_copies(n=, size=, [stagger=], [scale=], [inside=], p=);
copies = grid_copies(spacing, [n], [stagger=], [scale=], [inside=], p=);
copies = grid_copies(n=, inside=, [stagger], [scale], p=);
mats = grid_copies(spacing, size=, [stagger=], [scale=], [inside=]);
mats = grid_copies(n=, size=, [stagger=], [scale=], [inside=]);
mats = grid_copies(spacing, [n], [stagger=], [scale=], [inside=]);
mats = grid_copies(n=, inside=, [stagger], [scale]);
rot_copies(rots, [cp=], [sa=], [delta=], [subrot=]) CHILDREN;
rot_copies(rots, v, [cp=], [sa=], [delta=], [subrot=]) CHILDREN;
rot_copies(n=, [v=], [cp=], [sa=], [delta=], [subrot=]) CHILDREN;
copies = rot_copies(rots, [cp=], [sa=], [delta=], [subrot=], p=);
copies = rot_copies(rots, v, [cp=], [sa=], [delta=], [subrot=], p=);
copies = rot_copies(n=, [v=], [cp=], [sa=], [delta=], [subrot=], p=);
mats = rot_copies(rots, [cp=], [sa=], [delta=], [subrot=]);
mats = rot_copies(rots, v, [cp=], [sa=], [delta=], [subrot=]);
mats = rot_copies(n=, [v=], [cp=], [sa=], [delta=], [subrot=]);
xrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=]) CHILDREN;
xrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=]) CHILDREN;
copies = xrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=], p=);
copies = xrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=], p=);
mats = xrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=]);
mats = xrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=]);
yrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=]) CHILDREN;
yrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=]) CHILDREN;
copies = yrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=], p=);
copies = yrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=], p=);
mats = yrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=]);
mats = yrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=]);
zrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=]) CHILDREN;
zrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=]) CHILDREN;
copies = zrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=], p=);
copies = zrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=], p=);
mats = zrot_copies(rots, [cp], [r=|d=], [sa=], [subrot=]);
mats = zrot_copies(n=, [cp=], [r=|d=], [sa=], [subrot=]);
arc_copies(n, r|d=, [sa=], [ea=], [rot=]) CHILDREN;
arc_copies(n, rx=|dx=, ry=|dy=, [sa=], [ea=], [rot=]) CHILDREN;
copies = arc_copies(n, r|d=, [sa=], [ea=], [rot=], p=);
copies = arc_copies(n, rx=|dx=, ry=|dy=, [sa=], [ea=], [rot=], p=);
mats = arc_copies(n, r|d=, [sa=], [ea=], [rot=]);
mats = arc_copies(n, rx=|dx=, ry=|dy=, [sa=], [ea=], [rot=]);
sphere_copies(n, r|d=, [cone_ang=], [scale=], [perp=]) CHILDREN;
copies = sphere_copies(n, r|d=, [cone_ang=], [scale=], [perp=], p=);
mats = sphere_copies(n, r|d=, [cone_ang=], [scale=], [perp=]);
path_copies(path, [n], [spacing], [sp], [rotate_children], [closed=]) CHILDREN;
path_copies(path, dist=, [rotate_children=], [closed=]) CHILDREN;
copies = path_copies(path, [n], [spacing], [sp], [rotate_children], [closed=], p=);
copies = path_copies(path, dist=, [rotate_children=], [closed=], p=);
mats = path_copies(path, [n], [spacing], [sp], [rotate_children], [closed=]);
mats = path_copies(path, dist=, [rotate_children=], [closed=]);
xflip_copy([offset], [x]) CHILDREN;
copies = xflip_copy([offset], [x], p=);
mats = xflip_copy([offset], [x]);
yflip_copy([offset], [y]) CHILDREN;
copies = yflip_copy([offset], [y], p=);
mats = yflip_copy([offset], [y]);
zflip_copy([offset], [z]) CHILDREN;
copies = zflip_copy([offset], [z], p=);
mats = zflip_copy([offset], [z]);
mirror_copy(v, [cp], [offset]) CHILDREN;
copies = mirror_copy(v, [cp], [offset], p=);
mats = mirror_copy(v, [cp], [offset]);
xdistribute(spacing, [sizes]) CHILDREN;
xdistribute(l=, [sizes=]) CHILDREN;
ydistribute(spacing, [sizes]) CHILDREN;
ydistribute(l=, [sizes=]) CHILDREN;
zdistribute(spacing, [sizes]) CHILDREN;
zdistribute(l=, [sizes=]) CHILDREN;
distribute(spacing, sizes, dir) CHILDREN;
distribute(l=, [sizes=], [dir=]) CHILDREN;
recolor([c]) CHILDREN;
color_this([c]) CHILDREN;
rainbow(list,[stride],[maxhues],[shuffle],[seed]) CHILDREN;
color_overlaps([color]) CHILDREN;
half_of(v, [cp], [s], [planar]) CHILDREN;
result = half_of(p,v,[cp]);
left_half([s], [x]) CHILDREN;
left_half(planar=true, [s], [x]) CHILDREN;
result = left_half(p, [x]);
right_half([s=], [x=]) CHILDREN;
right_half(planar=true, [s=], [x=]) CHILDREN;
result = right_half(p, [x=]);
front_half([s], [y]) CHILDREN;
front_half(planar=true, [s], [y]) CHILDREN;
result = front_half(p, [y]);
back_half([s], [y]) CHILDREN;
back_half(planar=true, [s], [y]) CHILDREN;
result = back_half(p, [y]);
bottom_half([s], [z]) CHILDREN;
result = bottom_half(p, [z]);
partition_mask(l, w, h, [cutsize], [cutpath], [gap], [inverse], [$slop=], [anchor=], [spin=], [orient=]) [ATTACHMENTS];
partition_cut_mask(l, [cutsize], [cutpath], [gap], [inverse], [$slop=], [anchor=], [spin=], [orient=]) [ATTACHMENTS];
partition(size, [spread], [cutsize], [cutpath], [gap], [spin], [$slop=]) CHILDREN;
extrude_from_to(pt1, pt2, [convexity=], [twist=], [scale=], [slices=]) 2D-CHILDREN;
path_extrude2d(path, [caps=], [closed=], [s=], [convexity=]) 2D-CHILDREN;
path_extrude(path, [convexity], [clipsize]) 2D-CHILDREN;
cylindrical_extrude(ir|id=, or|od=, [size=], [convexity=], [spin=], [orient=]) 2D-CHILDREN;
bounding_box([excess],[planar]) CHILDREN;
chain_hull() CHILDREN;
minkowski_difference() { BASE; DIFF1; DIFF2; ... }
offset3d(r, [size], [convexity]) CHILDREN;
round3d(r) CHILDREN;
round3d(or) CHILDREN;
round3d(ir) CHILDREN;
round3d(or, ir) CHILDREN;
is_path(list, [dim], [fast])
bool = is_1region(path, [name])
outpath = force_path(path, [name])
path_merge_collinear(path, [eps])
path_length(path,[closed])
path_segment_lengths(path,[closed])
fracs = path_length_fractions(path, [closed]);
newpath = subdivide_path(path, n|refine=|maxlen=, [method=], [closed=], [exact=]);
newpath = resample_path(path, n|spacing=, [closed=]);
bool = is_path_simple(path, [closed], [eps]);
index_pt = path_closest_point(path, pt);
tangs = path_tangents(path, [closed], [uniform]);
norms = path_normals(path, [tangents], [closed]);
curvs = path_curvature(path, [closed]);
torsions = path_torsion(path, [closed]);
path_list = path_cut(path, cutdist, [closed]);
cuts = path_cut_points(path, cutdist, [closed=], [direction=]);
paths = split_path_at_self_crossings(path, [closed], [eps]);
splitpolys = polygon_parts(poly, [nonzero], [eps]);
bool = is_region(x);
bool = is_valid_region(region, [eps]);
bool = is_region_simple(region, [eps]);
region = make_region(polys, [nonzero], [eps]);
region = force_region(poly)
region(r, [anchor], [spin=], [cp=], [atype=]) [ATTACHMENTS];
debug_region(region, [vertices=], [edges=], [convexity=], [size=]);
check = point_in_region(point, region, [eps]);
area = region_area(region);
b = are_regions_equal(region1, region2, [either_winding])
split_region = split_region_at_region_crossings(region1, region2, [closed1], [closed2], [eps])
rgns = region_parts(region);
offsetpath = offset(path, [r=|delta=], [chamfer=], [closed=], [check_valid=], [quality=], [same_length=])
path_faces = offset(path, return_faces=true, [r=|delta=], [chamfer=], [closed=], [check_valid=], [quality=], [firstface_index=], [flip_faces=])
union() CHILDREN;
region = union(regions);
region = union(REGION1,REGION2);
region = union(REGION1,REGION2,REGION3);
difference() CHILDREN;
region = difference(regions);
region = difference(REGION1,REGION2);
region = difference(REGION1,REGION2,REGION3);
intersection() CHILDREN;
region = intersection(regions);
region = intersection(REGION1,REGION2);
region = intersection(REGION1,REGION2,REGION3);
exclusive_or() CHILDREN;
region = exclusive_or(regions);
region = exclusive_or(REGION1,REGION2);
region = exclusive_or(REGION1,REGION2,REGION3);
path = hull_region(region);
hull_region(region);
skin(profiles, slices, [z=], [refine=], [method=], [sampling=], [caps=], [closed=], [style=], [convexity=], [anchor=],[cp=],[spin=],[orient=],[atype=]) [ATTACHMENTS];
vnf = skin(profiles, slices, [z=], [refine=], [method=], [sampling=], [caps=], [closed=], [style=], [anchor=],[cp=],[spin=],[orient=],[atype=]);
linear_sweep(region, [height], [center=], [slices=], [twist=], [scale=], [style=], [caps=], [convexity=]) [ATTACHMENTS];
linear_sweep(region, [height], [center=], texture=, [tex_size=]|[tex_reps=], [tex_depth=], [style=], [tex_samples=], ...) [ATTACHMENTS];
vnf = linear_sweep(region, [height], [center=], [slices=], [twist=], [scale=], [style=], [caps=]);
vnf = linear_sweep(region, [height], [center=], texture=, [tex_size=]|[tex_reps=], [tex_depth=], [style=], [tex_samples=], ...);
vnf = rotate_sweep(shape, [angle], ...);
rotate_sweep(shape, [angle], ...) [ATTACHMENTS];
rotate_sweep(shape, texture=, [tex_size=]|[tex_reps=], [tex_depth=], [tex_samples=], [tex_rot=], [tex_inset=], ...) [ATTACHMENTS];
spiral_sweep(poly, h, r|d=, turns, [taper=], [center=], [taper1=], [taper2=], [internal=], ...)[ATTACHMENTS];
spiral_sweep(poly, h, r1=|d1=, r2=|d2=, turns, [taper=], [center=], [taper1=], [taper2=], [internal=], ...)[ATTACHMENTS];
vnf = spiral_sweep(poly, h, r|d=, turns, ...);
vnf = spiral_sweep(poly, h, r1=|d1=, r1=|d2=, turns, ...);
path_sweep(shape, path, [method], [normal=], [closed=], [twist=], [twist_by_length=], [symmetry=], [scale=], [scale_by_length=], [last_normal=], [tangent=], [uniform=], [relaxed=], [caps=], [style=], [convexity=], [anchor=], [cp=], [spin=], [orient=], [atype=]) [ATTACHMENTS];
vnf = path_sweep(shape, path, [method], [normal=], [closed=], [twist=], [twist_by_length=], [symmetry=], [scale=], [scale_by_length=], [last_normal=], [tangent=], [uniform=], [relaxed=], [caps=], [style=], [transforms=], [anchor=], [cp=], [spin=], [orient=], [atype=]);
path_sweep2d(shape, path, [closed], [caps], [quality], [style], [convexity=], [anchor=], [spin=], [orient=], [atype=], [cp=]) [ATTACHMENTS];
vnf = path_sweep2d(shape, path, [closed], [caps], [quality], [style], [anchor=], [spin=], [orient=], [atype=], [cp=]);
sweep(shape, transforms, [closed], [caps], [style], [convexity=], [anchor=], [spin=], [orient=], [atype=]) [ATTACHMENTS];
vnf = sweep(shape, transforms, [closed], [caps], [style], [anchor=], [spin=], [orient=], [atype=]);
path_sweep(...) { sweep_attach(parent, [child], [frac], [idx=], [len=], [spin=], [overlap=], [atype=]) CHILDREN; }
sweep(...) { sweep_attach(parent, [child], [frac], [idx=], [len=], [spin=], [overlap=], [atype=]) CHILDREN; }
newprof = subdivide_and_slice(profiles, slices, [numpoints], [method], [closed]);
profs = slice_profiles(profiles, slices, [closed]);
rlist = rot_resample(rotlist, n, [method=], [twist=], [scale=], [smoothlen=], [long=], [turns=], [closed=])
newpoly = associate_vertices(polygons, split);
tx = texture(tex, [n=], [inset=], [gap=], [roughness=]);
vnf = vnf_vertex_array(points, [caps=], [cap1=], [cap2=], [style=], [reverse=], [col_wrap=], [row_wrap=], [triangulate=]);
vnf = vnf_tri_array(points, [row_wrap], [reverse])
vnf = vnf_join([VNF, VNF, VNF, ...]);
vnf = vnf_from_polygons(polygons, [eps]);
vnf = vnf_from_region(region, [transform], [reverse]);
bool = is_vnf(x);
rvnf = vnf_reverse_faces(vnf);
vnf2 = vnf_quantize(vnf,[q]);
new_vnf = vnf_merge_points(vnf, [eps]);
clean_vnf = vnf_drop_unused_points(vnf);
vnf2 = vnf_triangulate(vnf);
newvnf = vnf_unify_faces(vnf);
sliced = vnf_slice(vnf, dir, cuts);
vnf_polyhedron(vnf) [ATTACHMENTS];
vnf_polyhedron([VNF, VNF, VNF, ...]) [ATTACHMENTS];
vnf_wireframe(vnf, [width]);
vol = vnf_volume(vnf);
area = vnf_area(vnf);
region = projection(vnf, [cut]);
newvnf = vnf_halfspace(plane, vnf, [closed], [boundary]);
bentvnf = vnf_bend(vnf,r|d=,[axis=]);
vnf_hull = hull_vnf(vnf);
hull_vnf(vnf,[fast]);
boundary = vnf_boundary(vnf, [merge=], [idx=]);
newvnf = vnf(vnf, delta, [merge=]);
newvnf = vnf_sheet(vnf, thickness, [style=], [merge=]);
debug_vnf(vnfs, [faces=], [vertices=], [opacity=], [size=], [convexity=], [filter=]);
vnf_validate(vnf, [size], [show_warns=], [check_isects=], [opacity=], [adjacent=], [label_verts=], [label_faces=], [wireframe=]);
pt = bezier_points(bezier, u);
ptlist = bezier_points(bezier, RANGE);
ptlist = bezier_points(bezier, LIST);
path = bezier_curve(bezier, [splinesteps], [endpoint]);
deriv = bezier_derivative(bezier, u, [order]);
derivs = bezier_derivative(bezier, LIST, [order]);
derivs = bezier_derivative(bezier, RANGE, [order]);
tanvec = bezier_tangent(bezier, u);
tanvecs = bezier_tangent(bezier, LIST);
tanvecs = bezier_tangent(bezier, RANGE);
crv = bezier_curvature(curve, u);
crvlist = bezier_curvature(curve, LIST);
crvlist = bezier_curvature(curve, RANGE);
u = bezier_closest_point(bezier, pt, [max_err]);
pathlen = bezier_length(bezier, [start_u], [end_u], [max_deflect]);
u = bezier_line_intersection(bezier, line);
pt = bezpath_points(bezpath, curveind, u, [N]);
ptlist = bezpath_points(bezpath, curveind, LIST, [N]);
path = bezpath_points(bezpath, curveind, RANGE, [N]);
path = bezpath_curve(bezpath, [splinesteps], [N], [endpoint])
res = bezpath_closest_point(bezpath, pt, [N], [max_err]);
plen = bezpath_length(path, [N], [max_deflect]);
bezpath = path_to_bezpath(path, [closed], [tangents], [uniform], [size=]|[relsize=]);
bezpath = bezpath_close_to_axis(bezpath, [axis], [N]);
bezpath = bezpath_offset(offset, bezier, [N]);
pts = bez_begin(pt, a, r, [p=]);
pts = bez_begin(pt, VECTOR, [r], [p=]);
pts = bez_tang(pt, a, r1, r2, [p=]);
pts = bez_tang(pt, VECTOR, [r1], [r2], [p=]);
pts = bez_joint(pt, a1, a2, r1, r2, [p1=], [p2=]);
pts = bez_joint(pt, VEC1, VEC2, [r1=], [r2=], [p1=], [p2=]);
pts = bez_end(pt, a, r, [p=]);
pts = bez_end(pt, VECTOR, [r], [p=]);
bool = is_bezier_patch(x);
patch = bezier_patch_flat(size, [N=], [spin=], [orient=], [trans=]);
rpatch = bezier_patch_reverse(patch);
pt = bezier_patch_points(patch, u, v);
ptgrid = bezier_patch_points(patch, LIST, LIST);
ptgrid = bezier_patch_points(patch, RANGE, RANGE);
vnf = bezier_vnf(patches, [splinesteps], [style]);
vnf = bezier_vnf_degenerate_patch(patch, [splinesteps], [reverse]);
vnf_edges = bezier_vnf_degenerate_patch(patch, [splinesteps], [reverse], return_edges=true);
n = bezier_patch_normals(patch, u, v);
ngrid = bezier_patch_normals(patch, LIST, LIST);
ngrid = bezier_patch_normals(patch, RANGE, RANGE);
debug_bezier(bez, [size], [N=]);
debug_bezier_patches(patches, [size=], [splinesteps=], [showcps=], [showdots=], [showpatch=], [convexity=], [style=]);
rounded_path = round_corners(path, [method], [radius=], [cut=], [joint=], [closed=], [verbose=]);
smoothed = smooth_path(path, [tangents], [size=|relsize=], [splinesteps=], [closed=], [uniform=]);
joined_path = path_join(paths, [joint], [k=], [relocate=], [closed=]);
offset_stroke(path, [width], [rounded=], [chamfer=], [start=], [end=], [check_valid=], [quality=], [closed=],...) [ATTACHMENTS];
path = offset_stroke(path, [width], closed=false, [rounded=], [chamfer=], [start=], [end=], [check_valid=], [quality=],...);
region = offset_stroke(path, [width], closed=true, [rounded=], [chamfer=], [start=], [end=], [check_valid=], [quality=],...);
offset_sweep(path, [height|length=|h=|l=], [bottom], [top], [offset=], [convexity=],...) [ATTACHMENTS];
vnf = offset_sweep(path, [height|length=|h=|l=], [bottom], [top], [offset=], ...);
convex_offset_extrude(height, [bottom], [top], ...) 2D-CHILDREN;
rounded_prism(bottom, [top], [height=|h=|length=|l=], [joint_top=], [joint_bot=], [joint_sides=], [k=], [k_top=], [k_bot=], [k_sides=], [splinesteps=], [debug=], [convexity=],...) [ATTACHMENTS];
vnf = rounded_prism(bottom, [top], [height=|h=|length=|l=], [joint_top=], [joint_bot=], [joint_sides=], [k=], [k_top=], [k_bot=], [k_sides=], [splinesteps=], [debug=]);
bent_cutout_mask(r|radius, thickness, path);
join_prism(polygon, base, length=|height=|l=|h=, fillet=, [base_T=], [scale=], [prism_end_T=], [short=], ...) [ATTACHMENTS];
join_prism(polygon, base, aux=, fillet=, [base_T=], [aux_T=], [scale=], [prism_end_T=], [short=], ...) [ATTACHMENTS];
vnf = join_prism( ... );
path = turtle3d(commands, [state=], [repeat=]);
mats = turtle3d(commands, transforms=true, [state=], [repeat=]);
state = turtle3d(commands, full_state=true, [state=], [repeat=]);
Constants: PHI
EPSILON
INF
NAN
list = count(n, [s], [step], [reverse]);
x2 = sqr(x);
val = log2(x);
l = hypot(x, y, [z]);
x = factorial(n, [d]);
x = binomial(n);
x = binomial_coefficient(n, k);
x = gcd(a,b)
a = sinh(x);
a = cosh(x);
a = tanh(x);
a = asinh(x);
a = acosh(x);
a = atanh(x);
num = quant(x, y);
num = quantdn(x, y);
num = quantup(x, y);
val = constrain(v, minval, maxval);
mod = posmod(x, m)
ang = modang(x);
x = sum(v, [dflt]);
x = mean(v);
middle = median(v)
delts = deltas(v,[wrap]);
sums = cumsum(v);
x = product(v);
prod_list = cumprod(list, [right]);
x = convolve(p,q);
sum_of_sines(a,sines)
rand_int(minval, maxval, n, [seed]);
points = random_points(n, dim, [scale], [seed]);
arr = gaussian_rands([n],[mean], [cov], [seed]);
arr = exponential_rands([n], [lambda], [seed])
points = spherical_random_points([n], [radius], [seed]);
points = random_polygon([n], [size], [seed]);
x = deriv(data, [h], [closed])
x = deriv2(data, [h], [closed])
x = deriv3(data, [h], [closed])
z = complex(list)
c = c_mul(z1,z2)
x = c_div(z1,z2)
w = c_conj(z)
x = c_real(z)
x = c_imag(z)
I = c_ident(n)
n = c_norm(z)
roots = quadratic_roots(a, b, c, [real])
x = polynomial(p, z)
x = polymult(p,q)
x = polymult([p1,p2,p3,...])
[quotient,remainder] = poly_div(n,d)
sum = poly_add(p,q)
roots = poly_roots(p, [tol]);
roots = real_roots(p, [eps], [tol])
x = root_find(f, x0, x1, [tol])
test = is_matrix(A, [m], [n], [square])
b = is_matrix_symmetric(A, [eps])
b = is_rotation(A, [dim], [centered])
echo_matrix(M, [description], [sig], [sep], [eps]);
dummy = echo_matrix(M, [description], [sig], [sep], [eps]),
list = column(M, i);
mat = submatrix(M, idx1, idx2);
mat = ident(n);
mat = diagonal_matrix(diag, [offdiag]);
M = transpose(M, [reverse]);
x = outer_product(u,v);
M = outer_product(u,v);
mat = submatrix_set(M, A, [m], [n]);
A = hstack(M1, M2)
A = hstack(M1, M2, M3)
A = hstack([M1, M2, M3, ...])
bmat = block_matrix([[M11, M12,...],[M21, M22,...], ... ]);
solv = linear_solve(A,b,[pivot])
x = linear_solve3(A,b)
mat = matrix_inverse(A)
B = rot_inverse(A)
x = null_space(A)
qr = qr_factor(A,[pivot]);
x = back_substitute(R, b, [transpose]);
L = cholesky(A);
d = det2(M);
d = det3(M);
d = det4(M);
d = determinant(M);
norm_fro(A)
matrix_trace(M)
bool = is_vector(v, [length], [zero=], [all_nonzero=], [eps=]);
v_new = add_scalar(v, s);
v3 = v_mul(v1, v2);
v3 = v_div(v1, v2);
v2 = v_abs(v);
v2 = v_floor(v);
v2 = v_ceil(v);
v2 = v_lookup(x, v);
v = unit(v, [error]);
theta = v_theta([X,Y]);
ang = vector_angle(v1,v2);
ang = vector_angle([v1,v2]);
ang = vector_angle(PT1,PT2,PT3);
ang = vector_angle([PT1,PT2,PT3]);
axis = vector_axis(v1,v2);
axis = vector_axis([v1,v2]);
axis = vector_axis(PT1,PT2,PT3);
axis = vector_axis([PT1,PT2,PT3]);
newv = vector_bisect(v1,v2);
pt_pair = pointlist_bounds(pts);
index = closest_point(pt, points);
index = furthest_point(pt, points);
indices = vector_search(query, r, target);
tree = vector_search_tree(points,leafsize);
indices = vector_nearest(query, k, target);
pt = point2d(p, [fill]);
pts = path2d(points);
pt = point3d(p, [fill]);
pts = path3d(points, [fill]);
pt = point4d(p, [fill]);
pt = path4d(points, [fill]);
pt = polar_to_xy(r, theta);
pt = polar_to_xy([R, THETA]);
pts = polar_to_xy([[R,THETA], [R,THETA], ...]);
r_theta = xy_to_polar(x,y);
r_theta = xy_to_polar([X,Y]);
r_thetas = xy_to_polar([[X,Y], [X,Y], ...]);
xy = project_plane(plane, p);
M = project_plane(plane)
xyz = lift_plane(plane, p);
M = lift_plane(plane);
pt = cylindrical_to_xyz(r, theta, z);
pt = cylindrical_to_xyz([RADIUS,THETA,Z]);
pts = cylindrical_to_xyz([[RADIUS,THETA,Z], [RADIUS,THETA,Z], ...]);
rtz = xyz_to_cylindrical(x,y,z);
rtz = xyz_to_cylindrical([X,Y,Z]);
rtzs = xyz_to_cylindrical([[X,Y,Z], [X,Y,Z], ...]);
pt = spherical_to_xyz(r, theta, phi);
pt = spherical_to_xyz([RADIUS,THETA,PHI]);
pts = spherical_to_xyz([[RADIUS,THETA,PHI], [RADIUS,THETA,PHI], ...]);
r_theta_phi = xyz_to_spherical(x,y,z)
r_theta_phi = xyz_to_spherical([X,Y,Z])
r_theta_phis = xyz_to_spherical([[X,Y,Z], [X,Y,Z], ...])
pt = altaz_to_xyz(alt, az, r);
pt = altaz_to_xyz([ALT,AZ,R]);
pts = altaz_to_xyz([[ALT,AZ,R], [ALT,AZ,R], ...]);
alt_az_r = xyz_to_altaz(x,y,z);
alt_az_r = xyz_to_altaz([X,Y,Z]);
alt_az_rs = xyz_to_altaz([[X,Y,Z], [X,Y,Z], ...]);
pt = is_point_on_line(point, line, [bounded], [eps]);
bool = is_collinear(a, [b, c], [eps]);
dist = point_line_distance(pt, line, [bounded]);
dist = segment_distance(seg1, seg2, [eps]);
vec = line_normal([P1,P2])
vec = line_normal(p1,p2)
pt = line_intersection(line1, line2, [bounded1], [bounded2], [bounded=], [eps=]);
pt = line_closest_point(line, pt, [bounded]);
line = line_from_points(points, [fast], [eps]);
bool = is_coplanar(points,[eps]);
plane = plane3pt(p1, p2, p3);
plane = plane3pt([p1, p2, p3]);
plane = plane3pt_indexed(points, i1, i2, i3);
plane = plane_from_normal(normal, [pt])
plane = plane_from_points(points, [fast], [eps]);
plane = plane_from_polygon(points, [fast], [eps]);
vec = plane_normal(plane);
d = plane_offset(plane);
pt = plane_line_intersection(plane, line, [bounded], [eps]);
line = plane_intersection(plane1, plane2)
pt = plane_intersection(plane1, plane2, plane3)
angle = plane_line_angle(plane,line);
pts = plane_closest_point(plane, points);
dist = point_plane_distance(plane, point)
bool = are_points_on_plane(points, plane, [eps]);
pts = circle_line_intersection(r|d=, cp, line, [bounded], [eps=]);
pts = circle_circle_intersection(r1|d1=, cp1, r2|d2=, cp2, [eps]);
circ = circle_2tangents(r|d=, pt1, pt2, pt3, [tangents=]);
circ = circle_2tangents(r|d=, [PT1, PT2, PT3], [tangents=]);
circ = circle_3points(pt1, pt2, pt3);
circ = circle_3points([PT1, PT2, PT3]);
tangents = circle_point_tangents(r|d=, cp, pt);
segs = circle_circle_tangents(r1|d1=, cp1, r2|d2=, cp2);
isect = sphere_line_intersection(r|d=, cp, line, [bounded], [eps=]);
area = polygon_area(poly, [signed]);
c = centroid(object, [eps]);
vec = polygon_normal(poly);
bool = point_in_polygon(point, poly, [nonzero], [eps])
pt = polygon_line_intersection(poly, line, [bounded], [nonzero], [eps]);
triangles = polygon_triangulate(poly, [ind], [error], [eps])
bool = is_polygon_clockwise(poly);
newpoly = clockwise_polygon(poly);
newpoly = ccw_polygon(poly);
newpoly = reverse_polygon(poly)
newpoly = reindex_polygon(reference, poly);
newpoly = align_polygon(reference, poly, [angles], [cp], [tran], [return_ind]);
bool = are_polygons_equal(poly1, poly2, [eps])
face_list_or_index_list = hull(points);
hull_points(points, [fast]);
index_list = hull2d_path(points,all)
faces = hull3d_faces(points)
bool = is_polygon_convex(poly, [eps]);
dist = convex_distance(points1, points2,eps);
bool = convex_collision(points1, points2, [eps]);
info = rot_decode(rotation,[long]); // Returns: [angle,axis,cp,translation]
C = law_of_cosines(a, b, c);
c = law_of_cosines(a, b, C=);
B = law_of_sines(a, A, b);
b = law_of_sines(a, A, B=);
adj = hyp_opp_to_adj(hyp,opp);
adj = opp_hyp_to_adj(opp,hyp);
adj = hyp_ang_to_adj(hyp,ang);
adj = ang_hyp_to_adj(ang,hyp);
adj = opp_ang_to_adj(opp,ang);
adj = ang_opp_to_adj(ang,opp);
opp = hyp_adj_to_opp(hyp,adj);
opp = adj_hyp_to_opp(adj,hyp);
opp = hyp_ang_to_opp(hyp,ang);
opp = ang_hyp_to_opp(ang,hyp);
opp = adj_ang_to_opp(adj,ang);
opp = ang_adj_to_opp(ang,adj);
hyp = adj_opp_to_hyp(adj,opp);
hyp = opp_adj_to_hyp(opp,adj);
hyp = adj_ang_to_hyp(adj,ang);
hyp = ang_adj_to_hyp(ang,adj);
hyp = opp_ang_to_hyp(opp,ang);
hyp = ang_opp_to_hyp(ang,opp);
ang = hyp_adj_to_ang(hyp,adj);
ang = adj_hyp_to_ang(adj,hyp);
ang = hyp_opp_to_ang(hyp,opp);
ang = opp_hyp_to_ang(opp,hyp);
ang = adj_opp_to_ang(adj,opp);
ang = opp_adj_to_ang(opp,adj);
ver = bosl_version();
ver = bosl_version_num();
ver = bosl_version_str();
bosl_required(version);
ver = version_to_list(x);
str = version_to_str(version);
str = version_to_num(version);
cmp = version_cmp(a,b);
test = approx(a, b, [eps])
x = all_zero(x, [eps]);
test = all_nonzero(x, [eps]);
test = all_positive(x,[eps]);
test = all_negative(x, [eps]);
all_nonpositive(x, [eps]);
all_nonnegative(x, [eps]);
b = all_equal(vec, [eps]);
are_ends_equal(list, [eps]);
bool = is_increasing(list, [strict]);
bool = is_decreasing(list, [strict]);
test = compare_vals(a, b);
test = compare_lists(a, b)
idx = find_approx(val, list, [start=], [eps=]);
indices = find_approx(val, list, all=true, [start=], [eps=]);
list = deduplicate(list, [closed], [eps]);
new_idxs = deduplicate_indexed(list, indices, [closed], [eps]);
list_wrap(path, [eps]);
list_unwrap(list, [eps]);
ulist = unique(list);
sorted_counts = unique_count(list);
slist = sort(list, [idx]);
idxlist = sortidx(list, [idx]);
ulist = group_sort(list,[idx]);
groupings = group_data(groups, values);
small = list_smallest(list, k)
bool = is_homogeneous(list, [depth]);
llen = min_length(list);
llen = max_length(list);
dims = list_shape(v, [depth]);
bool = in_list(val, list, [idx]);
item = select(list, start);
item = select(list, [s:d:e]);
item = select(list, [i0,i1...,ik]);
list = select(list, start, end);
list = slice(list, s, e);
item = last(list);
list = list_head(list, [to]);
list = list_tail(list, [from]);
sublist = bselect(list, index);
list = repeat(val, n);
arr = list_bset(indexset, valuelist, [dflt]);
list = force_list(value, [n], [fill]);
rlist = reverse(list);
rlist = list_rotate(list, [n]);
newlist = repeat_entries(list, N, [exact]);
newlist = list_pad(list, minlen, [fill]);
list = list_set(list, indices, values, [dflt], [minlen]);
list = list_insert(list, indices, values);
list = list_remove(list, ind);
list = list_remove_values(list, values, [all]);
range = idx(list, [s=], [e=], [step=]);
for(i=idx(list, [s=], [e=], [step=])) ...
p = pair(list, [wrap]);
for (p = pair(list, [wrap])) ... // On each iteration, p contains a list of two adjacent items.
list = triplet(list, [wrap]);
for (t = triplet(list, [wrap])) ...
list = combinations(l, [n]);
list = permutations(l, [n]);
groups = list_to_matrix(v, cnt, [dflt]);
list = flatten(l);
list = full_flatten(l);
s = set_union(a, b, [get_indices]);
s = set_difference(a, b);
s = set_intersection(a, b);
typ = typeof(x);
bool = is_type(x, types);
bool = is_def(x);
bool = is_str(x);
bool = all_integer(x);
bool = is_nan(x);
bool = is_finite(x);
bool = is_range(x);
bool = valid_range(x);
bool = is_func(x);
bool = is_consistent(list, [pattern]);
bool = same_shape(a,b);
check = is_bool_list(list,[length])
bool = any(l);
bool = any(l, func); // Requires OpenSCAD 2021.01 or later.
bool = all(l);
bool = all(l, func); // Requires OpenSCAD 2021.01 or later.
seq = num_true(l);
seq = num_true(l, func); // Requires OpenSCAD 2021.01 or later.
val = default(val, dflt);
val = first_defined(v, [recursive]);
val = one_defined(vals, names, [dflt])
cnt = num_defined(v);
bool = any_defined(v, [recursive]);
bool = all_defined(v, [recursive]);
x = u_add(a, b);
x = u_sub(a, b);
x = u_mul(a, b);
x = u_div(a, b);
anchr = get_anchor(anchor,center,[uncentered],[dflt]);
r = get_radius([r1=], [r2=], [r=], [d1=], [d2=], [d=], [dflt=]);
vec = scalar_vec3(v, [dflt]);
sides = segs(r);
no_children($children);
req_children($children);
dummy = no_function(name)
no_module();
deprecate(new_name);
assert_approx(got, expected, [info]);
assert_equal(got, expected, [info]);
shape_compare([eps]) {TEST_SHAPE; EXPECTED_SHAPE;}
bool = looping(state);
state = loop_while(state, continue);
bool = loop_done(state);
newstr = substr(str, [pos], [len]);
newstr = suffix(str,len);
ind = str_find(str,pattern,[last=],[all=],[start=]);
bool = starts_with(str,pattern);
bool = ends_with(str,pattern);
string_list = str_split(str, sep, [keep_nulls]);
str = str_join(list, [sep]);
str = str_strip(s,c,[start],[end]);
padded = str_pad(str, length, char, [left]);
newstr = str_replace_char(str, char, replace);
newstr = downcase(str);
newstr = upcase(str);
str = rand_str(n, [charset], [seed]);
num = parse_int(str, [base])
num = parse_float(str);
num = parse_frac(str,[mixed=],[improper=],[signed=]);
num = parse_num(str);
str = format_int(i, [mindigits]);
s = format_fixed(f, [digits]);
str = format_float(f,[sig]);
s = format(fmt, vals);
x = is_lower(s);
x = is_upper(s);
x = is_digit(s);
x = is_hexdigit(s);
x = is_letter(s);
struct2 = struct_set(struct, key, value, [grow=]);
struct2 = struct_set(struct, [key1, value1, key2, value2, ...], [grow=]);
struct2 = struct_remove(struct, key);
val = struct_val(struct, key, default);
keys = struct_keys(struct);
echo_struct(struct, [name]);
foo = echo_struct(struct, [name]);
bool = is_struct(struct);
lst = filter(func, list);
lst = filter(function (x) x>1, list);
res = reduce(func, list, [init]);
res = reduce(function (a,b) a+b, list, <init=);
res = accumulate(func, list, [init]);
res = accumulate(function (a,b) a+b, list, [init=]);
x = while(init, cond, func);
x = for_n(n, init, func);
indices = find_all(func, list);
indices = find_all(function (x) x>1, list);
idx = find_first(func, list, [start=]);
idx = binsearch(key,list, [cmp]);
hx = simple_hash(x);
hm = hashmap([hashsize=]);
hm = hashmap(items=KEYVAL_LIST, [hashsize=]);
hm2 = hm(key, val);
hm2 = hm(additems=KEYVAL_LIST);
hm2 = hm(del=KEY);
x = hm(key);
for (kv=hm()) let(k=kv[0], v=kv[1]) ...
fn = f_1arg(func);
fn = f_2arg(target_func);
fn = f_2arg_simple(target_func);
fn = f_3arg(target_func);
newfunc = ival(func);
newfunc = xval(func);
fn = f_or();
fn = f_or(a=);
fn = f_or(b=);
fn = f_or(a=,b=);
fn = f_and();
fn = f_and(a=);
fn = f_and(b=);
fn = f_and(a=,b=);
fn = f_nor();
fn = f_nor(a=);
fn = f_nor(b=);
fn = f_nor(a=,b=);
fn = f_nand();
fn = f_nand(a=);
fn = f_nand(b=);
fn = f_nand(a=,b=);
fn = f_xor();
fn = f_xor(a=);
fn = f_xor(b);
fn = f_xor(a=,b=);
fn = f_add();
fn = f_add(a=);
fn = f_add(b);
fn = f_add(a=,b=);
fn = f_sub();
fn = f_sub(a=);
fn = f_sub(b);
fn = f_sub(a=,b=);
fn = f_mul();
fn = f_mul(a=);
fn = f_mul(b);
fn = f_mul(a=,b=);
fn = f_div();
fn = f_div(a=);
fn = f_div(b);
fn = f_div(a=,b=);
fn = f_mod();
fn = f_mod(a=);
fn = f_mod(b);
fn = f_mod(a=,b=);
fn = f_pow();
fn = f_pow(a=);
fn = f_pow(b);
fn = f_pow(a=,b=);
fn = f_min2();
fn = f_min2(a=);
fn = f_min2(b);
fn = f_min2(a=,b=);
fn = f_max2();
fn = f_max2(a=);
fn = f_max2(b);
fn = f_max2(a=,b=);
fn = f_min3();
fn = f_min3(a=);
fn = f_min3(b=);
fn = f_min3(c=);
fn = f_min3(a=,b=);
fn = f_min3(b=,c=);
fn = f_min3(a=,c=);
fn = f_min3(a=,b=,c=);
fn = f_max3();
fn = f_max3(a=);
fn = f_max3(b=);
fn = f_max3(c=);
fn = f_max3(a=,b=);
fn = f_max3(b=,c=);
fn = f_max3(a=,c=);
fn = f_max3(a=,b=,c=);
fn = f_atan2();
fn = f_atan2(a=);
fn = f_atan2(b);
fn = f_atan2(a=,b=);
fn = f_str2();
fn = f_str2(a=);
fn = f_str2(b);
fn = f_str2(a=,b=);
fn = f_str3();
fn = f_str3(a=);
fn = f_str3(b=);
fn = f_str3(c=);
fn = f_str3(a=,b=);
fn = f_str3(b=,c=);
fn = f_str3(a=,c=);
fn = f_str3(a=,b=,c=);
fn = f_cross();
fn = f_cross(a=);
fn = f_cross(b);
fn = f_cross(a=,b=);
fn = f_is_def();
fn = f_is_undef();
fn = f_is_bool();
fn = f_is_num();
fn = f_is_int();
fn = f_is_nan();
fn = f_is_finite();
fn = f_is_string();
fn = f_is_list();
fn = f_is_range();
fn = f_is_function();
fn = f_is_vector();
fn = f_is_path();
fn = f_is_region();
fn = f_is_vnf();
fn = f_is_patch();
threaded_rod(d, l|length, pitch, [internal=], ...) [ATTACHMENTS];
threaded_nut(nutwidth, id, h|height|thickness, pitch,...) [ATTACHMENTS];
trapezoidal_threaded_rod(d, l|length, pitch, [thread_angle=|flank_angle=], [thread_depth=], [internal=], ...) [ATTACHMENTS];
trapezoidal_threaded_nut(nutwidth, id, h|height|thickness, pitch, [thread_angle=|flank_angle=], [thread_depth], ...) [ATTACHMENTS];
acme_threaded_rod(d, l|length, tpi|pitch=, [internal=], ...) [ATTACHMENTS];
acme_threaded_nut(nutwidth, id, h|height|thickness, tpi|pitch=, [shape=], ...) [ATTACHMENTS];
npt_threaded_rod(size, [internal=], ...) [ATTACHMENTS];
buttress_threaded_rod(d, l|length, pitch, [internal=], ...) [ATTACHMENTS];
buttress_threaded_nut(nutwidth, id, h|height|thickness, pitch, ...) [ATTACHMENTS];
square_threaded_rod(d, l|length, pitch, [internal=], ...) [ATTACHMENTS];
square_threaded_nut(nutwidth, id, h|height|thickness, pitch, ...) [ATTACHMENTS];
ball_screw_rod(d, l|length, pitch, [ball_diam], [ball_arc], [internal=], ...) [ATTACHMENTS];
generic_threaded_rod(d, l|length, pitch, profile, [internal=], ...) [ATTACHMENTS];
generic_threaded_nut(nutwidth, id, h|height|thickness, pitch, profile, [$slop], ...) [ATTACHMENTS];
thread_helix(d, pitch, turns=, [thread_depth=], [thread_angle=|flank_angle=], [profile=], [starts=], [internal=], ...) {ATTACHMENTS};
thread_helix(d1=,d2=, pitch=, turns=, [thread_depth=], [thread_angle=|flank_angle=], [profile=], [starts=], [internal=], ...) {ATTACHMENTS};
screw([spec], [head], [drive], [thread=], [drive_size=], [length=|l=], [thread_len=], [undersize=], [shaft_undersize=], [head_undersize=], [tolerance=], [blunt_start=], [details=], [anchor=], [atype=], [orient=], [spin=]) [ATTACHMENTS];
screw_hole([spec], [head], [thread=], [length=|l=], [oversize=], [hole_oversize=], [teardrop=], [head_oversize], [tolerance=], [$slop=], [blunt_start=], [anchor=], [atype=], [orient=], [spin=]) [ATTACHMENTS];
shoulder_screw(s, d, length, [head=], [thread_len=], [tolerance=], [head_size=], [drive=], [drive_size=], [thread=], [undersize=], [shaft_undersize=], [head_undersize=], [shoulder_undersize=],[atype=],[anchor=],[orient=],[spin=]) [ATTACHMENTS];
screw_head(screw_info, [details],[counterbore],[flat_height],[teardrop],[internal])
nut([spec], [shape], [thickness], [nutwidth], [thread=], [tolerance=], [hole_oversize=], [bevel=], [$slop=], [anchor=], [spin=], [orient=]) [ATTACHMENTS];
nut_trap_side(trap_width, [spec], [shape], [thickness], [nutwidth=], [poke_len=], [poke_diam=], [$slop=], [anchor=], [orient=], [spin=]) [ATTACHMENTS];
nut_trap_inline(length|l|heigth|h, [spec], [shape], [$slop=], [anchor=], [orient=], [spin=]) [ATTACHMENTS];
info = screw_info(name, [head], [drive], [thread=], [drive_size=], [oversize=], [head_oversize=])
nut_spec = nut_info(name, [shape], [thickness=], [thread=], [width=], [hole_oversize=]);
thread_specification(screw_spec, [tolerance], [internal])
phillips_mask(size) [ATTACHMENTS];
depth = phillips_depth(size, d);
diam = phillips_diam(size, depth);
hex_drive_mask(size, length, [anchor], [spin], [orient], [$slop]) [ATTACHMENTS];
torx_mask(size, l, [center]) [ATTACHMENTS];
torx_mask2d(size);
info = torx_info(size);
diam = torx_diam(size);
depth = torx_depth(size);
robertson_mask(size, [extra], [ang], [$slop=]);
pco1810_neck([wall]) [ATTACHMENTS];
pco1810_cap([h], [r|d], [wall], [texture]) [ATTACHMENTS];
pco1881_neck([wall]) [ATTACHMENTS];
pco1881_cap(wall, [texture]) [ATTACHMENTS];
generic_bottle_neck([wall], ...) [ATTACHMENTS];
generic_bottle_cap(wall, [texture], ...) [ATTACHMENTS];
bottle_adapter_neck_to_cap(wall, [texture], ...) [ATTACHMENTS];
bottle_adapter_cap_to_cap(wall, [texture]) [ATTACHMENTS];
bottle_adapter_neck_to_neck(...) [ATTACHMENTS];
sp_neck(diam, type, wall|id=, [style=], [bead=]) [ATTACHMENTS];
sp_cap(diam, type, wall, [style=], [top_adj=], [bot_adj=], [texture=], [$slop]) [ATTACHMENTS];
true_diam = sp_diameter(diam,type)
cubetruss(extents, [clips=], [bracing=], [size=], [strut=], [clipthick=], ...) [ATTACHMENTS];
cubetruss_corner(h, extents, [bracing=], [size=], [strut=], [clipthick=]);
cubetruss_support([size=], [strut=], [extents=]) [ATTACHMENTS];
cubetruss_foot(w, [size=], [strut=], [clipthick=]) [ATTACHMENTS];
cubetruss_joiner([w=], [vert=], [size=], [strut=], [clipthick=]) [ATTACHMENTS];
cubetruss_uclip(dual, [size=], [strut=], [clipthick=]) [ATTACHMENTS];
cubetruss_segment([size=], [strut=], [bracing=]);
cubetruss_clip(extents, [size=], [strut=], [clipthick=]) [ATTACHMENTS];
length = cubetruss_dist(cubes, [gaps], [size=], [strut=]);
spur_gear(circ_pitch, teeth, [thickness], [helical=], [pressure_angle=], [profile_shift=], [backlash=], [shaft_diam=], [hide=], [clearance=], [slices=], [internal=], [herringbone=]) [ATTACHMENTS];
spur_gear(mod=|diam_pitch=, teeth=, [thickness=], ...) [ATTACHMENTS];
vnf = spur_gear(circ_pitch, teeth, [thickness], ...);
vnf = spur_gear(mod=|diam_pitch=, teeth=, [thickness=], ...);
spur_gear2d(circ_pitch, teeth, [pressure_angle=], [profile_shift=], [shorten=], [hide=], [shaft_diam=], [clearance=], [backlash=], [internal=]) [ATTACHMENTS];
spur_gear2d(mod=|diam_pitch=, teeth=, [pressure_angle=], [profile_shift=], [shorten=], [hide=], [shaft_diam=], [clearance=], [backlash=], [internal=]) [ATTACHMENTS];
rgn = spur_gear2d(circ_pitch, teeth, [pressure_angle=], [profile_shift=], [shorten=], [hide=], [shaft_diam=], [clearance=], [backlash=], [internal=]);
rgn = spur_gear2d(mod=, teeth=, [pressure_angle=], [profile_shift=], [shorten=], [hide=], [shaft_diam=], [clearance=], [backlash=], [internal=]);
ring_gear(circ_pitch, teeth, thickness, [backing|od=|or=|width=], [pressure_angle=], [helical=], [herringbone=], [profile_shift=], [clearance=], [backlash=]) [ATTACHMENTS];
ring_gear(mod=, teeth=, thickness=, [backing=|od=|or=|width=], [pressure_angle=], [helical=], [herringbone=], [profile_shift=], [clearance=], [backlash=]) [ATTACHMENTS];
ring_gear(diam_pitch=, teeth=, thickness=, [backing=|od=|or=|width=], [pressure_angle=], [helical=], [herringbone=], [profile_shift=], [clearance=], [backlash=]) [ATTACHMENTS];
ring_gear2d(circ_pitch, teeth, [backing|od=|or=|width=], [pressure_angle=], [helical=], [profile_shift=], [clearance=], [backlash=]) [ATTACHMENTS];
ring_gear2d(mod=, teeth=, [backing=|od=|or=|width=], [pressure_angle=], [helical=], [profile_shift=], [clearance=], [backlash=]) [ATTACHMENTS];
ring_gear2d(diam_pitch=, teeth=, [backing=|od=|or=|width=], [pressure_angle=], [helical=], [profile_shift=], [clearance=], [backlash=]) [ATTACHMENTS];
rack(pitch, teeth, thickness, [base|bottom=|width=], [helical=], [pressure_angle=], [backlash=], [clearance=]) [ATTACHMENTS];
rack(mod=, teeth=, thickness=, [base=|bottom=|width=], [helical=], [pressure_angle=], [backlash]=, [clearance=]) [ATTACHMENTS];
vnf = rack(pitch, teeth, thickness, [base|bottom=|width=], [helical=], [pressure_angle=], [backlash=], [clearance=]);
vnf = rack(mod=, teeth=, thickness=, [base=|bottom=|width=], [helical=], [pressure_angle=], [backlash=], [clearance=]);
rack2d(pitch, teeth, [base|bottom=|width=], [pressure_angle=], [backlash=], [clearance=]) [ATTACHMENTS];
rack2d(mod=, teeth=, [base=|bottom=|width=], [pressure_angle=], [backlash=], [clearance=]) [ATTACHMENTS];
path = rack2d(pitch, teeth, [base|bottom=|width=], [pressure_angle=], [backlash=], [clearance=]);
path = rack2d(mod=, teeth=, [base=|bottom=|width=], [pressure_angle=], [backlash=], [clearance=]);
crown_gear(circ_pitch, teeth, backing, face_width, [pressure_angle=], [clearance=], [backlash=], [profile_shift=], [slices=]);
crown_gear(diam_pitch=, teeth=, backing=, face_width=, [pressure_angle=], [clearance=], [backlash=], [profile_shift=], [slices=]);
crown_gear(mod=, teeth=, backing=, face_width=, [pressure_angle=], [clearance=], [backlash=], [profile_shift=], [slices=]);
vnf = crown_gear(circ_pitch, teeth, backing, face_width, [pressure_angle=], [clearance=], [backlash=], [profile_shift=], [slices=]);
vnf = crown_gear(diam_pitch=, teeth=, backing=, face_width=, [pressure_angle=], [clearance=], [backlash=], [profile_shift=], [slices=]);
vnf = crown_gear(mod=, teeth=, backing=, face_width=, [pressure_angle=], [clearance=], [backlash=], [profile_shift=], [slices=]);
gear_dist(mod=|diam_pitch=|circ_pitch=, teeth, mate_teeth, [shaft_angle], [shaft_diam], [face_width=], [hide=], [spiral=], [cutter_radius=], [right_handed=], [pressure_angle=], [backing=|thickness=|bottom=], [cone_backing=], [backlash=], [slices=], [internal=], [gear_spin=], ...) [ATTACHMENTS];
vnf = gear_dist(mod=|diam_pitch=|circ_pitch=, teeth, mate_teeth, [shaft_angle], [face_width=], [hide=], [spiral=], [cutter_radius=], [right_handed=], [pressure_angle=], , [backing=|thickness=|bottom=], [cone_backing=], [backlash=], [slices=], [internal=], [gear_spin=], ...);
worm(circ_pitch, d, l, [starts=], [left_handed=], [pressure_angle=], [backlash=], [clearance=]);
worm(mod=, d=, l=, [starts=], [left_handed=], [pressure_angle=], [backlash=], [clearance=]);
vnf = worm(circ_pitch, d, l, [starts=], [left_handed=], [pressure_angle=], [backlash=], [clearance=]);
vnf = worm(mod=, d=, l=, [starts=], [left_handed=], [pressure_angle=], [backlash=], [clearance=]);
enveloping_worm(circ_pitch, mate_teeth, d, [left_handed=], [starts=], [arc=], [pressure_angle=]);
enveloping_worm(mod=, mate_teeth=, d=, [left_handed=], [starts=], [arc=], [pressure_angle=]);
enveloping_worm(diam_pitch=, mate_teeth=, d=, [left_handed=], [starts=], [arc=], [pressure_angle=]);
vnf = enveloping_worm(circ_pitch, mate_teeth, d, [left_handed=], [starts=], [arc=], [pressure_angle=]);
vnf = enveloping_worm(mod=, mate_teeth=, d=, [left_handed=], [starts=], [arc=], [pressure_angle=]);
vnf = enveloping_worm(diam_pitch=, mate_teeth=, d=, [left_handed=], [starts=], [arc=], [pressure_angle=]);
worm_gear(circ_pitch, teeth, worm_diam, [worm_starts=], [worm_arc=], [crowning=], [left_handed=], [pressure_angle=], [backlash=], [clearance=], [slices=], [shaft_diam=]) [ATTACHMENTS];
worm_gear(mod=, teeth=, worm_diam=, [worm_starts=], [worm_arc=], [crowning=], [left_handed=], [pressure_angle=], [backlash=], [clearance=], [slices=], [shaft_diam=]) [ATTACHMENTS];
vnf = worm_gear(circ_pitch, teeth, worm_diam, [worm_starts=], [worm_arc=], [crowning=], [left_handed=], [pressure_angle=], [backlash=], [clearance=], [slices=]);
vnf = worm_gear(mod=, teeth=, worm_diam=, [worm_starts=], [worm_arc=], [crowning=], [left_handed=], [pressure_angle=], [backlash=], [clearance=], [slices=]);
gear_data = planetary_gears(mod=|circ_pitch=|diam_pitch=, n, max_teeth, ring_carrier=|carrier_ring=|sun_carrier=|carrier_sun=|sun_ring=|ring_sun=, [helical=], [gear_spin=]);
circ_pitch = circular_pitch(circ_pitch);
circ_pitch = circular_pitch(mod=);
circ_pitch = circular_pitch(diam_pitch=);
dp = diametral_pitch(circ_pitch);
dp = diametral_pitch(mod=);
dp = diametral_pitch(diam_pitch=);
mod = module_value(circ_pitch);
mod = module_value(mod=);
mod = module_value(diam_pitch=);
pr = pitch_radius(pitch, teeth, [helical]);
pr = pitch_radius(mod=, teeth=, [helical=]);
or = outer_radius(circ_pitch, teeth, [helical=], [clearance=], [internal=], [profile_shift=], [shorten=]);
or = outer_radius(mod=, teeth=, [helical=], [clearance=], [internal=], [profile_shift=], [shorten=]);
or = outer_radius(diam_pitch=, teeth=, [helical=], [clearance=], [internal=], [profile_shift=], [shorten=]);
ang = bevel_pitch_angle(teeth, mate_teeth, [drive_angle=]);
thick = worm_gear_thickness(pitch, teeth, worm_diam, [worm_arc=], [crowning=], [clearance=]);
thick = worm_gear_thickness(mod=, teeth=, worm_diam=, [worm_arc=], [crowning=], [clearance=]);
dist = worm_dist(mod=|diam_pitch=|circ_pitch=, d, starts, teeth, [profile_shift], [pressure_angle=]);
dist = gear_dist(mod=|diam_pitch=|circ_pitch=, teeth1, teeth2, [helical], [profile_shift1], [profile_shift2], [pressure_angle=], [backlash=]);
dist = gear_dist_skew(mod=|diam_pitch=|circ_pitch=, teeth1, teeth2, helical1, helical2, [profile_shift1], [profile_shift2], [pressure_angle=]
ang = gear_skew_angle(teeth1, teeth2, helical1, helical2, [profile_shift1], [profile_shift2], [pressure_angle=]
total_shift = get_profile_shift(mod=|diam_pitch=|circ_pitch=, desired, teeth1, teeth2, [helical], [pressure_angle=],
x = auto_profile_shift(teeth, [pressure_angle], [helical], [profile_shift=]);
x = auto_profile_shift(teeth, [pressure_angle], [helical], get_min=);
x = auto_profile_shift(teeth, min_teeth=);
shorten = gear_shorten(teeth1, teeth2, [helical], [profile_shift1], [profile_shift2], [pressure_angle=]);
shorten = gear_shorten_skew(teeth1, teeth2, helical1, helical2, [profile_shift1], [profile_shift2], [pressure_angle=]);
knuckle_hinge(length, offset, segs, [inner], [arm_height=], [arm_angle=], [fill=], [clear_top=], [gap=], [round_top=], [round_bot=], [knuckle_diam=], [pin_diam=], [pin_fn=], [anchor=], [spin=], [orient=]) [ATTACHMENTS];
living_hinge_mask(l, thick, [layerheight=], [foldangle=], [hingegap=], [$slop=], [anchor=], [spin=], [orient=]) [ATTACHMENTS];
apply_folding_hinges_and_snaps(thick, [foldangle=], [hinges=], [snaps=], [sockets=], [snaplen=], [snapdiam=], [hingegap=], [layerheight=], [$slop=]) CHILDREN;
snap_lock(thick, [snaplen=], [snapdiam=], [layerheight=], [foldangle=], [hingegap=], [$slop=], [anchor=], [spin=], [orient=]) [ATTACHMENTS];
snap_socket(thick, [snaplen=], [snapdiam=], [layerheight=], [foldangle=], [hingegap=], [$slop=], [anchor=], [spin=], [orient=]) [ATTACHMENTS];
half_joiner_clear(l, w, [ang=], [clearance=], [overlap=]) [ATTACHMENTS];
vnf = half_joiner_clear(l, w, [ang=], [clearance=], [overlap=]);
half_joiner(l, w, [base=], [ang=], [screwsize=], [$slop=]) [ATTACHMENTS];
vnf = half_joiner(l, w, [base=], [ang=], [screwsize=], [$slop=]);
half_joiner2(l, w, [base=], [ang=], [screwsize=])
vnf = half_joiner2(l, w, [base=], [ang=], [screwsize=])
joiner_clear(l, w, [ang=], [clearance=], [overlap=]) [ATTACHMENTS];
joiner(l, w, base, [ang=], [screwsize=], [$slop=]) [ATTACHMENTS];
dovetail(gender, w=|width, h=|height, slide|thickness=, [slope=|angle=], [taper=|back_width=], [chamfer=], [r=|radius=], [round=], [extra=], [$slop=])
snap_pin(size, [pointed=], [anchor=], [spin=], [orient]=) [ATTACHMENTS];
snap_pin(r=|radius=|d=|diameter=, l=|length=, nub_depth=, snap=, thickness=, [clearance=], [preload=], [pointed=]) [ATTACHMENTS];
snap_pin_socket(size, [fixed=], [fins=], [pointed=], [anchor=], [spin=], [orient=]) [ATTACHMENTS];
snap_pin_socket(r=|radius=|d=|diameter=, l=|length=, nub_depth=, snap=, [fixed=], [pointed=], [fins=]) [ATTACHMENTS];
rabbit_clip(type, length, width, snap, thickness, depth, [compression=], [clearance=], [lock=], [lock_clearance=], [splineteps=], [anchor=], [orient=], [spin=]) [ATTACHMENTS];
linear_bearing_housing(d, l, tab, gap, wall, tabwall, screwsize) [ATTACHMENTS];
linear_bearing(l, od, id, length) [ATTACHMENTS];
lmXuu_housing(size, tab, gap, wall, tabwall, screwsize) [ATTACHMENTS];
lmXuu_bearing(size) [ATTACHMENTS];
diam_len = lmXuu_info(size);
modular_hose(size, type, [clearance], [waist_len], [anchor], [spin], [orient]) [ATTACHMENTS];
r = modular_hose_radius(size, [outer]);
nema_stepper_motor(size, h, shaft_len, [$slop=], ...) [ATTACHMENTS];
nema_mount_mask(size, depth, l, [$slop], ...);
info = nema_motor_info(size);
regular_polyhedron([name],[index=],[type=],[faces=],[facetype=],[hasfaces=],...) [CHILDREN];
regular_polyhedron(..., [or=|r=|d=],[ir=],[mr=],[side=],[facedown=],[anchor=], ...) [CHILDREN];]
regular_polyhedron(..., [draw=], [rounding=], [stellate=], [repeat=], [rotate_children=]) [CHILDREN];
regular_polyhedron("trapezohedron", [longside=],[h=], ...) [CHILDREN];
info = regular_polyhedron_info(info, ...);
slider(l, w, h, [base=], [wall=], [ang=], [$slop=]) [ATTACHMENTS];
rail(l, w, h, [chamfer=], [ang=]) [ATTACHMENTS];
manfrotto_rc2_plate([chamfer],[anchor],[orient],[spin]) [ATTACHMENTS];
sparse_wall(h, l, thick, [maxang=], [strut=], [max_bridge=]) [ATTACHMENTS];
sparse_wall2d(size, [maxang=], [strut=], [max_bridge=]) [ATTACHMENTS];
sparse_cuboid(size, [dir], [maxang=], [struct=]
hex_panel(shape, wall, spacing, [frame=], [bevel=], [bevel_frame=], [h=|height=|l=|length=], [anchor=], [orient=], [spin=])
corrugated_wall(h, l, thick, [strut=], [wall=]) [ATTACHMENTS];
thinning_wall(h, l, thick, [ang=], [braces=], [strut=], [wall=]) [ATTACHMENTS];
thinning_triangle(h, l, thick, [ang=], [strut=], [wall=], [diagonly=], [center=]) [ATTACHMENTS];
narrowing_strut(w, l, wall, [ang=]) [ATTACHMENTS];
wire_bundle(path, wires, [wirediam], [rounding], [wirenum=], [corner_steps=]);
Table of Contents
Function Index
Topics Index
Cheat Sheet
Tutorials
Basic Modeling:
- constants.scad STD
- transforms.scad STD
- attachments.scad STD
- shapes2d.scad STD
- shapes3d.scad STD
- drawing.scad STD
- masks2d.scad STD
- masks3d.scad STD
- distributors.scad STD
- color.scad STD
- partitions.scad STD
- miscellaneous.scad STD
Advanced Modeling:
Math:
- math.scad STD
- linalg.scad STD
- vectors.scad STD
- coords.scad STD
- geometry.scad STD
- trigonometry.scad STD
Data Management:
- version.scad STD
- comparisons.scad STD
- lists.scad STD
- utility.scad STD
- strings.scad STD
- structs.scad
- fnliterals.scad
Threaded Parts:
Parts:
- ball_bearings.scad
- cubetruss.scad
- gears.scad
- hinges.scad
- joiners.scad
- linear_bearings.scad
- modular_hose.scad
- nema_steppers.scad
- polyhedra.scad
- sliders.scad
- tripod_mounts.scad
- walls.scad
- wiring.scad
STD = Included in std.scad