Ok I want you to get this code snippets and convert them to work in roblox studio. This si a fluid simulation. Get rid of the erosion i dont need that. Here are the snippets.

errode.shader: /*
    :copyright: 2011 by Florian Boesch <<PRESIDIO_ANONYMIZED_EMAIL_ADDRESS>>.
    :license: GNU AGPL3, see LICENSE for more details.
*/

vertex:
    attribute vec2 position;
    void main(){
        gl_Position = vec4(position, 0.0, 1.0);
    }

fragment:
    uniform sampler2D ground, water;
    uniform vec2 viewport;
    uniform float factor;

    vec4 get(sampler2D source, float x, float y){
        return texture2D(source, (gl_FragCoord.xy+vec2(x,y))/viewport);
    }
        
    float tf = 0.0015;
    float tm = 0.5;

    void main(void){
        vec4 g = get(ground, 0.0, 0.0);
        vec3 w = get(water, 0.0, 0.0).xyz;

        float erroded = (length(w.yz)*0.000005)/(w.x+0.001)*factor;
        erroded /= 1.0 + g.z*300.0;
        g.y -= erroded;
        g.z += erroded;

        vec3 w_left    = get(water, -1.0,  0.0).xyz;
        vec3 w_right   = get(water,  1.0,  0.0).xyz;
        vec3 w_top     = get(water,  0.0,  1.0).xyz;
        vec3 w_bot     = get(water,  0.0, -1.0).xyz;
        
        vec4 g_left    = get(ground, -1.0,  0.0);
        vec4 g_right   = get(ground,  1.0,  0.0);
        vec4 g_top     = get(ground,  0.0,  1.0);
        vec4 g_bot     = get(ground,  0.0, -1.0);
        
        float soil_transported_off = (min(abs(w.y*tf/(w.x+0.001)), tm) + min(abs(w.z*tf/(w.x+0.001)), tm))*g.z;
        float soil_transported_in = (
            clamp(w_left.y*tf/(w_left.x+0.001), 0.0, tm) * g_left.z +
            clamp(-w_right.y*tf/(w_right.x+0.001), 0.0, tm) * g_right.z +
            clamp(-w_top.z*tf/(w_top.x+0.001), 0.0, tm) * g_top.z +
            clamp(w_bot.z*tf/(w_bot.x+0.001), 0.0, tm) * g_bot.z
        );
        g.z += (soil_transported_in - soil_transported_off)*factor;
        g.z = max(0.0, g.z);
        g.x = g.y + g.z;

        gl_FragColor = g;
    }

flows.shader: /*
    :copyright: 2011 by Florian Boesch <<PRESIDIO_ANONYMIZED_EMAIL_ADDRESS>>.
    :license: GNU AGPL3, see LICENSE for more details.
*/

vertex:
    attribute vec2 position;
    void main(){
        gl_Position = vec4(position, 0.0, 1.0);
    }

fragment:
    uniform sampler2D water, flows;
    uniform vec2 viewport;

    void main(void){
        vec2 uv = gl_FragCoord.xy/viewport;
        vec2 pos = texture2D(flows, uv).xy;
        vec3 w = texture2D(water, uv).xyz;
        vec2 vel = (w.yz*0.001)/(w.x*0.1+0.001);
        gl_FragColor = vec4(pos+vel, 0.0, 1.0);
    }

god.shader: /*
    :copyright: 2011 by Florian Boesch <<PRESIDIO_ANONYMIZED_EMAIL_ADDRESS>>.
    :license: GNU AGPL3, see LICENSE for more details.
*/

vertex:
    attribute vec2 position;
    void main(){
        gl_Position = vec4(position, 0.0, 1.0);
    }

fragment:
    uniform sampler2D ground;
    uniform vec2 viewport, screen, mousepos;
    uniform mat4 inv_view, inv_proj;
    uniform mat3 inv_rot;
    uniform float delta, rockfactor, soilfactor, editsize;
    
    //
    // Description : Array and textureless GLSL 2D/3D/4D simplex 
    //               noise functions.
    //      Author : Ian McEwan, Ashima Arts.
    //  Maintainer : ijm
    //     Lastmod : 20110822 (ijm)
    //     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
    //               Distributed under the MIT License. See LICENSE file.
    //               https://github.com/ashima/webgl-noise
    // 

    vec3 mod289(vec3 x) {
      return x - floor(x * (1.0 / 289.0)) * 289.0;
    }

    vec4 mod289(vec4 x) {
      return x - floor(x * (1.0 / 289.0)) * 289.0;
    }

    vec4 permute(vec4 x) {
         return mod289(((x*34.0)+1.0)*x);
    }

    vec4 taylorInvSqrt(vec4 r)
    {
      return 1.79284291400159 - 0.85373472095314 * r;
    }

    float snoise(vec3 v)
      { 
      const vec2  C = vec2(1.0/6.0, 1.0/3.0) ;
      const vec4  D = vec4(0.0, 0.5, 1.0, 2.0);

      vec3 i  = floor(v + dot(v, C.yyy) );
      vec3 x0 =   v - i + dot(i, C.xxx) ;

      vec3 g = step(x0.yzx, x0.xyz);
      vec3 l = 1.0 - g;
      vec3 i1 = min( g.xyz, l.zxy );
      vec3 i2 = max( g.xyz, l.zxy );

      vec3 x1 = x0 - i1 + C.xxx;
      vec3 x2 = x0 - i2 + C.yyy; // 2.0*C.x = 1/3 = C.y
      vec3 x3 = x0 - D.yyy;      // -1.0+3.0*C.x = -0.5 = -D.y

      i = mod289(i); 
      vec4 p = permute( permute( permute( 
                 i.z + vec4(0.0, i1.z, i2.z, 1.0 ))
               + i.y + vec4(0.0, i1.y, i2.y, 1.0 )) 
               + i.x + vec4(0.0, i1.x, i2.x, 1.0 ));

      float n_ = 0.142857142857; // 1.0/7.0
      vec3  ns = n_ * D.wyz - D.xzx;

      vec4 j = p - 49.0 * floor(p * ns.z * ns.z);  //  mod(p,7*7)

      vec4 x_ = floor(j * ns.z);
      vec4 y_ = floor(j - 7.0 * x_ );    // mod(j,N)

      vec4 x = x_ *ns.x + ns.yyyy;
      vec4 y = y_ *ns.x + ns.yyyy;
      vec4 h = 1.0 - abs(x) - abs(y);

      vec4 b0 = vec4( x.xy, y.xy );
      vec4 b1 = vec4( x.zw, y.zw );

      vec4 s0 = floor(b0)*2.0 + 1.0;
      vec4 s1 = floor(b1)*2.0 + 1.0;
      vec4 sh = -step(h, vec4(0.0));

      vec4 a0 = b0.xzyw + s0.xzyw*sh.xxyy ;
      vec4 a1 = b1.xzyw + s1.xzyw*sh.zzww ;

      vec3 p0 = vec3(a0.xy,h.x);
      vec3 p1 = vec3(a0.zw,h.y);
      vec3 p2 = vec3(a1.xy,h.z);
      vec3 p3 = vec3(a1.zw,h.w);

      vec4 norm = taylorInvSqrt(vec4(dot(p0,p0), dot(p1,p1), dot(p2, p2), dot(p3,p3)));
      p0 *= norm.x;
      p1 *= norm.y;
      p2 *= norm.z;
      p3 *= norm.w;

      vec4 m = max(0.6 - vec4(dot(x0,x0), dot(x1,x1), dot(x2,x2), dot(x3,x3)), 0.0);
      m = m * m;
      return 42.0 * dot( m*m, vec4( dot(p0,x0), dot(p1,x1), 
                                    dot(p2,x2), dot(p3,x3) ) );
      }
    
    vec3 get_world_normal(vec2 coord){
        vec2 frag_coord = coord/screen;
        frag_coord = (frag_coord-0.5)*2.0;
        vec4 device_normal = vec4(frag_coord, 0.0, 1.0);
        vec3 eye_normal = normalize((inv_proj * device_normal).xyz);
        vec3 world_normal = normalize(inv_rot*eye_normal);
        return world_normal;
    }

    void main(void){
        vec2 uv = gl_FragCoord.xy/viewport;
        vec4 g = texture2D(ground, uv);
        
        vec3 mousevec = get_world_normal(mousepos);
        vec4 eyepos = inv_view * vec4(0.0, 0.0, 0.0, 1.0);
        float u = dot(vec3(0.0, 1.0, 0.0), -eyepos.xyz)/dot(vec3(0.0, 1.0, 0.0), mousevec);
        vec3 intersection = eyepos.xyz + mousevec * u;
        vec3 position = vec3(uv.x-0.5, 0.0, -uv.y+0.5);
        float dist = distance(position, intersection)*pow(editsize, 3.0);
        float s = smoothstep(1.0, 0.0, dist);
       
        float h = 0.1;
        for(int i=2; i<8; i++){
            float factor = pow(2.0, float(i));
            h += snoise(vec3(uv*factor, 0.05*delta*float(i+1)))/(pow(factor, 0.8)*6.0);
        }

        g.y += h*rockfactor*s*0.01;
        g.z += h*soilfactor*s*0.01;
        g.z = clamp(g.z, 0.0, 1.0);
        g.x = g.y + g.z;

        gl_FragColor = g;
    }

main.js: /*
    :copyright: 2011 by Florian Boesch <<PRESIDIO_ANONYMIZED_EMAIL_ADDRESS>>.
    :license: GNU AGPL3, see LICENSE for more details.
*/

var editsize = 3;
var lightview = new Mat4().rotatex(15).rotatey(60);
var inv_lightview = new Mat4().updateFrom(lightview).invert();
var keys = new Keys();
var controls = {
    rock: 1.0,
    soil: 0.0,
    water: 0.0,
    dir: 1.0,
    rain: 1.0,
    erode: 1.0,
    evaporate: 1.0,
};
var view, mousepos, projection;
var start = Date.now()/1000;
var terrain;

var Processor = Class({
    __init__: function(width, height, framework){
        this.result = new framework.Texture()
            .size(width, height, 'float')
            .linear()
            .clampToEdge();
        this.fbo = new framework.Framebuffer()
            .color(this.result);
        this.quad = framework.unitQuad();
    },
    run: function(program){
        program.draw(this.quad, this.fbo);
    }
});

var Water = Class({
    __init__: function(width, height, framework, programs, heights, normals){
        this.programs = programs;
        this.framework = framework;
        
        this.tmp = new Processor(width, height, framework);
        this.last = new Processor(width, height, framework);
        this.current = new Processor(width, height, framework);
        this.normals = new Processor(width, height, framework);
        this.flows = new Processor(128, 128, framework);
        this.flows.result.nearest();

        programs.water_diffuse.set('heights', heights.result);
        programs.water_momentum
            .set('last', this.last.result)
            .set('current', this.current.result)
            .set('ground', heights.result);
        programs.water_cycle.set('water', this.tmp.result);
        programs.water_normals.set({
            ground: heights.result,
            water: this.current.result,
        });
        programs.flows.set({
            flows: this.flows.result,
            water: this.current.result,
        });
    },
    update: function(){
        this.programs.water_diffuse.set('axis', 0, 1).set('source', this.current.result);
        this.tmp.run(this.programs.water_diffuse);
        this.programs.water_diffuse.set('axis', 1, 0).set('source', this.tmp.result);
        this.current.run(this.programs.water_diffuse);

        this.tmp.run(this.programs.water_momentum);
        this.programs.copy.set('source', this.current.result);
        this.last.run(this.programs.copy);
        this.programs.water_cycle
            .set('rain', controls.rain)
            .set('evaporate', controls.evaporate)
            .set(view)
            .set(projection)
            .set('mousepos', mousepos)
            .set('editsize', editsize)
            .set('screen', [this.framework.screen.width, this.framework.screen.height])
            .set('create', keys.space && controls.water ? 1.0 * controls.dir : 0.0)

        this.current.run(this.programs.water_cycle);
        this.normals.run(this.programs.water_normals);
        this.tmp.run(this.programs.flows);
        this.flows.run(this.programs.copy.set('source', this.tmp.result));
    },
});

var Shadow = Class({
    __init__: function(width, height, framework, programs, terrain, grid){
        this.programs = programs;
        this.grid = grid;
        this.gl = framework.gl;

        this.depth = new framework.Texture()
            .size(2048, 2048, 'float')
            .linear()
            .clampToEdge();

        this.fbo = new framework.Framebuffer()
            .color(this.depth)
            .depth();
        
        this.proj = new framework.Ortho(this.fbo, {
            scale: 1.5,
            near: -20,
            far: 20,
        });

        programs.shadow
            .set('heights', terrain.heights.result)
            .set(this.proj);
            
        programs.shadowmap
            .set('heights', terrain.heights.result)
            .set('normals', terrain.normals.result)
            .set('shadows', this.depth)
            .set('shadowsize', this.depth.width, this.depth.height)
            .set(this.proj);

        programs.water_shadowmap
            .set('ground', terrain.heights.result)
            .set('water', terrain.water.current.result)
            .set('normals', terrain.water.normals.result)
            .set('shadows', this.depth)
            .set('shadowsize', this.depth.width, this.depth.height)
            .set(this.proj);

        this.map = new Processor(width*2, height*2, framework);
        this.water_map = new Processor(width*2, height*2, framework);
        this.tmp = new Processor(width*2, height*2, framework);
    },
    update: function(){
        this.fbo.bind();
        this.gl.clearColor(1, 1, 1, 1);
        this.gl.clear(this.gl.COLOR_BUFFER_BIT | this.gl.DEPTH_BUFFER_BIT);
        this.programs.shadow.set('view', lightview).draw(this.grid, this.fbo);

        this.programs.shadowmap.set('view', lightview);
        this.map.run(this.programs.shadowmap);
        this.programs.blur.set('axis', 1.2, 0.0).set('source', this.map.result);
        this.tmp.run(this.programs.blur);
        this.programs.blur.set('axis', 0.0, 1.2).set('source', this.tmp.result);
        this.map.run(this.programs.blur);
        
        this.programs.water_shadowmap.set('view', lightview);
        this.water_map.run(this.programs.water_shadowmap);
        this.programs.blur.set('axis', 1.2, 0.0).set('source', this.water_map.result);
        this.tmp.run(this.programs.blur);
        this.programs.blur.set('axis', 0.0, 1.2).set('source', this.tmp.result);
        this.water_map.run(this.programs.blur);
    }
});
    
var Terrain = Class({
    __init__: function(width, height, framework, programs, grid){
        this.framework = framework;
        this.programs = programs;
        this.heights = new Processor(width, height, framework);
        this.normals = new Processor(width, height, framework);
        this.occlusions = new Processor(width, height, framework);
        this.water = new Water(width, height, framework, programs, this.heights, this.normals);
        this.shadow = new Shadow(width, height, framework, programs, this, grid);
        
        this.tmp = new Processor(width, height, framework);

        programs.normal.set('heights', this.heights.result);
        programs.occlusion.set({
            'heights': this.heights.result,
            'normals': this.normals.result,
        });
        this.reset($( "#seedslider" ).slider( "value" ));
 		$( "#seed" ).val( $( "#seedslider" ).slider( "value" ) );
    },
    reset: function(delta) {
    	this.delta = delta;
//        console.log(this.delta);
        this.programs.simplex.set('delta', this.delta);
        this.heights.run(this.programs.simplex);
        this.programs.errode.set({
            ground: this.heights.result,
            water: this.water.current.result,
        });
        this.programs.diffuse_soil.set({
            ground: this.tmp.result,
            water: this.water.current.result,
        });
    },
    update: function(){
        this.water.update();
        this.programs.errode.set('factor', controls.erode);
        this.tmp.run(this.programs.errode);
        
        this.heights.run(this.programs.diffuse_soil);

        if(keys.space && (controls.soil || controls.rock)){
            this.programs.god
                .set(view)
                .set(projection)
                .set('mousepos', mousepos)
                .set('delta', Date.now()/1000-start)
                .set('screen', [this.framework.screen.width, this.framework.screen.height])
                .set('rockfactor', controls.rock * controls.dir)
                .set('soilfactor', controls.soil * controls.dir)
                .set('editsize', editsize)
            this.tmp.run(this.programs.god);
            this.heights.run(this.programs.copy.set('source', this.tmp.result));
        }
        
        this.normals.run(this.programs.normal);
        this.occlusions.run(this.programs.occlusion);
        this.shadow.update();
    },
});

$(function(){
    var canvas = $('canvas');
    $('#modtype').buttonset();
    $('#modop').buttonset();
    $('#params').buttonset();
   
    $('input[name="modtype"]').change(function(){
        controls.rock = 0.0;
        controls.soil = 0.0;
        controls.water = 0.0;
        controls[$(this).attr('id')] = 1.0;
    });
    
    $('input[name="modop"]').change(function(){
        if($(this).attr('id') == 'add'){
            controls.dir = 1.0;
        }
        else{
            controls.dir = -1.0;
        }
    });

    $('#rain,#erode,#evaporate').change(function(){
        var id = $(this).attr('id');
        if(this.checked){
            controls[id] = 1.0;
        }
        else{
            controls[id] = 0.0;
        }
    });

    $( ".ui-icon-wrench" ).click(function() {
        $(".hideable").toggle();
	});

    $('#seed').change(function(){
    	var newseed = parseInt($( "#seed" ).val());
  		$( "#seedslider" ).slider( 'value', newseed );
      terrain.reset(newseed);       
    });

	$( "#seedslider" ).slider(	{
		slide: function( event, ui ) {
			$( "#seed" ).val( ui.value );
			terrain.reset(ui.value);
		},
        value:1,
        min: 1,
        max: 1000,
        step: 1
    });
    
   	$(".hideable").toggle();
   	
    view = new Viewpoint({
        element: canvas,
        offset: new Vec3(0, 0, 0.0),
        x: -0.08,
        y: -0.08,
        z: -0.65,
        pitch: 12,
    });

    mousepos = [0, 0];
    canvas.mousemove(function(event){
        mousepos[0] = event.pageX;
        mousepos[1] = this.height - event.pageY;
    });
    
    $(document).mousewheel(function(event, delta){
        editsize = clamp(editsize - delta*0.1, 2, 20);
    });

    var handle_error = function(description){
        $(document).unbind();
        $('body').empty();
        var elem = $('<div id="error"></div>')
            .appendTo('body');
        $('<h1>Whoops, shit happens.</h1>')
            .appendTo(elem);
        $('<pre></pre>').text(description).appendTo(elem);
        $('<div id="bugs"><a href="https://bugzilla.mozilla.org/enter_bug.cgi">file a mozilla bug</a>, <a href="http://code.google.com/p/chromium/issues/list">file a chrome bug</a>, <a href="http://code.google.com/p/angleproject/issues/list">file an angleproject bug</a>, <a href="http://emailcustomercare.amd.com/">file an AMD bug</a>, <a href="http://nvidia.custhelp.com/app/chat/chat_launch">file an Nvidia bug</a></div>').appendTo(elem);
    }

    try{
        var framework = new Framework(canvas[0])
            .depthLess()
            .blendAlpha()
            .getExt('texture_float')
            .requireParam('MAX_VERTEX_TEXTURE_IMAGE_UNITS', 4);
    }
    catch(error){
        handle_error(error);
        return;
    }
    
    try {   // some browsers need this extension
        framework.getExt('texture_float_linear')
    } catch (error){
        // ignore error in browsers that do not have this extension
    }
    
    projection = new framework.Perspective(framework.screen, {
        near: 0.01,
        far: 20,
        fov: 60,
    });

    var gl = framework.gl;

    var gridsize = 512;
    var grid, hexgrid;
    var createGrids = function(gridsize) {
        grid = new framework.Grid({
            xsize: gridsize,
            ysize: gridsize,
            cell_width: 4,
            cell_height: 4,
            width: 1,
            height: 1,
        });
    
        hexgrid = new framework.HexGrid({
            xsize: gridsize,
            ysize: gridsize,
            width: 1,
            height: 1,
        });
    };
    createGrids(gridsize);
    
    var scheduler = new Scheduler(function(delta, now){ 
        terrain.update();
        framework.screen.bind();

        gl.clearColor(0.7, 0.7, 0.7, 1);
        gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);
        view.update(delta);

        programs.display
            .set(projection)
            .set(view)
            .set('mousepos', mousepos)
            .set('editsize', editsize)
            .draw(hexgrid, framework.screen);

        programs.water_display
            .set(projection)
            .set(view)
            .set('mousepos', mousepos)
            .set('editsize', editsize)
            .draw(grid, framework.screen);
            
        var error = gl.getError();
        if (error == 1285) {    // out of memory
            gridsize /= 4;      // reduce grid size
            console.log("Reducing gridsize to " + gridsize);
            createGrids(gridsize);
        }
    });

    var programs = {
        display: 'display.shader',
        simplex: 'simplex3d.shader',
        normal: 'normal.shader',
        occlusion: 'occlusion.shader',
        shadow: 'shadow.shader',
        shadowmap: 'shadowmap.shader',
        blur: 'blur.shader',
        rock: 'rock_texture.png',
        rock_normals: 'rock2_normals.png',
        grass: 'grass_material.png',
        grass_normals: 'grass_normals.png',

        water_diffuse: 'water/diffuse.shader',
        water_display: 'water/display.shader',
        water_momentum: 'water/momentum.shader',
        water_cycle: 'water/cycle.shader',
        water_normals: 'water/normals.shader',
        water_shadowmap: 'water/shadowmap.shader',
        flows: 'flows.shader',
        god: 'god.shader',

        errode: 'errode.shader',
        diffuse_soil: 'diffuse_soil.shader',

        copy: 'copy.shader',
    };
   
    var loader = new framework.Loader()
        .error(function(description){
            handle_error(description);
        })
        .load(programs)
        .ready(function(){
            terrain = new Terrain(512, 512, framework, programs, hexgrid);
            terrain.update();
            programs.display.set({
                'heights': terrain.heights.result,
                'normals': terrain.normals.result,
                'occlusions': terrain.occlusions.result,
                'rock': programs.rock.mipmap(),
                'rock_normals': programs.rock_normals.mipmap(),
                'grass': programs.grass.mipmap(),
                'grass_normals': programs.grass_normals.mipmap(),
                'shadowmap': terrain.shadow.map.result,
                water: terrain.water.current.result,
            });
            programs.water_display.set({
                lightview: inv_lightview,
                normals: terrain.water.normals.result,
                heights: terrain.heights.result,
                water_heights: terrain.water.current.result,
                detail_normals: programs.grass_normals,
                shadowmap: terrain.shadow.water_map.result,
                flows: terrain.water.flows.result,
            });
            scheduler.start();
        });
});

diffuse.shader:/*
    :copyright: 2011 by Florian Boesch <<PRESIDIO_ANONYMIZED_EMAIL_ADDRESS>>.
    :license: GNU AGPL3, see LICENSE for more details.
*/

vertex:
    attribute vec2 position;
    void main(){
        gl_Position = vec4(position, 0.0, 1.0);
    }

fragment:
    uniform sampler2D heights, source;
    uniform vec2 viewport, axis;

    vec3 exchange(float t1, float h1, vec2 off){
        vec2 uv = (gl_FragCoord.xy+off)/viewport;
        float t2 = texture2D(heights, uv).x;
        float h2 = texture2D(source, uv).x;
        float f1 = t1+h1;
        float f2 = t2+h2;
        float diff = (f2-f1)/2.0;
        diff = clamp(diff*0.65, -h1/2.0, h2/2.0);
        return vec3(diff, -off*diff);
    }

    void main(void){
        vec2 uv = gl_FragCoord.xy/viewport;
        float t = texture2D(heights, uv).x;
        vec3 h = texture2D(source, uv).xyz;
        vec3 r = h + exchange(t, h.x, axis) + exchange(t, h.x, -axis);
        gl_FragColor = vec4(r, 1.0);
    }

init.shader: /*
    :copyright: 2011 by Florian Boesch <<PRESIDIO_ANONYMIZED_EMAIL_ADDRESS>>.
    :license: GNU AGPL3, see LICENSE for more details.
*/

//      Author : Ian McEwan, Ashima Arts.
//  Maintainer : ijm
//     License : Copyright (C) 2011 Ashima Arts. All rights reserved.
//               Distributed under the MIT License. See LICENSE file.

vertex:
    attribute vec2 position;
    void main(){
        gl_Position = vec4(position, 0.0, 1.0);
    }

fragment:
    uniform vec2 viewport;

    vec3 mod289(vec3 x) {
        return x - floor(x * (1.0 / 289.0)) * 289.0;
    }

    vec2 mod289(vec2 x) {
        return x - floor(x * (1.0 / 289.0)) * 289.0;
    }

    vec3 permute(vec3 x) {
        return mod289(((x*34.0)+1.0)*x);
    }

    float snoise(vec2 v){
        const vec4 C = vec4(
            0.211324865405187,  // (3.0-sqrt(3.0))/6.0
            0.366025403784439,  // 0.5*(sqrt(3.0)-1.0)
            -0.577350269189626,  // -1.0 + 2.0 * C.x
            0.024390243902439   // 1.0 / 41.0
        ); 
        // First corner
        vec2 i  = floor(v + dot(v, C.yy) );
        vec2 x0 = v -   i + dot(i, C.xx);

        // Other corners
        vec2 i1;
        //i1.x = step( x0.y, x0.x ); // x0.x > x0.y ? 1.0 : 0.0
        //i1.y = 1.0 - i1.x;
        i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
        // x0 = x0 - 0.0 + 0.0 * C.xx ;
        // x1 = x0 - i1 + 1.0 * C.xx ;
        // x2 = x0 - 1.0 + 2.0 * C.xx ;
        vec4 x12 = x0.xyxy + C.xxzz;
        x12.xy -= i1;

        // Permutations
        i = mod289(i); // Avoid truncation effects in permutation
        vec3 p = permute(
            permute(i.y + vec3(0.0, i1.y, 1.0)) +
            i.x +
            vec3(0.0, i1.x, 1.0)
        );

        vec3 m = max(0.5 - vec3(dot(x0,x0), dot(x12.xy,x12.xy), dot(x12.zw,x12.zw)), 0.0);
        m = m*m ;
        m = m*m ;

        // Gradients: 41 points uniformly over a line, mapped onto a diamond.
        // The ring size 17*17 = 289 is close to a multiple of 41 (41*7 = 287)

        vec3 x = 2.0 * fract(p * C.www) - 1.0;
        vec3 h = abs(x) - 0.5;
        vec3 ox = floor(x + 0.5);
        vec3 a0 = x - ox;

        // Normalise gradients implicitly by scaling m
        // Approximation of: m *= inversesqrt( a0*a0 + h*h );
        m *= 1.79284291400159 - 0.85373472095314 * ( a0*a0 + h*h );

        // Compute final noise value at P
        vec3 g;
        g.x  = a0.x  * x0.x  + h.x  * x0.y;
        g.yz = a0.yz * x12.xz + h.yz * x12.yw;
        return 130.0 * dot(m, g);
    }
    
    void main(){
        float h = 0.0;
        for(int i=0; i<5; i++){
            float factor = pow(2.0, float(i));
            h += snoise((gl_FragCoord.xy+100.0)*factor/viewport)/(pow(factor, 0.88)*5.0);
        }
        h = clamp(h-0.20, 0.0, 1.0);
        //gl_FragColor = vec4(h, h, h, 1.0);
        gl_FragColor = vec4(0.0000, 0.0000, 0.0000, 1.0);
    }

momentum.shader:/*
    :copyright: 2011 by Florian Boesch <<PRESIDIO_ANONYMIZED_EMAIL_ADDRESS>>.
    :license: GNU AGPL3, see LICENSE for more details.
*/

vertex:
    attribute vec2 position;
    void main(){
        gl_Position = vec4(position, 0.0, 1.0);
    }

fragment:
    uniform sampler2D current, last, ground;
    uniform vec2 viewport;

    vec4 get(sampler2D src, float x, float y){
        return texture2D(src, (gl_FragCoord.xy+vec2(x,y))/viewport);
    }
    
    vec3 exchange(float g1, vec3 l1, vec3 c1, float x, float y){
        float g2 = get(ground, x, y).x;
        vec3 c2 = get(current, x, y).xyz;
        float change = (g2+c2.x) - (g1+l1.x);
        change = clamp(change*1.00, -c1.x*0.25, c2.x*0.25);
        return vec3(change, vec2(-x*change, -y*change));
    }

    void main(void){
        float g = get(ground, 0.0, 0.0).x;
        vec3 l = get(last, 0.0, 0.0).xyz;
        vec3 c = get(current, 0.0, 0.0).xyz;

        vec3 v = (
            exchange(g, l, c,  1.0,  0.0) +
            exchange(g, l, c, -1.0,  0.0) +
            exchange(g, l, c,  0.0,  1.0) +
            exchange(g, l, c,  0.0, -1.0)
        )*vec3(0.25, 0.25, 0.25);
        
        vec3 n = c + v;
        gl_FragColor = vec4(n, 1.0);
    }

cycle.shader:/*
    :copyright: 2011 by Florian Boesch <<PRESIDIO_ANONYMIZED_EMAIL_ADDRESS>>.
    :license: GNU AGPL3, see LICENSE for more details.
*/

vertex:
    attribute vec2 position;
    void main(){
        gl_Position = vec4(position, 0.0, 1.0);
    }

fragment:
    uniform sampler2D water;
    uniform vec2 viewport, screen, mousepos;
    uniform float rain, evaporate, create, editsize;
    
    uniform mat4 inv_view, inv_proj;
    uniform mat3 inv_rot;
    
    vec2 get(float x, float y){
        return texture2D(water, (gl_FragCoord.xy+vec2(x,y))/viewport).yz;
    }
    
    vec3 get_world_normal(vec2 coord){
        vec2 frag_coord = coord/screen;
        frag_coord = (frag_coord-0.5)*2.0;
        vec4 device_normal = vec4(frag_coord, 0.0, 1.0);
        vec3 eye_normal = normalize((inv_proj * device_normal).xyz);
        vec3 world_normal = normalize(inv_rot*eye_normal);
        return world_normal;
    }

    void main(void){
        vec2 uv = gl_FragCoord.xy/viewport;
        
        vec3 mousevec = get_world_normal(mousepos);
        vec4 eyepos = inv_view * vec4(0.0, 0.0, 0.0, 1.0);
        float u = dot(vec3(0.0, 1.0, 0.0), -eyepos.xyz)/dot(vec3(0.0, 1.0, 0.0), mousevec);
        vec3 intersection = eyepos.xyz + mousevec * u;
        vec3 position = vec3(uv.x-0.5, 0.0, -uv.y+0.5);
        float dist = distance(position, intersection)*pow(editsize, 3.0);
        float s = smoothstep(1.0, 0.0, dist);

        vec3 w = texture2D(water, uv).xyz;
        w.x += 0.00000005*rain;
        w.x *= mix(1.0, 0.999925, evaporate);
        w.x += s * create * 0.0001;
        w.x = clamp(w.x, 0.0, 1.0);
        w.yz = (
            get(-1.0, -1.0)*1.0    + get(0.0, -1.0)*1.4    + get(1.0, -1.0)*1.0 +
            get(-1.0,  0.0)*1.4     + w.yz*300.0              + get(1.0, -1.0)*1.4 +
            get(-1.0, -1.0)*1.0    + get(0.0, -1.0)*1.4    + get(1.0, -1.0)*1.0
        )*0.98*(1.0/(300.0+1.4*4.0+4.0));
        gl_FragColor = vec4(w, 1.0);
    }

Remember I only mant the fluid mechanics not the erosion and stuff so tell me if you need any other snippets.