Forest & Fire Simulation

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

// Make a texture:
var size=512;

// Set up texture filtering properly
var tex_filter=function() {
  // Linear smooth sampling (need mipmaps here)
  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_LINEAR);
  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
  
  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.REPEAT);
  gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.REPEAT);
}

// Allocate a texture of these dimensions:
var babgloo_tex=function(size) {
  igloo.check("before texture create");

// Make igloo texture
  var tex=igloo.texture(null, gl.RGBA, 
    gl.CLAMP_TO_EDGE, gl.NEAREST, gl.FLOAT)
    .blank(size,size);
  tex.bind();
  tex_filter();

// Make a framebuffer, to render into the texture:
  tex.fbo=igloo.framebuffer(tex);

// Clear bound texture
  gl.bindTexture(gl.TEXTURE_2D, null);

// Link igloo texture over to babylon for render:
  tex.babytex = BABYLON_tex(tex.texture);

igloo.check("after texture create");

return tex;
}
var tex=babgloo_tex(size);
var tex2=babgloo_tex(size);

// Build a program to render into it:
var prog=igloo.program(
  igloo_vertexshader,
  PixAnvil.loadTab("Frag")
);

var sim_dt=0.01;
var rendercount=0;
var render=function (prog,desttex,srctex)
{
  igloo.check("before pingpong render");
  // Render into destination texture:
  desttex.fbo.attach(desttex);

var status = gl.checkFramebufferStatus(gl.FRAMEBUFFER);
  if (status!=gl.FRAMEBUFFER_COMPLETE) 
    throw("Framebuffer status: "+status);

// Read from source texture
  var srcunit=3; // texture unit number
  if (srctex) srctex.bind(srcunit);
  tex_filter();

// Turn random rendering stuff off:
  gl.disable(gl.CULL_FACE);
  gl.disable(gl.STENCIL_TEST);
  gl.disable(gl.BLEND);
  gl.disable(gl.DEPTH_TEST);
  gl.disable(gl.SCISSOR_TEST);
  gl.viewport(0, 0, size,size);
  prog.use()
    .uniformi('texsrc',srcunit)
    .uniform('time',lib.time)
    .uniform('dt',sim_dt)
    .uniform('texdel',[1.0/size,1.0/size])
    .attrib('quad', igloo_quad, 2)
    .draw(gl.TRIANGLE_STRIP, 4);

/*
// Read back rendered pixels (for debug)
  var pixels=new Float32Array(4);
  gl.readPixels(256,100,1,1,
     gl.RGBA, gl.FLOAT,pixels,0);
  for (var channel=0;channel<=3;channel++)
  trace("Channel "+channel+": "+pixels[channel]);
*/
  // Turn stuff on again:
  gl.enable(gl.BLEND);
  gl.enable(gl.DEPTH_TEST);
  desttex.fbo.unbind(); // back to drawing to screen

// Build mipmaps for the freshly rendered texture:
  var destunit=srcunit+1;
  desttex.bind(destunit);
  gl.generateMipmap(gl.TEXTURE_2D); // <- this!
  gl.bindTexture(gl.TEXTURE_2D, null);

// Fix up babylon state
  BABYLON_flush();
  
  console.log("Rendered offscreen image");
  igloo.check("after pingpong render");
}

// Make a plane to show the texture
function planeSim() 
{
  var o=this;
  o.mesh = BABYLON.Mesh.CreatePlane("texshow", 6.0, scene);
  var m = new BABYLON.StandardMaterial("texture", scene);
  m.backFaceCulling = false; // double sided
  o.mesh.material = m;

// Draw this object using Babylon texture:
  o.mesh.material.emissiveTexture=tex.babytex;

// Turn off diffuse and specular, so you can see emissive:
  o.mesh.material.diffuseColor=new BABYLON.Color3(0,0,0);
  o.mesh.material.specularColor=new BABYLON.Color3(0,0,0);

o.mass=10000.0; // mass in kg
  o.V=new vec3(0,0,1); // moving up
  o.P=new vec3(0,0,0.002); // in the air (m)

o.mesh.position=o.P; // hook display to sim
  o.mesh.rotation.x=Math.PI/2; // Make plane stand upright
}

sim.obj=new planeSim();

lib.createGround(-4);

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

/* GLSL Fragment Shader: 
       red channel: heat from fire
       green channel: forest growth
*/
#ifdef GL_ES
precision highp float;
#endif

uniform float time; // lib.time, seconds
uniform float dt; // lib.dt timestep, seconds

varying vec2 texcoords; // our texture coords, [0-1]
uniform vec2 texdel; // texcoord change per pixel
uniform sampler2D texsrc; // source texture

// Sample our texture at this pixel offset:
//   cen gives the center texture coords.
//   (dx,dy) is a pixel offset from cen.
//   Level gives the mipmap bias:
//     (0==finest resolution; k==k levels coarser)
vec4 texat(vec2 cen,float dx,float dy,float level) {
  return texture2D(texsrc,
    cen+vec2(dx*texdel.x,dy*texdel.y),
    level);
}

void main() {
  vec2 cen=texcoords;
  float level=0.0;
  vec4 C=texat(cen,0.0,0.0,level);

vec4 L,R,T,B;
  L=texat(cen,-1.0,0.0,level);
  R=texat(cen,+1.0,0.0,level);
  B=texat(cen,0.0,-1.0,level);
  T=texat(cen,0.0,+1.0,level);

float edt=dt;
  if (fract(0.05*time)<0.5) { // fast fire phase
     edt*=0.01; // growth happens during fire, but *slow*
     if (C.r>0.1 && C.g>0.0) {
       float burn=C.r*C.g;
       C.g-=burn*dt;
       C.r+=20.0*burn*dt;
     }

// Blur, to simulate radiant heat transfer:
     vec4 blur=texat(cen,0.0,0.0,1.5);
     float blurFrac=3.0*dt;
     C.r+=blurFrac*(blur.r-C.r);
     
     if (C.r>0.0) {
       C.r-=1.0*C.r*dt; // cooling
     }

} else { // not fire season
     C.r=0.0;
  }

// Blur, to simulate vegetative propagation:
  vec4 blur=texat(cen,0.0,0.0,3.5);
  if (blur.g>C.g) { // colonization
    float blurFrac=3.0*edt;
    C.g+=blurFrac*(blur.g-C.g);
  }

// Self-growth of forest:
  if (C.g>0.1) {
    C.g+=edt*(1.0-C.g)*1.0/20.0;
  }

// Periodic blip of fire
  float firephase=0.15*time;
  if (length(texcoords-vec2(0.5+0.2*cos(0.1*time),0.5+0.2*sin(1.03*time)))<0.03*(cos(firephase)-0.5)) 
  { // forest on fire
    C.r=1.0;
  }

// Startup
  if (time<0.4) { 
    C=vec4(0.0,0.0,0.0,0.0);

// Initial forest in center
    if (length(texcoords-vec2(0.5,0.5))<0.3) 
    { // forest in middle
      C.g=1.0;
    }
  }

gl_FragColor = C;
}