Surface 2 Build

local surface = { } do
--[[
Surface 2

The MIT License (MIT)
Copyright (c) 2017 CrazedProgrammer

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 surf = { }
surface.surf = surf

local table_concat, math_floor, math_atan2 = table.concat, math.floor, math.atan2

local _cc_color_to_hex, _cc_hex_to_color = { }, { }
for i = 0, 15 do
    _cc_color_to_hex[2 ^ i] = string.format("%01x", i)
    _cc_hex_to_color[string.format("%01x", i)] = 2 ^ i
end

local _chars = { }
for i = 0, 255 do
    _chars[i] = string.char(i)
end
local _numstr = { }
for i = 0, 1023 do
    _numstr[i] = tostring(i)
end

local _eprc, _esin, _ecos = 20, { }, { }
for i = 0, _eprc - 1 do
    _esin[i + 1] = (1 - math.sin(i / _eprc * math.pi * 2)) / 2
    _ecos[i + 1] = (1 + math.cos(i / _eprc * math.pi * 2)) / 2
end

local _steps, _palette, _rgbpal, _palr, _palg, _palb = 16

local function calcStack(stack, width, height)
    local ox, oy, cx, cy, cwidth, cheight = 0, 0, 0, 0, width, height
    for i = 1, #stack do
        ox = ox + stack[i].ox
        oy = oy + stack[i].oy
        cx = cx + stack[i].x
        cy = cy + stack[i].y
        cwidth = stack[i].width
        cheight = stack[i].height
    end
    return ox, oy, cx, cy, cwidth, cheight
end

local function clipRect(x, y, width, height, cx, cy, cwidth, cheight)
    if x < cx then
        width = width + x - cx
        x = cx
    end
    if y < cy then
        height = height + y - cy
        y = cy
    end
    if x + width > cx + cwidth then
        width = cwidth + cx - x
    end
    if y + height > cy + cheight then
        height = cheight + cy - y
    end
    return x, y, width, height
end



function surface.create(width, height, b, t, c)
    local surface = setmetatable({ }, {__index = surface.surf})
    surface.width = width
    surface.height = height
    surface.buffer = { }
    surface.overwrite = false
    surface.stack = { }
    surface.ox, surface.oy, surface.cx, surface.cy, surface.cwidth, surface.cheight = calcStack(surface.stack, width, height)
    -- force array indeces instead of hashed indices

    local buffer = surface.buffer
    for i = 1, width * height * 3, 3 do
        buffer[i] = b or false
        buffer[i + 1] = t or false
        buffer[i + 2] = c or false
    end
    buffer[width * height * 3 + 1] = false
    if not b then
        for i = 1, width * height * 3, 3 do
            buffer[i] = b
        end
    end
    if not t then
        for i = 2, width * height * 3, 3 do
            buffer[i] = t
        end
    end
    if not c then
        for i = 3, width * height * 3, 3 do
            buffer[i] = c
        end
    end

    return surface
end

function surface.getPlatformOutput(output)
    output = output or (term or gpu or (love and love.graphics) or io)

    if output.blit and output.setCursorPos then
        return "cc", output, output.getSize()
    elseif output.write and output.setCursorPos and output.setTextColor and output.setBackgroundColor then
        return "cc-old", output, output.getSize()
    elseif output.blitPixels then
        return "riko-4", output, 320, 200
    elseif output.points and output.setColor then
        return "love2d", output, output.getWidth(), output.getHeight()
    elseif output.drawPixel then
        return "redirection", output, 64, 64
    elseif output.setForeground and output.setBackground and output.set then
        return "oc", output, output.getResolution()
    elseif output.write then
        return "ansi", output, (os.getenv and (os.getenv("COLUMNS"))) or 80, (os.getenv and (os.getenv("LINES"))) or 43
    else
        error("unsupported platform/output object")
    end
end

function surf:output(output, x, y, sx, sy, swidth, sheight)
    local platform, output, owidth, oheight = surface.getPlatformOutput(output)

    x = x or 0
    y = y or 0
    sx = sx or 0
    sy = sy or 0
    swidth = swidth or self.width
    sheight = sheight or self.height
    sx, sy, swidth, sheight = clipRect(sx, sy, swidth, sheight, 0, 0, self.width, self.height)

    local buffer = self.buffer
    local bwidth = self.width
    local xoffset, yoffset, idx

    if platform == "cc" then
        -- CC
        local str, text, back = { }, { }, { }
        for j = 0, sheight - 1 do
            yoffset = (j + sy) * bwidth + sx
            for i = 0, swidth - 1 do
                xoffset = (yoffset + i) * 3
                idx = i + 1
                str[idx] = buffer[xoffset + 3] or " "
                text[idx] = _cc_color_to_hex[buffer[xoffset + 2] or 1]
                back[idx] = _cc_color_to_hex[buffer[xoffset + 1] or 32768]
            end
            output.setCursorPos(x + 1, y + j + 1)
            output.blit(table_concat(str), table_concat(text), table_concat(back))
        end

    elseif platform == "cc-old" then
        -- CC pre-1.76
        local str, b, t, pb, pt = { }
        for j = 0, sheight - 1 do
            output.setCursorPos(x + 1, y + j + 1)
            yoffset = (j + sy) * bwidth + sx
            for i = 0, swidth - 1 do
                xoffset = (yoffset + i) * 3
                pb = buffer[xoffset + 1] or 32768
                pt = buffer[xoffset + 2] or 1
                if pb ~= b then
                    if #str ~= 0 then
                        output.write(table_concat(str))
                        str = { }
                    end
                    b = pb
                    output.setBackgroundColor(b)
                end
                if pt ~= t then
                    if #str ~= 0 then
                        output.write(table_concat(str))
                        str = { }
                    end
                    t = pt
                    output.setTextColor(t)
                end
                str[#str + 1] = buffer[xoffset + 3] or " "
            end
            output.write(table_concat(str))
            str = { }
        end

    elseif platform == "riko-4" then
        -- Riko 4
        local pixels = { }
        for j = 0, sheight - 1 do
            yoffset = (j + sy) * bwidth + sx
            for i = 0, swidth - 1 do
                pixels[j * swidth + i + 1] = buffer[(yoffset + i) * 3 + 1] or 0
            end
        end
        output.blitPixels(x, y, swidth, sheight, pixels)

    elseif platform == "love2d" then
        -- Love2D
        local pos, r, g, b, pr, pg, pb = { }
        for j = 0, sheight - 1 do
            yoffset = (j + sy) * bwidth + sx
            for i = 0, swidth - 1 do
                xoffset = (yoffset + i) * 3
                pr = buffer[xoffset + 1]
                pg = buffer[xoffset + 2]
                pb = buffer[xoffset + 3]
                if pr ~= r or pg ~= g or pb ~= b then
                    if #pos ~= 0 then
                        output.setColor((r or 0) * 255, (g or 0) * 255, (b or 0) * 255, (r or g or b) and 255 or 0)
                        output.points(pos)
                    end
                    r, g, b = pr, pg, pb
                    pos = { }
                end
                pos[#pos + 1] = i + x + 1
                pos[#pos + 1] = j + y + 1
            end
        end
        output.setColor((r or 0) * 255, (g or 0) * 255, (b or 0) * 255, (r or g or b) and 255 or 0)
        output.points(pos)

    elseif platform == "redirection" then
        -- Redirection arcade (gpu)
        -- todo: add image:write support for extra performance
        local px = output.drawPixel
        for j = 0, sheight - 1 do
            for i = 0, swidth - 1 do
                px(x + i, y + j, buffer[((j + sy) * bwidth + (i + sx)) * 3 + 1] or 0)
            end
        end

    elseif platform == "oc" then
        -- OpenComputers
        local str, lx, b, t, pb, pt = { }
        for j = 0, sheight - 1 do
            lx = x
            yoffset = (j + sy) * bwidth + sx
            for i = 0, swidth - 1 do
                xoffset = (yoffset + i) * 3
                pb = buffer[xoffset + 1] or 0x000000
                pt = buffer[xoffset + 2] or 0xFFFFFF
                if pb ~= b then
                    if #str ~= 0 then
                        output.set(lx + 1, j + y + 1, table_concat(str))
                        lx = i + x
                        str = { }
                    end
                    b = pb
                    output.setBackground(b)
                end
                if pt ~= t then
                    if #str ~= 0 then
                        output.set(lx + 1, j + y + 1, table_concat(str))
                        lx = i + x
                        str = { }
                    end
                    t = pt
                    output.setForeground(t)
                end
                str[#str + 1] = buffer[xoffset + 3] or " "
            end
            output.set(lx + 1, j + y + 1, table_concat(str))
            str = { }
        end

    elseif platform == "ansi" then
        -- ANSI terminal
        local str, b, t, pb, pt = { }
        for j = 0, sheight - 1 do
            str[#str + 1] = "\x1b[".._numstr[y + j + 1]..";".._numstr[x + 1].."H"
            yoffset = (j + sy) * bwidth + sx
            for i = 0, swidth - 1 do
                xoffset = (yoffset + i) * 3
                pb = buffer[xoffset + 1] or 0
                pt = buffer[xoffset + 2] or 7
                if pb ~= b then
                    b = pb
                    if b < 8 then
                        str[#str + 1] = "\x1b[".._numstr[40 + b].."m"
                    elseif b < 16 then
                        str[#str + 1] = "\x1b[".._numstr[92 + b].."m"
                    elseif b < 232 then
                        str[#str + 1] = "\x1b[48;2;".._numstr[math_floor((b - 16) / 36 * 85 / 2)]..";".._numstr[math_floor((b - 16) / 6 % 6 * 85 / 2)]..";".._numstr[math_floor((b - 16) % 6 * 85 / 2)].."m"
                    else
                        local gr = _numstr[b * 10 - 2312]
                        str[#str + 1] = "\x1b[48;2;"..gr..";"..gr..";"..gr.."m"
                    end
                end
                if pt ~= t then
                    t = pt
                    if t < 8 then
                        str[#str + 1] = "\x1b[".._numstr[30 + t].."m"
                    elseif t < 16 then
                        str[#str + 1] = "\x1b[".._numstr[82 + t].."m"
                    elseif t < 232 then
                        str[#str + 1] = "\x1b[38;2;".._numstr[math_floor((t - 16) / 36 * 85 / 2)]..";".._numstr[math_floor((t - 16) / 6 % 6 * 85 / 2)]..";".._numstr[math_floor((t - 16) % 6 * 85 / 2)].."m"
                    else
                        local gr = _numstr[t * 10 - 2312]
                        str[#str + 1] = "\x1b[38;2;"..gr..";"..gr..";"..gr.."m"
                    end
                end
                str[#str + 1] = buffer[xoffset + 3] or " "
            end
        end
        output.write(table_concat(str))
    end
end

function surf:push(x, y, width, height, nooffset)
    x, y = x + self.ox, y + self.oy

    local ox, oy = nooffset and self.ox or x, nooffset and self.oy or y
    x, y, width, height = clipRect(x, y, width, height, self.cx, self.cy, self.cwidth, self.cheight)
    self.stack[#self.stack + 1] = {ox = ox - self.ox, oy = oy - self.oy, x = x - self.cx, y = y - self.cy, width = width, height = height}

    self.ox, self.oy, self.cx, self.cy, self.cwidth, self.cheight = calcStack(self.stack, self.width, self.height)
end

function surf:pop()
    if #self.stack == 0 then
        error("no stencil to pop")
    end
    self.stack[#self.stack] = nil
    self.ox, self.oy, self.cx, self.cy, self.cwidth, self.cheight = calcStack(self.stack, self.width, self.height)
end

function surf:copy()
    local surface = setmetatable({ }, {__index = surface.surf})

    for k, v in pairs(self) do
        surface[k] = v
    end

    surface.buffer = { }
    for i = 1, self.width * self.height * 3 + 1 do
        surface.buffer[i] = false
    end
    for i = 1, self.width * self.height * 3 do
        surface.buffer[i] = self.buffer[i]
    end

    surface.stack = { }
    for i = 1, #self.stack do
        surface.stack[i] = self.stack[i]
    end

    return surface
end

function surf:clear(b, t, c)
    local xoffset, yoffset

    for j = 0, self.cheight - 1 do
        yoffset = (j + self.cy) * self.width + self.cx
        for i = 0, self.cwidth - 1 do
            xoffset = (yoffset + i) * 3
            self.buffer[xoffset + 1] = b
            self.buffer[xoffset + 2] = t
            self.buffer[xoffset + 3] = c
        end
    end
end

function surf:drawPixel(x, y, b, t, c)
    x, y = x + self.ox, y + self.oy

    local idx
    if x >= self.cx and x < self.cx + self.cwidth and y >= self.cy and y < self.cy + self.cheight then
        idx = (y * self.width + x) * 3
        if b or self.overwrite then
            self.buffer[idx + 1] = b
        end
        if t or self.overwrite then
            self.buffer[idx + 2] = t
        end
        if c or self.overwrite then
            self.buffer[idx + 3] = c
        end
    end
end

function surf:drawString(str, x, y, b, t)
    x, y = x + self.ox, y + self.oy

    local sx = x
    local insidey = y >= self.cy and y < self.cy + self.cheight
    local idx
    local lowerxlim = self.cx
    local upperxlim = self.cx + self.cwidth
    local writeb = b or self.overwrite
    local writet = t or self.overwrite

    for i = 1, #str do
        local c = str:sub(i, i)
        if c == "\n" then
            x = sx
            y = y + 1
            if insidey then
                if y >= self.cy + self.cheight then
                    return
                end
            else
                insidey = y >= self.cy
            end
        else
            idx = (y * self.width + x) * 3
            if x >= lowerxlim and x < upperxlim and insidey then
                if writeb then
                    self.buffer[idx + 1] = b
                end
                if writet then
                    self.buffer[idx + 2] = t
                end
                self.buffer[idx + 3] = c
            end
            x = x + 1
        end
    end
end

-- You can remove any of these components
function surface.load(strpath, isstr)
    local data = strpath
    if not isstr then
        local handle = io.open(strpath, "rb")
        if not handle then return end
        local chars = { }
        local byte = handle:read(1)
        if type(byte) == "number" then -- cc doesn't conform to standards
            while byte do
                chars[#chars + 1] = _chars[byte]
                byte = handle:read(1)
            end
        else
            while byte do
                chars[#chars + 1] = byte
                byte = handle:read(1)
            end
        end
        handle:close()
        data = table_concat(chars)
    end

    if data:sub(1, 3) == "RIF" then
        -- Riko 4 image format
        local width, height = data:byte(4) * 256 + data:byte(5), data:byte(6) * 256 + data:byte(7)
        local surf = surface.create(width, height)
        local buffer = surf.buffer
        local upper, byte = 8, false
        local byte = data:byte(index)

        for j = 0, height - 1 do
            for i = 0, height - 1 do
                if not upper then
                    buffer[(j * width + i) * 3 + 1] = math_floor(byte / 16)
                else
                    buffer[(j * width + i) * 3 + 1] = byte % 16
                    index = index + 1
                    data = data:byte(index)
                end
                upper = not upper
            end
        end
        return surf

    elseif data:sub(1, 2) == "BM" then
        -- BMP format
        local width = data:byte(0x13) + data:byte(0x14) * 256
        local height = data:byte(0x17) + data:byte(0x18) * 256
        if data:byte(0xF) ~= 0x28 or data:byte(0x1B) ~= 1 or data:byte(0x1D) ~= 0x18 then
            error("unsupported bmp format, only uncompressed 24-bit rgb is supported.")
        end
        local offset, linesize = 0x36, math.ceil((width * 3) / 4) * 4

        local surf = surface.create(width, height)
        local buffer = surf.buffer
        for j = 0, height - 1 do
            for i = 0, width - 1 do
                buffer[(j * width + i) * 3 + 1] = data:byte((height - j - 1) * linesize + i * 3 + offset + 3) / 255
                buffer[(j * width + i) * 3 + 2] = data:byte((height - j - 1) * linesize + i * 3 + offset + 2) / 255
                buffer[(j * width + i) * 3 + 3] = data:byte((height - j - 1) * linesize + i * 3 + offset + 1) / 255
            end
        end
        return surf

    elseif data:find("\30") then
        -- NFT format
        local width, height, lwidth = 0, 1, 0
        for i = 1, #data do
            if data:byte(i) == 10 then -- newline
                height = height + 1
                if lwidth > width then
                    width = lwidth
                end
                lwidth = 0
            elseif data:byte(i) == 30 or data:byte(i) == 31 then -- color control
                lwidth = lwidth - 1
            elseif data:byte(i) ~= 13 then -- not carriage return
                lwidth = lwidth + 1
            end
        end
        if data:byte(#data) == 10 then
            height = height - 1
        end

        local surf = surface.create(width, height)
        local buffer = surf.buffer
        local index, x, y, b, t = 1, 0, 0

        while index <= #data do
            if data:byte(index) == 10 then
                x, y = 0, y + 1
            elseif data:byte(index) == 30 then
                index = index + 1
                b = _cc_hex_to_color[data:sub(index, index)]
            elseif data:byte(index) == 31 then
                index = index + 1
                t = _cc_hex_to_color[data:sub(index, index)]
            elseif data:byte(index) ~= 13 then
                buffer[(y * width + x) * 3 + 1] = b
                buffer[(y * width + x) * 3 + 2] = t
                if b or t then
                    buffer[(y * width + x) * 3 + 3] = data:sub(index, index)
                elseif data:sub(index, index) ~= " " then
                    buffer[(y * width + x) * 3 + 3] = data:sub(index, index)
                end
                x = x + 1
            end
            index = index + 1
        end

        return surf
    else
        -- NFP format
        local width, height, lwidth = 0, 1, 0
        for i = 1, #data do
            if data:byte(i) == 10 then -- newline
                height = height + 1
                if lwidth > width then
                    width = lwidth
                end
                lwidth = 0
            elseif data:byte(i) ~= 13 then -- not carriage return
                lwidth = lwidth + 1
            end
        end
        if data:byte(#data) == 10 then
            height = height - 1
        end

        local surf = surface.create(width, height)
        local buffer = surf.buffer
        local x, y = 0, 0
        for i = 1, #data do
            if data:byte(i) == 10 then
                x, y = 0, y + 1
            elseif data:byte(i) ~= 13 then
                buffer[(y * width + x) * 3 + 1] = _cc_hex_to_color[data:sub(i, i)]
                x = x + 1
            end
        end

        return surf
    end
end

function surf:save(file, format)
    format = format or "nfp"
    local data = { }
    if format == "nfp" then
        for j = 0, self.height - 1 do
            for i = 0, self.width - 1 do
                data[#data + 1] = _cc_color_to_hex[self.buffer[(j * self.width + i) * 3 + 1]] or " "
            end
            data[#data + 1] = "\n"
        end

    elseif format == "nft" then
        for j = 0, self.height - 1 do
            local b, t, pb, pt
            for i = 0, self.width - 1 do
                pb = self.buffer[(j * self.width + i) * 3 + 1]
                pt = self.buffer[(j * self.width + i) * 3 + 2]
                if pb ~= b then
                    data[#data + 1] = "\30"..(_cc_color_to_hex[pb] or " ")
                    b = pb
                end
                if pt ~= t then
                    data[#data + 1] = "\31"..(_cc_color_to_hex[pt] or " ")
                    t = pt
                end
                data[#data + 1] = self.buffer[(j * self.width + i) * 3 + 3] or " "
            end
            data[#data + 1] = "\n"
        end

    elseif format == "rif" then
        data[1] = "RIF"
        data[2] = string.char(math_floor(self.width / 256), self.width % 256)
        data[3] = string.char(math_floor(self.height / 256), self.height % 256)
        local byte, upper, c = 0, false
        for j = 0, self.width - 1 do
            for i = 0, self.height - 1 do
                c = self.buffer[(j * self.width + i) * 3 + 1] or 0
                if not upper then
                    byte = c * 16
                else
                    byte = byte + c
                    data[#data + 1] = string.char(byte)
                end
                upper = not upper
            end
        end
        if upper then
            data[#data + 1] = string.char(byte)
        end

    elseif format == "bmp" then
        data[1] = "BM"
        data[2] = string.char(0, 0, 0, 0) -- file size, change later
        data[3] = string.char(0, 0, 0, 0, 0x36, 0, 0, 0, 0x28, 0, 0, 0)
        data[4] = string.char(self.width % 256, math_floor(self.width / 256), 0, 0)
        data[5] = string.char(self.height % 256, math_floor(self.height / 256), 0, 0)
        data[6] = string.char(1, 0, 0x18, 0, 0, 0, 0, 0)
        data[7] = string.char(0, 0, 0, 0) -- pixel data size, change later
        data[8] = string.char(0x13, 0x0B, 0, 0, 0x13, 0x0B, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0)

        local padchars = math.ceil((self.width * 3) / 4) * 4 - self.width * 3
        for j = self.height - 1, 0, -1 do
            for i = 0, self.width - 1 do
                data[#data + 1] = string.char((self.buffer[(j * self.width + i) * 3 + 1] or 0) * 255)
                data[#data + 1] = string.char((self.buffer[(j * self.width + i) * 3 + 2] or 0) * 255)
                data[#data + 1] = string.char((self.buffer[(j * self.width + i) * 3 + 3] or 0) * 255)
            end
            data[#data + 1] = ("\0"):rep(padchars)
        end
        local size = #table_concat(data)
        data[2] = string.char(size % 256, math_floor(size / 256) % 256, math_floor(size / 65536), 0)
        size = size - 54
        data[7] = string.char(size % 256, math_floor(size / 256) % 256, math_floor(size / 65536), 0)

    else
        error("format not supported")
    end

    data = table_concat(data)
    if file then
        local handle = io.open(file, "wb")
        for i = 1, #data do
            handle:write(data:byte(i))
        end
        handle:close()
    end
    return data
end
function surf:drawLine(x1, y1, x2, y2, b, t, c)
    if x1 == x2 then
        x1, y1, x2, y2 = x1 + self.ox, y1 + self.oy, x2 + self.ox, y2 + self.oy
        if x1 < self.cx or x1 >= self.cx + self.cwidth then return end
        if y2 < y1 then
            local temp = y1
            y1 = y2
            y2 = temp
        end
        if y1 < self.cy then y1 = self.cy end
        if y2 >= self.cy + self.cheight then y2 = self.cy + self.cheight - 1 end
        if b or self.overwrite then
            for j = y1, y2 do
                self.buffer[(j * self.width + x1) * 3 + 1] = b
            end
        end
        if t or self.overwrite then
            for j = y1, y2 do
                self.buffer[(j * self.width + x1) * 3 + 2] = t
            end
        end
        if c or self.overwrite then
            for j = y1, y2 do
                self.buffer[(j * self.width + x1) * 3 + 3] = c
            end
        end
    elseif y1 == y2 then
        x1, y1, x2, y2 = x1 + self.ox, y1 + self.oy, x2 + self.ox, y2 + self.oy
        if y1 < self.cy or y1 >= self.cy + self.cheight then return end
        if x2 < x1 then
            local temp = x1
            x1 = x2
            x2 = temp
        end
        if x1 < self.cx then x1 = self.cx end
        if x2 >= self.cx + self.cwidth then x2 = self.cx + self.cwidth - 1 end
        if b or self.overwrite then
            for i = x1, x2 do
                self.buffer[(y1 * self.width + i) * 3 + 1] = b
            end
        end
        if t or self.overwrite then
            for i = x1, x2 do
                self.buffer[(y1 * self.width + i) * 3 + 2] = t
            end
        end
        if c or self.overwrite then
            for i = x1, x2 do
                self.buffer[(y1 * self.width + i) * 3 + 3] = c
            end
        end
    else
        local delta_x = x2 - x1
        local ix = delta_x > 0 and 1 or -1
        delta_x = 2 * math.abs(delta_x)
        local delta_y = y2 - y1
        local iy = delta_y > 0 and 1 or -1
        delta_y = 2 * math.abs(delta_y)
        self:drawPixel(x1, y1, b, t, c)
        if delta_x >= delta_y then
            local error = delta_y - delta_x / 2
            while x1 ~= x2 do
                if (error >= 0) and ((error ~= 0) or (ix > 0)) then
                    error = error - delta_x
                    y1 = y1 + iy
                end
                error = error + delta_y
                x1 = x1 + ix
                self:drawPixel(x1, y1, b, t, c)
            end
        else
            local error = delta_x - delta_y / 2
            while y1 ~= y2 do
                if (error >= 0) and ((error ~= 0) or (iy > 0)) then
                    error = error - delta_y
                    x1 = x1 + ix
                end
                error = error + delta_x
                y1 = y1 + iy
                self:drawPixel(x1, y1, b, t, c)
            end
        end
    end
end

function surf:drawRect(x, y, width, height, b, t, c)
    self:drawLine(x, y, x + width - 1, y, b, t, c)
    self:drawLine(x, y, x, y + height - 1, b, t, c)
    self:drawLine(x + width - 1, y, x + width - 1, y + height - 1, b, t, c)
    self:drawLine(x, y + height - 1, x + width - 1, y + height - 1, b, t, c)
end

function surf:fillRect(x, y, width, height, b, t, c)
    x, y, width, height = clipRect(x + self.ox, y + self.oy, width, height, self.cx, self.cy, self.cwidth, self.cheight)

    if b or self.overwrite then
        for j = 0, height - 1 do
            for i = 0, width - 1 do
                self.buffer[((j + y) * self.width + i + x) * 3 + 1] = b
            end
        end
    end
    if t or self.overwrite then
        for j = 0, height - 1 do
            for i = 0, width - 1 do
                self.buffer[((j + y) * self.width + i + x) * 3 + 2] = t
            end
        end
    end
    if c or self.overwrite then
        for j = 0, height - 1 do
            for i = 0, width - 1 do
                self.buffer[((j + y) * self.width + i + x) * 3 + 3] = c
            end
        end
    end
end

function surf:drawTriangle(x1, y1, x2, y2, x3, y3, b, t, c)
    self:drawLine(x1, y1, x2, y2, b, t, c)
    self:drawLine(x2, y2, x3, y3, b, t, c)
    self:drawLine(x3, y3, x1, y1, b, t, c)
end

function surf:fillTriangle(x1, y1, x2, y2, x3, y3, b, t, c)
    if y1 > y2 then
        local tempx, tempy = x1, y1
        x1, y1 = x2, y2
        x2, y2 = tempx, tempy
    end
    if y1 > y3 then
        local tempx, tempy = x1, y1
        x1, y1 = x3, y3
        x3, y3 = tempx, tempy
    end
    if y2 > y3 then
        local tempx, tempy = x2, y2
        x2, y2 = x3, y3
        x3, y3 = tempx, tempy
    end
    if y1 == y2 and x1 > x2 then
        local temp = x1
        x1 = x2
        x2 = temp
    end
    if y2 == y3 and x2 > x3 then
        local temp = x2
        x2 = x3
        x3 = temp
    end

    local x4, y4
    if x1 <= x2 then
        x4 = x1 + (y2 - y1) / (y3 - y1) * (x3 - x1)
        y4 = y2
        local tempx, tempy = x2, y2
        x2, y2 = x4, y4
        x4, y4 = tempx, tempy
    else
        x4 = x1 + (y2 - y1) / (y3 - y1) * (x3 - x1)
        y4 = y2
    end

    local finvslope1 = (x2 - x1) / (y2 - y1)
    local finvslope2 = (x4 - x1) / (y4 - y1)
    local linvslope1 = (x3 - x2) / (y3 - y2)
    local linvslope2 = (x3 - x4) / (y3 - y4)

    local xstart, xend, dxstart, dxend
    for y = math.ceil(y1 + 0.5) - 0.5, math.floor(y3 - 0.5) + 0.5, 1 do
        if y <= y2 then -- first half
            xstart = x1 + finvslope1 * (y - y1)
            xend = x1 + finvslope2 * (y - y1)
        else -- second half
            xstart = x3 - linvslope1 * (y3 - y)
            xend = x3 - linvslope2 * (y3 - y)
        end

        dxstart, dxend = math.ceil(xstart - 0.5), math.floor(xend - 0.5)
        if dxstart <= dxend then
            self:drawLine(dxstart, y - 0.5, dxend, y - 0.5, b, t, c)
        end
    end
end

function surf:drawEllipse(x, y, width, height, b, t, c)
    for i = 0, _eprc - 1 do
        self:drawLine(math_floor(x + _ecos[i + 1] * (width - 1) + 0.5), math_floor(y + _esin[i + 1] * (height - 1) + 0.5), math_floor(x + _ecos[(i + 1) % _eprc + 1] * (width - 1) + 0.5), math_floor(y + _esin[(i + 1) % _eprc + 1] * (height - 1) + 0.5), b, t, c)
    end
end

function surf:fillEllipse(x, y, width, height, b, t, c)
    x, y = x + self.ox, y + self.oy

    local sx, sy
    for j = 0, height - 1 do
        for i = 0, width - 1 do
            sx, sy = i + x, j + y
            if ((i + 0.5) / width * 2 - 1) ^ 2 + ((j + 0.5) / height * 2 - 1) ^ 2 <= 1 and sx >= self.cx and sx < self.cx + self.cwidth and sy >= self.cy and sy < self.cy + self.cheight then
                if b or self.overwrite then
                    self.buffer[(sy * self.width + sx) * 3 + 1] = b
                end
                if t or self.overwrite then
                    self.buffer[(sy * self.width + sx) * 3 + 2] = t
                end
                if c or self.overwrite then
                    self.buffer[(sy * self.width + sx) * 3 + 3] = c
                end
            end
        end
    end
end

function surf:drawArc(x, y, width, height, fromangle, toangle, b, t, c)
    if fromangle > toangle then
        local temp = fromangle
        fromangle = toangle
        temp = toangle
    end
    fromangle = math_floor(fromangle / math.pi / 2 * _eprc + 0.5)
    toangle = math_floor(toangle / math.pi / 2 * _eprc + 0.5) - 1

    for j = fromangle, toangle do
        local i = j % _eprc
        self:drawLine(math_floor(x + _ecos[i + 1] * (width - 1) + 0.5), math_floor(y + _esin[i + 1] * (height - 1) + 0.5), math_floor(x + _ecos[(i + 1) % _eprc + 1] * (width - 1) + 0.5), math_floor(y + _esin[(i + 1) % _eprc + 1] * (height - 1) + 0.5), b, t, c)
    end
end

function surf:fillArc(x, y, width, height, fromangle, toangle, b, t, c)
    x, y = x + self.ox, y + self.oy

    if fromangle > toangle then
        local temp = fromangle
        fromangle = toangle
        temp = toangle
    end
    local diff = toangle - fromangle
    fromangle = fromangle % (math.pi * 2)

    local fx, fy, sx, sy, dir
    for j = 0, height - 1 do
        for i = 0, width - 1 do
            fx, fy = (i + 0.5) / width * 2 - 1, (j + 0.5) / height * 2 - 1
            sx, sy = i + x, j + y
            dir = math_atan2(-fy, fx) % (math.pi * 2)
            if fx ^ 2 + fy ^ 2 <= 1 and ((dir >= fromangle and dir - fromangle <= diff) or (dir <= (fromangle + diff) % (math.pi * 2))) and sx >= self.cx and sx < self.cx + self.cwidth and sy >= self.cy and sy < self.cy + self.cheight then
                if b or self.overwrite then
                    self.buffer[(sy * self.width + sx) * 3 + 1] = b
                end
                if t or self.overwrite then
                    self.buffer[(sy * self.width + sx) * 3 + 2] = t
                end
                if c or self.overwrite then
                    self.buffer[(sy * self.width + sx) * 3 + 3] = c
                end
            end
        end
    end
end
function surf:drawSurface(surf2, x, y, width, height, sx, sy, swidth, sheight)
    x, y, width, height, sx, sy, swidth, sheight = x + self.ox, y + self.oy, width or surf2.width, height or surf2.height, sx or 0, sy or 0, swidth or surf2.width, sheight or surf2.height

    if width == swidth and height == sheight then
        local nx, ny
        nx, ny, width, height = clipRect(x, y, width, height, self.cx, self.cy, self.cwidth, self.cheight)
        swidth, sheight = width, height
        if nx > x then
            sx = sx + nx - x
            x = nx
        end
        if ny > y then
            sy = sy + ny - y
            y = ny
        end
        nx, ny, swidth, sheight = clipRect(sx, sy, swidth, sheight, 0, 0, surf2.width, surf2.height)
        width, height = swidth, sheight
        if nx > sx then
            x = x + nx - sx
            sx = nx
        end
        if ny > sy then
            y = y + ny - sy
            sy = ny
        end

        local b, t, c
        for j = 0, height - 1 do
            for i = 0, width - 1 do
                b = surf2.buffer[((j + sy) * surf2.width + i + sx) * 3 + 1]
                t = surf2.buffer[((j + sy) * surf2.width + i + sx) * 3 + 2]
                c = surf2.buffer[((j + sy) * surf2.width + i + sx) * 3 + 3]
                if b or self.overwrite then
                    self.buffer[((j + y) * self.width + i + x) * 3 + 1] = b
                end
                if t or self.overwrite then
                    self.buffer[((j + y) * self.width + i + x) * 3 + 2] = t
                end
                if c or self.overwrite then
                    self.buffer[((j + y) * self.width + i + x) * 3 + 3] = c
                end
            end
        end
    else
        local hmirror, vmirror = false, false
        if width < 0 then
            hmirror = true
            x = x + width
        end
        if height < 0 then
            vmirror = true
            y = y + height
        end
        if swidth < 0 then
            hmirror = not hmirror
            sx = sx + swidth
        end
        if sheight < 0 then
            vmirror = not vmirror
            sy = sy + sheight
        end
        width, height, swidth, sheight = math.abs(width), math.abs(height), math.abs(swidth), math.abs(sheight)

        local xscale, yscale, px, py, ssx, ssy, b, t, c = swidth / width, sheight / height
        for j = 0, height - 1 do
            for i = 0, width - 1 do
                px, py = math_floor((i + 0.5) * xscale), math_floor((j + 0.5) * yscale)
                if hmirror then
                    ssx = x + width - i - 1
                else
                    ssx = i + x
                end
                if vmirror then
                    ssy = y + height - j - 1
                else
                    ssy = j + y
                end

                if ssx >= self.cx and ssx < self.cx + self.cwidth and ssy >= self.cy and ssy < self.cy + self.cheight and px >= 0 and px < surf2.width and py >= 0 and py < surf2.height then
                    b = surf2.buffer[(py * surf2.width + px) * 3 + 1]
                    t = surf2.buffer[(py * surf2.width + px) * 3 + 2]
                    c = surf2.buffer[(py * surf2.width + px) * 3 + 3]
                    if b or self.overwrite then
                        self.buffer[(ssy * self.width + ssx) * 3 + 1] = b
                    end
                    if t or self.overwrite then
                        self.buffer[(ssy * self.width + ssx) * 3 + 2] = t
                    end
                    if c or self.overwrite then
                        self.buffer[(ssy * self.width + ssx) * 3 + 3] = c
                    end
                end
            end
        end
    end
end

function surf:drawSurfaceRotated(surf2, x, y, ox, oy, angle)
    local sin, cos, sx, sy, px, py = math.sin(angle), math.cos(angle)
    for j = math.floor(-surf2.height * 0.75), math.ceil(surf2.height * 0.75) do
        for i = math.floor(-surf2.width * 0.75), math.ceil(surf2.width * 0.75) do
            sx, sy, px, py = x + i, y + j, math_floor(cos * (i + 0.5) - sin * (j + 0.5) + ox), math_floor(sin * (i + 0.5) + cos * (j + 0.5) + oy)
            if sx >= self.cx and sx < self.cx + self.cwidth and sy >= self.cy and sy < self.cy + self.cheight and px >= 0 and px < surf2.width and py >= 0 and py < surf2.height then
                b = surf2.buffer[(py * surf2.width + px) * 3 + 1]
                t = surf2.buffer[(py * surf2.width + px) * 3 + 2]
                c = surf2.buffer[(py * surf2.width + px) * 3 + 3]
                if b or self.overwrite then
                    self.buffer[(sy * self.width + sx) * 3 + 1] = b
                end
                if t or self.overwrite then
                    self.buffer[(sy * self.width + sx) * 3 + 2] = t
                end
                if c or self.overwrite then
                    self.buffer[(sy * self.width + sx) * 3 + 3] = c
                end
            end
        end
    end
end

function surf:drawSurfacesInterlaced(surfs, x, y, step)
    x, y, step = x + self.ox, y + self.oy, step or 0
    local width, height = surfs[1].width, surfs[1].height
    for i = 2, #surfs do
        if surfs[i].width ~= width or surfs[i].height ~= height then
            error("surfaces should be the same size")
        end
    end

    local sx, sy, swidth, sheight, index, b, t, c = clipRect(x, y, width, height, self.cx, self.cy, self.cwidth, self.cheight)
    for j = sy, sy + sheight - 1 do
        for i = sx, sx + swidth - 1 do
            index = (i + j + step) % #surfs + 1
            b = surfs[index].buffer[((j - sy) * surfs[index].width + i - sx) * 3 + 1]
            t = surfs[index].buffer[((j - sy) * surfs[index].width + i - sx) * 3 + 2]
            c = surfs[index].buffer[((j - sy) * surfs[index].width + i - sx) * 3 + 3]
            if b or self.overwrite then
                self.buffer[(j * self.width + i) * 3 + 1] = b
            end
            if t or self.overwrite then
                self.buffer[(j * self.width + i) * 3 + 2] = t
            end
            if c or self.overwrite then
                self.buffer[(j * self.width + i) * 3 + 3] = c
            end
        end
    end
end

function surf:drawSurfaceSmall(surf2, x, y)
    x, y = x + self.ox, y + self.oy
    if surf2.width % 2 ~= 0 or surf2.height % 3 ~= 0 then
        error("surface width must be a multiple of 2 and surface height a multiple of 3")
    end

    local sub, char, c1, c2, c3, c4, c5, c6 = 32768
    for j = 0, surf2.height / 3 - 1 do
        for i = 0, surf2.width / 2 - 1 do
            if i + x >= self.cx and i + x < self.cx + self.cwidth and j + y >= self.cy and j + y < self.cy + self.cheight then
                char, c1, c2, c3, c4, c5, c6 = 0,
                surf2.buffer[((j * 3) * surf2.width + i * 2) * 3 + 1],
                surf2.buffer[((j * 3) * surf2.width + i * 2 + 1) * 3 + 1],
                surf2.buffer[((j * 3 + 1) * surf2.width + i * 2) * 3 + 1],
                surf2.buffer[((j * 3 + 1) * surf2.width + i * 2 + 1) * 3 + 1],
                surf2.buffer[((j * 3 + 2) * surf2.width + i * 2) * 3 + 1],
                surf2.buffer[((j * 3 + 2) * surf2.width + i * 2 + 1) * 3 + 1]
                if c1 ~= c6 then
                    sub = c1
                    char = 1
                end
                if c2 ~= c6 then
                    sub = c2
                    char = char + 2
                end
                if c3 ~= c6 then
                    sub = c3
                    char = char + 4
                end
                if c4 ~= c6 then
                    sub = c4
                    char = char + 8
                end
                if c5 ~= c6 then
                    sub = c5
                    char = char + 16
                end
                self.buffer[((j + y) * self.width + i + x) * 3 + 1] = c6
                self.buffer[((j + y) * self.width + i + x) * 3 + 2] = sub
                self.buffer[((j + y) * self.width + i + x) * 3 + 3] = _chars[128 + char]
            end
        end
    end
end
function surf:flip(horizontal, vertical)
    local ox, oy, nx, ny, tb, tt, tc
    if horizontal then
        for i = 0, math.ceil(self.cwidth / 2) - 1 do
            for j = 0, self.cheight - 1 do
                ox, oy, nx, ny = i + self.cx, j + self.cy, self.cx + self.cwidth - i - 1, j + self.cy
                tb = self.buffer[(oy * self.width + ox) * 3 + 1]
                tt = self.buffer[(oy * self.width + ox) * 3 + 2]
                tc = self.buffer[(oy * self.width + ox) * 3 + 3]
                self.buffer[(oy * self.width + ox) * 3 + 1] = self.buffer[(ny * self.width + nx) * 3 + 1]
                self.buffer[(oy * self.width + ox) * 3 + 2] = self.buffer[(ny * self.width + nx) * 3 + 2]
                self.buffer[(oy * self.width + ox) * 3 + 3] = self.buffer[(ny * self.width + nx) * 3 + 3]
                self.buffer[(ny * self.width + nx) * 3 + 1] = tb
                self.buffer[(ny * self.width + nx) * 3 + 2] = tt
                self.buffer[(ny * self.width + nx) * 3 + 3] = tc
            end
        end
    end
    if vertical then
        for j = 0, math.ceil(self.cheight / 2) - 1 do
            for i = 0, self.cwidth - 1 do
                ox, oy, nx, ny = i + self.cx, j + self.cy, i + self.cx, self.cy + self.cheight - j - 1
                tb = self.buffer[(oy * self.width + ox) * 3 + 1]
                tt = self.buffer[(oy * self.width + ox) * 3 + 2]
                tc = self.buffer[(oy * self.width + ox) * 3 + 3]
                self.buffer[(oy * self.width + ox) * 3 + 1] = self.buffer[(ny * self.width + nx) * 3 + 1]
                self.buffer[(oy * self.width + ox) * 3 + 2] = self.buffer[(ny * self.width + nx) * 3 + 2]
                self.buffer[(oy * self.width + ox) * 3 + 3] = self.buffer[(ny * self.width + nx) * 3 + 3]
                self.buffer[(ny * self.width + nx) * 3 + 1] = tb
                self.buffer[(ny * self.width + nx) * 3 + 2] = tt
                self.buffer[(ny * self.width + nx) * 3 + 3] = tc
            end
        end
    end
end

function surf:shift(x, y, b, t, c)
    local hdir, vdir = x < 0, y < 0
    local xstart, xend = self.cx, self.cx + self.cwidth - 1
    local ystart, yend = self.cy, self.cy + self.cheight - 1
    local nx, ny
    for j = vdir and ystart or yend, vdir and yend or ystart, vdir and 1 or -1 do
        for i = hdir and xstart or xend, hdir and xend or xstart, hdir and 1 or -1 do
            nx, ny = i - x, j - y
            if nx >= 0 and nx < self.width and ny >= 0 and ny < self.height then
                self.buffer[(j * self.width + i) * 3 + 1] = self.buffer[(ny * self.width + nx) * 3 + 1]
                self.buffer[(j * self.width + i) * 3 + 2] = self.buffer[(ny * self.width + nx) * 3 + 2]
                self.buffer[(j * self.width + i) * 3 + 3] = self.buffer[(ny * self.width + nx) * 3 + 3]
            else
                self.buffer[(j * self.width + i) * 3 + 1] = b
                self.buffer[(j * self.width + i) * 3 + 2] = t
                self.buffer[(j * self.width + i) * 3 + 3] = c
            end
        end
    end
end

function surf:map(colors)
    local c
    for j = self.cy, self.cy + self.cheight - 1 do
        for i = self.cx, self.cx + self.cwidth - 1 do
            c = colors[self.buffer[(j * self.width + i) * 3 + 1]]
            if c or self.overwrite then
                self.buffer[(j * self.width + i) * 3 + 1] = c
            end
        end
    end
end
surface.palette = { }
surface.palette.cc = {[1]="F0F0F0",[2]="F2B233",[4]="E57FD8",[8]="99B2F2",[16]="DEDE6C",[32]="7FCC19",[64]="F2B2CC",[128]="4C4C4C",[256]="999999",[512]="4C99B2",[1024]="B266E5",[2048]="3366CC",[4096]="7F664C",[8192]="57A64E",[16384]="CC4C4C",[32768]="191919"}
surface.palette.riko4 = {"181818","1D2B52","7E2553","008651","AB5136","5F564F","7D7F82","FF004C","FFA300","FFF023","00E755","29ADFF","82769C","FF77A9","FECCA9","ECECEC"}
surface.palette.redirection = {[0]="040404",[1]="FFFFFF"}

local function setPalette(palette)
    if palette == _palette then return end
    _palette = palette
    _rgbpal, _palr, _palg, _palb = { }, { }, { }, { }

    local indices = { }
    for k, v in pairs(_palette) do
        if type(v) == "string" then
            _palr[k] = tonumber(v:sub(1, 2), 16) / 255
            _palg[k] = tonumber(v:sub(3, 4), 16) / 255
            _palb[k] = tonumber(v:sub(5, 6), 16) / 255
        elseif type(v) == "number" then
            _palr[k] = math.floor(v / 65536) / 255
            _palg[k] = (math.floor(v / 256) % 256) / 255
            _palb[k] = (v % 256) / 255
        end
        indices[#indices + 1] = k
    end

    local pr, pg, pb, dist, d, id
    for i = 0, _steps - 1 do
        for j = 0, _steps - 1 do
            for k = 0, _steps - 1 do
                pr = (i + 0.5) / _steps
                pg = (j + 0.5) / _steps
                pb = (k + 0.5) / _steps

                dist = 1e10
                for l = 1, #indices do
                    d = (pr - _palr[indices[l]]) ^ 2 + (pg - _palg[indices[l]]) ^ 2 + (pb - _palb[indices[l]]) ^ 2
                    if d < dist then
                        dist = d
                        id = l
                    end
                end
                _rgbpal[i * _steps * _steps + j * _steps + k + 1] = indices[id]
            end
        end
    end
end



function surf:toRGB(palette)
    setPalette(palette)
    local c
    for j = 0, self.height - 1 do
        for i = 0, self.width - 1 do
            c = self.buffer[(j * self.width + i) * 3 + 1]
            self.buffer[(j * self.width + i) * 3 + 1] = _palr[c]
            self.buffer[(j * self.width + i) * 3 + 2] = _palg[c]
            self.buffer[(j * self.width + i) * 3 + 3] = _palb[c]
        end
    end
end

function surf:toPalette(palette, dither)
    setPalette(palette)
    local scale, r, g, b, nr, ng, nb, c, dr, dg, db = _steps - 1
    for j = 0, self.height - 1 do
        for i = 0, self.width - 1 do
            r = self.buffer[(j * self.width + i) * 3 + 1]
            g = self.buffer[(j * self.width + i) * 3 + 2]
            b = self.buffer[(j * self.width + i) * 3 + 3]
            r = (r > 1) and 1 or r
            r = (r < 0) and 0 or r
            g = (g > 1) and 1 or g
            g = (g < 0) and 0 or g
            b = (b > 1) and 1 or b
            b = (b < 0) and 0 or b

            nr = (r == 1) and scale or math_floor(r * _steps)
            ng = (g == 1) and scale or math_floor(g * _steps)
            nb = (b == 1) and scale or math_floor(b * _steps)
            c = _rgbpal[nr * _steps * _steps + ng * _steps + nb + 1]
            if dither then
                dr = (r - _palr[c]) / 16
                dg = (g - _palg[c]) / 16
                db = (b - _palb[c]) / 16

                if i < self.width - 1 then
                    self.buffer[(j * self.width + i + 1) * 3 + 1] = self.buffer[(j * self.width + i + 1) * 3 + 1] + dr * 7
                    self.buffer[(j * self.width + i + 1) * 3 + 2] = self.buffer[(j * self.width + i + 1) * 3 + 2] + dg * 7
                    self.buffer[(j * self.width + i + 1) * 3 + 3] = self.buffer[(j * self.width + i + 1) * 3 + 3] + db * 7
                end
                if j < self.height - 1 then
                    if i > 0 then
                        self.buffer[((j + 1) * self.width + i - 1) * 3 + 1] = self.buffer[((j + 1) * self.width + i - 1) * 3 + 1] + dr * 3
                        self.buffer[((j + 1) * self.width + i - 1) * 3 + 2] = self.buffer[((j + 1) * self.width + i - 1) * 3 + 2] + dg * 3
                        self.buffer[((j + 1) * self.width + i - 1) * 3 + 3] = self.buffer[((j + 1) * self.width + i - 1) * 3 + 3] + db * 3
                    end
                    self.buffer[((j + 1) * self.width + i) * 3 + 1] = self.buffer[((j + 1) * self.width + i) * 3 + 1] + dr * 5
                    self.buffer[((j + 1) * self.width + i) * 3 + 2] = self.buffer[((j + 1) * self.width + i) * 3 + 2] + dg * 5
                    self.buffer[((j + 1) * self.width + i) * 3 + 3] = self.buffer[((j + 1) * self.width + i) * 3 + 3] + db * 5
                    if i < self.width - 1 then
                        self.buffer[((j + 1) * self.width + i + 1) * 3 + 1] = self.buffer[((j + 1) * self.width + i + 1) * 3 + 1] + dr * 1
                        self.buffer[((j + 1) * self.width + i + 1) * 3 + 2] = self.buffer[((j + 1) * self.width + i + 1) * 3 + 2] + dg * 1
                        self.buffer[((j + 1) * self.width + i + 1) * 3 + 3] = self.buffer[((j + 1) * self.width + i + 1) * 3 + 3] + db * 1
                    end
                end
            end
            self.buffer[(j * self.width + i) * 3 + 1] = c
            self.buffer[(j * self.width + i) * 3 + 2] = nil
            self.buffer[(j * self.width + i) * 3 + 3] = nil
        end
    end
end
function surface.loadFont(surf)
    local font = {width = surf.width, height = surf.height - 1}
    font.buffer =  { }
    font.indices = {0}
    font.widths = { }

    local startc, hitc, curc = surf.buffer[((surf.height - 1) * surf.width) * 3 + 1]
    for i = 0, surf.width - 1 do
        curc = surf.buffer[((surf.height - 1) * surf.width + i) * 3 + 1]
        if curc ~= startc then
            hitc = curc
            break
        end
    end

    for j = 0, surf.height - 2 do
        for i = 0, surf.width - 1 do
            font.buffer[j * font.width + i + 1] = surf.buffer[(j * surf.width + i) * 3 + 1] == hitc
        end
    end

    local curchar = 1
    for i = 0, surf.width - 1 do
        if surf.buffer[((surf.height - 1) * surf.width + i) * 3 + 1] == hitc then
            font.widths[curchar] = i - font.indices[curchar]
            curchar = curchar + 1
            font.indices[curchar] = i + 1
        end
    end
    font.widths[curchar] = font.width - font.indices[curchar]

    return font
end

function surface.getTextSize(str, font)
    local cx, cy, maxx = 0, 0, 0
    local ox, char = cx

    for i = 1, #str do
        char = str:byte(i) - 31

        if char + 31 == 10 then -- newline
            cx = ox
            cy = cy + font.height + 1
        elseif font.indices[char] then
            cx = cx + font.widths[char] + 1
        else
            cx = cx + font.widths[1]
        end
        if cx > maxx then
            maxx = cx
        end
    end

    return maxx - 1, cy + font.height
end

function surf:drawText(str, font, x, y, b, t, c)
    local cx, cy = x + self.ox, y + self.oy
    local ox, char, idx = cx

    for i = 1, #str do
        char = str:byte(i) - 31

        if char + 31 == 10 then -- newline
            cx = ox
            cy = cy + font.height + 1
        elseif font.indices[char] then
            for i = 0, font.widths[char] - 1 do
                for j = 0, font.height - 1 do
                    x, y = cx + i, cy + j
                    if font.buffer[j * font.width + i + font.indices[char] + 1] then
                        if x >= self.cx and x < self.cx + self.cwidth and y >= self.cy and y < self.cy + self.cheight then
                            idx = (y * self.width + x) * 3
                            if b or self.overwrite then
                                self.buffer[idx + 1] = b
                            end
                            if t or self.overwrite then
                                self.buffer[idx + 2] = t
                            end
                            if c or self.overwrite then
                                self.buffer[idx + 3] = c
                            end
                        end
                    end
                end
            end
            cx = cx + font.widths[char] + 1
        else
            cx = cx + font.widths[1]
        end
    end
end
local smap = { }
surface.smap = smap

function surface.loadSpriteMap(surf, spwidth, spheight, sprites)
    if surf.width % spwidth ~= 0 or surf.height % spheight ~= 0 then
        error("sprite width/height does not match smap width/height")
    end

    local smap = setmetatable({ }, {__index = surface.smap})
    smap.surf = surf
    smap.spwidth = spwidth
    smap.spheight = spheight
    smap.sprites = sprites or ((surf.width / spwidth) * (surf.height / spheight))
    smap.perline = surf.width / spwidth

    return smap
end

function smap:pos(index, scale)
    if index < 0 or index >= self.sprites then
        error("sprite index out of bounds")
    end

    return (index % self.perline) * self.spwidth, math.floor(index / self.perline) * self.spheight
end

function smap:sprite(index, x, y, width, height)
    local sx, sy = self:pos(index)
    return self.surf, x, y, width or self.spwidth, height or self.spheight, sx, sy, self.spwidth, self.spheight
end
end return surface