first commit

Author: jwu

.eslintrc.json

@@ -0,0 +1,30 @@
+{
+  "extends": "eslint:recommended",
+  "rules": {
+    "comma-dangle": 0,
+    "no-console": 0,
+    "no-constant-condition": 0,
+    "semi": 1
+  },
+  "parserOptions": {
+    "ecmaVersion": 6,
+    "sourceType": "module",
+    "ecmaFeatures": {
+      "jsx": true
+    }
+  },
+  "env": {
+    "browser": true,
+    "node": true,
+    "es6": true,
+    "mocha": true
+  },
+  "plugins": [
+  ],
+  "globals": {
+    "deprecate": false,
+    "helper": false,
+    "tap": false,
+    "unused": false
+  }
+}

.gitignore

@@ -0,0 +1,30 @@
+# mac-osx files
+.DS_store
+profile
+
+# visual-studio files
+*.ncb *.sln
+*.suo
+*.vcproj.*.user
+*.pdb
+*.idb
+*.csproj
+*.csproj.user
+
+# visual-studio code
+.vscode/
+
+# exvim files
+*.err
+*.exvim
+.exvim.*/
+
+# webstorm
+.idea
+
+# log files
+*.log
+
+# project files
+node_modules/
+bower_components/

LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2016-2017 Johnny Wu
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

README.md

@@ -0,0 +1,17 @@
+## vmath
+
+Yet another gl-matrix but smaller (without SIMD) and faster (use Hidden class instead of Float32Array).
+
+## Why?
+
+TODO
+
+## Install
+
+```bash
+npm install vmath
+```
+
+## Documentation
+
+TODO

dist/vmath.dev.js

@@ -0,0 +1,2 @@
+export * from './lib/utils';
+export { default as vec2 } from './lib/vec2';

dist/vmath.dev.js.map

@@ -0,0 +1,126 @@
+const _d2r = Math.PI / 180.0;
+const _r2d = 180.0 / Math.PI;
+
+/**
+ * @property {number} EPSILON
+ */
+export const EPSILON = 0.000001;
+
+/**
+ * Tests whether or not the arguments have approximately the same value, within an absolute
+ * or relative tolerance of glMatrix.EPSILON (an absolute tolerance is used for values less
+ * than or equal to 1.0, and a relative tolerance is used for larger values)
+ *
+ * @param {Number} a The first number to test.
+ * @param {Number} b The second number to test.
+ * @returns {Boolean} True if the numbers are approximately equal, false otherwise.
+ */
+export function equals(a, b) {
+  return Math.abs(a - b) <= EPSILON * Math.max(1.0, Math.abs(a), Math.abs(b));
+}
+
+/**
+ * Tests whether or not the arguments have approximately the same value by given maxDiff
+ *
+ * @param {Number} a The first number to test.
+ * @param {Number} b The second number to test.
+ * @param {Number} maxDiff Maximum difference.
+ * @returns {Boolean} True if the numbers are approximately equal, false otherwise.
+ */
+export function approx(a, b, maxDiff) {
+  maxDiff = maxDiff || EPSILON;
+  return Math.abs(a - b) <= maxDiff;
+}
+
+/**
+ * Clamps a value between a minimum float and maximum float value.
+ *
+ * @method clamp
+ * @param {number} val
+ * @param {number} min
+ * @param {number} max
+ * @return {number}
+ */
+export function clamp(val, min, max) {
+  return val < min ? min : val > max ? max : val;
+}
+
+/**
+ * Clamps a value between 0 and 1.
+ *
+ * @method clamp01
+ * @param {number} val
+ * @return {number}
+ */
+export function clamp01(val) {
+  return val < 0 ? 0 : val > 1 ? 1 : val;
+}
+
+/**
+ * Returns true if argument is a power-of-two and false otherwise.
+ *
+ * @method powof2
+ * @param {number} x Number to check for power-of-two property.
+ * @returns {boolean} true if power-of-two and false otherwise.
+ */
+export function powof2(x) {
+  return ((x !== 0) && !(x & (x - 1)));
+}
+
+/**
+ * @method lerp
+ * @param {number} from
+ * @param {number} to
+ * @param {number} ratio - the interpolation coefficient
+ * @return {number}
+ */
+export function lerp(from, to, ratio) {
+  return from + (to - from) * ratio;
+}
+
+/**
+* Convert Degree To Radian
+*
+* @param {Number} a Angle in Degrees
+*/
+export function toRadian(a) {
+  return a * _d2r;
+}
+
+/**
+* Convert Radian To Degree
+*
+* @param {Number} a Angle in Radian
+*/
+export function toDegree(a) {
+  return a * _r2d;
+}
+
+/**
+* @method random
+*/
+export const random = Math.random;
+
+/**
+ * Returns a floating-point random number between min (inclusive) and max (exclusive).
+ *
+ * @method randomRange
+ * @param {number} min
+ * @param {number} max
+ * @return {number} the random number
+ */
+export function randomRange(min, max) {
+  return Math.random() * (max - min) + min;
+}
+
+/**
+ * Returns a random integer between min (inclusive) and max (exclusive).
+ *
+ * @method randomRangeInt
+ * @param {number} min
+ * @param {number} max
+ * @return {number} the random integer
+ */
+export function randomRangeInt(min, max) {
+  return Math.floor(this.randomRange(min, max));
+}

dist/vmath.js

@@ -0,0 +1,35 @@
+{
+  "name": "vmath",
+  "version": "1.0.0",
+  "description": "Yet another gl-matrix: faster and smaller",
+  "main": "dist/vmath.js",
+  "scripts": {
+    "build": "rollup --config ./script/rollup.config.js",
+    "min": "uglifyjs ./dist/vmath.dev.js --source-map ./dist/vmath.min.js.map -o ./dist/vmath.min.js",
+    "release": "npm run build && npm run min",
+    "test": "npm run build && tap test/*.spec.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/gamedev-js/vmath.git"
+  },
+  "keywords": [
+    "math",
+    "algebre",
+    "vector",
+    "matrix"
+  ],
+  "author": "jwu",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/gamedev-js/vmath/issues"
+  },
+  "homepage": "https://github.com/gamedev-js/vmath/issues",
+  "dependencies": {},
+  "devDependencies": {
+    "fs-jetpack": "^0.13.0",
+    "rollup": "^0.41.4",
+    "tap": "^10.3.0",
+    "uglify-js": "git+https://github.com/mishoo/UglifyJS2.git#harmony"
+  }
+}

dist/vmath.js.map

@@ -0,0 +1,32 @@
+'use strict';
+
+const fsJetpack = require('fs-jetpack');
+const pjson = require('../package.json');
+
+let banner = `
+/*
+ * ${pjson.name} v${pjson.version}
+ * (c) ${new Date().getFullYear()} @Johnny Wu
+ * Released under the MIT License.
+ */
+`;
+
+let dest = './dist';
+let file = 'vmath';
+let moduleName = 'vmath';
+
+// clear directory
+fsJetpack.dir(dest, { empty: true });
+
+module.exports = {
+  entry: './index.js',
+  targets: [
+    { dest: `${dest}/${file}.dev.js`, format: 'iife' },
+    { dest: `${dest}/${file}.js`, format: 'cjs' },
+  ],
+  moduleName,
+  banner,
+  external: [],
+  globals: {},
+  sourceMap: true,
+};

index.js

@@ -0,0 +1,37 @@
+const tap = require('tap');
+
+tap.Test.prototype.addAssert('approx', 3, function (found, wanted, maxDifferent, message, extra ) {
+  let diff = Math.abs(found - wanted);
+
+  maxDifferent = maxDifferent || 0.0001;
+  message = message || `should be approximate (${maxDifferent})`;
+
+  if ( diff <= maxDifferent ) {
+    return this.pass(message, extra);
+  }
+
+  extra.found = found;
+  extra.wanted = wanted;
+  extra.compare = '~=';
+
+  return this.fail(message, extra);
+});
+
+tap.Test.prototype.addAssert('notApprox', 3, function (found, wanted, maxDifferent, message, extra ) {
+  let diff = Math.abs(found - wanted);
+
+  maxDifferent = maxDifferent || 0.0001;
+  message = message || `should be not approximate (${maxDifferent})`;
+
+  if ( diff > maxDifferent ) {
+    return this.pass(message, extra);
+  }
+
+  extra.found = found;
+  extra.wanted = wanted;
+  extra.compare = '!~=';
+
+  return this.fail(message, extra);
+});
+
+module.exports = tap;

lib/utils.js

@@ -0,0 +1,57 @@
+const tap = require('./tap');
+const {vec2} = require('../dist/vmath');
+
+tap.test('vec2', t => {
+  let out, vecA, vecB, result;
+
+  t.beforeEach(done => {
+    vecA = vec2.fromValues(1,2);
+    vecB = vec2.fromValues(3,4);
+    out = vec2.fromValues(0,0);
+
+    done();
+  });
+
+  t.test('create', t => {
+    result = vec2.create();
+    t.equal(result.x, 0.0);
+    t.equal(result.y, 0.0);
+
+    t.end();
+  });
+
+  t.test('clone', t => {
+    result = vec2.clone(vecA);
+    t.deepEqual(result, vecA);
+
+    t.end();
+  });
+
+  t.test('fromValues', t => {
+    result = vec2.fromValues(1, 2);
+    t.equal(result.x, 1);
+    t.equal(result.y, 2);
+
+    t.end();
+  });
+
+  t.test('copy', t => {
+    result = vec2.copy(out, vecA);
+    t.deepEqual(result, vecA);
+    t.deepEqual(out, vecA);
+
+    t.end();
+  });
+
+  t.test('set', t => {
+    result = vec2.set(out, 1, 2);
+    t.equal(result.x, 1);
+    t.equal(result.y, 2);
+    t.equal(out.x, 1);
+    t.equal(out.y, 2);
+
+    t.end();
+  });
+
+  t.end();
+});