function main()

 {

     var canvas = document.getElementById("machine");

     var context = new Context(canvas);

     var gl = context.gl;

     context.object = new Box(1, context);

     gl.clearColor(0.0, 0.0, 0.0, 1.0);

     gl.enable(gl.DEPTH_TEST);

     draw(context);

 }

 function Context(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.program;

     var pMatrix = this.pMatrix;

     var mvMatrix = this.mvMatrix;

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

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

 }

 function Shader(context)

 {

     var gl = context.gl;

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

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

     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.pMatrixUniform = gl.getUniformLocation(this.program, "uPMatrix");

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

     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 Box(size, context)

 {

     var gl = context.gl;

     this.size = size || 1;

     this.buffer = gl.createBuffer();

     gl.bindBuffer(gl.ARRAY_BUFFER, this.buffer);

     var vertices = [1.0, 1.0, 0.0,

 		    -1.0, 1.0, 0.0,

 		    1.0, -1.0, 0.0,

 		    -1.0, -1.0, 0.0];

     gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(vertices), gl.STATIC_DRAW);

     this.itemSize = 3;

     this.numItems = 4;

 }

 function draw(context)

 {

     var gl = context.gl;

     var viewport = context.viewport;

     var shader = context.shader;

     var mvMatrix = context.mvMatrix;

     var pMatrix = context.pMatrix;

     var object = context.object;

     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, 100.0, pMatrix);

     mat4.identity(mvMatrix);

     mat4.translate(mvMatrix, [0.0, 0.0, -7.0]);

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

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

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

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

     //context.updateMatrixUniforms();

     gl.drawArrays(gl.TRIANGLE_STRIP, 0, object.numItems);

     return context;

 } 

 function drawScene(context) {

         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, 100.0, pMatrix);

         mat4.identity(mvMatrix); 

         mat4.translate(mvMatrix, [0.0, 0.0, -7.0]);

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

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

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

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

         gl.drawArrays(gl.TRIANGLE_STRIP, 0, object.numItems);

     }