-- rspr.lua
function rspr(sprite,cx,cy,sx,sy,rot)
    sx = sx and sx or 1
    sy = sy and sy or 1
    rot = rot and rot or 0
    local tex = get_spr(sprite)
    local dx,dy = tex:width()*sx,tex:height()*sy
    quad = {
        {x=0, y=0, u=0, v=0},
        {x=dx, y=0, u=tex:width()-0.001, v=0},
        {x=dx, y=dy, u=tex:width()-0.001, v=tex:height()-0.001},
        {x=0, y=dy, u=0, v=tex:height()-0.001},
    }
    local c,s = cos(rot),-sin(rot)
    local w,h = (dx-1)/2, (dy-1)/2
    for _,v in pairs(quad) do
        local x,y = v.x-w,v.y-h
        v.x = c*x-s*y
        v.y = s*x+c*y   
    end
    tquad(quad, tex, cx, cy)
end

function tquad(coords,tex,dx,dy)
    local screen_max = get_display():height()-1
    local p0,spans = coords[#coords],{}
    local x0,y0,u0,v0=p0.x+dx,p0.y+dy,p0.u,p0.v
    for i=1,#coords do
        local p1 = coords[i]
        local x1,y1,u1,v1=p1.x+dx,p1.y+dy,p1.u,p1.v
        local _x1,_y1,_u1,_v1=x1,y1,u1,v1
        if(y0>y1) x0,y0,x1,y1,u0,v0,u1,v1=x1,y1,x0,y0,u1,v1,u0,v0
        local dy=y1-y0
        local dx,du,dv=(x1-x0)/dy,(u1-u0)/dy,(v1-v0)/dy
        if(y0<0) x0-=y0*dx u0-=y0*du v0-=y0*dv y0=0
        local cy0=ceil(y0)
        local sy=cy0-y0
        x0+=sy*dx
        u0+=sy*du
        v0+=sy*dv
        for y=cy0,min(ceil(y1)-1,screen_max) do
            local span=spans[y]
            if span then tline3d(tex,span.x,y,x0,y,span.u,span.v,u0,v0)
            else spans[y]={x=x0,u=u0,v=v0} end
            x0+=dx
            u0+=du
            v0+=dv
        end
        x0,y0,u0,v0=_x1,_y1,_u1,_v1
    end
end

-- rspr - draw a rotated sprite
-- param: sprite - the number of the sprite to read from the spritesheet
-- param: cx - the x-coordinate on which to render the sprite (center of the sprite, not top-left)
-- param: cy - the y-coordinate on which to render the sprite (center of the sprite, not top-left)
-- param: sx - scale factor in the x direction
-- param: sy - scale factor in the y direction
-- param: rot - the angle to render the sprite [0-1)
function rspr(sprite,cx,cy,sx,sy,rot)
    -- get default values
    sx = sx and sx or 1
    sy = sy and sy or 1
    rot = rot and rot or 0

    -- get sprite userdata and sprite dimensions
    local tex = get_spr(sprite)
    local dx,dy = tex:width()*sx,tex:height()*sy

    -- create a polygon of 4 points that will represent the corners of the rendered sprite
    -- we subtract an arbitrarily small amount from the texture to prevent artifacting (tline3d bug)
    quad = {
        {x=0, y=0, u=0, v=0},
        {x=dx, y=0, u=tex:width()-0.001, v=0},
        {x=dx, y=dy, u=tex:width()-0.001, v=tex:height()-0.001},
        {x=0, y=dy, u=0, v=tex:height()-0.001},
    }

    -- calculate cosine and sine, as well as the center point for the sprite
    local c,s = cos(rot),-sin(rot)
    local w,h = (dx-1)/2, (dy-1)/2

    -- rotate each point in the quad
    for _,v in pairs(quad) do
        local x,y = v.x-w,v.y-h
        v.x = c*x-s*y
        v.y = s*x+c*y   
    end

    -- render the quad to the display
    tquad(quad, tex, cx, cy)
end

-- tquad - render a textured quadrilateral. based on @fred72's implementation here: https://www.lexaloffle.com/bbs/?tid=37561
-- param: coords - a table with 4 subtables. each subtable has values for x, y, u, v
-- param: tex - a bitmap userdata that represents the texture to render
-- param: dx, dy - the center of the quad on screen
function tquad(coords,tex,dx,dy)
    -- what is the max y value that will get rendered? use this to cull unnecessary draw ops
    local screen_max = get_display():height()-1
    -- load the first set of points into the p0 table
    local p0,spans = coords[#coords],{}
    -- extract coordinates, offset by the desired position
    local x0,y0,u0,v0=p0.x+dx,p0.y+dy,p0.u,p0.v

    -- loop through the polygon's vertices
    for i=1,#coords do
        -- get the next vertex from the list
        local p1 = coords[i]
        -- extract coordinates, offset by desired position
        local x1,y1,u1,v1=p1.x+dx,p1.y+dy,p1.u,p1.v
        -- save those coordinate values to restore later
        local _x1,_y1,_u1,_v1=x1,y1,u1,v1
        -- swap coordinate pairs if they are out of order (with respect to y)
        if(y0>y1) x0,y0,x1,y1,u0,v0,u1,v1=x1,y1,x0,y0,u1,v1,u0,v0
        -- get the difference between y0 and y1
        local dy=y1-y0
        -- get the change in x,u,v based on the slope of y
        local dx,du,dv=(x1-x0)/dy,(u1-u0)/dy,(v1-v0)/dy
        -- cull our calculations to not go above y=0 to save CPU
        if(y0<0) x0-=y0*dx u0-=y0*du v0-=y0*dv y0=0
        -- snap y0 to a pixel value
        local cy0=ceil(y0)
        -- get the fractional difference between y0 and cy0
        local sy=cy0-y0
        -- adjust x,u,v by the fractional offset
        x0+=sy*dx
        u0+=sy*du
        v0+=sy*dv
        -- loop through all of the horizontal rows that we need to draw to make the rotated shape
        -- we stop at screen_max if the sprite goes off screen to save CPU
        for y=cy0,min(ceil(y1)-1,screen_max) do
            -- a "span" is a row of pixels that we'll draw. attempt to get the span that we saved for this y-value from the list
            local span=spans[y]
            -- if we found a span, then draw a horizontal line across the span, sampling the texture from the sprite provided
            if span then tline3d(tex,span.x,y,x0,y,span.u,span.v,u0,v0)
            -- if we didn't find a span, add one to the list
            else spans[y]={x=x0,u=u0,v=v0} end
            -- add the change-in values to each coordinate based on the slope of y
            x0+=dx
            u0+=du
            v0+=dv
        end
        -- restore coordinates to prepare for the next loop
        x0,y0,u0,v0=_x1,_y1,_u1,_v1
    end
end