var gl;
var canvas;

var startTime;
var currentTime;

var testPlaneObject;

function initWebGl()
{
    gl = null;
    try
    {
        gl = canvas.getContext("experimental-webgl");
    }
    catch (e)
    {
    }

	if (!gl)
		alert("ARG NO WEBGL");
}

function start()
{
    canvas = document.getElementById("glcanvas");

	canvas.width = window.innerWidth;
	canvas.height = window.innerHeight;


    initWebGl();

	if (gl)
	{
		window.onresize = function()
		{
			canvas.width = window.innerWidth;
			canvas.height = window.innerHeight;

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


		gl.clearColor(0.2, .05, .01, 1.0);
		gl.clearDepth(1.0);
		gl.enable(gl.DEPTH_TEST);
		gl.depthFunc(gl.LEQUAL);
		gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);

		initializeScene();
		setInterval(drawScene, 30);
	}

	startTime = (new Date).getTime();
}

function initializeScene()
{
	testPlaneObject = null;

	jQuery.ajax({ url: "./skewplane.json", dataType: "text" })
		.success(function(data) { loadPlaneObject(data); })
		.error(function() { alert("Data load error!"); })
}

function loadPlaneObject(data)
{
	testPlaneSourceData = eval('('+data+')');

	var loadPlaneObject = new Object();
	loadPlaneObject.sourceData = testPlaneSourceData;
	
	loadPlaneObject.vertexBuffer = gl.createBuffer();
	gl.bindBuffer(gl.ARRAY_BUFFER, loadPlaneObject.vertexBuffer);
	gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(testPlaneSourceData.vertices), gl.STATIC_DRAW);

	loadPlaneObject.normalBuffer = gl.createBuffer();
	gl.bindBuffer(gl.ARRAY_BUFFER, loadPlaneObject.normalBuffer);
	gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(testPlaneSourceData.normals), gl.STATIC_DRAW);

	loadPlaneObject.uvBuffer = gl.createBuffer();
	gl.bindBuffer(gl.ARRAY_BUFFER, loadPlaneObject.uvBuffer);
	gl.bufferData(gl.ARRAY_BUFFER, new Float32Array(testPlaneSourceData.uvs), gl.STATIC_DRAW);

	loadPlaneObject.indexBuffer = gl.createBuffer();
	gl.bindBuffer(gl.ELEMENT_ARRAY_BUFFER, loadPlaneObject.indexBuffer);
	gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Int16Array(testPlaneSourceData.indices), gl.STATIC_DRAW);

	var vertexShader = gl.createShader(gl.VERTEX_SHADER);
	gl.shaderSource(vertexShader, testPlaneSourceData.vshader);
	gl.compileShader(vertexShader);

	if (!gl.getShaderParameter(vertexShader, gl.COMPILE_STATUS))
	{
		alert("Vertex Shader compilation error: "+gl.getShaderInfoLog(vertexShader));
		return;
	}

	var pixelShader = gl.createShader(gl.FRAGMENT_SHADER);
	gl.shaderSource(pixelShader, testPlaneSourceData.pshader);
	gl.compileShader(pixelShader);

	if (!gl.getShaderParameter(pixelShader, gl.COMPILE_STATUS))
	{
		alert("Pixel Shader compilation error: "+gl.getShaderInfoLog(pixelShader));
		return;
	}	

	loadPlaneObject.shaderProgram = gl.createProgram();
	gl.attachShader(loadPlaneObject.shaderProgram, vertexShader);
	gl.attachShader(loadPlaneObject.shaderProgram, pixelShader);
	gl.linkProgram(loadPlaneObject.shaderProgram);

	if (!gl.getProgramParameter(loadPlaneObject.shaderProgram, gl.LINK_STATUS))
	{
		alert("Unable to initialize shader program.");
		return;
	}

	gl.useProgram(loadPlaneObject.shaderProgram);
	testPlaneSourceData.init(loadPlaneObject);
	loadPlaneObject.vertexAttribPosition = gl.getAttribLocation(loadPlaneObject.shaderProgram, "inVertex");
	loadPlaneObject.normalAttribPosition = gl.getAttribLocation(loadPlaneObject.shaderProgram, "inNormal");
	loadPlaneObject.uvAttribPosition = gl.getAttribLocation(loadPlaneObject.shaderProgram, "inUv")

	testPlaneObject = loadPlaneObject;
}

function drawScene()
{
	gl.clear(gl.COLOR_BUFFER_BIT | gl.DEPTH_BUFFER_BIT);

	var newTime = (new Date).getTime();
	var delta = 0;
	if (currentTime)
		delta = newTime - currentTime;
	currentTime = newTime;
		
	if (testPlaneObject != null)
	{
		gl.useProgram(testPlaneObject.shaderProgram);

		gl.bindBuffer(gl.ARRAY_BUFFER, testPlaneObject.vertexBuffer);
		gl.enableVertexAttribArray(testPlaneObject.vertexAttribPosition);
		gl.vertexAttribPointer(testPlaneObject.vertexAttribPosition, 3, gl.FLOAT, false, 0, 0);

		gl.bindBuffer(gl.ARRAY_BUFFER, testPlaneObject.normalBuffer);
		gl.enableVertexAttribArray(testPlaneObject.normalAttribPosition);
		gl.vertexAttribPointer(testPlaneObject.normalAttribPosition, 3, gl.FLOAT, false, 0, 0);

		gl.bindBuffer(gl.ARRAY_BUFFER, testPlaneObject.uvBuffer);
		gl.enableVertexAttribArray(testPlaneObject.uvAttribPosition);
		gl.vertexAttribPointer(testPlaneObject.uvAttribPosition, 2, gl.FLOAT, false, 0, 0);

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

		var timeSinceStart = (currentTime - startTime);
		testPlaneObject.sourceData.draw(testPlaneObject, gl, timeSinceStart);

//		gl.disable(gl.CULL_FACE);

		gl.drawElements(gl.TRIANGLES, 6, gl.UNSIGNED_SHORT, 0);
//		gl.drawArrays(gl.TRIANGLES, 0, 4);
	}

	gl.finish();

}

function loadTexture(filename)
{
	var tex = gl.createTexture();
	var img = new Image();
	img.onload = function()
	{
		gl.bindTexture(gl.TEXTURE_2D, tex);
		gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, img);
		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
		gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR_MIPMAP_NEAREST);
		gl.generateMipmap(gl.TEXTURE_2D);
		gl.bindTexture(gl.TEXTURE_2D, null);
	}
	img.src = filename;
	return tex;

}