diff --git a/test/index.js b/test/index.js
index 7424430..bf50692 100755
--- a/test/index.js
+++ b/test/index.js
@@ -14,4 +14,5 @@
     require('./core');
     require('./interaction');
     require('./renders');
+    require('./prepare');
 });

diff --git a/test/index.js b/test/index.js
index 7424430..bf50692 100755
--- a/test/index.js
+++ b/test/index.js
@@ -14,4 +14,5 @@
     require('./core');
     require('./interaction');
     require('./renders');
+    require('./prepare');
 });
diff --git a/test/prepare/BasePrepare.js b/test/prepare/BasePrepare.js
new file mode 100644
index 0000000..a0fa06b
--- /dev/null
+++ b/test/prepare/BasePrepare.js
@@ -0,0 +1,158 @@
+'use strict';
+
+describe('PIXI.prepare.BasePrepare', function ()
+{
+    it('should create a new, empty, BasePrepare', function ()
+    {
+        const renderer = {};
+        const prep = new PIXI.prepare.BasePrepare(renderer);
+
+        expect(prep.renderer).to.equal(renderer);
+        expect(prep.uploadHookHelper).to.be.null;
+        expect(prep.queue).to.be.empty;
+        expect(prep.addHooks).to.be.empty;
+        expect(prep.uploadHooks).to.be.empty;
+        expect(prep.completes).to.be.empty;
+
+        prep.destroy();
+    });
+
+    it('should add hooks', function ()
+    {
+        function addHook() { /* empty */ }
+        function uploadHook() { /* empty */ }
+        const prep = new PIXI.prepare.BasePrepare();
+
+        prep.register(addHook, uploadHook);
+
+        expect(prep.addHooks).to.contain(addHook);
+        expect(prep.addHooks).to.have.lengthOf(1);
+        expect(prep.uploadHooks).to.contain(uploadHook);
+        expect(prep.uploadHooks).to.have.lengthOf(1);
+
+        prep.destroy();
+    });
+
+    it('should call hooks and complete', function ()
+    {
+        const prep = new PIXI.prepare.BasePrepare();
+        const uploadItem = {};
+        const uploadHelper = {};
+
+        prep.uploadHookHelper = uploadHelper;
+
+        const addHook = sinon.spy(function (item, queue)
+        {
+            expect(item).to.equal(uploadItem);
+            expect(queue).to.equal(prep.queue);
+            queue.push(item);
+
+            return true;
+        });
+        const uploadHook = sinon.spy(function (helper, item)
+        {
+            expect(helper).to.equal(uploadHelper);
+            expect(item).to.equal(uploadItem);
+
+            return true;
+        });
+        const complete = sinon.spy(function () { /* empty */ });
+
+        prep.register(addHook, uploadHook);
+        prep.upload(uploadItem, complete);
+
+        expect(prep.queue).to.contain(uploadItem);
+
+        prep.tick();
+
+        expect(addHook.calledOnce).to.be.true;
+        expect(uploadHook.calledOnce).to.be.true;
+        expect(complete.calledOnce).to.be.true;
+
+        prep.destroy();
+    });
+
+    it('should call complete if no queue', function ()
+    {
+        const prep = new PIXI.prepare.BasePrepare();
+
+        function addHook()
+        {
+            return false;
+        }
+        const complete = sinon.spy(function () { /* empty */ });
+
+        prep.register(addHook);
+        prep.upload({}, complete);
+
+        expect(complete.calledOnce).to.be.true;
+
+        prep.destroy();
+    });
+
+    it('should remove un-preparable items from queue', function ()
+    {
+        const prep = new PIXI.prepare.BasePrepare();
+
+        const addHook = sinon.spy(function (item, queue)
+        {
+            queue.push(item);
+
+            return true;
+        });
+        const uploadHook = sinon.spy(function ()
+        {
+            return false;
+        });
+        const complete = sinon.spy(function () { /* empty */ });
+
+        prep.register(addHook, uploadHook);
+        prep.upload({}, complete);
+
+        expect(prep.queue).to.have.lengthOf(1);
+
+        prep.tick();
+
+        expect(prep.queue).to.be.empty;
+        expect(addHook.calledOnce).to.be.true;
+        expect(uploadHook.calledOnce).to.be.true;
+        expect(complete.calledOnce).to.be.true;
+
+        prep.destroy();
+    });
+
+    it('should attach to SharedTicker', function (done)
+    {
+        const prep = new PIXI.prepare.BasePrepare();
+
+        const addHook = sinon.spy(function (item, queue)
+        {
+            queue.push(item);
+
+            return true;
+        });
+        const uploadHook = sinon.spy(function ()
+        {
+            return true;
+        });
+
+        function complete()
+        {
+            expect(prep.queue).to.be.empty;
+            expect(addHook.calledOnce).to.be.true;
+            expect(uploadHook.calledOnce).to.be.true;
+
+            prep.destroy();
+
+            done();
+        }
+
+        prep.register(addHook, uploadHook);
+        prep.upload({}, complete);
+
+        expect(prep.queue).to.have.lengthOf(1);
+        expect(addHook.called).to.be.true;
+        expect(uploadHook.called).to.be.false;
+        expect(complete.called).to.not.be.ok;
+    });
+});

diff --git a/test/index.js b/test/index.js
index 7424430..bf50692 100755
--- a/test/index.js
+++ b/test/index.js
@@ -14,4 +14,5 @@
     require('./core');
     require('./interaction');
     require('./renders');
+    require('./prepare');
 });
diff --git a/test/prepare/BasePrepare.js b/test/prepare/BasePrepare.js
new file mode 100644
index 0000000..a0fa06b
--- /dev/null
+++ b/test/prepare/BasePrepare.js
@@ -0,0 +1,158 @@
+'use strict';
+
+describe('PIXI.prepare.BasePrepare', function ()
+{
+    it('should create a new, empty, BasePrepare', function ()
+    {
+        const renderer = {};
+        const prep = new PIXI.prepare.BasePrepare(renderer);
+
+        expect(prep.renderer).to.equal(renderer);
+        expect(prep.uploadHookHelper).to.be.null;
+        expect(prep.queue).to.be.empty;
+        expect(prep.addHooks).to.be.empty;
+        expect(prep.uploadHooks).to.be.empty;
+        expect(prep.completes).to.be.empty;
+
+        prep.destroy();
+    });
+
+    it('should add hooks', function ()
+    {
+        function addHook() { /* empty */ }
+        function uploadHook() { /* empty */ }
+        const prep = new PIXI.prepare.BasePrepare();
+
+        prep.register(addHook, uploadHook);
+
+        expect(prep.addHooks).to.contain(addHook);
+        expect(prep.addHooks).to.have.lengthOf(1);
+        expect(prep.uploadHooks).to.contain(uploadHook);
+        expect(prep.uploadHooks).to.have.lengthOf(1);
+
+        prep.destroy();
+    });
+
+    it('should call hooks and complete', function ()
+    {
+        const prep = new PIXI.prepare.BasePrepare();
+        const uploadItem = {};
+        const uploadHelper = {};
+
+        prep.uploadHookHelper = uploadHelper;
+
+        const addHook = sinon.spy(function (item, queue)
+        {
+            expect(item).to.equal(uploadItem);
+            expect(queue).to.equal(prep.queue);
+            queue.push(item);
+
+            return true;
+        });
+        const uploadHook = sinon.spy(function (helper, item)
+        {
+            expect(helper).to.equal(uploadHelper);
+            expect(item).to.equal(uploadItem);
+
+            return true;
+        });
+        const complete = sinon.spy(function () { /* empty */ });
+
+        prep.register(addHook, uploadHook);
+        prep.upload(uploadItem, complete);
+
+        expect(prep.queue).to.contain(uploadItem);
+
+        prep.tick();
+
+        expect(addHook.calledOnce).to.be.true;
+        expect(uploadHook.calledOnce).to.be.true;
+        expect(complete.calledOnce).to.be.true;
+
+        prep.destroy();
+    });
+
+    it('should call complete if no queue', function ()
+    {
+        const prep = new PIXI.prepare.BasePrepare();
+
+        function addHook()
+        {
+            return false;
+        }
+        const complete = sinon.spy(function () { /* empty */ });
+
+        prep.register(addHook);
+        prep.upload({}, complete);
+
+        expect(complete.calledOnce).to.be.true;
+
+        prep.destroy();
+    });
+
+    it('should remove un-preparable items from queue', function ()
+    {
+        const prep = new PIXI.prepare.BasePrepare();
+
+        const addHook = sinon.spy(function (item, queue)
+        {
+            queue.push(item);
+
+            return true;
+        });
+        const uploadHook = sinon.spy(function ()
+        {
+            return false;
+        });
+        const complete = sinon.spy(function () { /* empty */ });
+
+        prep.register(addHook, uploadHook);
+        prep.upload({}, complete);
+
+        expect(prep.queue).to.have.lengthOf(1);
+
+        prep.tick();
+
+        expect(prep.queue).to.be.empty;
+        expect(addHook.calledOnce).to.be.true;
+        expect(uploadHook.calledOnce).to.be.true;
+        expect(complete.calledOnce).to.be.true;
+
+        prep.destroy();
+    });
+
+    it('should attach to SharedTicker', function (done)
+    {
+        const prep = new PIXI.prepare.BasePrepare();
+
+        const addHook = sinon.spy(function (item, queue)
+        {
+            queue.push(item);
+
+            return true;
+        });
+        const uploadHook = sinon.spy(function ()
+        {
+            return true;
+        });
+
+        function complete()
+        {
+            expect(prep.queue).to.be.empty;
+            expect(addHook.calledOnce).to.be.true;
+            expect(uploadHook.calledOnce).to.be.true;
+
+            prep.destroy();
+
+            done();
+        }
+
+        prep.register(addHook, uploadHook);
+        prep.upload({}, complete);
+
+        expect(prep.queue).to.have.lengthOf(1);
+        expect(addHook.called).to.be.true;
+        expect(uploadHook.called).to.be.false;
+        expect(complete.called).to.not.be.ok;
+    });
+});
diff --git a/test/prepare/CountLimiter.js b/test/prepare/CountLimiter.js
new file mode 100644
index 0000000..570ff5c
--- /dev/null
+++ b/test/prepare/CountLimiter.js
@@ -0,0 +1,21 @@
+'use strict';
+
+describe('PIXI.prepare.CountLimiter', function ()
+{
+    it('should limit to specified number per beginFrame()', function ()
+    {
+        const limit = new PIXI.prepare.CountLimiter(3);
+
+        limit.beginFrame();
+        expect(limit.allowedToUpload()).to.be.true;
+        expect(limit.allowedToUpload()).to.be.true;
+        expect(limit.allowedToUpload()).to.be.true;
+        expect(limit.allowedToUpload()).to.be.false;
+
+        limit.beginFrame();
+        expect(limit.allowedToUpload()).to.be.true;
+        expect(limit.allowedToUpload()).to.be.true;
+        expect(limit.allowedToUpload()).to.be.true;
+        expect(limit.allowedToUpload()).to.be.false;
+    });
+});

diff --git a/test/index.js b/test/index.js
index 7424430..bf50692 100755
--- a/test/index.js
+++ b/test/index.js
@@ -14,4 +14,5 @@
     require('./core');
     require('./interaction');
     require('./renders');
+    require('./prepare');
 });
diff --git a/test/prepare/BasePrepare.js b/test/prepare/BasePrepare.js
new file mode 100644
index 0000000..a0fa06b
--- /dev/null
+++ b/test/prepare/BasePrepare.js
@@ -0,0 +1,158 @@
+'use strict';
+
+describe('PIXI.prepare.BasePrepare', function ()
+{
+    it('should create a new, empty, BasePrepare', function ()
+    {
+        const renderer = {};
+        const prep = new PIXI.prepare.BasePrepare(renderer);
+
+        expect(prep.renderer).to.equal(renderer);
+        expect(prep.uploadHookHelper).to.be.null;
+        expect(prep.queue).to.be.empty;
+        expect(prep.addHooks).to.be.empty;
+        expect(prep.uploadHooks).to.be.empty;
+        expect(prep.completes).to.be.empty;
+
+        prep.destroy();
+    });
+
+    it('should add hooks', function ()
+    {
+        function addHook() { /* empty */ }
+        function uploadHook() { /* empty */ }
+        const prep = new PIXI.prepare.BasePrepare();
+
+        prep.register(addHook, uploadHook);
+
+        expect(prep.addHooks).to.contain(addHook);
+        expect(prep.addHooks).to.have.lengthOf(1);
+        expect(prep.uploadHooks).to.contain(uploadHook);
+        expect(prep.uploadHooks).to.have.lengthOf(1);
+
+        prep.destroy();
+    });
+
+    it('should call hooks and complete', function ()
+    {
+        const prep = new PIXI.prepare.BasePrepare();
+        const uploadItem = {};
+        const uploadHelper = {};
+
+        prep.uploadHookHelper = uploadHelper;
+
+        const addHook = sinon.spy(function (item, queue)
+        {
+            expect(item).to.equal(uploadItem);
+            expect(queue).to.equal(prep.queue);
+            queue.push(item);
+
+            return true;
+        });
+        const uploadHook = sinon.spy(function (helper, item)
+        {
+            expect(helper).to.equal(uploadHelper);
+            expect(item).to.equal(uploadItem);
+
+            return true;
+        });
+        const complete = sinon.spy(function () { /* empty */ });
+
+        prep.register(addHook, uploadHook);
+        prep.upload(uploadItem, complete);
+
+        expect(prep.queue).to.contain(uploadItem);
+
+        prep.tick();
+
+        expect(addHook.calledOnce).to.be.true;
+        expect(uploadHook.calledOnce).to.be.true;
+        expect(complete.calledOnce).to.be.true;
+
+        prep.destroy();
+    });
+
+    it('should call complete if no queue', function ()
+    {
+        const prep = new PIXI.prepare.BasePrepare();
+
+        function addHook()
+        {
+            return false;
+        }
+        const complete = sinon.spy(function () { /* empty */ });
+
+        prep.register(addHook);
+        prep.upload({}, complete);
+
+        expect(complete.calledOnce).to.be.true;
+
+        prep.destroy();
+    });
+
+    it('should remove un-preparable items from queue', function ()
+    {
+        const prep = new PIXI.prepare.BasePrepare();
+
+        const addHook = sinon.spy(function (item, queue)
+        {
+            queue.push(item);
+
+            return true;
+        });
+        const uploadHook = sinon.spy(function ()
+        {
+            return false;
+        });
+        const complete = sinon.spy(function () { /* empty */ });
+
+        prep.register(addHook, uploadHook);
+        prep.upload({}, complete);
+
+        expect(prep.queue).to.have.lengthOf(1);
+
+        prep.tick();
+
+        expect(prep.queue).to.be.empty;
+        expect(addHook.calledOnce).to.be.true;
+        expect(uploadHook.calledOnce).to.be.true;
+        expect(complete.calledOnce).to.be.true;
+
+        prep.destroy();
+    });
+
+    it('should attach to SharedTicker', function (done)
+    {
+        const prep = new PIXI.prepare.BasePrepare();
+
+        const addHook = sinon.spy(function (item, queue)
+        {
+            queue.push(item);
+
+            return true;
+        });
+        const uploadHook = sinon.spy(function ()
+        {
+            return true;
+        });
+
+        function complete()
+        {
+            expect(prep.queue).to.be.empty;
+            expect(addHook.calledOnce).to.be.true;
+            expect(uploadHook.calledOnce).to.be.true;
+
+            prep.destroy();
+
+            done();
+        }
+
+        prep.register(addHook, uploadHook);
+        prep.upload({}, complete);
+
+        expect(prep.queue).to.have.lengthOf(1);
+        expect(addHook.called).to.be.true;
+        expect(uploadHook.called).to.be.false;
+        expect(complete.called).to.not.be.ok;
+    });
+});
diff --git a/test/prepare/CountLimiter.js b/test/prepare/CountLimiter.js
new file mode 100644
index 0000000..570ff5c
--- /dev/null
+++ b/test/prepare/CountLimiter.js
@@ -0,0 +1,21 @@
+'use strict';
+
+describe('PIXI.prepare.CountLimiter', function ()
+{
+    it('should limit to specified number per beginFrame()', function ()
+    {
+        const limit = new PIXI.prepare.CountLimiter(3);
+
+        limit.beginFrame();
+        expect(limit.allowedToUpload()).to.be.true;
+        expect(limit.allowedToUpload()).to.be.true;
+        expect(limit.allowedToUpload()).to.be.true;
+        expect(limit.allowedToUpload()).to.be.false;
+
+        limit.beginFrame();
+        expect(limit.allowedToUpload()).to.be.true;
+        expect(limit.allowedToUpload()).to.be.true;
+        expect(limit.allowedToUpload()).to.be.true;
+        expect(limit.allowedToUpload()).to.be.false;
+    });
+});
diff --git a/test/prepare/TimeLimiter.js b/test/prepare/TimeLimiter.js
new file mode 100644
index 0000000..3db1f51
--- /dev/null
+++ b/test/prepare/TimeLimiter.js
@@ -0,0 +1,26 @@
+'use strict';
+
+describe('PIXI.prepare.TimeLimiter', function ()
+{
+    it('should limit to stop after time from beginFrame()', function (done)
+    {
+        const limit = new PIXI.prepare.TimeLimiter(3);
+
+        limit.beginFrame();
+        for (let i = 0; i < 20; ++i)
+        {
+            expect(limit.allowedToUpload()).to.be.true;
+        }
+
+        setTimeout(function ()
+        {
+            expect(limit.allowedToUpload()).to.be.false;
+
+            limit.beginFrame();
+
+            expect(limit.allowedToUpload()).to.be.true;
+
+            done();
+        }, 4);
+    });
+});

diff --git a/test/index.js b/test/index.js
index 7424430..bf50692 100755
--- a/test/index.js
+++ b/test/index.js
@@ -14,4 +14,5 @@
     require('./core');
     require('./interaction');
     require('./renders');
+    require('./prepare');
 });
diff --git a/test/prepare/BasePrepare.js b/test/prepare/BasePrepare.js
new file mode 100644
index 0000000..a0fa06b
--- /dev/null
+++ b/test/prepare/BasePrepare.js
@@ -0,0 +1,158 @@
+'use strict';
+
+describe('PIXI.prepare.BasePrepare', function ()
+{
+    it('should create a new, empty, BasePrepare', function ()
+    {
+        const renderer = {};
+        const prep = new PIXI.prepare.BasePrepare(renderer);
+
+        expect(prep.renderer).to.equal(renderer);
+        expect(prep.uploadHookHelper).to.be.null;
+        expect(prep.queue).to.be.empty;
+        expect(prep.addHooks).to.be.empty;
+        expect(prep.uploadHooks).to.be.empty;
+        expect(prep.completes).to.be.empty;
+
+        prep.destroy();
+    });
+
+    it('should add hooks', function ()
+    {
+        function addHook() { /* empty */ }
+        function uploadHook() { /* empty */ }
+        const prep = new PIXI.prepare.BasePrepare();
+
+        prep.register(addHook, uploadHook);
+
+        expect(prep.addHooks).to.contain(addHook);
+        expect(prep.addHooks).to.have.lengthOf(1);
+        expect(prep.uploadHooks).to.contain(uploadHook);
+        expect(prep.uploadHooks).to.have.lengthOf(1);
+
+        prep.destroy();
+    });
+
+    it('should call hooks and complete', function ()
+    {
+        const prep = new PIXI.prepare.BasePrepare();
+        const uploadItem = {};
+        const uploadHelper = {};
+
+        prep.uploadHookHelper = uploadHelper;
+
+        const addHook = sinon.spy(function (item, queue)
+        {
+            expect(item).to.equal(uploadItem);
+            expect(queue).to.equal(prep.queue);
+            queue.push(item);
+
+            return true;
+        });
+        const uploadHook = sinon.spy(function (helper, item)
+        {
+            expect(helper).to.equal(uploadHelper);
+            expect(item).to.equal(uploadItem);
+
+            return true;
+        });
+        const complete = sinon.spy(function () { /* empty */ });
+
+        prep.register(addHook, uploadHook);
+        prep.upload(uploadItem, complete);
+
+        expect(prep.queue).to.contain(uploadItem);
+
+        prep.tick();
+
+        expect(addHook.calledOnce).to.be.true;
+        expect(uploadHook.calledOnce).to.be.true;
+        expect(complete.calledOnce).to.be.true;
+
+        prep.destroy();
+    });
+
+    it('should call complete if no queue', function ()
+    {
+        const prep = new PIXI.prepare.BasePrepare();
+
+        function addHook()
+        {
+            return false;
+        }
+        const complete = sinon.spy(function () { /* empty */ });
+
+        prep.register(addHook);
+        prep.upload({}, complete);
+
+        expect(complete.calledOnce).to.be.true;
+
+        prep.destroy();
+    });
+
+    it('should remove un-preparable items from queue', function ()
+    {
+        const prep = new PIXI.prepare.BasePrepare();
+
+        const addHook = sinon.spy(function (item, queue)
+        {
+            queue.push(item);
+
+            return true;
+        });
+        const uploadHook = sinon.spy(function ()
+        {
+            return false;
+        });
+        const complete = sinon.spy(function () { /* empty */ });
+
+        prep.register(addHook, uploadHook);
+        prep.upload({}, complete);
+
+        expect(prep.queue).to.have.lengthOf(1);
+
+        prep.tick();
+
+        expect(prep.queue).to.be.empty;
+        expect(addHook.calledOnce).to.be.true;
+        expect(uploadHook.calledOnce).to.be.true;
+        expect(complete.calledOnce).to.be.true;
+
+        prep.destroy();
+    });
+
+    it('should attach to SharedTicker', function (done)
+    {
+        const prep = new PIXI.prepare.BasePrepare();
+
+        const addHook = sinon.spy(function (item, queue)
+        {
+            queue.push(item);
+
+            return true;
+        });
+        const uploadHook = sinon.spy(function ()
+        {
+            return true;
+        });
+
+        function complete()
+        {
+            expect(prep.queue).to.be.empty;
+            expect(addHook.calledOnce).to.be.true;
+            expect(uploadHook.calledOnce).to.be.true;
+
+            prep.destroy();
+
+            done();
+        }
+
+        prep.register(addHook, uploadHook);
+        prep.upload({}, complete);
+
+        expect(prep.queue).to.have.lengthOf(1);
+        expect(addHook.called).to.be.true;
+        expect(uploadHook.called).to.be.false;
+        expect(complete.called).to.not.be.ok;
+    });
+});
diff --git a/test/prepare/CountLimiter.js b/test/prepare/CountLimiter.js
new file mode 100644
index 0000000..570ff5c
--- /dev/null
+++ b/test/prepare/CountLimiter.js
@@ -0,0 +1,21 @@
+'use strict';
+
+describe('PIXI.prepare.CountLimiter', function ()
+{
+    it('should limit to specified number per beginFrame()', function ()
+    {
+        const limit = new PIXI.prepare.CountLimiter(3);
+
+        limit.beginFrame();
+        expect(limit.allowedToUpload()).to.be.true;
+        expect(limit.allowedToUpload()).to.be.true;
+        expect(limit.allowedToUpload()).to.be.true;
+        expect(limit.allowedToUpload()).to.be.false;
+
+        limit.beginFrame();
+        expect(limit.allowedToUpload()).to.be.true;
+        expect(limit.allowedToUpload()).to.be.true;
+        expect(limit.allowedToUpload()).to.be.true;
+        expect(limit.allowedToUpload()).to.be.false;
+    });
+});
diff --git a/test/prepare/TimeLimiter.js b/test/prepare/TimeLimiter.js
new file mode 100644
index 0000000..3db1f51
--- /dev/null
+++ b/test/prepare/TimeLimiter.js
@@ -0,0 +1,26 @@
+'use strict';
+
+describe('PIXI.prepare.TimeLimiter', function ()
+{
+    it('should limit to stop after time from beginFrame()', function (done)
+    {
+        const limit = new PIXI.prepare.TimeLimiter(3);
+
+        limit.beginFrame();
+        for (let i = 0; i < 20; ++i)
+        {
+            expect(limit.allowedToUpload()).to.be.true;
+        }
+
+        setTimeout(function ()
+        {
+            expect(limit.allowedToUpload()).to.be.false;
+
+            limit.beginFrame();
+
+            expect(limit.allowedToUpload()).to.be.true;
+
+            done();
+        }, 4);
+    });
+});
diff --git a/test/prepare/index.js b/test/prepare/index.js
new file mode 100644
index 0000000..ecc127c
--- /dev/null
+++ b/test/prepare/index.js
@@ -0,0 +1,5 @@
+'use strict';
+
+require('./CountLimiter');
+require('./TimeLimiter');
+require('./BasePrepare');