Can someone explain what the primitives and parameters mean in my Graphics3D code?

Question

Graphics3D[
  Table[
    GeometricTransformation[
      Cuboid[{1, 0, 0}, {.01, .2, .1}], 
      {RotationMatrix[a, {0, 0, .05}], {.001 Cos[a], .001 Sin[a], a}}], 
    {a, -Pi, 2 Pi, .2}], 
  Boxed -> False]

I followed this Documentation Center page about rotating cuboids along a space curve to make the above code (which creates the stairs for spiral staircase). I don't want to just follow it, though, I would like to understand everything I am typing in. After researching the primitives, I know that Cuboid[{a,b,c},{d,e,f}] creates a cuboid with corner {a, b, c} and opposing corner {d, e, f}.

But other than that, I'm not all sure what else is going on. I can guess at what is going on, but that does not make me feel confident in my Mathematica usage.

Specific questions:

• What does Table do? When reading about it, I cannot make sense of why I need it in my code.
• Graphics3D creates a 3D image based upon the primitives and directives entered. Is this correct? What else should I know about this?
• To make sure I understand primitives and directives clearly: Table is a primitive for Graphics3D. GeometricTransformation is a primitive for Table. Cuboid and RotationMatrix are primitives for GeometricTransformation. Boxed is a directive for Graphics3D. And things like {a, b, c} are parameters for equations or primitives. Is this correct? Sorry, this may read like a riddle.
• Final questions: What exactly does GeometricTransformation do? Is it basically saying "I'd like to rotate something (a cuboid) about an axis and in the shape of a helix?" Where are the vectors/matrices coming to play in this? This is where I read about it, but it does not help me much in understanding what I am doing.

Answer 1

Although your code produces a picture of a "spiral staircase", there are some choices of parameters the escape my understanding, so let's look at simplified version with some debugging code added.

Module[{t, g},
  g = Graphics3D[
    t = Table[
      GeometricTransformation[
        Cuboid[{1, 0, 0}, {.01, .2, .1}],
        {RotationMatrix[a, {0, 0, 1}],(* rotation by angle a about z-axis *)
         {0, 0, a} (* translation by a along z-axis *)}],
      {a, -Pi, 2 Pi, .2}],
    Boxed -> False];
 Print[Row[{"Number of cuboids: ", Length@t}]];
 g]

Number of cuboids: 48

The Table expression produces 48 cuboids (the steps), each one slightly different from tho others because of the iteration variable a is stepped from -Pi to 2 Pi by step size 0.2. GeometricTransformation applies two geometric transforms to the cuboid as each table element is generated. These are a rotation about and a translation along the z-axis, which are given in its the second argument.

The number 48 comes from the iteration descriptor, {a, -Pi, 2 Pi, .2}, which calls for Ceiling[(2 Pi - (-Pi))/.2] steps (which evaluates to 48).

Edit

This is to satisfy the OP's request for more information on the role of RotationMatrix.

GeometricTransformation needs to told what transforms to use and its second argument supplies that info. In this case, it is given a list of two transforms, a rotation by angle a about the z-axis and a translation by a along the z-axis. Let RotationMatrix[a, {0, 0, 1}], the first item in the list, be denoted by r. Then r.{x, y, z} gives {x Cos[a] - y Sin[a], y Cos[a] + x Sin[a], z}, the rotation of {x, y, z} by angle a about the z-axis.

Answer 2

If you indent the code, it's easier to see its structure

Graphics3D[
    Table[
        GeometricTransformation[
            Cuboid[{1, 0, 0}, {.01, .2, .1}],
            {RotationMatrix[ a, {0, 0, .05}], {.001 Cos[a], .001 Sin[a], a}}],
    {a, -[Pi], 2 Pi, .2}
    ], Boxed -> False
]

Graphics3D is a container for three-dimensional graphics objects, like Cuboid. Table is used here to produce a list of transformed cuboids depending on parameter a. Consider it an iteration construct that stores each step in a list (that will be passed to Graphics3D to be shown). GeometricTransformation takes a graphics object and produce another graphics object that has been transformed according to the specified transformation rule, here a rototranslation (if I am not mistaken).

I have not run the code, but I believe it will generate a series of pictures of a rolling cuboid. Well, sort of... Er, let's say it's 'spirolling'.