LCD has nothing to do with Liquid Crystal Display: it is LDraw Connection Database. This is a proposal for developers of Lego CAD softwares, such as MLCAD, LeoCAD etc. It is based on the LDraw .dat file system of parts.

LCD, if once realized, can solve problems of Lego CAD software users of connecting parts correctly. When connecting virtual Lego parts, it is possible to make two kinds of errors: either leaving a gap or pushing the parts inside each other. The correct distance between two parts may be hard to discover exactly, especially when working in three dimensions, for example, in complex Technic lego sets. Even if an experienced Lego CAD builder can connect parts quickly, LCD may add some convenience to his or her work; and for beginners, it seems to be a must.
  And LCD can do more.

In this document, numbers like 3001 refer to numbers of Lego parts, as registered in Lego CAD softwares. When writing the document, we have used MLCAD 2.00 with the parts list from the archive complete.exe, downloaded from www.ldraw.org, archived at 30th September, 2000.
  Abbreviations used in this document:

CDL – Connector Descripting List. A file accompanying each Lego part file, containing information about connectors found on a specific part.
  LCD – LDraw Connection Database. A file accompanying a Lego CAD software, containing general connector and connection information. Also, the name of the whole idea.
  LCS – Local Coordinate System. A three-dimensional coordinate system belonging to a specific type of connector.

All trademarks mentioned in this document are property of their respective owners.

The idea is maintaining a connection database. It deals with “connectors”, what is a term to group all particles what can connect to each other. The most important connector is the Lego stud. All connectors are arranged to pairs, “what connects to what”. We may call them as male and female, but sometimes this may be confusing. The “spouse” of the Lego stud is a stud inlet created on the bottom of a basic Lego brick. And finally, connectors may have variants: for example, 3062A and 3062B are the same parts, but 3062B has a hollow stud on it. The variant behaves like a normal connector, but may have some additional behaviors.
  A draft example of the stud connector family:

male:
  Stud
  variant:
  Hollow Stud (e.g. 3062B)

female:
  Stud Inlet

When coding the properties of a connector, we specify:
  1. What connectors are suitable for the connector as a spouse? In the above example, the female Stud Inlet may connect to either a Stud or a Hollow Stud. Both male variants may connect to a Stud Inlet, but the Hollow Stud may, additionally, connect to an antenna or other rods.
  2. What is the position they take when connected? This is specified in a coordinate system.
  3. What movements can the connected pair make? This is specified in a coordinate system, by a range of degrees (or radians), according to each axis. For example, the Stud–Stud Inlet connection cannot move; other connections can slide and/or rotate.

LCD is a database what contains information about connectors and only connectors. There is nothing in it about any specific Lego part. It describes connectors in a pseudo-physical context, not dealing with their visual appearance, focusing only to the question of connecting and, later, of moving compared to each other.

Some kinds of Lego connectors for a first taste:

male: Stud (connects to Stud Inlet)
  variant: Hollow Stud (connects to Stud Inlet, Rod)
  variant: Minifig Head Stud (connects to Stud Inlet, Minifig Cap)
  variant: Minifig Head Hollow Stud (connects to Stud Inlet, Minifig Cap, Rod)
  female: Stud Inlet (connects to Stud and variants)
  variant: Turnable Stud Inlet (connects to Stud and variants) e.g. 3821
  female: Minifig Cap (connects to Minifig Head Stud, Minifig Head Hollow Stud)

male: Rod (connects to Hollow Stud, Minifig Head Hollow Stud, Minifig Hand)

male: Pin (connects to Pinhole) e.g. 3673
  variant: Pin 3/4 (connects to Pinhole) e.g. 32002
  variant: Pin 1/2 (connects to Pinhole) e.g. 4274
  female: Pinhole (connects to Pin and variants) e.g. 3700

male: Axle (connects to Axlehole) e.g. 3704
  female: Axlehole (connects to Axle) e.g. 32064

male: Minifig Arm Top (connects to Minifig Torso)
  female: Minifig Torso (connects to Minifig Arm Top)

male: Minifig Waist (connects to Minifig Arm Bottom)
  female: Minifig Arm Bottom (connects to Minifig Waist)

male: Minifig Tool (connects to Minifig Hand) e.g. 38, 2561, 2562, 3852
  female: Minifig Hand (connects to Minifig Tool)

male: Towball (connects to Towball Socket) e.g. 3184
  female: Towball Socket (connects to Towball) e.g. 3183

These examples show some interesting differences. A Minifig Head Stud is an absolutely normal stud, identical to any Stud in its physical appearence; however, if we’d identify it as a Stud, we’d fall into problems when taking any minifig headdress (3624, 3833, 3844, 3896, 4485 etc.). These parts have a normal Stud Inlet inside, but they cannot be connected to, say, a 3001 block. This will force us to make a distinction between a normal Stud and a Minifig Head Stud; the latter can connect to a Minifig Cap, the former cannot.
  Some connectors are very specific. For example, there are only two minifig arms (975, 976) and one minifig hand (977) listed in the parts inventory, but we need a special connection pair to put them together, and another special connection is needed to connect the arm to the torso. Other connections are, on the other hand, very diversified, like the Stud family. Similarly, Minifig Tool is a group name for all parts (more exactly, for handles of all parts) that are designed to fit into a minifig’s hand. For example, a Rod (the 3957 antenna) fits into a minifig’s hand, so it is actually a Minifig Tool. But because it can be assembled into a 3062B hollow rounded block, we must make a distinction here, too. Rod is a “bachelor” connector, it hasn’t any female spouse designed specifically for it, but it fits to several places. Such connectors will turn our full connector list into a cross-referencing database.
  When will we be able to give the same code to two kinds of connectors, and when will be two different codes required? The answer is simple in theory: if the two connectors act in the same way physically, and if all spouses for the first connector are applicable to the second one and vice versa, we can treat them as identical. (This means that anything what can hold a Stud tight is a Stud Inlet, no matter how does it look like.) In practice, the answer is a little more difficult, since we have to hunt the whole database for possible exceptions; but for the first drafts of LCD, we may omit bizarre or rare applications, such as the antenna poked through a hollow round 1*1 block. This is a physical possibility, but probably not a used building practice. (Are we wrong here?)

A connector, observed as a standalone entity, has some properties; two connectors in a connected state have additional properties. We will refer these as standalone and connected properties.

The most important standalone property will be the Local Coordinate System (LCS). This is a three-dimensional coordinate system, having a base point and axes. We will use it to snap the two connectors together. For example, a Stud can be observed as a virtual disk with 8 mm of diameter, with an axis crossing its center. A Stud Inlet can be observed as a similar disk. If we position both base points to the same coordinates, and turn their axes to the same directions, we have connected the Stud and the Stud Inlet perfectly.

Another standalone property will be the Size property. We won’t refer to each millimeter of an Axle as a separate connector, although an Axle may connect to several Axleholes. We treat its whole length as a single, large sized Axle connector. This helps us to move parts along the Axle. But this makes it necessary to keep more parts connect to the same connector, too.
  Similarly, we won’t refer to each Stud on the same surface separately. Instead, we treat them as a single, large sized Stud connector. This helps us to maintain special connections, like the Stud–Plate Edge connection (see Appendix A).
  The Size property will be different for different parts; hence, it won’t be stored in the LCD but in the CDL files (see below).

The most important connected property will be the Movement property: how can the connectors act together? We have to store the rules for this property for each pair of possible combinations; for example, we store (at least) two Movement properties for the Hollow Stud connector: one will be Hollow Stud with Stud Inlet and the other will be Hollow Stud with Rod.
  The value of a Movement property can be one or more allowed rotations and slides.
  A rotation is registered for the Stud–Turnable Stud Inlet connection: a Turnable Stud Inlet (like at the bottom of 3821 door) may turn around the vertical axis (vertical if studs pointing upwards) in 360 degrees. (The door itself may collide with the neighboring studs, if any, but this is a question being totally out of our interest.)
  A slide is registered for the Axle–Axlehole connection: the Axlehole may slide along the main axis of the Axle, as long as the Axle is physically present.
  Several rotations are registered for the Towball–Towball Socket connection: they may rotate freely around the center of the Towball, according to all three dimensions, up to a specified degree of difference.
  And finally, both a rotation and a slide is registered for the Rod–Hollow Stud connection: the Hollow Stud may slide along the Rod and/or rotate around its axis.

Another connection property will be the Distance of Drag. This is a distance (in millimeters, maybe) from where the two connectors are recognized as a pair and being automatically fitted by the Lego CAD software. For example, the height of a plate (1/3 brick) without the studs is 3.2 millimeters; it seems to be logical to set the distance of drag to be less than the half of this, so 1.5 mm. This is a lot less than half of the diameter of a stud and its surrounding area. If this value is set correctly, take two bricks and put them near each other – in a distance of 1.6 mm between a Stud and a Stud Inlet. Nothing happens. Move them a little closer – snap! The bricks fit correctly.
  Why do we use less than the half? Take a 2*1 brick and put a 1*1 brick onto it, exactly positioning onto the center of the bigger brick. How will the software know where does the smaller brick belong to? There is an equal chance for both studs. If you set the distance to the half of the critical value, you will see the brick snapping to an arbitrarily chosen stud, what may make things messing up.

How to build the LDraw Connection Database? We have to take all virtually available Lego parts and examine the ways of possible connections. We have to take notes on what do they connect to, how do they fit together, what movements can they make. For each connector type, we set up an LCS. For each possible connection, we set up Movement rules. (And, of course, we register properties not mentioned in this document but to be invented later.) We discover what connectors may be treated as the same and what are different. We assign a unique code to each connector type and variant.
  Finally, we build a database (LCD) containing all required data, and publish the list of assigned codes with the necessary information.

After building the LCD, we have to use it. To do so, we have to register the actual connectors found on the surface (and, if necessary, in the interior) of the actual Lego parts. For each .dat file describing a part, we create a Connector Descripting List (CDL). This file will describe:
  1. where are connectors on the part and what are their Sizes;
  2. what direction are they pointing to;
  3. what type of connector are they each.
  The position and direction of connectors on the part are specified in a coordinate system relative to the part, suitable for the general coordinate system used in Lego CAD softwares. (Yet we didn’t find a description for the .dat file format, so we can’t talk about details; however, this document is intended to be read by Lego CAD developers who already know this coordinate system much better than we do.) The type of connectors is coded according to the LCD database codes. For those locations on the part where no connector is there, we don’t store any information.

For example, the standard 3001 brick will be described in 3001.cdl as follows (coordinates are specified here as stud and brick height units, what won’t be useful for real, only used as an example):

Stud at x = 0, y = 0, z = 1; Size x = 2, y = 4
  Stud Inlet at x = 0, y = 0, z = 0; Size x = 2, y = 4

We must be careful when looking for connectors. A fully equipped minifig will be a good example. Let’s take a minifig wearing a helmet with a visor, an airtank, tools in his hands and a ski; disassemble him and take notes for all parts:

PartConnectors found

2446 Minifig Helmet Minifig Cap, Visor Holder
  2447 Minifig Helmet Visor Visor
  3626B Minifig Head – Stud Hollow Minifig Head Hollow Stud, Stud Inlet
  3838 Minifig Airtanks Minifig Neck Surround
  973 Minifig Torso Stud, Minifig Neck, Minifig Torso (2), Stud Inlet (2)
  975 Minifig Arm Right Minifig Arm Top, Minifig Arm Bottom
  976 Minifig Arm LeftMinifig Arm Top, Minifig Arm Bottom
  977 Minifig Hand (2)Minifig Waist, Minifig Hand
  38 Minifig HarpoonMinifig Tool
  4479 Minifig Metal Detector Minifig Tool, Stud (6), Stud Inlet
  970 Minifig HipsStud (2), Minifig Hips Left, Minifig Hips Right
  971 Minifig Leg Right Minifig Leg Right, Stud Inlet
  972 Minifig Leg LeftMinifig Leg Left, Stud Inlet
  6120 Minifig Ski (2)Stud, Stud Inlet, Hole (2)

Many of the listed connectors weren’t mentioned previously in the document, but probably their meanings will be obvious.
  Some questions may arise from this example. Why do we need separate Minifig Hips/Leg Left and Minifig Hips/Leg Right connector pairs? They both seem to be the same. This is true for their physical appearance, but not for their movement. If we set up the LCS around the rotator axle on the hips, what seems to be logical, we well see them rotating in opposite directions. If the legs could turn forwards as far as backwards, this wouldn’t be a problem, but they cannot. The range of allowed movement will be the opposite of each other.

Of course, if the LCD system is once developed in reality and implemented in Lego CAD softwares, designers of new parts should equip their creations with the appropriate .cdl files.

But finally, what is this whole thing for? Who will take any advantage from it? The end user. Those people who use MLCAD, LeoCAD or other Lego CAD software for building sets of virtual Lego. When getting LCD-equipped software in their hands, they will see almost the same as previously, but there will be something more.
  They take two parts near each other, and they fit. No need to position them neatly together, they will fit as in real plastic life. They can assemble a complete minifig on their own in some seconds, and they will be sure that all parts are really fitting together. They assemble a complicated Technic model almost as easily as they do it in real. But if they want to try something irregular, they can simply turn off LCD system as an option and go on their own.
  When putting two parts near each other, the currently selected one will be moved to the connecting one, leaving the latter where it is.
  When selecting and moving a part which is already connected to another part, either the selected part will move only, separating from the connecting part – or both parts will move, and if the second one is connected to a third part, that will move, too, and so on. This is because when connecting parts, LCD system makes a note for itself telling that those parts are connected together, so it always knows what parts are building up a submodel. Now the user can take a
  submodel just like in reality, grabbing a part of it and the whole is moving. Or, the grabbed part may separate from the submodel. Which one will happen depends on a toggle that the user can set.
  By keeping information of the way connections can rotate or slide, LCD system can put life into virtual Lego models. When connecting parts, each movable connection is included in a special list. The user can view this list, disable items in it (in the case of unimportant or obstacled movements), make notes for the important items, and, most importantly, give orders to the items. Here is a hinge, rotate it! And it will be so. And user will see it is good. And user will call it Lego. Evening and morning, seventh day.

Acrylnitrile butadiene styrene, the raw material for real Lego bricks, moulds in a precision of 0.005 mm.
  Light, the raw material for virtual Lego bricks, moulds in a precision smaller than an atom.
  We can take an advantage from this.

In this section, we will create a draft list for Lego connectors. This is a simplified version of a real LCD database. We only list connectors and their most important properties. We didn’t take a ruler and a protractor to discover actual size and angle information. Yet we don’t establish LCS orientations. The purpose of this draft is only to show developers: what can they do and how they can do it.

The following format is used to describe connectors:

Stud
  Level: 1
  Sample: 3001, top
  Spouse: Stud Inlet, Plate Edge
  Variant: Hollow Stud, Minifig Stud, Minifig Hollow Stud

Variants are listed separately, but only the differences from their ascendant are listed.
  A new thing here is Level. This isn’t a property and we needn’t include it in a real LCD database. This is an information for developers on how important the connector is. Level 1 connectors are the most important, basic-level ones; an LCD system won’t be usable before knowing all of these. Level 2 ones are less important, developers may omit them from first releases. Level 3 are unofficial, non-standard connectors.
  The list is far from complete.

Stud
  Level: 1
  Sample: 3001, top
  Spouse: Stud Inlet, Plate Edge
  Variant: Hollow Stud, Minifig Stud, Minifig Hollow Stud

Hollow Stud
  Level: 2
  Sample: 3062B, top
  Spouse: Stud Inlet, Plate Edge, Rod
  Variant of: Stud

Minifig Head Stud
  Level: 2
  Sample: 3626A, top
  Spouse: Stud Inlet, Minifig Cap
  Variant of: Stud

Minifig Head Hollow Stud
  Level: 2
  Sample: 3626B, top
  Spouse: Stud Inlet, Minifig Cap, Rod
  Variant of: Stud

Stud Inlet
  Level: 1
  Sample: 3001, bottom
  Spouse: Stud and variants
  Variant: Turnable Stud Inlet

Turnable Stud Inlet
  Level: 1
  Sample: 3821, bottom
  Variant of: Stud Inlet

Minifig Cap
  Level: 2
  Sample: 3624
  Spouse: Minifig Head Stud, Minifig Head Hollow Stud

Shutter Holder
  Level: 2
  Sample: 3581
  Spouse: Shutter

Shutter
  Level: 2
  Sample: 3582
  Spouse: Shutter Holder

Pin
  Level: 2
  Sample: 2458
  Spouse: Hole

Axlehole
  Level: 2
  Sample: 3941
  Spouse: Axle

Axle
  Level: 2
  Sample: 3704
  Spouse: Axlehole

Metal Axle Holder
  Level: 2
  Sample: 3137
  Spouse: Metal Axle

Metal Axle
  Level: 2
  Sample: 35B
  Spouse: Metal Axle Holder, Wheel Town

Wheel Town
  Level: 2
  Sample: 3137C01
  Spouse: Metal Axle, Wheel Town Tyre

Wheel Town Tyre
  Level: 2
  Sample: 123
  Spouse: Wheel Town Tyre

Coupling Male
  Level: 2
  Sample: 4747
  Spouse: Coupling Female

Coupling Female
  Level: 2
  Sample: 4748
  Spouse: Coupling Male

Minifig Hand
  Level: 2
  Sample: 977, 4085
  Spouse: Minifig Tool, Plate Edge

Towball
  Level: 2
  Sample: 3184
  Spouse: Towball Socket

Towball Socket
  Level: 2
  Sample: 3183
  Spouse: Towball

Plate Edge
  Level: 3
  Sample: 3022
  Spouse: Stud, Minifig Hand

Hole
  Level: 2
  Sample: 6541
  Spouse: Pin

Gear Tooth
  Level: 2
  Sample: 741, 3647, 3743, 6589, 32270
  Spouse: Gear Tooth

Train Rail
  Level: 2
  Sample: 3228
  Spouse: Train Wheel

Train Wheel
  Level: 2
  Sample: 2879
  Spouse: Train Rail

Minifig Neck Surround
  Level: 2
  Sample: 3838
  Spouse: Minifig Neck

Minifig Arm Top
  Level: 2
  Sample: 976
  Spouse: Minifig Torso

Minifig Tool
  Level: 2
  Sample: 2562
  Spouse: Minifig Hand

Visor Holder
  Level: 2
  Sample: 2446
  Spouse: Visor

Visor
  Level: 2
  Sample: 2447
  Spouse: Visor

Minifig Hips Left
  Level: 2
  Sample: 970
  Spouse: Minifig Leg Left

Minifig Hips Right
  Level: 2
  Sample: 970
  Spouse: Minifig Leg Right

Minifig Leg Left
  Level: 2
  Sample: 972
  Spouse: Minifig Hips Left

Minifig Leg Right
  Level: 2
  Sample: 971
  Spouse: Minifig Hips Right

Minifig Arm Bottom
  Level: 2
  Sample: 976
  Spouse: Minifig Waist

Minifig Waist
  Level: 2
  Sample: 977
  Spouse: Minifig Arm Bottom

Minifig Torso
  Level: 2
  Sample: 973
  Spouse: Minifig Arm Top

Two Fingers
  Level: 2
  Sample: 6048
  Spouse: Three Fingers

Three Fingers
  Level: 2
  Sample: 6217
  Spouse: Two Fingers

Cupboard Inlet
  Level: 2
  Sample: 4534
  Spouse: Cupboard Drawer

Cupboard Drawer
  Level: 2
  Sample: 4536
  Spouse: Cupboard Inlet

Light
  Level: 2
  Sample: 4767
  Spouse: Light Globe

Light Globe
  Level: 2
  Sample: 4773
  Spouse: Light

Hinge Base
  Level: 2
  Sample: 3937
  Spouse: Hinge Top

Hinge Top
  Level: 2
  Sample: 3938
  Spouse: Hinge Bottom

Hinge Female
  Level: 2
  Sample: 3831
  Spouse: Hinge Male

Hinge Male
  Level: 2
  Sample: 3830
  Spouse: Hinge Female

Car Roof
  Level: 2
  Sample: 4213
  Spouse: Car Roof Holder

Car Roof Holder
  Level: 2
  Sample: 4214
  Spouse: Car Roof

Magnet
  Level: 2
  Sample: 73092
  Spouse: Magnet, Magnet Holder

Magnet Holder
  Level: 2
  Sample: 2607
  Spouse: Magnet

Turntable Small Base
  Level: 2
  Sample: 3680
  Spouse: Turntable Small Top

Turntable Small Top
  Level: 2
  Sample: 3679
  Spouse: Turntable Small Base

Turntable Big Base
  Level: 2
  Sample: 3403
  Spouse: Turntable Big Top

Turntable Big Top
  Level: 2
  Sample: 3404
  Spouse: Turntable Big Base

In this section, we will create a draft list for Lego connections. This is a simplified version of a real LCD database. We only list connections and their most important properties. We didn’t take a ruler and a protractor to discover actual size and angle information. Yet we don’t establish LCS orientations. The purpose of this draft is only to show developers: what can they do and how they can do it.

The following format is used to describe connections:

Stud–Stud Inlet
  Level: 1
  Sample:
  Snap: each stud into an inlet
  Rotation: none
  Slide: none

Snap is a property describing how connectors will fit together; Rotation and Slide describe how do they act together once snapped. In an actual LCD database, all three properties are expressed in
  coordinate figures.
  A new thing here is Level. This isn’t a property and we needn’t include it in a real LCD database. This is an information for developers on how important the connection is. Level 1 connections are the most important, basic-level ones; an LCD system won’t be usable before knowing all of these. Level 2 ones are less important, developers may omit them from first releases. Level 3 are unofficial, non-standard connections.
  The list is far from complete.

Stud–Stud Inlet
  Level: 1
  Snap: each stud into an inlet
  Rotation: none
  Slide: none

Stud–Plate Edge
  Level: 3
  Snap: edge between rows of studs
  Rotation: none
  Slide: along the edge

Hollow Stud–Rod
  Level: 3
  Snap: rod through the stud
  Rotation: 360 degrees
  Slide: along the axis

Minifig Head Stud–Minifig Cap
  Level: 2
  Snap: like Stud–Stud Inlet
  Rotation: 360 degrees
  Slide: none

Stud–Turnable Stud Inlet
  Level: 1
  Snap: like Stud–Stud Inlet
  Rotation: 360 degrees
  Slide: none

Shutter Holder–Shutter
  Level: 2
  Snap: both ends of shutter into the bevels of holder
  Rotation: 180 degrees
  Slide: none

Pin–Hole
  Level: 2
  Snap: pin into the hole
  Rotation: 360 degrees
  Slide: none

Metal Axle Holder–Metal Axle
  Level: 2
  Snap: both ends of axle into the holder
  Rotation: 360 degrees
  Slide: none (physically possible but unnecessary in practice)

Metal Axle–Wheel Town
  Level: 2
  Snap: an end of the axle into the wheel
  Rotation: none (they rotate together)
  Slide: none

Wheel Town–Wheel Town Tyre
  Level: 2
  Snap: tyre around the wheel
  Rotation: none (they rotate together)
  Slide: none

Towball–Towball Socket
  Level: 2
  Snap: towball into the socket
  Rotation: up to a limited angle in all three dimensions
  Slide: none

Axle–Axlehole
  Level: 2
  Snap: axle through the axlehole
  Rotation: none
  Slide: along the axis

This appendix shows drafts of CDL files for some sample parts. The following format is used:

3001 Brick 2 x 4
  Level: 1
  Stud at x = 0, y = 0, z = 1; Direction z = 1; Size x = 2, y = 4
  Stud Inlet at x = 0, y = 0, z = 0; Direction z = 1; Size x = 2, y = 4

The coordinates are expressed in studs and bricks, in an arbitrarily chosen coordinate system and with an estimated precision only. For real CDL files, the currently Lego CAD software coordinate system is used, relative to a specified point on the part.
  The list is far from complete.

3001 Brick 2 x 4
  Level: 1
  Stud at x = 0, y = 0, z = 1; Direction z = 1; Size x = 2, y = 4
  Stud Inlet at x = 0, y = 0, z = 0; Direction z = 1; Size x = 2, y = 4

4733 Brick 1 x 1 with Studs on Sides
  Level: 2
  Hollow Stud at x = 0, y = 0, z = 1; Direction z = 1; Size x = 1, y = 1
  Hollow Stud at x = -0.5, y = 0, z = 0.5; Direction x = -1; Size x = 1, y = 1
  Hollow Stud at x = 0.5, y = 0, z = 0.5; Direction x = 1; Size x = 1, y = 1
  Hollow Stud at x = 0, y = -0.5, z = 0.5; Direction y = -1; Size x = 1, y = 1
  Hollow Stud at x = 0, y = 0.5, z = 0.5; Direction y = 1; Size x = 1, y = 1
  Stud Inlet at x = 0, y = 0, z = 0; Direction z = 1; Size x = 1, y = 1

(Note that all side studs are pointing to the same direction where they are located from the center of the brick.)

4070 Brick 1 x 1 with Headlight
  Level: 2
  Stud at x = 0, y = 0, z = 1; Direction z = 1; Size x = 1, y = 1
  Stud Inlet at x = 0, y = 0, z = 0; Direction z = 1; Size x = 1, y = 1
  Hollow Stud at x = -0.4, y = 0, z = 0.5; Direction x = -1; Size x = 1, y = 1
  Stud Inlet at x = 0.4, y = 0, z = 0.5; Direction x = 1; Size x = 1, y = 1

(Note that the hollow stud is 0.1 units [estimated] closer to the center than in the previous sample.)

6019 Plate 1 x 1 with Clip Horizontal
  Level: 2
  Stud at x = 0, y = 0, z = 1; Direction z = 1; Size x = 1, y = 1
  Stud Inlet at x = 0, y = 0, z = 0; Direction z = 1; Size x = 1, y = 1
  Minifig Hand at x = -1, y = 0, z = 0.5; Direction y = 1
  Plate Edge at x = 0.5, y = 0, z = 0.5; Direction x = 1; Size y = 1
  Plate Edge at x = 0, y = -0.5, z = 0.5; Direction y = -1; Size x = 1
  Plate Edge at x = 0, y = 0.5, z = 0.5; Direction y = 1; Size x = 1

(Note that a Minifig Hand connector does not have a Size property.)

If a Lego CAD software has been equipped with a full-fledged LCD system, we can take further advantages from that. Some additional thoughts follow in this appendix, to let you see what you didn’t see in previous chapters.

CABLES. Electric cables, fiber optic tubes, pneumatic tubes and any kind of flexible equipment can be now easily modeled and handled. The way is the following. We design two special parts for each kind of cable, one for both ends and one for a middle particle. The middle particle is short, its length may vary from some millimeters or less to some centimeters or more, depending on how realistic we want to be. The middle part can connect to another middle part or an end part; the end part can connect to a middle part or a different Lego part suitable for the tube or cable.
  When the user takes a cable, he or she will be prompted for a length and, optionally, for a “density”. The density will specify the number of middle parts used to build the cable. The connectors used to build the cable are having a special property: even if the user turned the respective toggle to make connected parts separate when moved, the parts of cables do not separate. The user can move any part of the cable, either an end or a middle part, and the LCD system will move the neighboring parts together with it, as the connections require to do so.

FINAL CONTROL. When a model is ready built, a user can’t play with it in current Lego CAD softwares. With LCD system, they can. We mentioned a list of movable connections found in the model, what the user can view and give commands to connections. In this case, any part connected to a moving part in a non-moving way will move together. But we needn’t stop here.
  The user can create toolbars, as in several Windows applications, and assign buttons to chosen movable connections, setting what modification should happen by a click. Press a button and the door opens. Press another one and the window closes.
  Later, developers may add sliders or disks to toolbars what a user can slide or rotate, and chosen connections slide or rotate along with them. Cables can have a property telling if there is electric current or pneumatic pressure in them; electric or pneumatic parts may have a property telling if there is activity in them, and if yes, the software can know what to do. Finally, a user turns a battery switch on and the car wheels start rotating; and if there is a surface below the car, that can be observed as a connection and the car will start running on.
  If these are realized all, the game will almost be perfect; however, it is still hard to imagine that anybody would give up buying real Lego sets for the purpose of playing Lego only in simulation. That is the thing what is really perfect, not the virtual one.

COMPUTER PARTS. Electronical parts like the Technic Control Center or the RCX would be harder to emulate, but even this is possible. People are creating softwares to emulate home computers of the 1980s, and they work; programs written originally for these home computers are running well on emulators. An RCX emulator is undoubtedly outside the task of a 3D CAD program development, but it is possible, and there may be living a programmer somewhere who can create a software module for it.