SHARE
TWEET

Surface API 1.4.0

CrazedProgrammer Apr 27th, 2015 (edited) 254 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. -- Surface API version 1.5.0 by CrazedProgrammer
  2. -- You can find info and documentation on these pages:
  3. -- http://www.computercraft.info/forums2/index.php?/topic/22397-surface-api/
  4. -- You may use this in your ComputerCraft programs and modify it without asking.
  5. -- However, you may not publish this API under your name without asking me.
  6. -- If you have any suggestions, bug reports or questions then please send an email to:
  7. -- crazedprogrammer@gmail.com
  8. version = "1.5.0"
  9.  
  10. local _log = math.log(2)
  11.  
  12. local _bufferLine = function(buffer, width, x1, y1, x2, y2)
  13.     local delta_x = x2 - x1
  14.     local ix = delta_x > 0 and 1 or -1
  15.     delta_x = 2 * math.abs(delta_x)
  16.     local delta_y = y2 - y1
  17.     local iy = delta_y > 0 and 1 or -1
  18.     delta_y = 2 * math.abs(delta_y)
  19.     buffer[(y1 - 1) * width + x1] = true
  20.     if delta_x >= delta_y then
  21.         local error = delta_y - delta_x / 2
  22.         while x1 ~= x2 do
  23.             if (error >= 0) and ((error ~= 0) or (ix > 0)) then
  24.                 error = error - delta_x
  25.                 y1 = y1 + iy
  26.             end
  27.             error = error + delta_y
  28.             x1 = x1 + ix
  29.             buffer[(y1 - 1) * width + x1] = true
  30.         end
  31.     else
  32.         local error = delta_x - delta_y / 2
  33.         while y1 ~= y2 do
  34.             if (error >= 0) and ((error ~= 0) or (iy > 0)) then
  35.                 error = error - delta_y
  36.                 x1 = x1 + ix
  37.             end
  38.             error = error + delta_x
  39.             y1 = y1 + iy
  40.             buffer[(y1 - 1) * width + x1] = true
  41.         end
  42.     end
  43. end
  44.  
  45. local _drawHLine = function(surf, x1, x2, y, char, backcolor, textcolor)
  46.     if x1 > x2 then
  47.         local temp = x1
  48.         x1, x2 = x2, temp
  49.     end
  50.     if y < surf.y1 or y > surf.y2 or x2 < surf.x1 or x1 > surf.x2 then return end
  51.     if x1 < surf.x1 then x1 = surf.x1 end
  52.     if x2 > surf.x2 then x2 = surf.x2 end
  53.     if char or surf.overwrite then
  54.         for x=x1,x2 do
  55.             surf.buffer[((y - 1) * surf.width + x) * 3 - 2] = char
  56.         end
  57.     end
  58.     if backcolor or surf.overwrite then
  59.         for x=x1,x2 do
  60.             surf.buffer[((y - 1) * surf.width + x) * 3 - 1] = backcolor
  61.         end
  62.     end
  63.     if textcolor or surf.overwrite then
  64.         for x=x1,x2 do
  65.             surf.buffer[((y - 1) * surf.width + x) * 3] = textcolor
  66.         end
  67.     end
  68. end
  69.  
  70. local _drawVLine = function(surf, y1, y2, x, char, backcolor, textcolor)
  71.     if y1 > y2 then
  72.         local temp = y1
  73.         y1, y2 = y2, temp
  74.     end
  75.     if x < surf.x1 or x > surf.x2 or y2 < surf.y1 or y1 > surf.y2 then return end
  76.     if y1 < surf.y1 then y1 = surf.y1 end
  77.     if y2 > surf.y2 then y2 = surf.y2 end
  78.     if char or surf.overwrite then
  79.         for y=y1,y2 do
  80.             surf.buffer[((y - 1) * surf.width + x) * 3 - 2] = char
  81.         end
  82.     end
  83.     if backcolor or surf.overwrite then
  84.         for y=y1,y2 do
  85.             surf.buffer[((y - 1) * surf.width + x) * 3 - 1] = backcolor
  86.         end
  87.     end
  88.     if textcolor or surf.overwrite then
  89.         for y=y1,y2 do
  90.             surf.buffer[((y - 1) * surf.width + x) * 3] = textcolor
  91.         end
  92.     end
  93. end
  94.  
  95. local _functions = {
  96. setBounds = function(surf, x1, y1, x2, y2)
  97.     if x1 > x2 then
  98.         local temp = x1
  99.         x1, x2 = x2, temp
  100.     end
  101.     if y1 > y2 then
  102.         local temp = y1
  103.         y1, y2 = y2, temp
  104.     end
  105.     if x2 < 1 or x1 > surf.width or y2 < 1 or y1 > surf.height then return end
  106.     if x1 < 1 then x1 = 1 end
  107.     if x2 > surf.width then x2 = surf.width end
  108.     if y1 < 1 then y1 = 1 end
  109.     if y2 > surf.height then y2 = surf.height end
  110.     surf.x1, surf.y1, surf.x2, surf.y2 = x1, y1, x2, y2
  111. end,
  112.  
  113. getBounds = function(surf)
  114.     return surf.x1, surf.y1, surf.x2, surf.y2
  115. end,
  116.  
  117. copy = function(surf)
  118.     local surf2 = surface.create(surf.width, surf.height)
  119.     surf2.x1, surf2.y1, surf2.x2, surf2.y2, surf2.blink, surf2.curX, surf2.curY, surf2.overwrite = surf.x1, surf.y1, surf.x2, surf.y2, surf.blink, surf.curX, surf.curY, surf.overwrite
  120.     for i=1,surf.width * surf.height * 3 do
  121.         surf2.buffer[i] = surf.buffer[i]
  122.     end
  123.     return surf2
  124. end,
  125.  
  126. save = function(surf, path, type)
  127.     type = type or "srf"
  128.     local f = fs.open(path, "w")
  129.     if type == "nfp" then
  130.         local color = nil
  131.         for j=1,surf.height do
  132.             if j > 1 then f.write("\n") end
  133.             for i=1,surf.width do
  134.                 color = surf.buffer[((j - 1) * surf.width + i) * 3 - 1]
  135.                 if color then
  136.                     f.write(string.format("%x", math.log(color)/_log))
  137.                 else
  138.                     f.write(" ")
  139.                 end
  140.             end
  141.         end
  142.     elseif type == "nft" then
  143.         local backcolor, textcolor, char = nil
  144.         for j=1,surf.height,1 do
  145.             if j > 1 then f.write("\n") end
  146.             backcolor = nil
  147.             textcolor = nil
  148.             for i=1,surf.width do
  149.                 if backcolor ~= surf.buffer[((j - 1) * surf.width + i) * 3 - 1] then
  150.                     f.write(string.char(30))
  151.                     backcolor = surf.buffer[((j - 1) * surf.width + i) * 3 - 1]
  152.                     if backcolor then
  153.                         f.write(string.format("%x", math.log(backcolor)/_log))
  154.                     else
  155.                         f.write(" ")
  156.                     end
  157.                 end
  158.                 if textcolor ~= surf.buffer[((j - 1) * surf.width + i) * 3] then
  159.                     f.write(string.char(31))
  160.                     textcolor = surf.buffer[((j - 1) * surf.width + i) * 3]
  161.                     if textcolor then
  162.                         f.write(string.format("%x", math.log(textcolor)/_log))
  163.                     else
  164.                         f.write(" ")
  165.                     end
  166.                 end
  167.                 char = surf.buffer[((j - 1) * surf.width + i) * 3 - 2]
  168.                 if char then
  169.                     f.write(char)
  170.                 else
  171.                     f.write(" ")
  172.                 end
  173.             end
  174.         end
  175.     elseif type == "srf" then
  176.         f.write(surf:saveString())
  177.     end
  178.     f.close()
  179. end,
  180.  
  181. saveString = function(surf)
  182.     local str = { "_"..string.format("%04x", surf.width)..string.format("%04x", surf.height) }
  183.     for j=1,surf.height do
  184.         for i=1,surf.width do
  185.             if surf.buffer[((j - 1) * surf.width + i) * 3 - 2] then
  186.                 str[#str + 1] = string.format("%02x", surf.buffer[((j - 1) * surf.width + i) * 3 - 2]:byte(1))
  187.             else
  188.                 str[#str + 1] = "__"
  189.             end
  190.             if surf.buffer[((j - 1) * surf.width + i) * 3 - 1] then
  191.                 str[#str + 1] = string.format("%x", math.log(surf.buffer[((j - 1) * surf.width + i) * 3 - 1])/_log)
  192.             else
  193.                 str[#str + 1] = "_"
  194.             end
  195.             if surf.buffer[((j - 1) * surf.width + i) * 3] then
  196.                 str[#str + 1] = string.format("%x", math.log(surf.buffer[((j - 1) * surf.width + i) * 3])/_log)
  197.             else
  198.                 str[#str + 1] = "_"
  199.             end
  200.         end
  201.     end
  202.     return table.concat(str)
  203. end,
  204.  
  205. getTerm = function(surf)
  206.     local term, textcolor, backcolor = { }
  207.     function term.write(str)
  208.         surf:drawText(surf.curX, surf.curY, str, backcolor, textcolor)
  209.         surf.curX = surf.curX + #str
  210.     end
  211.     function term.blit(str, text, back)
  212.         for i=1,#str do
  213.             if surf.curX >= surf.x1 and surf.curY >= surf.y1 and surf.curX <= surf.x2 and surf.curY <= surf.y2 then
  214.                 surf.buffer[((surf.curY - 1) * surf.width + surf.curX) * 3 - 2] = str:sub(i, i)
  215.                 surf.buffer[((surf.curY - 1) * surf.width + surf.curX) * 3 - 1] = 2 ^ tonumber(back:sub(i, i), 16)
  216.                 surf.buffer[((surf.curY - 1) * surf.width + surf.curX) * 3] = 2 ^ tonumber(text:sub(i, i), 16)
  217.             end
  218.             surf.curX = surf.curX + 1
  219.         end
  220.     end
  221.     function term.clear()
  222.         surf:clear(" ", backcolor, textcolor)
  223.     end
  224.     function term.clearLine(n)
  225.         _drawHLine(surf, surf.x1, surf.x2, n)
  226.     end
  227.     function term.getCursorPos()
  228.         return surf.curX, surf.curY
  229.     end
  230.     function term.setCursorPos(x, y)
  231.         surf.curX, surf.curY = math.floor(x), math.floor(y)
  232.     end
  233.     function term.setCursorBlink(blink)
  234.         surf.blink = blink
  235.     end
  236.     function term.isColor()
  237.         return true
  238.     end
  239.     term.isColour = term.isColor
  240.     function term.setTextColor(color)
  241.         textcolor = color
  242.     end
  243.     term.setTextColour = term.setTextColor
  244.     function term.setBackgroundColor(color)
  245.         backcolor = color
  246.     end
  247.     term.setBackgroundColour = term.setBackgroundColor
  248.     function term.getSize()
  249.         return surf.width, surf.height
  250.     end
  251.     function term.scroll(n)
  252.         surf:shift(0, n)
  253.     end
  254.     function term.getTextColor()
  255.         return textcolor
  256.     end
  257.     term.getTextColour = term.getTextColor
  258.     function term.getBackgroundColor()
  259.         return backcolor
  260.     end
  261.     term.getBackgroundColour = term.getBackgroundColor
  262.     return term
  263. end,
  264.  
  265. render = function(surf, display, x, y, sx1, sy1, sx2, sy2)
  266.     display, x, y, sx1, sy1, sx2, sy2 = display or term, x or 1, y or 1, sx1 or 1, sy1 or 1, sx2 or surf.width, sy2 or surf.height
  267.     if sx1 > sx2 then
  268.         local temp = sx1
  269.         sx1, sx2 = sx2, temp
  270.     end
  271.     if sy1 > sy2 then
  272.         local temp = sy1
  273.         sy1, sy2 = sy2, temp
  274.     end
  275.     if sx2 < 1 or sx1 > surf.width or sy2 < 1 or sy1 > surf.height then return end
  276.     if sx1 < 1 then sx1 = 1 end
  277.     if sx2 > surf.width then sx2 = surf.width end
  278.     if sy1 < 1 then sy1 = 1 end
  279.     if sy2 > surf.height then sy2 = surf.height end
  280.     if display.blit then
  281.         local cmd, str, back, text = { }, { }, { }, { }
  282.         for j=sy1,sy2 do
  283.             for i=sx1,sx2 do
  284.                 str[i - sx1 + 1] = surf.buffer[((j - 1) * surf.width + i) * 3 - 2] or " "
  285.                 back[i - sx1 + 1] = math.log(surf.buffer[((j - 1) * surf.width + i) * 3 - 1] or 32768)/_log
  286.                 text[i - sx1 + 1] = math.log(surf.buffer[((j - 1) * surf.width + i) * 3] or 1)/_log
  287.             end
  288.             cmd[#cmd + 1] = y + j - sy1
  289.             cmd[#cmd + 1] = table.concat(str)
  290.             cmd[#cmd + 1] = string.format(string.rep("%x", #text), unpack(text))
  291.             cmd[#cmd + 1] = string.format(string.rep("%x", #back), unpack(back))
  292.         end
  293.         for i=1,#cmd,4 do
  294.             display.setCursorPos(x, cmd[i])
  295.             display.blit(cmd[i + 1], cmd[i + 2], cmd[i + 3])
  296.         end
  297.     else
  298.         local cmd, str, backcolor, textcolor = { }, "", nil, nil
  299.         for j=sy1,sy2 do
  300.             cmd[#cmd + 1] = 1
  301.             cmd[#cmd + 1] = y + j - sy1
  302.             for i=sx1,sx2 do
  303.                 if surf.buffer[((j - 1) * surf.width + i) * 3 - 1] ~= backcolor then
  304.                     backcolor = surf.buffer[((j - 1) * surf.width + i) * 3 - 1]
  305.                     if str ~= "" then
  306.                         cmd[#cmd + 1] = 4
  307.                         cmd[#cmd + 1] = str
  308.                         str = ""
  309.                     end
  310.                     cmd[#cmd + 1] = 2
  311.                     cmd[#cmd + 1] = backcolor
  312.                 end
  313.                 if surf.buffer[((j - 1) * surf.width + i) * 3] ~= textcolor then
  314.                     textcolor = surf.buffer[((j - 1) * surf.width + i) * 3]
  315.                     if str ~= "" then
  316.                         cmd[#cmd + 1] = 4
  317.                         cmd[#cmd + 1] = str
  318.                         str = ""
  319.                     end
  320.                     cmd[#cmd + 1] = 3
  321.                     cmd[#cmd + 1] = textcolor
  322.                 end
  323.                 str = str..(surf.buffer[((j - 1) * surf.width + i) * 3 - 2] or " ")
  324.             end
  325.             cmd[#cmd + 1] = 4
  326.             cmd[#cmd + 1] = str
  327.             str = ""
  328.         end
  329.         local c, a = nil, nil
  330.         for i=1,#cmd,2 do
  331.             c, a = cmd[i], cmd[i + 1]
  332.             if c == 1 then
  333.                 display.setCursorPos(x, a)
  334.             elseif c == 2 then
  335.                 display.setBackgroundColor(a or 32768)
  336.             elseif c == 3 then
  337.                 display.setTextColor(a or 1)
  338.             else
  339.                 display.write(a)
  340.             end
  341.         end
  342.     end
  343.     if surf.blink then
  344.         display.setCursorPos(x + surf.curX - sx1, y + surf.curY - sy1)
  345.         display.setCursorBlink(true)
  346.     elseif surf.blink == false then
  347.         display.setCursorBlink(false)
  348.         surf.blink = nil
  349.     end
  350. end,
  351.  
  352. clear = function(surf, char, backcolor, textcolor)
  353.     local overwrite = surf.overwrite
  354.     surf.overwrite = true
  355.     surf:fillRect(surf.x1, surf.y1, surf.x2, surf.y2, char, backcolor, textcolor)
  356.     surf.overwrite = overwrite
  357. end,
  358.  
  359. drawPixel = function(surf, x, y, char, backcolor, textcolor)
  360.     if x < surf.x1 or y < surf.y1 or x > surf.x2 or y > surf.y2 then return end
  361.     if char or surf.overwrite then
  362.         surf.buffer[((y - 1) * surf.width + x) * 3 - 2] = char
  363.     end
  364.     if backcolor or surf.overwrite then
  365.         surf.buffer[((y - 1) * surf.width + x) * 3 - 1] = backcolor
  366.     end
  367.     if textcolor or surf.overwrite then
  368.         surf.buffer[((y - 1) * surf.width + x) * 3] = textcolor
  369.     end
  370. end,
  371.  
  372. getPixel = function(surf, x, y)
  373.     if x < 1 or y < 1 or x > surf.width or y > surf.height then return end
  374.     return surf.buffer[((y - 1) * surf.width + x) * 3 - 2], surf.buffer[((y - 1) * surf.width + x) * 3 - 1], surf.buffer[((y - 1) * surf.width + x) * 3]
  375. end,
  376.  
  377. drawText = function(surf, x, y, text, backcolor, textcolor)
  378.     local px = x
  379.     for i=1,#text,1 do
  380.         if text:sub(i, i) ~= "\n" then
  381.             if x >= surf.x1 and y >= surf.y1 and x <= surf.x2 and y <= surf.y2 then
  382.                 surf.buffer[((y - 1) * surf.width + x) * 3 - 2] = text:sub(i, i)
  383.                 if backcolor or surf.overwrite then
  384.                     surf.buffer[((y - 1) * surf.width + x) * 3 - 1] = backcolor
  385.                 end
  386.                 if textcolor or surf.overwrite then
  387.                     surf.buffer[((y - 1) * surf.width + x) * 3] = textcolor
  388.                 end
  389.             end
  390.         else
  391.             x = px - 1
  392.             y = y + 1
  393.         end
  394.         x = x + 1
  395.     end
  396. end,
  397.  
  398. drawLine = function(surf, x1, y1, x2, y2, char, backcolor, textcolor)
  399.     local delta_x = x2 - x1
  400.     local ix = delta_x > 0 and 1 or -1
  401.     delta_x = 2 * math.abs(delta_x)
  402.     local delta_y = y2 - y1
  403.     local iy = delta_y > 0 and 1 or -1
  404.     delta_y = 2 * math.abs(delta_y)
  405.     surf:drawPixel(x1, y1, char, backcolor, textcolor)
  406.     if delta_x >= delta_y then
  407.         local error = delta_y - delta_x / 2
  408.         while x1 ~= x2 do
  409.             if (error >= 0) and ((error ~= 0) or (ix > 0)) then
  410.                 error = error - delta_x
  411.                 y1 = y1 + iy
  412.             end
  413.             error = error + delta_y
  414.             x1 = x1 + ix
  415.             surf:drawPixel(x1, y1, char, backcolor, textcolor)
  416.         end
  417.     else
  418.         local error = delta_x - delta_y / 2
  419.         while y1 ~= y2 do
  420.             if (error >= 0) and ((error ~= 0) or (iy > 0)) then
  421.                 error = error - delta_y
  422.                 x1 = x1 + ix
  423.             end
  424.             error = error + delta_x
  425.             y1 = y1 + iy
  426.             surf:drawPixel(x1, y1, char, backcolor, textcolor)
  427.         end
  428.     end
  429. end,
  430.  
  431. drawLines = function(surf, points, mode, char, backcolor, textcolor)
  432.     mode = mode or 1
  433.     if mode == 1 then
  434.         for i=1,#points,4 do
  435.             surf:drawLine(points[i], points[i+1], points[i+2], points[i+3], char, backcolor, textcolor)
  436.         end
  437.     elseif mode == 2 then
  438.         local lastx, lasty = points[1], points[2]
  439.         for i=3,#points,2 do
  440.             local curx, cury = points[i], points[i+1]
  441.             surf:drawLine(lastx, lasty, curx, cury, char, backcolor, textcolor)
  442.             lastx = curx
  443.             lasty = cury
  444.         end
  445.     elseif mode == 3 then
  446.         local midx, midy = points[1], points[2]
  447.         for i=3,#points,2 do
  448.             surf:drawLine(midx, midy, points[i], points[i+1], char, backcolor, textcolor)
  449.         end
  450.     end
  451. end,
  452.  
  453. drawRect = function(surf, x1, y1, x2, y2, char, backcolor, textcolor)
  454.     _drawHLine(surf, x1, x2, y1, char, backcolor, textcolor)
  455.     _drawHLine(surf, x1, x2, y2, char, backcolor, textcolor)
  456.     _drawVLine(surf, y1, y2, x1, char, backcolor, textcolor)
  457.     _drawVLine(surf, y1, y2, x2, char, backcolor, textcolor)
  458. end,
  459.  
  460. drawRoundRect = function(surf, x1, y1, x2, y2, char, backcolor, textcolor)
  461.     _drawHLine(surf, x1 + 1, x2 - 1, y1, char, backcolor, textcolor)
  462.     _drawHLine(surf, x1 + 1, x2 - 1, y2, char, backcolor, textcolor)
  463.     _drawVLine(surf, y1 + 1, y2 - 1, x1, char, backcolor, textcolor)
  464.     _drawVLine(surf, y1 + 1, y2 - 1, x2, char, backcolor, textcolor)
  465. end,
  466.  
  467. drawRoundedRect = function(surf, x1, y1, x2, y2, radius, char, backcolor, textcolor)
  468.     _drawHLine(surf, x1 + radius, x2 - radius, y1, char, backcolor, textcolor)
  469.     _drawHLine(surf, x1 + radius, x2 - radius, y2, char, backcolor, textcolor)
  470.     _drawVLine(surf, y1 + radius, y2 - radius, x1, char, backcolor, textcolor)
  471.     _drawVLine(surf, y1 + radius, y2 - radius, x2, char, backcolor, textcolor)
  472.     surf:drawArc(x1, y1, x1 + radius * 2 + 2, y1 + radius * 2 + 2, -math.pi, -math.pi / 2, char, backcolor, textcolor)
  473.     surf:drawArc(x2, y1, x2 - radius * 2 - 2, y1 + radius * 2 + 2, 0, -math.pi / 2, char, backcolor, textcolor)
  474.     surf:drawArc(x1, y2, x1 + radius * 2 + 2, y2 - radius * 2 - 2, math.pi, math.pi / 2, char, backcolor, textcolor)
  475.     surf:drawArc(x2, y2, x2 - radius * 2 - 2, y2 - radius * 2 - 2, 0, math.pi / 2, char, backcolor, textcolor)
  476. end,
  477.  
  478. fillRect = function(surf, x1, y1, x2, y2, char, backcolor, textcolor)
  479.     if x1 > x2 then
  480.         local temp = x1
  481.         x1, x2 = x2, temp
  482.     end
  483.     if y1 > y2 then
  484.         local temp = y1
  485.         y1, y2 = y2, temp
  486.     end
  487.     if x2 < surf.x1 or x1 > surf.x2 or y2 < surf.y1 or y1 > surf.y2 then return end
  488.     if x1 < surf.x1 then x1 = surf.x1 end
  489.     if x2 > surf.x2 then x2 = surf.x2 end
  490.     if y1 < surf.y1 then y1 = surf.y1 end
  491.     if y2 > surf.y2 then y2 = surf.y2 end
  492.     if char or surf.overwrite then
  493.         for y=y1,y2 do
  494.             for x=x1,x2 do
  495.                 surf.buffer[((y - 1) * surf.width + x) * 3 - 2] = char
  496.             end
  497.         end
  498.     end
  499.     if backcolor or surf.overwrite then
  500.         for y=y1,y2 do
  501.             for x=x1,x2 do
  502.                 surf.buffer[((y - 1) * surf.width + x) * 3 - 1] = backcolor
  503.             end
  504.         end
  505.     end
  506.     if textcolor or surf.overwrite then
  507.         for y=y1,y2 do
  508.             for x=x1,x2 do
  509.                 surf.buffer[((y - 1) * surf.width + x) * 3] = textcolor
  510.             end
  511.         end
  512.     end
  513. end,
  514.  
  515. fillRoundRect = function(surf, x1, y1, x2, y2, char, backcolor, textcolor)
  516.     _drawHLine(surf, x1 + 1, x2 - 1, y1, char, backcolor, textcolor)
  517.     _drawHLine(surf, x1 + 1, x2 - 1, y2, char, backcolor, textcolor)
  518.     _drawVLine(surf, y1 + 1, y2 - 1, x1, char, backcolor, textcolor)
  519.     _drawVLine(surf, y1 + 1, y2 - 1, x2, char, backcolor, textcolor)
  520.     surf:fillRect(x1 + 1, y1 + 1, x2 - 1, y2 - 1, char, backcolor, textcolor)
  521. end,
  522.  
  523. fillRoundedRect = function(surf, x1, y1, x2, y2, radius, char, backcolor, textcolor)
  524.     surf:fillRect(x1 + radius, y1, x2 - radius, y2, char, backcolor, textcolor)
  525.     surf:fillRect(x1, y1 + radius, x1 + radius, y2 - radius, char, backcolor, textcolor)
  526.     surf:fillRect(x2 - radius, y1 + radius, x2, y2 - radius, char, backcolor, textcolor)
  527.     surf:fillPie(x1, y1, x1 + radius * 2 + 2, y1 + radius * 2 + 2, -math.pi, -math.pi / 2, char, backcolor, textcolor)
  528.     surf:fillPie(x2, y1, x2 - radius * 2 - 2, y1 + radius * 2 + 2, 0, -math.pi / 2, char, backcolor, textcolor)
  529.     surf:fillPie(x1, y2, x1 + radius * 2 + 2, y2 - radius * 2 - 2, math.pi, math.pi / 2, char, backcolor, textcolor)
  530.     surf:fillPie(x2, y2, x2 - radius * 2 - 2, y2 - radius * 2 - 2, 0, math.pi / 2, char, backcolor, textcolor)
  531. end,
  532.  
  533. drawTriangle = function(surf, x1, y1, x2, y2, x3, y3, char, backcolor, textcolor)
  534.     surf:drawLine(x1, y1, x2, y2, char, backcolor, textcolor)
  535.     surf:drawLine(x2, y2, x3, y3, char, backcolor, textcolor)
  536.     surf:drawLine(x3, y3, x1, y1, char, backcolor, textcolor)
  537. end,
  538.  
  539. fillTriangle = function(surf, x1, y1, x2, y2, x3, y3, char, backcolor, textcolor)
  540.     local minX, minY, maxX, maxY = x1, y1, x1, y1
  541.     if x2 < minX then minX = x2 end
  542.     if x3 < minX then minX = x3 end
  543.     if y2 < minY then minY = y2 end
  544.     if y3 < minY then minY = y3 end
  545.     if x2 > maxX then maxX = x2 end
  546.     if x3 > maxX then maxX = x3 end
  547.     if y2 > maxY then maxY = y2 end
  548.     if y3 > maxY then maxY = y3 end
  549.     local width, height, buffer, min, max = maxX - minX + 1, maxY - minY + 1, { }, 0, 0
  550.     _bufferLine(buffer, width, x1 - minX + 1, y1 - minY + 1, x2 - minX + 1, y2 - minY + 1)
  551.     _bufferLine(buffer, width, x2 - minX + 1, y2 - minY + 1, x3 - minX + 1, y3 - minY + 1)
  552.     _bufferLine(buffer, width, x3 - minX + 1, y3 - minY + 1, x1 - minX + 1, y1 - minY + 1)
  553.     for j=1,height do
  554.         min, max = nil, 0
  555.         for i=1,width,1 do
  556.             if buffer[(j - 1) * width + i] then
  557.                 if not min then min = i end
  558.                 if i > max then max = i end
  559.             end
  560.         end
  561.         _drawHLine(surf, min + minX - 1, max + minX - 1, j + minY - 1, char, backcolor, textcolor)
  562.     end
  563. end,
  564.  
  565. drawTriangles = function(surf, points, mode, char, backcolor, textcolor)
  566.     mode = mode or 1
  567.     if mode == 1 then
  568.         for i=1,#points,6 do
  569.             surf:drawTriangle(points[i], points[i+1], points[i+2], points[i+3], points[i+4], points[i+5], char, backcolor, textcolor)
  570.         end
  571.     elseif mode == 2 then
  572.         local lastx, lasty, prevx, prevy, curx, cury = points[1], points[2], points[3], points[4]
  573.         for i=5,#points,2 do
  574.             curx, cury = points[i], points[i+1]
  575.             surf:drawTriangle(lastx, lasty, prevx, prevy, curx, cury, char, backcolor, textcolor)
  576.             lastx, lasty, prevx, prevy = prevx, prevy, curx, cury
  577.         end
  578.     elseif mode == 3 then
  579.         local midx, midy, lastx, lasty, curx, cury = points[1], points[2], points[3], points[4]
  580.         for i=5,#points,2 do
  581.             curx, cury = points[i], points[i+1]
  582.             surf:drawTriangle(midx, midy, lastx, lasty, curx, cury, char, backcolor, textcolor)
  583.             lastx, lasty = curx, cury
  584.         end
  585.     end
  586. end,
  587.  
  588. fillTriangles = function(surf, points, mode, char, backcolor, textcolor)
  589.     mode = mode or 1
  590.     if mode == 1 then
  591.         for i=1,#points,6 do
  592.             surf:fillTriangle(points[i], points[i+1], points[i+2], points[i+3], points[i+4], points[i+5], char, backcolor, textcolor)
  593.         end
  594.     elseif mode == 2 then
  595.         local lastx, lasty, prevx, prevy, curx, cury = points[1], points[2], points[3], points[4]
  596.         for i=5,#points,2 do
  597.             curx, cury = points[i], points[i+1]
  598.             surf:fillTriangle(lastx, lasty, prevx, prevy, curx, cury, char, backcolor, textcolor)
  599.             lastx, lasty, prevx, prevy = prevx, prevy, curx, cury
  600.         end
  601.     elseif mode == 3 then
  602.         local midx, midy, lastx, lasty, curx, cury = points[1], points[2], points[3], points[4]
  603.         for i=5,#points,2 do
  604.             curx, cury = points[i], points[i+1]
  605.             surf:fillTriangle(midx, midy, lastx, lasty, curx, cury, char, backcolor, textcolor)
  606.             lastx, lasty = curx, cury
  607.         end
  608.     end
  609. end,
  610.  
  611. drawEllipse = function(surf, x1, y1, x2, y2, char, backcolor, textcolor)
  612.     if x1 > x2 then
  613.         local temp = x1
  614.         x1, x2 = x2, temp
  615.     end
  616.     if y1 > y2 then
  617.         local temp = y1
  618.         y1, y2 = y2, temp
  619.     end
  620.     local step, midX, midY, width, height, lastX, lastY = (math.pi * 2) / 16, (x1 + x2) / 2, (y1 + y2) / 2, (x2 - x1) / 2, (y2 - y1) / 2, 1, 1
  621.     for i=1,17,1 do
  622.         local x, y = math.floor((midX + math.cos(step * i) * width) + 0.5), math.floor((midY + math.sin(step * i) * height) + 0.5)
  623.         if i > 1 then
  624.             surf:drawLine(lastX, lastY, x, y, char, backcolor, textcolor)
  625.         end
  626.         lastX, lastY = x, y
  627.     end
  628. end,
  629.  
  630. fillEllipse = function(surf, x1, y1, x2, y2, char, backcolor, textcolor)
  631.     if x1 > x2 then
  632.         local temp = x1
  633.         x1, x2 = x2, temp
  634.     end
  635.     if y1 > y2 then
  636.         local temp = y1
  637.         y1, y2 = y2, temp
  638.     end
  639.     local resolution, step, midX, midY, width, height, lastX, lastY, bwidth, bheight, buffer = 16, (math.pi * 2) / 16, (x1 + x2) / 2, (y1 + y2) / 2, (x2 - x1) / 2, (y2 - y1) / 2, 1, 1, x2 - x1 + 1, y2 - y1 + 1, { }
  640.     for i=1,resolution+1,1 do
  641.         local x, y = math.floor((midX + math.cos(step * i) * width) + 0.5), math.floor((midY + math.sin(step * i) * height) + 0.5)
  642.         if i > 1 then
  643.             _bufferLine(buffer, bwidth, lastX - x1 + 1, lastY - y1 + 1, x - x1 + 1, y - y1 + 1)
  644.         end
  645.         lastX, lastY = x, y
  646.     end
  647.     for j=1,bheight do
  648.         min, max = nil, 0
  649.         for i=1,bwidth,1 do
  650.             if buffer[(j - 1) * bwidth + i] then
  651.                 if not min then min = i end
  652.                 if i > max then max = i end
  653.             end
  654.         end
  655.         _drawHLine(surf, min + x1 - 1, max + x1 - 1, j + y1 - 1, char, backcolor, textcolor)
  656.     end
  657. end,
  658.  
  659. drawArc = function(surf, x1, y1, x2, y2, a1, a2, char, backcolor, textcolor)
  660.     if x1 > x2 then
  661.         local temp = x1
  662.         x1, x2 = x2, temp
  663.     end
  664.     if y1 > y2 then
  665.         local temp = y1
  666.         y1, y2 = y2, temp
  667.     end
  668.     if a1 > a2 then
  669.         local temp = a1
  670.         a1, a2 = a2, temp
  671.     end
  672.     local step, midX, midY, width, height, lastX, lastY = (a2 - a1) / 16, (x1 + x2) / 2, (y1 + y2) / 2, (x2 - x1) / 2, (y2 - y1) / 2, 1, 1
  673.     for i=1,17,1 do
  674.         local x, y = math.floor((midX + math.cos(step * (i - 1) + a1) * width) + 0.5), math.floor((midY + math.sin(step * (i - 1) + a1) * height) + 0.5)
  675.         if i > 1 then
  676.             surf:drawLine(lastX, lastY, x, y, char, backcolor, textcolor)
  677.         end
  678.         lastX, lastY = x, y
  679.     end
  680. end,
  681.  
  682. drawPie = function(surf, x1, y1, x2, y2, a1, a2, char, backcolor, textcolor)
  683.     if x1 > x2 then
  684.         local temp = x1
  685.         x1, x2 = x2, temp
  686.     end
  687.     if y1 > y2 then
  688.         local temp = y1
  689.         y1, y2 = y2, temp
  690.     end
  691.     if a1 > a2 then
  692.         local temp = a1
  693.         a1, a2 = a2, temp
  694.     end
  695.     local step, midX, midY, width, height, lastX, lastY = (a2 - a1) / 16, (x1 + x2) / 2, (y1 + y2) / 2, (x2 - x1) / 2, (y2 - y1) / 2, 1, 1
  696.     for i=1,17,1 do
  697.         local x, y = math.floor((midX + math.cos(step * (i - 1) + a1) * width) + 0.5), math.floor((midY + math.sin(step * (i - 1) + a1) * height) + 0.5)
  698.         if i > 1 then
  699.             surf:drawLine(lastX, lastY, x, y, char, backcolor, textcolor)
  700.         end
  701.         lastX, lastY = x, y
  702.     end
  703.     surf:drawLine(math.floor(midX + 0.5), math.floor(midY + 0.5), math.floor((midX + math.cos(a1) * width) + 0.5), math.floor((midY + math.sin(a1) * height) + 0.5), char, backcolor, textcolor)
  704.     surf:drawLine(math.floor(midX + 0.5), math.floor(midY + 0.5), math.floor((midX + math.cos(a2) * width) + 0.5), math.floor((midY + math.sin(a2) * height) + 0.5), char, backcolor, textcolor)
  705. end,
  706.  
  707. fillPie = function(surf, x1, y1, x2, y2, a1, a2, char, backcolor, textcolor)
  708.     if x1 > x2 then
  709.         local temp = x1
  710.         x1, x2 = x2, temp
  711.     end
  712.     if y1 > y2 then
  713.         local temp = y1
  714.         y1, y2 = y2, temp
  715.     end
  716.     if a1 > a2 then
  717.         local temp = a1
  718.         a1, a2 = a2, temp
  719.     end
  720.     local step, midX, midY, width, height, lastX, lastY, bwidth, bheight, buffer = (a2 - a1) / 16, (x1 + x2) / 2, (y1 + y2) / 2, (x2 - x1) / 2, (y2 - y1) / 2, 1, 1, x2 - x1 + 1, y2 - y1 + 1, { }
  721.     for i=1,17,1 do
  722.         local x, y = math.floor((midX + math.cos(step * (i - 1) + a1) * width) + 0.5), math.floor((midY + math.sin(step * (i - 1) + a1) * height) + 0.5)
  723.         if i > 1 then
  724.             _bufferLine(buffer, bwidth, lastX - x1 + 1, lastY - y1 + 1, x - x1 + 1, y - y1 + 1)
  725.         end
  726.         lastX, lastY = x, y
  727.     end
  728.     _bufferLine(buffer, bwidth, math.floor(midX + 0.5) - x1 + 1, math.floor(midY + 0.5) - y1 + 1, math.floor((midX + math.cos(a1) * width) + 0.5) - x1 + 1, math.floor((midY + math.sin(a1) * height) + 0.5) - y1 + 1)
  729.     _bufferLine(buffer, bwidth, math.floor(midX + 0.5) - x1 + 1, math.floor(midY + 0.5) - y1 + 1, math.floor((midX + math.cos(a2) * width) + 0.5) - x1 + 1, math.floor((midY + math.sin(a2) * height) + 0.5) - y1 + 1)
  730.     for j=1,bheight do
  731.         min, max = nil, 0
  732.         for i=1,bwidth,1 do
  733.             if buffer[(j - 1) * bwidth + i] then
  734.                 if not min then min = i end
  735.                 if i > max then max = i end
  736.             end
  737.         end
  738.         if min then
  739.             _drawHLine(surf, min + x1 - 1, max + x1 - 1, j + y1 - 1, char, backcolor, textcolor)
  740.         end
  741.     end
  742. end,
  743.  
  744. floodFill = function(surf, x, y, char, backcolor, textcolor)
  745.     if x < surf.x1 or y < surf.y1 or x > surf.x2 or y > surf.y2 then return end
  746.     local stack, tchar, tbackcolor, ttextcolor = { x, y }, surf.buffer[((y - 1) * surf.width + x) * 3 - 2], surf.buffer[((y - 1) * surf.width + x) * 3 - 1], surf.buffer[((y - 1) * surf.width + x) * 3]
  747.     if (tchar == char) and (tbackcolor == backcolor) and (ttextcolor == textcolor) then return end
  748.     while #stack > 0 do
  749.         local cx, cy = stack[#stack - 1], stack[#stack]
  750.         stack[#stack] = nil
  751.         stack[#stack] = nil
  752.         if cx >= surf.x1 and cy >= surf.y1 and cx <= surf.x2 and cy <= surf.y2 then
  753.             local cchar, cbackcolor, ctextcolor = surf.buffer[((cy - 1) * surf.width + cx) * 3 - 2], surf.buffer[((cy - 1) * surf.width + cx) * 3 - 1], surf.buffer[((cy - 1) * surf.width + cx) * 3]
  754.             if (tchar == cchar) and (tbackcolor == cbackcolor) and (ttextcolor == ctextcolor) then
  755.                 if char or surf.overwrite then
  756.                     surf.buffer[((cy - 1) * surf.width + cx) * 3 - 2] = char
  757.                 end
  758.                 if backcolor or surf.overwrite then
  759.                     surf.buffer[((cy - 1) * surf.width + cx) * 3 - 1] = backcolor
  760.                 end
  761.                 if textcolor or surf.overwrite then
  762.                     surf.buffer[((cy - 1) * surf.width + cx) * 3] = textcolor
  763.                 end
  764.                 stack[#stack + 1] = cx - 1
  765.                 stack[#stack + 1] = cy
  766.                 stack[#stack + 1] = cx + 1
  767.                 stack[#stack + 1] = cy
  768.                 stack[#stack + 1] = cx
  769.                 stack[#stack + 1] = cy - 1
  770.                 stack[#stack + 1] = cx
  771.                 stack[#stack + 1] = cy + 1
  772.             end
  773.         end
  774.     end
  775. end,
  776.  
  777. drawSurface = function(surf, x, y, surf2)
  778.     for j=1,surf2.height,1 do
  779.         for i=1,surf2.width,1 do
  780.             surf:drawPixel(i + x - 1, j + y - 1, surf2.buffer[((j - 1) * surf2.width + i) * 3 - 2], surf2.buffer[((j - 1) * surf2.width + i) * 3 - 1], surf2.buffer[((j - 1) * surf2.width + i) * 3])
  781.         end
  782.     end
  783. end,
  784.  
  785. drawSurfacePart = function(surf, x, y, sx1, sy1, sx2, sy2, surf2)
  786.     if sx1 > sx2 then
  787.         local temp = sx1
  788.         sx1, sx2 = sx2, temp
  789.     end
  790.     if sy1 > sy2 then
  791.         local temp = sy1
  792.         sy1, sy2 = sy2, temp
  793.     end
  794.     if sx2 < 1 or sx1 > surf2.width or sy2 < 1 or sy1 > surf2.height then return end
  795.     if sx1 < 1 then sx1 = 1 end
  796.     if sx2 > surf2.width then sx2 = surf2.width end
  797.     if sy1 < 1 then sy1 = 1 end
  798.     if sy2 > surf2.height then sy2 = surf2.height end
  799.     for j=sy1,sy2,1 do
  800.         for i=sx1,sx2,1 do
  801.             surf:drawPixel(x + i - sx1, y + j - sy1, surf2.buffer[((j - 1) * surf2.width + i) * 3 - 2], surf2.buffer[((j - 1) * surf2.width + i) * 3 - 1], surf2.buffer[((j - 1) * surf2.width + i) * 3])
  802.         end
  803.     end
  804. end,
  805.  
  806. drawSurfaceScaled = function(surf, x1, y1, x2, y2, surf2)
  807.     local x, width, xinv, y, height, yinv = 0, 0, false, 0, 0, false
  808.     if x1 <= x2 then
  809.         x = x1
  810.         width = x2 - x1 + 1
  811.     else
  812.         x = x2
  813.         width = x1 - x2 + 1
  814.         xinv = true
  815.     end
  816.     if y1 <= y2 then
  817.         y = y1
  818.         height = y2 - y1 + 1
  819.     else
  820.         y = y2
  821.         height = y1 - y2 + 1
  822.         yinv = true
  823.     end
  824.     local xscale, yscale, px, py = width / surf2.width, height / surf2.height
  825.     for j=1,height,1 do
  826.         for i=1,width,1 do
  827.             if xinv then
  828.                 px = math.floor((width - i + 0.5) / xscale) + 1
  829.             else
  830.                 px = math.floor((i - 0.5) / xscale) + 1
  831.             end
  832.             if yinv then
  833.                 py = math.floor((height - j + 0.5) / yscale) + 1
  834.             else
  835.                 py = math.floor((j - 0.5) / yscale) + 1
  836.             end
  837.             surf:drawPixel(x + i - 1, y + j - 1, surf2.buffer[((py - 1) * surf2.width + px) * 3 - 2], surf2.buffer[((py - 1) * surf2.width + px) * 3 - 1], surf2.buffer[((py - 1) * surf2.width + px) * 3])
  838.         end
  839.     end
  840. end,
  841.  
  842. drawSurfaceRotated = function(surf, x, y, ox, oy, angle, surf2)
  843.     local cos, sin, range = math.cos(angle), math.sin(angle), math.floor(math.sqrt(surf2.width * surf2.width + surf2.height * surf2.height))
  844.     x, y = x - math.floor(cos * (ox - 1) + sin * (oy - 1) + 0.5), y - math.floor(cos * (oy - 1) - sin * (ox - 1) + 0.5)
  845.     for j=-range,range,1 do
  846.         for i=-range,range,1 do
  847.             local sx, sy = math.floor(i * cos - j * sin), math.floor(i * sin + j * cos)
  848.             if sx >= 0 and sx < surf2.width and sy >= 0 and sy < surf2.height then
  849.                 surf:drawPixel(x + i, y + j, surf2.buffer[(sy * surf2.width + sx) * 3 + 1], surf2.buffer[(sy * surf2.width + sx) * 3 + 2], surf2.buffer[(sy * surf2.width + sx) * 3 + 3])
  850.             end
  851.         end
  852.     end
  853. end,
  854.  
  855. shader = function(surf, f, x1, y1, x2, y2)
  856.     x1, y1, x2, y2 = x1 or surf.x1, y1 or surf.y1, x2 or surf.x2, y2 or surf.y2
  857.     if x1 > x2 then
  858.         local temp = x1
  859.         x1, x2 = x2, temp
  860.     end
  861.     if y1 > y2 then
  862.         local temp = y1
  863.         y1, y2 = y2, temp
  864.     end
  865.     if x2 < surf.x1 or x1 > surf.x2 or y2 < surf.y1 or y1 > surf.y2 then return end
  866.     if x1 < surf.x1 then x1 = surf.x1 end
  867.     if x2 > surf.x2 then x2 = surf.x2 end
  868.     if y1 < surf.y1 then y1 = surf.y1 end
  869.     if y2 > surf.y2 then y2 = surf.y2 end
  870.     local width, buffer = x2 - x1 + 1, { }
  871.     for j=y1,y2 do
  872.         for i=x1,x2 do
  873.             buffer[((j - y1) * width + i - x1) * 3 + 1], buffer[((j - y1) * width + i - x1) * 3 + 2], buffer[((j - y1) * width + i - x1) * 3 + 3] = f(surf.buffer[((j - 1) * surf.width + i) * 3 - 2], surf.buffer[((j - 1) * surf.width + i) * 3 - 1], surf.buffer[((j - 1) * surf.width + i) * 3], i, j)
  874.         end
  875.     end
  876.     for j=y1,y2 do
  877.         for i=x1,x2 do
  878.             surf.buffer[((j - 1) * surf.width + i) * 3 - 2], surf.buffer[((j - 1) * surf.width + i) * 3 - 1], surf.buffer[((j - 1) * surf.width + i) * 3] = buffer[((j - y1) * width + i - x1) * 3 + 1], buffer[((j - y1) * width + i - x1) * 3 + 2], buffer[((j - y1) * width + i - x1) * 3 + 3]
  879.         end
  880.     end
  881. end,
  882.  
  883. shift = function(surf, x, y, x1, y1, x2, y2)
  884.     x1, y1, x2, y2 = x1 or surf.x1, y1 or surf.y1, x2 or surf.x2, y2 or surf.y2
  885.     if x1 > x2 then
  886.         local temp = x1
  887.         x1, x2 = x2, temp
  888.     end
  889.     if y1 > y2 then
  890.         local temp = y1
  891.         y1, y2 = y2, temp
  892.     end
  893.     if x2 < surf.x1 or x1 > surf.x2 or y2 < surf.y1 or y1 > surf.y2 then return end
  894.     if x1 < surf.x1 then x1 = surf.x1 end
  895.     if x2 > surf.x2 then x2 = surf.x2 end
  896.     if y1 < surf.y1 then y1 = surf.y1 end
  897.     if y2 > surf.y2 then y2 = surf.y2 end
  898.     local width, buffer = x2 - x1 + 1, { }
  899.     for j=y1,y2 do
  900.         for i=x1,x2 do
  901.             if i - x >= 1 and j - y >= 1 and i - x <= surf.width and j - y <= surf.height then
  902.                 buffer[((j - y1) * width + i - x1) * 3 + 1], buffer[((j - y1) * width + i - x1) * 3 + 2], buffer[((j - y1) * width + i - x1) * 3 + 3] = surf.buffer[((j - y - 1) * surf.width + i - x) * 3 - 2], surf.buffer[((j - y - 1) * surf.width + i - x) * 3 - 1], surf.buffer[((j - y - 1) * surf.width + i - x) * 3]
  903.             end
  904.         end
  905.     end
  906.     for j=y1,y2 do
  907.         for i=x1,x2 do
  908.             surf.buffer[((j - 1) * surf.width + i) * 3 - 2], surf.buffer[((j - 1) * surf.width + i) * 3 - 1], surf.buffer[((j - 1) * surf.width + i) * 3] = buffer[((j - y1) * width + i - x1) * 3 + 1], buffer[((j - y1) * width + i - x1) * 3 + 2], buffer[((j - y1) * width + i - x1) * 3 + 3]
  909.         end
  910.     end
  911. end
  912. }
  913.  
  914. function create(width, height, char, backcolor, textcolor)
  915.     local surf = { }
  916.     for k,v in pairs(_functions) do
  917.         surf[k] = v
  918.     end
  919.     surf.width, surf.height, surf.x1, surf.y1, surf.x2, surf.y2, surf.blink, surf.curX, surf.curY, surf.overwrite, surf.buffer = width, height, 1, 1, width, height, nil, 1, 1, false, { }
  920.     if char then
  921.         for i=1,width * height do
  922.             surf.buffer[i * 3 - 2] = char
  923.         end
  924.     end
  925.     if backcolor then
  926.         for i=1,width * height do
  927.             surf.buffer[i * 3 - 1] = backcolor
  928.         end
  929.     end
  930.     if textcolor then
  931.         for i=1,width * height do
  932.             surf.buffer[i * 3] = textcolor
  933.         end
  934.     end
  935.     return surf
  936. end
  937.  
  938. function load(path)
  939.     local lines, f = { }, fs.open(path, "r")
  940.     for line in f.readLine do
  941.         lines[#lines + 1] = line
  942.     end
  943.     f.close()
  944.     local height = #lines
  945.     if lines[1]:byte(1) == 30 then
  946.         local width, i = 0, 1
  947.         while i <= #lines[1] do
  948.             local char = lines[1]:byte(i)
  949.             if char == 30 or char == 31 then
  950.                 i = i + 1
  951.             else
  952.                 width = width + 1
  953.             end
  954.             i = i + 1
  955.         end
  956.         local surf, backcolor, textcolor, i, px, char, color = create(width, height)
  957.         for j=1,height do
  958.             i = 1
  959.             px = 1
  960.             while i <= #lines[j] do
  961.                 char = lines[j]:byte(i)
  962.                 if char == 30 then
  963.                     i = i + 1
  964.                     char = lines[j]:byte(i)
  965.                     color = tonumber(lines[j]:sub(i, i), 16)
  966.                     if color then
  967.                         backcolor = 2^color
  968.                     else
  969.                         backcolor = nil
  970.                     end
  971.                 elseif char == 31 then
  972.                     i = i + 1
  973.                     char = lines[j]:byte(i)
  974.                     color = tonumber(lines[j]:sub(i, i), 16)
  975.                     if color then
  976.                         textcolor = 2^color
  977.                     else
  978.                         textcolor = nil
  979.                     end
  980.                 else
  981.                     surf.buffer[((j - 1) * surf.width + px) * 3 - 2] = lines[j]:sub(i, i)
  982.                     surf.buffer[((j - 1) * surf.width + px) * 3 - 1] = backcolor
  983.                     surf.buffer[((j - 1) * surf.width + px) * 3] = textcolor
  984.                     px = px + 1
  985.                 end
  986.                 i = i + 1
  987.             end
  988.         end
  989.         return surf
  990.     elseif lines[1]:byte(1) == 95 then
  991.         return loadString(lines[1])
  992.     else
  993.         local width = 0
  994.         for i=1,#lines,1 do
  995.             if #lines[i] > width then
  996.                 width = #lines[i]
  997.             end
  998.         end
  999.         local surf, color = create(width, height)
  1000.         for j=1,height do
  1001.             for i=1,width do
  1002.                 color = tonumber(lines[j]:sub(i, i), 16)
  1003.                 if color then
  1004.                     surf.buffer[((j - 1) * surf.width + i) * 3 - 1] = 2 ^ color
  1005.                 end
  1006.             end
  1007.         end
  1008.         return surf
  1009.     end
  1010. end
  1011.  
  1012. function loadString(str)
  1013.     local width, height, n = tonumber(str:sub(2, 5), 16), tonumber(str:sub(6, 9), 16), 10
  1014.     local surf = create(width, height)
  1015.     for j=1,height do
  1016.         for i=1,width do
  1017.             if str:byte(n) ~= 95 then
  1018.                 surf.buffer[((j - 1) * surf.width + i) * 3 - 2] = string.char(tonumber(str:sub(n, n + 1), 16))
  1019.             end
  1020.             if str:byte(n + 2) ~= 95 then
  1021.                 surf.buffer[((j - 1) * surf.width + i) * 3 - 1] = 2 ^ tonumber(str:sub(n + 2, n + 2), 16)
  1022.             end
  1023.             if str:byte(n + 3) ~= 95 then
  1024.                 surf.buffer[((j - 1) * surf.width + i) * 3] = 2 ^ tonumber(str:sub(n + 3, n + 3), 16)
  1025.             end
  1026.             n = n + 4
  1027.         end
  1028.     end
  1029.     return surf
  1030. end
RAW Paste Data
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy. OK, I Understand
Top