minimal AMD module directly wrapping webgl shaders

glsl.js

//A minimal wrapper around WebGL Shaders
//takes the vertexShader and fragmentShader as plain-text
//**basic use:**
//
//		shaderProgram = glsl( gl )
//			.createProgram(vertexShader, fragmentShader)
//			.attributes({
//				"vertexPositionAttribute" : 'aVertexPosition',
//				'vertexColorAttribute' : 'aVertexColor'
//			})
//			.uniforms({
//				'pMatrixUniform' : 'uPMatrix',
//				'mvMatrixUniform' : 'uMVMatrix'
//			});

define(function(){
	return function( gl ){

		var exports = {};
		var createShader = function( shaderSource, type ){
			var shader = gl.createShader( type );
			gl.shaderSource( shader, shaderSource );
			gl.compileShader( shader );

			if( !gl.getShaderParameter(shader, gl.COMPILE_STATUS)) {
				throw Error( gl.getShaderInfoLog(shader) );
			}
			return shader;
		};

		//apply attributes shader variables
		exports.applyAttributes = function( shaderProgram, attributes ){
			var prop = "";
			for( prop in attributes ){
				shaderProgram[prop] = gl.getAttribLocation( shaderProgram, attributes[prop] );
				gl.enableVertexAttribArray(shaderProgram[prop]);
			}
			return exports;
		};
		//apply uniform shader variables
		exports.applyUniforms = function( shaderProgram, uniforms ){
			if ( shaderProgram.uniformsCache === undefined ){
				shaderProgram.uniformsCache = {};
			}
			for( var prop in uniforms ){
				shaderProgram[prop] = gl.getUniformLocation( shaderProgram, uniforms[prop] );
				shaderProgram.uniformsCache[ prop ] = gl.getUniformLocation( shaderProgram, uniforms[prop] );
			}
			return exports;
		};


		//create shader program
		//####prog = glsl(gl).createProgresm( vertShad, fragShad, attribs, uniforms)
		//where **vertShad** and **fragShad** are the plain-text shaders
		//returned shader object can be used like:
		//
		//		prog.attributes({}).uniforms({}).use().del()
		exports.createProgram = function( vs, fs, attributes, uniforms, optCallback ){
			var frag, vert, shaderProgram;
			
			try {
				frag = createShader(fs, gl.FRAGMENT_SHADER);
				vert = createShader(vs, gl.VERTEX_SHADER);
			} catch( e ){
				if( optCallback ){
					optCallback( e );
				} else {
					console.error( e );
				}
				return;
			}
			shaderProgram = gl.createProgram();
				
			//attach shaders to shaderProgram
			gl.attachShader( shaderProgram, vert );
			gl.attachShader( shaderProgram, frag );
			//link program to gpu
			gl.linkProgram( shaderProgram );

			if( !gl.getProgramParameter( shaderProgram, gl.LINK_STATUS) ){
				var err = Error("Could not initialize shaders");
				if( optCallback ){
					optCallback( err );
				} else {
					console.error( err );
				}
			}
			
			//set as a part of current OpenGL state
			gl.useProgram( shaderProgram );
			//set attributes on the shader program
			shaderProgram.attributes = function( attributes ){
				exports.applyAttributes( shaderProgram, attributes );
				return shaderProgram;
			};
			//set uniforms on the shader program
			shaderProgram.uniforms = function( uniforms ){
				exports.applyUniforms( shaderProgram, uniforms );
				return shaderProgram;
			};
			//use this shader program
			shaderProgram.use = function(){
				gl.useProgram( shaderProgram );
				return shaderProgram;
			};
			//delete this shader program
			shaderProgram.del = function(){
				gl.deleteProgram( shaderProgram );
			};
			exports.applyAttributes( shaderProgram, attributes );
			exports.applyUniforms( shaderProgram, uniforms );

			if( optCallback ){
				optCallback( null, shaderProgram );
			}
			return shaderProgram;
		};

		return exports;
	};
});