Merge pull request #4 from diroru/master

Pull request for the project’s raytracing-based revisit.

Author: codeanticode

README.md

@@ -2,9 +2,30 @@ The planetarium library is intended to project 3D Processing sketches on spheric
 
 It is based on the FullDomeTemplate code from Christopher Warnow, available at https://github.com/mphasize/FullDome
 
-### Overview
+### Work in progress
 
-A brief descrition of how it works: a 360° view of the scene is generated by rendering the scene 6 times from each direction: positive x, negative x, and so on. The output of each rendering is stored inside a cube map texture, which is then applied on a sphere representing the dome. Hence, the library calls the draw() method 6 times per frame in order to update the corresponding side of the cube map texture (in reality, only 5 times since the bottom side of the cube map is not invisible on the dome). 
+**DONE:**
+
+- More accurate rendering.
+- Variable aperture.
+- Debug grid (shader-based).
+- Toggle rendering of cubemap sides.
+- 2D overlay image rendering in post. (has unfortunately a noticeable performance penalty).
+
+**TODO:**
+- Improve cubemap resolution (or at least visual quality).
+- Implement rendering into background (2D) layer. (Possible implementation would be to send PGraphics as sampler into the shader, but it collides with the samplerCube, haven’t found a solution yet).
+- Custom sweet spot.
+- 4 sides should suffice for fulldome, need to rotate cubemap by 45° for that.
+- Implement picking?
+
+**CHANGES:** (technical)
+- Switching to a raycasting approach in the cube map rendering stage. Uses quad with ray-casting instead of hemisphere.
+- Cubemap sampling set to linear.
+
+### Overview (original)
+
+A brief descrition of how it works: a 360° view of the scene is generated by rendering the scene 6 times from each direction: positive x, negative x, and so on. The output of each rendering is stored inside a cube map texture, which is then applied on a sphere representing the dome. Hence, the library calls the draw() method 6 times per frame in order to update the corresponding side of the cube map texture (in reality, only 5 times since the bottom side of the cube map is not invisible on the dome).
 
 So, it is important to keep in mind that if you need to perform some calculation only one time per frame, then the code for that calculation should be put inside the pre() method. Similarly, calculations that should performed only once after the rendering is concluded should be put in the post() method.
 

data/cubeMapQuadFrag.glsl

@@ -0,0 +1,78 @@
+//grid code originally appears: https://github.com/diroru/domemod
+#define PI 3.1415926535897932384626433832795
+#define AA 0.1
+
+uniform samplerCube cubemap;
+uniform float aperture;
+uniform float renderGrid;
+
+varying vec2 vertTexCoord;
+
+vec2 domeXYToLatLon(vec2 xy, float aperture) {
+  float x = xy.x - 0.5;
+  float y = xy.y - 0.5;
+  float lat = sqrt(x*x + y*y) * aperture;
+  float lon = atan(y,x);
+  return vec2(lat, lon);
+}
+
+vec3 latLonToXYZ(vec2 latLon) {
+  float lat = latLon.x;
+  float lon = latLon.y;
+  float x = cos(lon) * sin(lat);
+  float y = sin(lon) * sin(lat);
+  float z = cos(lat);
+  return vec3(x,y,z);
+}
+
+vec3 domeXYToXYZ(vec2 xy, float aperture) {
+  return latLonToXYZ(domeXYToLatLon(xy, aperture));
+}
+
+float rad2Deg(float r) {
+  return r * 180.0 / PI;
+}
+
+vec3 getLatitudeGrid(vec2 longLat, float gratOffset, float gratWidth, vec3 gratColour) {
+	float gr = mod(rad2Deg(longLat.y) + gratWidth * 0.5, gratOffset) - gratWidth * 0.5;
+	//return mix(gratColour, vec3(0.0), smoothstep(gratWidth*0.5 - AA, gratWidth*0.5 + AA, abs(gr)));
+	return mix(gratColour, vec3(0.0), step(gratWidth, abs(gr)));
+}
+
+vec3 getLongtitudeGrid(vec2 longLat, float gratOffset, float gratWidth, vec3 gratColour) {
+	float longDeg = rad2Deg(longLat.x);
+	float latDeg = rad2Deg(longLat.y);
+	float go = gratWidth / sin(longLat.y);
+	float gr = mod(longDeg + go , gratOffset) - go;
+	//return mix(gratColour, vec3(0.0), smoothstep(go*0.5 - AA, go*0.5 + AA, abs(gr)));
+	return mix(gratColour, vec3(0.0), step(go, abs(gr)));
+}
+
+vec3 getGrid(vec2 longLat, vec3 colour, float gratOffset0, float gratWidth0, float gratOffset1, float gratWidth1) {
+	vec3 longGrid_0 = getLongtitudeGrid(longLat, gratOffset0, gratWidth0, colour);
+  	vec3 longGrid_1 = getLongtitudeGrid(longLat, gratOffset1, gratWidth1, colour);
+	vec3 latGrid_0 = getLatitudeGrid(longLat, gratOffset0, gratWidth0, colour);
+  	vec3 latGrid_1 = getLatitudeGrid(longLat, gratOffset1, gratWidth1, colour);
+	vec3 grid_rgb = longGrid_0 + longGrid_1 + latGrid_0 + latGrid_1;
+	//grid_rgb = longGrid_0;
+	//TODO eg. vec3(0.0) as const
+	return clamp(grid_rgb, vec3(0.0), vec3(1.0));
+	//return grid_rgb;
+}
+
+
+
+void main() {
+  //vec3 color = vec3(textureCube(cubemap, vec3(vertTexCoord,1.0)));
+  vec2 latLon = domeXYToLatLon(vertTexCoord, aperture*PI);
+  vec3 ray = latLonToXYZ(latLon);
+  //vec3 color = ray * 0.5 + vec3(0.5);
+  vec3 color = vec3(textureCube(cubemap, ray));
+
+  vec3 gridColor = getGrid(latLon.yx, vec3(1.0, 1.0, 0.0), 45.0, 0.6, 15.0, 0.2);
+//  float gridX = 1.0 - smoothstep(gridWeight*0.5-AA, gridWeight*0.5+AA, mod(latLon.x - gridWeight*0.5, gridSize.x));
+//  float gridY = 1.0 - smoothstep(gridWeight*0.5-AA, gridWeight*0.5+AA, mod(latLon.y - gridWeight*0.5, gridSize.y));
+
+  gl_FragColor = vec4(mix(color, gridColor, min(length(gridColor)*0.5, renderGrid)), 1.0);
+  //gl_FragColor = vec4(rgb + gridColor, 1.0);
+}

data/cubeMapQuadVert.glsl

@@ -0,0 +1,16 @@
+precision highp float;
+precision highp int;
+
+uniform mat4 transform;
+uniform mat4 modelview;
+uniform mat3 normalMatrix;
+attribute vec4 vertex;
+attribute vec3 normal;
+attribute vec2 texCoord;
+
+varying vec2 vertTexCoord;
+
+void main() {
+  gl_Position = transform * vertex;
+  vertTexCoord = texCoord;
+}

examples/Basic/Basic.pde

@@ -6,10 +6,13 @@
 // A brief descrition on how it works: a 360° view of the scene is generated
 // by rendering the scene 6 times from each direction: positive x, negative x, 
 // positive y, and so on. The output of each rendering is stored inside a cube map 
-// texture, which is then applied on a sphere representing the dome.
+// texture, which is then rendered on to a quad using a raytraced fisheye lens.
+//
 // Hence, the library calls the draw() method 6 times per frame in order to update  
 // the corresponding side of the cube map texture (in reality, only 5 times since  
 // the bottom side of the cube map is not invisible on the dome). 
+// Now you can manually set which face should render using domeCamera's toggleFaceDraw() method.
+//
 // So, it is important to keep in mind that if you need to perform some calculation
 // only one time per frame, then the code for those calculations should be put inside
 // the pre() method.
@@ -18,28 +21,40 @@ import codeanticode.planetarium.*;
 
 float cubeX, cubeY, cubeZ;
 
+DomeCamera dc;
+int gridMode = Dome.NORMAL;
+
 void setup() {
   // For the time being, only use square windows  
-  size(600, 600, Dome.RENDERER);
+  size(1024, 1024, Dome.RENDERER);
+  //initial default camera, i.e. interface to interact with the renderer.
+  dc = new DomeCamera(this);
+  //Set the aperture, or radial coverage of the dome. 
+  //1 is default, 2 would show the contents of an entire sphere.
+  dc.setDomeAperture(2f);
+  //we enable the sixth side, sothat we see what is happenning
+  dc.setFaceDraw(DomeCamera.NEGATIVE_Z, true);
+  //This method unfortunately doesn't work yet. 
+  //dc.setCubemapSize(2048);
 }
 
 // Called one time per frame.
 void pre() {
   // The dome projection is centered at (0, 0), so the mouse coordinates
   // need to be offset by (width/2, height/2)
-  cubeX += ((mouseX - width * 0.5) - cubeX) * 0.2;
-  cubeY += ((mouseY - height * 0.5) - cubeY) * 0.2;
+  cubeX += ((mouseX - width * 0.5)*2 - cubeX) * 0.2;
+  cubeY += ((mouseY - height * 0.5)*2 - cubeY) * 0.2;
 }
 
 // Called five times per frame.
 void draw() {
-  background(0);
-  
-  pushMatrix();  
-  translate(width/2, height/2, 300);
-  
+  background(0, 0, 0, 0);
+
+  pushMatrix();
+
+  translate(width/2, height/2, -300);
   lights();
-  
+
   stroke(0);  
   fill(150);
   pushMatrix();
@@ -49,16 +64,60 @@ void draw() {
 
   stroke(255);
   int linesAmount = 10;
-  for (int i = 0; i < linesAmount;i++) {
+  for (int i = 0; i < linesAmount; i++) {
     float ratio = (float)i/(linesAmount-1);
     line(0, 0, cos(ratio*TWO_PI) * 50, sin(ratio*TWO_PI) * 50);
   }
   popMatrix();
 }
 
+void mouseDragged() {
+  //exaggerating dome aperture. 1f <=> 180°
+  dc.setDomeAperture(map(mouseY, 0, height, 0.1f, 2f));
+}
+
 void keyPressed() {
   if (key == CODED) {
     if (keyCode == UP) cubeZ -= 5;
     else if (keyCode == DOWN) cubeZ += 5;
-  }  
+  }
+  switch(key) {
+  case ' ':
+    gridMode = gridMode == Dome.GRID ? Dome.NORMAL : Dome.GRID;
+    //enables rendering of a reference grid (happens inside the shader)
+    dc.setMode(gridMode);
+    break;
+  case 'e':
+    //fulldome-conform rendering
+    dc.enable();
+    break;
+  case 'd':
+    //rendering only into a single, conventional camera
+    dc.disable();
+    break;
+  case '0':
+    //toggles rendering into the X+ side of the cubemap
+    dc.toggleFaceDraw(0);
+    break;
+  case '1':
+    //toggles rendering into the X- side of the cubemap
+    dc.toggleFaceDraw(1);
+    break;
+  case '2':
+    //toggles rendering into the Y+ side of the cubemap
+    dc.toggleFaceDraw(2);
+    break;
+  case '3':
+    //toggles rendering into the Y- side of the cubemap
+    dc.toggleFaceDraw(3);
+    break;
+  case '4':
+    //toggles rendering into the Z+ side of the cubemap
+    dc.toggleFaceDraw(4);
+    break;
+  case '5':
+    //toggles rendering into the Z- side of the cubemap
+    dc.toggleFaceDraw(5);
+    break;
+  }
 }

examples/Overlay/Overlay.pde

@@ -0,0 +1,75 @@
+// The planetarium library is designed to create real-time projections on 
+// spherical domes. It is based on the FullDome project by Christopher 
+// Warnow (ch.warnow@gmx.de):
+// https://github.com/mphasize/FullDome
+//
+// A brief descrition on how it works: a 360° view of the scene is generated
+// by rendering the scene 6 times from each direction: positive x, negative x, 
+// positive y, and so on. The output of each rendering is stored inside a cube map 
+// texture, which is then rendered on to a quad using a raytraced fisheye lens.
+//
+// Hence, the library calls the draw() method 6 times per frame in order to update  
+// the corresponding side of the cube map texture (in reality, only 5 times since  
+// the bottom side of the cube map is not invisible on the dome). 
+// Now you can manually set which face should render using domeCamera's toggleFaceDraw() method.
+//
+// So, it is important to keep in mind that if you need to perform some calculation
+// only one time per frame, then the code for those calculations should be put inside
+// the pre() method.
+
+import codeanticode.planetarium.*;
+
+float cubeX, cubeY, cubeZ;
+PImage grid;
+
+DomeCamera dc;
+int gridMode = Dome.NORMAL;
+
+void setup() {
+  // For the time being, only use square windows  
+  size(1024, 1024, Dome.RENDERER);
+
+  dc = new DomeCamera(this);
+  grid = loadImage("DomeGrid_2k.png");
+}
+
+// Called one time per frame.
+void pre() {
+  // The dome projection is centered at (0, 0), so the mouse coordinates
+  // need to be offset by (width/2, height/2)
+  cubeX += ((mouseX - width * 0.5) - cubeX) * 0.2;
+  cubeY += ((mouseY - height * 0.5) - cubeY) * 0.2;
+  dc.imageToForeground(grid,0,0,width,height);
+}
+
+// Called five times per frame.
+void draw() {
+  background(0, 0, 0, 0);
+
+  pushMatrix();
+
+  translate(width/2, height/2, -300);
+  lights();
+
+  stroke(0);  
+  fill(150);
+  pushMatrix();
+  translate(cubeX, cubeY, cubeZ);  
+  box(50);
+  popMatrix();
+
+  stroke(255);
+  int linesAmount = 10;
+  for (int i = 0; i < linesAmount; i++) {
+    float ratio = (float)i/(linesAmount-1);
+    line(0, 0, cos(ratio*TWO_PI) * 50, sin(ratio*TWO_PI) * 50);
+  }
+  popMatrix();
+}
+
+void keyPressed() {
+  if (key == CODED) {
+    if (keyCode == UP) cubeZ -= 5;
+    else if (keyCode == DOWN) cubeZ += 5;
+  }
+}