First commit.

.gitignore

@@ -0,0 +1,2 @@
+gltumble.js
+gltumble.min.js

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2018 Philip Rideout
+
+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,69 @@
+<h1>gltumble<img src="https://github.com/prideout/lava/raw/master/extras/assets/klein31416.gif" align="right" width="128"></h1>
+
+[![badge]](https://travis-ci.org/prideout/gltumble)
+
+This library provides a math class called `Trackball` that allows users to spin (or "tumble") an
+object by dragging with a mouse, trackpad, or touch screen. It optionally applies inertia such that
+the object continues to spin if you flick it.
+
+The trackball does not do anything with quaternions. It simply applies Y rotation followed by X
+rotation. It avoids rotation about the Z axis, and here's why:
+
+**When I'm at a museum, I often walk around an *objet d'art*, or stand on my tiptoes to see its top,
+or crouch to see its underside. However, I very rarely tilt my head to the side, since that doesn't
+reveal anything new. The only times I tilt my head are when I'm expressing confusion, or trying to
+read vertical text.**
+
+Personally, I like this constraint. If you find it to be too limiting, try another package such
+as [trackball-controller].
+
+- [Interactive Demo] using [Filament] and WebGL 2.0
+- The demo [source code] is a single JS file.
+
+Note that `gltumble` emulates the behavior used by [sketchfab.com].
+
+## Example
+
+```js
+const trackball = new Trackball({foo: bar});
+const mat = trackball.getMatrix();
+trackball.execute();
+console.info(`The first component has ${nverts} vertices.`);
+```
+
+## Install
+
+Install with NPM (`npm install gltumble`) or Yarn (`yarn add gltumble`), then:
+
+```js
+import Trackball from 'gltumble';
+```
+
+Or use one of the following two CDN builds.
+
+```html
+<script src="//unpkg.com/gltumble/gltumble.min.js"></script> <!-- minified build -->
+<script src="//unpkg.com/gltumble/gltumble.js"></script> <!-- dev build -->
+```
+
+## API Reference
+
+#### new Trackball(options)
+
+Constructs a trackball, given an optional configuration dictionary.
+
+#### trackball.touch(...)
+
+TBD.
+
+#### trackball.getTransform(...)
+
+TBD.
+
+[badge]: https://travis-ci.org/prideout/.svg?branch=master "Build Status"
+[glMatrix]: http://glmatrix.net
+[Interactive Demo]: https://prideout.net/gltumble
+[Filament]: https://github.com/google/filament
+[source code]: https://github.com/prideout/knotess/blob/master/docs/demo.js
+[trackball-controller]: https://github.com/wwwtyro/trackball-controller
+[sketchfab.com]: https://sketchfab.com/models/bde956d410d4483da4126f1b0c80a06b

docs/Turntable.js

@@ -0,0 +1,180 @@
+var GIZA = GIZA || {};
+
+// Restricts rotation to Spin (Y axis) and Tilt (X axis)
+GIZA.Turntable = function(config) {
+
+  var M3 = GIZA.Matrix3;
+  var V3 = GIZA.Vector3;
+  var V2 = GIZA.Vector2;
+
+  // Allow clients to skip the "new"
+  if (!(this instanceof GIZA.Turntable)) {
+    return new GIZA.Turntable(config);
+  }
+
+  var defaults = {
+    startSpin: 0.001, // radians per second
+    allowTilt: true,
+    allowSpin: true,
+    spinFriction: 0.125, // 0 means no friction (infinite spin) while 1 means no inertia
+    epsilon: 3, // distance (in pixels) to wait before deciding if a drag is a Tilt or a Spin
+    radiansPerPixel: V2.make(0.01, 0.01),
+    canvas: GIZA.canvas,
+    trackpad: true,  // if true, compensate for the delay on trackpads that occur between touchup and mouseup
+    lockAxes: false, // if true, don't allow simultaneous spin + tilt
+    homeTilt: 0.25,
+    //bounceTilt: false, // if true, returns the tilt to the "home" angle after a mouse release
+    //boundSpin: false, // if true, returns to the startSpin state after a mouse release
+  };
+
+  this.config = config = GIZA.merge(defaults, config || {});
+
+  // diagram please!
+  var state = {
+    Resting: 0,
+    SpinningStart: 1,
+    SpinningInertia: 2,
+    DraggingInit: 3,
+    DraggingSpin: 4,
+    DraggingTilt: 5,
+    ReturningHome: 6,
+  };
+
+  var startPosition = V2.make(0, 0);
+  var currentPosition = V2.make(0, 0);
+
+  // TODO make these into a "positionHistory"
+  var previousPosition = currentPosition.slice(0);
+  var previous2Position = currentPosition.slice(0);
+
+  var currentSpin = 0;
+  var currentTilt = config.homeTilt;
+  var currentState = config.startSpin ?
+    state.SpinningStart : state.Resting;
+  var previousTime = null;
+  var inertiaSpeed = 0;
+  var initialInertia = 0.125;
+  var turntable = this;
+
+  GIZA.mousedown(function(position, modifiers) {
+    turntable.startDrag(position);
+  });
+
+  GIZA.mouseup(function(position, modifiers) {
+    turntable.endDrag(position);
+  });
+
+  GIZA.mousemove(function(position, modifiers) {
+    if (modifiers.button) {
+      turntable.updateDrag(position);
+    }
+  });
+
+  GIZA.drawHooks.push(function(time) {
+    if (previousTime == null) {
+      previousTime = time;
+    }
+    var deltaTime = time - previousTime;
+    previousTime = time;
+
+    var isSpinning = currentState == state.DraggingSpin ||
+      (currentState == state.DraggingInit && !config.lockAxes);
+
+    if (currentState == state.SpinningStart) {
+      currentSpin += config.startSpin * deltaTime;
+    } else if (currentState == state.SpinningInertia) {
+      currentSpin += inertiaSpeed * deltaTime;
+      inertiaSpeed *= (1 - config.spinFriction);
+      if (Math.abs(inertiaSpeed) < 0.0001) {
+        currentState = state.Resting;
+      }
+
+    // Some trackpads have an intentional delay between fingers-up
+    // and the time we receive the mouseup event.  To accomodate this,
+    // we execute inertia even while we think the mouse is still down.
+    // This behavior can be disabled with the "trackpad" config option.
+    } else if (config.trackpad && isSpinning &&
+               V2.equivalent(currentPosition, previous2Position, 0)) {
+      currentSpin += inertiaSpeed * deltaTime;
+      inertiaSpeed *= (1 - config.spinFriction);
+    }
+
+    previous2Position = previousPosition.slice(0);
+    previousPosition = currentPosition.slice(0);
+  });
+
+  this.startDrag = function(position) {
+    startPosition = position.slice(0);
+    currentPosition = position.slice(0);
+    currentState = state.DraggingInit;
+  };
+
+  this.updateDrag = function(position) {
+    var delta = V2.subtract(position, startPosition);
+
+    // If we haven't decided yet, decide if we're spinning or tilting.
+    if (currentState == state.DraggingInit && config.lockAxes) {
+      if (Math.abs(delta[0]) > config.epsilon && config.allowSpin) {
+        currentState = state.DraggingSpin;
+      } else if (Math.abs(delta[1]) > config.epsilon && config.allowTilt) {
+        currentState = state.DraggingTilt;
+      } else {
+        return;
+      }
+    }
+
+    var previousSpin = this.getAngles()[0];
+    currentPosition = position.slice(0);
+
+    // This is purely for trackpads:
+    var spinDelta = this.getAngles()[0] - previousSpin;
+    inertiaSpeed = initialInertia * spinDelta;
+  };
+
+  this.getAngles = function() {
+    var delta = V2.subtract(currentPosition, startPosition);
+    var spin = currentSpin;
+    var tilt = currentTilt;
+    if (currentState == state.DraggingSpin) {
+      var radians = config.radiansPerPixel[0] * delta[0];
+      spin += radians;
+    } else if (currentState == state.DraggingTilt) {
+      var radians = config.radiansPerPixel[1] * delta[1];
+      tilt += radians;
+    } else if (!config.lockAxes && currentState == state.DraggingInit) {
+      spin += config.radiansPerPixel[0] * delta[0];
+      tilt += config.radiansPerPixel[1] * delta[1];
+    }
+    return [spin, tilt];
+  };
+
+  this.getRotation = function() {
+    var r = this.getAngles();
+    var spin = M3.rotationY(r[0]);
+    var tilt = M3.rotationX(r[1]);
+    return M3.multiply(tilt, spin);
+  };
+
+  // When releasing the mouse, capture the current rotation and change
+  // the state machine back to 'Resting' or 'SpinningInertia'.
+  this.endDrag = function(position) {
+    var previousSpin = this.getAngles()[0];
+    currentPosition = position.slice(0);
+    var r = this.getAngles();
+    currentSpin = r[0];
+    currentTilt = r[1];
+
+    var spinDelta = currentSpin - previousSpin;
+
+    if (config.spinFriction == 1) {
+      currentState = state.Resting;
+    } else {
+      currentState = state.SpinningInertia;
+      inertiaSpeed = initialInertia * spinDelta;
+    }
+
+  };
+
+};
+
+GIZA.Turntable.INFINITE = 1000; // not sure if I'll use this

index.js

@@ -0,0 +1,19 @@
+import { vec3, quat } from 'gl-matrix';
+
+const TWOPI = 2 * Math.PI;
+
+export default class Trackball {
+    constructor() {
+        this.defaults = Object.freeze({
+            startSpin: 0.001, // radians per second
+            allowTilt: true,
+            allowSpin: true,
+            spinFriction: 0.125, // 0 means no friction (infinite spin) while 1 means no inertia
+            epsilon: 3, // distance (in pixels) to wait before deciding if a drag is a Tilt or a Spin
+            radiansPerPixel: V2.make(0.01, 0.01),
+            trackpad: true,  // if true, compensate for the delay on trackpads that occur between touchup and mouseup
+            lockAxes: false, // if true, don't allow simultaneous spin + tilt
+            homeTilt: 0.25,
+        });
+    }
+}

package.json

@@ -0,0 +1,49 @@
+{
+  "name": "gltumble",
+  "version": "0.0.0",
+  "description": "Spin an object by dragging with a mouse, trackpad, or touch screen",
+  "main": "gltumble.js",
+  "module": "index.js",
+  "jsdelivr": "gltumble.min.js",
+  "unpkg": "gltumble.min.js",
+  "dependencies": {
+    "gl-matrix": "^2.8.1"
+  },
+  "devDependencies": {
+    "c8": "^3.2.0",
+    "eslint": "^5.6.0",
+    "eslint-config-mourner": "^3.0.0",
+    "esm": "^3.0.84",
+    "rollup": "^0.66.2",
+    "rollup-plugin-buble": "^0.19.2",
+    "rollup-plugin-node-resolve": "^3.4.0",
+    "rollup-plugin-terser": "^3.0.0",
+    "tape": "^4.9.1"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/prideout/gltumble.git"
+  },
+  "scripts": {
+    "disable__lint": "eslint index.js test.js rollup.config.js",
+    "disable__pretest": "npm run lint",
+    "test": "node -r esm test.js",
+    "disable__cov": "c8 node -r esm test.js && c8 report -r html",
+    "build": "rollup -c",
+    "clean": "rm gltumble.*",
+    "watch": "rollup -cw",
+    "disable__prepublishOnly": "npm test && npm run build"
+  },
+  "files": [
+    "gltumble.js",
+    "gltumble.min.js"
+  ],
+  "eslintConfig": {
+    "extends": "mourner",
+    "rules": {
+      "no-sequences": 0
+    }
+  },
+  "author": "Philip Rideout",
+  "license": "MIT"
+}

rollup.config.js

@@ -0,0 +1,20 @@
+import {terser} from 'rollup-plugin-terser';
+import buble from 'rollup-plugin-buble';
+import resolve from 'rollup-plugin-node-resolve';
+
+const config = (file, plugins) => ({
+    input: 'index.js',
+    output: {
+        name: 'gltumble',
+        format: 'umd',
+        file
+    },
+    plugins
+});
+
+const bubleConfig = {transforms: {dangerousForOf: true}};
+
+export default [
+    config('gltumble.js', [resolve(), buble(bubleConfig)]),
+    config('gltumble.min.js', [resolve(), terser(), buble(bubleConfig)])
+];

test.js

@@ -0,0 +1,8 @@
+import test from 'tape';
+import Trackball from './index.js';
+
+test('smoke', (t) => {
+    const trackball = new Trackball(data);
+    t.notSame(trackball, null);
+    t.end();
+});