webruby 0.1.2 → 0.2.1

data/modules/emscripten/src/library_glfw.js

@@ -354,7 +354,10 @@ var LibraryGLFW = {
       throw "Invalid glfwOpenWindow mode.";
     }
 
-    Module.ctx = Browser.createContext(Module['canvas'], true, true);
+    var contextAttributes = {
+      antialias: (GLFW.params[0x00020013] > 1) //GLFW_FSAA_SAMPLES
+    }
+    Module.ctx = Browser.createContext(Module['canvas'], true, true, contextAttributes);
     return 1; //GL_TRUE
   },
 

data/modules/emscripten/src/library_glut.js

@@ -16,6 +16,7 @@ var LibraryGLUT = {
     modifiers: 0,
     initWindowWidth: 256,
     initWindowHeight: 256,
+    initDisplayMode: 0x0000 /*GLUT_RGBA*/ | 0x0002 /*GLUT_DOUBLE*/ | 0x0010 /*GLUT_DEPTH*/,
     // Set when going fullscreen
     windowX: 0,
     windowY: 0,
@@ -189,12 +190,12 @@ var LibraryGLUT = {
       }
     },
 
-    onMouseButtonDown: function(event){
+    onMouseButtonDown: function(event) {
       Browser.calculateMouseEvent(event);
 
       GLUT.buttons |= (1 << event['button']);
 
-      if(event.target == Module["canvas"] && GLUT.mouseFunc){
+      if (event.target == Module["canvas"] && GLUT.mouseFunc) {
         try {
           event.target.setCapture();
         } catch (e) {}
@@ -204,21 +205,40 @@ var LibraryGLUT = {
       }
     },
 
-    onMouseButtonUp: function(event){
+    onMouseButtonUp: function(event) {
       Browser.calculateMouseEvent(event);
 
       GLUT.buttons &= ~(1 << event['button']);
 
-      if(GLUT.mouseFunc) {
+      if (GLUT.mouseFunc) {
         event.preventDefault();
         GLUT.saveModifiers(event);
         Runtime.dynCall('viiii', GLUT.mouseFunc, [event['button'], 1/*GLUT_UP*/, Browser.mouseX, Browser.mouseY]);
       }
     },
 
+    onMouseWheel: function(event) {
+      Browser.calculateMouseEvent(event);
+
+      // cross-browser wheel delta
+      var e = window.event || event; // old IE support
+      var delta = Math.max(-1, Math.min(1, (e.wheelDelta || -e.detail)));
+
+      var button = 3; // wheel up
+      if (delta < 0) {
+        button = 4; // wheel down
+      }
+      
+      if (GLUT.mouseFunc) {
+        event.preventDefault();
+        GLUT.saveModifiers(event);
+        Runtime.dynCall('viiii', GLUT.mouseFunc, [button, 0/*GLUT_DOWN*/, Browser.mouseX, Browser.mouseY]);
+      }
+    },
+    
     // TODO add fullscreen API ala:
     // http://johndyer.name/native-fullscreen-javascript-api-plus-jquery-plugin/
-    onFullScreenEventChange: function(event){
+    onFullScreenEventChange: function(event) {
       var width;
       var height;
       if (document["fullScreen"] || document["mozFullScreen"] || document["webkitIsFullScreen"]) {
@@ -267,11 +287,23 @@ var LibraryGLUT = {
     // Ignore arguments
     GLUT.initTime = Date.now();
 
+    var isTouchDevice = 'ontouchstart' in document.documentElement;
+
     window.addEventListener("keydown", GLUT.onKeydown, true);
     window.addEventListener("keyup", GLUT.onKeyup, true);
-    window.addEventListener("mousemove", GLUT.onMousemove, true);
-    window.addEventListener("mousedown", GLUT.onMouseButtonDown, true);
-    window.addEventListener("mouseup", GLUT.onMouseButtonUp, true);
+    if (isTouchDevice) {
+      window.addEventListener("touchmove", GLUT.onMousemove, true);
+      window.addEventListener("touchstart", GLUT.onMouseButtonDown, true);
+      window.addEventListener("touchend", GLUT.onMouseButtonUp, true);
+    } else {
+      window.addEventListener("mousemove", GLUT.onMousemove, true);
+      window.addEventListener("mousedown", GLUT.onMouseButtonDown, true);
+      window.addEventListener("mouseup", GLUT.onMouseButtonUp, true);
+      // IE9, Chrome, Safari, Opera
+      window.addEventListener("mousewheel", GLUT.onMouseWheel, true);
+      // Firefox
+      window.addEventListener("DOMMouseScroll", GLUT.onMouseWheel, true);
+    }
     
     Browser.resizeListeners.push(function(width, height) {
       if (GLUT.reshapeFunc) {
@@ -282,9 +314,19 @@ var LibraryGLUT = {
     __ATEXIT__.push({ func: function() {
       window.removeEventListener("keydown", GLUT.onKeydown, true);
       window.removeEventListener("keyup", GLUT.onKeyup, true);
-      window.removeEventListener("mousemove", GLUT.onMousemove, true);
-      window.removeEventListener("mousedown", GLUT.onMouseButtonDown, true);
-      window.removeEventListener("mouseup", GLUT.onMouseButtonUp, true);
+      if (isTouchDevice) {
+        window.removeEventListener("touchmove", GLUT.onMousemove, true);
+        window.removeEventListener("touchstart", GLUT.onMouseButtonDown, true);
+        window.removeEventListener("touchend", GLUT.onMouseButtonUp, true);
+      } else {
+        window.removeEventListener("mousemove", GLUT.onMousemove, true);
+        window.removeEventListener("mousedown", GLUT.onMouseButtonDown, true);
+        window.removeEventListener("mouseup", GLUT.onMouseButtonUp, true);
+        // IE9, Chrome, Safari, Opera
+        window.removeEventListener("mousewheel", GLUT.onMouseWheel, true);
+        // Firefox
+        window.removeEventListener("DOMMouseScroll", GLUT.onMouseWheel, true);
+      }
       Module["canvas"].width = Module["canvas"].height = 1;
     } });
   },
@@ -384,7 +426,10 @@ var LibraryGLUT = {
 
   glutCreateWindow__deps: ['$Browser'],
   glutCreateWindow: function(name) {
-    Module.ctx = Browser.createContext(Module['canvas'], true, true);
+    var contextAttributes = {
+      antialias: ((GLUT.initDisplayMode & 0x0080 /*GLUT_MULTISAMPLE*/) != 0)
+    };
+    Module.ctx = Browser.createContext(Module['canvas'], true, true, contextAttributes);
     return Module.ctx ? 1 /* a new GLUT window ID for the created context */ : 0 /* failure */;
   },
 
@@ -423,7 +468,10 @@ var LibraryGLUT = {
     GLUT.requestFullScreen();
   },
 
-  glutInitDisplayMode: function(mode) {},
+  glutInitDisplayMode: function(mode) {
+    GLUT.initDisplayMode = mode;
+  },
+
   glutSwapBuffers: function() {},
 
   glutPostRedisplay: function() {

data/modules/emscripten/src/library_idbfs.js

@@ -0,0 +1,216 @@
+mergeInto(LibraryManager.library, {
+  $IDBFS__deps: ['$FS', '$MEMFS', '$PATH'],
+  $IDBFS: {
+    dbs: {},
+    indexedDB: function() {
+      return window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+    },
+    DB_VERSION: 20,
+    DB_STORE_NAME: 'FILE_DATA',
+    // reuse all of the core MEMFS functionality
+    mount: function(mount) {
+      return MEMFS.mount.apply(null, arguments);
+    },
+    // the only custom function IDBFS implements is to handle
+    // synchronizing the wrapped MEMFS with a backing IDB instance
+    syncfs: function(mount, populate, callback) {
+      IDBFS.getLocalSet(mount, function(err, local) {
+        if (err) return callback(err);
+
+        IDBFS.getRemoteSet(mount, function(err, remote) {
+          if (err) return callback(err);
+
+          var src = populate ? remote : local;
+          var dst = populate ? local : remote;
+
+          IDBFS.reconcile(src, dst, callback);
+        });
+      });
+    },
+    reconcile: function(src, dst, callback) {
+      var total = 0;
+
+      var create = {};
+      for (var key in src.files) {
+        if (!src.files.hasOwnProperty(key)) continue;
+        var e = src.files[key];
+        var e2 = dst.files[key];
+        if (!e2 || e.timestamp > e2.timestamp) {
+          create[key] = e;
+          total++;
+        }
+      }
+
+      var remove = {};
+      for (var key in dst.files) {
+        if (!dst.files.hasOwnProperty(key)) continue;
+        var e = dst.files[key];
+        var e2 = src.files[key];
+        if (!e2) {
+          remove[key] = e;
+          total++;
+        }
+      }
+
+      if (!total) {
+        // early out
+        return callback(null);
+      }
+
+      var completed = 0;
+      var done = function(err) {
+        if (err) return callback(err);
+        if (++completed >= total) {
+          return callback(null);
+        }
+      };
+
+      // create a single transaction to handle and IDB reads / writes we'll need to do
+      var db = src.type === 'remote' ? src.db : dst.db;
+      var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readwrite');
+      transaction.onerror = function() { callback(this.error); };
+      var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+
+      for (var path in create) {
+        if (!create.hasOwnProperty(path)) continue;
+        var entry = create[path];
+
+        if (dst.type === 'local') {
+          // save file to local
+          try {
+            if (FS.isDir(entry.mode)) {
+              FS.mkdir(path, entry.mode);
+            } else if (FS.isFile(entry.mode)) {
+              var stream = FS.open(path, 'w+', 0666);
+              FS.write(stream, entry.contents, 0, entry.contents.length, 0, true /* canOwn */);
+              FS.close(stream);
+            }
+            done(null);
+          } catch (e) {
+            return done(e);
+          }
+        } else {
+          // save file to IDB
+          var req = store.put(entry, path);
+          req.onsuccess = function() { done(null); };
+          req.onerror = function() { done(this.error); };
+        }
+      }
+
+      for (var path in remove) {
+        if (!remove.hasOwnProperty(path)) continue;
+        var entry = remove[path];
+
+        if (dst.type === 'local') {
+          // delete file from local
+          try {
+            if (FS.isDir(entry.mode)) {
+              // TODO recursive delete?
+              FS.rmdir(path);
+            } else if (FS.isFile(entry.mode)) {
+              FS.unlink(path);
+            }
+            done(null);
+          } catch (e) {
+            return done(e);
+          }
+        } else {
+          // delete file from IDB
+          var req = store.delete(path);
+          req.onsuccess = function() { done(null); };
+          req.onerror = function() { done(this.error); };
+        }
+      }
+    },
+    getLocalSet: function(mount, callback) {
+      var files = {};
+
+      var isRealDir = function(p) {
+        return p !== '.' && p !== '..';
+      };
+      var toAbsolute = function(root) {
+        return function(p) {
+          return PATH.join(root, p);
+        }
+      };
+
+      var check = FS.readdir(mount.mountpoint)
+        .filter(isRealDir)
+        .map(toAbsolute(mount.mountpoint));
+
+      while (check.length) {
+        var path = check.pop();
+        var stat, node;
+
+        try {
+          var lookup = FS.lookupPath(path);
+          node = lookup.node;
+          stat = FS.stat(path);
+        } catch (e) {
+          return callback(e);
+        }
+
+        if (FS.isDir(stat.mode)) {
+          check.push.apply(check, FS.readdir(path)
+            .filter(isRealDir)
+            .map(toAbsolute(path)));
+
+          files[path] = { mode: stat.mode, timestamp: stat.mtime };
+        } else if (FS.isFile(stat.mode)) {
+          files[path] = { contents: node.contents, mode: stat.mode, timestamp: stat.mtime };
+        } else {
+          return callback(new Error('node type not supported'));
+        }
+      }
+
+      return callback(null, { type: 'local', files: files });
+    },
+    getDB: function(name, callback) {
+      // look it up in the cache
+      var db = IDBFS.dbs[name];
+      if (db) {
+        return callback(null, db);
+      }
+      var req;
+      try {
+        req = IDBFS.indexedDB().open(name, IDBFS.DB_VERSION);
+      } catch (e) {
+        return onerror(e);
+      }
+      req.onupgradeneeded = function() {
+        db = req.result;
+        db.createObjectStore(IDBFS.DB_STORE_NAME);
+      };
+      req.onsuccess = function() {
+        db = req.result;
+        // add to the cache
+        IDBFS.dbs[name] = db;
+        callback(null, db);
+      };
+      req.onerror = function() {
+        callback(this.error);
+      };
+    },
+    getRemoteSet: function(mount, callback) {
+      var files = {};
+
+      IDBFS.getDB(mount.mountpoint, function(err, db) {
+        if (err) return callback(err);
+
+        var transaction = db.transaction([IDBFS.DB_STORE_NAME], 'readonly');
+        transaction.onerror = function() { callback(this.error); };
+
+        var store = transaction.objectStore(IDBFS.DB_STORE_NAME);
+        store.openCursor().onsuccess = function(event) {
+          var cursor = event.target.result;
+          if (!cursor) {
+            return callback(null, { type: 'remote', db: db, files: files });
+          }
+
+          files[cursor.key] = cursor.value;
+          cursor.continue();
+        };
+      });
+    }
+  }
+});

data/modules/emscripten/src/library_memfs.js

@@ -0,0 +1,279 @@
+mergeInto(LibraryManager.library, {
+  $MEMFS__deps: ['$FS'],
+  $MEMFS: {
+    // content modes
+    CONTENT_OWNING: 1, // contains a subarray into the heap, and we own it, without copying (note: someone else needs to free() it, if that is necessary)
+    CONTENT_FLEXIBLE: 2, // has been modified or never set to anything, and is a flexible js array that can grow/shrink
+    CONTENT_FIXED: 3, // contains some fixed-size content written into it, in a typed array
+    mount: function(mount) {
+      return MEMFS.createNode(null, '/', {{{ cDefine('S_IFDIR') }}} | 0777, 0);
+    },
+    createNode: function(parent, name, mode, dev) {
+      if (FS.isBlkdev(mode) || FS.isFIFO(mode)) {
+        // no supported
+        throw new FS.ErrnoError(ERRNO_CODES.EPERM);
+      }
+      var node = FS.createNode(parent, name, mode, dev);
+      if (FS.isDir(node.mode)) {
+        node.node_ops = {
+          getattr: MEMFS.node_ops.getattr,
+          setattr: MEMFS.node_ops.setattr,
+          lookup: MEMFS.node_ops.lookup,
+          mknod: MEMFS.node_ops.mknod,
+          mknod: MEMFS.node_ops.mknod,
+          rename: MEMFS.node_ops.rename,
+          unlink: MEMFS.node_ops.unlink,
+          rmdir: MEMFS.node_ops.rmdir,
+          readdir: MEMFS.node_ops.readdir,
+          symlink: MEMFS.node_ops.symlink
+        };
+        node.stream_ops = {
+          llseek: MEMFS.stream_ops.llseek
+        };
+        node.contents = {};
+      } else if (FS.isFile(node.mode)) {
+        node.node_ops = {
+          getattr: MEMFS.node_ops.getattr,
+          setattr: MEMFS.node_ops.setattr
+        };
+        node.stream_ops = {
+          llseek: MEMFS.stream_ops.llseek,
+          read: MEMFS.stream_ops.read,
+          write: MEMFS.stream_ops.write,
+          allocate: MEMFS.stream_ops.allocate,
+          mmap: MEMFS.stream_ops.mmap
+        };
+        node.contents = [];
+        node.contentMode = MEMFS.CONTENT_FLEXIBLE;
+      } else if (FS.isLink(node.mode)) {
+        node.node_ops = {
+          getattr: MEMFS.node_ops.getattr,
+          setattr: MEMFS.node_ops.setattr,
+          readlink: MEMFS.node_ops.readlink
+        };
+        node.stream_ops = {};
+      } else if (FS.isChrdev(node.mode)) {
+        node.node_ops = {
+          getattr: MEMFS.node_ops.getattr,
+          setattr: MEMFS.node_ops.setattr
+        };
+        node.stream_ops = FS.chrdev_stream_ops;
+      }
+      node.timestamp = Date.now();
+      // add the new node to the parent
+      if (parent) {
+        parent.contents[name] = node;
+      }
+      return node;
+    },
+    ensureFlexible: function(node) {
+      if (node.contentMode !== MEMFS.CONTENT_FLEXIBLE) {
+        var contents = node.contents;
+        node.contents = Array.prototype.slice.call(contents);
+        node.contentMode = MEMFS.CONTENT_FLEXIBLE;
+      }
+    },
+    node_ops: {
+      getattr: function(node) {
+        var attr = {};
+        // device numbers reuse inode numbers.
+        attr.dev = FS.isChrdev(node.mode) ? node.id : 1;
+        attr.ino = node.id;
+        attr.mode = node.mode;
+        attr.nlink = 1;
+        attr.uid = 0;
+        attr.gid = 0;
+        attr.rdev = node.rdev;
+        if (FS.isDir(node.mode)) {
+          attr.size = 4096;
+        } else if (FS.isFile(node.mode)) {
+          attr.size = node.contents.length;
+        } else if (FS.isLink(node.mode)) {
+          attr.size = node.link.length;
+        } else {
+          attr.size = 0;
+        }
+        attr.atime = new Date(node.timestamp);
+        attr.mtime = new Date(node.timestamp);
+        attr.ctime = new Date(node.timestamp);
+        // NOTE: In our implementation, st_blocks = Math.ceil(st_size/st_blksize),
+        //       but this is not required by the standard.
+        attr.blksize = 4096;
+        attr.blocks = Math.ceil(attr.size / attr.blksize);
+        return attr;
+      },
+      setattr: function(node, attr) {
+        if (attr.mode !== undefined) {
+          node.mode = attr.mode;
+        }
+        if (attr.timestamp !== undefined) {
+          node.timestamp = attr.timestamp;
+        }
+        if (attr.size !== undefined) {
+          MEMFS.ensureFlexible(node);
+          var contents = node.contents;
+          if (attr.size < contents.length) contents.length = attr.size;
+          else while (attr.size > contents.length) contents.push(0);
+        }
+      },
+      lookup: function(parent, name) {
+        throw new FS.ErrnoError(ERRNO_CODES.ENOENT);
+      },
+      mknod: function(parent, name, mode, dev) {
+        return MEMFS.createNode(parent, name, mode, dev);
+      },
+      rename: function(old_node, new_dir, new_name) {
+        // if we're overwriting a directory at new_name, make sure it's empty.
+        if (FS.isDir(old_node.mode)) {
+          var new_node;
+          try {
+            new_node = FS.lookupNode(new_dir, new_name);
+          } catch (e) {
+          }
+          if (new_node) {
+            for (var i in new_node.contents) {
+              throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+            }
+          }
+        }
+        // do the internal rewiring
+        delete old_node.parent.contents[old_node.name];
+        old_node.name = new_name;
+        new_dir.contents[new_name] = old_node;
+        old_node.parent = new_dir;
+      },
+      unlink: function(parent, name) {
+        delete parent.contents[name];
+      },
+      rmdir: function(parent, name) {
+        var node = FS.lookupNode(parent, name);
+        for (var i in node.contents) {
+          throw new FS.ErrnoError(ERRNO_CODES.ENOTEMPTY);
+        }
+        delete parent.contents[name];
+      },
+      readdir: function(node) {
+        var entries = ['.', '..']
+        for (var key in node.contents) {
+          if (!node.contents.hasOwnProperty(key)) {
+            continue;
+          }
+          entries.push(key);
+        }
+        return entries;
+      },
+      symlink: function(parent, newname, oldpath) {
+        var node = MEMFS.createNode(parent, newname, 0777 | {{{ cDefine('S_IFLNK') }}}, 0);
+        node.link = oldpath;
+        return node;
+      },
+      readlink: function(node) {
+        if (!FS.isLink(node.mode)) {
+          throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+        }
+        return node.link;
+      },
+    },
+    stream_ops: {
+      read: function(stream, buffer, offset, length, position) {
+        var contents = stream.node.contents;
+        if (position >= contents.length)
+          return 0;
+        var size = Math.min(contents.length - position, length);
+        assert(size >= 0);
+#if USE_TYPED_ARRAYS == 2
+        if (size > 8 && contents.subarray) { // non-trivial, and typed array
+          buffer.set(contents.subarray(position, position + size), offset);
+        } else
+#endif
+        {
+          for (var i = 0; i < size; i++) {
+            buffer[offset + i] = contents[position + i];
+          }
+        }
+        return size;
+      },
+      write: function(stream, buffer, offset, length, position, canOwn) {
+        var node = stream.node;
+        node.timestamp = Date.now();
+        var contents = node.contents;
+#if USE_TYPED_ARRAYS == 2
+        if (length && contents.length === 0 && position === 0 && buffer.subarray) {
+          // just replace it with the new data
+          assert(buffer.length);
+          if (canOwn && buffer.buffer === HEAP8.buffer && offset === 0) {
+            node.contents = buffer; // this is a subarray of the heap, and we can own it
+            node.contentMode = MEMFS.CONTENT_OWNING;
+          } else {
+            node.contents = new Uint8Array(buffer.subarray(offset, offset+length));
+            node.contentMode = MEMFS.CONTENT_FIXED;
+          }
+          return length;
+        }
+#endif
+        MEMFS.ensureFlexible(node);
+        var contents = node.contents;
+        while (contents.length < position) contents.push(0);
+        for (var i = 0; i < length; i++) {
+          contents[position + i] = buffer[offset + i];
+        }
+        return length;
+      },
+      llseek: function(stream, offset, whence) {
+        var position = offset;
+        if (whence === 1) {  // SEEK_CUR.
+          position += stream.position;
+        } else if (whence === 2) {  // SEEK_END.
+          if (FS.isFile(stream.node.mode)) {
+            position += stream.node.contents.length;
+          }
+        }
+        if (position < 0) {
+          throw new FS.ErrnoError(ERRNO_CODES.EINVAL);
+        }
+        stream.ungotten = [];
+        stream.position = position;
+        return position;
+      },
+      allocate: function(stream, offset, length) {
+        MEMFS.ensureFlexible(stream.node);
+        var contents = stream.node.contents;
+        var limit = offset + length;
+        while (limit > contents.length) contents.push(0);
+      },
+      mmap: function(stream, buffer, offset, length, position, prot, flags) {
+        if (!FS.isFile(stream.node.mode)) {
+          throw new FS.ErrnoError(ERRNO_CODES.ENODEV);
+        }
+        var ptr;
+        var allocated;
+        var contents = stream.node.contents;
+        // Only make a new copy when MAP_PRIVATE is specified.
+        if ( !(flags & {{{ cDefine('MAP_PRIVATE') }}}) &&
+              (contents.buffer === buffer || contents.buffer === buffer.buffer) ) {
+          // We can't emulate MAP_SHARED when the file is not backed by the buffer
+          // we're mapping to (e.g. the HEAP buffer).
+          allocated = false;
+          ptr = contents.byteOffset;
+        } else {
+          // Try to avoid unnecessary slices.
+          if (position > 0 || position + length < contents.length) {
+            if (contents.subarray) {
+              contents = contents.subarray(position, position + length);
+            } else {
+              contents = Array.prototype.slice.call(contents, position, position + length);
+            }
+          }
+          allocated = true;
+          ptr = _malloc(length);
+          if (!ptr) {
+            throw new FS.ErrnoError(ERRNO_CODES.ENOMEM);
+          }
+          buffer.set(contents, ptr);
+        }
+        return { ptr: ptr, allocated: allocated };
+      },
+    }
+  }
+});
+