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);

    }