BLittle (ComputerCraft)

-- +--------------------------------------------------------+
-- |                                                        |
-- |                        BLittle                         |
-- |                                                        |
-- +--------------------------------------------------------+

local version = "Version 1.1.6beta"

-- By Jeffrey Alexander, aka Bomb Bloke.
-- Convenience functions to make use of ComputerCraft 1.76's new "drawing" characters.
-- http://www.computercraft.info/forums2/index.php?/topic/25354-cc-176-blittle-api/

-------------------------------------------------------------

if shell then
    local arg = {...}

    if #arg == 0 then
        print("Usage:")
        print("blittle <scriptName> [args]")
        return
    end

    if not blittle then os.loadAPI(shell.getRunningProgram()) end
    local oldTerm = term.redirect(blittle.createWindow())
    shell.run(unpack(arg))
    term.redirect(oldTerm)

    return
end

local relations = {[0] = {8, 4, 3, 6, 5}, {4, 14, 8, 7}, {6, 10, 8, 7}, {9, 11, 8, 0}, {1, 14, 8, 0}, {13, 12, 8, 0}, {2, 10, 8, 0}, {15, 8, 10, 11, 12, 14},
        {0, 7, 1, 9, 2, 13}, {3, 11, 8, 7}, {2, 6, 7, 15}, {9, 3, 7, 15}, {13, 5, 7, 15}, {5, 12, 8, 7}, {1, 4, 7, 15}, {7, 10, 11, 12, 14}}

local colourNum, exponents, colourChar = {}, {}, {}
for i = 0, 15 do exponents[2^i] = i end
do
    local hex = "0123456789abcdef"
    for i = 1, 16 do
        colourNum[hex:sub(i, i)] = i - 1
        colourNum[i - 1] = hex:sub(i, i)
        colourChar[hex:sub(i, i)] = 2 ^ (i - 1)
        colourChar[2 ^ (i - 1)] = hex:sub(i, i)

        local thisRel = relations[i - 1]
        for i = 1, #thisRel do thisRel[i] = 2 ^ thisRel[i] end
    end
end

local function getBestColourMatch(usage)
    local lastCol = relations[exponents[usage[#usage][1]]]

    for j = 1, #lastCol do
        local thisRelation = lastCol[j]
        for i = 1, #usage - 1 do if usage[i][1] == thisRelation then return i end end
    end

    return 1
end

local function colsToChar(pattern, totals)
    if not totals then
        local newPattern = {}
        totals = {}
        for i = 1, 6 do
            local thisVal = pattern[i]
            local thisTot = totals[thisVal]
            totals[thisVal], newPattern[i] = thisTot and (thisTot + 1) or 1, thisVal
        end
        pattern = newPattern
    end

    local usage = {}
    for key, value in pairs(totals) do usage[#usage + 1] = {key, value} end

    if #usage > 1 then
        -- Reduce the chunk to two colours:
        while #usage > 2 do
            table.sort(usage, function (a, b) return a[2] > b[2] end)
            local matchToInd, usageLen = getBestColourMatch(usage), #usage
            local matchFrom, matchTo = usage[usageLen][1], usage[matchToInd][1]
            for i = 1, 6 do if pattern[i] == matchFrom then
                pattern[i] = matchTo
                usage[matchToInd][2] = usage[matchToInd][2] + 1
            end end
            usage[usageLen] = nil
        end

        -- Convert to character. Adapted from oli414's function:
        -- http://www.computercraft.info/forums2/index.php?/topic/25340-cc-176-easy-drawing-characters/
        local data = 128
        for i = 1, #pattern - 1 do if pattern[i] ~= pattern[6] then data = data + 2^(i-1) end end
        return string.char(data), colourChar[usage[1][1] == pattern[6] and usage[2][1] or usage[1][1]], colourChar[pattern[6]]
    else
        -- Solid colour character:
        return "\128", colourChar[pattern[1]], colourChar[pattern[1]]
    end
end

local function snooze()
    local myEvent = tostring({})
    os.queueEvent(myEvent)
    os.pullEvent(myEvent)
end

function shrink(image, bgCol)
    local results, width, height, bgCol = {{}, {}, {}}, 0, #image + #image % 3, bgCol or colours.black
    for i = 1, #image do if #image[i] > width then width = #image[i] end end

    for y = 0, height - 1, 3 do
        local cRow, tRow, bRow, counter = {}, {}, {}, 1

        for x = 0, width - 1, 2 do
            -- Grab a 2x3 chunk:
            local pattern, totals = {}, {}

            for yy = 1, 3 do for xx = 1, 2 do
                pattern[#pattern + 1] = (image[y + yy] and image[y + yy][x + xx]) and (image[y + yy][x + xx] == 0 and bgCol or image[y + yy][x + xx]) or bgCol
                totals[pattern[#pattern]] = totals[pattern[#pattern]] and (totals[pattern[#pattern]] + 1) or 1
            end end

            cRow[counter], tRow[counter], bRow[counter] = colsToChar(pattern, totals)
            counter = counter + 1
        end

        results[1][#results[1] + 1], results[2][#results[2] + 1], results[3][#results[3] + 1] = table.concat(cRow), table.concat(tRow), table.concat(bRow)
    end

    results.width, results.height = #results[1][1], #results[1]

    return results
end

function shrinkGIF(image, bgCol)
    if not GIF and not os.loadAPI("GIF") then error("blittle.shrinkGIF: Load GIF API first.", 2) end

    image = GIF.flattenGIF(image)
    snooze()

    local prev = GIF.toPaintutils(image[1])
    snooze()

    prev = blittle.shrink(prev, bgCol)
    prev.delay = image[1].delay
    image[1] = prev
    snooze()

    image.width, image.height = prev.width, prev.height

    for i = 2, #image do
        local temp = GIF.toPaintutils(image[i])
        snooze()

        temp = blittle.shrink(temp, bgCol)
        snooze()

        local newImage = {{}, {}, {}, ["delay"] = image[i].delay, ["width"] = temp.width, ["height"] = 0}

        local a, b, c, pa, pb, pc = temp[1], temp[2], temp[3], prev[1], prev[2], prev[3]
        for i = 1, temp.height do
            local a1, b1, c1, pa1, pb1, pc1 = a[i], b[i], c[i], pa[i], pb[i], pc[i]

            if a1 ~= pa1 or b1 ~= pb1 or c1 ~= pc1 then
                local min, max = 1, #a1
                local a2, b2, c2, pa2, pb2, pc2 = {a1:byte(1, max)}, {b1:byte(1, max)}, {c1:byte(1, max)}, {pa1:byte(1, max)}, {pb1:byte(1, max)}, {pc1:byte(1, max)}

                for j = 1, max do if a2[j] ~= pa2[j] or b2[j] ~= pb2[j] or c2[j] ~= pc2[j] then
                    min = j
                    break
                end end

                for j = max, min, -1 do if a2[j] ~= pa2[j] or b2[j] ~= pb2[j] or c2[j] ~= pc2[j] then
                    max = j
                    break
                end end

                newImage[1][i], newImage[2][i], newImage[3][i], newImage.height = min > 1 and {min - 1, a1:sub(min, max)} or a1:sub(min, max), b1:sub(min, max), c1:sub(min, max), i
            end

            snooze()
        end

        image[i], prev = newImage, temp

        for j = 1, i - 1 do
            local oldImage = image[j]

            if type(oldImage[1]) == "table" and oldImage.height == newImage.height then
                local same = true

                for k = 1, oldImage.height do
                    local comp1, comp2 = oldImage[1][k], newImage[1][k]

                    if type(comp1) ~= type(comp2) or
                        (type(comp1) == "string" and comp1 ~= comp2) or
                        (type(comp1) == "table" and (comp1[1] ~= comp2[1] or comp1[2] ~= comp2[2])) or
                        oldImage[2][k] ~= newImage[2][k] or
                        oldImage[3][k] ~= newImage[3][k] then
                            same = false
                            break
                    end
                end

                if same then
                    newImage[1], newImage[2], newImage[3] = j
                    break
                end
            end

            snooze()
        end
    end

    return image
end

local function newLine(width, bCol)
    local line = {}
    for i = 1, width do line[i] = {bCol, bCol, bCol, bCol, bCol, bCol} end
    return line
end

function createWindow(parent, x, y, width, height, visible)
    if parent == term or not parent then
        parent = term.current()
    elseif type(parent) ~= "table" or not parent.write then
        error("blittle.newWindow: \"parent\" does not appear to be a terminal object.", 2)
    end

    local workBuffer, backBuffer, frontBuffer, window, tCol, bCol, curX, curY, blink, cWidth, cHeight, pal = {}, {}, {}, {}, colours.white, colours.black, 1, 1, false
    if type(visible) ~= "boolean" then visible = true end
    x, y = x and math.floor(x) or 1, y and math.floor(y) or 1

    do
        local xSize, ySize = parent.getSize()
        cWidth, cHeight = (width or xSize), (height or ySize)
        width, height = cWidth * 2, cHeight * 3
    end

    if parent.setPaletteColour then
        pal = {}

        local counter = 1
        for i = 1, 16 do
            pal[counter] = {parent.getPaletteColour(counter)}
            counter = counter * 2
        end

        window.getPaletteColour = function(colour)
            return unpack(pal[colour])
        end

        window.setPaletteColour = function(colour, r, g, b)
            pal[colour] = {r, g, b}
            if visible then return parent.setPaletteColour(colour, r, g, b) end
        end

        window.getPaletteColor, window.setPaletteColor = window.getPaletteColour, window.setPaletteColour
    end

    window.blit = function(_, _, bC)
        local bClen = #bC
        if curX > width or curX + bClen < 2 or curY < 1 or curY > height then
            curX = curX + bClen
            return
        end

        if curX < 1 then
            bC = bC:sub(2 - curX)
            curX, bClen = 1, #bC
        end

        if curX + bClen - 1 > width then bC, bClen = bC:sub(1, width - curX + 1), width - curX + 1 end

        local colNum, rowNum, thisX, yBump = math.floor((curX - 1) / 2) + 1, math.floor((curY - 1) / 3) + 1, (curX - 1) % 2, ((curY - 1) % 3) * 2
        local firstColNum, lastColNum, thisRow = colNum, math.floor((curX + bClen) / 2), backBuffer[rowNum]
        local thisChar = thisRow[colNum]

        for i = 1, bClen do
            thisChar[thisX + yBump + 1] = colourChar[bC:sub(i, i)]

            if thisX == 1 then
                thisX, colNum = 0, colNum + 1
                thisChar = thisRow[colNum]
                if not thisChar then break end
            else thisX = 1 end
        end

        if visible then
            local chars1, chars2, chars3, count = {}, {}, {}, 1

            for i = firstColNum, lastColNum do
                chars1[count], chars2[count], chars3[count] = colsToChar(thisRow[i])
                count = count + 1
            end

            chars1, chars2, chars3 = table.concat(chars1), table.concat(chars2), table.concat(chars3)
            parent.setCursorPos(x + math.floor((curX - 1) / 2), y + math.floor((curY - 1) / 3))
            parent.blit(chars1, chars2, chars3)
            local thisRow = frontBuffer[rowNum]
            frontBuffer[rowNum] = {thisRow[1]:sub(1, firstColNum - 1) .. chars1 .. thisRow[1]:sub(lastColNum + 1), thisRow[2]:sub(1, firstColNum - 1) .. chars2 .. thisRow[2]:sub(lastColNum + 1), thisRow[3]:sub(1, firstColNum - 1) .. chars3 .. thisRow[3]:sub(lastColNum + 1)}
        else
            local thisRow = workBuffer[rowNum]

            if (not thisRow[firstColNum]) or thisRow[firstColNum] < lastColNum then
                local x, newLastColNum = 1, lastColNum

                while x <= lastColNum + 1 do
                    local thisSpot = thisRow[x]

                    if thisSpot then
                        if thisSpot >= firstColNum - 1 then
                            if x < firstColNum then firstColNum = x else thisRow[x] = nil end
                            if thisSpot > newLastColNum then newLastColNum = thisSpot end
                        end
                        x = thisSpot + 1
                    else x = x + 1 end
                end

                thisRow[firstColNum] = newLastColNum
                if thisRow.max <= newLastColNum then thisRow.max = firstColNum end
            end
        end

        curX = curX + bClen
    end

    window.write = function(text)
        window.blit(nil, nil, string.rep(colourChar[bCol], #tostring(text)))
    end

    window.clearLine = function()
        local oldX = curX
        curX = 1
        window.blit(nil, nil, string.rep(colourChar[bCol], width))
        curX = oldX
    end

    window.clear = function()
        local t, fC, bC = string.rep("\128", cWidth), string.rep(colourChar[tCol], cWidth), string.rep(colourChar[bCol], cWidth)
        for y = 1, cHeight do workBuffer[y], backBuffer[y], frontBuffer[y] = {["max"] = 0}, newLine(cWidth, bCol), {t, fC, bC} end
        window.redraw()
    end

    window.getCursorPos = function()
        return curX, curY
    end

    window.setCursorPos = function(newX, newY)
        curX, curY = math.floor(newX), math.floor(newY)
        if visible and blink then window.restoreCursor() end
    end

    window.restoreCursor = function() end
    window.setCursorBlink = window.restoreCursor

    window.isColour = function()
        return parent.isColour()
    end
    window.isColor = window.isColour

    window.getSize = function()
        return width, height
    end

    window.scroll = function(lines)
        lines = math.floor(lines)

        if lines ~= 0 then
            if lines % 3 == 0 then
                local newWB, newBB, newFB, line1, line2, line3 = {}, {}, {}, string.rep("\128", cWidth), string.rep(colourChar[tCol], cWidth), string.rep(colourChar[bCol], cWidth)
                for y = 1, cHeight do newWB[y], newBB[y], newFB[y] = workBuffer[y + lines] or {["max"] = 0}, backBuffer[y + lines] or newLine(cWidth, bCol), frontBuffer[y + lines] or {line1, line2, line3} end
                workBuffer, backBuffer, frontBuffer = newWB, newBB, newFB
            else
                local newBB, tRowNum, tBump, sRowNum, sBump = {}, 1, 0, math.floor(lines / 3) + 1, (lines % 3) * 2
                local sRow, tRow = backBuffer[sRowNum], {}
                for x = 1, cWidth do tRow[x] = {} end

                for y = 1, height do
                    if sRow then
                        for x = 1, cWidth do
                            local tChar, sChar = tRow[x], sRow[x]
                            tChar[tBump + 1], tChar[tBump + 2] = sChar[sBump + 1], sChar[sBump + 2]
                        end
                    else
                        for x = 1, cWidth do
                            local tChar = tRow[x]
                            tChar[tBump + 1], tChar[tBump + 2] = bCol, bCol
                        end
                    end

                    tBump, sBump = tBump + 2, sBump + 2

                    if tBump > 4 then
                        tBump, newBB[tRowNum] = 0, tRow
                        tRowNum, tRow = tRowNum + 1, {}
                        for x = 1, cWidth do tRow[x] = {} end
                    end

                    if sBump > 4 then
                        sRowNum, sBump = sRowNum + 1, 0
                        sRow = backBuffer[sRowNum]
                    end
                end

                for y = 1, cHeight do workBuffer[y] = {["max"] = 1, cWidth} end

                backBuffer = newBB
            end

            window.redraw()
        end
    end

    window.setTextColour = function(newCol)
        tCol = newCol
    end
    window.setTextColor = window.setTextColour

    window.setBackgroundColour = function(newCol)
        bCol = newCol
    end
    window.setBackgroundColor = window.setBackgroundColour

    window.getTextColour = function()
        return tCol
    end
    window.getTextColor = window.getTextColour

    window.getBackgroundColour = function()
        return bCol
    end
    window.getBackgroundColor = window.getBackgroundColour

    window.redraw = function()
        if visible then
            for i = 1, cHeight do
                local work, front = workBuffer[i], frontBuffer[i]
                local front1, front2, front3 = front[1], front[2], front[3]

                if work.max > 0 then
                    local line1, line2, line3, lineLen, skip, back, count = {}, {}, {}, 1, 0, backBuffer[i], 1

                    while count <= work.max do if work[count] then
                        if skip > 0 then
                            line1[lineLen], line2[lineLen], line3[lineLen] = front1:sub(count - skip, count - 1), front2:sub(count - skip, count - 1), front3:sub(count - skip, count - 1)
                            skip, lineLen = 0, lineLen + 1
                        end

                        for i = count, work[count] do
                            line1[lineLen], line2[lineLen], line3[lineLen] = colsToChar(back[i])
                            lineLen = lineLen + 1
                        end

                        count = work[count] + 1
                    else skip, count = skip + 1, count + 1 end end

                    if count < cWidth + 1 then line1[lineLen], line2[lineLen], line3[lineLen] = front1:sub(count), front2:sub(count), front3:sub(count) end

                    front1, front2, front3 = table.concat(line1), table.concat(line2), table.concat(line3)
                    frontBuffer[i], workBuffer[i] = {front1, front2, front3}, {["max"] = 0}
                end

                parent.setCursorPos(x, y + i - 1)
                parent.blit(front1, front2, front3)
            end

            if pal then
                local counter = 1
                for i = 1, 16 do
                    parent.setPaletteColour(counter, unpack(pal[counter]))
                    counter = counter * 2
                end
            end
        end
    end

    window.setVisible = function(newVis)
        newVis = newVis and true or false

        if newVis and not visible then
            visible = true
            window.redraw()
        else visible = newVis end
    end

    window.getPosition = function()
        return x, y
    end

    window.reposition = function(newX, newY, newWidth, newHeight)
        x, y = type(newX) == "number" and math.floor(newX) or x, type(newY) == "number" and math.floor(newY) or y

        if type(newWidth) == "number" then
            newWidth = math.floor(newWidth)
            if newWidth > cWidth then
                local line1, line2, line3 = string.rep("\128", newWidth - cWidth), string.rep(colourChar[tCol], newWidth - cWidth), string.rep(colourChar[bCol], newWidth - cWidth)
                for y = 1, cHeight do
                    local bRow, fRow = backBuffer[y], frontBuffer[y]
                    for x = cWidth + 1, newWidth do bRow[x] = {bCol, bCol, bCol, bCol, bCol, bCol} end
                    frontBuffer[y] = {fRow[1] .. line3, fRow[2] .. line2, fRow[3] .. line3}
                end
            elseif newWidth < cWidth then
                for y = 1, cHeight do
                    local wRow, bRow, fRow = workBuffer[y], backBuffer[y], frontBuffer[y]
                    for x = newWidth + 1, cWidth do bRow[x] = nil end
                    frontBuffer[y] = {fRow[1]:sub(1, newWidth), fRow[2]:sub(1, newWidth), fRow[3]:sub(1, newWidth)}

                    while wRow[wRow.max] and wRow[wRow.max] > newWidth do
                        wRow[wRow.max] = nil
                        wRow.max = table.maxn(wRow)
                    end
                end
            end
            width, cWidth = newWidth * 2, newWidth
        end

        if type(newHeight) == "number" then
            newHeight = math.floor(newHeight)
            if newHeight > cHeight then
                local line1, line2, line3 = string.rep("\128", cWidth), string.rep(colourChar[tCol], cWidth), string.rep(colourChar[bCol], cWidth)
                for y = cHeight + 1, newHeight do workBuffer[y], backBuffer[y], frontBuffer[y] = {["max"] = 0}, newLine(cWidth, bCol), {line1, line2, line3} end
            elseif newHeight < cHeight then
                for y = newHeight + 1, cHeight do workBuffer[y], backBuffer[y], frontBuffer[y] = nil, nil, nil end
            end
            height, cHeight = newHeight * 3, newHeight
        end

        window.redraw()
    end

    window.clear()
    return window
end

function draw(image, x, y, terminal)
    local t, tC, bC = image[1], image[2], image[3]
    x, y, terminal = x or 1, y or 1, terminal or term.current()

    for i = 1, image.height do
        local tI = t[i]
        if type(tI) == "string" then
            terminal.setCursorPos(x, y + i - 1)
            terminal.blit(tI, tC[i], bC[i])
        elseif type(tI) == "table" then
            terminal.setCursorPos(x + tI[1], y + i - 1)
            terminal.blit(tI[2], tC[i], bC[i])
        end
    end
end

function save(image, filename)
    local output = fs.open(filename, "wb")
    if not output then error("Can't open "..filename.." for output.") end

    local writeByte = output.write

    local function writeInt(num)
        writeByte(bit.band(num, 255))
        writeByte(bit.brshift(num, 8))
    end

    writeByte(66)  -- B
    writeByte(76)  -- L
    writeByte(84)  -- T

    local animated = image[1].delay ~= nil
    writeByte(animated and 1 or 0)

    if animated then
        writeInt(#image)
    else
        local tempImage = {image[1], image[2], image[3]}
        image[1], image[2], image[3] = tempImage, nil, nil
    end

    local width, height = image.width, image.height

    writeInt(width)
    writeInt(height)

    for k = 1, #image do
        local thisImage = image[k]

        if type(thisImage[1]) == "number" then
            writeByte(3)
            writeInt(thisImage[1])
        else
            for i = 1, height do
                if thisImage[1][i] then
                    local rowType, len, thisRow = type(thisImage[1][i])

                    if rowType == "string" then
                        writeByte(1)
                        len = #thisImage[1][i]
                        writeInt(len)
                        thisRow = {thisImage[1][i]:byte(1, len)}
                    elseif rowType == "table" then
                        writeByte(2)
                        len = #thisImage[1][i][2]
                        writeInt(len)
                        writeInt(thisImage[1][i][1])
                        thisRow = {thisImage[1][i][2]:byte(1, len)}
                    else
                        error("Malformed row record #"..i.." in frame #"..k.." when attempting to save \""..filename.."\", type is "..rowType..".")
                    end

                    for x = 1, len do writeByte(thisRow[x]) end

                    local txt, bg = thisImage[2][i], thisImage[3][i]
                    for x = 1, len do writeByte(colourNum[txt:sub(x, x)] + colourNum[bg:sub(x, x)] * 16) end
                else writeByte(0) end
            end
        end

        if animated then writeInt(thisImage.delay * 20) end

        snooze()
    end

    if image.pal then
        writeByte(#image.pal)
        for i = 0, #image.pal do for j = 1, 3 do writeByte(image.pal[i][j]) end end
    end

    if not animated then
        image[2], image[3] = image[1][2], image[1][3]
        image[1] = image[1][1]
    end

    output.close()
end

function load(filename)
    local input = fs.open(filename, "rb")
    if not input then error("Can't open "..filename.." for input.") end

    local read = input.read

    local function readInt()
        local result = read()
        return result + bit.blshift(read(), 8)
    end

    if string.char(read(), read(), read()) ~= "BLT" then
        -- Assume legacy format.
        input.close()
        input = fs.open(filename, "rb")

        read = input.read

        function readInt()
            local result = input.read()
            return result + bit.blshift(input.read(), 8)
        end

        local image = {}
        image.width, image.height = readInt(), readInt()

        for i = 1, 3 do
            local thisSet = {}
            for y = 1, image.height do
                local thisRow = {}
                for x = 1, image.width do thisRow[x] = string.char(input.read()) end
                thisSet[y] = table.concat(thisRow)
            end
            image[i] = thisSet
        end

        input.close()

        return image
    end

    local image, animated, frames = {}, read() == 1
    if animated then frames = readInt() else frames = 1 end

    local width, height = readInt(), readInt()
    image.width, image.height = width, height

    for k = 1, frames do
        local thisImage = {["width"] = width, ["height"] = 0}
        local chr, txt, bg = {}, {}, {}

        for i = 1, height do
            local lineType = read()

            if lineType == 3 then
                chr, txt, bg = readInt()
                break
            elseif lineType > 0 then
                local l1, l2, len, bump = {}, {}, readInt()
                if lineType == 2 then bump = readInt() end

                for x = 1, len do l1[x] = read() end
                chr[i] = string.char(unpack(l1))
                if lineType == 2 then chr[i] = {bump, chr[i]} end

                for x = 1, len do
                    local thisVal = read()
                    l1[x], l2[x] = colourNum[bit.band(thisVal, 15)], colourNum[bit.brshift(thisVal, 4)]
                end

                txt[i], bg[i], thisImage.height = table.concat(l1), table.concat(l2), i
            end
        end

        if animated then thisImage["delay"] = readInt() / 20 end
        thisImage[1], thisImage[2], thisImage[3] = chr, txt, bg
        image[k] = thisImage

        snooze()
    end

    local palLength = read()
    if palLength and palLength > 0 then
        image.pal = {}
        for i = 0, palLength do image.pal[i] = {read(), read(), read()} end
    end

    if not animated then
        image[2], image[3] = image[1][2], image[1][3]
        image[1] = image[1][1]
    end

    input.close()

    return image
end

if term.setPaletteColour then
    function applyPalette(image, terminal)
        terminal = terminal or term

        local col, pal = 1, image.pal

        for i = 0, #pal do
            local thisCol = pal[i]
            terminal.setPaletteColour(col, thisCol[1] / 255, thisCol[2] / 255, thisCol[3] / 255)
            col = col * 2
        end
    end
end