path: root/src/GPU3D_Soft.cpp

/*
    Copyright 2016-2017 StapleButter

    This file is part of melonDS.

    melonDS is free software: you can redistribute it and/or modify it under
    the terms of the GNU General Public License as published by the Free
    Software Foundation, either version 3 of the License, or (at your option)
    any later version.

    melonDS is distributed in the hope that it will be useful, but WITHOUT ANY
    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

    You should have received a copy of the GNU General Public License along
    with melonDS. If not, see http://www.gnu.org/licenses/.
*/

#include <stdio.h>
#include <string.h>
#include "NDS.h"
#include "GPU.h"


namespace GPU3D
{
namespace SoftRenderer
{

u32 ColorBuffer[256*192];
u32 DepthBuffer[256*192];
u32 AttrBuffer[256*192];

// attribute buffer:
// bit0-5: polygon ID
// bit8: fog enable


bool Init()
{
    return true;
}

void DeInit()
{
}

void Reset()
{
    memset(ColorBuffer, 0, 256*192 * 4);
    memset(DepthBuffer, 0, 256*192 * 4);
    memset(AttrBuffer, 0, 256*192 * 4);
}


void TextureLookup(u32 texparam, u32 texpal, s16 s, s16 t, u16* color, u8* alpha)
{
    u32 vramaddr = (texparam & 0xFFFF) << 3;

    u32 width = 8 << ((texparam >> 20) & 0x7);
    u32 height = 8 << ((texparam >> 23) & 0x7);

    s >>= 4;
    t >>= 4;

    // texture wrapping
    // TODO: optimize this somehow

    if (texparam & (1<<16))
    {
        if (texparam & (1<<18))
        {
            if (s & width) s = (width-1) - (s & (width-1));
            else           s = (s & (width-1));
        }
        else
            s &= width-1;
    }
    else
    {
        if (s < 0) s = 0;
        else if (s >= width) s = width-1;
    }

    if (texparam & (1<<17))
    {
        if (texparam & (1<<19))
        {
            if (t & height) t = (height-1) - (t & (height-1));
            else            t = (t & (height-1));
        }
        else
            t &= height-1;
    }
    else
    {
        if (t < 0) t = 0;
        else if (t >= height) t = height-1;
    }

    u8 alpha0;
    if (texparam & (1<<29)) alpha0 = 0;
    else                    alpha0 = 31;

    switch ((texparam >> 26) & 0x7)
    {
    case 1: // A3I5
        {
            vramaddr += ((t * width) + s);
            u8 pixel = GPU::ReadVRAM_Texture<u8>(vramaddr);

            texpal <<= 4;
            *color = GPU::ReadVRAM_TexPal<u16>(texpal + ((pixel&0x1F)<<1));
            *alpha = ((pixel >> 3) & 0x1C) + (pixel >> 6);
        }
        break;

    case 2: // 4-color
        {
            vramaddr += (((t * width) + s) >> 2);
            u8 pixel = GPU::ReadVRAM_Texture<u8>(vramaddr);
            pixel >>= ((s & 0x3) << 1);
            pixel &= 0x3;

            texpal <<= 3;
            *color = GPU::ReadVRAM_TexPal<u16>(texpal + (pixel<<1));
            *alpha = (pixel==0) ? alpha0 : 31;
        }
        break;

    case 3: // 16-color
        {
            vramaddr += (((t * width) + s) >> 1);
            u8 pixel = GPU::ReadVRAM_Texture<u8>(vramaddr);
            if (s & 0x1) pixel >>= 4;
            else         pixel &= 0xF;

            texpal <<= 4;
            *color = GPU::ReadVRAM_TexPal<u16>(texpal + (pixel<<1));
            *alpha = (pixel==0) ? alpha0 : 31;
        }
        break;

    case 4: // 256-color
        {
            vramaddr += ((t * width) + s);
            u8 pixel = GPU::ReadVRAM_Texture<u8>(vramaddr);

            texpal <<= 4;
            *color = GPU::ReadVRAM_TexPal<u16>(texpal + (pixel<<1));
            *alpha = (pixel==0) ? alpha0 : 31;
        }
        break;

    case 5: // compressed
        {
            vramaddr += ((t & 0x3FC) * (width>>2)) + (s & 0x3FC);
            vramaddr += (t & 0x3);

            u32 slot1addr = 0x20000 + ((vramaddr & 0x1FFFC) >> 1);
            if (vramaddr >= 0x40000)
                slot1addr += 0x10000;

            u8 val = GPU::ReadVRAM_Texture<u8>(vramaddr);
            val >>= (2 * (s & 0x3));

            u16 palinfo = GPU::ReadVRAM_Texture<u16>(slot1addr);
            u32 paloffset = (palinfo & 0x3FFF) << 2;
            texpal <<= 4;

            switch (val & 0x3)
            {
            case 0:
                *color = GPU::ReadVRAM_TexPal<u16>(texpal + paloffset);
                *alpha = 31;
                break;

            case 1:
                *color = GPU::ReadVRAM_TexPal<u16>(texpal + paloffset + 2);
                *alpha = 31;
                break;

            case 2:
                if ((palinfo >> 14) == 1)
                {
                    u16 color0 = GPU::ReadVRAM_TexPal<u16>(texpal + paloffset);
                    u16 color1 = GPU::ReadVRAM_TexPal<u16>(texpal + paloffset + 2);

                    u32 r0 = color0 & 0x001F;
                    u32 g0 = color0 & 0x03E0;
                    u32 b0 = color0 & 0x7C00;
                    u32 r1 = color1 & 0x001F;
                    u32 g1 = color1 & 0x03E0;
                    u32 b1 = color1 & 0x7C00;

                    u32 r = (r0 + r1) >> 1;
                    u32 g = ((g0 + g1) >> 1) & 0x03E0;
                    u32 b = ((b0 + b1) >> 1) & 0x7C00;

                    *color = r | g | b;
                }
                else if ((palinfo >> 14) == 3)
                {
                    u16 color0 = GPU::ReadVRAM_TexPal<u16>(texpal + paloffset);
                    u16 color1 = GPU::ReadVRAM_TexPal<u16>(texpal + paloffset + 2);

                    u32 r0 = color0 & 0x001F;
                    u32 g0 = color0 & 0x03E0;
                    u32 b0 = color0 & 0x7C00;
                    u32 r1 = color1 & 0x001F;
                    u32 g1 = color1 & 0x03E0;
                    u32 b1 = color1 & 0x7C00;

                    u32 r = (r0*5 + r1*3) >> 3;
                    u32 g = ((g0*5 + g1*3) >> 3) & 0x03E0;
                    u32 b = ((b0*5 + b1*3) >> 3) & 0x7C00;

                    *color = r | g | b;
                }
                else
                    *color = GPU::ReadVRAM_TexPal<u16>(texpal + paloffset + 4);
                *alpha = 31;
                break;

            case 3:
                if ((palinfo >> 14) == 2)
                {
                    *color = GPU::ReadVRAM_TexPal<u16>(texpal + paloffset + 6);
                    *alpha = 31;
                }
                else if ((palinfo >> 14) == 3)
                {
                    u16 color0 = GPU::ReadVRAM_TexPal<u16>(texpal + paloffset);
                    u16 color1 = GPU::ReadVRAM_TexPal<u16>(texpal + paloffset + 2);

                    u32 r0 = color0 & 0x001F;
                    u32 g0 = color0 & 0x03E0;
                    u32 b0 = color0 & 0x7C00;
                    u32 r1 = color1 & 0x001F;
                    u32 g1 = color1 & 0x03E0;
                    u32 b1 = color1 & 0x7C00;

                    u32 r = (r0*3 + r1*5) >> 3;
                    u32 g = ((g0*3 + g1*5) >> 3) & 0x03E0;
                    u32 b = ((b0*3 + b1*5) >> 3) & 0x7C00;

                    *color = r | g | b;
                    *alpha = 31;
                }
                else
                {
                    *color = 0;
                    *alpha = 0;
                }
                break;
            }
        }
        break;

    case 6: // A5I3
        {
            vramaddr += ((t * width) + s);
            u8 pixel = GPU::ReadVRAM_Texture<u8>(vramaddr);

            texpal <<= 4;
            *color = GPU::ReadVRAM_TexPal<u16>(texpal + ((pixel&0x7)<<1));
            *alpha = (pixel >> 3);
        }
        break;

    case 7: // direct color
        {
            vramaddr += (((t * width) + s) << 1);
            *color = GPU::ReadVRAM_Texture<u16>(vramaddr);
            *alpha = (*color & 0x8000) ? 31 : 0;
        }
        break;
    }
}

bool DepthTest(Polygon* polygon, s32 x, s32 y, s32 z)
{
    u32 oldz = DepthBuffer[(256*y) + x];

    if (polygon->Attr & (1<<14))
    {
        s32 diff = oldz - z;
        if ((u32)(diff + 0x200) <= 0x400)
            return true;
    }
    else
    if (z < oldz)
        return true;

    return false;
}

u32 RenderPixel(Polygon* polygon, s32 x, s32 y, s32 z, u8 vr, u8 vg, u8 vb, s16 s, s16 t)
{
    u32 attr = polygon->Attr;
    u8 r, g, b, a;

    u32 polyalpha = (polygon->Attr >> 16) & 0x1F;
    bool wireframe = (polyalpha == 0);

    if ((DispCnt & (1<<0)) && (((polygon->TexParam >> 26) & 0x7) != 0))
    {
        u8 tr, tg, tb;

        u16 tcolor; u8 talpha;
        TextureLookup(polygon->TexParam, polygon->TexPalette, s, t, &tcolor, &talpha);

        tr = (tcolor << 1) & 0x3E; if (tr) tr++;
        tg = (tcolor >> 4) & 0x3E; if (tg) tg++;
        tb = (tcolor >> 9) & 0x3E; if (tb) tb++;

        // TODO: other blending modes
        r = ((tr+1) * (vr+1) - 1) >> 6;
        g = ((tg+1) * (vg+1) - 1) >> 6;
        b = ((tb+1) * (vb+1) - 1) >> 6;
        a = ((talpha+1) * (polyalpha+1) - 1) >> 5;
    }
    else
    {
        r = vr;
        g = vg;
        b = vb;
        a = polyalpha;
    }

    if (wireframe) a = 31;

    return r | (g << 8) | (b << 16) | (a << 24);
}

void RenderPolygon(Polygon* polygon)
{
    int nverts = polygon->NumVertices;
    bool isline = false;

    int vtop = polygon->VTop, vbot = polygon->VBottom;
    s32 ytop = polygon->YTop, ybot = polygon->YBottom;
    s32 xtop = polygon->XTop, xbot = polygon->XBottom;

    if (ytop > 191) return;

    // draw, line per line

    u32 polyalpha = (polygon->Attr >> 16) & 0x1F;
    bool wireframe = (polyalpha == 0);

    int lcur = vtop, rcur = vtop;
    int lnext, rnext;

    s32 dxl, dxr;
    s32 lslope, rslope;
    bool l_xmajor, r_xmajor;

    if (ybot == ytop)
    {
        ybot++;
        isline = true;

        vtop = 0; vbot = 0;
        xtop = 256; xbot = 0;
        int i;

        i = 1;
        if (polygon->Vertices[i]->FinalPosition[0] < polygon->Vertices[vtop]->FinalPosition[0]) vtop = i;
        if (polygon->Vertices[i]->FinalPosition[0] > polygon->Vertices[vbot]->FinalPosition[0]) vbot = i;

        i = nverts - 1;
        if (polygon->Vertices[i]->FinalPosition[0] < polygon->Vertices[vtop]->FinalPosition[0]) vtop = i;
        if (polygon->Vertices[i]->FinalPosition[0] > polygon->Vertices[vbot]->FinalPosition[0]) vbot = i;

        lcur = vtop; lnext = vtop;
        rcur = vbot; rnext = vbot;

        lslope = 0; l_xmajor = false;
        rslope = 0; r_xmajor = false;
    }
    else
    {
        //while (polygon->Vertices[lnext]->FinalPosition[1] )
        if (polygon->FacingView)
        {
            lnext = lcur + 1;
            if (lnext >= nverts) lnext = 0;
            rnext = rcur - 1;
            if (rnext < 0) rnext = nverts - 1;
        }
        else
        {
            lnext = lcur - 1;
            if (lnext < 0) lnext = nverts - 1;
            rnext = rcur + 1;
            if (rnext >= nverts) rnext = 0;
        }

        if (polygon->Vertices[lnext]->FinalPosition[1] == polygon->Vertices[lcur]->FinalPosition[1])
            lslope = 0;
        else
            lslope = ((polygon->Vertices[lnext]->FinalPosition[0] - polygon->Vertices[lcur]->FinalPosition[0]) << 12) /
                      (polygon->Vertices[lnext]->FinalPosition[1] - polygon->Vertices[lcur]->FinalPosition[1]);

        if (polygon->Vertices[rnext]->FinalPosition[1] == polygon->Vertices[rcur]->FinalPosition[1])
            rslope = 0;
        else
            rslope = ((polygon->Vertices[rnext]->FinalPosition[0] - polygon->Vertices[rcur]->FinalPosition[0]) << 12) /
                      (polygon->Vertices[rnext]->FinalPosition[1] - polygon->Vertices[rcur]->FinalPosition[1]);

        l_xmajor = (lslope < -0x1000) || (lslope > 0x1000);
        r_xmajor = (rslope < -0x1000) || (rslope > 0x1000);
    }

    if (l_xmajor)    dxl = (lslope > 0) ? 0x800 : (-lslope-0x800)+0x1000;
    else if (lslope) dxl = (lslope > 0) ? 0     : 0x1000;
    else             dxl = 0;

    if (r_xmajor)    dxr = (rslope > 0) ? rslope-0x800 : 0x800+0x1000;
    else if (rslope) dxr = (rslope > 0) ? 0            : 0x1000;
    else             dxr = 0x1000;

    if (ybot > 192) ybot = 192;
    for (s32 y = ytop; y < ybot; y++)
    {
        if (!isline)
        {
            if (y >= polygon->Vertices[lnext]->FinalPosition[1] && lcur != vbot)
            {
                while (y >= polygon->Vertices[lnext]->FinalPosition[1] && lcur != vbot)
                {
                    lcur = lnext;

                    if (polygon->FacingView)
                    {
                        lnext = lcur + 1;
                        if (lnext >= nverts) lnext = 0;
                    }
                    else
                    {
                        lnext = lcur - 1;
                        if (lnext < 0) lnext = nverts - 1;
                    }
                }

                if (polygon->Vertices[lnext]->FinalPosition[1] == polygon->Vertices[lcur]->FinalPosition[1])
                    lslope = 0;
                else
                    lslope = ((polygon->Vertices[lnext]->FinalPosition[0] - polygon->Vertices[lcur]->FinalPosition[0]) << 12) /
                              (polygon->Vertices[lnext]->FinalPosition[1] - polygon->Vertices[lcur]->FinalPosition[1]);

                l_xmajor = (lslope < -0x1000) || (lslope > 0x1000);

                if (l_xmajor)    dxl = (lslope > 0) ? 0x800 : (-lslope-0x800)+0x1000;
                else if (lslope) dxl = (lslope > 0) ? 0     : 0x1000;
                else             dxl = 0;
            }

            if (y >= polygon->Vertices[rnext]->FinalPosition[1] && rcur != vbot)
            {
                while (y >= polygon->Vertices[rnext]->FinalPosition[1] && rcur != vbot)
                {
                    rcur = rnext;

                    if (polygon->FacingView)
                    {
                        rnext = rcur - 1;
                        if (rnext < 0) rnext = nverts - 1;
                    }
                    else
                    {
                        rnext = rcur + 1;
                        if (rnext >= nverts) rnext = 0;
                    }
                }

                if (polygon->Vertices[rnext]->FinalPosition[1] == polygon->Vertices[rcur]->FinalPosition[1])
                    rslope = 0;
                else
                    rslope = ((polygon->Vertices[rnext]->FinalPosition[0] - polygon->Vertices[rcur]->FinalPosition[0]) << 12) /
                              (polygon->Vertices[rnext]->FinalPosition[1] - polygon->Vertices[rcur]->FinalPosition[1]);

                r_xmajor = (rslope < -0x1000) || (rslope > 0x1000);

                if (r_xmajor)    dxr = (rslope > 0) ? rslope-0x800 : 0x800+0x1000;
                else if (rslope) dxr = (rslope > 0) ? 0            : 0x1000;
                else             dxr = 0x1000;
            }
        }

        Vertex *vlcur, *vlnext, *vrcur, *vrnext;
        s32 xstart, xend;
        s32 xstart_int, xend_int;
        s32 slope_start, slope_end;

        if (lslope == 0 && rslope == 0 &&
            polygon->Vertices[lcur]->FinalPosition[0] == polygon->Vertices[rcur]->FinalPosition[0])
        {
            xstart = polygon->Vertices[lcur]->FinalPosition[0];
            xend = xstart;
        }
        else
        {
            if (lslope > 0)
            {
                xstart = polygon->Vertices[lcur]->FinalPosition[0] + (dxl >> 12);
                if (xstart < polygon->Vertices[lcur]->FinalPosition[0])
                    xstart = polygon->Vertices[lcur]->FinalPosition[0];
                else if (xstart > polygon->Vertices[lnext]->FinalPosition[0]-1)
                    xstart = polygon->Vertices[lnext]->FinalPosition[0]-1;
            }
            else if (lslope < 0)
            {
                xstart = polygon->Vertices[lcur]->FinalPosition[0] - (dxl >> 12);
                if (xstart < polygon->Vertices[lnext]->FinalPosition[0])
                    xstart = polygon->Vertices[lnext]->FinalPosition[0];
                else if (xstart > polygon->Vertices[lcur]->FinalPosition[0]-1)
                    xstart = polygon->Vertices[lcur]->FinalPosition[0]-1;
            }
            else
                xstart = polygon->Vertices[lcur]->FinalPosition[0];

            if (rslope > 0)
            {
                xend = polygon->Vertices[rcur]->FinalPosition[0] + (dxr >> 12);
                if (xend < polygon->Vertices[rcur]->FinalPosition[0])
                    xend = polygon->Vertices[rcur]->FinalPosition[0];
                else if (xend > polygon->Vertices[rnext]->FinalPosition[0]-1)
                    xend = polygon->Vertices[rnext]->FinalPosition[0]-1;
            }
            else if (rslope < 0)
            {
                xend = polygon->Vertices[rcur]->FinalPosition[0] - (dxr >> 12);
                if (xend < polygon->Vertices[rnext]->FinalPosition[0])
                    xend = polygon->Vertices[rnext]->FinalPosition[0];
                else if (xend > polygon->Vertices[rcur]->FinalPosition[0]-1)
                    xend = polygon->Vertices[rcur]->FinalPosition[0]-1;
            }
            else
                xend = polygon->Vertices[rcur]->FinalPosition[0] - 1;
        }

        // if the left and right edges are swapped, render backwards.
        // note: we 'forget' to swap the xmajor flags, on purpose
        // the hardware has the same bug
        if (xstart > xend)
        {
            vlcur = polygon->Vertices[rcur];
            vlnext = polygon->Vertices[rnext];
            vrcur = polygon->Vertices[lcur];
            vrnext = polygon->Vertices[lnext];

            slope_start = rslope;
            slope_end = lslope;

            s32 tmp = xstart; xstart = xend; xend = tmp;
        }
        else
        {
            vlcur = polygon->Vertices[lcur];
            vlnext = polygon->Vertices[lnext];
            vrcur = polygon->Vertices[rcur];
            vrnext = polygon->Vertices[rnext];

            slope_start = lslope;
            slope_end = rslope;
        }

        // interpolate attributes along Y
        s64 lfactor1, lfactor2;
        s64 rfactor1, rfactor2;

        if (l_xmajor)
        {
            lfactor1 = (vlnext->FinalPosition[0] - xstart) * vlnext->FinalPosition[3];
            lfactor2 = (xstart - vlcur->FinalPosition[0]) * vlcur->FinalPosition[3];
        }
        else
        {
            lfactor1 = (vlnext->FinalPosition[1] - y) * vlnext->FinalPosition[3];
            lfactor2 = (y - vlcur->FinalPosition[1]) * vlcur->FinalPosition[3];
        }

        s64 ldenom = lfactor1 + lfactor2;
        if (ldenom == 0)
        {
            lfactor1 = 0x1000;
            lfactor2 = 0;
            ldenom = 0x1000;
        }

        if (r_xmajor)
        {
            rfactor1 = (vrnext->FinalPosition[0] - xend+1) * vrnext->FinalPosition[3];
            rfactor2 = (xend+1 - vrcur->FinalPosition[0]) * vrcur->FinalPosition[3];
        }
        else
        {
            rfactor1 = (vrnext->FinalPosition[1] - y) * vrnext->FinalPosition[3];
            rfactor2 = (y - vrcur->FinalPosition[1]) * vrcur->FinalPosition[3];
        }

        s64 rdenom = rfactor1 + rfactor2;
        if (rdenom == 0)
        {
            rfactor1 = 0x1000;
            rfactor2 = 0;
            rdenom = 0x1000;
        }

        s32 zl = ((lfactor1 * vlcur->FinalPosition[2]) + (lfactor2 * vlnext->FinalPosition[2])) / ldenom;
        s32 zr = ((rfactor1 * vrcur->FinalPosition[2]) + (rfactor2 * vrnext->FinalPosition[2])) / rdenom;

        s32 wl = ((lfactor1 * vlcur->FinalPosition[3]) + (lfactor2 * vlnext->FinalPosition[3])) / ldenom;
        s32 wr = ((rfactor1 * vrcur->FinalPosition[3]) + (rfactor2 * vrnext->FinalPosition[3])) / rdenom;

        s32 rl = ((lfactor1 * vlcur->FinalColor[0]) + (lfactor2 * vlnext->FinalColor[0])) / ldenom;
        s32 gl = ((lfactor1 * vlcur->FinalColor[1]) + (lfactor2 * vlnext->FinalColor[1])) / ldenom;
        s32 bl = ((lfactor1 * vlcur->FinalColor[2]) + (lfactor2 * vlnext->FinalColor[2])) / ldenom;

        s32 sl = ((lfactor1 * vlcur->TexCoords[0]) + (lfactor2 * vlnext->TexCoords[0])) / ldenom;
        s32 tl = ((lfactor1 * vlcur->TexCoords[1]) + (lfactor2 * vlnext->TexCoords[1])) / ldenom;

        s32 rr = ((rfactor1 * vrcur->FinalColor[0]) + (rfactor2 * vrnext->FinalColor[0])) / rdenom;
        s32 gr = ((rfactor1 * vrcur->FinalColor[1]) + (rfactor2 * vrnext->FinalColor[1])) / rdenom;
        s32 br = ((rfactor1 * vrcur->FinalColor[2]) + (rfactor2 * vrnext->FinalColor[2])) / rdenom;

        s32 sr = ((rfactor1 * vrcur->TexCoords[0]) + (rfactor2 * vrnext->TexCoords[0])) / rdenom;
        s32 tr = ((rfactor1 * vrcur->TexCoords[1]) + (rfactor2 * vrnext->TexCoords[1])) / rdenom;

        // calculate edges
        s32 l_edgeend, r_edgestart;

        if (l_xmajor)
        {
            if (slope_start > 0) l_edgeend = vlcur->FinalPosition[0] + ((dxl + slope_start) >> 12);
            else                 l_edgeend = vlcur->FinalPosition[0] - ((dxl - slope_start) >> 12);

            if (l_edgeend == xstart) l_edgeend++;
        }
        else
            l_edgeend = xstart + 1;

        if (r_xmajor)
        {
            if (slope_end > 0) r_edgestart = vrcur->FinalPosition[0] + ((dxr + slope_end) >> 12);
            else               r_edgestart = vrcur->FinalPosition[0] - ((dxr - slope_end) >> 12);

            if (r_edgestart == xend_int) r_edgestart--;
        }
        else
            r_edgestart = xend - 1;

        // edge fill rules for opaque pixels:
        // * right edge is filled if slope > 1
        // * left edge is filled if slope <= 1
        // * edges with slope = 0 are always filled
        // edges are always filled if the pixels are translucent
        // in wireframe mode, there are special rules for equal Z (TODO)

        for (s32 x = xstart; x <= xend; x++)
        {
            if (x < 0) continue;
            if (x > 255) break;

            int edge = 0;
            if (y == ytop)            edge |= 0x4;
            else if (y == ybot-1)     edge |= 0x8;
            if (x < l_edgeend)        edge |= 0x1;
            else if (x > r_edgestart) edge |= 0x2;

            // wireframe polygons. really ugly, but works
            if (wireframe && edge==0) continue;

            s64 factor1 = (xend+1 - x) * wr;
            s64 factor2 = (x - xstart) * wl;
            s64 denom = factor1 + factor2;
            if (denom == 0)
            {
                factor1 = 0x1000;
                factor2 = 0;
                denom = 0x1000;
            }

            s32 z = ((factor1 * zl) + (factor2 * zr)) / denom;
            if (!DepthTest(polygon, x, y, z)) continue;

            u32 vr = ((factor1 * rl) + (factor2 * rr)) / denom;
            u32 vg = ((factor1 * gl) + (factor2 * gr)) / denom;
            u32 vb = ((factor1 * bl) + (factor2 * br)) / denom;

            s16 s = ((factor1 * sl) + (factor2 * sr)) / denom;
            s16 t = ((factor1 * tl) + (factor2 * tr)) / denom;

            u32 color = RenderPixel(polygon, x, y, z, vr>>3, vg>>3, vb>>3, s, t);
            u32 attr = 0;
            u32 pixeladdr = (y*256) + x;

            u8 alpha = color >> 24;

            // alpha test
            if (DispCnt & (1<<2))
            {
                if (alpha <= AlphaRef) continue;
            }
            else
            {
                if (alpha == 0) continue;
            }

            // alpha blending disable
            // TODO: check alpha test when blending is disabled
            if (!(DispCnt & (1<<3)))
                alpha = 31;

            u32 dstcolor = ColorBuffer[pixeladdr];
            u32 dstalpha = dstcolor >> 24;

            if (alpha == 31)
            {
                // edge fill rules for opaque pixels
                // TODO, eventually: antialiasing
                if (!wireframe)// && !(edge & 0x4))
                {
                    if ((edge & 0x1) && slope_start > 0x1000)
                        continue;
                    if ((edge & 0x2) && (slope_end != 0 && slope_end <= 0x1000))
                        continue;
                }

                DepthBuffer[pixeladdr] = z;
            }
            else if (dstalpha == 0)
            {
                // TODO: conditional Z-buffer update
                DepthBuffer[pixeladdr] = z;
            }
            else
            {
                u32 srcR = color & 0x3F;
                u32 srcG = (color >> 8) & 0x3F;
                u32 srcB = (color >> 16) & 0x3F;

                u32 dstR = dstcolor & 0x3F;
                u32 dstG = (dstcolor >> 8) & 0x3F;
                u32 dstB = (dstcolor >> 16) & 0x3F;

                alpha++;
                dstR = ((srcR * alpha) + (dstR * (32-alpha))) >> 5;
                dstG = ((srcG * alpha) + (dstG * (32-alpha))) >> 5;
                dstB = ((srcB * alpha) + (dstB * (32-alpha))) >> 5;

                alpha--;
                if (alpha > dstalpha) dstalpha = alpha;

                color = dstR | (dstG << 8) | (dstB << 16) | (dstalpha << 24);

                // TODO: conditional Z-buffer update
                DepthBuffer[pixeladdr] = z;
            }

            ColorBuffer[pixeladdr] = color;
            AttrBuffer[pixeladdr] = attr;
        }

        if (lslope > 0) dxl += lslope;
        else            dxl -= lslope;
        if (rslope > 0) dxr += rslope;
        else            dxr -= rslope;
    }

    /*for (int i = 0; i < polygon->NumVertices; i++)
    {
        Vertex* vtx = polygon->Vertices[i];
        u32 addr = vtx->FinalPosition[0] + (vtx->FinalPosition[1]*256);
        if (addr < 256*192)
        ColorBuffer[addr] = 0x1F3F003F;
    }*/
}

void RenderFrame(Vertex* vertices, Polygon* polygons, int npolys)
{
    u32 polyid = (ClearAttr1 >> 24) & 0x3F;

    if (DispCnt & (1<<14))
    {
        u8 xoff = (ClearAttr2 >> 16) & 0xFF;
        u8 yoff = (ClearAttr2 >> 24) & 0xFF;

        for (int y = 0; y < 256*192; y += 256)
        {
            for (int x = 0; x < 256; x++)
            {
                u16 val2 = GPU::ReadVRAM_Texture<u16>(0x40000 + (yoff << 9) + (xoff << 1));
                u16 val3 = GPU::ReadVRAM_Texture<u16>(0x60000 + (yoff << 9) + (xoff << 1));

                // TODO: confirm color conversion
                u32 r = (val2 << 1) & 0x3E; if (r) r++;
                u32 g = (val2 >> 4) & 0x3E; if (g) g++;
                u32 b = (val2 >> 9) & 0x3E; if (b) b++;
                u32 a = (val2 & 0x8000) ? 0x1F000000 : 0;
                u32 color = r | (g << 8) | (b << 16) | a;

                u32 z = ((val3 & 0x7FFF) * 0x200) + 0x1FF;
                if (z >= 0x10000 && z < 0xFFFFFF) z++;

                ColorBuffer[y+x] = color;
                DepthBuffer[y+x] = z;
                AttrBuffer[y+x] = polyid | ((val3 & 0x8000) >> 7);

                xoff++;
            }

            yoff++;
        }
    }
    else
    {
        // TODO: confirm color conversion
        u32 r = (ClearAttr1 << 1) & 0x3E; if (r) r++;
        u32 g = (ClearAttr1 >> 4) & 0x3E; if (g) g++;
        u32 b = (ClearAttr1 >> 9) & 0x3E; if (b) b++;
        u32 a = (ClearAttr1 >> 16) & 0x1F;
        u32 color = r | (g << 8) | (b << 16) | (a << 24);

        u32 z = ((ClearAttr2 & 0x7FFF) * 0x200) + 0x1FF;
		if (z >= 0x10000 && z < 0xFFFFFF) z++;

		polyid |= ((ClearAttr1 & 0x8000) >> 7);

        for (int i = 0; i < 256*192; i++)
        {
            ColorBuffer[i] = color;
            DepthBuffer[i] = z;
            AttrBuffer[i] = polyid;
        }
    }

    // TODO: Y-sorting of translucent polygons

    for (int i = 0; i < npolys; i++)
    {
        if (polygons[i].Translucent) continue;
        RenderPolygon(&polygons[i]);
    }

    for (int i = 0; i < npolys; i++)
    {
        if (!polygons[i].Translucent) continue;
        RenderPolygon(&polygons[i]);
    }
}

u32* GetLine(int line)
{
    return &ColorBuffer[line * 256];
}

}
}