248 lines
7.5 KiB
Lua
248 lines
7.5 KiB
Lua
local cindy = {
|
|
_VERSION = 'cindy 0.1',
|
|
_LICENSE = 'WTFPL, http://www.wtfpl.net',
|
|
_URL = 'https://github.com/megagrump/cindy',
|
|
_DESCRIPTION = 'True Colors for LOVE 11',
|
|
}
|
|
|
|
--[[-----------------------------------------------------------------------------------------------------------------
|
|
|
|
cindy adds functions to LOVE 11.x that accept/return colors in the [0-255] range instead of the newly introduced
|
|
[0.0-1.0] range.
|
|
|
|
In love.graphics:
|
|
- clearBytes
|
|
- getColorBytes, setColorBytes
|
|
- getBackgroundColorBytes, setBackgroundColorBytes
|
|
- getColorMaskBytes, setColorMaskBytes
|
|
|
|
In ImageData:
|
|
- getPixelBytes, setPixelBytes
|
|
- mapPixelBytes
|
|
|
|
In ParticleSystem:
|
|
- setColorsBytes, getColorsBytes
|
|
|
|
In SpriteBatch:
|
|
- getColorBytes, setColorBytes
|
|
|
|
In Shader:
|
|
- sendColorBytes
|
|
|
|
These functions behave the same as their built-in counterparts, except for the different value range.
|
|
Note that calling them has additional runtime costs.
|
|
|
|
To replace all original functions, call cindy.applyPatch() at the start of the program: require('cindy').applyPatch() -
|
|
this effectively restores the pre-11.0 behavior.
|
|
|
|
-------------------------------------------------------------------------------------------------------------------]]
|
|
|
|
local gfx, reg = love.graphics, debug.getregistry()
|
|
local ImageData, ParticleSystem, SpriteBatch, Shader = reg.ImageData, reg.ParticleSystem, reg.SpriteBatch, reg.Shader
|
|
local clear, getColor, setColor = gfx.clear, gfx.getColor, gfx.setColor
|
|
local getBackgroundColor, setBackgroundColor = gfx.getBackgroundColor, gfx.setBackgroundColor
|
|
local getColorMask, setColorMask = gfx.getColorMask, gfx.setColorMask
|
|
local getPixel, setPixel, mapPixel = ImageData.getPixel, ImageData.setPixel, ImageData.mapPixel
|
|
local getParticleColors, setParticleColors = ParticleSystem.getColors, ParticleSystem.setColors
|
|
local getBatchColor, setBatchColor = SpriteBatch.getColor, SpriteBatch.setColor
|
|
local sendColor = Shader.sendColor
|
|
|
|
---------------------------------------------------------------------------------------------------------------------
|
|
|
|
local function round(v)
|
|
return math.floor(v + .5)
|
|
end
|
|
|
|
-- convert a single channel value from [0-1] to [0-255]
|
|
function cindy.channel2byte(c)
|
|
return round(c * 255)
|
|
end
|
|
|
|
-- convert a single channel value from [0-255] to [0-1]
|
|
function cindy.byte2channel(c)
|
|
return c / 255
|
|
end
|
|
|
|
-- convert RGBA values from [0-1] to [0-255]
|
|
function cindy.rgba2bytes(r, g, b, a)
|
|
return round(r * 255), round(g * 255), round(b * 255), a and round(a * 255)
|
|
end
|
|
|
|
-- convert RGBA values from [0-255] to [0-1]
|
|
function cindy.bytes2rgba(r, g, b, a)
|
|
return r / 255, g / 255, b / 255, a and a / 255
|
|
end
|
|
|
|
-- convert RGBA value table from [0-1] to [0-255]. places the result in dest, if given
|
|
function cindy.table2bytes(color, dest)
|
|
dest = dest or {}
|
|
dest[1], dest[2], dest[3], dest[4] = cindy.rgba2bytes(color[1], color[2], color[3], color[4])
|
|
return dest
|
|
end
|
|
|
|
-- convert RGBA value table from [0-255] to [0-1]. places the result in dest, if given
|
|
function cindy.bytes2table(color, dest)
|
|
dest = dest or {}
|
|
dest[1], dest[2], dest[3], dest[4] = cindy.bytes2rgba(color[1], color[2], color[3], color[4])
|
|
return dest
|
|
end
|
|
|
|
-- convert RGBA values or table from [0-1] to [0-255]. returns separate values
|
|
function cindy.color2bytes(r, g, b, a)
|
|
if type(r) == 'table' then
|
|
r, g, b, a = r[1], r[2], r[3], r[4]
|
|
end
|
|
|
|
return cindy.rgba2bytes(r, g, b, a)
|
|
end
|
|
|
|
-- convert RGBA values or table from [0-255] to [0-1]. returns separate values
|
|
function cindy.bytes2color(r, g, b, a)
|
|
if type(r) == 'table' then
|
|
r, g, b, a = r[1], r[2], r[3], r[4]
|
|
end
|
|
|
|
return cindy.bytes2rgba(r, g, b, a)
|
|
end
|
|
|
|
-- patch all LÖVE functions to accept colors in the [0-255] range
|
|
function cindy.applyPatch()
|
|
gfx.clear, gfx.getColor, gfx.setColor = gfx.clearBytes, gfx.getColorBytes, gfx.setColorBytes
|
|
gfx.getBackgroundColor, gfx.setBackgroundColor = gfx.getBackgroundColorBytes, gfx.setBackgroundColorBytes
|
|
gfx.getColorMask, gfx.setColorMask = gfx.getMaskColorBytes, gfx.setMaskColorBytes
|
|
ImageData.getPixel, ImageData.setPixel = ImageData.getPixelBytes, ImageData.setPixelBytes
|
|
ImageData.mapPixel = ImageData.mapPixelBytes
|
|
ParticleSystem.getColors, ParticleSystem.setColors = ParticleSystem.getColorsBytes, ParticleSystem.setColorsBytes
|
|
SpriteBatch.getColor, SpriteBatch.setColor = SpriteBatch.getColorBytes, SpriteBatch.setColorBytes
|
|
Shader.sendColor = Shader.sendColorBytes
|
|
|
|
return cindy
|
|
end
|
|
|
|
---------------------------------------------------------------------------------------------------------------------
|
|
|
|
local tempTables = { {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {}, {} }
|
|
|
|
function gfx.getColorBytes()
|
|
return cindy.rgba2bytes(getColor())
|
|
end
|
|
|
|
function gfx.setColorBytes(r, g, b, a)
|
|
return setColor(cindy.bytes2color(r, g, b, a))
|
|
end
|
|
|
|
function gfx.getBackgroundColorBytes()
|
|
return cindy.rgba2bytes(getBackgroundColor())
|
|
end
|
|
|
|
function gfx.setBackgroundColorBytes(r, g, b, a)
|
|
return setBackgroundColor(cindy.bytes2color(r, g, b, a))
|
|
end
|
|
|
|
function gfx.getColorMaskBytes()
|
|
return cindy.rgba2bytes(getColorMask())
|
|
end
|
|
|
|
function gfx.setColorMaskBytes(r, g, b, a)
|
|
return setColorMask(cindy.bytes2color(r, g, b, a))
|
|
end
|
|
|
|
function gfx.clearBytes(...)
|
|
local nargs = select('#', ...)
|
|
|
|
if nargs == 0 or type(select(1, ...)) == 'boolean' then
|
|
return clear(...)
|
|
end
|
|
|
|
local args = {...}
|
|
for i = 1, nargs do
|
|
if type(args[i]) == 'table' then
|
|
args[i] = cindy.bytes2table(args[i], tempTables[i])
|
|
elseif type(args[i]) == 'number' then
|
|
args[i] = args[i] / 255
|
|
end
|
|
end
|
|
|
|
return clear(unpack(args))
|
|
end
|
|
|
|
---------------------------------------------------------------------------------------------------------------------
|
|
|
|
function ImageData:getPixelBytes(x, y)
|
|
return cindy.rgba2bytes(getPixel(self, x, y))
|
|
end
|
|
|
|
function ImageData:setPixelBytes(x, y, r, g, b, a)
|
|
return setPixel(self, x, y, cindy.bytes2rgba(r, g, b, a))
|
|
end
|
|
|
|
function ImageData:mapPixelBytes(fn)
|
|
return mapPixel(self, function(x, y, r, g, b, a)
|
|
return cindy.bytes2rgba(fn(x, y, cindy.rgba2bytes(r, g, b, a)))
|
|
end)
|
|
end
|
|
|
|
---------------------------------------------------------------------------------------------------------------------
|
|
|
|
function ParticleSystem:setColorsBytes(...)
|
|
local args, nargs = {...}, select('#', ...)
|
|
|
|
if type(args[1]) == 'table' then
|
|
for i = 1, nargs do
|
|
args[i] = cindy.bytes2table(args[i], tempTables[i])
|
|
end
|
|
else
|
|
for i = 1, nargs do
|
|
args[i] = args[i] / 255
|
|
end
|
|
end
|
|
|
|
return setParticleColors(self, unpack(args))
|
|
end
|
|
|
|
function ParticleSystem:getColorsBytes()
|
|
local colors = { getParticleColors(self) }
|
|
local ncolors = #colors
|
|
|
|
for i = 1, ncolors do
|
|
local rgba = colors[i]
|
|
rgba[1], rgba[2], rgba[3], rgba[4] = cindy.rgba2bytes(rgba[1], rgba[2], rgba[3], rgba[4])
|
|
end
|
|
|
|
return unpack(colors)
|
|
end
|
|
|
|
---------------------------------------------------------------------------------------------------------------------
|
|
|
|
function SpriteBatch:getColorBytes()
|
|
local r, g, b, a = getBatchColor(self)
|
|
|
|
if r then
|
|
return cindy.rgba2bytes(r, g, b, a)
|
|
end
|
|
end
|
|
|
|
function SpriteBatch:setColorBytes(r, g, b, a)
|
|
if r then
|
|
return setBatchColor(self, cindy.bytes2color(r, g, b, a))
|
|
end
|
|
|
|
return setBatchColor(self)
|
|
end
|
|
|
|
---------------------------------------------------------------------------------------------------------------------
|
|
|
|
function Shader:sendColorBytes(name, ...)
|
|
local colors, ncolors = {...}, select('#', ...)
|
|
|
|
for i = 1, ncolors do
|
|
colors[i] = cindy.bytes2table(colors[i], tempTables[i])
|
|
end
|
|
|
|
return sendColor(self, name, unpack(colors))
|
|
end
|
|
|
|
---------------------------------------------------------------------------------------------------------------------
|
|
|
|
return cindy
|