### 9.7.8 Other things to note

There's no reason why the index value in your simple for-loop should step one unit at a time. Since the while-loop doesn't care how the index changes, you can change it in whichever way you want. Eg:

    #declare Index = Index - 1;  Decrements the index (be careful with the while
                                 loop condition)

    #declare Index = Index + 0.2;  Increases by steps of 0.2

    #declare Index = Index * 2;  Doubles the value of the index at each step.

    etc.

- Be careful where you put your while-loop.

I have seen this kind of mistake more than once:

    #declare Index = 1;
    #while(Index <= 10)
       blob
       {  threshold 0.6
          sphere { <Index, 0, 0>, 2, 1 }
       }
       #declare Index = Index + 1;
    #end

You'll probably see immediately the problem.

This code creates 10 blobs with one component each. It doesn't seem to make much sense. Most probably the user wanted to make one blob with 10 components.

Why did this mistake happen? It may be that the user (more or less subconsciously) thought that the while-loop must be the outermost control structure and do not realize that while-loops can be anywhere, also inside objects (creating subcomponents or whatever).

The correct code is, of course:

    blob
    {  threshold 0.6

       #declare Index = 1;
       #while(Index <= 10)

          sphere { <Index, 0, 0>, 2, 1 }

          #declare Index = Index + 1;
       #end
    }

The essential difference here is that it's only the sphere code which is run 10 times instead of the whole blob code. The net result is the same as if we had written the sphere code 10 times with proper values of 'Index'.

Be also careful with the placement of the braces. If you put them in the wrong place you can end up accidentally repeating an opening or a closing brace 10 times. Again, a proper indentation usually helps a lot with this (as seen in the above example).

- Tip: You can use while-loops in conjunction with arrays to automatize the creation of long lists of elements with differing data.

Imagine that you are making something like this:

      color_map
      {  [0.00 rgb <.1,1,.6>]
         [0.05 rgb <.8,.3,.6>]
         [0.10 rgb <.3,.7,.9>]
         [0.15 rgb <1,.7,.3>]
         ...
         and so on

It's tedious to have to write the same things over and over just changing the index value and the values in the vector (even if you use copy-paste to copy the lines).

There's also one very big problem here: If you ever want to add a new color to the color map or remove a color, you would have to renumber all the indices again, which can be extremely tedious and frustrating.

Wouldn't it be nice to automatize the creation of the color map so that you only have to write the vectors and that's it?

Well, you can. Using a while-loop which reads an array of vectors:

    #declare MyColors = array[20]
       {  <.1,1,.6>, <.8,.3,.6>, <.3,.7,.9>,
          <1,.7,.3>, ...
       }

    ...

       color_map
       {  #declare LastIndex = dimension_size(MyColors, 1)-1;
          #declare Index = 0;
          #while(Index <= LastIndex)

             [Index/LastIndex rgb MyColors[Index]]

             #declare Index = Index + 1;
          #end
       }

Now it's easy to add, remove or modify colors in your color map. Just edit the vector array (remembering to change its size number accordingly) and the while-loop will automatically calculate the right values and create the color map for yourself.