JIG3D_AP_API_v1.0

-- AR tools API

local function interpolate(p1x,p1y,p2x,p2y,x)
    return p1y + ( ((p2y-p1y)/(p2x-p1x)) * (x-p1x) )
end

--Draws a line from x1,y1 to x2,y2 with given color, using name of wrapped AR controller
--Draws a line from x1,y1 to x2,y2 with given color, using name of wrapped AR controller
local function drawLineAR(arController,x1,y1,x2,y2,color,zBuffer)
    color = 0x000000 --Overriding color to black. Comment out to use custom colors
    local dx = x2 - x1
    local dy = y2 - y1
    --local zBufOffset = y*sx
    local length = math.floor(math.sqrt((dx^2)+(dy^2)))

    for i = 1, length do
        local nextY = y1 + dy * (i / length)
        local nextX = x1 + dx * (i / length)

        --[[if nextY > 0 and nextX > 0 then
            local zI = zBufOffset + x
            local newZ = interpolate(xStart,zStart,xEnd,zEnd,x)

            if newZ < zBuffer[ zI ] then]]
                --zBuffer[ zI ] = newZ
                arController.horizontalLine(nextX, nextX, nextY, color)
            --end
        --end
    end
end

--Draws an object with an indexList which points to a list x/y points, using name of wrapped AR controller
local function drawWireObj(arController,vL) --vL == vertice list. cL == color list
    local cL = vL.colorList
    for i = 1, #vL, 3 do --Draws a whole triangle per loop
        local i1,i2 = i+1, i+2
        local col = cL[(i+2)/3]
        drawLineAR(arController, vL[i].x,  vL[i].y,  vL[i1].x, vL[i1].y, col) --vert 1 to 2
        drawLineAR(arController, vL[i1].x, vL[i1].y, vL[i2].x, vL[i2].y, col) --vert 2 to 3
        drawLineAR(arController, vL[i2].x, vL[i2].y, vL[i].x,  vL[i].y, col) --vert 3 to 1
    end
end

--Basically a line function with cutoffs for anything < 0.
local function drawFlatTriangle(arController,px1,px2,pz1,pz2,y,color,zBuffer)
    local zBufOffset = y*zBuffer.size.x

    local xStart = math.ceil(px1 - 0.5)
    local xEnd =   math.ceil(px2 - 0.5)

    local zStart = math.ceil(pz1 - 0.5)
    local zEnd = math.ceil(pz2 - 0.5)

    if y > 0 and xEnd > 0 then
        if xStart < 0 then
            xStart = 0
        end

        for x = xStart, xEnd do
            local zI = zBufOffset + x
            local newZ = interpolate(xStart,zStart,xEnd,zEnd,x)

            if newZ < zBuffer[ zI ] then
                zBuffer[ zI ] = newZ
                arController.horizontalLine(x, x, y, color)
            end
        end
    end
end

--Both draw flat top and bottom draw an entire line at a time instead of each pixel individually b/c performance. Will add individual pixel support later.
local function drawFlatTopTriangle( arController,vec1,vec2,vec3,color,zBuffer )
    --Calculate slopes in screen space
    --Run over rise so we don't get infinite slopes
    local m1 = (vec3.x - vec1.x) / (vec3.y - vec1.y)
    local m2 = (vec3.x - vec2.x) / (vec3.y - vec2.y)

    local zm1 = (vec2.z - vec1.z) / (vec2.y - vec1.y) --left line
    local zm2 = (vec3.z - vec1.z) / (vec3.y - vec1.y) --right line

    --Calculate start and end scanlines
    local yStart = math.ceil(vec1.y - 0.5)
    local yEnd =   math.ceil(vec3.y - 0.5)-1 --the scanline AFTER the last line drawn, which is why it's offset by -1

    for y = yStart, yEnd do
        --calculate start and end x's
        --Add 0.5 because we're calculating based on pixel centers
        local px1 = m1 * (y + 0.5 - vec1.y) + vec1.x
        local px2 = m2 * (y + 0.5 - vec2.y) + vec2.x

        local pz1 = zm1 * (y + 0.5 - vec1.y) + vec1.z
        local pz2 = zm2 * (y + 0.5 - vec1.y) + vec1.z

        drawFlatTriangle( arController,px1,px2,pz1,pz2,y,color,zBuffer )
    end
end

local function drawFlatBottomTriangle( arController,vec1,vec2,vec3,color,zBuffer )
    --Calculate slopes in screen space
    local m1 = (vec2.x - vec1.x) / (vec2.y - vec1.y)
    local m2 = (vec3.x - vec1.x) / (vec3.y - vec1.y)

    local zm1 = (vec2.z - vec1.z) / (vec2.y - vec1.y) --left line
    local zm2 = (vec3.z - vec1.z) / (vec3.y - vec1.y) --right line

    --Calculate start and end scanlines
    local yStart = math.ceil(vec1.y-0.5)
    local yEnd =   math.ceil(vec3.y-0.5)-1 --the scanline AFTER the last line drawn, which is why we need to subtract 1 otherwise we get visual bugs

    for y = yStart, yEnd do

        --calculate start and end points (x/z coords)
        --Add 0.5 because we're calculating based on pixel centers
        local px1 = m1 * (y + 0.5 - vec1.y) + vec1.x
        local px2 = m2 * (y + 0.5 - vec1.y) + vec1.x

        local pz1 = zm1 * (y + 0.5 - vec1.y) + vec1.z
        local pz2 = zm2 * (y + 0.5 - vec1.y) + vec1.z

        drawFlatTriangle( arController,px1,px2,pz1,pz2,y,color,zBuffer )
    end
end

--Draws a solid triangle from 3 vectors
local function drawSolidTriangle( arController,vec1,vec2,vec3,color,zBuffer )

    --using pointers so we can swap (for sorting purposes) probably don't need this b/c lua? idk
    local pv1 = vec1
    local pv2 = vec2
    local pv3 = vec3

    --Sort vertices by y
    if pv2.y < pv1.y then pv1,pv2 = pv2,pv1 end
    if pv3.y < pv2.y then pv2,pv3 = pv3,pv2 end
    if pv2.y < pv1.y then pv1,pv2 = pv2,pv1 end

    if pv1.y == pv2.y then --Natural flat top
        --Sort top vertice by x
        if pv2.x < pv1.x then pv1,pv2 = pv2,pv1 end
        drawFlatTopTriangle(arController,pv1,pv2,pv3,color,zBuffer )

    elseif pv2.y == pv3.y then --Natural flat bottom
        --Sort bottom vertice by x
        if pv3.x < pv2.x then pv3,pv2 = pv2,pv3 end
        drawFlatBottomTriangle(arController,pv1,pv2,pv3,color,zBuffer )

    else --General triangle
        local alphaSplit = (pv2.y-pv1.y)/(pv3.y-pv1.y)
        local vi ={
            x = pv1.x + ((pv3.x - pv1.x) * alphaSplit),
            y = pv1.y + ((pv3.y - pv1.y) * alphaSplit),
            z = pv1.z + ((pv3.z - pv1.z) * alphaSplit) }
        if pv2.x < vi.x then --Major right
            drawFlatBottomTriangle(arController,pv1,pv2,vi,color,zBuffer)
            drawFlatTopTriangle(arController,pv2,vi,pv3,color,zBuffer)
        else --Major left
            drawFlatBottomTriangle(arController,pv1,vi,pv2,color,zBuffer)
            drawFlatTopTriangle(arController,vi,pv2,pv3,color,zBuffer)
        end
    end
end

--Draw an entire object one triangle at a time
--Converts points from the 1D table to vectors b/c I'm lazy
local function drawSolidObj( arController, iL, zBuffer) --iL == index List. vL == vertex list. cL == color list
    local cL = iL.colorList
        --OPTIMIZATION here?. Probably should convert to 1D at least
    for i = 1, #iL, 3 do --Try to draw a triangle
        drawSolidTriangle( arController, iL[i], iL[i+1], iL[i+2], cL[(i+2)/3], zBuffer )
    end
end

--Expose functions
return
{
    drawWireObj = drawWireObj,
    drawSolidObj = drawSolidObj,
}