PixAnvil Reaction Diffusion demo: Turk-Turing Equations

See the equations. This GPU version uses mipmaps to compute diffusion, and converges rapidly by limiting the magnitude of the values.

Er, JavaScript or WebGL doesn't seem to be running, so basically all you're going to see is the bare code...

/* This GLSL shader calculates the new reaction-diffusion texture.
*/
vec4 run(float index) {
   float tex_size=512.0; // pixels across
   float del=1.0/tex_size; // texture coordinates per pixel
   float bias=-10.0; // mipmap bias (disable mipmaps)
   
   // P stores our texture coordinates
   vec2 P=texcoords;
   vec4 C=texture2D(tex,P,bias);

// We vary the beta parameter across the screen:
   // beta==0.5 on the left side, giving solid green
   // beta==1.0 on the right side, giving spotted red
   float beta=0.5+0.5*texcoords.x;

float a=C.r, b=C.g; // red is A, green is B
   float ab=8.0*a*b;
   C.r+=dt*(1.0-ab);
   C.g+=dt*(ab-b-beta);

// For stability, we need to limit C to be positive
   // For fast convergence, we limit C to be small
   C=clamp(C,0.001,1.0);

// Blur to simulate diffusion.
   //  This sets the spatial scale of the features.
   float blurA=20.0, blurB=5.0;
   vec3 neighbors=texture2D(tex,P.xy,0.8).rgb; // mipmaps
   C.r+=dt*blurA*(neighbors.r-C.r); // blur r more
   C.g+=dt*blurB*(neighbors.g-C.g); // blur g less
   
   return C;
}

// JavaScript setup: runs once at startup

// Create 2D texture to store the particles
var tex_size=512;
sim.nP=tex_size*tex_size; // number of pixels

// Enable mipmaps and texture filtering
var options={
 minFilter: THREE.LinearMipmapLinearFilter,
 magFilter: THREE.LinearFilter,
 //minFilter: THREE.NearestFilter,
 //magFilter: THREE.NearestFilter,
 //wrapS:THREE.RepeatWrapping, // horizontal
 wrapT:THREE.RepeatWrapping, // vertical
 format:THREE.RGBAFormat,
 type:THREE.FloatType 
};

sim.tex=new gVector1D(sim.nP,options); // current values
sim.texnext=new gVector1D(sim.nP,options); // values in next frame

// For debugging, show texture onscreen
sim.tex.debugTo(scene,10.0,0.0,10.0,6.0);

// Compile shader
sim.fnTex=new gFunction1D(PixAnvil.loadTab('Frag'));

// Initialize pixel values
new gFunction1D(
"vec4 run(float index) {\n"+
"   float tex_size=512.0; // pixels across\n"+
"   float del=1.0/tex_size; // texture coordinates per pixel\n"+
"   // P stores our texture coordinates\n"+
"   vec2 P=fract(del*vec2(0.5+index, (0.5+index)/tex_size));\n"+
"   // Boundary condition sphere:\n"+
"   vec2 sphere=vec2(0.63,0.65);\n"+
"   float r=length(sphere-P);\n"+
"   if (fract(5.0*r)<0.5) return vec4(0.9,0.1,0.0,1);\n"+

"   return vec4(0.1+0.9*sin(30.0*P.x),0.1+0.9*sin(20.0*P.y),0.0,1.0);\n"+
"}\n"
).run(sim.tex);

// Ground
sim.ground = new THREE.Mesh(
  new THREE.BoxGeometry(500,500,0.0001),
  new THREE.ShaderMaterial(
{
   uniforms: {
		time: { type: "f", value: 1.0 },
		ripples: { type: "t", value: sim.tex.tex }
   },
   vertexShader:
"varying vec3 world;\n"+
"void main(void) {\n"+
"   vec3 P=vec3(position); \n"+
"   world=P;\n"+
"   gl_Position=projectionMatrix * modelViewMatrix * vec4( P, 1.0 );\n"+
"   gl_PointSize = 4.0; \n"+
"}\n"
,
    fragmentShader:
       PixAnvil.loadTab("Reflect")
})
);
sim.ground.position.z=-0.001;
sim.ground.receiveShadow=true;
scene.add(sim.ground);

// Sun-like spotlight
var l=new THREE.SpotLight();
sim.light = l;
l.position.set( -50, -100, 100 );
l.castShadow=true;
l.shadowCameraNear = 50; 
l.shadowCameraFar = 500; 
l.shadowCameraFov = 10; // degrees field of view
scene.add(l);

// Set up timestepping
sim.target_t=sim.current_t=0;
sim.framecount=0;

// Camera control:

// Update camera coordinate system
var s=camera;
if (!s.X) { // startup: create initial coordinates
    s.X=new vec3(1,0,0);
    s.Y=new vec3(0,0,1);
    s.Z=new vec3(0,-1,0); // camera Z is world Y
    s.P=new vec3(0,-2,5); // initial location
}

// Move camera via keyboard
var move=new vec3(0,0,0); // sums current frame motion

// X control via A and D
if (lib.key['a']) move.pe(new vec3(-1,0,0));
if (lib.key['d']) move.pe(new vec3(+1,0,0));
// Y control via W and S
if (lib.key['w']) move.pe(new vec3(0,0,-1));
if (lib.key['s']) move.pe(new vec3(0,0,+1));
// Z control via Q and Z
if (lib.key['q']) move.pe(new vec3(0,+1,0));
if (lib.key['z']) move.pe(new vec3(0,-1,0));

move.te(5.0*lib.dt); // meters/second motion rate
s.P.pe(s.X.t(move.x).p(s.Y.t(move.y)).p(s.Z.t(move.z)));

// Rotate camera via mouse
var speed=0.01; // radians per mouse pixel
if (lib.mouseleft) { // move Z with mouse
    s.Z.pe(s.X.t(-lib.mousedx*speed).p(
           s.Y.t( lib.mousedy*speed)));
}

// Keep level: make sure X is horizontal.
s.X.z=0.0;
s.Y.crossVectors(s.Z,s.X.normalize());

// Orthonormalize
s.X.crossVectors(s.Y,s.Z).normalize();
s.Y.crossVectors(s.Z,s.X).normalize();
s.Z.normalize();

// Write coordinate system into matrix
s.matrixAutoUpdate=false; // don't trash
s.matrixWorldNeedsUpdate=true; // show
  
var m=s.matrix; // the camera's matrix

// Utility function: set a matrix column
function setCol(m,col,vec) {
  m.elements[4*col+0]=vec.x;
  m.elements[4*col+1]=vec.y;
  m.elements[4*col+2]=vec.z;
}

setCol(m,0,s.X);
  setCol(m,1,s.Y);
  setCol(m,2,s.Z);
  setCol(m,3,s.P); // position from sim