bounding sphere and aabb calculations for mesh, a few more math functions

Author: Evan Wallace

src/matrix.js

@@ -64,6 +64,24 @@ Matrix.prototype.multiply = function(matrix) {
     );
 };
 
+Matrix.prototype.transformPoint = function(v) {
+    var m = this.m;
+    return new Vector(
+        m[0] * v.x + m[1] * v.y + m[2] * v.z + m[3],
+        m[4] * v.x + m[5] * v.y + m[6] * v.z + m[7],
+        m[8] * v.x + m[9] * v.y + m[10] * v.z + m[11]
+    ).divide(m[12] * v.x + m[13] * v.y + m[14] * v.z + m[15]);
+};
+
+Matrix.prototype.transformVector = function(v) {
+    var m = this.m;
+    return new Vector(
+        m[0] * v.x + m[1] * v.y + m[2] * v.z,
+        m[4] * v.x + m[5] * v.y + m[6] * v.z,
+        m[8] * v.x + m[9] * v.y + m[10] * v.z
+    );
+};
+
 Matrix.perspective = function(fov, aspect, near, far) {
     var y = Math.tan(fov * Math.PI / 360) * near;
     var x = y * aspect;

src/mesh.js

@@ -56,6 +56,26 @@ Mesh.prototype.compile = function() {
     this.indexBuffer.compile();
 };
 
+Mesh.prototype.computeAABB = function() {
+    var aabb = { min: new Vector(Number.MAX_VALUE, Number.MAX_VALUE, Number.MAX_VALUE) };
+    aabb.max = aabb.min.negative();
+    for (var i = 0; i < this.vertices.length; i++) {
+        var v = this.vertices[i];
+        aabb.min = aabb.min.min(v);
+        aabb.max = aabb.max.max(v);
+    }
+    return aabb;
+};
+
+Mesh.prototype.computeBoundingSphere = function() {
+    var aabb = this.computeAABB();
+    var sphere = { center: aabb.min.add(aabb.max).divide(2), radius: 0 };
+    for (var i = 0; i < this.vertices.length; i++) {
+        sphere.radius = Math.max(sphere.radius, this.vertices[i].subtract(sphere.center).length());
+    }
+    return sphere;
+};
+
 Mesh.plane = function(sizeX, sizeY, countX, countY, options) {
     var mesh = new Mesh(options);
     for (var y = 0; y <= countY; y++) {
@@ -64,7 +84,7 @@ Mesh.plane = function(sizeX, sizeY, countX, countY, options) {
             var s = x / countX;
             mesh.vertices.push(new Vector((s - 0.5) * sizeX, (t - 0.5) * sizeY, 0));
             if (mesh.coords) mesh.coords.push(new Vector(s, t));
-            if (mesh.normals) mesh.normals.push(new Vector(0, 1, 0));
+            if (mesh.normals) mesh.normals.push(new Vector(0, 0, 1));
         }
     }
     for (var y = 0; y < countY; y++) {

src/texture.js

@@ -3,14 +3,14 @@ Texture = function(width, height, options) {
     this.id = gl.createTexture();
     this.width = width;
     this.height = height;
+    this.format = options.format || gl.RGBA;
     gl.bindTexture(gl.TEXTURE_2D, this.id);
     gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, 1);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, options.magFilter || gl.LINEAR);
-    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, options.minFilter || gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, options.filter || options.magFilter || gl.LINEAR);
+    gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, options.filter || options.minFilter || gl.LINEAR);
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, options.wrap || options.wrapS || gl.CLAMP_TO_EDGE);
     gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, options.wrap || options.wrapT || gl.CLAMP_TO_EDGE);
-    var format = options.format || gl.RGBA;
-    gl.texImage2D(gl.TEXTURE_2D, 0, format, width, height, 0, format, options.type || gl.UNSIGNED_BYTE, null);
+    gl.texImage2D(gl.TEXTURE_2D, 0, this.format, width, height, 0, this.format, options.type || gl.UNSIGNED_BYTE, null);
 };
 
 Texture.prototype.bind = function(unit) {
@@ -56,8 +56,8 @@ Texture.prototype.swapWith = function(other) {
     temp = other.height; other.height = this.height; this.height = temp;
 };
 
-Texture.fromImage = function(image) {
-    var texture = new Texture(image.width, image.height);
-    gl.texImage2D(gl.TEXTURE_2D, 0, gl.RGBA, gl.RGBA, gl.UNSIGNED_BYTE, image);
+Texture.fromImage = function(image, options) {
+    var texture = new Texture(image.width, image.height, options);
+    gl.texImage2D(gl.TEXTURE_2D, 0, texture.format, texture.format, gl.UNSIGNED_BYTE, image);
     return texture;
 };

src/vector.js

@@ -4,6 +4,7 @@ Vector = function(x, y, z) {
     this.z = z || 0;
 };
 
+Vector.prototype.negative = function() { return new Vector(-this.x, -this.y, -this.z); };
 Vector.prototype.add = function(v) { return new Vector(this.x + v.x, this.y + v.y, this.z + v.z); };
 Vector.prototype.subtract = function(v) { return new Vector(this.x - v.x, this.y - v.y, this.z - v.z); };
 Vector.prototype.multiply = function(n) { return new Vector(this.x * n, this.y * n, this.z * n); };
@@ -12,3 +13,5 @@ Vector.prototype.dot = function(v) { return this.x * v.x + this.y * v.y + this.z
 Vector.prototype.cross = function(v) { return new Vector(this.y * v.z - this.z * v.y, this.z * v.x - this.x * v.z, this.x * v.y - this.y * v.x); };
 Vector.prototype.length = function() { return Math.sqrt(this.dot(this)); };
 Vector.prototype.unit = function() { return this.divide(this.length()); };
+Vector.prototype.min = function(v) { return new Vector(Math.min(this.x, v.x), Math.min(this.y, v.y), Math.min(this.z, v.z)); };
+Vector.prototype.max = function(v) { return new Vector(Math.max(this.x, v.x), Math.max(this.y, v.y), Math.max(this.z, v.z)); };