var LibraryHUMBLE = {
|
$HUMBLE_API: {
|
options: {
|
/**
|
* allows altering the incoming URL before it is fetched from the network
|
* ex. function(path) { return path; }
|
*/
|
locateAsset: null,
|
/**
|
* returns a key for the specified path. return null to NOT cache the specific resource
|
* for scoped keys.. return { scope: 'deadbeef', path: 'path' }, otherwise just return a string
|
* ex. function(path) { return path; }
|
*/
|
buildCacheKey: null,
|
/**
|
* function returning a hash like {width: 800, height: 600, locked: true}
|
* locked specifies whether the game should use that width/height.
|
* ex. function() { return { width: 800, height: 600, locked: true } }
|
*/
|
playerSize: null,
|
/**
|
* callback to handle the demo_ended API from in the game
|
* the callback takes no parameters.
|
*/
|
demoEndedCallback: null
|
},
|
callbacks: {
|
/**
|
* a callback in the game code to set the expected player volume.
|
* The callback takes a float parameter with a value between 0.0 and 1.0
|
*/
|
setPlayerVolume: null,
|
/**
|
* a callback to set the fullscreen
|
*/
|
setPlayerFullscreen: null
|
},
|
/**
|
* Attempts to call into the app to inform it that the volume should be adjusted
|
* @param volume the float volume (between 0.0 and 1.0)
|
* @return bool.. true if the callback was successful.. false if no callback registered
|
*/
|
setPlayerVolume: function(volume) {
|
if (HUMBLE_API.callbacks.setPlayerVolume == null) return false;
|
var cb = HUMBLE_API.callbacks.setPlayerVolume[0],
|
data = HUMBLE_API.callbacks.setPlayerVolume[1];
|
if (volume > 1.0) volume = 1.0;
|
if (volume < 0.0) volume = 0.0;
|
Runtime.dynCall('vdi', cb, [volume, data]);
|
return true;
|
},
|
/**
|
* Attempts to call into the app to inform it that it should change to or from fullscreen mode
|
* @param fullscreen A bool of either true or false
|
* @return bool.. true if the callback was successful.. false if no callback registered
|
*/
|
setPlayerFullscreen: function(fullscreen) {
|
if (HUMBLE_API.callbacks.setPlayerFullscreen == null) return false;
|
var cb = HUMBLE_API.callbacks.setPlayerFullscreen[0],
|
data = HUMBLE_API.callbacks.setPlayerFullscreen[1];
|
Runtime.dynCall('vii', cb, [fullscreen ? 1 : 0, data]);
|
return true;
|
},
|
/**
|
* allows configuring the HUMBLE_API simply call this method in a preRun to initialize..
|
* any option is accepted and will be added to the configuration hash.
|
* Also all hooks will be context of HUMBLE_API so this.options.myCustomKey will be accessible
|
*/
|
configure: function(options) {
|
for (var i in options) {
|
HUMBLE_API.options[i] = options[i];
|
}
|
},
|
|
locateAsset: function(path) {
|
if (HUMBLE_API.options.locateAsset) {
|
return HUMBLE_API.options.locateAsset.call(HUMBLE_API, path);
|
} else {
|
return path;
|
}
|
},
|
|
buildCacheKey: function(path) {
|
if (HUMBLE_API.options.buildCacheKey) {
|
return HUMBLE_API.options.buildCacheKey.call(HUMBLE_API, path);
|
} else {
|
return null;
|
}
|
},
|
|
pathToKey: function(path) {
|
if (typeof path == 'string') {
|
return { path: path, scope: '', key: ':' + path};
|
} else {
|
return { path: path.path, scope: path.scope, key: path.scope + ':' + path.path };
|
}
|
},
|
// deletes all entries for the specified scope
|
clearCacheByScope: function(scope, oncomplete) {
|
HUMBLE_API.getDB(function(err, db) {
|
if (err) return oncomplete(err);
|
|
var transaction = db.transaction([HUMBLE_API.DB_ASYNC_CACHE_STORE], 'readwrite');
|
transaction.onerror = function() { oncomplete(this.error); };
|
|
var store = transaction.objectStore(HUMBLE_API.DB_ASYNC_CACHE_STORE);
|
var index = store.index('scope');
|
|
index.openKeyCursor(IDBKeyRange.only(scope)).onsuccess = function(e) {
|
var cursor = event.target.result;
|
|
if (cursor) {
|
store.delete(cursor.primaryKey);
|
|
cursor.continue();
|
} else {
|
oncomplete(null);
|
}
|
};
|
});
|
},
|
storeToCache: function(path, byteArray, ondone) {
|
if (path === null) {
|
return ondone(null);
|
}
|
|
HUMBLE_API.getDB(function(err, db) {
|
if (err) return ondone(err);
|
|
var transaction = db.transaction([HUMBLE_API.DB_ASYNC_CACHE_STORE], 'readwrite');
|
transaction.onerror = function() { ondone(this.error); };
|
|
var store = transaction.objectStore(HUMBLE_API.DB_ASYNC_CACHE_STORE);
|
|
var data = HUMBLE_API.pathToKey(path);
|
data['data'] = byteArray;
|
|
var req = store.put(data);
|
|
req.onsuccess = function(e) {
|
ondone(null);
|
};
|
req.onerror = function() { ondone(this.error); };
|
});
|
},
|
fetchFromCache: function(path, ondone, onfail) {
|
if (path === null) {
|
return onfail(null);
|
}
|
HUMBLE_API.getDB(function(err, db) {
|
if (err) return onfail(err);
|
|
var transaction = db.transaction([HUMBLE_API.DB_ASYNC_CACHE_STORE], 'readonly');
|
transaction.onerror = function() { onfail(this.error); };
|
|
var store = transaction.objectStore(HUMBLE_API.DB_ASYNC_CACHE_STORE);
|
|
var data = HUMBLE_API.pathToKey(path);
|
|
var req = store.get(data.key);
|
req.onsuccess = function(e) {
|
if (e.target.result) {
|
var o = e.target.result;
|
ondone(o.data);
|
} else {
|
onfail(null);
|
}
|
};
|
req.onerror = function() { onfail(this.error); };
|
});
|
},
|
|
/* indexedDB access */
|
// borrowed from IDBFS
|
dbs: {},
|
indexedDB: function() {
|
if (typeof indexedDB !== 'undefined') return indexedDB;
|
var ret = null;
|
if (typeof window === 'object') ret = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
|
assert(ret, 'IDBFS used, but indexedDB not supported');
|
return ret;
|
},
|
DB_VERSION: 1,
|
DB_NAME: 'HUMBLE_API',
|
DB_ASYNC_CACHE_STORE: 'HUMBLE_API_ASYNC',
|
getDB: function(callback) {
|
var db = HUMBLE_API.dbs[HUMBLE_API.DB_NAME];
|
if (db) {
|
return callback(null, db);
|
}
|
|
var req;
|
try {
|
req = HUMBLE_API.indexedDB().open(HUMBLE_API.DB_NAME, HUMBLE_API.DB_VERSION)
|
} catch (e) {
|
return callback(e);
|
}
|
req.onupgradeneeded = function(e) {
|
var db = e.target.result;
|
|
var fileStore;
|
|
// Just replace it for now
|
fileStore = db.createObjectStore(HUMBLE_API.DB_ASYNC_CACHE_STORE, {keyPath: 'key'});
|
fileStore.createIndex('scope','scope',{ unique: false });
|
};
|
req.onsuccess = function() {
|
db = req.result;
|
|
HUMBLE_API.dbs[HUMBLE_API.DB_NAME] = db;
|
callback(null, db);
|
};
|
req.onerror = function() {
|
callback(this.error);
|
};
|
}
|
},
|
humble_init__deps: ['$CLOUDFS','$HUMBLE_API'],
|
humble_init: function() {
|
// Dummy function to pull in the rest of the functions
|
},
|
humble_syncfs__deps: ['$FS', '$CLOUDFS','$HUMBLE_API'],
|
humble_syncfs: function() {
|
FS.syncfs(function (err) {
|
console.log('File Sync');
|
});
|
},
|
humble_fetch_asset_data__deps: ['$BROWSER','$HUMBLE_API'],
|
humble_fetch_asset_data: function(assetPath, arg, onload, onerror) {
|
var path = Pointer_stringify(assetPath);
|
var cacheKey = HUMBLE_API.buildCacheKey(path);
|
|
HUMBLE_API.fetchFromCache(cacheKey, function(byteArray) {
|
var buffer = _malloc(byteArray.length);
|
HEAPU8.set(byteArray, buffer);
|
Runtime.dynCall('viii', onload, [arg, buffer, byteArray.length]);
|
_free(buffer);
|
}, function(err) {
|
try {
|
var url = HUMBLE_API.locateAsset(path);
|
Browser.asyncLoad(url, function (byteArray) {
|
HUMBLE_API.storeToCache(cacheKey, byteArray, function (err) {
|
var buffer = _malloc(byteArray.length);
|
HEAPU8.set(byteArray, buffer);
|
Runtime.dynCall('viii', onload, [arg, buffer, byteArray.length]);
|
_free(buffer);
|
});
|
}, function() {
|
if (onerror) Runtime.dynCall('vi', onerror, [arg]);
|
}, true /* NO run dependency */);
|
} catch(ex) {
|
if (onerror) Runtime.dynCall('vi', onerror, [arg]);
|
}
|
});
|
},
|
humble_get_player_size__deps: ['$HUMBLE_API'],
|
humble_get_player_size: function(w, h) {
|
var ret = {width: 0, height: 0, locked: false};
|
if (HUMBLE_API.options.playerSize) {
|
ret = HUMBLE_API.options.playerSize();
|
}
|
if (w && ret.width > 0) {{{ makeSetValue('w', '0', 'ret.width', 'i32') }}};
|
if (h && ret.height > 0) {{{ makeSetValue('h', '0', 'ret.height', 'i32') }}};
|
return ret.locked ? 1 : 0;
|
},
|
humble_demo_ended__deps: ['$HUMBLE_API'],
|
humble_demo_ended: function() {
|
if (HUMBLE_API.options.demoEndedCallback) {
|
return HUMBLE_API.options.demoEndedCallback.call(HUMBLE_API);
|
}
|
},
|
humble_set_callback__deps: ['$HUMBLE_API'],
|
humble_set_callback: function(type, cb, data) {
|
var key = null;
|
switch(type) {
|
case 1: key = 'setPlayerVolume'; break;
|
case 2: key = 'setPlayerFullscreen'; break;
|
}
|
if (key == null) {
|
return 0;
|
}
|
if (cb == 0) {
|
HUMBLE_API.callbacks[key] = null;
|
} else {
|
HUMBLE_API.callbacks[key] = [cb, data];
|
}
|
return 1;
|
},
|
};
|
|
mergeInto(LibraryManager.library, LibraryHUMBLE);
|
