Iterating Quickly: Copy Arrays, Rotate Copies, and Option Management

Why these tools matter for fast iteration

Fast form exploration in SketchUp depends on two things: (1) generating variations quickly (arrays, rotate copies, scale tests), and (2) keeping options controllable so you can compare without losing work. This chapter is structured as mini-drills you can repeat on any project massing model.

Mini-drill 1: Linear arrays with Move + copy (xN and /N)

Use linear arrays to test rhythms, bay counts, façade fins, column grids, terrace steps, or repeated mass modules. The key is to create one accurate spacing move, then let SketchUp multiply it.

• Copy mode: With the Move tool, toggle copy mode (Ctrl on Windows, Option on Mac). You will place a duplicate instead of moving the original.
• xN syntax: After placing the first copy, type x10 to create 10 copies at the same spacing (total count depends on your starting selection and copies; focus on the visual result and adjust N).
• /N syntax: After placing the first copy, type /8 to divide the distance between the original and the last copy into 8 equal segments (useful when you know the overall length but want equal spacing).

Step-by-step: Bay study along a façade

1. Prepare one “bay module” (a simple mass slice, fin, mullion placeholder, or balcony block). Make sure it is a single selectable object (typically a group or component instance).

2. Set the direction: Activate Move, click a logical reference point on the module (corner or midpoint), then constrain along an axis (arrow keys if you use them) or hover to lock inference.

3. Make the first copy: Toggle copy mode (Ctrl/Option), move the copy to the next bay spacing, and click to place it.

   Continue in our app.

   • Listen to the audio with the screen off.
   • Earn a certificate upon completion.
   • Over 5000 courses for you to explore!

   Or continue reading below...

   

   Download the app

4. Array it: Immediately type xN (e.g., x12) to extend the rhythm, or type /N (e.g., /10) to evenly subdivide the overall span.

5. Adjust without redoing: If the count is wrong, simply type a new value (e.g., x14) right away—SketchUp updates the array as long as you haven’t started another command.

When to use xN vs /N

Micro-check: keep arrays editable

• Array from a clean reference: If the first spacing move is sloppy, every copy inherits the error. Take an extra second to infer from a known point.
• Don’t explode to “fix”: If something is off, undo and redo the first move; exploding removes the ability to quickly re-array with predictable selection behavior.

Mini-drill 2: Radial arrays with Rotate + copy

Radial arrays are ideal for testing tower rotations, atrium ribs, circular colonnades, auditorium seating blocks, or sun-shading fins around a curve. The workflow mirrors linear arrays: establish one accurate rotation, then multiply.

Step-by-step: Create a radial fin study around a cylinder

1. Place one fin/module near the circular edge. Keep it as a single object (group/component instance).

2. Activate Rotate and set the protractor plane correctly (match the plane of rotation). Click to set the rotation center at the circle’s center (use inference to find it).

3. Set the reference angle: Click a start reference point (e.g., from center to the fin), then toggle copy mode (Ctrl/Option), rotate to the next position, and click to place the first copy.

4. Array it: Type xN to repeat that angle N times (e.g., x24), or type /N to divide the angle between original and last copy into N segments (useful when you rotate to a known endpoint first).

Two reliable radial strategies

• Known increment strategy (xN): Rotate one copy by a known increment (e.g., 15°), then type x23 to complete a ring (adjust as needed).
• Known total angle strategy (/N): Rotate a copy to a known endpoint (e.g., 180° across a semicircle), then type /12 to distribute evenly.

Mini-drill 3: Scaling strategies for proportion tests

Scaling is the fastest way to test proportion without rebuilding. Use it to explore tower slenderness, podium-to-tower ratios, courtyard widths, step-back depth, or roof profile emphasis. The goal is controlled scaling: change one dimension family at a time and keep a record of options.

Three practical scaling modes

• Uniform scale: Preserve overall proportions while testing “bigger/smaller” mass presence.
• Axis scale (non-uniform): Stretch only one axis to test slenderness, depth, or frontage without changing height (or vice versa).
• Scale about a meaningful anchor: Scale from a corner or base point so the building stays “on” the site line or setback edge.

Step-by-step: Slenderness test without losing the base alignment

1. Duplicate safely first (see “Safe iteration” below). Work on the duplicate option.

2. Select the option group (top-level group representing the whole scheme option).

3. Activate Scale and choose a handle that keeps the correct anchor. For example, use a side handle to change width while keeping the opposite side aligned to a property line.

4. Constrain the change by scaling along one axis direction (visually align the handle movement with the axis). Make small, readable changes (e.g., 0.9×, 1.1×) rather than extreme jumps.

5. Record the intent in the name: rename the option to reflect the test (e.g., OPT_B_Tower_0.85W).

Mini-drill 4: Guides for consistent offsets

Guides let you iterate with consistent setbacks, overhangs, and alignments. They are especially useful when you are generating multiple options and need each to respect the same rules (street wall line, easements, courtyard offsets, structural grid lines).

Step-by-step: Consistent setback band for multiple options

1. Create guide offsets from the controlling edges (property line, curb line, or podium face). Place guides at key distances you will reuse (e.g., 3 m setback, 6 m step-back).

2. Use guides as snap targets during Move/Scale operations so each option lands on the same offset logic.

3. Keep guides readable: avoid over-creating guides. Place only the few that define the rules of the study.

Option management: compare without confusion

High-speed iteration becomes useless if options get mixed, overwritten, or hard to toggle. Use a simple method: each option is a top-level group, each option is stored in a scene set, and visibility is controlled with tags plus clear Outliner naming.

Method overview

• One option = one top-level group: Each scheme option should be a single group at the model root (not nested inside other option groups). This makes selection, hiding, and scene control predictable.
• One option = one scene: Create a scene per option so you can flip between them instantly for review.
• Tags control visibility: Assign each option group to its own tag (e.g., OPT_A, OPT_B). Toggle tags to show exactly one option at a time (or two for comparison).
• Outliner naming prevents mistakes: Name option groups with a consistent prefix and a short description so you never edit the wrong one.

Recommended naming pattern

Use a sortable, readable structure. Examples:

• OPT_A_Podium_Aligned
• OPT_B_Podium_Setback3m
• OPT_C_Tower_Rot15deg
• OPT_D_Tower_Slender_0.85W

Step-by-step: Build an option set you can toggle in seconds

1. Create Option A as a single top-level group. Name it OPT_A_....

2. Assign a tag to the group (e.g., OPT_A). Repeat for other options (OPT_B, OPT_C).

3. Create a scene for Option A: show only tag OPT_A (and any shared context tags you need), then add a scene named Scene_OPT_A.

4. Repeat for each option: for Option B, show only OPT_B, add Scene_OPT_B, etc.

5. Use Outliner as your “option dashboard”: collapse everything except the top-level option groups so you can select the right option instantly.

Comparing two options cleanly

• Side-by-side in place: Temporarily show two option tags at once (e.g., OPT_A and OPT_B) and use a distinct material override per option if needed for clarity.
• Swap scenes rapidly: Use scenes as “states” so you can present differences without hunting for visibility toggles.

Safe iteration: duplicate, rename, then modify

The fastest way to lose time is to overwrite your only good version. Adopt a strict rule: duplicate, rename, then modify. This keeps your iteration chain intact and makes backtracking effortless.

Safe iteration checklist (repeat every time)

1. Duplicate: Copy the entire top-level option group (Move + copy or copy/paste in place) so the new option starts from the same baseline.

2. Rename immediately: Before editing, rename the duplicate in Outliner (e.g., from OPT_B to OPT_C_Tower_Rot10deg).

3. Re-tag if needed: Assign the duplicate to its own option tag (OPT_C) so visibility control stays clean.

4. Modify: Only now run your array/rotate/scale drills on the new option.

5. Capture a scene: Save a scene for the new option so it becomes part of the comparison set.

Mini-drill sequence: 10-minute option sprint

Use this sequence to generate three controlled variations from one baseline:

• Option A (baseline): establish the initial mass and one façade rhythm using a linear array (xN).
• Option B (rotation study): duplicate A, rename, then apply a radial array to rotate fins/modules around a curve or rotate a tower volume relative to podium geometry.
• Option C (proportion study): duplicate B, rename, then scale one axis to test slenderness or depth while snapping to guide offsets for consistent setbacks.

By the end, you should be able to toggle Scene_OPT_A, Scene_OPT_B, and Scene_OPT_C and explain each option in one sentence: what changed, why it changed, and what it improves or risks.