text: /**
   * A static class with functions for performing calculations
   *
   * @class Utilities
   * @static
   */
  LE.Utilities = {
      /**
       * Used to convert pixel positions to WebGL matrix positions
       *
       * @private
       * @method toMatrix
       * @param {Object} gl
       * @param {Number} value
       * @param {Boolean} isWidth
       * @return {Number} newValue
       */
      toMatrix : function(gl, value, isWidth) {
          if(isWidth == true) {
              return (value / gl.viewportWidth * gl.viewportRatio * 2);
          } else {
              return (value / gl.viewportHeight * 2);
          }
      },
      /**
       * Used to convert pixel positions to WebGL matrix positions
       *
       * @private
       * @method vertToMatrix
       * @param {Object} gl
       * @param {Number} x
       * @param {Number} y
       * @return {Object} newVector
       */
      vertToMatrix : function(gl, x, y) {
          return verts = { x: x / gl.viewportWidth * gl.viewportRatio * 2, y: y / gl.viewportHeight * 2 };
      },
      /**
       * Checks if an x and y position is within the bounds provided as parameters
       *
       * @method checkScreenBounds
       * @param {Number} boundX Camera x position
       * @param {Number} boundY Camera y position
       * @param {Number} boundWidth Viewport width
       * @param {Number} boundHeight Viewport height
       * @param {Number} boundXAdditive Extra amount to allow for on x boundaries
       * @param {Number} boundYAdditive Extra amount to allow for on y boundaries
       * @param {Number} testX The x position to test
       * @param {Number} testY The y position to test
       * @return {Boolean}
       */
      checkScreenBounds : function(boundX, boundY, boundWidth, boundHeight, boundXAdditive, boundYAdditive, testX, testY) {
          if(testX >= boundX - boundXAdditive && testX <= boundX + boundWidth + boundXAdditive &&
              testY >= boundY - boundYAdditive && testY <= boundY + boundHeight + boundYAdditive) {
              return true;
          } else {
              return false;
          }
      },
      /**
       * Converts from degrees (angle) to radians
       *
       * @method degToRad
       * @param {Number} degrees
       * @return {Number} radian
       */
      degToRad : function(degrees) {
          return degrees * Math.PI / 180;
      },
      /**
       * Returns the minimum width and height and maximum width and height from a set of vertices
       *
       * @private
       * @method minMaxFromVerts
       * @param {Object} vertcies
       * @return {Object} minAndMax
       */
      minMaxFromVerts : function(vertices) {
          var minWidth = 0, maxWidth = 0, minHeight = 0, maxHeight = 0;
          for(var i = 0; i < vertices.length; i++) {
              if(i == 0) {
                  minWidth = vertices[i].x, maxWidth = vertices[i].x;
                  minHeight = vertices[i].y, maxHeight = vertices[i].y;
              } else {
                  minWidth = vertices[i].x < minWidth ? vertices[i].x : minWidth;
                  maxWidth = vertices[i].x > maxWidth ? vertices[i].x : maxWidth;
                  minHeight = vertices[i].y < minHeight ? vertices[i].y : minHeight;
                  maxHeight = vertices[i].y > maxHeight ? vertices[i].y : maxHeight;
              }
          }  
          return { minWidth: minWidth, maxWidth: maxWidth, minHeight: minHeight, maxHeight: maxHeight };
      },
      /**
       * Returns the total width and height from a set of vertices
       *
       * @private
       * @method sizeFromVerts
       * @param {Object} vertcies
       * @return {Object} widthAndHeight
       */
      sizeFromVerts : function(vertices) {
          var v = this.minMaxFromVerts(vertices);
          return { width: Math.abs(v.maxWidth - v.minWidth), height: Math.abs(v.maxHeight - v.minHeight) };
      },
      /**
       * Returns a Vector container the center point from a set of vertices
       *
       * @private
       * @method centerOfVerts
       * @param {Object} vertcies
       * @return {Object} xAndY
       */
      centerOfVerts : function(vertices) {
          var x = 0;
          var y = 0;
          for(var i = 0; i < vertices.length; i++) {
              x += vertices[i].x;
              y += vertices[i].y;
          }
          x = (x / vertices.length);
          y = (y / vertices.length);
          return { x: x, y: y };
      },
      /**
       * Returns a Vector container the center point from a set of vertices
       *
       * @method checkPointCollision
       * @param {Number} testX X position to be checked
       * @param {Number} testY Y position to be checked
       * @param {Object} object Object to be checked. Takes a Polygon or a Texture
       * @return {Boolean} isColliding
       */
      checkPointCollision : function(testX, testY, object) {
          // Inner function
          function polygonCollision(nVert, vertX, vertY, testX, testY) {
              var i, j, c = 0;
              for (var i = 0, j = nVert-1; i < nVert; j = i++) {
              if ( ((vertY[i]>testY) != (vertY[j]>testY)) &&
               (testX < (vertX[j]-vertX[i]) * (testY-vertY[i]) / (vertY[j]-vertY[i]) + vertX[i]) )
                 c = !c;
              }
              return c;
          }
          // checkPointCollision Function begin
          var nVert = object.vertices.length;
          var vertX = [];
          var vertY = [];
          for(var i = 0; i < nVert; i++) {
              vertX.push(object.x + object.vertices[i].x);
              vertY.push(object.y + object.vertices[i].y);
          }
          var num = polygonCollision(nVert, vertX, vertY, testX, testY);
          if(num == true) {
              return true;
          } else {
              return false;
          } 
      },
  };
  