Phaser Source: src/pixi/renderers/webgl/shaders/StripShader.js

# Source: src/pixi/renderers/webgl/shaders/StripShader.js

    /**
     * @author Mat Groves http://matgroves.com/ @Doormat23
     */

    /**
    * @class StripShader
    * @constructor
    * @param gl {WebGLContext} the current WebGL drawing context
    */
    PIXI.StripShader = function(gl)
    {
        /**
         * @property _UID
         * @type Number
         * @private
         */
        this._UID = PIXI._UID++;

        /**
         * @property gl
         * @type WebGLContext
         */
        this.gl = gl;

        /**
         * The WebGL program.
         * @property program
         * @type Any
         */
        this.program = null;

        /**
         * The fragment shader.
         * @property fragmentSrc
         * @type Array
         */
        this.fragmentSrc = [
            'precision mediump float;',
            'varying vec2 vTextureCoord;',
         //   'varying float vColor;',
            'uniform float alpha;',
            'uniform sampler2D uSampler;',

            'void main(void) {',
            '   gl_FragColor = texture2D(uSampler, vec2(vTextureCoord.x, vTextureCoord.y)) * alpha;',
          //  '   gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);',//gl_FragColor * alpha;',
            '}'
        ];

        /**
         * The vertex shader.
         * @property vertexSrc
         * @type Array
         */
        this.vertexSrc  = [
            'attribute vec2 aVertexPosition;',
            'attribute vec2 aTextureCoord;',
            'uniform mat3 translationMatrix;',
            'uniform vec2 projectionVector;',
            'uniform vec2 offsetVector;',
          //  'uniform float alpha;',
           // 'uniform vec3 tint;',
            'varying vec2 vTextureCoord;',
          //  'varying vec4 vColor;',

            'void main(void) {',
            '   vec3 v = translationMatrix * vec3(aVertexPosition , 1.0);',
            '   v -= offsetVector.xyx;',
            '   gl_Position = vec4( v.x / projectionVector.x -1.0, v.y / -projectionVector.y + 1.0 , 0.0, 1.0);',
            '   vTextureCoord = aTextureCoord;',
           // '   vColor = aColor * vec4(tint * alpha, alpha);',
            '}'
        ];

        this.init();
    };

    PIXI.StripShader.prototype.constructor = PIXI.StripShader;

    /**
    * Initialises the shader.
    *
    * @method init
    */
    PIXI.StripShader.prototype.init = function()
    {
        var gl = this.gl;

        var program = PIXI.compileProgram(gl, this.vertexSrc, this.fragmentSrc);
        gl.useProgram(program);

        // get and store the uniforms for the shader
        this.uSampler = gl.getUniformLocation(program, 'uSampler');
        this.projectionVector = gl.getUniformLocation(program, 'projectionVector');
        this.offsetVector = gl.getUniformLocation(program, 'offsetVector');
        this.colorAttribute = gl.getAttribLocation(program, 'aColor');
        //this.dimensions = gl.getUniformLocation(this.program, 'dimensions');

        // get and store the attributes
        this.aVertexPosition = gl.getAttribLocation(program, 'aVertexPosition');
        this.aTextureCoord = gl.getAttribLocation(program, 'aTextureCoord');

        this.attributes = [this.aVertexPosition, this.aTextureCoord];

        this.translationMatrix = gl.getUniformLocation(program, 'translationMatrix');
        this.alpha = gl.getUniformLocation(program, 'alpha');

        this.program = program;
    };

    /**
    * Destroys the shader.
    *
    * @method destroy
    */
    PIXI.StripShader.prototype.destroy = function()
    {
        this.gl.deleteProgram( this.program );
        this.uniforms = null;
        this.gl = null;

        this.attribute = null;
    };