Question

Here’s what I got so far. I rewrote the code to simplify things a bit. Previous code wasn’t actually the real, basic algorithm. It had fluff that I didn’t need. I answered the question about pitch, and below you’ll see some images of my test results.

local function Line (buf, x1, y1, x2, y2, color, pitch)

    -- identify the first pixel
    local n = x1 + y1 * pitch

    -- // difference between starting and ending points
    local dx = x2 - x1;
    local dy = y2 - y1;

    local m = dy / dx
    local err = m - 1

    if (dx > dy) then   -- // dx is the major axis
        local j = y1
        local i = x1
        while i < x2 do
            buf.buffer[j * pitch + i] = color
            if (err >= 0) then
                i = i + 1
                err = err - 1
            end
            j = j + 1
            err = err + m
        end
    else        -- // dy is the major axis
        local j = x1
        local i = y1
        while i < y2 do
            buf.buffer[i * pitch + j] = color
            if (err >= 0) then
                i = i + 1
                err = err - 1
            end
            j = j + 1
            err = err + m
        end
    end
end


-- (visdata[2][1][576], int isBeat, int *framebuffer, int *fbout, int w, int h
function LibAVSSuperScope:Render(visdata, isBeat, framebuffer, fbout, w, h)
    local size = 5

    Line (self.buffer, 0, 0, 24, 24, 0xffff00, 24)
    do return end
end

Edit: Oh I just realized something. 0,0 is in the lower left-hand corner. So the function’s sort of working, but it’s overlapping and slanted.

Edit2:

Yeah, this whole thing’s broken. I’m plugging numbers into Line() and getting all sort of results. Let me show you some.

Here’s Line (self.buffer, 0, 0, 23, 23, 0x00ffff, 24 * 2)

And here’s Line (self.buffer, 0, 1, 23, 23, 0x00ffff, 24 * 2)

Edit: Wow, doing Line (self.buffer, 0, 24, 24, 24, 0x00ffff, 24 * 2) uses way too much CPU time.

Edit: Here’s another image using this algorithm. The yellow dots are starting points.

Line (self.buffer, 0, 0, 24, 24, 0xff0000, 24)
Line (self.buffer, 0, 12, 23, 23, 0x00ff00, 24)
Line (self.buffer, 12, 0, 23, 23, 0x0000ff, 24)

Edit: And yes, that blue line wraps around.

Answer 1

This is what I settled on. I just had to find valid information on that Bresenham algorithm. Thanks cs-unc for the information about various line algorithms, from simple to complex.

function LibBuffer:Line4(x0, y0, x1, y1, color, pitch)
    local dx = x1 - x0;
    local dy = y1 - y0;
    local stepx, stepy

    if dy < 0 then
        dy = -dy
        stepy = -1
    else
        stepy = 1
    end

    if dx < 0 then
        dx = -dx
        stepx = -1
    else
        stepx = 1
    end

    self.buffer[x0 + y0 * pitch] = color
    if dx > dy then
        local fraction = dy - bit.rshift(dx, 1)
        while x0 ~= x1 do
            if fraction >= 0 then
                y0 = y0 + stepy
                fraction = fraction - dx
            end
            x0 = x0 + stepx
            fraction = fraction + dy
            self.buffer[floor(y0) * pitch + floor(x0)] = color
        end
    else
        local fraction = dx - bit.rshift(dy, 1)
        while y0 ~= y1 do
            if fraction >= 0 then
                x0 = x0 + stepx
                fraction = fraction - dy
            end
            y0 = y0 + stepy
            fraction = fraction + dx
            self.buffer[floor(y0) * pitch + floor(x0)] = color
        end
    end
end

Here’s what this one looks like.