Maybe the Roon effect is a good starting point to explain and show a state machine. A state machine breaks down your code in little steps and each time you call Roon it will go to the next steps (if conditions are satisfied, e.g. a delay has lapsed or a letter is displayed).
Your comments in Roon already give you a guidance (//R, //o, //o and //n); there are a few more. You start with a fill(), next you do letters, next you move stuff and lastly you do a fill again. In between you have all kinds of delays.
fill
R
o
o
n
shift
fill
Now each letter consists of setting some voxels and a delay, setting some other voxels, delay again etc.
Every time you do one or more statements (setvoxel, shift) that is/are followed by a delay_ms, you have two steps. The fills also count as steps. If I counted correctly, you have 57 steps.
// effect 2 text Roon
void Roon() {
 PORTC = B10110110; // 2
1)
 fill(0x00);
Â
 //R
2)
 setvoxel(0, 7, 0);
 ...
3)
 delay_ms(5000);
4)
 setvoxel(0, 7, 4);
 ...
5)
 delay_ms(5000);
6)
 setvoxel(0, 7, 3);
 ...
 shift(AXIS_X, 1);
7)
 delay_ms(5000);
8)
 setvoxel(0, 7, 0);
 ...
 shift(AXIS_X, 1);
9)
 delay_ms(5000);
10)
 shift(AXIS_X, 1);
11)
 delay_ms(6000);
 //o
12)
 setvoxel(0, 7, 1);
 ...
 shift(AXIS_X, 1);
13)
 delay_ms(5000);
14)
 setvoxel(0, 7, 0);
 ...
 shift(AXIS_X, 1);
15)
 delay_ms(5000);
16)
 setvoxel(0, 7, 0);
 ...
 shift(AXIS_X, 1);
17)
 delay_ms(5000);
18)
 setvoxel(0, 7, 1);
 ...
 shift(AXIS_X, 1);
19)
 delay_ms(5000);
20)
 shift(AXIS_X, 1);
21)
 delay_ms(6000);
 //o
21)
 setvoxel(0, 7, 1);
 ...
 shift(AXIS_X, 1);
22)
 delay_ms(5000);
23)
 setvoxel(0, 7, 4);
 ...
 shift(AXIS_X, 1);
24)
 delay_ms(5000);
25)
 setvoxel(0, 7, 4);
 ...
 shift(AXIS_X, 1);
26)
 delay_ms(5000);
27)
 setvoxel(0, 7, 1);
 ...
 shift(AXIS_X, 1);
28)
 delay_ms(5000);
29)
 shift(AXIS_X, 1);
30)
 delay_ms(6000);
 //n
31)
 setvoxel(0, 7, 0);
 ...
 shift(AXIS_X, 1);
32)
 delay_ms(5000);
33)
 setvoxel(0, 7, 4);
 shift(AXIS_X, 1);
34)
 delay_ms(5000);
35)
 setvoxel(0, 7, 4);
 shift(AXIS_X, 1);
36)
 delay_ms(5000);
37)
 setvoxel(0, 7, 0);
 ...
 shift(AXIS_X, 1);
38)
 delay_ms(5000);
39)
 shift(AXIS_X, 1);
40)
 delay_ms(6000);
41)
 shift(AXIS_X, 1);
42)
 delay_ms(5000);
43)
 shift(AXIS_X, 1);
44)
 delay_ms(5000);
45)
 shift(AXIS_X, 1);
46)
 delay_ms(5000);
47)
 shift(AXIS_X, 1);
48)
 delay_ms(5000);
49)
 shift(AXIS_X, 1);
50)
 delay_ms(5000);
51)
 shift(AXIS_X, 1);
52)
 delay_ms(5000);
53)
 shift(AXIS_X, 1);
54)
 delay_ms(5000);
55)
 shift(AXIS_X, 1);
56)
 delay_ms(3500);
57)
 fill(0x00);
}
I do not understand why you did not implement steps 39 to 56 in e.g. a for-loop; maybe inexperience.
E.g.
// shift 7 times with a delay of 5000
for(int cnt=0;cnt<7;cnt++)
{
 shift(AXIS_X,1);
 delay_ms(5000);
}
// shift one more with a delay of 3500
shift(AXIS_X,1);
delay_ms(5000);
Anyway, that does not matter too much.
A simple way to implement a state machine is the use of a switch/case construction.
/*
 display Roon
 Returns:
  true if completed, else false
*/
bool effect_Roon()
{
 // remember what we are going to do
 static byte currentState = 1;
Â
 switch(currentState)
 {
  case 1:
   fill(0x00);
   // done with this state, next time we call effect_Roon do the next step
   currentState++;
   break;
  case 2:
   setvoxel(0, 7, 0);
   setvoxel(0, 7, 1);
   setvoxel(0, 7, 2);
   setvoxel(0, 7, 3);
   setvoxel(0, 7, 4);
   setvoxel(0, 7, 5);
   setvoxel(0, 7, 6);
   setvoxel(0, 7, 7);
   shift(AXIS_X, 1);
   // done with this state, next time we call effect_Roon do the next step
   currentState++;
   break;
  case 3:
   delay_ms(5000);
   // done with this state, next time we call effect_Roon do the next step
   currentState++;
   break;
  case 4:
   setvoxel(0, 7, 4);
   setvoxel(0, 7, 7);
   shift(AXIS_X, 1);
   currentState++;
   break;
  case 5:
   delay_ms(5000);
   currentState++;
   break;
  ...
  ...
  case 57:
   fill(0x00);
   // done with this state, next time we call effect_Roon do first step
   currentState=0;
   // indicate that the effect is finished
   return true;
 }
 // indicate that effect is in progress
 return true;
}
Note that I have renamed Roon to effect_roon for a more consistent naming with other effects.
Because of all the delay_ms calls, we will end up with the 57 states. We can reduce this by roughly 50% if we dedicate one state to delay. For this, I'm going to reserve a number of numbers (1..10); this allows for a bit of growth if needed; the normal cases will start at 11. To make this work, you need to remember where to go after the delay; you also need to setup a delay duration.
#define ROON_DELAYSTATE 1
/*
 display Roon
 Returns:
  true if completed, else false
*/
bool effect_Roon()
{
 // remember what we are going to do; now start at 11
 static byte currentState = 11;
 // where to go after a delay
 static byte stateAfterDelay = 0;
 // we will also keep a variable for the required delay duration
 static unsigned long delayDuration;
Â
 switch(currentState)
 {
  case ROON_DELAYSTATE:
   delay_ms(delayDuration);
   // next time effect_roon is called, execute the indicated step
   currentState = stateAfterDelay;
   break;
  case 11:
   fill(0x00);
   // done with this state, next time we call effect_Roon do the next step
   currentState++;
   break;
  case 12:
   setvoxel(0, 7, 0);
   setvoxel(0, 7, 1);
   setvoxel(0, 7, 2);
   setvoxel(0, 7, 3);
   setvoxel(0, 7, 4);
   setvoxel(0, 7, 5);
   setvoxel(0, 7, 6);
   setvoxel(0, 7, 7);
   shift(AXIS_X, 1);
   // we're going to do a delay after this step; remember which step we want to do after the delay
   stateAfterDelay = currentState + 1;
   // set delay duration to 5000
   delayDuration = 5000;
   // done with this state, next time we call effect_Roon, do a delay
   currentState = ROON_DELAYSTATE;
   break;
  case 13:
   setvoxel(0, 7, 4);
   setvoxel(0, 7, 7);
   shift(AXIS_X, 1);
   // setup the delay step
   stateAfterDelay = currentState + 1;
   delayDuration = 5000;
   currentState = ROON_DELAYSTATE;
   break;
  case 14:
   setvoxel(0, 7, 3);
   setvoxel(0, 7, 4);
   setvoxel(0, 7, 7);
   shift(AXIS_X, 1);
   // setup the delay step
   stateAfterDelay = currentState + 1;
   delayDuration = 5000;
   currentState = ROON_DELAYSTATE;
   break;
  ...
  ...
  case xx:
   fill(0x00);
   // done with this state, next time we call effect_Roon do first step
   currentState=0;
   break;
 }
}
Now, in state 12 (was state 2), we first prepare for the delay. We remember that we need to go to state 13 after the delay, we specify the delay duration and next instead of incrementing the step, we set the step to be the delay step.
In the delay step, we call delay_ms and once that's finished we set the step to the stateAfterDelay variable.
Now basically the only thing left is to implement a non-blocking delay using millis() replacing delay_ms.
/*
 non-blocking delay; call repetitively
 In:
  delay in milliseconds
 Returns:
  true if duration has lapsed, else false
*/
bool delayMS(unsigned long duration)
{
 // remember when the delay was started
 static unsigned long delayStartTime;
 // remember if delay in progress
 static bool inProgress = false;
Â
 // if delay is not in progress, 'start' it
 if(inProgress == false)
 {
  inProgress = true;
  delayStartTime = currentTime;
 }
Â
 if(currentTime - delayStartTime >= duration)
 {
  inProgress = false;
  // indicate that duration has lapsed
  return true;
 }
 else
 {
  // indicate that delay is not finished yet
  return false;
 }
}
You can use this in the ROON_DELAYSTATE as shown below
  case ROON_DELAYSTATE:
   // if duration lapsed
   if(delayMS(delayDuration) == true)
   {
    // next time effect_roon is called, execute the indicated step
    currentState = stateAfterDelay;
   }
   else
   {
    // if the delay did not lapse yet, we stay in the same state
   }
   break;
I would probably not set effect_roon up this way, but this is easier for you to follow as it better follows your original. Unfortunately a lot of cases inside the switch.
delayMS is tested, the rest as a guide line to get you started.