luajitos

PNG.lua (12006B)

---

 -- PNG.lua - PNG Image Creation and Manipulation Library
 -- Requires: "imaging" permission
 
 local PNG = {}
 
 -- Check for imaging permission
 local function checkPermission()
     if not ADMIN_HasPermission then
         error("PNG library requires permission system, but ADMIN_HasPermission is not available")
     end
 
     if not ADMIN_HasPermission("imaging") then
         error("Permission denied: 'imaging' permission required to use PNG library")
     end
 end
 
 -- PNG image object
 local PNGImage = {}
 PNGImage.__index = PNGImage
 PNGImage.__metatable = false  -- Prevent metatable access/modification
 
 -- Create a new PNG image
 -- @param width Image width in pixels
 -- @param height Image height in pixels
 -- @param hasAlpha Optional, default true - whether image has alpha channel
 -- @return PNG image object
 function PNG.new(width, height, hasAlpha)
     checkPermission()
 
     if not width or not height then
         error("PNG.new requires width and height")
     end
 
     if width <= 0 or width > 4096 then
         error("PNG width must be between 1 and 4096")
     end
 
     if height <= 0 or height > 4096 then
         error("PNG height must be between 1 and 4096")
     end
 
     hasAlpha = (hasAlpha == nil) and true or hasAlpha
 
     local self = setmetatable({}, PNGImage)
 
     -- Create image buffer using C API
     -- We'll create a simple RGBA buffer in memory
     self.width = width
     self.height = height
     self.hasAlpha = hasAlpha
     self.bpp = hasAlpha and 32 or 24
 
     -- Allocate pixel data (RGBA format)
     -- Each pixel is 4 bytes (R, G, B, A)
     local pixelCount = width * height
     self.pixels = {}
 
     -- Initialize to transparent black (or opaque black if no alpha)
     local defaultAlpha = hasAlpha and 0 or 255
     for i = 1, pixelCount do
         self.pixels[i] = {
             r = 0,
             g = 0,
             b = 0,
             a = defaultAlpha
         }
     end
 
     -- Create C image buffer if available
     if ImageCreate then
         self.imageBuffer = ImageCreate(width, height, hasAlpha)
     end
 
     return self
 end
 
 -- Write a pixel to the image
 -- @param x X coordinate (0-based)
 -- @param y Y coordinate (0-based)
 -- @param color Color in hex format "RRGGBB" or "RRGGBBAA"
 function PNGImage:writePixel(x, y, color)
     checkPermission()
 
     if not x or not y or not color then
         error("writePixel requires x, y, and color")
     end
 
     if x < 0 or x >= self.width or y < 0 or y >= self.height then
         error("Pixel coordinates out of bounds: (" .. x .. ", " .. y .. ")")
     end
 
     -- Parse color string
     local r, g, b, a
 
     if type(color) == "string" then
         -- Remove # if present
         color = color:gsub("^#", "")
 
         if #color == 6 then
             -- RRGGBB format
             r = tonumber(color:sub(1, 2), 16)
             g = tonumber(color:sub(3, 4), 16)
             b = tonumber(color:sub(5, 6), 16)
             a = 255
         elseif #color == 8 then
             -- RRGGBBAA format
             r = tonumber(color:sub(1, 2), 16)
             g = tonumber(color:sub(3, 4), 16)
             b = tonumber(color:sub(5, 6), 16)
             a = tonumber(color:sub(7, 8), 16)
         else
             error("Invalid color format. Use 'RRGGBB' or 'RRGGBBAA'")
         end
     elseif type(color) == "number" then
         -- Treat as 0xRRGGBB or 0xRRGGBBAA
         if color <= 0xFFFFFF then
             -- RGB format
             r = bit.rshift(bit.band(color, 0xFF0000), 16)
             g = bit.rshift(bit.band(color, 0x00FF00), 8)
             b = bit.band(color, 0x0000FF)
             a = 255
         else
             -- RGBA format
             r = bit.rshift(bit.band(color, 0xFF000000), 24)
             g = bit.rshift(bit.band(color, 0x00FF0000), 16)
             b = bit.rshift(bit.band(color, 0x0000FF00), 8)
             a = bit.band(color, 0x000000FF)
         end
     else
         error("Color must be a string (hex) or number")
     end
 
     if not r or not g or not b then
         error("Failed to parse color: " .. tostring(color))
     end
 
     -- Calculate pixel index (row-major order)
     local index = y * self.width + x + 1
 
     -- Store pixel
     self.pixels[index] = {
         r = r,
         g = g,
         b = b,
         a = a or 255
     }
 
     -- Update C image buffer if available
     if self.imageBuffer and ImageSetPixel then
         ImageSetPixel(self.imageBuffer, x, y, r, g, b, a or 255)
     end
 end
 
 -- Read a pixel from the image
 -- @param x X coordinate (0-based)
 -- @param y Y coordinate (0-based)
 -- @return Color string in "RRGGBB" or "RRGGBBAA" format
 function PNGImage:readPixel(x, y)
     checkPermission()
 
     if not x or not y then
         error("readPixel requires x and y coordinates")
     end
 
     if x < 0 or x >= self.width or y < 0 or y >= self.height then
         error("Pixel coordinates out of bounds: (" .. x .. ", " .. y .. ")")
     end
 
     -- Calculate pixel index
     local index = y * self.width + x + 1
 
     local pixel = self.pixels[index]
 
     if not pixel then
         return "00000000"
     end
 
     -- Format as hex string
     local r = string.format("%02X", pixel.r)
     local g = string.format("%02X", pixel.g)
     local b = string.format("%02X", pixel.b)
 
     if self.hasAlpha then
         local a = string.format("%02X", pixel.a)
         return r .. g .. b .. a
     else
         return r .. g .. b
     end
 end
 
 -- Get pixel as RGBA table
 -- @param x X coordinate (0-based)
 -- @param y Y coordinate (0-based)
 -- @return Table with r, g, b, a fields (0-255)
 function PNGImage:getPixel(x, y)
     checkPermission()
 
     if not x or not y then
         error("getPixel requires x and y coordinates")
     end
 
     if x < 0 or x >= self.width or y < 0 or y >= self.height then
         error("Pixel coordinates out of bounds: (" .. x .. ", " .. y .. ")")
     end
 
     local index = y * self.width + x + 1
     local pixel = self.pixels[index]
 
     if not pixel then
         return { r = 0, g = 0, b = 0, a = 0 }
     end
 
     return {
         r = pixel.r,
         g = pixel.g,
         b = pixel.b,
         a = pixel.a
     }
 end
 
 -- Set pixel from RGBA table
 -- @param x X coordinate (0-based)
 -- @param y Y coordinate (0-based)
 -- @param rgba Table with r, g, b, a fields
 function PNGImage:setPixel(x, y, rgba)
     checkPermission()
 
     if not x or not y or not rgba then
         error("setPixel requires x, y, and rgba table")
     end
 
     if x < 0 or x >= self.width or y < 0 or y >= self.height then
         error("Pixel coordinates out of bounds: (" .. x .. ", " .. y .. ")")
     end
 
     local index = y * self.width + x + 1
 
     self.pixels[index] = {
         r = rgba.r or 0,
         g = rgba.g or 0,
         b = rgba.b or 0,
         a = rgba.a or 255
     }
 
     if self.imageBuffer and ImageSetPixel then
         ImageSetPixel(self.imageBuffer, x, y, rgba.r or 0, rgba.g or 0, rgba.b or 0, rgba.a or 255)
     end
 end
 
 -- Fill entire image with a color
 -- @param color Color in hex format "RRGGBB" or "RRGGBBAA"
 function PNGImage:fill(color)
     checkPermission()
 
     for y = 0, self.height - 1 do
         for x = 0, self.width - 1 do
             self:writePixel(x, y, color)
         end
     end
 end
 
 -- Clear image to transparent (or opaque black if no alpha)
 function PNGImage:clear()
     checkPermission()
 
     local clearColor = self.hasAlpha and "00000000" or "000000FF"
     self:fill(clearColor)
 end
 
 -- Get image dimensions
 -- @return width, height
 function PNGImage:getSize()
     return self.width, self.height
 end
 
 -- Get image info
 -- @return Table with width, height, hasAlpha, bpp
 function PNGImage:getInfo()
     return {
         width = self.width,
         height = self.height,
         hasAlpha = self.hasAlpha,
         bpp = self.bpp
     }
 end
 
 -- Draw a rectangle
 -- @param x X coordinate of top-left corner
 -- @param y Y coordinate of top-left corner
 -- @param width Rectangle width
 -- @param height Rectangle height
 -- @param color Fill color
 function PNGImage:fillRect(x, y, width, height, color)
     checkPermission()
 
     for dy = 0, height - 1 do
         for dx = 0, width - 1 do
             local px = x + dx
             local py = y + dy
             if px >= 0 and px < self.width and py >= 0 and py < self.height then
                 self:writePixel(px, py, color)
             end
         end
     end
 end
 
 -- Draw a line (Bresenham's algorithm)
 -- @param x1 Start X
 -- @param y1 Start Y
 -- @param x2 End X
 -- @param y2 End Y
 -- @param color Line color
 function PNGImage:drawLine(x1, y1, x2, y2, color)
     checkPermission()
 
     local dx = math.abs(x2 - x1)
     local dy = math.abs(y2 - y1)
     local sx = x1 < x2 and 1 or -1
     local sy = y1 < y2 and 1 or -1
     local err = dx - dy
 
     while true do
         if x1 >= 0 and x1 < self.width and y1 >= 0 and y1 < self.height then
             self:writePixel(x1, y1, color)
         end
 
         if x1 == x2 and y1 == y2 then
             break
         end
 
         local e2 = 2 * err
         if e2 > -dy then
             err = err - dy
             x1 = x1 + sx
         end
         if e2 < dx then
             err = err + dx
             y1 = y1 + sy
         end
     end
 end
 
 -- Convert to C image buffer (if not already)
 -- @return C image_t userdata or nil
 function PNGImage:toImageBuffer()
     checkPermission()
 
     if self.imageBuffer then
         return self.imageBuffer
     end
 
     if not ImageCreate then
         return nil
     end
 
     -- Create C image buffer
     local img = ImageCreate(self.width, self.height, self.hasAlpha)
 
     if not img then
         return nil
     end
 
     -- Copy all pixels
     if ImageSetPixel then
         for y = 0, self.height - 1 do
             for x = 0, self.width - 1 do
                 local index = y * self.width + x + 1
                 local p = self.pixels[index]
                 ImageSetPixel(img, x, y, p.r, p.g, p.b, p.a)
             end
         end
     end
 
     self.imageBuffer = img
     return img
 end
 
 -- Load PNG from file
 -- @param path Path to PNG file
 -- @return PNG image object or nil on error
 function PNG.load(path)
     checkPermission()
 
     if not CRamdiskExists or not CRamdiskOpen or not CRamdiskRead or not CRamdiskClose then
         error("PNG.load requires ramdisk functions")
     end
 
     if not PNGLoad or not ImageGetWidth or not ImageGetHeight or not ImageGetPixel then
         error("PNG.load requires PNG decoder functions")
     end
 
     if not CRamdiskExists(path) then
         return nil, "File not found: " .. path
     end
 
     local handle = CRamdiskOpen(path, "r")
     if not handle then
         return nil, "Failed to open file: " .. path
     end
 
     local pngData = CRamdiskRead(handle)
     CRamdiskClose(handle)
 
     if not pngData then
         return nil, "Failed to read file: " .. path
     end
 
     -- Decode PNG
     local imgBuffer = PNGLoad(pngData)
     if not imgBuffer then
         return nil, "Failed to decode PNG: " .. path
     end
 
     -- Get dimensions
     local width = ImageGetWidth(imgBuffer)
     local height = ImageGetHeight(imgBuffer)
 
     -- Create PNG object
     local self = setmetatable({}, PNGImage)
     self.width = width
     self.height = height
     self.hasAlpha = true
     self.bpp = 32
     self.pixels = {}
     self.imageBuffer = imgBuffer
 
     -- Read all pixels from C buffer
     for y = 0, height - 1 do
         for x = 0, width - 1 do
             local r, g, b, a = ImageGetPixel(imgBuffer, x, y)
             local index = y * width + x + 1
             self.pixels[index] = {
                 r = r or 0,
                 g = g or 0,
                 b = b or 0,
                 a = a or 255
             }
         end
     end
 
     return self
 end
 
 -- Clone the image
 -- @return New PNG image object with copied pixels
 function PNGImage:clone()
     checkPermission()
 
     local newImg = PNG.new(self.width, self.height, self.hasAlpha)
 
     -- Copy all pixels
     for i = 1, #self.pixels do
         local p = self.pixels[i]
         newImg.pixels[i] = {
             r = p.r,
             g = p.g,
             b = p.b,
             a = p.a
         }
     end
 
     return newImg
 end
 
 return PNG