luajitos

Gfx.lua (12925B)

---

 -- Graphics Library for LuajitOS
 -- Provides high-level drawing functions using VGA Mode 13h (320x200, 256 colors)
 
 local gfx = {}
 
 -- Graphics mode enum
 gfx.MODE_VGA = 0
 gfx.MODE_VESA = 1
 
 -- Screen dimensions (default to VGA)
 gfx.WIDTH = 320
 gfx.HEIGHT = 200
 
 -- Graphics mode state
 gfx.enabled = false
 gfx.currentMode = gfx.MODE_VGA  -- Default to VGA Mode 13h
 
 -- Draw operation type constants
 local PIXEL = 0
 local RECT = 1
 local RECT_FILL = 2
 local CIRCLE = 3
 local CIRCLE_FILL = 4
 local TRIANGLE = 5
 local TRIANGLE_FILL = 6
 local POLYGON = 7
 local POLYGON_FILL = 8
 local LINE = 9
 
 -- Buffer state
 gfx.buffer = {
     enable = false,
     operations = {}
 }
 
 -- Helper function to clamp coordinates
 local function clamp(val, min, max)
     if val < min then return min end
     if val > max then return max end
     return val
 end
 
 -- Draw a single pixel
 function gfx.pixel(x, y, color)
     if gfx.buffer.enable then
         table.insert(gfx.buffer.operations, {PIXEL, x, y, color})
     else
         SetPixel(x, y, color)
     end
 end
 
 -- Draw a filled rectangle
 function gfx.fillRect(x, y, width, height, color)
     if gfx.buffer.enable then
         table.insert(gfx.buffer.operations, {RECT_FILL, x, y, width, height, color})
     else
         DrawRect(x, y, width, height, color)
     end
 end
 
 -- Draw a line using Bresenham's algorithm
 function gfx.line(x0, y0, x1, y1, color, thickness)
     thickness = thickness or 1
 
     if gfx.buffer.enable then
         -- Buffer as a single LINE operation
         table.insert(gfx.buffer.operations, {LINE, x0, y0, x1, y1, color, thickness})
     else
         local dx = x1 - x0
         local dy = y1 - y0
 
         -- Handle vertical and horizontal lines specially for thickness
         if dx == 0 then
             -- Vertical line
             local startY = y0 < y1 and y0 or y1
             local endY = y0 < y1 and y1 or y0
             for ty = startY, endY do
                 for tx = 0, thickness - 1 do
                     SetPixel(x0 + tx, ty, color)
                 end
             end
             return
         end
 
         if dy == 0 then
             -- Horizontal line
             local startX = x0 < x1 and x0 or x1
             local endX = x0 < x1 and x1 or x0
             for tx = startX, endX do
                 for ty = 0, thickness - 1 do
                     SetPixel(tx, y0 + ty, color)
                 end
             end
             return
         end
 
         -- Bresenham's line algorithm
         local dx_abs = dx < 0 and -dx or dx
         local dy_abs = dy < 0 and -dy or dy
         local sx = dx > 0 and 1 or -1
         local sy = dy > 0 and 1 or -1
         local err = dx_abs - dy_abs
 
         local x = x0
         local y = y0
 
         while true do
             -- Draw with thickness
             for ty = 0, thickness - 1 do
                 for tx = 0, thickness - 1 do
                     SetPixel(x + tx, y + ty, color)
                 end
             end
 
             if x == x1 and y == y1 then break end
 
             local e2 = 2 * err
             if e2 > -dy_abs then
                 err = err - dy_abs
                 x = x + sx
             end
             if e2 < dx_abs then
                 err = err + dx_abs
                 y = y + sy
             end
         end
     end
 end
 
 -- Draw an outlined rectangle
 function gfx.rect(x, y, width, height, color, thickness)
     thickness = thickness or 1
 
     if gfx.buffer.enable then
         table.insert(gfx.buffer.operations, {RECT, x, y, width, height, color, thickness})
     else
         -- Top and bottom edges
         for i = 0, thickness - 1 do
             DrawRect(x, y + i, width, 1, color)
             DrawRect(x, y + height - 1 - i, width, 1, color)
         end
 
         -- Left and right edges
         for i = 0, thickness - 1 do
             DrawRect(x + i, y, 1, height, color)
             DrawRect(x + width - 1 - i, y, 1, height, color)
         end
     end
 end
 
 -- Draw a filled circle using midpoint algorithm
 function gfx.fillCircle(cx, cy, radius, color)
     if gfx.buffer.enable then
         table.insert(gfx.buffer.operations, {CIRCLE_FILL, cx, cy, radius, color})
     else
         local x = radius
         local y = 0
         local err = 0
 
         while x >= y do
             -- Draw horizontal lines for each octant
             DrawRect(cx - x, cy + y, 2 * x + 1, 1, color)
             DrawRect(cx - x, cy - y, 2 * x + 1, 1, color)
             DrawRect(cx - y, cy + x, 2 * y + 1, 1, color)
             DrawRect(cx - y, cy - x, 2 * y + 1, 1, color)
 
             y = y + 1
             err = err + 1 + 2 * y
             if 2 * (err - x) + 1 > 0 then
                 x = x - 1
                 err = err + 1 - 2 * x
             end
         end
     end
 end
 
 -- Draw an outlined circle using midpoint algorithm
 function gfx.circle(cx, cy, radius, color, thickness)
     thickness = thickness or 1
 
     if gfx.buffer.enable then
         table.insert(gfx.buffer.operations, {CIRCLE, cx, cy, radius, color, thickness})
     else
         for t = 0, thickness - 1 do
             local r = radius - t
             if r < 0 then break end
 
             local x = r
             local y = 0
             local err = 0
 
             while x >= y do
                 -- Draw 8 symmetric points
                 SetPixel(cx + x, cy + y, color)
                 SetPixel(cx + y, cy + x, color)
                 SetPixel(cx - y, cy + x, color)
                 SetPixel(cx - x, cy + y, color)
                 SetPixel(cx - x, cy - y, color)
                 SetPixel(cx - y, cy - x, color)
                 SetPixel(cx + y, cy - x, color)
                 SetPixel(cx + x, cy - y, color)
 
                 y = y + 1
                 err = err + 1 + 2 * y
                 if 2 * (err - x) + 1 > 0 then
                     x = x - 1
                     err = err + 1 - 2 * x
                 end
             end
         end
     end
 end
 
 -- Draw a filled triangle
 function gfx.fillTriangle(x0, y0, x1, y1, x2, y2, color)
     if gfx.buffer.enable then
         table.insert(gfx.buffer.operations, {TRIANGLE_FILL, x0, y0, x1, y1, x2, y2, color})
     else
         -- Sort vertices by y-coordinate (y0 <= y1 <= y2)
         if y0 > y1 then
             x0, y0, x1, y1 = x1, y1, x0, y0
         end
         if y0 > y2 then
             x0, y0, x2, y2 = x2, y2, x0, y0
         end
         if y1 > y2 then
             x1, y1, x2, y2 = x2, y2, x1, y1
         end
 
         -- Draw flat-bottom triangle (y0 to y1)
         if y1 - y0 > 0 then
             local invslope1 = (x1 - x0) / (y1 - y0)
             local invslope2 = (x2 - x0) / (y2 - y0)
             local curx1 = x0
             local curx2 = x0
 
             for scanlineY = y0, y1 do
                 local startX = curx1 < curx2 and curx1 or curx2
                 local endX = curx1 < curx2 and curx2 or curx1
                 DrawRect(startX, scanlineY, endX - startX + 1, 1, color)
                 curx1 = curx1 + invslope1
                 curx2 = curx2 + invslope2
             end
         end
 
         -- Draw flat-top triangle (y1 to y2)
         if y2 - y1 > 0 then
             local invslope1 = (x2 - x1) / (y2 - y1)
             local invslope2 = (x2 - x0) / (y2 - y0)
             local curx1 = x1
             local curx2 = x0 + (y1 - y0) * ((x2 - x0) / (y2 - y0))
 
             for scanlineY = y1, y2 do
                 local startX = curx1 < curx2 and curx1 or curx2
                 local endX = curx1 < curx2 and curx2 or curx1
                 DrawRect(startX, scanlineY, endX - startX + 1, 1, color)
                 curx1 = curx1 + invslope1
                 curx2 = curx2 + invslope2
             end
         end
     end
 end
 
 -- Draw an outlined triangle
 function gfx.triangle(x0, y0, x1, y1, x2, y2, color, thickness)
     thickness = thickness or 1
     if gfx.buffer.enable then
         table.insert(gfx.buffer.operations, {TRIANGLE, x0, y0, x1, y1, x2, y2, color, thickness})
     else
         gfx.line(x0, y0, x1, y1, color, thickness)
         gfx.line(x1, y1, x2, y2, color, thickness)
         gfx.line(x2, y2, x0, y0, color, thickness)
     end
 end
 
 -- Draw a filled polygon (arbitrary number of vertices)
 function gfx.fillPolygon(vertices, color)
     if #vertices < 3 then return end
 
     if gfx.buffer.enable then
         -- Store polygon vertices as flat array: {POLYGON_FILL, numVertices, x1, y1, x2, y2, ..., color}
         local operation = {POLYGON_FILL, #vertices}
         for i = 1, #vertices do
             table.insert(operation, vertices[i].x)
             table.insert(operation, vertices[i].y)
         end
         table.insert(operation, color)
         table.insert(gfx.buffer.operations, operation)
     else
         -- Find min and max Y
         local minY = vertices[1].y
         local maxY = vertices[1].y
         for i = 1, #vertices do
             if vertices[i].y < minY then minY = vertices[i].y end
             if vertices[i].y > maxY then maxY = vertices[i].y end
         end
 
         -- Scanline fill
         for y = minY, maxY do
             local intersections = {}
 
             -- Find intersections with all edges
             for i = 1, #vertices do
                 local j = (i % #vertices) + 1
                 local x1, y1 = vertices[i].x, vertices[i].y
                 local x2, y2 = vertices[j].x, vertices[j].y
 
                 if (y1 <= y and y < y2) or (y2 <= y and y < y1) then
                     -- Calculate x intersection
                     local x = x1 + (y - y1) * (x2 - x1) / (y2 - y1)
                     table.insert(intersections, x)
                 end
             end
 
             -- Sort intersections
             table.sort(intersections)
 
             -- Fill between pairs
             for i = 1, #intersections - 1, 2 do
                 local startX = intersections[i]
                 local endX = intersections[i + 1]
                 if endX >= startX then
                     DrawRect(startX, y, endX - startX + 1, 1, color)
                 end
             end
         end
     end
 end
 
 -- Draw an outlined polygon
 function gfx.polygon(vertices, color, thickness)
     if #vertices < 2 then return end
     thickness = thickness or 1
 
     if gfx.buffer.enable then
         -- Store polygon vertices as flat array: {POLYGON, numVertices, x1, y1, x2, y2, ..., color, thickness}
         local operation = {POLYGON, #vertices}
         for i = 1, #vertices do
             table.insert(operation, vertices[i].x)
             table.insert(operation, vertices[i].y)
         end
         table.insert(operation, color)
         table.insert(operation, thickness)
         table.insert(gfx.buffer.operations, operation)
     else
         for i = 1, #vertices do
             local j = (i % #vertices) + 1
             gfx.line(vertices[i].x, vertices[i].y, vertices[j].x, vertices[j].y, color, thickness)
         end
     end
 end
 
 -- Clear screen
 function gfx.clear(color)
     ClearScreen(color or 0)
 end
 
 -- Enter graphics mode (VGA Mode 13h - 320x200)
 function gfx.init()
     EnterGraphicsMode()
     gfx.enabled = true
     gfx.currentMode = gfx.MODE_VGA
     gfx.WIDTH = 320
     gfx.HEIGHT = 200
 end
 
 -- Enter VESA mode with specified resolution
 -- Falls back to VGA if VESA initialization fails
 function gfx.initVESA(width, height, bpp)
     width = width or 1024
     height = height or 768
     bpp = bpp or 32
 
     -- Try to initialize VESA mode
     local success = VESASetMode(width, height, bpp)
 
     if success then
         gfx.enabled = true
         gfx.currentMode = gfx.MODE_VESA
         gfx.WIDTH = width
         gfx.HEIGHT = height
         gfx.BPP = bpp
         return true
     else
         -- Fallback to VGA Mode 13h
         osprint("VESA initialization failed, falling back to VGA Mode 13h\n")
         gfx.init()
         return false
     end
 end
 
 -- Exit graphics mode
 function gfx.close()
     if gfx.currentMode == gfx.MODE_VESA then
         -- VESA mode - no specific exit needed, just clear state
         gfx.enabled = false
         gfx.currentMode = gfx.MODE_VGA
     else
         -- VGA Mode 13h
         ExitGraphicsMode()
         gfx.enabled = false
     end
 end
 
 -- Check if currently using VESA mode
 function gfx.isVESA()
     return gfx.currentMode == gfx.MODE_VESA
 end
 
 -- Get current mode info
 function gfx.getModeInfo()
     if gfx.currentMode == gfx.MODE_VESA then
         return VESAGetModeInfo()
     else
         return {
             width = 320,
             height = 200,
             bpp = 8,
             mode = "VGA Mode 13h"
         }
     end
 end
 
 -- Draw all buffered operations and clear the buffer
 function gfx.buffer.drawAll()
     if #gfx.buffer.operations > 0 then
         -- Call appropriate C function based on current mode
         if gfx.currentMode == gfx.MODE_VESA then
             VESAProcessBufferedDrawOps(gfx.buffer.operations)
         else
             ProcessBufferedDrawOps(gfx.buffer.operations)
         end
         -- Clear the buffer
         gfx.buffer.operations = {}
     end
 end
 
 -- Clear the buffer without drawing
 function gfx.buffer.clear()
     gfx.buffer.operations = {}
 end
 
 return gfx