share context creation code between sdl and glut in browser

3 files changed, 95 insertions, 108 deletions

diff --git a/src/library_browser.js b/src/library_browser.js
index f5f0ed82..17dff2eb 100644
--- a/src/library_browser.js
+++ b/src/library_browser.js
@@ -20,11 +20,100 @@ mergeInto(LibraryManager.library, {
   },
 
   $Browser: {
+    createContext: function(canvas, useWebGL) {
+#if !USE_TYPED_ARRAYS
+      if (useWebGL) {
+        Module.print('(USE_TYPED_ARRAYS needs to be enabled for WebGL)');
+        return null;
+      }
+#endif
+      try {
+        var ctx = canvas.getContext(useWebGL ? 'experimental-webgl' : '2d');
+        if (!ctx) throw ':(';
+      } catch (e) {
+        Module.print('Could not create canvas - ' + e);
+        return null;
+      }
+      if (useWebGL) {
+#if GL_DEBUG
+        // Useful to debug native webgl apps: var Module = { printErr: function(x) { console.log(x) } };
+        var tempCtx = ctx;
+        var wrapper = {};
+        wrapper.objectMap = new WeakMap();
+        wrapper.objectCounter = 1;
+        for (var prop in tempCtx) {
+          (function(prop) {
+            switch (typeof tempCtx[prop]) {
+              case 'function': {
+                wrapper[prop] = function() {
+                  var printArgs = Array.prototype.slice.call(arguments).map(function(arg) {
+                    if (wrapper.objectMap[arg]) return '<' + arg + '|' + wrapper.objectMap[arg] + '>';
+                    if (arg.toString() == '[object HTMLImageElement]') {
+                      return arg + '\n\n';
+                    }
+                    if (arg.byteLength) {
+                      var buf = new ArrayBuffer(32);
+                      var i8buf = new Int8Array(buf);
+                      var f32buf = new Float32Array(buf);
+                      switch(arg.toString()) {
+                        case '[object Uint8Array]':
+                          i8buf.set(arg.subarray(0, 32));
+                          break;
+                        case '[object Float32Array]':
+                          f32buf.set(arg.subarray(0, 5));
+                          break;
+                        default:
+                          alert('unknown array for debugging: ' + arg);
+                          throw 'see alert';
+                      }
+                      var ret = '{' + arg.byteLength + ':\n';
+                      var arr = Array.prototype.slice.call(i8buf);
+                      ret += 'i8:' + arr.toString().replace(/,/g, ',') + '\n';
+                      arr = Array.prototype.slice.call(f32buf, 0, 8);
+                      ret += 'f32:' + arr.toString().replace(/,/g, ',') + '}';
+                      return ret;
+                    }
+                    return arg;
+                  });
+                  Module.printErr('[gl_f:' + prop + ':' + printArgs + ']');
+                  var ret = tempCtx[prop].apply(tempCtx, arguments);
+                  var printRet = ret;
+                  if (typeof ret == 'object') {
+                    wrapper.objectMap[ret] = wrapper.objectCounter++;
+                    printRet = '<' + ret + '|' + wrapper.objectMap[ret] + '>';
+                  }
+                  Module.printErr('[     gl:' + prop + ':return:' + printRet + ']');
+                  return ret;
+                }
+                break;
+              }
+              case 'number': case 'string': {
+                wrapper.__defineGetter__(prop, function() {
+                  //Module.printErr('[gl_g:' + prop + ':' + tempCtx[prop] + ']');
+                  return tempCtx[prop];
+                });
+                wrapper.__defineSetter__(prop, function(value) {
+                  Module.printErr('[gl_s:' + prop + ':' + value + ']');
+                  tempCtx[prop] = value;
+                });
+                break;
+              }
+            }
+          })(prop);
+        }
+        ctx = wrapper;
+#endif
+        // Set the background of the WebGL canvas to black
+        canvas.style.backgroundColor = "black";
+      }
+      return ctx;
+    },
+
     // Given binary data for an image, in a format like PNG or JPG, we convert it
     // to flat pixel data. We do so using the browser's native code.
     // This is deprecated, it is preferred to load binary files, createObjectURL, etc.,
     // see the sdl_* tests.
-    decodeImage: function(pixels, format) {
+    /*decodeImage: function(pixels, format) {
       function encodeBase64(data) {
         var BASE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
         var PAD = '=';
@@ -59,7 +148,7 @@ mergeInto(LibraryManager.library, {
       ctx.drawImage(image, 0, 0);
       var imageData = ctx.getImageData(0, 0, canvas.width, canvas.height);
       return imageData;
-    },
+    },*/ 
   }
 });
 
diff --git a/src/library_glut.js b/src/library_glut.js
index b57e1475..0de0ce6a 100644
--- a/src/library_glut.js
+++ b/src/library_glut.js
@@ -365,89 +365,9 @@ var LibraryGLUT = {
     GLUT.mouseFunc = func;
   },
 
+  glutCreateWindow__deps: ['$Browser'],
   glutCreateWindow: function(name) {
-#if USE_TYPED_ARRAYS
-    try {
-      var ctx = Module["canvas"].getContext('experimental-webgl');
-      if (!ctx) throw 'Could not create canvas :(';
-#if GL_DEBUG
-      // Useful to debug native webgl apps: var Module = { printErr: function(x) { console.log(x) } };
-      var wrapper = {};
-      wrapper.objectMap = new WeakMap();
-      wrapper.objectCounter = 1;
-      for (var prop in ctx) {
-        (function(prop) {
-          switch (typeof ctx[prop]) {
-            case 'function': {
-              wrapper[prop] = function() {
-                var printArgs = Array.prototype.slice.call(arguments).map(function(arg) {
-                  if (wrapper.objectMap[arg]) return '<' + arg + '|' + wrapper.objectMap[arg] + '>';
-                  if (arg.toString() == '[object HTMLImageElement]') {
-                    return arg + '\n\n';
-                  }
-                  if (arg.byteLength) {
-                    var buf = new ArrayBuffer(32);
-                    var i8buf = new Int8Array(buf);
-                    var f32buf = new Float32Array(buf);
-                    switch(arg.toString()) {
-                      case '[object Uint8Array]':
-                        i8buf.set(arg.subarray(0, 32));
-                        break;
-                      case '[object Float32Array]':
-                        f32buf.set(arg.subarray(0, 5));
-                        break;
-                      default:
-                        alert('unknown array for debugging: ' + arg);
-                        throw 'see alert';
-                    }
-                    var ret = '{' + arg.byteLength + ':\n';
-                    var arr = Array.prototype.slice.call(i8buf);
-                    ret += 'i8:' + arr.toString().replace(/,/g, ',') + '\n';
-                    arr = Array.prototype.slice.call(f32buf, 0, 8);
-                    ret += 'f32:' + arr.toString().replace(/,/g, ',') + '}';
-                    return ret;
-                  }
-                  return arg;
-                });
-                Module.printErr('[gl_f:' + prop + ':' + printArgs + ']');
-                var ret = ctx[prop].apply(ctx, arguments);
-                var printRet = ret;
-                if (typeof ret == 'object') {
-                  wrapper.objectMap[ret] = wrapper.objectCounter++;
-                  printRet = '<' + ret + '|' + wrapper.objectMap[ret] + '>';
-                }
-                Module.printErr('[     gl:' + prop + ':return:' + printRet + ']');
-                return ret;
-              }
-              break;
-            }
-            case 'number': case 'string': {
-              wrapper.__defineGetter__(prop, function() {
-                //Module.printErr('[gl_g:' + prop + ':' + ctx[prop] + ']');
-                return ctx[prop];
-              });
-              wrapper.__defineSetter__(prop, function(value) {
-                Module.printErr('[gl_s:' + prop + ':' + value + ']');
-                ctx[prop] = value;
-              });
-              break;
-            }
-          }
-        })(prop);
-      }
-      Module.ctx = wrapper;
-#else
-      Module.ctx = ctx;
-#endif
-      // Set the background of the canvas to black, because glut gives us a
-      // window which has a black background by default.
-      Module["canvas"].style.backgroundColor = "black";
-    } catch (e) {
-      Module.print('(canvas not available)');
-    }
-#else
-    Module.print('(USE_TYPED_ARRAYS needs to be enabled for WebGL)');
-#endif
+    Module.ctx = Browser.createContext(Module['canvas'], true);
     return 1;
   },
 
diff --git a/src/library_sdl.js b/src/library_sdl.js
index 24b90dce..c5190aa8 100644
--- a/src/library_sdl.js
+++ b/src/library_sdl.js
@@ -76,7 +76,7 @@
 //  * SDL_Quit does nothing.
 
 mergeInto(LibraryManager.library, {
-  $SDL__deps: ['$FS'],
+  $SDL__deps: ['$FS', '$Browser'],
   $SDL: {
     defaults: {
       width: 320,
@@ -285,7 +285,7 @@ mergeInto(LibraryManager.library, {
       } else {
         canvas = Module['canvas'];
       }
-      var ctx = SDL.createContext(canvas, useWebGL);
+      var ctx = Browser.createContext(canvas, useWebGL);
       if (usePageCanvas) {
         Module.ctx = ctx;
       }
@@ -306,28 +306,6 @@ mergeInto(LibraryManager.library, {
       return surf;
     },
 
-    createContext: function(canvas, useWebGL) {
-#if !USE_TYPED_ARRAYS
-      if (useWebGL) {
-	Module.print('(USE_TYPED_ARRAYS needs to be enabled for WebGL)');
-        return null;
-      }
-#endif
-      try {
-        var ctx = canvas.getContext(useWebGL ? 'experimental-webgl' : '2d');
-        if (!ctx) throw 'Could not create canvas :(';
-        if (useWebGL) {
-          // Set the background of the WebGL canvas to black, because SDL gives us a
-          // window which has a black background by default.
-          canvas.style.backgroundColor = "black";
-        }
-        return ctx;
-      } catch (e) {
-        Module.print('(canvas not available)');
-        return null;
-      }
-    },
-
     freeSurface: function(surf) {
       _free(SDL.surfaces[surf].buffer);
       _free(SDL.surfaces[surf].pixelFormat);