are you crazy? 8)

the pngs might be small on disk but that's because they are compressed. they are expanded to an uncompressed 3 (maybe 4) bytes per pixel before being used as textures so that might cause your issues.

can i suggest using only 3 images per cube - you can only see 3 sides of any given cube at any one time so you could use the same image on opposite sides without fear of having the same image showing twice in any view.

With 400 cubes and 6 faces thats a total of 2400 images to load from disk

One possible soltuion would be to load each image as a single entity, then (from setup) split it into 400 subimages. Mathematically you are still loading the same amount of data but it is much faster to load a single file of 400kb than 400 files of 1kb each.

quarks, my savior!  That sounds a lot easier, actually, since I have been spending too much time already chopping up my images in Photoshop and renaming them with Automator.

Actually found this thread:

Also, I'm still curious about how all this stuff works--I figured loading a lot of images would take more time in setup() but once they are loaded they won't affect each draw() cycle.  But clearly this is wrong.

Actually you are not wrong, once the images are loaded, they will be converted into OpenGL textures then the performance of the draw method depends entirely on the Box render code, the underlying implementation of JOGL (The Java <> OpenGL inteface) and your graphics hardware.

As for chopping up images this worked well for me, simply change the image filename in line 7

1. PImage img0;
2. PImage[][] imgs;
3. int w, h, ns = 20;
4. 
   
5. public void setup() {
6.   size(500, 500);
7.   img0 = loadImage("pkl.jpg");
8.   imgs = chopImage(img0, ns);
9.   background(0, 0, 96);
10.   // display with 2 pixel gap between tiles
11.   for (int col = 0; col < ns; col++) {
12.     for (int row = 0; row < ns; row++) {
13.       image(imgs[col][row], col*(w + 2), row*(h + 2));
14.     }
15.   }
16. }
17. 
    
18. public PImage[][] chopImage(PImage src, int n) {
19.   PImage[][] img = new PImage[n][n];
20.   w = src.width/n;
21.   h = src.height/n;
22.   for (int col = 0; col < n; col++) {
23.     for (int row = 0; row < n; row++) {
24.       img[col][row] = src.get(col*w, row*h, w, h);
25.     }
26.   }
27.   return img;
28. }

be careful of that though - if memory is your limiting factor then doubling the amount you use (one big image on top of all the small ones) isn't going to help.

but it will probably help with the loading time.

Loading time isn't really an issue, the sketch is for an installation so I'm most concerned that it run smoothly after startup.  I am prototyping on my laptop, but will be moving to a more powerful machine soon, so I'll see how that effects the performance.  What hardware component is the bottleneck here?  The graphics card?