Replicates the 3D solid, applying a transformation function to each replica. Transformation function could alter rotation, scale, visibility, position, etc.
The `patternTransform` call itself takes a number for how many total instances of the shape should be. For example, if you use a circle with `patternTransform(4, transform)` then there will be 4 circles: the original, and 3 created by replicating the original and calling the transform function on each.
The transform function takes a single parameter: an integer representing which number replication the transform is for. E.g. the first replica to be transformed will be passed the argument `1`. This simplifies your math: the transform function can rely on id `0` being the original instance passed into the `patternTransform`. See the examples.
The transform function returns a transform object. All properties of the object are optional, they each default to "no change". So the overall transform object defaults to "no change" too. Its properties are:
-`translate` (3D point)
Translates the replica, moving its position in space.
-`replicate` (bool)
If false, this ID will not actually copy the object. It'll be skipped.
-`scale` (3D point)
Stretches the object, multiplying its width in the given dimension by the point's component in that direction.
-`rotation` (object, with the following properties)
-`rotation.axis` (a 3D point, defaults to the Z axis)
-`rotation.angle` (number of degrees)
-`rotation.origin` (either "local" i.e. rotate around its own center, "global" i.e. rotate around the scene's center, or a 3D point, defaults to "local")
// Each instance will be shifted along the X axis.
fn transform = (id) => {
return { translate: [4 * id, 0, 0] }
}
// Sketch 4 cylinders.
sketch001 = startSketchOn('XZ')
|> circle({ center: [0, 0], radius: 2 }, %)
|> extrude(5, %)
|> patternTransform(4, transform, %)
```
 and the first replica
// (at x = 8). This is because `id` starts at 1.
fn transform = (id) => {
return { translate: [4 * (1 + id), 0, 0] }
}
sketch001 = startSketchOn('XZ')
|> circle({ center: [0, 0], radius: 2 }, %)
|> extrude(5, %)
|> patternTransform(4, transform, %)
```
 => {
l = length / 2
x = center[0]
y = center[1]
p0 = [-l + x, -l + y]
p1 = [-l + x, l + y]
p2 = [l + x, l + y]
p3 = [l + x, -l + y]
return startSketchAt(p0)
|> lineTo(p1, %)
|> lineTo(p2, %)
|> lineTo(p3, %)
|> lineTo(p0, %)
|> close(%)
|> extrude(length, %)
}
width = 20
fn transform = (i) => {
return {
// Move down each time.
translate: [0, 0, -i * width],
// Make the cube longer, wider and flatter each time.
scale: [pow(1.1, i), pow(1.1, i), pow(0.9, i)],
// Turn by 15 degrees each time.
rotation: { angle: 15 * i, origin: "local" }
}
}
myCubes = cube(width, [100, 0])
|> patternTransform(25, transform, %)
```
 => {
l = length / 2
x = center[0]
y = center[1]
p0 = [-l + x, -l + y]
p1 = [-l + x, l + y]
p2 = [l + x, l + y]
p3 = [l + x, -l + y]
return startSketchAt(p0)
|> lineTo(p1, %)
|> lineTo(p2, %)
|> lineTo(p3, %)
|> lineTo(p0, %)
|> close(%)
|> extrude(length, %)
}
width = 20
fn transform = (i) => {
return {
translate: [0, 0, -i * width],
rotation: {
angle: 90 * i,
// Rotate around the overall scene's origin.
origin: "global"
}
}
}
myCubes = cube(width, [100, 100])
|> patternTransform(4, transform, %)
```
