API tools faq
paste
Advertisement
Omsigames

grapes/Color.lua

Omsigames
Dec 25th, 2024 (edited)
30
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Lua 9.55 KB | None | 0 0
raw download clone embed print report
  1. local computer = require("computer")
  2.  
  3. local palette = {0x000000, 0x000040, 0x000080, 0x0000BF, 0x0000FF, 0x002400, 0x002440, 0x002480, 0x0024BF, 0x0024FF, 0x004900, 0x004940, 0x004980, 0x0049BF, 0x0049FF, 0x006D00, 0x006D40, 0x006D80, 0x006DBF, 0x006DFF, 0x009200, 0x009240, 0x009280, 0x0092BF, 0x0092FF, 0x00B600, 0x00B640, 0x00B680, 0x00B6BF, 0x00B6FF, 0x00DB00, 0x00DB40, 0x00DB80, 0x00DBBF, 0x00DBFF, 0x00FF00, 0x00FF40, 0x00FF80, 0x00FFBF, 0x00FFFF, 0x0F0F0F, 0x1E1E1E, 0x2D2D2D, 0x330000, 0x330040, 0x330080, 0x3300BF, 0x3300FF, 0x332400, 0x332440, 0x332480, 0x3324BF, 0x3324FF, 0x334900, 0x334940, 0x334980, 0x3349BF, 0x3349FF, 0x336D00, 0x336D40, 0x336D80, 0x336DBF, 0x336DFF, 0x339200, 0x339240, 0x339280, 0x3392BF, 0x3392FF, 0x33B600, 0x33B640, 0x33B680, 0x33B6BF, 0x33B6FF, 0x33DB00, 0x33DB40, 0x33DB80, 0x33DBBF, 0x33DBFF, 0x33FF00, 0x33FF40, 0x33FF80, 0x33FFBF, 0x33FFFF, 0x3C3C3C, 0x4B4B4B, 0x5A5A5A, 0x660000, 0x660040, 0x660080, 0x6600BF, 0x6600FF, 0x662400, 0x662440, 0x662480, 0x6624BF, 0x6624FF, 0x664900, 0x664940, 0x664980, 0x6649BF, 0x6649FF, 0x666D00, 0x666D40, 0x666D80, 0x666DBF, 0x666DFF, 0x669200, 0x669240, 0x669280, 0x6692BF, 0x6692FF, 0x66B600, 0x66B640, 0x66B680, 0x66B6BF, 0x66B6FF, 0x66DB00, 0x66DB40, 0x66DB80, 0x66DBBF, 0x66DBFF, 0x66FF00, 0x66FF40, 0x66FF80, 0x66FFBF, 0x66FFFF, 0x696969, 0x787878, 0x878787, 0x969696, 0x990000, 0x990040, 0x990080, 0x9900BF, 0x9900FF, 0x992400, 0x992440, 0x992480, 0x9924BF, 0x9924FF, 0x994900, 0x994940, 0x994980, 0x9949BF, 0x9949FF, 0x996D00, 0x996D40, 0x996D80, 0x996DBF, 0x996DFF, 0x999200, 0x999240, 0x999280, 0x9992BF, 0x9992FF, 0x99B600, 0x99B640, 0x99B680, 0x99B6BF, 0x99B6FF, 0x99DB00, 0x99DB40, 0x99DB80, 0x99DBBF, 0x99DBFF, 0x99FF00, 0x99FF40, 0x99FF80, 0x99FFBF, 0x99FFFF, 0xA5A5A5, 0xB4B4B4, 0xC3C3C3, 0xCC0000, 0xCC0040, 0xCC0080, 0xCC00BF, 0xCC00FF, 0xCC2400, 0xCC2440, 0xCC2480, 0xCC24BF, 0xCC24FF, 0xCC4900, 0xCC4940, 0xCC4980, 0xCC49BF, 0xCC49FF, 0xCC6D00, 0xCC6D40, 0xCC6D80, 0xCC6DBF, 0xCC6DFF, 0xCC9200, 0xCC9240, 0xCC9280, 0xCC92BF, 0xCC92FF, 0xCCB600, 0xCCB640, 0xCCB680, 0xCCB6BF, 0xCCB6FF, 0xCCDB00, 0xCCDB40, 0xCCDB80, 0xCCDBBF, 0xCCDBFF, 0xCCFF00, 0xCCFF40, 0xCCFF80, 0xCCFFBF, 0xCCFFFF, 0xD2D2D2, 0xE1E1E1, 0xF0F0F0, 0xFF0000, 0xFF0040, 0xFF0080, 0xFF00BF, 0xFF00FF, 0xFF2400, 0xFF2440, 0xFF2480, 0xFF24BF, 0xFF24FF, 0xFF4900, 0xFF4940, 0xFF4980, 0xFF49BF, 0xFF49FF, 0xFF6D00, 0xFF6D40, 0xFF6D80, 0xFF6DBF, 0xFF6DFF, 0xFF9200, 0xFF9240, 0xFF9280, 0xFF92BF, 0xFF92FF, 0xFFB600, 0xFFB640, 0xFFB680, 0xFFB6BF, 0xFFB6FF, 0xFFDB00, 0xFFDB40, 0xFFDB80, 0xFFDBBF, 0xFFDBFF, 0xFFFF00, 0xFFFF40, 0xFFFF80, 0xFFFFBF, 0xFFFFFF}
  4. local mathFloor, mathMax, mathMin, mathModf = math.floor, math.max, math.min, math.modf
  5. local integerToRGB, RGBToInteger, blend, transition, to8Bit
  6.  
  7. local color = {}
  8.  
  9. --------------------------------------------------------------------------------
  10.  
  11. -- Optimized Lua 5.3 bitwise support
  12. if computer.getArchitecture and computer.getArchitecture() == "Lua 5.3" then
  13.     integerToRGB, RGBToInteger, blend, transition, to8Bit = load([[
  14.         local mathHuge, palette = math.huge, select(1, ...)
  15.  
  16.         return
  17.             function(integerColor)
  18.                 return integerColor >> 16, integerColor >> 8 & 0xFF, integerColor & 0xFF
  19.             end,
  20.  
  21.             function(r, g, b)
  22.                 return r << 16 | g << 8 | b
  23.             end,
  24.  
  25.             function(color1, color2, transparency)
  26.                 local invertedTransparency = 1 - transparency
  27.                
  28.                 return
  29.                     ((color2 >> 16) * invertedTransparency + (color1 >> 16) * transparency) // 1.0 << 16 |
  30.                     ((color2 >> 8 & 0xFF) * invertedTransparency + (color1 >> 8 & 0xFF) * transparency) // 1.0 << 8 |
  31.                     ((color2 & 0xFF) * invertedTransparency + (color1 & 0xFF) * transparency) // 1.0
  32.             end,
  33.  
  34.             function(color1, color2, position)
  35.                 local r1, g1, b1 = color1 >> 16, color1 >> 8 & 0xFF, color1 & 0xFF
  36.                
  37.                 return
  38.                     (r1 + ((color2 >> 16) - r1) * position) // 1.0 << 16 |
  39.                     (g1 + ((color2 >> 8 & 0xFF) - g1) * position) // 1.0 << 8 |
  40.                     (b1 + ((color2 & 0xFF) - b1) * position) // 1.0
  41.             end,
  42.  
  43.             function(color24Bit)
  44.                 local r, g, b, closestDelta, closestIndex, delta, paletteColor, paletteR, paletteG, paletteB = color24Bit >> 16, color24Bit >> 8 & 0xFF, color24Bit & 0xFF, mathHuge, 1
  45.  
  46.                 for i = 1, #palette do
  47.                     paletteColor = palette[i]
  48.  
  49.                     if color24Bit == paletteColor then
  50.                         return i - 1
  51.                     else
  52.                         paletteR, paletteG, paletteB = paletteColor >> 16, paletteColor >> 8 & 0xFF, paletteColor & 0xFF
  53.  
  54.                         delta = (paletteR - r) ^ 2 + (paletteG - g) ^ 2 + (paletteB - b) ^ 2
  55.                        
  56.                         if delta < closestDelta then
  57.                             closestDelta, closestIndex = delta, i
  58.                         end
  59.                     end
  60.                 end
  61.  
  62.                 return closestIndex - 1
  63.             end
  64.     ]], "=lua53colorfunctions")(palette)
  65. else
  66.     integerToRGB, RGBToInteger, blend, transition, to8Bit = load([[
  67.         local mathHuge, palette = math.huge, select(1, ...)
  68.  
  69.         return
  70.             function(integerColor)
  71.                 local r = integerColor / 65536
  72.                 r = r - r % 1
  73.                
  74.                 local g = (integerColor - r * 65536) / 256
  75.                 g = g - g % 1
  76.  
  77.                 return r, g, integerColor - r * 65536 - g * 256
  78.             end,
  79.  
  80.             function(r, g, b)
  81.                 return r * 65536 + g * 256 + b
  82.             end,
  83.  
  84.             function(color1, color2, transparency)
  85.                 local invertedTransparency = 1 - transparency
  86.                
  87.                 local r1 = color1 / 65536
  88.                 r1 = r1 - r1 % 1
  89.                
  90.                 local g1 = (color1 - r1 * 65536) / 256
  91.                 g1 = g1 - g1 % 1
  92.  
  93.                 local r2 = color2 / 65536
  94.                 r2 = r2 - r2 % 1
  95.                
  96.                 local g2 = (color2 - r2 * 65536) / 256
  97.                 g2 = g2 - g2 % 1
  98.  
  99.                 local r, g, b =
  100.                     r2 * invertedTransparency + r1 * transparency,
  101.                     g2 * invertedTransparency + g1 * transparency,
  102.                     (color2 - r2 * 65536 - g2 * 256) * invertedTransparency + (color1 - r1 * 65536 - g1 * 256) * transparency
  103.  
  104.                 return
  105.                     (r - r % 1) * 65536 +
  106.                     (g - g % 1) * 256 +
  107.                     (b - b % 1)
  108.             end,
  109.  
  110.             function(color1, color2, position)
  111.                 local r1 = color1 / 65536
  112.                 r1 = r1 - r1 % 1
  113.                
  114.                 local g1 = (color1 - r1 * 65536) / 256
  115.                 g1 = g1 - g1 % 1
  116.                
  117.                 local b1 = color1 - r1 * 65536 - g1 * 256
  118.  
  119.                 local r2 = color2 / 65536
  120.                 r2 = r2 - r2 % 1
  121.                
  122.                 local g2 = (color2 - r2 * 65536) / 256
  123.                 g2 = g2 - g2 % 1
  124.  
  125.                 local r, g, b =
  126.                     r1 + (r2 - r1) * position,
  127.                     g1 + (g2 - g1) * position,
  128.                     b1 + (color2 - r2 * 65536 - g2 * 256 - b1) * position
  129.  
  130.                 return
  131.                     (r - r % 1) * 65536 +
  132.                     (g - g % 1) * 256 +
  133.                     (b - b % 1)
  134.             end,
  135.  
  136.             function(color24Bit)
  137.                 local closestDelta, closestIndex, delta, paletteColor, paletteR, paletteG, paletteB = mathHuge, 1
  138.  
  139.                 local r = color24Bit / 65536
  140.                 r = r - r % 1
  141.                
  142.                 local g = (color24Bit - r * 65536) / 256
  143.                 g = g - g % 1
  144.                
  145.                 local b = color24Bit - r * 65536 - g * 256
  146.  
  147.                 for index = 1, #palette do
  148.                     paletteColor = palette[index]
  149.                    
  150.                     if color24Bit == paletteColor then
  151.                         return index - 1
  152.                     else
  153.                         paletteR = paletteColor / 65536
  154.                         paletteR = paletteR - paletteR % 1
  155.                         paletteG = (paletteColor - paletteR * 65536) / 256
  156.                         paletteG = paletteG - paletteG % 1
  157.                         paletteB = paletteColor - paletteR * 65536 - paletteG * 256
  158.  
  159.                         delta = (paletteR - r) ^ 2 + (paletteG - g) ^ 2 + (paletteB - b) ^ 2
  160.                        
  161.                         if delta < closestDelta then
  162.                             closestDelta, closestIndex = delta, index
  163.                         end
  164.                     end
  165.                 end
  166.  
  167.                 return closestIndex - 1
  168.             end
  169.     ]], "=lua52colorfunctions")(palette)
  170. end
  171.  
  172. --------------------------------------------------------------------------------
  173.  
  174. local function RGBToHSB(r, g, b)
  175.     local max, min = mathMax(r, g, b), mathMin(r, g, b)
  176.  
  177.     if max == min then
  178.         return 0, max == 0 and 0 or (1 - min / max), max / 255
  179.     elseif max == r and g >= b then
  180.         return 60 * (g - b) / (max - min), max == 0 and 0 or (1 - min / max), max / 255
  181.     elseif max == r and g < b then
  182.         return 60 * (g - b) / (max - min) + 360, max == 0 and 0 or (1 - min / max), max / 255
  183.     elseif max == g then
  184.         return 60 * (b - r) / (max - min) + 120, max == 0 and 0 or (1 - min / max), max / 255
  185.     elseif max == b then
  186.         return 60 * (r - g) / (max - min) + 240, max == 0 and 0 or (1 - min / max), max / 255
  187.     else
  188.         return 0, max == 0 and 0 or (1 - min / max), max / 255
  189.     end
  190. end
  191.  
  192. local function HSBToRGB(h, s, b)
  193.     local integer, fractional = mathModf(h / 60)   
  194.     local p, q, t = b * (1 - s), b * (1 - s * fractional), b * (1 - (1 - fractional) * s)
  195.  
  196.     if integer == 0 then
  197.         return mathFloor(b * 255), mathFloor(t * 255), mathFloor(p * 255)
  198.     elseif integer == 1 then
  199.         return mathFloor(q * 255), mathFloor(b * 255), mathFloor(p * 255)
  200.     elseif integer == 2 then
  201.         return mathFloor(p * 255), mathFloor(b * 255), mathFloor(t * 255)
  202.     elseif integer == 3 then
  203.         return mathFloor(p * 255), mathFloor(q * 255), mathFloor(b * 255)
  204.     elseif integer == 4 then
  205.         return mathFloor(t * 255), mathFloor(p * 255), mathFloor(b * 255)
  206.     else
  207.         return mathFloor(b * 255), mathFloor(p * 255), mathFloor(q * 255)
  208.     end
  209. end
  210.  
  211. local function integerToHSB(integerColor)
  212.     return RGBToHSB(integerToRGB(integerColor))
  213. end
  214.  
  215. local function HSBToInteger(h, s, b)
  216.     return RGBToInteger(HSBToRGB(h, s, b))
  217. end
  218.  
  219. --------------------------------------------------------------------------------
  220.  
  221. local function to24Bit(color8Bit)
  222.     return palette[color8Bit + 1]
  223. end
  224.  
  225. local function optimize(color24Bit)
  226.     return to24Bit(to8Bit(color24Bit))
  227. end
  228.  
  229. --------------------------------------------------------------------------------
  230.  
  231. return {
  232.     RGBToInteger = RGBToInteger,
  233.     integerToRGB = integerToRGB,
  234.     RGBToHSB = RGBToHSB,
  235.     HSBToRGB = HSBToRGB,
  236.     integerToHSB = integerToHSB,
  237.     HSBToInteger = HSBToInteger,
  238.     blend = blend,
  239.     transition = transition,
  240.     to8Bit = to8Bit,
  241.     to24Bit = to24Bit,
  242.     optimize = optimize,
  243. }
Tags: ORMS
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
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
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!