add reaction_diffusion

Author: monkstone

external_library/java/PixelFlow/README.md

@@ -38,4 +38,4 @@ end
 @skylight = DwSkyLight.new(context, scene_display, mat_scene_bounds)
 ```
 
-In __antialiasing.rb__ if just use the overloaded `color` method jruby complains of overloaded method, but guesses right and chooses the correct java signature (float, float, float). Mainly to show how we can do it, we provide an alias method `color_float` that avoids the look up cost in detecting the correct signature, this is not generally important if you can put up with the warning. 
+In __antialiasing.rb__ if we just use the overloaded `color` method, jruby complains of overloaded method but guesses right and chooses the correct java signature (float, float, float). Mainly to show how we can do it, we provide an alias method `color_float` that avoids the look up cost in detecting the correct signature, this is not generally important if you can put up with the warning. 

external_library/java/PixelFlow/data/grayscott.frag

@@ -0,0 +1,37 @@
+// file: grayscott.frag
+// author: diewald
+
+#version 150
+
+out vec2 fragColor;
+
+uniform vec2 wh_rcp;
+uniform sampler2D tex;
+
+uniform float dA   = 1.0;
+uniform float dB   = 0.5;
+uniform float feed = 0.055;
+uniform float kill = 0.062;
+uniform float dt   = 1.0;
+
+void main () {
+
+  vec2 posn = gl_FragCoord.xy * wh_rcp;
+  
+  vec4 val = texture(tex, posn);
+  
+  vec4 laplace = -val;
+  laplace += textureOffset(tex, posn, ivec2(-1, 0)) * + 0.20;
+  laplace += textureOffset(tex, posn, ivec2(+1, 0)) * + 0.20;
+  laplace += textureOffset(tex, posn, ivec2( 0,-1)) * + 0.20;
+  laplace += textureOffset(tex, posn, ivec2( 0,+1)) * + 0.20;
+  laplace += textureOffset(tex, posn, ivec2(-1,-1)) * + 0.05;
+  laplace += textureOffset(tex, posn, ivec2(+1,-1)) * + 0.05;
+  laplace += textureOffset(tex, posn, ivec2(-1,+1)) * + 0.05;
+  laplace += textureOffset(tex, posn, ivec2(+1,+1)) * + 0.05;
+  
+  float nA = val.r + (dA * laplace.r - val.r * val.g * val.g + (feed * (1.0 - val.r))) * dt;
+  float nB = val.g + (dB * laplace.g + val.r * val.g * val.g - ((kill + feed) * val.g)) * dt;
+  
+  fragColor = clamp(vec2(nA, nB), vec2(0), vec2(1));
+}

external_library/java/PixelFlow/data/render.frag

@@ -0,0 +1,14 @@
+// file: render.frag
+// author: diewald
+
+#version 150
+
+out vec4 fragColor;
+
+uniform vec2 wh_rcp;
+uniform sampler2D tex;
+
+void main () {
+  vec2 val = texture(tex, gl_FragCoord.xy * wh_rcp).rg;
+  fragColor = vec4(vec3(1.0 - val.g), 1);
+}

external_library/java/PixelFlow/reaction_diffusion.rb

@@ -0,0 +1,110 @@
+load_library :PixelFlow
+
+# PixelFlow | Copyright (C) 2016 Thomas Diewald - http://thomasdiewald.com
+# translated to JRubyArt by MArtihn Prout
+# A Processing/Java library for high performance GPU-Computing (GLSL).
+# MIT License: https://opensource.org/licenses/MIT
+module Reaction
+  java_import 'com.thomasdiewald.pixelflow.java.DwPixelFlow'
+  java_import 'com.thomasdiewald.pixelflow.java.dwgl.DwGLSLProgram'
+  java_import 'com.thomasdiewald.pixelflow.java.dwgl.DwGLTexture'
+  java_import 'com.thomasdiewald.pixelflow.java.imageprocessing.filter.DwFilter'
+  java_import 'com.jogamp.opengl.GL2'
+end
+
+include Reaction
+# reaction-diffusion, grayscott
+#
+# using custom shaders/textures for fast multipass rendering.
+attr_reader :context, :tex_grayscott, :shader_grayscott, :shader_render
+attr_reader :pass, :tex_render
+
+def settings
+  size(800, 800, P2D)
+  smooth(0)
+end
+
+def setup
+  # multipass rendering texture
+  @tex_grayscott = DwGLTexture::TexturePingPong.new
+  # pixelflow context
+  @context = DwPixelFlow.new(self)
+  @pass = 0
+  # 1) 32 bit per channel
+  tex_grayscott.resize(
+    context,
+    GL2::GL_RG32F, # NB we need :: not . here to access constant
+    width,
+    height,
+    GL2::GL_RG,
+    GL2::GL_FLOAT,
+    GL2::GL_NEAREST,
+    2,
+    4
+  )
+
+  # 2) 16 bit per channel, lack of precision is obvious in the result, its fast though
+  # tex_grayscott.resize(context, GL2::GL_RG16F, width, height, GL2::GL_RG, GL2::GL_FLOAT, GL2::GL_NEAREST, 2, 2)
+
+  # 3) 16 bit per channel, better than 2)
+  # tex_grayscott.resize(context, GL2::GL_RG16_SNORM, width, height, GL2::GL_RG, GL2::GL_FLOAT, GL2::GL_NEAREST, 2, 2)
+
+  # glsl shader
+  @shader_grayscott = context.createShader(data_path('grayscott.frag'))
+  @shader_render = context.createShader(data_path('render.frag'))
+  # init
+  @tex_render = create_graphics(width, height, P2D)
+  tex_render.smooth(0)
+  tex_render.beginDraw
+  tex_render.textureSampling(2)
+  tex_render.blendMode(REPLACE)
+  tex_render.clear
+  tex_render.noStroke
+  tex_render.background(0x00FF0000) # NB: we can use hexadecimal in ruby
+  tex_render.fill(0x0000FF00)
+  tex_render.noStroke
+  tex_render.rectMode(CENTER)
+  tex_render.rect(width / 2, height / 2, 20, 20)
+  tex_render.endDraw
+  # copy initial data to source texture
+  DwFilter.get(context).copy.apply(tex_render, tex_grayscott.src)
+  frame_rate(1_000)
+end
+
+def reaction_diffusion_pass
+  context.beginDraw(tex_grayscott.dst)
+  shader_grayscott.begin
+  shader_grayscott.uniform1f('dA', 1.0)
+  shader_grayscott.uniform1f('dB', 0.5)
+  shader_grayscott.uniform1f('feed', 0.055)
+  shader_grayscott.uniform1f('kill', 0.062)
+  shader_grayscott.uniform1f('dt', 1)
+  shader_grayscott.uniform2f('wh_rcp', 1.0 / width, 1.0 / height)
+  shader_grayscott.uniformTexture('tex', tex_grayscott.src)
+  shader_grayscott.drawFullScreenQuad
+  shader_grayscott.end
+  context.endDraw('reaction_diffusion_pass')
+  tex_grayscott.swap
+  @pass += 1
+end
+
+def draw
+  # multipass rendering, ping-pong
+  context.begin
+  100.times { reaction_diffusion_pass }
+  # create display texture
+  context.beginDraw(tex_render)
+  shader_render.begin
+  shader_render.uniform2f('wh_rcp', 1.0 / width, 1.0 / height)
+  shader_render.uniformTexture('tex', tex_grayscott.src)
+  shader_render.drawFullScreenQuad
+  shader_render.end
+  context.endDraw('render')
+  context.end
+  # put it on the screen
+  blendMode(REPLACE)
+  image(tex_render, 0, 0)
+  save_frame(data_path('grayscott1.jpg')) if frame_count == 1_000
+  format_string = 'Reaction Diffusion  [size %d/%d]  [frame %d]  [fps: (%6.2f)]'
+  surface.set_title(format(format_string, width, height, pass, frame_rate))
+end