I like this. Once it loads its fast.   I tried something similar using a sphere and equirectangular images. However the framerate left a lot to be desired.

Here is the link to it http://openprocessing.org/visuals/?visualID=5257

Thanx Andrew for your link to the Equirectangular Viewer...
Would be nice if he will be as fast as this viewer... http://www.ignorancia.org/en/index.php?page=Patio_Panorama 
Btw. loading big JPG files is really slow. Loading PNG's is a little bit faster... 

Another Question to All:
Can I add an image or an example zip file with 6 skybox textures to this posting?
Adding an image result in the error message "This topic is reported as Inappropriate (1)".
If it is possible, can you please give me some help how to do this.

I'm also interested if you make this faster.  I plan to look at it and if I make any significant changes that could improve performance, I'll post them as well.

I tried to speed up the skybox by using some OpenGL, cached textures and a display list.

1. import peasy.PeasyCam;  //peasy camera control
2. import processing.opengl.PGraphicsOpenGL;
3. import javax.media.opengl.GL;
4. import com.sun.opengl.util.texture.Texture;
5. import com.sun.opengl.util.texture.TextureIO;
6. // set skybox filename without orientation part here...
7. String skyboxName = "besiege"; 
8. PeasyCam cam;
9. PGraphicsOpenGL pgl;
10. GL gl;
11. int skybox;
12. void setup()
13. {
14.   size(screen.width, screen.height, OPENGL);
15.   //  size(screenWidth, screenHeight, OPENGL);  // fullscreen
16.   // frameRate(3000);
17.   pgl = (PGraphicsOpenGL) g;
18.   gl = pgl.gl;
19.   hint(DISABLE_DEPTH_TEST);
20.   gl.glDepthMask(false);
21.   gl.glDisable(GL.GL_DEPTH_TEST);
22.   loadSkybox(skyboxName, ".png");
23.   pgl.beginGL();
24.   skybox = gl.glGenLists(1);
25.   gl.glNewList(skybox, GL.GL_COMPILE);
26.   noStroke();  // comment it to see cube edges
27.   gl.glFrontFace(GL.GL_CCW);
28.   gl.glEnable(GL.GL_CULL_FACE);
29.   TexturedCube();
30.   gl.glDisable(GL.GL_CULL_FACE);
31.   gl.glEndList();
32.   pgl.endGL();
33.   float fov = PI/3.0;
34.   float cameraZ = (height/2.0) / tan(fov/2.0);
35.   perspective(fov, float(width)/float(height), cameraZ/10.0, cameraZ*100.0);
36.   cam = new PeasyCam(this, width);
37.   cam.setResetOnDoubleClick(false);
38.   cam.setMinimumDistance(10);
39.   cam.setMaximumDistance(width*10);
40.   // gl.glEnable(GL.GL_CULL_FACE);
41. }
42. void draw()
43. {
44.   // background(255);
45.   pgl.beginGL();
46.   gl.glCallList( skybox );
47.   pgl.endGL();
48.   //translate(width/2.0, height/2.0, -100);
49.   println("FPS: "+ frameRate);
50. }
51. float p = 40000;   // half skybox size
52. float m = -p;
53. // create cube edges
54. PVector P000 = new PVector (m,m,m);
55. PVector P010 = new PVector (m,p,m);
56. PVector P110 = new PVector (p,p,m);
57. PVector P100 = new PVector (p,m,m);
58. PVector P001 = new PVector (m,m,p);
59. PVector P011 = new PVector (m,p,p);
60. PVector P111 = new PVector (p,p,p);
61. PVector P101 = new PVector (p,m,p);
62. Texture tex1,tex2,tex3,tex4,tex5,tex6;   // texture images
63. // load six skybox images as cube texture
64. void loadSkybox(String skyboxName, String fExt)
65. {
66.   try {
67.     tex1 = TextureIO.newTexture(new File(dataPath(skyboxName + "_front" + fExt)), true);
68.     tex2 = TextureIO.newTexture(new File(dataPath(skyboxName + "_back" + fExt)), true);
69.     tex3 = TextureIO.newTexture(new File(dataPath(skyboxName + "_left" + fExt)), true);
70.     tex4 = TextureIO.newTexture(new File(dataPath(skyboxName + "_right" + fExt)), true);
71.     tex5 = TextureIO.newTexture(new File(dataPath(skyboxName + "_bottom" + fExt)), true);
72.     tex6 = TextureIO.newTexture(new File(dataPath(skyboxName + "_top" + fExt)), true);
73.   }
74.   catch (IOException e) {   
75.     println( e);
76.   }
77.   textureMode(NORMALIZED);
78. }
79. // Assign six texture to the six cube faces
80. void TexturedCube()
81. {
82.   TexturedCubeSide (P100, P000, P010, P110, tex1);   // -Z "front" face
83.   TexturedCubeSide (P001, P101, P111, P011, tex2);   // +Z "back" face
84.   TexturedCubeSide (P000, P001, P011, P010, tex3);   // -X "left" face
85.   TexturedCubeSide (P101, P100, P110, P111, tex4);   // +X "right" face
86.   TexturedCubeSide (P110, P010, P011, P111, tex5);   // +Y "base" face
87.   TexturedCubeSide (P101, P001, P000, P100, tex6);   // -Y "top" face
88. }
89. // create a cube side given by 4 edge vertices and a texture
90. void TexturedCubeSide(PVector P1, PVector P2, PVector P3, PVector P4, Texture tex)
91. {
92.   tex.enable();
93.   tex.bind();
94.   gl.glBegin(GL.GL_QUADS);
95.   gl.glTexCoord2f(1.0f, 0.0f);
96.   gl.glVertex3f(P1.x, P1.y, P1.z);
97.   gl.glTexCoord2f(0.0f, 0.0f);
98.   gl.glVertex3f(P2.x, P2.y, P2.z);
99.   gl.glTexCoord2f(0.0f, 1.0f);
100.   gl.glVertex3f(P3.x, P3.y, P3.z);
101.   gl.glTexCoord2f(1.0f, 1.0f);
102.   gl.glVertex3f(P4.x, P4.y, P4.z);
103.   gl.glEnd();
104.   tex.disable();
105. }

I tried to speed up the skybox by using some OpenGL, cached textures and a display list.  I tried to post it but it keeps getting marked as spam.  If you're interested, send me a PM and I'll send it to you.. if it lets me.  Hopefully someone will moderate the post and allow it through.

You could also use GLGraphics I suppose -- the Cg code below could be repurposed as a GLFilter object, since it reads an OpenGL cube-texture and then just determines the pixel lookups from the matrix, rather than actually rotating polys and rendering 6 objects. Just one quad....

1. struct CubeVertexOutput {
2.     float4 Position    : POSITION;
3.     float3 UVW        : TEXCOORD0;
4. };
5. // vertex shader
   
6. CubeVertexOutput CubeVS(
7.     float3 Position : POSITION, // in view coordinates -- that is, the screen maps -1 to 1 in both axes
   
8.     uniform float4x4 WorldViewInverseXf // the matrix to convert "view" coords to "world" coords
   
9. ) {
10.     CubeVertexOutput OUT = (CubeVertexOut)0;
11.     OUT.Position = float4(Position.xyz, 1);
12.     OUT.UVW = mul(WorldViewIXf,float4(-Position.xy,1,0)).xyz;
    
13.     OUT.UVW.xy *= -1.0;
14.     return OUT;
15. }
16. // now the fragment shader
17. float4 CubePS(CubeVertexOutput IN) : COLOR {  
    
18.     float4 texCol = texCUBE(BgSampler, IN.UVW);
19.     return texCol;
20. } 
    

The awkward bit for processing would be making the transform matrix, though I think you could query OpenGL for it.

kb, http://www.riftgame.com/