What kind of blurs can be implemented in pixel shaders?

前端 未结 4 1009
梦毁少年i
梦毁少年i 2020-12-18 00:27

Gaussian, box, radial, directional, motion blur, zoom blur, etc.

I read that Gaussian blur can be broken down in passes that could be implemented in pixel shaders, b

4条回答
  •  伪装坚强ぢ
    2020-12-18 01:19

    An often seen implementation to achieve a blur effect of a scene is the Gaussian blur, implemented by a 2 pass post-processing.
    This is an approximation which first blurs along the X-Axis in the 1st pass and along the Y-Axis in the 2nd pass (or vice versa). This results in a better performance for strong blurring.
    The blur shader uses a normal (or Gaussian) distribution. For the 2 passes is used the same shader program, with individual direction settings for the 2 passes, stored in the uniform vec2 u_dir. The strength of the blur effect can be varied with the uniform variable float u_sigma in the range [0.0, 1.0].
    The scene is written to frame buffer with a texture bound to the color plane. A screen space pass uses the texture as the input to blur the output along the X-axis. The X-axis blur pass writes to another frame buffer, with a texture bound to its color plane. This texture is used as the input, for the final blur process along the Y-axis.
    A detailed description of the blur algorithm can be found at the answer to the question OpenGL es 2.0 Gaussian blur on triangle or LeranOpenGL - Gaussian blur.

    Blur Vertex shader

    #version 330
    
    in  vec2 inPos;
    out vec2 pos;
    
    void main()
    {
        pos = inPos;
        gl_Position = vec4( inPos, 0.0, 1.0 );
    }
    

    Blur Fragment shader

    #version 330
    
    in vec2 pos;
    
    uniform sampler2D u_texture;
    uniform vec2      u_textureSize;
    uniform float     u_sigma;
    uniform vec2      u_dir;
    
    float CalcGauss( float x, float sigma )
    {
        if ( sigma <= 0.0 )
            return 0.0;
      return exp( -(x*x) / (2.0 * sigma) ) / (2.0 * 3.14157 * sigma);
    }
    
    void main()
    {
        vec2 texC     = pos.st * 0.5 + 0.5;
        vec4 texCol   = texture2D( u_texture, texC );
        vec4 gaussCol = vec4( texCol.rgb, 1.0 );
        vec2 step     = u_dir / u_textureSize;
        for ( int i = 1; i <= 32; ++ i )
        {
            float weight = CalcGauss( float(i) / 32.0, u_sigma * 0.5 );
            if ( weight < 1.0/255.0 )
                break;
            texCol    = texture2D( u_texture, texC + step * float(i) );
            gaussCol += vec4( texCol.rgb * weight, weight );
            texCol    = texture2D( u_texture, texC - step * float(i) );
            gaussCol += vec4( texCol.rgb * weight, weight );
        }
        gaussCol.rgb = clamp( gaussCol.rgb / gaussCol.w, 0.0, 1.0 );
        gl_FragColor = vec4( gaussCol.rgb, 1.0 );
    }
    

    See also the answers to the following question:

    • Fast Gaussian blur at pause
    • OpenGL es 2.0 Gaussian blur on triangle
    • How to get a "Glow" shader effect in OpenGL ES 2.0?

    See a WebGL example:

    var readInput = true;
    function changeEventHandler(event){
    readInput = true;
    }
    
    (function loadscene() {
    
    var resize, gl, progDraw, progBlur, vp_size, blurFB;
    var canvas;
    var camera;
    var bufCube = {};
    var bufQuad = {};
    var shininess = 10.0;
    var glow = 10.0;
    var sigma = 0.8;
    var radius = 1.0;
    
    function render(deltaMS){
    
        if ( readInput ) {
            //readInput = false;
            var sliderScale = 100;
            sigma     = document.getElementById( "sigma" ).value / sliderScale;
            radius    = document.getElementById( "radius" ).value / sliderScale;
        }
    
        vp_size = [canvas.width, canvas.height];
        camera.Update( vp_size );
            
        gl.enable( gl.DEPTH_TEST );
        gl.clearColor( 0.0, 0.0, 0.0, 1.0 );
        gl.clear( gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT );
    
        // set up framebuffer
        gl.bindFramebuffer( gl.FRAMEBUFFER, blurFB[0] );
        gl.viewport( 0, 0, blurFB[0].width, blurFB[0].height );
        gl.clear( gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT );
    
        // setup view projection and model
        var prjMat = camera.Perspective();
        var viewMat = camera.Orbit();
        var modelMat = IdentM44();
        modelMat = camera.AutoModelMatrix();
        
        // set up draw shader
        ShProg.Use( progDraw.prog );
        ShProg.SetM44( progDraw.prog, "u_projectionMat44", prjMat );
        ShProg.SetM44( progDraw.prog, "u_modelViewMat44", Multiply(viewMat, modelMat) );
        ShProg.SetF1( progDraw.prog, "u_shininess", shininess );
        
        // draw scene
        VertexBuffer.Draw( bufCube );
    
        // set blur-X framebuffer and bind frambuffer texture
        gl.bindFramebuffer( gl.FRAMEBUFFER, blurFB[1] );
        gl.viewport( 0, 0, blurFB[1].width, blurFB[1].height );
        gl.clear( gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT );
        var texUnit = 1;
        gl.activeTexture( gl.TEXTURE0 + texUnit );
        gl.bindTexture( gl.TEXTURE_2D, blurFB[0].color0_texture );
    
        // set up blur-X shader
        ShProg.Use( progBlur.prog );
        ShProg.SetI1( progBlur.prog, "u_texture", texUnit )
        ShProg.SetF2( progBlur.prog, "u_textureSize", vp_size );
        ShProg.SetF1( progBlur.prog, "u_sigma", sigma )
        ShProg.SetF1( progBlur.prog, "u_radius", radius )
        ShProg.SetF2( progBlur.prog, "u_dir", [1.0, 0.0] )
    
        // draw full screen space
        gl.enableVertexAttribArray( progBlur.inPos );
        gl.bindBuffer( gl.ARRAY_BUFFER, bufQuad.pos );
        gl.vertexAttribPointer( progBlur.inPos, 2, gl.FLOAT, false, 0, 0 ); 
        gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, bufQuad.inx );
        gl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 );
        gl.disableVertexAttribArray( progBlur.inPos );
    
        // reset framebuffer and bind frambuffer texture
        gl.bindFramebuffer( gl.FRAMEBUFFER, null );
        gl.viewport( 0, 0, vp_size[0], vp_size[1] );
        gl.clear( gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT );
        texUnit = 2;
        gl.activeTexture( gl.TEXTURE0 + texUnit );
        gl.bindTexture( gl.TEXTURE_2D, blurFB[1].color0_texture );
    
        // set up pst process shader
        ShProg.SetI1( progBlur.prog, "u_texture", texUnit )
        ShProg.SetF1( progBlur.prog, "u_radius", radius )
        ShProg.SetF2( progBlur.prog, "u_dir", [0.0, 1.0] )
    
        // draw full screen space
        gl.enableVertexAttribArray( progBlur.inPos );
        gl.bindBuffer( gl.ARRAY_BUFFER, bufQuad.pos );
        gl.vertexAttribPointer( progBlur.inPos, 2, gl.FLOAT, false, 0, 0 ); 
        gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, bufQuad.inx );
        gl.drawElements( gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0 );
        gl.disableVertexAttribArray( progBlur.inPos );
    
        requestAnimationFrame(render);
    }
    
    function initScene() {
    
        canvas = document.getElementById( "canvas");
        gl = canvas.getContext( "experimental-webgl" );
        if ( !gl )
            return null;
    
        progDraw = {}
        progDraw.prog = ShProg.Create( 
        [ { source : "draw-shader-vs", stage : gl.VERTEX_SHADER },
            { source : "draw-shader-fs", stage : gl.FRAGMENT_SHADER }
        ] );
        if ( !progDraw.prog )
            return null;
        progDraw.inPos = gl.getAttribLocation( progDraw.prog, "inPos" );
        progDraw.inNV  = gl.getAttribLocation( progDraw.prog, "inNV" );
        progDraw.inCol = gl.getAttribLocation( progDraw.prog, "inCol" );
    
        progBlur = {}
        progBlur.prog = ShProg.Create( 
        [ { source : "post-shader-vs", stage : gl.VERTEX_SHADER },
            { source : "blur-shader-fs", stage : gl.FRAGMENT_SHADER }
        ] );
        progBlur.inPos = gl.getAttribLocation( progBlur.prog, "inPos" );
        if ( !progBlur.prog )
            return;    
        
        // create cube
        var cubePos = [
        -1.0, -1.0,  1.0,  1.0, -1.0,  1.0,  1.0,  1.0,  1.0, -1.0,  1.0,  1.0,
        -1.0, -1.0, -1.0,  1.0, -1.0, -1.0,  1.0,  1.0, -1.0, -1.0,  1.0, -1.0 ];
        var cubeCol = [ 1.0, 0.0, 0.0, 1.0, 0.5, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0 ];
        var cubeHlpInx = [ 0, 1, 2, 3, 1, 5, 6, 2, 5, 4, 7, 6, 4, 0, 3, 7, 3, 2, 6, 7, 1, 0, 4, 5 ];  
        var cubePosData = [];
        for ( var i = 0; i < cubeHlpInx.length; ++ i ) {
        cubePosData.push( cubePos[cubeHlpInx[i]*3], cubePos[cubeHlpInx[i]*3+1], cubePos[cubeHlpInx[i]*3+2] );
        }
        var cubeNVData = [];
        for ( var i1 = 0; i1 < cubeHlpInx.length; i1 += 4 ) {
        var nv = [0, 0, 0];
        for ( i2 = 0; i2 < 4; ++ i2 ) {
            var i = i1 + i2;
            nv[0] += cubePosData[i*3]; nv[1] += cubePosData[i*3+1]; nv[2] += cubePosData[i*3+2];
        }
        for ( i2 = 0; i2 < 4; ++ i2 )
        cubeNVData.push( nv[0], nv[1], nv[2] );
        }
        var cubeColData = [];
        for ( var is = 0; is < 6; ++ is ) {
        for ( var ip = 0; ip < 4; ++ ip ) {
            cubeColData.push( cubeCol[is*3], cubeCol[is*3+1], cubeCol[is*3+2] ); 
        }
        }
        var cubeInxData = [];
        for ( var i = 0; i < cubeHlpInx.length; i += 4 ) {
        cubeInxData.push( i, i+1, i+2, i, i+2, i+3 );   
        }
        bufCube = VertexBuffer.Create(
        [ { data : cubePosData, attrSize : 3, attrLoc : progDraw.inPos },
        { data : cubeNVData,  attrSize : 3, attrLoc : progDraw.inNV },
        { data : cubeColData, attrSize : 3, attrLoc : progDraw.inCol } ],
        cubeInxData );
    
        bufQuad.pos = gl.createBuffer();
        gl.bindBuffer( gl.ARRAY_BUFFER, bufQuad.pos );
        gl.bufferData( gl.ARRAY_BUFFER, new Float32Array( [ -1.0, -1.0, 1.0, -1.0, 1.0, 1.0, -1.0, 1.0 ] ), gl.STATIC_DRAW );
        bufQuad.inx = gl.createBuffer();
        gl.bindBuffer( gl.ELEMENT_ARRAY_BUFFER, bufQuad.inx );
        gl.bufferData( gl.ELEMENT_ARRAY_BUFFER, new Uint16Array( [ 0, 1, 2, 0, 2, 3 ] ), gl.STATIC_DRAW );  
        
        camera = new Camera( [0, 3, 0.0], [0, 0, 0], [0, 0, 1], 90, vp_size, 0.5, 100 );
    
        window.onresize = resize;
        resize();
        requestAnimationFrame(render);
    }
    
    function resize() {
        //vp_size = [gl.drawingBufferWidth, gl.drawingBufferHeight];
        vp_size = [window.innerWidth, window.innerHeight]
        //vp_size = [256, 256]
        canvas.width = vp_size[0];
        canvas.height = vp_size[1];
    
        var fbsize = Math.max(vp_size[0], vp_size[1]);
        fbsize = 1 << 31 - Math.clz32(fbsize); // nearest power of 2
    
        blurFB = [];
        for ( var i = 0; i < 2; ++ i ) {
            fb = gl.createFramebuffer();
            fb.width = fbsize;
            fb.height = fbsize;
            gl.bindFramebuffer( gl.FRAMEBUFFER, fb );
            fb.color0_texture = gl.createTexture();
            gl.bindTexture( gl.TEXTURE_2D, fb.color0_texture );
            gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST );
            gl.texParameteri( gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST );
            gl.texImage2D( gl.TEXTURE_2D, 0, gl.RGBA, fb.width, fb.height, 0, gl.RGBA, gl.UNSIGNED_BYTE, null );
            fb.renderbuffer = gl.createRenderbuffer();
            gl.bindRenderbuffer( gl.RENDERBUFFER, fb.renderbuffer );
            gl.renderbufferStorage( gl.RENDERBUFFER, gl.DEPTH_COMPONENT16, fb.width, fb.height );
            gl.framebufferTexture2D( gl.FRAMEBUFFER, gl.COLOR_ATTACHMENT0, gl.TEXTURE_2D, fb.color0_texture, 0 );
            gl.framebufferRenderbuffer( gl.FRAMEBUFFER, gl.DEPTH_ATTACHMENT, gl.RENDERBUFFER, fb.renderbuffer );
            gl.bindTexture( gl.TEXTURE_2D, null );
            gl.bindRenderbuffer( gl.RENDERBUFFER, null );
            gl.bindFramebuffer( gl.FRAMEBUFFER, null );
            blurFB.push( fb );
        }
    }
    
    function Fract( val ) { 
        return val - Math.trunc( val );
    }
    function CalcAng( deltaTime, intervall ) {
        return Fract( deltaTime / (1000*intervall) ) * 2.0 * Math.PI;
    }
    function CalcMove( deltaTime, intervall, range ) {
        var pos = self.Fract( deltaTime / (1000*intervall) ) * 2.0
        var pos = pos < 1.0 ? pos : (2.0-pos)
        return range[0] + (range[1] - range[0]) * pos;
    }    
    function EllipticalPosition( a, b, angRag ) {
        var a_b = a * a - b * b
        var ea = (a_b <= 0) ? 0 : Math.sqrt( a_b );
        var eb = (a_b >= 0) ? 0 : Math.sqrt( -a_b );
        return [ a * Math.sin( angRag ) - ea, b * Math.cos( angRag ) - eb, 0 ];
    }
    
    function IdentM44() {
        return [ 1, 0, 0, 0,    0, 1, 0, 0,    0, 0, 1, 0,    0, 0, 0, 1 ];
    };
    
    function RotateAxis(matA, angRad, axis) {
        var aMap = [ [1, 2], [2, 0], [0, 1] ];
        var a0 = aMap[axis][0], a1 = aMap[axis][1]; 
        var sinAng = Math.sin(angRad), cosAng = Math.cos(angRad);
        var matB = matA.slice(0);
        for ( var i = 0; i < 3; ++ i ) {
            matB[a0*4+i] = matA[a0*4+i] * cosAng + matA[a1*4+i] * sinAng;
            matB[a1*4+i] = matA[a0*4+i] * -sinAng + matA[a1*4+i] * cosAng;
        }
        return matB;
    }
    
    function Rotate(matA, angRad, axis) {
        var s = Math.sin(angRad), c = Math.cos(angRad);
        var x = axis[0], y = axis[1], z = axis[2]; 
        matB = [
            x*x*(1-c)+c,   x*y*(1-c)-z*s, x*z*(1-c)+y*s, 0,
            y*x*(1-c)+z*s, y*y*(1-c)+c,   y*z*(1-c)-x*s, 0,
            z*x*(1-c)-y*s, z*y*(1-c)+x*s, z*z*(1-c)+c,   0,
            0,             0,             0,             1 ];
        return Multiply(matA, matB);
    }    
    
    function Multiply(matA, matB) {
        matC = IdentM44();
        for (var i0=0; i0<4; ++i0 )
            for (var i1=0; i1<4; ++i1 )
                matC[i0*4+i1] = matB[i0*4+0] * matA[0*4+i1] + matB[i0*4+1] * matA[1*4+i1] + matB[i0*4+2] * matA[2*4+i1] + matB[i0*4+3] * matA[3*4+i1]  
        return matC;
    }
    
    function Cross( a, b ) { return [ a[1] * b[2] - a[2] * b[1], a[2] * b[0] - a[0] * b[2], a[0] * b[1] - a[1] * b[0], 0.0 ]; }
    function Dot( a, b ) { return a[0]*b[0] + a[1]*b[1] + a[2]*b[2]; }
    function Normalize( v ) {
        var len = Math.sqrt( v[0] * v[0] + v[1] * v[1] + v[2] * v[2] );
        return [ v[0] / len, v[1] / len, v[2] / len ];
    }
    
    Camera = function( pos, target, up, fov_y, vp, near, far ) {
    this.Time = function() { return Date.now(); }
    this.pos = pos;
    this.target = target;
    this.up = up;
    this.fov_y = fov_y;
    this.vp = vp;
    this.near = near;
    this.far = far;
    this.orbit_mat = this.current_orbit_mat = this.model_mat = this.current_model_mat = IdentM44();
    this.mouse_drag = this.auto_spin = false;
    this.auto_rotate = true;
    this.mouse_start = [0, 0];
    this.mouse_drag_axis = [0, 0, 0];
    this.mouse_drag_angle = 0;
    this.mouse_drag_time = 0;
    this.drag_start_T = this.rotate_start_T = this.Time();
    this.Ortho = function() {
        var fn = this.far + this.near;
        var f_n = this.far - this.near;
        var w = this.vp[0];
        var h = this.vp[1];
        return [
            2/w, 0,   0,       0,
            0,   2/h, 0,       0,
            0,   0,   -2/f_n,  0,
            0,   0,   -fn/f_n, 1 ];
    };  
    this.Perspective = function() {
        var n = this.near;
        var f = this.far;
        var fn = f + n;
        var f_n = f - n;
        var r = this.vp[0] / this.vp[1];
        var t = 1 / Math.tan( Math.PI * this.fov_y / 360 );
        return [
            t/r, 0, 0,          0,
            0,   t, 0,          0,
            0,   0, -fn/f_n,   -1,
            0,   0, -2*f*n/f_n, 0 ];
    }; 
    this.LookAt = function() {
        var mz = Normalize( [ this.pos[0]-this.target[0], this.pos[1]-this.target[1], this.pos[2]-this.target[2] ] );
        var mx = Normalize( Cross( this.up, mz ) );
        var my = Normalize( Cross( mz, mx ) );
        var tx = Dot( mx, this.pos );
        var ty = Dot( my, this.pos );
        var tz = Dot( [-mz[0], -mz[1], -mz[2]], this.pos ); 
        return [mx[0], my[0], mz[0], 0, mx[1], my[1], mz[1], 0, mx[2], my[2], mz[2], 0, tx, ty, tz, 1]; 
    };
    this.Orbit = function() {
        return Multiply(this.LookAt(), this.OrbitMatrix());
    }; 
    this.OrbitMatrix = function() {
        return (this.mouse_drag || (this.auto_rotate && this.auto_spin)) ? Multiply(this.current_orbit_mat, this.orbit_mat) : this.orbit_mat;
    };
    this.AutoModelMatrix = function() {
        return this.auto_rotate ? Multiply(this.current_model_mat, this.model_mat) : this.model_mat;
    };
    this.Update = function(vp_size) {
        if (vp_size)
            this.vp = vp_size;
        var current_T = this.Time();
        this.current_model_mat = IdentM44()
        if (this.mouse_drag) {
            this.current_orbit_mat = Rotate(IdentM44(), this.mouse_drag_angle, this.mouse_drag_axis);
        } else if (this.auto_rotate) {
            if (this.auto_spin ) {
                if (this.mouse_drag_time > 0 ) {
                    var angle = this.mouse_drag_angle * (current_T - this.rotate_start_T) / this.mouse_drag_time;
                    this.current_orbit_mat = Rotate(IdentM44(), angle, this.mouse_drag_axis);
                }
            } else {
                var auto_angle_x = Fract( (current_T - this.rotate_start_T) / 13000.0 ) * 2.0 * Math.PI;
                var auto_angle_y = Fract( (current_T - this.rotate_start_T) / 17000.0 ) * 2.0 * Math.PI;
                this.current_model_mat = RotateAxis( this.current_model_mat, auto_angle_x, 0 );
                this.current_model_mat = RotateAxis( this.current_model_mat, auto_angle_y, 1 );
            }
        }
    };
    this.ChangeMotionMode = function(drag, spin, auto ) {
        var new_drag = drag;
        var new_auto = new_drag ? false : auto;
        var new_spin = new_auto ? spin : false;
        change = this.mouse_drag != new_drag || this.auto_rotate != new_auto || this.auto_spin != new_spin; 
        if (!change)
            return;
        if (new_drag && !this.mouse_drag) {
            this.drag_start_T = this.Time();
            this.mouse_drag_angle = 0.0;
            this.mouse_drag_time = 0;
        }
        if (new_auto && !this.auto_rotate)
            this.rotate_start_T = this.Time();
        this.mouse_drag = new_drag; 
        this.auto_rotate = new_auto;  
        this.auto_spin = new_spin;
        this.orbit_mat = Multiply(this.current_orbit_mat, this.orbit_mat);
        this.current_orbit_mat = IdentM44();
        this.model_mat = Multiply(this.current_model_mat, this.model_mat);
        this.current_model_mat = IdentM44();
    };
    this.OnMouseDown = function( event ) {
        var rect = gl.canvas.getBoundingClientRect();
        if ( event.clientX < rect.left || event.clientX > rect.right ) return;
        if ( event.clientY < rect.top || event.clientY > rect.bottom ) return;
        if (event.button == 0) { // left button
            this.mouse_start = [event.clientX, event.clientY]; 
            this.ChangeMotionMode( true, false, false );
        }
    };
    this.OnMouseUp = function( event ) {
        if (event.button == 0) { // left button
            this.ChangeMotionMode( false, true, true );
        } else if (event.button == 1) {// middle button
            this.ChangeMotionMode( false, false, !this.auto_rotate );
        }
    };
    this.OnMouseMove = function( event ) {
        var dx = (event.clientX-this.mouse_start[0]) / this.vp[0];
        var dy = (event.clientY-this.mouse_start[1]) / this.vp[1];
        var len = Math.sqrt(dx*dx + dy*dy);
        if (this.mouse_drag && len > 0) {
            this.mouse_drag_angle = Math.PI*len;
            this.mouse_drag_axis = [dy/len, 0, -dx/len];
            this.mouse_drag_time = this.Time() - this.drag_start_T;
        }
    };
    
    this.domElement = document;
    var cam = this;
    //this.domElement.addEventListener( 'contextmenu', function(e) { event.preventDefault(); }, false );
    this.domElement.addEventListener( 'mousedown', function(e) { cam.OnMouseDown(e) }, false );
    this.domElement.addEventListener( 'mouseup', function(e) { cam.OnMouseUp(e) }, false );
    this.domElement.addEventListener( 'mousemove', function(e) { cam.OnMouseMove(e) }, false );
    //this.domElement.addEventListener( 'mousewheel', hid_events.onMouseWheel, false );
    //this.domElement.addEventListener( 'DOMMouseScroll', hid_events.onMouseWheel, false ); // firefox
    }
    
    var ShProg = {};
    ShProg.Create = function( shaderList ) {
        var shaderObjs = [];
        for ( var i_sh = 0; i_sh < shaderList.length; ++ i_sh ) {
            var shderObj = this.Compile( shaderList[i_sh].source, shaderList[i_sh].stage );
            if ( shderObj == 0 )
                return 0;
            shaderObjs.push( shderObj );
        }
        var progObj = this.Link( shaderObjs )
        if ( progObj != 0 ) {
            progObj.attrInx = {};
            var noOfAttributes = gl.getProgramParameter( progObj, gl.ACTIVE_ATTRIBUTES );
            for ( var i_n = 0; i_n < noOfAttributes; ++ i_n ) {
                var name = gl.getActiveAttrib( progObj, i_n ).name;
                progObj.attrInx[name] = gl.getAttribLocation( progObj, name );
            }
            progObj.uniLoc = {};
            var noOfUniforms = gl.getProgramParameter( progObj, gl.ACTIVE_UNIFORMS );
            for ( var i_n = 0; i_n < noOfUniforms; ++ i_n ) {
                var name = gl.getActiveUniform( progObj, i_n ).name;
                progObj.uniLoc[name] = gl.getUniformLocation( progObj, name );
            }
        }
        return progObj;
    }
    ShProg.AttrI = function( progObj, name ) { return progObj.attrInx[name]; } 
    ShProg.UniformL = function( progObj, name ) { return progObj.uniLoc[name]; } 
    ShProg.Use = function( progObj ) { gl.useProgram( progObj ); } 
    ShProg.SetI1  = function( progObj, name, val ) { if(progObj.uniLoc[name]) gl.uniform1i( progObj.uniLoc[name], val ); }
    ShProg.SetF1  = function( progObj, name, val ) { if(progObj.uniLoc[name]) gl.uniform1f( progObj.uniLoc[name], val ); }
    ShProg.SetF2  = function( progObj, name, arr ) { if(progObj.uniLoc[name]) gl.uniform2fv( progObj.uniLoc[name], arr ); }
    ShProg.SetF3  = function( progObj, name, arr ) { if(progObj.uniLoc[name]) gl.uniform3fv( progObj.uniLoc[name], arr ); }
    ShProg.SetF4  = function( progObj, name, arr ) { if(progObj.uniLoc[name]) gl.uniform4fv( progObj.uniLoc[name], arr ); }
    ShProg.SetM33 = function( progObj, name, mat ) { if(progObj.uniLoc[name]) gl.uniformMatrix3fv( progObj.uniLoc[name], false, mat ); }
    ShProg.SetM44 = function( progObj, name, mat ) { if(progObj.uniLoc[name]) gl.uniformMatrix4fv( progObj.uniLoc[name], false, mat ); }
    ShProg.Compile = function( source, shaderStage ) {
        var shaderScript = document.getElementById(source);
        if (shaderScript)
        source = shaderScript.text;
        var shaderObj = gl.createShader( shaderStage );
        gl.shaderSource( shaderObj, source );
        gl.compileShader( shaderObj );
        var status = gl.getShaderParameter( shaderObj, gl.COMPILE_STATUS );
        if ( !status ) alert(gl.getShaderInfoLog(shaderObj));
        return status ? shaderObj : null;
    } 
    ShProg.Link = function( shaderObjs ) {
        var prog = gl.createProgram();
        for ( var i_sh = 0; i_sh < shaderObjs.length; ++ i_sh )
            gl.attachShader( prog, shaderObjs[i_sh] );
        gl.linkProgram( prog );
        status = gl.getProgramParameter( prog, gl.LINK_STATUS );
        if ( !status ) alert("Could not initialise shaders");
        gl.useProgram( null );
        return status ? prog : null;
    }
    
    var VertexBuffer = {
    Create: function(attribs, indices) {
        var buffer = { buf: [], attr: [], inx: gl.createBuffer(), inxLen: indices.length };
        for (var i=0; i
    html,body { margin: 0; overflow: hidden; }
    #gui { position : absolute; top : 0; left : 0; }
    
    
    
    
    
    
    
    
    
    radius
    blur

提交回复
热议问题