reorganize repo, move shit around

1 files changed, 0 insertions, 853 deletions

diff --git a/GPU3D_Soft.cpp b/GPU3D_Soft.cpp
deleted file mode 100644
index 5c9dc8e..0000000
--- a/GPU3D_Soft.cpp
+++ /dev/null
@@ -1,853 +0,0 @@
-/*
-    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)
-                {
-                    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;
-    }
-}
-
-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];
-}
-
-}
-}