function Context(canvas)

{

    this.canvas = canvas;

    try 

    {

	this.gl = canvas.getContext("experimental-webgl");

	this.viewport = {'width': canvas.width,

			 'height': canvas.height};

    } 

    catch(e) 

    {

	alert(e);

    }

    if (!this.gl) alert("Failed: WebGL init.");

    this.mvMatrix = mat4.create();

    this.pMatrix = mat4.create();

    this.shader = new Shader(this);  

}

Context.prototype.updateMatrixUniforms = function()

{

    var gl = this.gl;

    var program = this.shader;

    var pMatrix = this.pMatrix;

    var mvMatrix = this.mvMatrix;

    gl.uniformMatrix4fv(program.pMatrixUniform, false, pMatrix);

    gl.uniformMatrix4fv(program.mvMatrixUniform, false, mvMatrix);

    var normalMatrix = mat3.create();

    mat4.toInverseMat3(mvMatrix, normalMatrix);

    mat3.transpose(normalMatrix);

    gl.uniformMatrix3fv(program.nMatrixUniform, false, normalMatrix);

}

Context.prototype.expand = function()

{ 

    var width = window.innerWidth;

    var height = window.innerHeight;

    this.canvas.width = width;

    this.canvas.height = height;

    this.viewport.width = width;

    this.viewport.height = height;

}

function Shader(context)

{

    var gl = context.gl;

    var fragment = loadShader(gl, "fragment-shader");

    var vertex = loadShader(gl, "vertex-shader");

    this.program = gl.createProgram();

    gl.attachShader(this.program, vertex);

    gl.attachShader(this.program, fragment);

    gl.linkProgram(this.program);

    if (!gl.getProgramParameter(this.program, gl.LINK_STATUS))

    {

	alert("Failed: Shader init.");

    }

    gl.useProgram(this.program);

    this.vertexPosition = gl.getAttribLocation(this.program, "aVertexPosition");

    gl.enableVertexAttribArray(this.vertexPosition);

    this.vertexNormal = gl.getAttribLocation(this.program, "aVertexNormal");

    gl.enableVertexAttribArray(this.vertexNormal);

    this.vertexColour = gl.getAttribLocation(this.program, "aVertexColour");

    gl.enableVertexAttribArray(this.vertexColour);    

    this.textureCoord = gl.getAttribLocation(this.program, "aTextureCoord");

    gl.enableVertexAttribArray(this.textureCoord);

    this.pMatrixUniform = gl.getUniformLocation(this.program, "uPMatrix");

    this.mvMatrixUniform = gl.getUniformLocation(this.program, "uMVMatrix");    

    this.nMatrixUniform = gl.getUniformLocation(this.program, "uNMatrix");

    this.samplerUniform = gl.getUniformLocation(this.program, "uSampler");

    this.materialShininessUniform = gl.getUniformLocation(this.program, "uMaterialShininess");

    this.useLightingUniform = gl.getUniformLocation(this.program, "uUseLighting");

    this.useTexture = gl.getUniformLocation(this.program, "uUseTexture");

    this.ambientColourUniform = gl.getUniformLocation(this.program, "uAmbientColour");

    this.lightingDirectionUniform = gl.getUniformLocation(this.program, "uLightingDirection");

    this.directionalColourUniform = gl.getUniformLocation(this.program, "uDirectionalColour");

    this.pointLightingLocationUniform = gl.getUniformLocation(this.program, "uPointLightingLocation");

    this.pointLightingSpecularColourUniform = gl.getUniformLocation(this.program, "uPointLightingSpecularColour");

    this.pointLightingDiffuseColourUniform = gl.getUniformLocation(this.program, "uPointLightingDiffuseColour");

    function loadShader(gl, id)

    {

	var script = document.getElementById(id);

	if (!script) return null;

	var str = "";

	var child = script.firstChild;

	while (child)

	{

	    if (child.nodeType == 3) str += child.textContent;

	    child = child.nextSibling;

	}

	var shader;

	var common = "x-shader/x-";

	if (script.type == common + "fragment") shader = gl.createShader(gl.FRAGMENT_SHADER);

	else if (script.type == common + "vertex") shader = gl.createShader(gl.VERTEX_SHADER);

	else return null;

	gl.shaderSource(shader, str);

	gl.compileShader(shader);

	if (!gl.getShaderParameter(shader, gl.COMPILE_STATUS))

        {

	    alert(gl.getShaderInfoLog(shader));

	    return null;

	}

	return shader;

    }

}

function Renderer(camera, context)

{

    this.camera = camera;

    this.context = context;

    this.gl = context.gl;

    this.matrixStack = [];

}

Renderer.prototype.update = function(scene)

{ 

    var gl = this.context.gl; 

    var shader = this.context.shader;

    var viewport = this.context.viewport;

    var mvMatrix = this.context.mvMatrix;

    var pMatrix = this.context.pMatrix;

    var camera = this.camera;

    gl.viewport(0, 0, viewport.width, viewport.height);

    gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);

    mat4.perspective(45, viewport.width / viewport.height, 0.1, 1000.0, pMatrix);

    var lighting = true;

    gl.uniform1i(shader.useLightingUniform, lighting);

    gl.uniform1f(shader.materialShininessUniform, 20.0);

    if (lighting)

    {   

	var uni = 0.0;

	gl.uniform3f(shader.ambientColourUniform, uni, uni, uni);

	var pos = [0, 0, 0];

	gl.uniform3f(shader.pointLightingLocationUniform, pos[0], pos[1], pos[2]);

	uni = 1.0;

	gl.uniform3f(shader.pointLightingSpecularColourUniform, uni, uni, uni);

	uni = .07;

	gl.uniform3f(shader.pointLightingDiffuseColourUniform, uni, uni, uni);

	// var lightingDir = vec3.create();

	// vec3.add(lightingDir, [0.5, -0.5, 0.0]);

	// vec3.normalize(lightingDir);

	// vec3.scale(lightingDir, -1);     

	// gl.uniform3fv(shader.lightingDirectionUniform, lightingDir);

	// uni = 0.9;

	// var directional =  {"r": uni, "g": uni, "b": uni};

	// gl.uniform3f(shader.directionalColourUniform, directional.r, directional.g, directional.b);

    }

    mat4.identity(mvMatrix);

    mat4.multiply(mvMatrix, camera.matrix); 

    this.draw(scene);

    if (this.next) this.next.update(scene);

}

Renderer.prototype.draw = function(node)

{

    var gl = this.context.gl;

    var shader = this.context.shader;

    var mvMatrix = this.context.mvMatrix;

    var pMatrix = this.context.pMatrix;

    if (node)

    {

	this.pushMatrix(mvMatrix);

	mat4.translate(mvMatrix, node.pos);

	//mat4.rotate(mvMatrix, node.rot);

	//mat4.multiply(mvMatrix, node.matrix);

	var geometry = node.geometry;

	if (geometry)

	{

	    var object = geometry.vbo;

	    gl.bindBuffer(gl.ARRAY_BUFFER, object.positionBuffer);

	    gl.vertexAttribPointer(shader.vertexPosition, object.positionBuffer.itemSize, gl.FLOAT, false, 0, 0);

	    gl.bindBuffer(gl.ARRAY_BUFFER, object.normalBuffer);

	    gl.vertexAttribPointer(shader.vertexNormal, object.normalBuffer.itemSize, gl.FLOAT, false, 0, 0);

	    gl.bindBuffer(gl.ARRAY_BUFFER, object.textureCoordBuffer);

	    gl.vertexAttribPointer(shader.textureCoord, object.textureCoordBuffer.itemSize, gl.FLOAT, false, 0, 0);

	    gl.activeTexture(gl.TEXTURE0);

	    if (object.texture && object.useTexture)

	    {

		gl.uniform1i(shader.useTexture, true);

		gl.bindTexture(gl.TEXTURE_2D, object.texture.hnd);

		gl.uniform1i(shader.samplerUniform, 0);

	    }

	    else

	    {

		gl.uniform1i(shader.useTexture, false);

	    }

	    gl.bindBuffer(gl.ARRAY_BUFFER, object.colourBuffer);

	    gl.vertexAttribPointer(shader.vertexColour, object.colourBuffer.itemSize, gl.FLOAT, false, 0, 0);

	    gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, object.indexBuffer);

	    this.context.updateMatrixUniforms();

	    gl.drawElements(gl.TRIANGLES, object.indexBuffer.numItems, gl.UNSIGNED_SHORT, 0);

	    //gl.drawArrays(gl.TRIANGLE_STRIP, 0, scene.positionBuffer.numItems);

	}

	for (var id in node.children)

	{

	    this.mvMatrix = mvMatrix;

	    this.draw(node.children[id]);

	}

	this.context.mvMatrix = this.popMatrix();

    }

}

Renderer.prototype.pushMatrix = function(matrix)

{

    var copy = mat4.create();

    mat4.set(matrix, copy);

    this.matrixStack.push(copy);

}

Renderer.prototype.popMatrix = function()    

{

    if (this.matrixStack.length > 0) return this.matrixStack.pop();

}