How to Use Representations in BricsCAD Mechanical

Quick answer: Exploded (BMEXPLODE) and sequence (BMSEQUENCE) representations create associative representations of an assembly without modifying the assembly itself, resolving BMEXPLODE, BMEXPLODEMOVE, and BMTRAILINGLINES covered in brief on this hub’s assembly design commands page. Representations store in dedicated blocks, editable and insertable as needed, and can generate drawing views. Each part in a representation links to its corresponding assembly part; BMBALLOON updates exploded representations to the assembly’s current state and places balloon annotations on their drawing views.

Levels of the Exploded Representation

Top level: references only top-level components (those inserted directly into the main assembly), without exploding them further, letting you see your assembly’s basic composition. Bottom level: references only terminal parts (containing no other parts or subassemblies), letting you view every part in isolation.

If a middle-level component contains entities other than component inserts while Bottom level is selected, those entities get lost, since they can’t be referenced correctly; convert them into proper bottom-level components first.

Algorithms

Algorithm	What it does
Table by Type	Creates a table-like explosion, grouping components of the same type into rows
Linear	Finds a disassembly sequence in a given direction and order, accounting for physical collisions (a component only moves if nothing unmoved is blocking it)
Automatic	Finds a disassembly sequence respecting the assembly hierarchy, accounting for all possible collisions, automatically identifying each part’s movement direction
Manual	Creates an exact copy of the assembly ready for custom editing, without changing the main assembly

Steps and Animations

A representation contains one or more steps, each describing the components that move at that stage of assembly or disassembly. Algorithms create the required steps automatically, but you can also delete, merge, split, move, or add steps manually; each needs a unique name.

Animate a single step or the entire sequence, in either direction (disassembly or assembly), provided an initial step defining the assembly’s starting state exists. The Auto hide property automatically hides parts unimportant to a particular step during animation.

Editing Representations

Each representation stores as a block, editable with the block editor. Important: never use REFEDIT to edit a representation, it’s incompatible with exploded representation steps.

Open a representation for editing by right-clicking it in the Mechanical Browser and choosing Edit, by double-clicking it, or at the end of BMEXPLODE. While editing, double-clicking a step makes it current, discarding any unsaved modifications, so save your work first.

Move components within a representation using DMMOVE, MOVE, DMROTATE, or BMEXPLODEMOVE (which automatically adds the necessary steps after the current one); for other operations, save the current step once editing is complete, only the difference between the current and previous step gets stored. Removing a step returns its moved components to their prior positions. You can also associate text annotations (MTEXT) and other entities with a specific step, visible only while that step is active, though their positions aren’t stored in the step. Always use Save current state before finishing, or your changes are discarded.

Trailing Lines

A trailing line is a 3D polyline showing a part’s trajectory during disassembly. Use BMTRAILINGLINES on a representation open for editing to generate them, using information from the exploded view’s steps. Generate them for all parts, a subset, per step, or manually select two parts to connect. The algorithm automatically determines each part’s location and its removal point to compute the trajectory, considering both parts’ movements. Trailing lines list in the Mechanical Browser, where you can highlight, select, and zoom to their connected parts, or rename and remove them, and edit them with standard 3D polyline tools.

Creating a Representation

Local mechanical components (block- and solid-based) and mechanical external references are fully supported in exploded views.

Launch BMEXPLODE via the Explode tool button on the Tools panel of the Assembly tab, the Assembly toolbar, the Assembly menu, or the Command line. You’re prompted to select an explosion algorithm: Table by types, Linear, Automatic, Manual, Update, or Settings.
Optionally use Settings to set the representation’s Level and Name.
Select an algorithm; you’re prompted to choose Edit, Generate drawing views, or Finish.
Choose Edit to edit the representation, Generate drawing views to create views of it, or Finish to end the command.

Generating Drawing Views of the Representation

Launch VIEWBASE; you’re prompted to select objects, or choose Entire model, preseTs, or Special views.
Choose Special views; you’re prompted to choose Exploded view, Unfolded view, or Back.
Choose Exploded view; a dialog opens to select the representation and step.
Select the representation; you’re prompted for a layout name.
Optionally type one.
Position the generated views in the paper space layout.

To use balloons with representation drawing views, GENERATEASSOCVIEWS must be on.

Updating a Representation

Run BMUPDATE, or the Update option of BMEXPLODE, to sync a representation with the assembly’s current state, adjusting manually afterward if parts were added or removed. Note: part positions in representations created with Manual or Linear algorithms don’t update automatically.

Managing Representations

Open the Mechanical Browser; every representation and sequence lists under the Representations group. Right-click one for its context menu (Convert all views to new format only appears when old-format representations exist in the drawing).

Exploded view properties: Name (must be unique across every representation and block in the model); Type (Top or Bottom); Direction (Disassembly, start to end, or Assembly, end to start); Auto hide (Yes hides unimportant parts during animation); Step duration, s (default per-step duration in milliseconds, defaulting to 1000, or 1 second); Interval, s (default interval between steps); Default camera (Enabled uses the default camera position and target for every step set to use it, Disabled falls back to the previous step’s camera instead).

Operations when not open for edit: Edit (opens the representation, using a step’s custom camera if configured, otherwise the default camera if enabled, or the current camera otherwise; also possible via BEDIT or double-clicking); Update (syncs with the assembly’s current state); Convert to new format (old-format representations only); Generate views; Delete (removes the representation and its block); Renumerate similar nodes.

Operations when open for edit: Animate (the whole sequence); Show all parts; Hide unused parts; Save current state; Add a new step after the current (becomes current automatically, discarding unsaved changes); Add a new step to the end (same discard behaviour); Set this view as default for all steps (sets a default camera position tied to the exploded view itself, distinct from the initial step, which can have its own custom camera); Delete; Renumerate similar nodes; Renumerate child nodes / continuously.

Managing Representation Steps

Open the required representation for editing in the Mechanical Browser; its steps list under its node.

Step properties: Name (unique within the representation); Duration, s (defaults to the representation’s Step duration); Duration type (from the representation, or specific to this step); Duration value, s (Absolute duration type only); Camera (Default uses the representation’s default camera if enabled, or the previous step’s camera otherwise); Camera position / Target position (custom camera only, editable via the icon on the right).

Step operations: Apply (makes it current and updates parts accordingly, same as double-clicking); Set this view as default for all steps (sets this step’s camera as the representation-wide default; a step without its own camera inherits the initial step’s, and a newly created exploded view’s initial step inherits the model’s current camera); Update camera view (updates only the current step’s camera); Animate (just this step); Merge (two or more consecutive steps); Split (into a sequence of steps, one part each); Move step up / Move step down; Delete (removes the step and its associated part movements, updating positions accordingly); Renumerate similar nodes.

Editing Procedure

Select the representation in the Mechanical Browser.
Right-click it and choose Edit (or run BEDIT and select the block directly).
Perform the operations you need.
Save the current step.
Save your changes with BCLOSE and the Save option.

Important: never use the Discard option of BCLOSE, it can leave the block and its exploded representation steps in an inconsistent state, use Undo instead.

Adding Trailing Lines

Open the representation for editing.
Run BMTRAILINGLINES.
Select the subset of parts to generate trailing lines for, or the entire model.
Select which points (origin or centre) to use for the trajectory.
Optionally edit the resulting trailing lines.
Save your changes.

Frequently Asked Questions

Why should I never use REFEDIT to edit a representation? It’s incompatible with exploded representation steps and can leave the block in an inconsistent state.

What happens if I use the Discard option of BCLOSE instead of saving? It can lead to an inconsistent state for the block and its exploded representation steps, use Undo instead of Discard.

Does updating a representation with the Manual or Linear algorithm automatically move parts to match the current assembly? No, part positions in Manual and Linear representations need to be adjusted manually.

What’s lost if I generate a Bottom level representation from an assembly with mixed middle-level components? Any entities in those middle-level components other than component inserts, since they can’t be referenced correctly, convert them into proper bottom-level components first.