On extending scrolling 8x8 bitmap to 32x32 or 32x64 (see clip)
I've looked at your code briefly, long enough to get the impression that each array like rus5[] contains 32 groups of 4 bytes each, with each 4-byte group representing a row of a character.  [If not, let me know.]  Also, I read the question a time or two, but don't see specified what direction you want to scroll, and whether you will scroll a string of characters or just one character.  Anyhow, in following I suppose you want to scroll a string horizontally with characters entering at the right end of the display and scrolling off the left end.

To support horizontal scrolling, arrange your bit maps such that each group of 4 bytes represents the 32 bits of a single column of the display.  Regarding four bytes as an unsigned long, suppose the LSB (least significant bit) corresponds to the top LED in a column.  Use code like the following to set pixels, supposing cn = current column number; d = number of character columns already scrolled off, in range 0 to 31; maxCol = number of display columns; and t[] is a three-character string corresponding to three characters currently on the 64x32 display.  [That is, a right-hand part of t[0] is at the left end of display; then all of t[1] appears; then a left-hand part of t[2].]  [Generally, where this sets cc=0, you would set it to point at a current-character in a longer string, instead of at the first character in a three-character array t[]; and would advance one character each time d gets up to 32.]

cc = 0;     // index of first character to display
c = t[cc];  // first character to display
e = d;      // how far we have scrolled so far
for (cn=0; cn&lt;maxCol; ++cn) {
  unsigned long colData = pgm_read_dword(charData[c][e]);
  for (ro=0; ro&lt;32; ++ro) {
    matrix.drawPixel(cn, ro, (colData&amp;1)? cchsv : black);
    colData &gt;&gt;= 1; // discard used-up bit
  }
  ++e;
  if (e &gt;= 32) {  // Done with current character?
    c = t[++cc];  // Set c to next character
    e = 0;        // Start with leftmost col of character
  }
}


Edit 1: In the code above, charData[c][e] is an unsigned long int.  Its 32 bits represent column e of ascii character c, with the LSB representing the top-row pixel.  To create charData[][], write a program on your development system that reads whatever bitmaps you have now and writes out code to properly set up charData[][] in ProgMem.  

Note, for initial scroll-testing, you could skip writing a development-system program to re-orient characters and instead test with character-data arrays as they are.  Characters might display sideways or upside down, but would scroll ok anyway.  Or, if bytes are not in proper Endianness to be an unsigned long, they would display in four mis-ordered slices.

Edit 2 With the following code,

void  scroller (const PROGMEM byte bildo1[][4],const PROGMEM byte bildo2[][4],int maxCol, word cchsv) {

int d = 0;
int cc = 0; 
unsigned long c[32];

for(int ii=0;ii&lt;32;ii++) {
  c[ii]=0;      
  c[ii] += (long) pgm_read_byte(&amp;(bildo1[ii][0]))&lt;&lt; 24;
  c[ii] += (long) pgm_read_byte(&amp;(bildo1[ii][1]))&lt;&lt; 16;
  c[ii] += (long) pgm_read_byte(&amp;(bildo1[ii][2]))&lt;&lt; 8;
  c[ii] += (long) pgm_read_byte(&amp;(bildo1[ii][3]));
}
int e = d;      // how far we have scrolled so far
for (int cn=0; cn&lt;maxCol; ++cn) {
  unsigned long colData = c[e];
  for (int ro=0; ro&lt;32; ++ro) {
    matrix.drawPixel(cn, ro, (colData&amp;1)? cchsv : black);
    colData &gt;&gt;= 1; // discard used-up bit
  }
  ++e;
  if (e &gt;= 32) {  // Done with current character?
    for(int ii=0;ii&lt;32;ii++) {
      c[ii]=0;       
      c[ii] += (long) pgm_read_byte(&amp;(bildo2[ii][0]))&lt;&lt; 24;
      c[ii] += (long) pgm_read_byte(&amp;(bildo2[ii][1]))&lt;&lt; 16;
      c[ii] += (long) pgm_read_byte(&amp;(bildo2[ii][2]))&lt;&lt; 8;
      c[ii] += (long) pgm_read_byte(&amp;(bildo2[ii][3]));
    }
    e = 0;        // Start with leftmost col of character
  }
}}


chrisoutwright reports getting an image like the following [cropped from a larger dropbox.com image]:



Cutting this into 4 equal-size horizontal slices and swapping slices top to bottom, we get:  

That image suggests packing the bytes in reverse order, eg via

c[ii] += (long) pgm_read_byte(&amp;(bildo2[ii][0]));
c[ii] += (long) pgm_read_byte(&amp;(bildo2[ii][1]))&lt;&lt; 8;
c[ii] += (long) pgm_read_byte(&amp;(bildo2[ii][2]))&lt;&lt; 16;
c[ii] += (long) pgm_read_byte(&amp;(bildo2[ii][3]))&lt;&lt; 24;


Continuing on, if we rotate the left half of the above 90° then flip the rotated image left to right we get a reasonable facsimile of the letter 春 :



The "flip left to right" amounts to reading bits out MSB first instead of LSB first.  During testing, one might do that by saying

matrix.drawPixel(cn, ro, (colData&amp;(1&lt;&lt;31))? cchsv : black); colData &lt;&lt;= 1;


instead of 

matrix.drawPixel(cn, ro, (colData&amp;1)? cchsv : black); colData &gt;&gt;= 1;


but in the longer run, a development-system program should be used to re-orient characters instead of using up MCU memory space and time for bitmap organizing.



To make the characters scroll, add a parameter (eg, byte escroll) to the calling sequence.  Discard variable d if it isn't used within scroller, and instead of initializing e to d (which is always zero hence does not allow for scrolling) initialize it via

e = escroll;


In the routine that calls scroller(), say something like

byte es=0;
while (scrolling) {
  scroller(bildo1, bildo2, maxCol, cchsv, es);
  delay(msPerScrollStep);
  ++es;
  if (es &gt;= 32) {
    es = 0;
    // do stuff here about next characters to display
  }
}


That is, call scroller() within a scroll-timing loop (or perhaps put the timing into scroller(), whichever meshes better with overall design).

Note, with the code as it stands, plus suggested changes, bildo2 will scroll in a second time1 unless a third character is supplied to scroll in.  

1For example, with maxCol of 64, if es is 16, whenscroller() is called, e will go from 16 to 31 displaying the second half of bildo1, then from 0 to 31 displaying all of bildo2, then from 0 to 15 displaying the front half of bildo2.