moving the OpenGL examples to the core

java/examples/OpenGL/Shaders/FXAA/FXAA.pde

@@ -0,0 +1,92 @@
+// This example uses a FxAA post-processing filter for fast 
+// fullscreen antialiasing:
+// http://www.kotaku.com.au/2011/12/what-is-fxaa/
+//
+// Press any key to enable/disable the shader.
+
+PGraphics canvas;
+boolean drawing = false;
+PShader fxaa;
+boolean usingShader;
+String message;
+float msgLen;
+  
+void setup() {
+  size(1280, 800, P2D);
+  noSmooth();
+  
+  canvas = createGraphics(width, height, P2D);
+  canvas.noSmooth();
+    
+  fxaa = (PShader)loadShader("fxaa.glsl", PShader.TEXTURED);
+  shader(fxaa, PShader.TEXTURED);
+  usingShader = true;
+  
+  canvas.beginDraw();
+  canvas.background(255);  
+  canvas.stroke(0);
+  canvas.strokeWeight(15);
+  canvas.strokeCap(ROUND);
+  canvas.endDraw();
+  
+  PFont font = createFont("Arial", 18);
+  textFont(font);  
+  updateMessage();
+  
+  drawing = false;
+}
+
+public void draw() {
+  if (drawing) {
+    canvas.beginDraw();
+    if (1 < dist(mouseX, mouseY, pmouseX, pmouseY)) {
+      canvas.line(pmouseX, pmouseY, mouseX, mouseY);
+    }
+    canvas.endDraw();
+  }
+  
+  image(canvas, 0, 0);
+  
+  drawMessage();
+}
+  
+public void mousePressed() {
+  if (!drawing && width - msgLen < mouseX && height - 23 < mouseY) {
+    if (usingShader) {
+      resetShader(PShader.TEXTURED);
+      usingShader = false;
+    } else {
+      shader(fxaa, PShader.TEXTURED);
+      usingShader = true;
+    }
+    updateMessage();    
+  } else {
+    drawing = true;   
+  }
+}
+
+void mouseReleased() {
+  drawing = false;
+}
+
+void updateMessage() {
+  if (usingShader) {
+    message = "Anti-aliasing enabled";      
+  } else {
+    message = "Anti-aliasing disabled";
+  }
+  msgLen = textWidth(message);
+}
+
+void drawMessage() {
+  if (usingShader) {
+    // We need the default texture shader to 
+    // render text.
+    resetShader(PShader.TEXTURED);
+  }
+  fill(0);
+  text(message, width - msgLen, height - 5);
+  if (usingShader) {
+    shader(fxaa, PShader.TEXTURED);
+  }
+}

java/examples/OpenGL/Shaders/FXAA/data/fxaa.glsl

@@ -0,0 +1,69 @@
+// FXAA shader, GLSL code adapted from:
+// http://horde3d.org/wiki/index.php5?title=Shading_Technique_-_FXAA
+// Whitepaper describing the technique:
+// http://developer.download.nvidia.com/assets/gamedev/files/sdk/11/FXAA_WhitePaper.pdf
+
+#ifdef GL_ES
+precision mediump float;
+precision mediump int;
+#endif
+
+uniform sampler2D textureSampler;
+
+// The inverse of the texture dimensions along X and Y
+uniform vec2 texcoordOffset;
+
+varying vec4 vertColor;
+varying vec4 vertTexcoord;
+
+void main() {
+  // The parameters are hardcoded for now, but could be
+  // made into uniforms to control fromt he program.
+  float FXAA_SPAN_MAX = 8.0;
+  float FXAA_REDUCE_MUL = 1.0/8.0;
+  float FXAA_REDUCE_MIN = (1.0/128.0);
+
+  vec3 rgbNW = texture2D(textureSampler, vertTexcoord.xy + (vec2(-1.0, -1.0) * texcoordOffset)).xyz;
+  vec3 rgbNE = texture2D(textureSampler, vertTexcoord.xy + (vec2(+1.0, -1.0) * texcoordOffset)).xyz;
+  vec3 rgbSW = texture2D(textureSampler, vertTexcoord.xy + (vec2(-1.0, +1.0) * texcoordOffset)).xyz;
+  vec3 rgbSE = texture2D(textureSampler, vertTexcoord.xy + (vec2(+1.0, +1.0) * texcoordOffset)).xyz;
+  vec3 rgbM  = texture2D(textureSampler, vertTexcoord.xy).xyz;
+	
+  vec3 luma = vec3(0.299, 0.587, 0.114);
+  float lumaNW = dot(rgbNW, luma);
+  float lumaNE = dot(rgbNE, luma);
+  float lumaSW = dot(rgbSW, luma);
+  float lumaSE = dot(rgbSE, luma);
+  float lumaM  = dot( rgbM, luma);
+	
+  float lumaMin = min(lumaM, min(min(lumaNW, lumaNE), min(lumaSW, lumaSE)));
+  float lumaMax = max(lumaM, max(max(lumaNW, lumaNE), max(lumaSW, lumaSE)));
+	
+  vec2 dir;
+  dir.x = -((lumaNW + lumaNE) - (lumaSW + lumaSE));
+  dir.y =  ((lumaNW + lumaSW) - (lumaNE + lumaSE));
+	
+  float dirReduce = max((lumaNW + lumaNE + lumaSW + lumaSE) * (0.25 * FXAA_REDUCE_MUL), FXAA_REDUCE_MIN);
+	  
+  float rcpDirMin = 1.0/(min(abs(dir.x), abs(dir.y)) + dirReduce);
+	
+  dir = min(vec2(FXAA_SPAN_MAX,  FXAA_SPAN_MAX), 
+        max(vec2(-FXAA_SPAN_MAX, -FXAA_SPAN_MAX), dir * rcpDirMin)) * texcoordOffset;
+		
+  vec3 rgbA = (1.0/2.0) * (
+              texture2D(textureSampler, vertTexcoord.xy + dir * (1.0/3.0 - 0.5)).xyz +
+              texture2D(textureSampler, vertTexcoord.xy + dir * (2.0/3.0 - 0.5)).xyz);
+  vec3 rgbB = rgbA * (1.0/2.0) + (1.0/4.0) * (
+              texture2D(textureSampler, vertTexcoord.xy + dir * (0.0/3.0 - 0.5)).xyz +
+              texture2D(textureSampler, vertTexcoord.xy + dir * (3.0/3.0 - 0.5)).xyz);
+  float lumaB = dot(rgbB, luma);
+
+  if((lumaB < lumaMin) || (lumaB > lumaMax)){
+    gl_FragColor.xyz=rgbA;
+  } else {
+    gl_FragColor.xyz=rgbB;
+  }
+  gl_FragColor.a = 1.0;
+    
+  gl_FragColor *= vertColor;
+}