I discovered the "Frappuccino" library which seems to offer a way to do this, but I can't figure out how the library works.  The Frappuccino example for using a LCD looks like this:

2. import muvium.processing.*;
3. 
   
4. import muvium.processing.arduino.LiquidCrystal;
5. import muvium.sim.virtualbreadboard.ICEShield;
6. 
   
7. 
   
8. public class HelloWorldApp extends V18OBoard{
9. 
   
10.     LiquidCrystal lcd;
11.     /**
12.         Static Pins are configured in the configureDevice pre-process
13.     */
14.     public void configurePins(){
15.         LiquidCrystal.configurePins( new int[]{ 9, 8, 5, 4, 3, 2 } );
16.         ICEShield.configurePins(0); //Use pin 0 as wait pin - using ICEShield for testing with virtual hardware 
17.                                     //! comment out when using with real hardware
18.     }
19.      
20.     public void setup()  { 
21.      
22.       lcd = new LiquidCrystal();
23.      
24.       // set up the LCD's number of columns and rows: 
25.       lcd.begin(16, 2);
26.       // Print a message to the LCD.
27.       lcd.print("hello, world!");
28.       
29.     } 
30.     
31.     public void loop()  { 
32.       // set the cursor to column 0, line 1
33.       // (note: line 1 is the second row, since counting begins with 0):
34.       lcd.setCursor(0, 1);
35.       // print the number of seconds since reset:
36.       lcd.print(millis()/1000);
37.     }
38.      
39. 
    
40. }
41. ////////////////////////////////////////////////////////////////
42. // MUVIUM PROCESSING TOOLKIT 
43. ////////////////////////////////////////////////////////////////
44.  void draw(){
45.     MuviumToolkit.program( this );
46. }

But this example does not actually connect to an Arduino, it does not even have the Serial library added!  So I am wondering if anyone familiar with the Frappuccino library can offer me a quick explanation of how it works.  Am I even using it correctly?  What is the Muvium Toolkit?

Thanks in advance.

I have been working on a making a grid of cubes floating in 3d space, all textured with different photos so that the composite ends up looking like a face.

I started with a grid of 10x10 (100 cubes in total).  I textured each side of each cube with a different image that corresponded to its place in the grid.  That's 600 images total.  There were never any performance problems there.

I want to increase the resolution to 20x20 (400 cubes total), but the more images it has to load the more the program slows down.  I would think that since the images load at setup(), and the texture of the cubes don't change in the program, the amount of images shouldn't be slowing down the sketch.

If I texture each side of the cubes with the same image, then the Sketch only has to load 400 images, and it runs without a hiccup.  Which tells me that the number of *instances* of the Box() object is not the problem here.  It's the images being loaded.  I used "png-8" file types, so they are very small.  A thousand images takes up only a couple MBs of space.

I'm afraid someone is going to respond to this with "are you crazy?"  Well, I'm new to Processing and completely self-instructed, so, yes, maybe.  I have attached a link to the sketch folder in my dropbox  HERE.  Thanks for the insight, guys.

I am new to Processing, and to writing code in general, so forgive me in advance if I don't express myself clearly.

My goal is to make a 10x10 grid of Cubes floating in 3d space.  Eventually each cube will be textured with a corresponding piece of an image, so that a composite image is formed.

I have decided to use the Quark Shape3D library, which has a Box() class that allows for all 6 "faces" of the cube to use a different image as texture.

The problem I am having is that I do not really understand how the Box() class receives position and rotation parameters.  I have been using 

1. cube[i][j].shapeOrientation(null, new PVector(i*30, j*30, 20));

which positions the cubes into roughly the shape I want, but I don't really understand the what "PVector" is or how it decides the position.  0,0 seems to place the cubes at the center of the image, rather than at the top left as I would expect.

Then in  void draw()  I have included code to rotate each Cube, but instead of each cube rotating on its own axis, all the cubes end up rotating around a universal axis.

So I wonder if someone can help by explaining how the Shapes3d library actually works.  I have been digging through the library "Reference" pages, but I don't understand it much since everything is composed of abbreviations and acronyms. Below is the full code, I have commented out the lines involving Texturing so that you won't have to download dependent files.

2. import shapes3d.utils.*;
3. import shapes3d.animation.*;
4. import shapes3d.*;
5. 
   
6. Box[][] cube;
7. 
   
8. int cols = 10;
9. int rows = 10;
10. 
    
11. float angleX, angleY, angleZ;
12. 
    
13. void setup() {
14.   size(400,400, P3D);
15.   background(160, 0, 90);
16.   lights();
17.   cube = new Box[cols][rows];
18.   
19.   
20.   for (int i = 0; i < cols; i++) {
21.     for (int j = 0; j < rows; j++) {
22.       cube[i][j] = new Box(this);
23.        //String[] faces = new String[] {
24.        //     "face_00.png", "face_01.png", "face_02.png", 
25.        //     "face_03.png", "face_04.png", "face_05.png"
26.        //};
27.        //cube[i][j].setTextures(faces);
28.        cube[i][j].fill(color(255));
29.        cube[i][j].setSize(20,20,20);
30.        cube[i][j].drawMode(S3D.TEXTURE | S3D.SOLID);
31.        cube[i][j].shapeOrientation(null, new PVector(i*30, j*30, 20));
32.     }
33.   }
34.   frameRate(30);
35. }
36. 
    
37. void draw() {
38.   background(175, 0, 90);
39.   //directionalLight(0, 255, 0, 0, -1, 0);
40.   //directionalLight(160, 0, 90, 0, 0, -1);
41.   lights();
42.     pushMatrix();
43.   camera(0, 0, 400, 100, 100, 0, 0, 1, 0);
44.   angleX += radians(.013f);
45.   
46.   for (int i = 0; i < cols; i++) {
47.     for (int j = 0; j < rows; j++) {
48.       rotateX(angleX);
49.       cube[i][j].moveTo(i/10, j/10, i/10);
50.       cube[i][j].draw();
51.     }
52.   }
53.   popMatrix();
54. }