v1.0.1 commit.

This is the first commit.

Author: BKcore

README.md

@@ -1,4 +1,22 @@
 HexGL
-=====
+=========
 
-Source code of HexGL, the futuristic HTML5 racing game by Thibaut Despoulain (me)
+Source code of [HexGL](http://hexgl.bkcore.com), the futuristic HTML5 racing game by [Thibaut Despoulain](http://bkcore.com)
+
+## License
+
+Unless specified in the file, HexGL's code and resources are licensed under the *Creative Commons Attribution-NonCommercial 3.0 Unported License*. 
+
+To view a copy of this license, visit http://creativecommons.org/licenses/by-nc/3.0/.
+
+If you feel like you deserve another license for a special case, [drop me a note](http://bkcore.com/contact.html), and we'll talk about it.
+
+## Regarding the code
+
+As of now the code is pretty much undocumented. I'll be commenting it someday, but that won't be until I've finished the next content update and code refactoring sorry!
+
+## Note
+
+After much thinking, I've decided to release HexGL's source code under CC 3.0 BY-NC until further notice. This is not a definite choice, and the game may end up under the MIT license someday.
+
+Feel free to post issues, patch or anything to make the game better.

bkcore/ImageData.js

@@ -0,0 +1,149 @@
+/*!
+ * @class bkcore.ImageData
+ *
+ * Loads an image and gives access to pixel data.
+ * 
+ * @author Thibaut 'BKcore' Despoulain <http://bkcore.com>
+ */
+
+/*!
+ * @package bkcore
+ */
+var bkcore = bkcore || {};
+
+/*!
+ * Creates a new ImageData object
+ * 
+ * @param path String The path of the image
+ * @param callback Function A callback function to be called once th eimage is loaded
+ */
+bkcore.ImageData = function(path, callback)
+{
+	var self = this;
+
+	this.image = new Image();
+	this.pixels = null;
+	this.canvas = null;
+	this.loaded = false;
+
+	this.image.onload = function() {
+	    self.canvas = document.createElement('canvas');
+	    self.canvas.width = self.image.width;
+	    self.canvas.height = self.image.height;
+
+	    var context = self.canvas.getContext('2d');
+	    context.drawImage(self.image, 0, 0);
+
+	    self.pixels = context.getImageData(0, 0, self.canvas.width, self.canvas.height);
+
+	    self.loaded = true;
+
+	    context = null;
+	    self.canvas = null;
+	    self.image = null;
+
+	    if(callback) callback.call(self);	    
+	};
+	this.image.crossOrigin = "anonymous";
+	this.image.src = path;
+};
+
+/*!
+ * Gets pixel RGBA data at given index
+ * 
+ * @param x int In pixels
+ * @param y int In pixels
+ * @return Object{r,g,b,a}
+ */
+bkcore.ImageData.prototype.getPixel = function(x, y)
+{
+	if(this.pixels == null
+		|| x < 0
+		|| y < 0
+		|| x >= this.pixels.width
+		|| y >= this.pixels.height)
+		return {r: 0, g: 0, b: 0, a:0};
+
+	var index = (y*this.pixels.width + x) * 4;
+
+    return {
+    	r: this.pixels.data[index],
+    	g: this.pixels.data[index + 1],
+    	b: this.pixels.data[index + 2],
+    	a: this.pixels.data[index + 3]
+    };
+};
+
+/*!
+ * Gets pixel RGBA data at given float index using bilinear interpolation
+ * 
+ * @param x float In subpixels
+ * @param y float In subpixels
+ * @return Object{r,g,b,a}
+ */
+bkcore.ImageData.prototype.getPixelBilinear = function(fx, fy)
+{
+	var x = Math.floor(fx);
+	var y = Math.floor(fy);
+	var rx = fx - x - .5;
+	var ry = fy - y - .5;
+	var ax = Math.abs(rx);
+	var ay = Math.abs(ry);
+	var c, cxy, cx, cy, cf1, cf2;
+	var dx = rx < 0 ?  -1 : 1;
+	var dy = ry < 0 ? -1 : 1;
+	
+	c = this.getPixel(x, y);
+	cx = this.getPixel(x+dx, y);
+	cy = this.getPixel(x, y+dy);
+	cxy = this.getPixel(x+dx, y+dy);
+
+	cf1 = [
+		(1-ax) * c.r + ax * cx.r,
+		(1-ax) * c.g + ax * cx.g,
+		(1-ax) * c.b + ax * cx.b,
+		(1-ax) * c.a + ax * cx.a
+	];
+
+	cf2 = [
+		(1-ax) * cy.r + ax * cxy.r,
+		(1-ax) * cy.g + ax * cxy.g,
+		(1-ax) * cy.b + ax * cxy.b,
+		(1-ax) * cy.a + ax * cxy.a
+	];
+	
+	return {
+		r: (1-ay) * cf1[0] + ay * cf2[0],
+		g: (1-ay) * cf1[1] + ay * cf2[1],
+		b: (1-ay) * cf1[2] + ay * cf2[2],
+		a: (1-ay) * cf1[3] + ay * cf2[3]
+	};
+}
+
+/*!
+ * Gets pixel data at given index 
+ * as 3-bytes integer (for floating-point textures erzats, from RGB values)
+ * 
+ * @param x int In pixels
+ * @param y int In pixels
+ * @return int (R + G*255 + B*255*255)
+ */
+bkcore.ImageData.prototype.getPixelF = function(x, y)  
+{ 
+	var color = this.getPixel(x, y);
+	return color.r + color.g * 255 + color.b * 255 * 255; 
+};
+
+/*!
+ * Gets pixel data at given float index using bilinear interpolationas
+ * as 3-bytes integer (for floating-point textures erzats, from RGB values)
+ * 
+ * @param x float In subpixels
+ * @param y float In subpixels
+ * @return Object{r,g,b,a}
+ */
+bkcore.ImageData.prototype.getPixelFBilinear = function(fx, fy)
+{
+	var color = this.getPixelBilinear(fx, fy);
+	return color.r + color.g * 255.0 + color.b * 255.0 * 255.0; 
+}

bkcore/Timer.js

@@ -0,0 +1,123 @@
+/*!
+ * @class bkcore.Timer
+ *
+ * new Date().getTime() wrapper to use as timers.
+ * 
+ * @author Thibaut 'BKcore' Despoulain <http://bkcore.com>
+ */
+
+/*!
+ * @package bkcore
+ */
+var bkcore = bkcore || {};
+
+/*!
+ * Creates a new timer, inactive by default.
+ * Call Timer.start() to activate.
+ */
+bkcore.Timer = function()
+{
+	this.time = {
+		start: 0,
+		current: 0,
+		previous: 0,
+		elapsed: 0,
+		delta: 0
+	}
+
+	this.active = false;
+}
+
+/*!
+ * Starts/restarts the timer.
+ */
+bkcore.Timer.prototype.start = function()
+{
+	var now = new Date().getTime();
+
+	this.time.start = now;
+	this.time.current = now;
+	this.time.previous = now;
+	this.time.elapsed = 0;
+	this.time.delta = 0;
+
+	this.active = true;
+}
+
+/*!
+ * Pauses(true)/Unpauses(false) the timer.
+ *
+ * @param bool Do pause
+ */
+bkcore.Timer.prototype.pause = function(bool)
+{
+	this.active = !bool;
+}
+
+/*!
+ * Update method to be called inside a RAF loop
+ */
+bkcore.Timer.prototype.update = function()
+{
+	if(!this.active) return;
+
+	var now = new Date().getTime();
+
+	this.time.current = now;
+	this.time.elapsed = this.time.current - this.time.start;
+	this.time.delta = now - this.time.previous;
+	this.time.previous = now;
+}
+
+/*!
+ * Returns a formatted version of the current elapsed time using msToTime().
+ *
+ * 
+ */
+bkcore.Timer.prototype.getElapsedTime = function()
+{
+	return bkcore.Timer.msToTime(this.time.elapsed);
+}
+
+/*!
+ * Formats a millisecond integer into a h/m/s/ms object
+ * 
+ * @param x int In milliseconds
+ * @return Object{h,m,s,ms}
+ */
+bkcore.Timer.msToTime = function(t)
+{
+	var ms, s, m, h;
+	
+	ms = t%1000;
+
+	s = Math.floor((t/1000)%60);
+
+	m = Math.floor((t/60000)%60);
+	h = Math.floor((t/3600000));
+
+	return {h:h, m:m, s:s, ms:ms};
+}
+
+/*!
+ * Formats a millisecond integer into a h/m/s/ms object with prefix zeros
+ * 
+ * @param x int In milliseconds
+ * @return Object<string>{h,m,s,ms}
+ */
+bkcore.Timer.msToTimeString = function(t)
+{
+	var ms, s, m, h;
+	
+	ms = t%1000;
+	if(ms < 10) ms = "00"+ms;
+	else if(ms < 100) ms = "0"+ms;
+
+	s = Math.floor((t/1000)%60);
+	if(s < 10) s = "0"+s;
+
+	m = Math.floor((t/60000)%60);
+	h = Math.floor((t/3600000));
+
+	return {h:h, m:m, s:s, ms:ms};
+}