From 93c9acc6114863af8dc0b7af816bba03efe8e759 Mon Sep 17 00:00:00 2001
From: george-pro <48039709+george-pro@users.noreply.github.com>
Date: Sat, 6 Apr 2019 22:41:32 -0500
Subject: [PATCH] replaced push.lua with up-to-date file 4-6-2019

---
 pong-1/push.lua     | 110 +++++++++++++++++++++++++++++++-------------
 pong-10/push.lua    | 110 +++++++++++++++++++++++++++++++-------------
 pong-11/push.lua    | 110 +++++++++++++++++++++++++++++++-------------
 pong-12/push.lua    | 110 +++++++++++++++++++++++++++++++-------------
 pong-2/push.lua     | 110 +++++++++++++++++++++++++++++++-------------
 pong-3/push.lua     | 110 +++++++++++++++++++++++++++++++-------------
 pong-4/push.lua     | 110 +++++++++++++++++++++++++++++++-------------
 pong-5/push.lua     | 110 +++++++++++++++++++++++++++++++-------------
 pong-6/push.lua     | 110 +++++++++++++++++++++++++++++++-------------
 pong-7/push.lua     | 110 +++++++++++++++++++++++++++++++-------------
 pong-8/push.lua     | 110 +++++++++++++++++++++++++++++++-------------
 pong-9/push.lua     | 110 +++++++++++++++++++++++++++++++-------------
 pong-final/push.lua |   9 +++-
 13 files changed, 931 insertions(+), 398 deletions(-)

diff --git a/pong-1/push.lua b/pong-1/push.lua
index 0e0709a..ee9bf07 100644
--- a/pong-1/push.lua
+++ b/pong-1/push.lua
@@ -1,10 +1,18 @@
--- push.lua v0.2
+-- push.lua v0.3
 
--- Copyright (c) 2017 Ulysse Ramage
+-- Copyright (c) 2018 Ulysse Ramage
 -- 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.
 
+local love11 = love.getVersion() == 11
+local getDPI = love11 and love.window.getDPIScale or love.window.getPixelScale
+local windowUpdateMode = love11 and love.window.updateMode or function(width, height, settings)
+  local _, _, flags = love.window.getMode()
+  for k, v in pairs(settings) do flags[k] = v end
+  love.window.setMode(width, height, flags)
+end
+
 local push = {
   
   defaults = {
@@ -18,9 +26,6 @@ local push = {
 }
 setmetatable(push, push)
 
---TODO: rendering resolution?
---TODO: clean up code
-
 function push:applySettings(settings)
   for k, v in pairs(settings) do
     self["_" .. k] = v
@@ -39,11 +44,11 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
   self:applySettings(self.defaults) --set defaults first
   self:applySettings(settings) --then fill with custom settings
   
-  love.window.setMode( self._RWIDTH, self._RHEIGHT, {
+  windowUpdateMode(self._RWIDTH, self._RHEIGHT, {
     fullscreen = self._fullscreen,
     resizable = self._resizable,
     highdpi = self._highdpi
-  } )
+  })
 
   self:initValues()
 
@@ -62,25 +67,29 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
 end
 
 function push:setupCanvas(canvases)
-  table.insert(canvases, { name = "_render" }) --final render
+  table.insert(canvases, { name = "_render", private = true }) --final render
 
   self._canvas = true
   self.canvases = {}
 
   for i = 1, #canvases do
-    self.canvases[i] = {
-      name = canvases[i].name,
-      shader = canvases[i].shader,
-      canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
-    }
+    push:addCanvas(canvases[i])
   end
 
   return self
 end
+function push:addCanvas(params)
+  table.insert(self.canvases, {
+    name = params.name,
+    private = params.private,
+    shader = params.shader,
+    canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
+  })
+end
 
 function push:setCanvas(name)
   if not self._canvas then return true end
-  return love.graphics.setCanvas( self:getCanvasTable(name).canvas )
+  return love.graphics.setCanvas(self:getCanvasTable(name).canvas)
 end
 function push:getCanvasTable(name)
   for i = 1, #self.canvases do
@@ -98,7 +107,7 @@ function push:setShader(name, shader)
 end
 
 function push:initValues()
-  self._PSCALE = self._highdpi and love.window.getPixelScale() or 1
+  self._PSCALE = (not love11 and self._highdpi) and getDPI() or 1
   
   self._SCALE = {
     x = self._RWIDTH/self._WWIDTH * self._PSCALE,
@@ -119,13 +128,8 @@ function push:initValues()
   self._GHEIGHT = self._RHEIGHT * self._PSCALE - self._OFFSET.y * 2
 end
 
---[[ DEPRECATED ]]--
 function push:apply(operation, shader)
-  if operation == "start" then
-    self:start()
-  elseif operation == "finish" or operation == "end" then
-    self:finish(shader)
-  end
+  self._drawFunctions[operation](self, shader)
 end
 
 function push:start()
@@ -140,6 +144,40 @@ function push:start()
   end
 end
 
+function push:applyShaders(canvas, shaders)
+  local _shader = love.graphics.getShader()
+  if #shaders <= 1 then
+    love.graphics.setShader(shaders[1])
+    love.graphics.draw(canvas)
+  else
+    local _canvas = love.graphics.getCanvas()
+
+    local _tmp = self:getCanvasTable("_tmp")
+    if not _tmp then --create temp canvas only if needed
+      self:addCanvas({ name = "_tmp", private = true, shader = nil })
+      _tmp = self:getCanvasTable("_tmp")
+    end
+
+    love.graphics.push()
+    love.graphics.origin()
+    local outputCanvas
+    for i = 1, #shaders do
+      local inputCanvas = i % 2 == 1 and canvas or _tmp.canvas
+      outputCanvas = i % 2 == 0 and canvas or _tmp.canvas
+      love.graphics.setCanvas(outputCanvas)
+      love.graphics.clear()
+      love.graphics.setShader(shaders[i])
+      love.graphics.draw(inputCanvas)
+      love.graphics.setCanvas(inputCanvas)
+    end
+    love.graphics.pop()
+
+    love.graphics.setCanvas(_canvas)
+    love.graphics.draw(outputCanvas)
+  end
+  love.graphics.setShader(_shader)
+end
+
 function push:finish(shader)
   love.graphics.setBackgroundColor(unpack(self._borderColor))
   if self._canvas then
@@ -147,25 +185,32 @@ function push:finish(shader)
 
     love.graphics.pop()
 
-    love.graphics.setColor(255, 255, 255)
+    local white = love11 and 1 or 255
+    love.graphics.setColor(white, white, white)
 
     --draw canvas
     love.graphics.setCanvas(_render.canvas)
-    for i = 1, #self.canvases - 1 do --do not draw _render yet
+    for i = 1, #self.canvases do --do not draw _render yet
       local _table = self.canvases[i]
-      love.graphics.setShader(_table.shader)
-      love.graphics.draw(_table.canvas)
+      if not _table.private then
+        local _canvas = _table.canvas
+        local _shader = _table.shader
+        self:applyShaders(_canvas, type(_shader) == "table" and _shader or { _shader })
+      end
     end
     love.graphics.setCanvas()
-
+    
     --draw render
     love.graphics.translate(self._OFFSET.x, self._OFFSET.y)
-    love.graphics.setShader(shader or self:getCanvasTable("_render").shader)
-    love.graphics.draw(self:getCanvasTable("_render").canvas, 0, 0, 0, self._SCALE.x, self._SCALE.y)
+    local shader = shader or _render.shader
+    love.graphics.push()
+    love.graphics.scale(self._SCALE.x, self._SCALE.y)
+    self:applyShaders(_render.canvas, type(shader) == "table" and shader or { shader })
+    love.graphics.pop()
 
     --clear canvas
     for i = 1, #self.canvases do
-      love.graphics.setCanvas( self.canvases[i].canvas )
+      love.graphics.setCanvas(self.canvases[i].canvas)
       love.graphics.clear()
     end
 
@@ -193,7 +238,7 @@ end
 
 --doesn't work - TODO
 function push:toReal(x, y)
-  return x+self._OFFSET.x, y+self._OFFSET.y
+  return x + self._OFFSET.x, y + self._OFFSET.y
 end
 
 function push:switchFullscreen(winw, winh)
@@ -213,13 +258,12 @@ function push:switchFullscreen(winw, winh)
   
   love.window.setFullscreen(self._fullscreen, "desktop")
   if not self._fullscreen and (winw or winh) then
-    love.window.setMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
+    windowUpdateMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
   end
 end
 
 function push:resize(w, h)
-  local pixelScale = love.window.getPixelScale()
-  if self._highdpi then w, h = w / pixelScale, h / pixelScale end
+  if self._highdpi then w, h = w / self._PSCALE, h / self._PSCALE end
   self._RWIDTH = w
   self._RHEIGHT = h
   self:initValues()
diff --git a/pong-10/push.lua b/pong-10/push.lua
index 0e0709a..ee9bf07 100644
--- a/pong-10/push.lua
+++ b/pong-10/push.lua
@@ -1,10 +1,18 @@
--- push.lua v0.2
+-- push.lua v0.3
 
--- Copyright (c) 2017 Ulysse Ramage
+-- Copyright (c) 2018 Ulysse Ramage
 -- 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.
 
+local love11 = love.getVersion() == 11
+local getDPI = love11 and love.window.getDPIScale or love.window.getPixelScale
+local windowUpdateMode = love11 and love.window.updateMode or function(width, height, settings)
+  local _, _, flags = love.window.getMode()
+  for k, v in pairs(settings) do flags[k] = v end
+  love.window.setMode(width, height, flags)
+end
+
 local push = {
   
   defaults = {
@@ -18,9 +26,6 @@ local push = {
 }
 setmetatable(push, push)
 
---TODO: rendering resolution?
---TODO: clean up code
-
 function push:applySettings(settings)
   for k, v in pairs(settings) do
     self["_" .. k] = v
@@ -39,11 +44,11 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
   self:applySettings(self.defaults) --set defaults first
   self:applySettings(settings) --then fill with custom settings
   
-  love.window.setMode( self._RWIDTH, self._RHEIGHT, {
+  windowUpdateMode(self._RWIDTH, self._RHEIGHT, {
     fullscreen = self._fullscreen,
     resizable = self._resizable,
     highdpi = self._highdpi
-  } )
+  })
 
   self:initValues()
 
@@ -62,25 +67,29 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
 end
 
 function push:setupCanvas(canvases)
-  table.insert(canvases, { name = "_render" }) --final render
+  table.insert(canvases, { name = "_render", private = true }) --final render
 
   self._canvas = true
   self.canvases = {}
 
   for i = 1, #canvases do
-    self.canvases[i] = {
-      name = canvases[i].name,
-      shader = canvases[i].shader,
-      canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
-    }
+    push:addCanvas(canvases[i])
   end
 
   return self
 end
+function push:addCanvas(params)
+  table.insert(self.canvases, {
+    name = params.name,
+    private = params.private,
+    shader = params.shader,
+    canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
+  })
+end
 
 function push:setCanvas(name)
   if not self._canvas then return true end
-  return love.graphics.setCanvas( self:getCanvasTable(name).canvas )
+  return love.graphics.setCanvas(self:getCanvasTable(name).canvas)
 end
 function push:getCanvasTable(name)
   for i = 1, #self.canvases do
@@ -98,7 +107,7 @@ function push:setShader(name, shader)
 end
 
 function push:initValues()
-  self._PSCALE = self._highdpi and love.window.getPixelScale() or 1
+  self._PSCALE = (not love11 and self._highdpi) and getDPI() or 1
   
   self._SCALE = {
     x = self._RWIDTH/self._WWIDTH * self._PSCALE,
@@ -119,13 +128,8 @@ function push:initValues()
   self._GHEIGHT = self._RHEIGHT * self._PSCALE - self._OFFSET.y * 2
 end
 
---[[ DEPRECATED ]]--
 function push:apply(operation, shader)
-  if operation == "start" then
-    self:start()
-  elseif operation == "finish" or operation == "end" then
-    self:finish(shader)
-  end
+  self._drawFunctions[operation](self, shader)
 end
 
 function push:start()
@@ -140,6 +144,40 @@ function push:start()
   end
 end
 
+function push:applyShaders(canvas, shaders)
+  local _shader = love.graphics.getShader()
+  if #shaders <= 1 then
+    love.graphics.setShader(shaders[1])
+    love.graphics.draw(canvas)
+  else
+    local _canvas = love.graphics.getCanvas()
+
+    local _tmp = self:getCanvasTable("_tmp")
+    if not _tmp then --create temp canvas only if needed
+      self:addCanvas({ name = "_tmp", private = true, shader = nil })
+      _tmp = self:getCanvasTable("_tmp")
+    end
+
+    love.graphics.push()
+    love.graphics.origin()
+    local outputCanvas
+    for i = 1, #shaders do
+      local inputCanvas = i % 2 == 1 and canvas or _tmp.canvas
+      outputCanvas = i % 2 == 0 and canvas or _tmp.canvas
+      love.graphics.setCanvas(outputCanvas)
+      love.graphics.clear()
+      love.graphics.setShader(shaders[i])
+      love.graphics.draw(inputCanvas)
+      love.graphics.setCanvas(inputCanvas)
+    end
+    love.graphics.pop()
+
+    love.graphics.setCanvas(_canvas)
+    love.graphics.draw(outputCanvas)
+  end
+  love.graphics.setShader(_shader)
+end
+
 function push:finish(shader)
   love.graphics.setBackgroundColor(unpack(self._borderColor))
   if self._canvas then
@@ -147,25 +185,32 @@ function push:finish(shader)
 
     love.graphics.pop()
 
-    love.graphics.setColor(255, 255, 255)
+    local white = love11 and 1 or 255
+    love.graphics.setColor(white, white, white)
 
     --draw canvas
     love.graphics.setCanvas(_render.canvas)
-    for i = 1, #self.canvases - 1 do --do not draw _render yet
+    for i = 1, #self.canvases do --do not draw _render yet
       local _table = self.canvases[i]
-      love.graphics.setShader(_table.shader)
-      love.graphics.draw(_table.canvas)
+      if not _table.private then
+        local _canvas = _table.canvas
+        local _shader = _table.shader
+        self:applyShaders(_canvas, type(_shader) == "table" and _shader or { _shader })
+      end
     end
     love.graphics.setCanvas()
-
+    
     --draw render
     love.graphics.translate(self._OFFSET.x, self._OFFSET.y)
-    love.graphics.setShader(shader or self:getCanvasTable("_render").shader)
-    love.graphics.draw(self:getCanvasTable("_render").canvas, 0, 0, 0, self._SCALE.x, self._SCALE.y)
+    local shader = shader or _render.shader
+    love.graphics.push()
+    love.graphics.scale(self._SCALE.x, self._SCALE.y)
+    self:applyShaders(_render.canvas, type(shader) == "table" and shader or { shader })
+    love.graphics.pop()
 
     --clear canvas
     for i = 1, #self.canvases do
-      love.graphics.setCanvas( self.canvases[i].canvas )
+      love.graphics.setCanvas(self.canvases[i].canvas)
       love.graphics.clear()
     end
 
@@ -193,7 +238,7 @@ end
 
 --doesn't work - TODO
 function push:toReal(x, y)
-  return x+self._OFFSET.x, y+self._OFFSET.y
+  return x + self._OFFSET.x, y + self._OFFSET.y
 end
 
 function push:switchFullscreen(winw, winh)
@@ -213,13 +258,12 @@ function push:switchFullscreen(winw, winh)
   
   love.window.setFullscreen(self._fullscreen, "desktop")
   if not self._fullscreen and (winw or winh) then
-    love.window.setMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
+    windowUpdateMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
   end
 end
 
 function push:resize(w, h)
-  local pixelScale = love.window.getPixelScale()
-  if self._highdpi then w, h = w / pixelScale, h / pixelScale end
+  if self._highdpi then w, h = w / self._PSCALE, h / self._PSCALE end
   self._RWIDTH = w
   self._RHEIGHT = h
   self:initValues()
diff --git a/pong-11/push.lua b/pong-11/push.lua
index 0e0709a..ee9bf07 100644
--- a/pong-11/push.lua
+++ b/pong-11/push.lua
@@ -1,10 +1,18 @@
--- push.lua v0.2
+-- push.lua v0.3
 
--- Copyright (c) 2017 Ulysse Ramage
+-- Copyright (c) 2018 Ulysse Ramage
 -- 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.
 
+local love11 = love.getVersion() == 11
+local getDPI = love11 and love.window.getDPIScale or love.window.getPixelScale
+local windowUpdateMode = love11 and love.window.updateMode or function(width, height, settings)
+  local _, _, flags = love.window.getMode()
+  for k, v in pairs(settings) do flags[k] = v end
+  love.window.setMode(width, height, flags)
+end
+
 local push = {
   
   defaults = {
@@ -18,9 +26,6 @@ local push = {
 }
 setmetatable(push, push)
 
---TODO: rendering resolution?
---TODO: clean up code
-
 function push:applySettings(settings)
   for k, v in pairs(settings) do
     self["_" .. k] = v
@@ -39,11 +44,11 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
   self:applySettings(self.defaults) --set defaults first
   self:applySettings(settings) --then fill with custom settings
   
-  love.window.setMode( self._RWIDTH, self._RHEIGHT, {
+  windowUpdateMode(self._RWIDTH, self._RHEIGHT, {
     fullscreen = self._fullscreen,
     resizable = self._resizable,
     highdpi = self._highdpi
-  } )
+  })
 
   self:initValues()
 
@@ -62,25 +67,29 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
 end
 
 function push:setupCanvas(canvases)
-  table.insert(canvases, { name = "_render" }) --final render
+  table.insert(canvases, { name = "_render", private = true }) --final render
 
   self._canvas = true
   self.canvases = {}
 
   for i = 1, #canvases do
-    self.canvases[i] = {
-      name = canvases[i].name,
-      shader = canvases[i].shader,
-      canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
-    }
+    push:addCanvas(canvases[i])
   end
 
   return self
 end
+function push:addCanvas(params)
+  table.insert(self.canvases, {
+    name = params.name,
+    private = params.private,
+    shader = params.shader,
+    canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
+  })
+end
 
 function push:setCanvas(name)
   if not self._canvas then return true end
-  return love.graphics.setCanvas( self:getCanvasTable(name).canvas )
+  return love.graphics.setCanvas(self:getCanvasTable(name).canvas)
 end
 function push:getCanvasTable(name)
   for i = 1, #self.canvases do
@@ -98,7 +107,7 @@ function push:setShader(name, shader)
 end
 
 function push:initValues()
-  self._PSCALE = self._highdpi and love.window.getPixelScale() or 1
+  self._PSCALE = (not love11 and self._highdpi) and getDPI() or 1
   
   self._SCALE = {
     x = self._RWIDTH/self._WWIDTH * self._PSCALE,
@@ -119,13 +128,8 @@ function push:initValues()
   self._GHEIGHT = self._RHEIGHT * self._PSCALE - self._OFFSET.y * 2
 end
 
---[[ DEPRECATED ]]--
 function push:apply(operation, shader)
-  if operation == "start" then
-    self:start()
-  elseif operation == "finish" or operation == "end" then
-    self:finish(shader)
-  end
+  self._drawFunctions[operation](self, shader)
 end
 
 function push:start()
@@ -140,6 +144,40 @@ function push:start()
   end
 end
 
+function push:applyShaders(canvas, shaders)
+  local _shader = love.graphics.getShader()
+  if #shaders <= 1 then
+    love.graphics.setShader(shaders[1])
+    love.graphics.draw(canvas)
+  else
+    local _canvas = love.graphics.getCanvas()
+
+    local _tmp = self:getCanvasTable("_tmp")
+    if not _tmp then --create temp canvas only if needed
+      self:addCanvas({ name = "_tmp", private = true, shader = nil })
+      _tmp = self:getCanvasTable("_tmp")
+    end
+
+    love.graphics.push()
+    love.graphics.origin()
+    local outputCanvas
+    for i = 1, #shaders do
+      local inputCanvas = i % 2 == 1 and canvas or _tmp.canvas
+      outputCanvas = i % 2 == 0 and canvas or _tmp.canvas
+      love.graphics.setCanvas(outputCanvas)
+      love.graphics.clear()
+      love.graphics.setShader(shaders[i])
+      love.graphics.draw(inputCanvas)
+      love.graphics.setCanvas(inputCanvas)
+    end
+    love.graphics.pop()
+
+    love.graphics.setCanvas(_canvas)
+    love.graphics.draw(outputCanvas)
+  end
+  love.graphics.setShader(_shader)
+end
+
 function push:finish(shader)
   love.graphics.setBackgroundColor(unpack(self._borderColor))
   if self._canvas then
@@ -147,25 +185,32 @@ function push:finish(shader)
 
     love.graphics.pop()
 
-    love.graphics.setColor(255, 255, 255)
+    local white = love11 and 1 or 255
+    love.graphics.setColor(white, white, white)
 
     --draw canvas
     love.graphics.setCanvas(_render.canvas)
-    for i = 1, #self.canvases - 1 do --do not draw _render yet
+    for i = 1, #self.canvases do --do not draw _render yet
       local _table = self.canvases[i]
-      love.graphics.setShader(_table.shader)
-      love.graphics.draw(_table.canvas)
+      if not _table.private then
+        local _canvas = _table.canvas
+        local _shader = _table.shader
+        self:applyShaders(_canvas, type(_shader) == "table" and _shader or { _shader })
+      end
     end
     love.graphics.setCanvas()
-
+    
     --draw render
     love.graphics.translate(self._OFFSET.x, self._OFFSET.y)
-    love.graphics.setShader(shader or self:getCanvasTable("_render").shader)
-    love.graphics.draw(self:getCanvasTable("_render").canvas, 0, 0, 0, self._SCALE.x, self._SCALE.y)
+    local shader = shader or _render.shader
+    love.graphics.push()
+    love.graphics.scale(self._SCALE.x, self._SCALE.y)
+    self:applyShaders(_render.canvas, type(shader) == "table" and shader or { shader })
+    love.graphics.pop()
 
     --clear canvas
     for i = 1, #self.canvases do
-      love.graphics.setCanvas( self.canvases[i].canvas )
+      love.graphics.setCanvas(self.canvases[i].canvas)
       love.graphics.clear()
     end
 
@@ -193,7 +238,7 @@ end
 
 --doesn't work - TODO
 function push:toReal(x, y)
-  return x+self._OFFSET.x, y+self._OFFSET.y
+  return x + self._OFFSET.x, y + self._OFFSET.y
 end
 
 function push:switchFullscreen(winw, winh)
@@ -213,13 +258,12 @@ function push:switchFullscreen(winw, winh)
   
   love.window.setFullscreen(self._fullscreen, "desktop")
   if not self._fullscreen and (winw or winh) then
-    love.window.setMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
+    windowUpdateMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
   end
 end
 
 function push:resize(w, h)
-  local pixelScale = love.window.getPixelScale()
-  if self._highdpi then w, h = w / pixelScale, h / pixelScale end
+  if self._highdpi then w, h = w / self._PSCALE, h / self._PSCALE end
   self._RWIDTH = w
   self._RHEIGHT = h
   self:initValues()
diff --git a/pong-12/push.lua b/pong-12/push.lua
index 0e0709a..ee9bf07 100644
--- a/pong-12/push.lua
+++ b/pong-12/push.lua
@@ -1,10 +1,18 @@
--- push.lua v0.2
+-- push.lua v0.3
 
--- Copyright (c) 2017 Ulysse Ramage
+-- Copyright (c) 2018 Ulysse Ramage
 -- 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.
 
+local love11 = love.getVersion() == 11
+local getDPI = love11 and love.window.getDPIScale or love.window.getPixelScale
+local windowUpdateMode = love11 and love.window.updateMode or function(width, height, settings)
+  local _, _, flags = love.window.getMode()
+  for k, v in pairs(settings) do flags[k] = v end
+  love.window.setMode(width, height, flags)
+end
+
 local push = {
   
   defaults = {
@@ -18,9 +26,6 @@ local push = {
 }
 setmetatable(push, push)
 
---TODO: rendering resolution?
---TODO: clean up code
-
 function push:applySettings(settings)
   for k, v in pairs(settings) do
     self["_" .. k] = v
@@ -39,11 +44,11 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
   self:applySettings(self.defaults) --set defaults first
   self:applySettings(settings) --then fill with custom settings
   
-  love.window.setMode( self._RWIDTH, self._RHEIGHT, {
+  windowUpdateMode(self._RWIDTH, self._RHEIGHT, {
     fullscreen = self._fullscreen,
     resizable = self._resizable,
     highdpi = self._highdpi
-  } )
+  })
 
   self:initValues()
 
@@ -62,25 +67,29 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
 end
 
 function push:setupCanvas(canvases)
-  table.insert(canvases, { name = "_render" }) --final render
+  table.insert(canvases, { name = "_render", private = true }) --final render
 
   self._canvas = true
   self.canvases = {}
 
   for i = 1, #canvases do
-    self.canvases[i] = {
-      name = canvases[i].name,
-      shader = canvases[i].shader,
-      canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
-    }
+    push:addCanvas(canvases[i])
   end
 
   return self
 end
+function push:addCanvas(params)
+  table.insert(self.canvases, {
+    name = params.name,
+    private = params.private,
+    shader = params.shader,
+    canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
+  })
+end
 
 function push:setCanvas(name)
   if not self._canvas then return true end
-  return love.graphics.setCanvas( self:getCanvasTable(name).canvas )
+  return love.graphics.setCanvas(self:getCanvasTable(name).canvas)
 end
 function push:getCanvasTable(name)
   for i = 1, #self.canvases do
@@ -98,7 +107,7 @@ function push:setShader(name, shader)
 end
 
 function push:initValues()
-  self._PSCALE = self._highdpi and love.window.getPixelScale() or 1
+  self._PSCALE = (not love11 and self._highdpi) and getDPI() or 1
   
   self._SCALE = {
     x = self._RWIDTH/self._WWIDTH * self._PSCALE,
@@ -119,13 +128,8 @@ function push:initValues()
   self._GHEIGHT = self._RHEIGHT * self._PSCALE - self._OFFSET.y * 2
 end
 
---[[ DEPRECATED ]]--
 function push:apply(operation, shader)
-  if operation == "start" then
-    self:start()
-  elseif operation == "finish" or operation == "end" then
-    self:finish(shader)
-  end
+  self._drawFunctions[operation](self, shader)
 end
 
 function push:start()
@@ -140,6 +144,40 @@ function push:start()
   end
 end
 
+function push:applyShaders(canvas, shaders)
+  local _shader = love.graphics.getShader()
+  if #shaders <= 1 then
+    love.graphics.setShader(shaders[1])
+    love.graphics.draw(canvas)
+  else
+    local _canvas = love.graphics.getCanvas()
+
+    local _tmp = self:getCanvasTable("_tmp")
+    if not _tmp then --create temp canvas only if needed
+      self:addCanvas({ name = "_tmp", private = true, shader = nil })
+      _tmp = self:getCanvasTable("_tmp")
+    end
+
+    love.graphics.push()
+    love.graphics.origin()
+    local outputCanvas
+    for i = 1, #shaders do
+      local inputCanvas = i % 2 == 1 and canvas or _tmp.canvas
+      outputCanvas = i % 2 == 0 and canvas or _tmp.canvas
+      love.graphics.setCanvas(outputCanvas)
+      love.graphics.clear()
+      love.graphics.setShader(shaders[i])
+      love.graphics.draw(inputCanvas)
+      love.graphics.setCanvas(inputCanvas)
+    end
+    love.graphics.pop()
+
+    love.graphics.setCanvas(_canvas)
+    love.graphics.draw(outputCanvas)
+  end
+  love.graphics.setShader(_shader)
+end
+
 function push:finish(shader)
   love.graphics.setBackgroundColor(unpack(self._borderColor))
   if self._canvas then
@@ -147,25 +185,32 @@ function push:finish(shader)
 
     love.graphics.pop()
 
-    love.graphics.setColor(255, 255, 255)
+    local white = love11 and 1 or 255
+    love.graphics.setColor(white, white, white)
 
     --draw canvas
     love.graphics.setCanvas(_render.canvas)
-    for i = 1, #self.canvases - 1 do --do not draw _render yet
+    for i = 1, #self.canvases do --do not draw _render yet
       local _table = self.canvases[i]
-      love.graphics.setShader(_table.shader)
-      love.graphics.draw(_table.canvas)
+      if not _table.private then
+        local _canvas = _table.canvas
+        local _shader = _table.shader
+        self:applyShaders(_canvas, type(_shader) == "table" and _shader or { _shader })
+      end
     end
     love.graphics.setCanvas()
-
+    
     --draw render
     love.graphics.translate(self._OFFSET.x, self._OFFSET.y)
-    love.graphics.setShader(shader or self:getCanvasTable("_render").shader)
-    love.graphics.draw(self:getCanvasTable("_render").canvas, 0, 0, 0, self._SCALE.x, self._SCALE.y)
+    local shader = shader or _render.shader
+    love.graphics.push()
+    love.graphics.scale(self._SCALE.x, self._SCALE.y)
+    self:applyShaders(_render.canvas, type(shader) == "table" and shader or { shader })
+    love.graphics.pop()
 
     --clear canvas
     for i = 1, #self.canvases do
-      love.graphics.setCanvas( self.canvases[i].canvas )
+      love.graphics.setCanvas(self.canvases[i].canvas)
       love.graphics.clear()
     end
 
@@ -193,7 +238,7 @@ end
 
 --doesn't work - TODO
 function push:toReal(x, y)
-  return x+self._OFFSET.x, y+self._OFFSET.y
+  return x + self._OFFSET.x, y + self._OFFSET.y
 end
 
 function push:switchFullscreen(winw, winh)
@@ -213,13 +258,12 @@ function push:switchFullscreen(winw, winh)
   
   love.window.setFullscreen(self._fullscreen, "desktop")
   if not self._fullscreen and (winw or winh) then
-    love.window.setMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
+    windowUpdateMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
   end
 end
 
 function push:resize(w, h)
-  local pixelScale = love.window.getPixelScale()
-  if self._highdpi then w, h = w / pixelScale, h / pixelScale end
+  if self._highdpi then w, h = w / self._PSCALE, h / self._PSCALE end
   self._RWIDTH = w
   self._RHEIGHT = h
   self:initValues()
diff --git a/pong-2/push.lua b/pong-2/push.lua
index 0e0709a..ee9bf07 100644
--- a/pong-2/push.lua
+++ b/pong-2/push.lua
@@ -1,10 +1,18 @@
--- push.lua v0.2
+-- push.lua v0.3
 
--- Copyright (c) 2017 Ulysse Ramage
+-- Copyright (c) 2018 Ulysse Ramage
 -- 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.
 
+local love11 = love.getVersion() == 11
+local getDPI = love11 and love.window.getDPIScale or love.window.getPixelScale
+local windowUpdateMode = love11 and love.window.updateMode or function(width, height, settings)
+  local _, _, flags = love.window.getMode()
+  for k, v in pairs(settings) do flags[k] = v end
+  love.window.setMode(width, height, flags)
+end
+
 local push = {
   
   defaults = {
@@ -18,9 +26,6 @@ local push = {
 }
 setmetatable(push, push)
 
---TODO: rendering resolution?
---TODO: clean up code
-
 function push:applySettings(settings)
   for k, v in pairs(settings) do
     self["_" .. k] = v
@@ -39,11 +44,11 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
   self:applySettings(self.defaults) --set defaults first
   self:applySettings(settings) --then fill with custom settings
   
-  love.window.setMode( self._RWIDTH, self._RHEIGHT, {
+  windowUpdateMode(self._RWIDTH, self._RHEIGHT, {
     fullscreen = self._fullscreen,
     resizable = self._resizable,
     highdpi = self._highdpi
-  } )
+  })
 
   self:initValues()
 
@@ -62,25 +67,29 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
 end
 
 function push:setupCanvas(canvases)
-  table.insert(canvases, { name = "_render" }) --final render
+  table.insert(canvases, { name = "_render", private = true }) --final render
 
   self._canvas = true
   self.canvases = {}
 
   for i = 1, #canvases do
-    self.canvases[i] = {
-      name = canvases[i].name,
-      shader = canvases[i].shader,
-      canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
-    }
+    push:addCanvas(canvases[i])
   end
 
   return self
 end
+function push:addCanvas(params)
+  table.insert(self.canvases, {
+    name = params.name,
+    private = params.private,
+    shader = params.shader,
+    canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
+  })
+end
 
 function push:setCanvas(name)
   if not self._canvas then return true end
-  return love.graphics.setCanvas( self:getCanvasTable(name).canvas )
+  return love.graphics.setCanvas(self:getCanvasTable(name).canvas)
 end
 function push:getCanvasTable(name)
   for i = 1, #self.canvases do
@@ -98,7 +107,7 @@ function push:setShader(name, shader)
 end
 
 function push:initValues()
-  self._PSCALE = self._highdpi and love.window.getPixelScale() or 1
+  self._PSCALE = (not love11 and self._highdpi) and getDPI() or 1
   
   self._SCALE = {
     x = self._RWIDTH/self._WWIDTH * self._PSCALE,
@@ -119,13 +128,8 @@ function push:initValues()
   self._GHEIGHT = self._RHEIGHT * self._PSCALE - self._OFFSET.y * 2
 end
 
---[[ DEPRECATED ]]--
 function push:apply(operation, shader)
-  if operation == "start" then
-    self:start()
-  elseif operation == "finish" or operation == "end" then
-    self:finish(shader)
-  end
+  self._drawFunctions[operation](self, shader)
 end
 
 function push:start()
@@ -140,6 +144,40 @@ function push:start()
   end
 end
 
+function push:applyShaders(canvas, shaders)
+  local _shader = love.graphics.getShader()
+  if #shaders <= 1 then
+    love.graphics.setShader(shaders[1])
+    love.graphics.draw(canvas)
+  else
+    local _canvas = love.graphics.getCanvas()
+
+    local _tmp = self:getCanvasTable("_tmp")
+    if not _tmp then --create temp canvas only if needed
+      self:addCanvas({ name = "_tmp", private = true, shader = nil })
+      _tmp = self:getCanvasTable("_tmp")
+    end
+
+    love.graphics.push()
+    love.graphics.origin()
+    local outputCanvas
+    for i = 1, #shaders do
+      local inputCanvas = i % 2 == 1 and canvas or _tmp.canvas
+      outputCanvas = i % 2 == 0 and canvas or _tmp.canvas
+      love.graphics.setCanvas(outputCanvas)
+      love.graphics.clear()
+      love.graphics.setShader(shaders[i])
+      love.graphics.draw(inputCanvas)
+      love.graphics.setCanvas(inputCanvas)
+    end
+    love.graphics.pop()
+
+    love.graphics.setCanvas(_canvas)
+    love.graphics.draw(outputCanvas)
+  end
+  love.graphics.setShader(_shader)
+end
+
 function push:finish(shader)
   love.graphics.setBackgroundColor(unpack(self._borderColor))
   if self._canvas then
@@ -147,25 +185,32 @@ function push:finish(shader)
 
     love.graphics.pop()
 
-    love.graphics.setColor(255, 255, 255)
+    local white = love11 and 1 or 255
+    love.graphics.setColor(white, white, white)
 
     --draw canvas
     love.graphics.setCanvas(_render.canvas)
-    for i = 1, #self.canvases - 1 do --do not draw _render yet
+    for i = 1, #self.canvases do --do not draw _render yet
       local _table = self.canvases[i]
-      love.graphics.setShader(_table.shader)
-      love.graphics.draw(_table.canvas)
+      if not _table.private then
+        local _canvas = _table.canvas
+        local _shader = _table.shader
+        self:applyShaders(_canvas, type(_shader) == "table" and _shader or { _shader })
+      end
     end
     love.graphics.setCanvas()
-
+    
     --draw render
     love.graphics.translate(self._OFFSET.x, self._OFFSET.y)
-    love.graphics.setShader(shader or self:getCanvasTable("_render").shader)
-    love.graphics.draw(self:getCanvasTable("_render").canvas, 0, 0, 0, self._SCALE.x, self._SCALE.y)
+    local shader = shader or _render.shader
+    love.graphics.push()
+    love.graphics.scale(self._SCALE.x, self._SCALE.y)
+    self:applyShaders(_render.canvas, type(shader) == "table" and shader or { shader })
+    love.graphics.pop()
 
     --clear canvas
     for i = 1, #self.canvases do
-      love.graphics.setCanvas( self.canvases[i].canvas )
+      love.graphics.setCanvas(self.canvases[i].canvas)
       love.graphics.clear()
     end
 
@@ -193,7 +238,7 @@ end
 
 --doesn't work - TODO
 function push:toReal(x, y)
-  return x+self._OFFSET.x, y+self._OFFSET.y
+  return x + self._OFFSET.x, y + self._OFFSET.y
 end
 
 function push:switchFullscreen(winw, winh)
@@ -213,13 +258,12 @@ function push:switchFullscreen(winw, winh)
   
   love.window.setFullscreen(self._fullscreen, "desktop")
   if not self._fullscreen and (winw or winh) then
-    love.window.setMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
+    windowUpdateMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
   end
 end
 
 function push:resize(w, h)
-  local pixelScale = love.window.getPixelScale()
-  if self._highdpi then w, h = w / pixelScale, h / pixelScale end
+  if self._highdpi then w, h = w / self._PSCALE, h / self._PSCALE end
   self._RWIDTH = w
   self._RHEIGHT = h
   self:initValues()
diff --git a/pong-3/push.lua b/pong-3/push.lua
index 0e0709a..ee9bf07 100644
--- a/pong-3/push.lua
+++ b/pong-3/push.lua
@@ -1,10 +1,18 @@
--- push.lua v0.2
+-- push.lua v0.3
 
--- Copyright (c) 2017 Ulysse Ramage
+-- Copyright (c) 2018 Ulysse Ramage
 -- 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.
 
+local love11 = love.getVersion() == 11
+local getDPI = love11 and love.window.getDPIScale or love.window.getPixelScale
+local windowUpdateMode = love11 and love.window.updateMode or function(width, height, settings)
+  local _, _, flags = love.window.getMode()
+  for k, v in pairs(settings) do flags[k] = v end
+  love.window.setMode(width, height, flags)
+end
+
 local push = {
   
   defaults = {
@@ -18,9 +26,6 @@ local push = {
 }
 setmetatable(push, push)
 
---TODO: rendering resolution?
---TODO: clean up code
-
 function push:applySettings(settings)
   for k, v in pairs(settings) do
     self["_" .. k] = v
@@ -39,11 +44,11 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
   self:applySettings(self.defaults) --set defaults first
   self:applySettings(settings) --then fill with custom settings
   
-  love.window.setMode( self._RWIDTH, self._RHEIGHT, {
+  windowUpdateMode(self._RWIDTH, self._RHEIGHT, {
     fullscreen = self._fullscreen,
     resizable = self._resizable,
     highdpi = self._highdpi
-  } )
+  })
 
   self:initValues()
 
@@ -62,25 +67,29 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
 end
 
 function push:setupCanvas(canvases)
-  table.insert(canvases, { name = "_render" }) --final render
+  table.insert(canvases, { name = "_render", private = true }) --final render
 
   self._canvas = true
   self.canvases = {}
 
   for i = 1, #canvases do
-    self.canvases[i] = {
-      name = canvases[i].name,
-      shader = canvases[i].shader,
-      canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
-    }
+    push:addCanvas(canvases[i])
   end
 
   return self
 end
+function push:addCanvas(params)
+  table.insert(self.canvases, {
+    name = params.name,
+    private = params.private,
+    shader = params.shader,
+    canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
+  })
+end
 
 function push:setCanvas(name)
   if not self._canvas then return true end
-  return love.graphics.setCanvas( self:getCanvasTable(name).canvas )
+  return love.graphics.setCanvas(self:getCanvasTable(name).canvas)
 end
 function push:getCanvasTable(name)
   for i = 1, #self.canvases do
@@ -98,7 +107,7 @@ function push:setShader(name, shader)
 end
 
 function push:initValues()
-  self._PSCALE = self._highdpi and love.window.getPixelScale() or 1
+  self._PSCALE = (not love11 and self._highdpi) and getDPI() or 1
   
   self._SCALE = {
     x = self._RWIDTH/self._WWIDTH * self._PSCALE,
@@ -119,13 +128,8 @@ function push:initValues()
   self._GHEIGHT = self._RHEIGHT * self._PSCALE - self._OFFSET.y * 2
 end
 
---[[ DEPRECATED ]]--
 function push:apply(operation, shader)
-  if operation == "start" then
-    self:start()
-  elseif operation == "finish" or operation == "end" then
-    self:finish(shader)
-  end
+  self._drawFunctions[operation](self, shader)
 end
 
 function push:start()
@@ -140,6 +144,40 @@ function push:start()
   end
 end
 
+function push:applyShaders(canvas, shaders)
+  local _shader = love.graphics.getShader()
+  if #shaders <= 1 then
+    love.graphics.setShader(shaders[1])
+    love.graphics.draw(canvas)
+  else
+    local _canvas = love.graphics.getCanvas()
+
+    local _tmp = self:getCanvasTable("_tmp")
+    if not _tmp then --create temp canvas only if needed
+      self:addCanvas({ name = "_tmp", private = true, shader = nil })
+      _tmp = self:getCanvasTable("_tmp")
+    end
+
+    love.graphics.push()
+    love.graphics.origin()
+    local outputCanvas
+    for i = 1, #shaders do
+      local inputCanvas = i % 2 == 1 and canvas or _tmp.canvas
+      outputCanvas = i % 2 == 0 and canvas or _tmp.canvas
+      love.graphics.setCanvas(outputCanvas)
+      love.graphics.clear()
+      love.graphics.setShader(shaders[i])
+      love.graphics.draw(inputCanvas)
+      love.graphics.setCanvas(inputCanvas)
+    end
+    love.graphics.pop()
+
+    love.graphics.setCanvas(_canvas)
+    love.graphics.draw(outputCanvas)
+  end
+  love.graphics.setShader(_shader)
+end
+
 function push:finish(shader)
   love.graphics.setBackgroundColor(unpack(self._borderColor))
   if self._canvas then
@@ -147,25 +185,32 @@ function push:finish(shader)
 
     love.graphics.pop()
 
-    love.graphics.setColor(255, 255, 255)
+    local white = love11 and 1 or 255
+    love.graphics.setColor(white, white, white)
 
     --draw canvas
     love.graphics.setCanvas(_render.canvas)
-    for i = 1, #self.canvases - 1 do --do not draw _render yet
+    for i = 1, #self.canvases do --do not draw _render yet
       local _table = self.canvases[i]
-      love.graphics.setShader(_table.shader)
-      love.graphics.draw(_table.canvas)
+      if not _table.private then
+        local _canvas = _table.canvas
+        local _shader = _table.shader
+        self:applyShaders(_canvas, type(_shader) == "table" and _shader or { _shader })
+      end
     end
     love.graphics.setCanvas()
-
+    
     --draw render
     love.graphics.translate(self._OFFSET.x, self._OFFSET.y)
-    love.graphics.setShader(shader or self:getCanvasTable("_render").shader)
-    love.graphics.draw(self:getCanvasTable("_render").canvas, 0, 0, 0, self._SCALE.x, self._SCALE.y)
+    local shader = shader or _render.shader
+    love.graphics.push()
+    love.graphics.scale(self._SCALE.x, self._SCALE.y)
+    self:applyShaders(_render.canvas, type(shader) == "table" and shader or { shader })
+    love.graphics.pop()
 
     --clear canvas
     for i = 1, #self.canvases do
-      love.graphics.setCanvas( self.canvases[i].canvas )
+      love.graphics.setCanvas(self.canvases[i].canvas)
       love.graphics.clear()
     end
 
@@ -193,7 +238,7 @@ end
 
 --doesn't work - TODO
 function push:toReal(x, y)
-  return x+self._OFFSET.x, y+self._OFFSET.y
+  return x + self._OFFSET.x, y + self._OFFSET.y
 end
 
 function push:switchFullscreen(winw, winh)
@@ -213,13 +258,12 @@ function push:switchFullscreen(winw, winh)
   
   love.window.setFullscreen(self._fullscreen, "desktop")
   if not self._fullscreen and (winw or winh) then
-    love.window.setMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
+    windowUpdateMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
   end
 end
 
 function push:resize(w, h)
-  local pixelScale = love.window.getPixelScale()
-  if self._highdpi then w, h = w / pixelScale, h / pixelScale end
+  if self._highdpi then w, h = w / self._PSCALE, h / self._PSCALE end
   self._RWIDTH = w
   self._RHEIGHT = h
   self:initValues()
diff --git a/pong-4/push.lua b/pong-4/push.lua
index 0e0709a..ee9bf07 100644
--- a/pong-4/push.lua
+++ b/pong-4/push.lua
@@ -1,10 +1,18 @@
--- push.lua v0.2
+-- push.lua v0.3
 
--- Copyright (c) 2017 Ulysse Ramage
+-- Copyright (c) 2018 Ulysse Ramage
 -- 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.
 
+local love11 = love.getVersion() == 11
+local getDPI = love11 and love.window.getDPIScale or love.window.getPixelScale
+local windowUpdateMode = love11 and love.window.updateMode or function(width, height, settings)
+  local _, _, flags = love.window.getMode()
+  for k, v in pairs(settings) do flags[k] = v end
+  love.window.setMode(width, height, flags)
+end
+
 local push = {
   
   defaults = {
@@ -18,9 +26,6 @@ local push = {
 }
 setmetatable(push, push)
 
---TODO: rendering resolution?
---TODO: clean up code
-
 function push:applySettings(settings)
   for k, v in pairs(settings) do
     self["_" .. k] = v
@@ -39,11 +44,11 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
   self:applySettings(self.defaults) --set defaults first
   self:applySettings(settings) --then fill with custom settings
   
-  love.window.setMode( self._RWIDTH, self._RHEIGHT, {
+  windowUpdateMode(self._RWIDTH, self._RHEIGHT, {
     fullscreen = self._fullscreen,
     resizable = self._resizable,
     highdpi = self._highdpi
-  } )
+  })
 
   self:initValues()
 
@@ -62,25 +67,29 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
 end
 
 function push:setupCanvas(canvases)
-  table.insert(canvases, { name = "_render" }) --final render
+  table.insert(canvases, { name = "_render", private = true }) --final render
 
   self._canvas = true
   self.canvases = {}
 
   for i = 1, #canvases do
-    self.canvases[i] = {
-      name = canvases[i].name,
-      shader = canvases[i].shader,
-      canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
-    }
+    push:addCanvas(canvases[i])
   end
 
   return self
 end
+function push:addCanvas(params)
+  table.insert(self.canvases, {
+    name = params.name,
+    private = params.private,
+    shader = params.shader,
+    canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
+  })
+end
 
 function push:setCanvas(name)
   if not self._canvas then return true end
-  return love.graphics.setCanvas( self:getCanvasTable(name).canvas )
+  return love.graphics.setCanvas(self:getCanvasTable(name).canvas)
 end
 function push:getCanvasTable(name)
   for i = 1, #self.canvases do
@@ -98,7 +107,7 @@ function push:setShader(name, shader)
 end
 
 function push:initValues()
-  self._PSCALE = self._highdpi and love.window.getPixelScale() or 1
+  self._PSCALE = (not love11 and self._highdpi) and getDPI() or 1
   
   self._SCALE = {
     x = self._RWIDTH/self._WWIDTH * self._PSCALE,
@@ -119,13 +128,8 @@ function push:initValues()
   self._GHEIGHT = self._RHEIGHT * self._PSCALE - self._OFFSET.y * 2
 end
 
---[[ DEPRECATED ]]--
 function push:apply(operation, shader)
-  if operation == "start" then
-    self:start()
-  elseif operation == "finish" or operation == "end" then
-    self:finish(shader)
-  end
+  self._drawFunctions[operation](self, shader)
 end
 
 function push:start()
@@ -140,6 +144,40 @@ function push:start()
   end
 end
 
+function push:applyShaders(canvas, shaders)
+  local _shader = love.graphics.getShader()
+  if #shaders <= 1 then
+    love.graphics.setShader(shaders[1])
+    love.graphics.draw(canvas)
+  else
+    local _canvas = love.graphics.getCanvas()
+
+    local _tmp = self:getCanvasTable("_tmp")
+    if not _tmp then --create temp canvas only if needed
+      self:addCanvas({ name = "_tmp", private = true, shader = nil })
+      _tmp = self:getCanvasTable("_tmp")
+    end
+
+    love.graphics.push()
+    love.graphics.origin()
+    local outputCanvas
+    for i = 1, #shaders do
+      local inputCanvas = i % 2 == 1 and canvas or _tmp.canvas
+      outputCanvas = i % 2 == 0 and canvas or _tmp.canvas
+      love.graphics.setCanvas(outputCanvas)
+      love.graphics.clear()
+      love.graphics.setShader(shaders[i])
+      love.graphics.draw(inputCanvas)
+      love.graphics.setCanvas(inputCanvas)
+    end
+    love.graphics.pop()
+
+    love.graphics.setCanvas(_canvas)
+    love.graphics.draw(outputCanvas)
+  end
+  love.graphics.setShader(_shader)
+end
+
 function push:finish(shader)
   love.graphics.setBackgroundColor(unpack(self._borderColor))
   if self._canvas then
@@ -147,25 +185,32 @@ function push:finish(shader)
 
     love.graphics.pop()
 
-    love.graphics.setColor(255, 255, 255)
+    local white = love11 and 1 or 255
+    love.graphics.setColor(white, white, white)
 
     --draw canvas
     love.graphics.setCanvas(_render.canvas)
-    for i = 1, #self.canvases - 1 do --do not draw _render yet
+    for i = 1, #self.canvases do --do not draw _render yet
       local _table = self.canvases[i]
-      love.graphics.setShader(_table.shader)
-      love.graphics.draw(_table.canvas)
+      if not _table.private then
+        local _canvas = _table.canvas
+        local _shader = _table.shader
+        self:applyShaders(_canvas, type(_shader) == "table" and _shader or { _shader })
+      end
     end
     love.graphics.setCanvas()
-
+    
     --draw render
     love.graphics.translate(self._OFFSET.x, self._OFFSET.y)
-    love.graphics.setShader(shader or self:getCanvasTable("_render").shader)
-    love.graphics.draw(self:getCanvasTable("_render").canvas, 0, 0, 0, self._SCALE.x, self._SCALE.y)
+    local shader = shader or _render.shader
+    love.graphics.push()
+    love.graphics.scale(self._SCALE.x, self._SCALE.y)
+    self:applyShaders(_render.canvas, type(shader) == "table" and shader or { shader })
+    love.graphics.pop()
 
     --clear canvas
     for i = 1, #self.canvases do
-      love.graphics.setCanvas( self.canvases[i].canvas )
+      love.graphics.setCanvas(self.canvases[i].canvas)
       love.graphics.clear()
     end
 
@@ -193,7 +238,7 @@ end
 
 --doesn't work - TODO
 function push:toReal(x, y)
-  return x+self._OFFSET.x, y+self._OFFSET.y
+  return x + self._OFFSET.x, y + self._OFFSET.y
 end
 
 function push:switchFullscreen(winw, winh)
@@ -213,13 +258,12 @@ function push:switchFullscreen(winw, winh)
   
   love.window.setFullscreen(self._fullscreen, "desktop")
   if not self._fullscreen and (winw or winh) then
-    love.window.setMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
+    windowUpdateMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
   end
 end
 
 function push:resize(w, h)
-  local pixelScale = love.window.getPixelScale()
-  if self._highdpi then w, h = w / pixelScale, h / pixelScale end
+  if self._highdpi then w, h = w / self._PSCALE, h / self._PSCALE end
   self._RWIDTH = w
   self._RHEIGHT = h
   self:initValues()
diff --git a/pong-5/push.lua b/pong-5/push.lua
index 0e0709a..ee9bf07 100644
--- a/pong-5/push.lua
+++ b/pong-5/push.lua
@@ -1,10 +1,18 @@
--- push.lua v0.2
+-- push.lua v0.3
 
--- Copyright (c) 2017 Ulysse Ramage
+-- Copyright (c) 2018 Ulysse Ramage
 -- 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.
 
+local love11 = love.getVersion() == 11
+local getDPI = love11 and love.window.getDPIScale or love.window.getPixelScale
+local windowUpdateMode = love11 and love.window.updateMode or function(width, height, settings)
+  local _, _, flags = love.window.getMode()
+  for k, v in pairs(settings) do flags[k] = v end
+  love.window.setMode(width, height, flags)
+end
+
 local push = {
   
   defaults = {
@@ -18,9 +26,6 @@ local push = {
 }
 setmetatable(push, push)
 
---TODO: rendering resolution?
---TODO: clean up code
-
 function push:applySettings(settings)
   for k, v in pairs(settings) do
     self["_" .. k] = v
@@ -39,11 +44,11 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
   self:applySettings(self.defaults) --set defaults first
   self:applySettings(settings) --then fill with custom settings
   
-  love.window.setMode( self._RWIDTH, self._RHEIGHT, {
+  windowUpdateMode(self._RWIDTH, self._RHEIGHT, {
     fullscreen = self._fullscreen,
     resizable = self._resizable,
     highdpi = self._highdpi
-  } )
+  })
 
   self:initValues()
 
@@ -62,25 +67,29 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
 end
 
 function push:setupCanvas(canvases)
-  table.insert(canvases, { name = "_render" }) --final render
+  table.insert(canvases, { name = "_render", private = true }) --final render
 
   self._canvas = true
   self.canvases = {}
 
   for i = 1, #canvases do
-    self.canvases[i] = {
-      name = canvases[i].name,
-      shader = canvases[i].shader,
-      canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
-    }
+    push:addCanvas(canvases[i])
   end
 
   return self
 end
+function push:addCanvas(params)
+  table.insert(self.canvases, {
+    name = params.name,
+    private = params.private,
+    shader = params.shader,
+    canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
+  })
+end
 
 function push:setCanvas(name)
   if not self._canvas then return true end
-  return love.graphics.setCanvas( self:getCanvasTable(name).canvas )
+  return love.graphics.setCanvas(self:getCanvasTable(name).canvas)
 end
 function push:getCanvasTable(name)
   for i = 1, #self.canvases do
@@ -98,7 +107,7 @@ function push:setShader(name, shader)
 end
 
 function push:initValues()
-  self._PSCALE = self._highdpi and love.window.getPixelScale() or 1
+  self._PSCALE = (not love11 and self._highdpi) and getDPI() or 1
   
   self._SCALE = {
     x = self._RWIDTH/self._WWIDTH * self._PSCALE,
@@ -119,13 +128,8 @@ function push:initValues()
   self._GHEIGHT = self._RHEIGHT * self._PSCALE - self._OFFSET.y * 2
 end
 
---[[ DEPRECATED ]]--
 function push:apply(operation, shader)
-  if operation == "start" then
-    self:start()
-  elseif operation == "finish" or operation == "end" then
-    self:finish(shader)
-  end
+  self._drawFunctions[operation](self, shader)
 end
 
 function push:start()
@@ -140,6 +144,40 @@ function push:start()
   end
 end
 
+function push:applyShaders(canvas, shaders)
+  local _shader = love.graphics.getShader()
+  if #shaders <= 1 then
+    love.graphics.setShader(shaders[1])
+    love.graphics.draw(canvas)
+  else
+    local _canvas = love.graphics.getCanvas()
+
+    local _tmp = self:getCanvasTable("_tmp")
+    if not _tmp then --create temp canvas only if needed
+      self:addCanvas({ name = "_tmp", private = true, shader = nil })
+      _tmp = self:getCanvasTable("_tmp")
+    end
+
+    love.graphics.push()
+    love.graphics.origin()
+    local outputCanvas
+    for i = 1, #shaders do
+      local inputCanvas = i % 2 == 1 and canvas or _tmp.canvas
+      outputCanvas = i % 2 == 0 and canvas or _tmp.canvas
+      love.graphics.setCanvas(outputCanvas)
+      love.graphics.clear()
+      love.graphics.setShader(shaders[i])
+      love.graphics.draw(inputCanvas)
+      love.graphics.setCanvas(inputCanvas)
+    end
+    love.graphics.pop()
+
+    love.graphics.setCanvas(_canvas)
+    love.graphics.draw(outputCanvas)
+  end
+  love.graphics.setShader(_shader)
+end
+
 function push:finish(shader)
   love.graphics.setBackgroundColor(unpack(self._borderColor))
   if self._canvas then
@@ -147,25 +185,32 @@ function push:finish(shader)
 
     love.graphics.pop()
 
-    love.graphics.setColor(255, 255, 255)
+    local white = love11 and 1 or 255
+    love.graphics.setColor(white, white, white)
 
     --draw canvas
     love.graphics.setCanvas(_render.canvas)
-    for i = 1, #self.canvases - 1 do --do not draw _render yet
+    for i = 1, #self.canvases do --do not draw _render yet
       local _table = self.canvases[i]
-      love.graphics.setShader(_table.shader)
-      love.graphics.draw(_table.canvas)
+      if not _table.private then
+        local _canvas = _table.canvas
+        local _shader = _table.shader
+        self:applyShaders(_canvas, type(_shader) == "table" and _shader or { _shader })
+      end
     end
     love.graphics.setCanvas()
-
+    
     --draw render
     love.graphics.translate(self._OFFSET.x, self._OFFSET.y)
-    love.graphics.setShader(shader or self:getCanvasTable("_render").shader)
-    love.graphics.draw(self:getCanvasTable("_render").canvas, 0, 0, 0, self._SCALE.x, self._SCALE.y)
+    local shader = shader or _render.shader
+    love.graphics.push()
+    love.graphics.scale(self._SCALE.x, self._SCALE.y)
+    self:applyShaders(_render.canvas, type(shader) == "table" and shader or { shader })
+    love.graphics.pop()
 
     --clear canvas
     for i = 1, #self.canvases do
-      love.graphics.setCanvas( self.canvases[i].canvas )
+      love.graphics.setCanvas(self.canvases[i].canvas)
       love.graphics.clear()
     end
 
@@ -193,7 +238,7 @@ end
 
 --doesn't work - TODO
 function push:toReal(x, y)
-  return x+self._OFFSET.x, y+self._OFFSET.y
+  return x + self._OFFSET.x, y + self._OFFSET.y
 end
 
 function push:switchFullscreen(winw, winh)
@@ -213,13 +258,12 @@ function push:switchFullscreen(winw, winh)
   
   love.window.setFullscreen(self._fullscreen, "desktop")
   if not self._fullscreen and (winw or winh) then
-    love.window.setMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
+    windowUpdateMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
   end
 end
 
 function push:resize(w, h)
-  local pixelScale = love.window.getPixelScale()
-  if self._highdpi then w, h = w / pixelScale, h / pixelScale end
+  if self._highdpi then w, h = w / self._PSCALE, h / self._PSCALE end
   self._RWIDTH = w
   self._RHEIGHT = h
   self:initValues()
diff --git a/pong-6/push.lua b/pong-6/push.lua
index 0e0709a..ee9bf07 100644
--- a/pong-6/push.lua
+++ b/pong-6/push.lua
@@ -1,10 +1,18 @@
--- push.lua v0.2
+-- push.lua v0.3
 
--- Copyright (c) 2017 Ulysse Ramage
+-- Copyright (c) 2018 Ulysse Ramage
 -- 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.
 
+local love11 = love.getVersion() == 11
+local getDPI = love11 and love.window.getDPIScale or love.window.getPixelScale
+local windowUpdateMode = love11 and love.window.updateMode or function(width, height, settings)
+  local _, _, flags = love.window.getMode()
+  for k, v in pairs(settings) do flags[k] = v end
+  love.window.setMode(width, height, flags)
+end
+
 local push = {
   
   defaults = {
@@ -18,9 +26,6 @@ local push = {
 }
 setmetatable(push, push)
 
---TODO: rendering resolution?
---TODO: clean up code
-
 function push:applySettings(settings)
   for k, v in pairs(settings) do
     self["_" .. k] = v
@@ -39,11 +44,11 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
   self:applySettings(self.defaults) --set defaults first
   self:applySettings(settings) --then fill with custom settings
   
-  love.window.setMode( self._RWIDTH, self._RHEIGHT, {
+  windowUpdateMode(self._RWIDTH, self._RHEIGHT, {
     fullscreen = self._fullscreen,
     resizable = self._resizable,
     highdpi = self._highdpi
-  } )
+  })
 
   self:initValues()
 
@@ -62,25 +67,29 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
 end
 
 function push:setupCanvas(canvases)
-  table.insert(canvases, { name = "_render" }) --final render
+  table.insert(canvases, { name = "_render", private = true }) --final render
 
   self._canvas = true
   self.canvases = {}
 
   for i = 1, #canvases do
-    self.canvases[i] = {
-      name = canvases[i].name,
-      shader = canvases[i].shader,
-      canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
-    }
+    push:addCanvas(canvases[i])
   end
 
   return self
 end
+function push:addCanvas(params)
+  table.insert(self.canvases, {
+    name = params.name,
+    private = params.private,
+    shader = params.shader,
+    canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
+  })
+end
 
 function push:setCanvas(name)
   if not self._canvas then return true end
-  return love.graphics.setCanvas( self:getCanvasTable(name).canvas )
+  return love.graphics.setCanvas(self:getCanvasTable(name).canvas)
 end
 function push:getCanvasTable(name)
   for i = 1, #self.canvases do
@@ -98,7 +107,7 @@ function push:setShader(name, shader)
 end
 
 function push:initValues()
-  self._PSCALE = self._highdpi and love.window.getPixelScale() or 1
+  self._PSCALE = (not love11 and self._highdpi) and getDPI() or 1
   
   self._SCALE = {
     x = self._RWIDTH/self._WWIDTH * self._PSCALE,
@@ -119,13 +128,8 @@ function push:initValues()
   self._GHEIGHT = self._RHEIGHT * self._PSCALE - self._OFFSET.y * 2
 end
 
---[[ DEPRECATED ]]--
 function push:apply(operation, shader)
-  if operation == "start" then
-    self:start()
-  elseif operation == "finish" or operation == "end" then
-    self:finish(shader)
-  end
+  self._drawFunctions[operation](self, shader)
 end
 
 function push:start()
@@ -140,6 +144,40 @@ function push:start()
   end
 end
 
+function push:applyShaders(canvas, shaders)
+  local _shader = love.graphics.getShader()
+  if #shaders <= 1 then
+    love.graphics.setShader(shaders[1])
+    love.graphics.draw(canvas)
+  else
+    local _canvas = love.graphics.getCanvas()
+
+    local _tmp = self:getCanvasTable("_tmp")
+    if not _tmp then --create temp canvas only if needed
+      self:addCanvas({ name = "_tmp", private = true, shader = nil })
+      _tmp = self:getCanvasTable("_tmp")
+    end
+
+    love.graphics.push()
+    love.graphics.origin()
+    local outputCanvas
+    for i = 1, #shaders do
+      local inputCanvas = i % 2 == 1 and canvas or _tmp.canvas
+      outputCanvas = i % 2 == 0 and canvas or _tmp.canvas
+      love.graphics.setCanvas(outputCanvas)
+      love.graphics.clear()
+      love.graphics.setShader(shaders[i])
+      love.graphics.draw(inputCanvas)
+      love.graphics.setCanvas(inputCanvas)
+    end
+    love.graphics.pop()
+
+    love.graphics.setCanvas(_canvas)
+    love.graphics.draw(outputCanvas)
+  end
+  love.graphics.setShader(_shader)
+end
+
 function push:finish(shader)
   love.graphics.setBackgroundColor(unpack(self._borderColor))
   if self._canvas then
@@ -147,25 +185,32 @@ function push:finish(shader)
 
     love.graphics.pop()
 
-    love.graphics.setColor(255, 255, 255)
+    local white = love11 and 1 or 255
+    love.graphics.setColor(white, white, white)
 
     --draw canvas
     love.graphics.setCanvas(_render.canvas)
-    for i = 1, #self.canvases - 1 do --do not draw _render yet
+    for i = 1, #self.canvases do --do not draw _render yet
       local _table = self.canvases[i]
-      love.graphics.setShader(_table.shader)
-      love.graphics.draw(_table.canvas)
+      if not _table.private then
+        local _canvas = _table.canvas
+        local _shader = _table.shader
+        self:applyShaders(_canvas, type(_shader) == "table" and _shader or { _shader })
+      end
     end
     love.graphics.setCanvas()
-
+    
     --draw render
     love.graphics.translate(self._OFFSET.x, self._OFFSET.y)
-    love.graphics.setShader(shader or self:getCanvasTable("_render").shader)
-    love.graphics.draw(self:getCanvasTable("_render").canvas, 0, 0, 0, self._SCALE.x, self._SCALE.y)
+    local shader = shader or _render.shader
+    love.graphics.push()
+    love.graphics.scale(self._SCALE.x, self._SCALE.y)
+    self:applyShaders(_render.canvas, type(shader) == "table" and shader or { shader })
+    love.graphics.pop()
 
     --clear canvas
     for i = 1, #self.canvases do
-      love.graphics.setCanvas( self.canvases[i].canvas )
+      love.graphics.setCanvas(self.canvases[i].canvas)
       love.graphics.clear()
     end
 
@@ -193,7 +238,7 @@ end
 
 --doesn't work - TODO
 function push:toReal(x, y)
-  return x+self._OFFSET.x, y+self._OFFSET.y
+  return x + self._OFFSET.x, y + self._OFFSET.y
 end
 
 function push:switchFullscreen(winw, winh)
@@ -213,13 +258,12 @@ function push:switchFullscreen(winw, winh)
   
   love.window.setFullscreen(self._fullscreen, "desktop")
   if not self._fullscreen and (winw or winh) then
-    love.window.setMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
+    windowUpdateMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
   end
 end
 
 function push:resize(w, h)
-  local pixelScale = love.window.getPixelScale()
-  if self._highdpi then w, h = w / pixelScale, h / pixelScale end
+  if self._highdpi then w, h = w / self._PSCALE, h / self._PSCALE end
   self._RWIDTH = w
   self._RHEIGHT = h
   self:initValues()
diff --git a/pong-7/push.lua b/pong-7/push.lua
index 0e0709a..ee9bf07 100644
--- a/pong-7/push.lua
+++ b/pong-7/push.lua
@@ -1,10 +1,18 @@
--- push.lua v0.2
+-- push.lua v0.3
 
--- Copyright (c) 2017 Ulysse Ramage
+-- Copyright (c) 2018 Ulysse Ramage
 -- 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.
 
+local love11 = love.getVersion() == 11
+local getDPI = love11 and love.window.getDPIScale or love.window.getPixelScale
+local windowUpdateMode = love11 and love.window.updateMode or function(width, height, settings)
+  local _, _, flags = love.window.getMode()
+  for k, v in pairs(settings) do flags[k] = v end
+  love.window.setMode(width, height, flags)
+end
+
 local push = {
   
   defaults = {
@@ -18,9 +26,6 @@ local push = {
 }
 setmetatable(push, push)
 
---TODO: rendering resolution?
---TODO: clean up code
-
 function push:applySettings(settings)
   for k, v in pairs(settings) do
     self["_" .. k] = v
@@ -39,11 +44,11 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
   self:applySettings(self.defaults) --set defaults first
   self:applySettings(settings) --then fill with custom settings
   
-  love.window.setMode( self._RWIDTH, self._RHEIGHT, {
+  windowUpdateMode(self._RWIDTH, self._RHEIGHT, {
     fullscreen = self._fullscreen,
     resizable = self._resizable,
     highdpi = self._highdpi
-  } )
+  })
 
   self:initValues()
 
@@ -62,25 +67,29 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
 end
 
 function push:setupCanvas(canvases)
-  table.insert(canvases, { name = "_render" }) --final render
+  table.insert(canvases, { name = "_render", private = true }) --final render
 
   self._canvas = true
   self.canvases = {}
 
   for i = 1, #canvases do
-    self.canvases[i] = {
-      name = canvases[i].name,
-      shader = canvases[i].shader,
-      canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
-    }
+    push:addCanvas(canvases[i])
   end
 
   return self
 end
+function push:addCanvas(params)
+  table.insert(self.canvases, {
+    name = params.name,
+    private = params.private,
+    shader = params.shader,
+    canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
+  })
+end
 
 function push:setCanvas(name)
   if not self._canvas then return true end
-  return love.graphics.setCanvas( self:getCanvasTable(name).canvas )
+  return love.graphics.setCanvas(self:getCanvasTable(name).canvas)
 end
 function push:getCanvasTable(name)
   for i = 1, #self.canvases do
@@ -98,7 +107,7 @@ function push:setShader(name, shader)
 end
 
 function push:initValues()
-  self._PSCALE = self._highdpi and love.window.getPixelScale() or 1
+  self._PSCALE = (not love11 and self._highdpi) and getDPI() or 1
   
   self._SCALE = {
     x = self._RWIDTH/self._WWIDTH * self._PSCALE,
@@ -119,13 +128,8 @@ function push:initValues()
   self._GHEIGHT = self._RHEIGHT * self._PSCALE - self._OFFSET.y * 2
 end
 
---[[ DEPRECATED ]]--
 function push:apply(operation, shader)
-  if operation == "start" then
-    self:start()
-  elseif operation == "finish" or operation == "end" then
-    self:finish(shader)
-  end
+  self._drawFunctions[operation](self, shader)
 end
 
 function push:start()
@@ -140,6 +144,40 @@ function push:start()
   end
 end
 
+function push:applyShaders(canvas, shaders)
+  local _shader = love.graphics.getShader()
+  if #shaders <= 1 then
+    love.graphics.setShader(shaders[1])
+    love.graphics.draw(canvas)
+  else
+    local _canvas = love.graphics.getCanvas()
+
+    local _tmp = self:getCanvasTable("_tmp")
+    if not _tmp then --create temp canvas only if needed
+      self:addCanvas({ name = "_tmp", private = true, shader = nil })
+      _tmp = self:getCanvasTable("_tmp")
+    end
+
+    love.graphics.push()
+    love.graphics.origin()
+    local outputCanvas
+    for i = 1, #shaders do
+      local inputCanvas = i % 2 == 1 and canvas or _tmp.canvas
+      outputCanvas = i % 2 == 0 and canvas or _tmp.canvas
+      love.graphics.setCanvas(outputCanvas)
+      love.graphics.clear()
+      love.graphics.setShader(shaders[i])
+      love.graphics.draw(inputCanvas)
+      love.graphics.setCanvas(inputCanvas)
+    end
+    love.graphics.pop()
+
+    love.graphics.setCanvas(_canvas)
+    love.graphics.draw(outputCanvas)
+  end
+  love.graphics.setShader(_shader)
+end
+
 function push:finish(shader)
   love.graphics.setBackgroundColor(unpack(self._borderColor))
   if self._canvas then
@@ -147,25 +185,32 @@ function push:finish(shader)
 
     love.graphics.pop()
 
-    love.graphics.setColor(255, 255, 255)
+    local white = love11 and 1 or 255
+    love.graphics.setColor(white, white, white)
 
     --draw canvas
     love.graphics.setCanvas(_render.canvas)
-    for i = 1, #self.canvases - 1 do --do not draw _render yet
+    for i = 1, #self.canvases do --do not draw _render yet
       local _table = self.canvases[i]
-      love.graphics.setShader(_table.shader)
-      love.graphics.draw(_table.canvas)
+      if not _table.private then
+        local _canvas = _table.canvas
+        local _shader = _table.shader
+        self:applyShaders(_canvas, type(_shader) == "table" and _shader or { _shader })
+      end
     end
     love.graphics.setCanvas()
-
+    
     --draw render
     love.graphics.translate(self._OFFSET.x, self._OFFSET.y)
-    love.graphics.setShader(shader or self:getCanvasTable("_render").shader)
-    love.graphics.draw(self:getCanvasTable("_render").canvas, 0, 0, 0, self._SCALE.x, self._SCALE.y)
+    local shader = shader or _render.shader
+    love.graphics.push()
+    love.graphics.scale(self._SCALE.x, self._SCALE.y)
+    self:applyShaders(_render.canvas, type(shader) == "table" and shader or { shader })
+    love.graphics.pop()
 
     --clear canvas
     for i = 1, #self.canvases do
-      love.graphics.setCanvas( self.canvases[i].canvas )
+      love.graphics.setCanvas(self.canvases[i].canvas)
       love.graphics.clear()
     end
 
@@ -193,7 +238,7 @@ end
 
 --doesn't work - TODO
 function push:toReal(x, y)
-  return x+self._OFFSET.x, y+self._OFFSET.y
+  return x + self._OFFSET.x, y + self._OFFSET.y
 end
 
 function push:switchFullscreen(winw, winh)
@@ -213,13 +258,12 @@ function push:switchFullscreen(winw, winh)
   
   love.window.setFullscreen(self._fullscreen, "desktop")
   if not self._fullscreen and (winw or winh) then
-    love.window.setMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
+    windowUpdateMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
   end
 end
 
 function push:resize(w, h)
-  local pixelScale = love.window.getPixelScale()
-  if self._highdpi then w, h = w / pixelScale, h / pixelScale end
+  if self._highdpi then w, h = w / self._PSCALE, h / self._PSCALE end
   self._RWIDTH = w
   self._RHEIGHT = h
   self:initValues()
diff --git a/pong-8/push.lua b/pong-8/push.lua
index 0e0709a..ee9bf07 100644
--- a/pong-8/push.lua
+++ b/pong-8/push.lua
@@ -1,10 +1,18 @@
--- push.lua v0.2
+-- push.lua v0.3
 
--- Copyright (c) 2017 Ulysse Ramage
+-- Copyright (c) 2018 Ulysse Ramage
 -- 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.
 
+local love11 = love.getVersion() == 11
+local getDPI = love11 and love.window.getDPIScale or love.window.getPixelScale
+local windowUpdateMode = love11 and love.window.updateMode or function(width, height, settings)
+  local _, _, flags = love.window.getMode()
+  for k, v in pairs(settings) do flags[k] = v end
+  love.window.setMode(width, height, flags)
+end
+
 local push = {
   
   defaults = {
@@ -18,9 +26,6 @@ local push = {
 }
 setmetatable(push, push)
 
---TODO: rendering resolution?
---TODO: clean up code
-
 function push:applySettings(settings)
   for k, v in pairs(settings) do
     self["_" .. k] = v
@@ -39,11 +44,11 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
   self:applySettings(self.defaults) --set defaults first
   self:applySettings(settings) --then fill with custom settings
   
-  love.window.setMode( self._RWIDTH, self._RHEIGHT, {
+  windowUpdateMode(self._RWIDTH, self._RHEIGHT, {
     fullscreen = self._fullscreen,
     resizable = self._resizable,
     highdpi = self._highdpi
-  } )
+  })
 
   self:initValues()
 
@@ -62,25 +67,29 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
 end
 
 function push:setupCanvas(canvases)
-  table.insert(canvases, { name = "_render" }) --final render
+  table.insert(canvases, { name = "_render", private = true }) --final render
 
   self._canvas = true
   self.canvases = {}
 
   for i = 1, #canvases do
-    self.canvases[i] = {
-      name = canvases[i].name,
-      shader = canvases[i].shader,
-      canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
-    }
+    push:addCanvas(canvases[i])
   end
 
   return self
 end
+function push:addCanvas(params)
+  table.insert(self.canvases, {
+    name = params.name,
+    private = params.private,
+    shader = params.shader,
+    canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
+  })
+end
 
 function push:setCanvas(name)
   if not self._canvas then return true end
-  return love.graphics.setCanvas( self:getCanvasTable(name).canvas )
+  return love.graphics.setCanvas(self:getCanvasTable(name).canvas)
 end
 function push:getCanvasTable(name)
   for i = 1, #self.canvases do
@@ -98,7 +107,7 @@ function push:setShader(name, shader)
 end
 
 function push:initValues()
-  self._PSCALE = self._highdpi and love.window.getPixelScale() or 1
+  self._PSCALE = (not love11 and self._highdpi) and getDPI() or 1
   
   self._SCALE = {
     x = self._RWIDTH/self._WWIDTH * self._PSCALE,
@@ -119,13 +128,8 @@ function push:initValues()
   self._GHEIGHT = self._RHEIGHT * self._PSCALE - self._OFFSET.y * 2
 end
 
---[[ DEPRECATED ]]--
 function push:apply(operation, shader)
-  if operation == "start" then
-    self:start()
-  elseif operation == "finish" or operation == "end" then
-    self:finish(shader)
-  end
+  self._drawFunctions[operation](self, shader)
 end
 
 function push:start()
@@ -140,6 +144,40 @@ function push:start()
   end
 end
 
+function push:applyShaders(canvas, shaders)
+  local _shader = love.graphics.getShader()
+  if #shaders <= 1 then
+    love.graphics.setShader(shaders[1])
+    love.graphics.draw(canvas)
+  else
+    local _canvas = love.graphics.getCanvas()
+
+    local _tmp = self:getCanvasTable("_tmp")
+    if not _tmp then --create temp canvas only if needed
+      self:addCanvas({ name = "_tmp", private = true, shader = nil })
+      _tmp = self:getCanvasTable("_tmp")
+    end
+
+    love.graphics.push()
+    love.graphics.origin()
+    local outputCanvas
+    for i = 1, #shaders do
+      local inputCanvas = i % 2 == 1 and canvas or _tmp.canvas
+      outputCanvas = i % 2 == 0 and canvas or _tmp.canvas
+      love.graphics.setCanvas(outputCanvas)
+      love.graphics.clear()
+      love.graphics.setShader(shaders[i])
+      love.graphics.draw(inputCanvas)
+      love.graphics.setCanvas(inputCanvas)
+    end
+    love.graphics.pop()
+
+    love.graphics.setCanvas(_canvas)
+    love.graphics.draw(outputCanvas)
+  end
+  love.graphics.setShader(_shader)
+end
+
 function push:finish(shader)
   love.graphics.setBackgroundColor(unpack(self._borderColor))
   if self._canvas then
@@ -147,25 +185,32 @@ function push:finish(shader)
 
     love.graphics.pop()
 
-    love.graphics.setColor(255, 255, 255)
+    local white = love11 and 1 or 255
+    love.graphics.setColor(white, white, white)
 
     --draw canvas
     love.graphics.setCanvas(_render.canvas)
-    for i = 1, #self.canvases - 1 do --do not draw _render yet
+    for i = 1, #self.canvases do --do not draw _render yet
       local _table = self.canvases[i]
-      love.graphics.setShader(_table.shader)
-      love.graphics.draw(_table.canvas)
+      if not _table.private then
+        local _canvas = _table.canvas
+        local _shader = _table.shader
+        self:applyShaders(_canvas, type(_shader) == "table" and _shader or { _shader })
+      end
     end
     love.graphics.setCanvas()
-
+    
     --draw render
     love.graphics.translate(self._OFFSET.x, self._OFFSET.y)
-    love.graphics.setShader(shader or self:getCanvasTable("_render").shader)
-    love.graphics.draw(self:getCanvasTable("_render").canvas, 0, 0, 0, self._SCALE.x, self._SCALE.y)
+    local shader = shader or _render.shader
+    love.graphics.push()
+    love.graphics.scale(self._SCALE.x, self._SCALE.y)
+    self:applyShaders(_render.canvas, type(shader) == "table" and shader or { shader })
+    love.graphics.pop()
 
     --clear canvas
     for i = 1, #self.canvases do
-      love.graphics.setCanvas( self.canvases[i].canvas )
+      love.graphics.setCanvas(self.canvases[i].canvas)
       love.graphics.clear()
     end
 
@@ -193,7 +238,7 @@ end
 
 --doesn't work - TODO
 function push:toReal(x, y)
-  return x+self._OFFSET.x, y+self._OFFSET.y
+  return x + self._OFFSET.x, y + self._OFFSET.y
 end
 
 function push:switchFullscreen(winw, winh)
@@ -213,13 +258,12 @@ function push:switchFullscreen(winw, winh)
   
   love.window.setFullscreen(self._fullscreen, "desktop")
   if not self._fullscreen and (winw or winh) then
-    love.window.setMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
+    windowUpdateMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
   end
 end
 
 function push:resize(w, h)
-  local pixelScale = love.window.getPixelScale()
-  if self._highdpi then w, h = w / pixelScale, h / pixelScale end
+  if self._highdpi then w, h = w / self._PSCALE, h / self._PSCALE end
   self._RWIDTH = w
   self._RHEIGHT = h
   self:initValues()
diff --git a/pong-9/push.lua b/pong-9/push.lua
index 0e0709a..ee9bf07 100644
--- a/pong-9/push.lua
+++ b/pong-9/push.lua
@@ -1,10 +1,18 @@
--- push.lua v0.2
+-- push.lua v0.3
 
--- Copyright (c) 2017 Ulysse Ramage
+-- Copyright (c) 2018 Ulysse Ramage
 -- 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.
 
+local love11 = love.getVersion() == 11
+local getDPI = love11 and love.window.getDPIScale or love.window.getPixelScale
+local windowUpdateMode = love11 and love.window.updateMode or function(width, height, settings)
+  local _, _, flags = love.window.getMode()
+  for k, v in pairs(settings) do flags[k] = v end
+  love.window.setMode(width, height, flags)
+end
+
 local push = {
   
   defaults = {
@@ -18,9 +26,6 @@ local push = {
 }
 setmetatable(push, push)
 
---TODO: rendering resolution?
---TODO: clean up code
-
 function push:applySettings(settings)
   for k, v in pairs(settings) do
     self["_" .. k] = v
@@ -39,11 +44,11 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
   self:applySettings(self.defaults) --set defaults first
   self:applySettings(settings) --then fill with custom settings
   
-  love.window.setMode( self._RWIDTH, self._RHEIGHT, {
+  windowUpdateMode(self._RWIDTH, self._RHEIGHT, {
     fullscreen = self._fullscreen,
     resizable = self._resizable,
     highdpi = self._highdpi
-  } )
+  })
 
   self:initValues()
 
@@ -62,25 +67,29 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
 end
 
 function push:setupCanvas(canvases)
-  table.insert(canvases, { name = "_render" }) --final render
+  table.insert(canvases, { name = "_render", private = true }) --final render
 
   self._canvas = true
   self.canvases = {}
 
   for i = 1, #canvases do
-    self.canvases[i] = {
-      name = canvases[i].name,
-      shader = canvases[i].shader,
-      canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
-    }
+    push:addCanvas(canvases[i])
   end
 
   return self
 end
+function push:addCanvas(params)
+  table.insert(self.canvases, {
+    name = params.name,
+    private = params.private,
+    shader = params.shader,
+    canvas = love.graphics.newCanvas(self._WWIDTH, self._WHEIGHT)
+  })
+end
 
 function push:setCanvas(name)
   if not self._canvas then return true end
-  return love.graphics.setCanvas( self:getCanvasTable(name).canvas )
+  return love.graphics.setCanvas(self:getCanvasTable(name).canvas)
 end
 function push:getCanvasTable(name)
   for i = 1, #self.canvases do
@@ -98,7 +107,7 @@ function push:setShader(name, shader)
 end
 
 function push:initValues()
-  self._PSCALE = self._highdpi and love.window.getPixelScale() or 1
+  self._PSCALE = (not love11 and self._highdpi) and getDPI() or 1
   
   self._SCALE = {
     x = self._RWIDTH/self._WWIDTH * self._PSCALE,
@@ -119,13 +128,8 @@ function push:initValues()
   self._GHEIGHT = self._RHEIGHT * self._PSCALE - self._OFFSET.y * 2
 end
 
---[[ DEPRECATED ]]--
 function push:apply(operation, shader)
-  if operation == "start" then
-    self:start()
-  elseif operation == "finish" or operation == "end" then
-    self:finish(shader)
-  end
+  self._drawFunctions[operation](self, shader)
 end
 
 function push:start()
@@ -140,6 +144,40 @@ function push:start()
   end
 end
 
+function push:applyShaders(canvas, shaders)
+  local _shader = love.graphics.getShader()
+  if #shaders <= 1 then
+    love.graphics.setShader(shaders[1])
+    love.graphics.draw(canvas)
+  else
+    local _canvas = love.graphics.getCanvas()
+
+    local _tmp = self:getCanvasTable("_tmp")
+    if not _tmp then --create temp canvas only if needed
+      self:addCanvas({ name = "_tmp", private = true, shader = nil })
+      _tmp = self:getCanvasTable("_tmp")
+    end
+
+    love.graphics.push()
+    love.graphics.origin()
+    local outputCanvas
+    for i = 1, #shaders do
+      local inputCanvas = i % 2 == 1 and canvas or _tmp.canvas
+      outputCanvas = i % 2 == 0 and canvas or _tmp.canvas
+      love.graphics.setCanvas(outputCanvas)
+      love.graphics.clear()
+      love.graphics.setShader(shaders[i])
+      love.graphics.draw(inputCanvas)
+      love.graphics.setCanvas(inputCanvas)
+    end
+    love.graphics.pop()
+
+    love.graphics.setCanvas(_canvas)
+    love.graphics.draw(outputCanvas)
+  end
+  love.graphics.setShader(_shader)
+end
+
 function push:finish(shader)
   love.graphics.setBackgroundColor(unpack(self._borderColor))
   if self._canvas then
@@ -147,25 +185,32 @@ function push:finish(shader)
 
     love.graphics.pop()
 
-    love.graphics.setColor(255, 255, 255)
+    local white = love11 and 1 or 255
+    love.graphics.setColor(white, white, white)
 
     --draw canvas
     love.graphics.setCanvas(_render.canvas)
-    for i = 1, #self.canvases - 1 do --do not draw _render yet
+    for i = 1, #self.canvases do --do not draw _render yet
       local _table = self.canvases[i]
-      love.graphics.setShader(_table.shader)
-      love.graphics.draw(_table.canvas)
+      if not _table.private then
+        local _canvas = _table.canvas
+        local _shader = _table.shader
+        self:applyShaders(_canvas, type(_shader) == "table" and _shader or { _shader })
+      end
     end
     love.graphics.setCanvas()
-
+    
     --draw render
     love.graphics.translate(self._OFFSET.x, self._OFFSET.y)
-    love.graphics.setShader(shader or self:getCanvasTable("_render").shader)
-    love.graphics.draw(self:getCanvasTable("_render").canvas, 0, 0, 0, self._SCALE.x, self._SCALE.y)
+    local shader = shader or _render.shader
+    love.graphics.push()
+    love.graphics.scale(self._SCALE.x, self._SCALE.y)
+    self:applyShaders(_render.canvas, type(shader) == "table" and shader or { shader })
+    love.graphics.pop()
 
     --clear canvas
     for i = 1, #self.canvases do
-      love.graphics.setCanvas( self.canvases[i].canvas )
+      love.graphics.setCanvas(self.canvases[i].canvas)
       love.graphics.clear()
     end
 
@@ -193,7 +238,7 @@ end
 
 --doesn't work - TODO
 function push:toReal(x, y)
-  return x+self._OFFSET.x, y+self._OFFSET.y
+  return x + self._OFFSET.x, y + self._OFFSET.y
 end
 
 function push:switchFullscreen(winw, winh)
@@ -213,13 +258,12 @@ function push:switchFullscreen(winw, winh)
   
   love.window.setFullscreen(self._fullscreen, "desktop")
   if not self._fullscreen and (winw or winh) then
-    love.window.setMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
+    windowUpdateMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
   end
 end
 
 function push:resize(w, h)
-  local pixelScale = love.window.getPixelScale()
-  if self._highdpi then w, h = w / pixelScale, h / pixelScale end
+  if self._highdpi then w, h = w / self._PSCALE, h / self._PSCALE end
   self._RWIDTH = w
   self._RHEIGHT = h
   self:initValues()
diff --git a/pong-final/push.lua b/pong-final/push.lua
index 723eb26..ee9bf07 100644
--- a/pong-final/push.lua
+++ b/pong-final/push.lua
@@ -7,6 +7,11 @@
 
 local love11 = love.getVersion() == 11
 local getDPI = love11 and love.window.getDPIScale or love.window.getPixelScale
+local windowUpdateMode = love11 and love.window.updateMode or function(width, height, settings)
+  local _, _, flags = love.window.getMode()
+  for k, v in pairs(settings) do flags[k] = v end
+  love.window.setMode(width, height, flags)
+end
 
 local push = {
   
@@ -39,7 +44,7 @@ function push:setupScreen(WWIDTH, WHEIGHT, RWIDTH, RHEIGHT, settings)
   self:applySettings(self.defaults) --set defaults first
   self:applySettings(settings) --then fill with custom settings
   
-  love.window.setMode(self._RWIDTH, self._RHEIGHT, {
+  windowUpdateMode(self._RWIDTH, self._RHEIGHT, {
     fullscreen = self._fullscreen,
     resizable = self._resizable,
     highdpi = self._highdpi
@@ -253,7 +258,7 @@ function push:switchFullscreen(winw, winh)
   
   love.window.setFullscreen(self._fullscreen, "desktop")
   if not self._fullscreen and (winw or winh) then
-    love.window.setMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
+    windowUpdateMode(self._RWIDTH, self._RHEIGHT) --set window dimensions
   end
 end