project64/Source/Glide64/rdp.cpp

/*
* Glide64 - Glide video plugin for Nintendo 64 emulators.
* Copyright (c) 2002  Dave2001
* Copyright (c) 2003-2009  Sergey 'Gonetz' Lipski
*
* This program 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 2 of the License, or
* any later version.
*
* This program 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 this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

//****************************************************************
//
// Glide64 - Glide Plugin for Nintendo 64 emulators
// Project started on December 29th, 2001
//
// Authors:
// Dave2001, original author, founded the project in 2001, left it in 2002
// Gugaman, joined the project in 2002, left it in 2002
// Sergey 'Gonetz' Lipski, joined the project in 2002, main author since fall of 2002
// Hiroshi 'KoolSmoky' Morii, joined the project in 2007
//
//****************************************************************
//
// To modify Glide64:
// * Write your name and (optional)email, commented by your work, so I know who did it, and so that you can find which parts you modified when it comes time to send it to me.
// * Do NOT send me the whole project or file that you modified.  Take out your modified code sections, and tell me where to put them.  If people sent the whole thing, I would have many different versions, but no idea how to combine them all.
//
//****************************************************************

#include <math.h>
#include <string.h>

#include "Gfx_1.3.h"
#include "3dmath.h"
#include "Util.h"
#include "Debugger.h"
#include "Combine.h"
#include "TexCache.h"
#include "TexBuffer.h"
#include "FBtoScreen.h"
#include "CRC.h"
#include <Common/StdString.h>
#include "trace.h"
#include "SettingsID.h"

#ifdef _WIN32
#include <Common/CriticalSection.h>

extern CriticalSection * g_ProcessDListCS;
#endif

const char *ACmp[] = { "NONE", "THRESHOLD", "UNKNOWN", "DITHER" };

const char *Mode0[] = { "COMBINED", "TEXEL0",
    "TEXEL1", "PRIMITIVE",
    "SHADE", "ENVIORNMENT",
    "1", "NOISE",
    "0", "0",
    "0", "0",
    "0", "0",
    "0", "0" };

const char *Mode1[] = { "COMBINED", "TEXEL0",
    "TEXEL1", "PRIMITIVE",
    "SHADE", "ENVIORNMENT",
    "CENTER", "K4",
    "0", "0",
    "0", "0",
    "0", "0",
    "0", "0" };

const char *Mode2[] = { "COMBINED", "TEXEL0",
    "TEXEL1", "PRIMITIVE",
    "SHADE", "ENVIORNMENT",
    "SCALE", "COMBINED_ALPHA",
    "T0_ALPHA", "T1_ALPHA",
    "PRIM_ALPHA", "SHADE_ALPHA",
    "ENV_ALPHA", "LOD_FRACTION",
    "PRIM_LODFRAC", "K5",
    "0", "0",
    "0", "0",
    "0", "0",
    "0", "0",
    "0", "0",
    "0", "0",
    "0", "0",
    "0", "0" };

const char *Mode3[] = { "COMBINED", "TEXEL0",
    "TEXEL1", "PRIMITIVE",
    "SHADE", "ENVIORNMENT",
    "1", "0" };

const char *Alpha0[] = { "COMBINED", "TEXEL0",
    "TEXEL1", "PRIMITIVE",
    "SHADE", "ENVIORNMENT",
    "1", "0" };

#define Alpha1 Alpha0
const char *Alpha2[] = { "LOD_FRACTION", "TEXEL0",
    "TEXEL1", "PRIMITIVE",
    "SHADE", "ENVIORNMENT",
    "PRIM_LODFRAC", "0" };
#define Alpha3 Alpha0

const char *FBLa[] = { "G_BL_CLR_IN", "G_BL_CLR_MEM", "G_BL_CLR_BL", "G_BL_CLR_FOG" };
const char *FBLb[] = { "G_BL_A_IN", "G_BL_A_FOG", "G_BL_A_SHADE", "G_BL_0" };
const char *FBLc[] = { "G_BL_CLR_IN", "G_BL_CLR_MEM", "G_BL_CLR_BL", "G_BL_CLR_FOG" };
const char *FBLd[] = { "G_BL_1MA", "G_BL_A_MEM", "G_BL_1", "G_BL_0" };

const char *str_zs[] = { "G_ZS_PIXEL", "G_ZS_PRIM" };

const char *str_yn[] = { "NO", "YES" };
const char *str_offon[] = { "OFF", "ON" };

const char *str_cull[] = { "DISABLE", "FRONT", "BACK", "BOTH" };

// I=intensity probably
const char *str_format[] = { "RGBA", "YUV", "CI", "IA", "I", "?", "?", "?" };
const char *str_size[] = { "4bit", "8bit", "16bit", "32bit" };
const char *str_cm[] = { "WRAP/NO CLAMP", "MIRROR/NO CLAMP", "WRAP/CLAMP", "MIRROR/CLAMP" };
const char *str_lod[] = { "1", "2", "4", "8", "16", "32", "64", "128", "256", "512", "1024", "2048" };
const char *str_aspect[] = { "1x8", "1x4", "1x2", "1x1", "2x1", "4x1", "8x1" };

const char *str_filter[] = { "Point Sampled", "Average (box)", "Bilinear" };

const char *str_tlut[] = { "TT_NONE", "TT_UNKNOWN", "TT_RGBA_16", "TT_IA_16" };

const char *str_dither[] = { "Pattern", "~Pattern", "Noise", "None" };

const char *CIStatus[] = { "ci_main", "ci_zimg", "ci_unknown", "ci_useless",
    "ci_old_copy", "ci_copy", "ci_copy_self",
    "ci_zcopy", "ci_aux", "ci_aux_copy" };

//static variables

char out_buf[2048];

uint32_t frame_count;  // frame counter

bool g_ucode_error_report = TRUE;
int wrong_tile = -1;

// ** RDP graphics functions **
static void undef();
static void spnoop();

static void rdp_noop();
static void rdp_texrect();
//static void rdp_texrectflip();
static void rdp_loadsync();
static void rdp_pipesync();
static void rdp_tilesync();
static void rdp_fullsync();
static void rdp_setkeygb();
static void rdp_setkeyr();
static void rdp_setconvert();
static void rdp_setscissor();
static void rdp_setprimdepth();
static void rdp_setothermode();
static void rdp_loadtlut();
static void rdp_settilesize();
static void rdp_loadblock();
static void rdp_loadtile();
static void rdp_settile();
static void rdp_fillrect();
static void rdp_setfillcolor();
static void rdp_setfogcolor();
static void rdp_setblendcolor();
static void rdp_setprimcolor();
static void rdp_setenvcolor();
static void rdp_setcombine();
static void rdp_settextureimage();
static void rdp_setdepthimage();
static void rdp_setcolorimage();
static void rdp_trifill();
static void rdp_trishade();
static void rdp_tritxtr();
static void rdp_trishadetxtr();
static void rdp_trifillz();
static void rdp_trishadez();
static void rdp_tritxtrz();
static void rdp_trishadetxtrz();
static void rdphalf_1();
static void rdphalf_2();
static void rdphalf_cont();

static void rsp_reserved0();
static void rsp_reserved1();
static void rsp_reserved2();
static void rsp_reserved3();

static void ys_memrect();

uint8_t microcode[4096];
uint32_t uc_crc;
void microcheck();

// ** UCODE FUNCTIONS **
#include "ucode00.h"
#include "ucode01.h"
#include "ucode02.h"
#include "ucode03.h"
#include "ucode04.h"
#include "ucode05.h"
#include "ucode06.h"
#include "ucode07.h"
#include "ucode08.h"
#include "ucode09.h"
#include "ucode.h"
#include "ucode09rdp.h"
#include "turbo3D.h"

static int reset = 0;
static CSettings::ucode_t g_old_ucode = CSettings::uCode_Unsupported;

void RDP::Reset()
{
    memset(this, 0, sizeof(RDP_Base));
    // set all vertex numbers
    for (int i = 0; i < MAX_VTX; i++)
        vtx[i].number = i;

    scissor_o.ul_x = 0;
    scissor_o.ul_y = 0;
    scissor_o.lr_x = 320;
    scissor_o.lr_y = 240;

    vi_org_reg = *gfx.VI_ORIGIN_REG;
    view_scale[2] = 32.0f * 511.0f;
    view_trans[2] = 32.0f * 511.0f;
    clip_ratio = 1.0f;

    lookat[0][0] = lookat[1][1] = 1.0f;

    cycle_mode = 2;
    allow_combine = 1;
    rdp.update = UPDATE_SCISSOR | UPDATE_COMBINE | UPDATE_ZBUF_ENABLED | UPDATE_CULL_MODE;
    fog_mode = RDP::fog_enabled;
    maincimg[0].addr = maincimg[1].addr = last_drawn_ci_addr = 0x7FFFFFFF;
}

RDP::RDP()
{
    vtx1 = new VERTEX[256];
    memset(vtx1, 0, sizeof(VERTEX) * 256);
    vtx2 = new VERTEX[256];
    memset(vtx2, 0, sizeof(VERTEX) * 256);
    vtxbuf = vtxbuf2 = 0;
    vtx_buffer = n_global = 0;

    for (int i = 0; i < MAX_TMU; i++)
    {
        cache[i] = new CACHE_LUT[MAX_CACHE];
        cur_cache[i] = 0;
        cur_cache_n[i] = 0;
    };

    vtx = new VERTEX[MAX_VTX];
    memset(vtx, 0, sizeof(VERTEX)*MAX_VTX);
    v0 = vn = 0;

    frame_buffers = new COLOR_IMAGE[NUMTEXBUF + 2];
}

RDP::~RDP()
{
    delete[] vtx1;
    delete[] vtx2;
    for (int i = 0; i < MAX_TMU; i++)
        delete[] cache[i];

    delete[] vtx;
    delete[] frame_buffers;
}

void rdp_reset()
{
    reset = 1;
    rdp.Reset();
}

void microcheck()
{
    uint32_t i;
    uc_crc = 0;

    // Check first 3k of ucode, because the last 1k sometimes contains trash
    for (i = 0; i < 3072 >> 2; i++)
    {
        uc_crc += ((uint32_t*)microcode)[i];
    }

    WriteTrace(TraceRDP, TraceWarning, "crc: %08lx", uc_crc);

#ifdef LOG_UCODE
    std::ofstream ucf;
    ucf.open ("ucode.txt", std::ios::out | std::ios::binary);
    char d;
    for (i=0; i<0x400000; i++)
    {
        d = ((char*)gfx.RDRAM)[i^3];
        ucf.write (&d, 1);
    }
    ucf.close();
#endif

    g_old_ucode = g_settings->ucode();
    WriteTrace(TraceRDP, TraceDebug, "ucode = %08lx", uc_crc);
    CSettings::ucode_t uc = g_settings->DetectUCode(uc_crc);
    if (uc == CSettings::uCode_NotFound)
    {
        if (g_ucode_error_report)
        {
            ReleaseGfx();
            WriteTrace(TraceGlide64, TraceError, "uCode crc not found in INI, using currently selected uCode %08lx", (unsigned long)uc_crc);
#ifdef _WIN32
            MessageBox(gfx.hWnd, stdstr_f("Error: uCode crc not found in INI, using currently selected uCode\n\n%08lx", uc_crc).c_str(), "Error", MB_OK | MB_ICONEXCLAMATION);
#endif
            g_ucode_error_report = false; // don't report any more ucode errors from this game
        }
    }
    else if (uc == CSettings::uCode_Unsupported)
    {
        if (g_ucode_error_report)
        {
            ReleaseGfx();
            WriteTrace(TraceGlide64, TraceError, "Unsupported uCode! crc: %08lx", (unsigned long)uc_crc);
#ifdef _WIN32
            MessageBox(gfx.hWnd, stdstr_f("Error: Unsupported uCode!\n\ncrc: %08lx", uc_crc).c_str(), "Error", MB_OK | MB_ICONEXCLAMATION);
#endif
            g_ucode_error_report = FALSE; // don't report any more ucode errors from this game
        }
    }
    else
    {
        WriteTrace(TraceRDP, TraceDebug, "microcheck: old ucode: %d,  new ucode: %d", g_old_ucode, uc);
        if (uc_crc == 0x8d5735b2 || uc_crc == 0xb1821ed3 || uc_crc == 0x1118b3e0) //F3DLP.Rej ucode. perspective texture correction is not implemented
        {
            rdp.Persp_en = 1;
            rdp.persp_supported = FALSE;
        }
        else if (g_settings->texture_correction)
        {
            rdp.persp_supported = TRUE;
        }
    }
}

static uint32_t d_ul_x, d_ul_y, d_lr_x, d_lr_y;

static void DrawPartFrameBufferToScreen()
{
    FB_TO_SCREEN_INFO fb_info;
    fb_info.addr = rdp.cimg;
    fb_info.size = rdp.ci_size;
    fb_info.width = rdp.ci_width;
    fb_info.height = rdp.ci_height;
    fb_info.ul_x = d_ul_x;
    fb_info.lr_x = d_lr_x;
    fb_info.ul_y = d_ul_y;
    fb_info.lr_y = d_lr_y;
    fb_info.opaque = 0;
    DrawFrameBufferToScreen(fb_info);
    memset(gfx.RDRAM + rdp.cimg, 0, (rdp.ci_width*rdp.ci_height) << rdp.ci_size >> 1);
}

#define RGBA16TO32(color) \
    ((color&1)?0xFF:0) | \
    ((uint32_t)((float)((color&0xF800) >> 11) / 31.0f * 255.0f) << 24) | \
    ((uint32_t)((float)((color&0x07C0) >> 6) / 31.0f * 255.0f) << 16) | \
    ((uint32_t)((float)((color&0x003E) >> 1) / 31.0f * 255.0f) << 8)

static void copyWhiteToRDRAM()
{
    if (rdp.ci_width == 0)
        return;

    uint16_t *ptr_dst = (uint16_t*)(gfx.RDRAM + rdp.cimg);
    uint32_t *ptr_dst32 = (uint32_t*)(gfx.RDRAM + rdp.cimg);

    for (uint32_t y = 0; y < rdp.ci_height; y++)
    {
        for (uint32_t x = 0; x < rdp.ci_width; x++)
        {
            if (rdp.ci_size == 2)
                ptr_dst[(x + y * rdp.ci_width) ^ 1] = 0xFFFF;
            else
                ptr_dst32[x + y * rdp.ci_width] = 0xFFFFFFFF;
        }
    }
}

static void CopyFrameBuffer(GrBuffer_t buffer = GR_BUFFER_BACKBUFFER)
{
    WriteTrace(TraceRDP, TraceDebug, "CopyFrameBuffer: %08lx... ", rdp.cimg);

    // don't bother to write the stuff in asm... the slow part is the read from video card,
    //   not the copy.

    uint32_t width = rdp.ci_width;//*gfx.VI_WIDTH_REG;
    uint32_t height;
    if (g_settings->fb_emulation_enabled() && !g_settings->hacks(CSettings::hack_PPL))
    {
        int ind = (rdp.ci_count > 0) ? rdp.ci_count - 1 : 0;
        height = rdp.frame_buffers[ind].height;
    }
    else
    {
        height = rdp.ci_lower_bound;
        if (g_settings->hacks(CSettings::hack_PPL))
        {
            height -= rdp.ci_upper_bound;
        }
    }
    WriteTrace(TraceRDP, TraceDebug, "width: %d, height: %d...  ", width, height);

    if (rdp.scale_x < 1.1f)
    {
        uint16_t * ptr_src = new uint16_t[width*height];
        if (grLfbReadRegion(buffer,
            (uint32_t)rdp.offset_x,
            (uint32_t)rdp.offset_y,//rdp.ci_upper_bound,
            width,
            height,
            width << 1,
            ptr_src))
        {
            uint16_t *ptr_dst = (uint16_t*)(gfx.RDRAM + rdp.cimg);
            uint32_t *ptr_dst32 = (uint32_t*)(gfx.RDRAM + rdp.cimg);
            uint16_t c;

            for (uint32_t y = 0; y < height; y++)
            {
                for (uint32_t x = 0; x < width; x++)
                {
                    c = ptr_src[x + y * width];
                    if (g_settings->fb_read_alpha_enabled())
                    {
                        if (c > 0)
                            c = (c & 0xFFC0) | ((c & 0x001F) << 1) | 1;
                    }
                    else
                    {
                        c = (c & 0xFFC0) | ((c & 0x001F) << 1) | 1;
                    }
                    if (rdp.ci_size == 2)
                        ptr_dst[(x + y * width) ^ 1] = c;
                    else
                        ptr_dst32[x + y * width] = RGBA16TO32(c);
                }
            }
            WriteTrace(TraceRDP, TraceDebug, "ReadRegion.  Framebuffer copy complete.");
        }
        else
        {
            WriteTrace(TraceRDP, TraceDebug, "Framebuffer copy failed.");
        }
        delete[] ptr_src;
    }
    else
    {
        if (rdp.motionblur && g_settings->fb_hwfbe_enabled())
        {
            return;
        }
        else
        {
            float scale_x = (g_settings->scr_res_x() - rdp.offset_x*2.0f) / maxval(width, rdp.vi_width);
            float scale_y = (g_settings->scr_res_y() - rdp.offset_y*2.0f) / maxval(height, rdp.vi_height);

            WriteTrace(TraceRDP, TraceDebug, "width: %d, height: %d, ul_y: %d, lr_y: %d, scale_x: %f, scale_y: %f, ci_width: %d, ci_height: %d", width, height, rdp.ci_upper_bound, rdp.ci_lower_bound, scale_x, scale_y, rdp.ci_width, rdp.ci_height);
            GrLfbInfo_t info;
            info.size = sizeof(GrLfbInfo_t);

            if (grLfbLock(GR_LFB_READ_ONLY,
                buffer,
                GR_LFBWRITEMODE_565,
                GR_ORIGIN_UPPER_LEFT,
                FXFALSE,
                &info))
            {
                uint16_t *ptr_src = (uint16_t*)info.lfbPtr;
                uint16_t *ptr_dst = (uint16_t*)(gfx.RDRAM + rdp.cimg);
                uint32_t *ptr_dst32 = (uint32_t*)(gfx.RDRAM + rdp.cimg);
                uint16_t c;
                uint32_t stride = info.strideInBytes >> 1;

                int read_alpha = g_settings->fb_read_alpha_enabled();
                if (g_settings->hacks(CSettings::hack_PMario) && rdp.frame_buffers[rdp.ci_count - 1].status != ci_aux)
                {
                    read_alpha = FALSE;
                }
                int x_start = 0, y_start = 0, x_end = width, y_end = height;
                if (g_settings->hacks(CSettings::hack_BAR))
                {
                    x_start = 80, y_start = 24, x_end = 240, y_end = 86;
                }
                for (int y = y_start; y < y_end; y++)
                {
                    for (int x = x_start; x < x_end; x++)
                    {
                        c = ptr_src[int(x*scale_x + rdp.offset_x) + int(y * scale_y + rdp.offset_y) * stride];
                        c = (c & 0xFFC0) | ((c & 0x001F) << 1) | 1;
                        if (read_alpha && c == 1)
                            c = 0;
                        if (rdp.ci_size <= 2)
                            ptr_dst[(x + y * width) ^ 1] = c;
                        else
                            ptr_dst32[x + y * width] = RGBA16TO32(c);
                    }
                }

                // Unlock the backbuffer
                grLfbUnlock(GR_LFB_READ_ONLY, buffer);
                WriteTrace(TraceRDP, TraceDebug, "LfbLock.  Framebuffer copy complete.");
            }
            else
            {
                WriteTrace(TraceRDP, TraceDebug, "Framebuffer copy failed.");
            }
        }
    }
}

void GoToFullScreen()
{
    if (!InitGfx())
    {
        WriteTrace(TraceGlide64, TraceError, "tInitGfx failed");
        return;
    }
}

/******************************************************************
Function: ProcessDList
Purpose:  This function is called when there is a Dlist to be
processed. (High level GFX list)
input:    none
output:   none
*******************************************************************/
void DetectFrameBufferUsage();
uint32_t fbreads_front = 0;
uint32_t fbreads_back = 0;
int cpu_fb_read_called = FALSE;
int cpu_fb_write_called = FALSE;
int cpu_fb_write = FALSE;
int cpu_fb_ignore = FALSE;
int CI_SET = TRUE;
uint32_t ucode5_texshiftaddr = 0;
uint32_t ucode5_texshiftcount = 0;
uint16_t ucode5_texshift = 0;
int depth_buffer_fog;

EXPORT void CALL ProcessDList(void)
{
#ifdef _WIN32
    CGuard guard(*g_ProcessDListCS);
#endif
    no_dlist = false;
    update_screen_count = 0;
    ChangeSize();

    WriteTrace(TraceGlide64, TraceDebug, "ProcessDList");

    if (reset)
    {
        reset = 0;
        if (g_settings->autodetect_ucode)
        {
            // Thanks to ZeZu for ucode autodetection!!!
            uint32_t startUcode = *(uint32_t*)(gfx.DMEM + 0xFD0);
            memcpy(microcode, gfx.RDRAM + startUcode, 4096);
            microcheck();
        }
        else
            memset(microcode, 0, 4096);
    }
    else if ((g_old_ucode == CSettings::ucode_S2DEX && g_settings->ucode() == CSettings::ucode_F3DEX) || g_settings->force_microcheck)
    {
        uint32_t startUcode = *(uint32_t*)(gfx.DMEM + 0xFD0);
        memcpy(microcode, gfx.RDRAM + startUcode, 4096);
        microcheck();
    }

    if (exception)
    {
        return;
    }

    // Switch to fullscreen?
    if (to_fullscreen)
    {
        GoToFullScreen();
    }

    //* Set states *//
    if (g_settings->swapmode() != CSettings::SwapMode_Old)
    {
        SwapOK = TRUE;
    }
    rdp.updatescreen = 1;

    rdp.tri_n = 0;  // 0 triangles so far this frame
    rdp.debug_n = 0;

    rdp.model_i = 0; // 0 matrices so far in stack
    //stack_size can be less then 32! Important for Silicon Vally. Thanks Orkin!
    rdp.model_stack_size = minval(32, (*(uint32_t*)(gfx.DMEM + 0x0FE4)) >> 6);
    if (rdp.model_stack_size == 0)
        rdp.model_stack_size = 32;
    rdp.Persp_en = TRUE;
    rdp.fb_drawn = rdp.fb_drawn_front = FALSE;
    rdp.update = 0x7FFFFFFF;  // All but clear cache
    rdp.geom_mode = 0;
    rdp.acmp = 0;
    rdp.maincimg[1] = rdp.maincimg[0];
    rdp.skip_drawing = FALSE;
    rdp.s2dex_tex_loaded = FALSE;
    rdp.bg_image_height = 0xFFFF;
    fbreads_front = fbreads_back = 0;
    rdp.fog_multiplier = rdp.fog_offset = 0;
    rdp.zsrc = 0;
    if (rdp.vi_org_reg != *gfx.VI_ORIGIN_REG)
        rdp.tlut_mode = 0; //is it correct?
    rdp.scissor_set = FALSE;
    ucode5_texshiftaddr = ucode5_texshiftcount = 0;
    cpu_fb_write = FALSE;
    cpu_fb_read_called = FALSE;
    cpu_fb_write_called = FALSE;
    cpu_fb_ignore = FALSE;
    d_ul_x = 0xffff;
    d_ul_y = 0xffff;
    d_lr_x = 0;
    d_lr_y = 0;
    depth_buffer_fog = TRUE;

    //analize possible frame buffer usage
    if (g_settings->fb_emulation_enabled())
        DetectFrameBufferUsage();
    if (!g_settings->hacks(CSettings::hack_Lego) || rdp.num_of_ci > 1)
        rdp.last_bg = 0;
    //* End of set states *//

    // Get the start of the display list and the length of it
    uint32_t dlist_start = *(uint32_t*)(gfx.DMEM + 0xFF0);
    uint32_t dlist_length = *(uint32_t*)(gfx.DMEM + 0xFF4);
    WriteTrace(TraceRDP, TraceDebug, "--- NEW DLIST --- crc: %08lx, ucode: %d, fbuf: %08lx, fbuf_width: %d, dlist start: %08lx, dlist_length: %d, x_scale: %f, y_scale: %f", uc_crc, g_settings->ucode(), *gfx.VI_ORIGIN_REG, *gfx.VI_WIDTH_REG, dlist_start, dlist_length, (*gfx.VI_X_SCALE_REG & 0xFFF) / 1024.0f, (*gfx.VI_Y_SCALE_REG & 0xFFF) / 1024.0f);

    // Do nothing if dlist is empty
    if (dlist_start == 0)
        return;

    if (cpu_fb_write == TRUE)
        DrawPartFrameBufferToScreen();
    if (g_settings->hacks(CSettings::hack_Tonic) && dlist_length < 16)
    {
        rdp_fullsync();
        WriteTrace(TraceRDP, TraceWarning, "DLIST is too short!");
        return;
    }

    // Start executing at the start of the display list
    rdp.pc_i = 0;
    rdp.pc[rdp.pc_i] = dlist_start;
    rdp.dl_count = -1;
    rdp.halt = 0;
    uint32_t a;

    // catches exceptions so that it doesn't freeze
#ifdef CATCH_EXCEPTIONS
    try {
#endif
        if (g_settings->ucode() == CSettings::ucode_Turbo3d)
        {
            Turbo3D();
        }
        else
        {
            // MAIN PROCESSING LOOP
            do 
            {
                // Get the address of the next command
                a = rdp.pc[rdp.pc_i] & BMASK;

                // Load the next command and its input
                rdp.cmd0 = ((uint32_t*)gfx.RDRAM)[a >> 2];   // \ Current command, 64 bit
                rdp.cmd1 = ((uint32_t*)gfx.RDRAM)[(a >> 2) + 1]; // /
                // cmd2 and cmd3 are filled only when needed, by the function that needs them

                // Output the address before the command
                WriteTrace(TraceRDP, TraceDebug, "%08lx (c0:%08lx, c1:%08lx): ", a, rdp.cmd0, rdp.cmd1);

                // Go to the next instruction
                rdp.pc[rdp.pc_i] = (a + 8) & BMASK;

#ifdef PERFORMANCE
                perf_cur = CDateTime().SetToNow().Value();
#endif
                // Process this instruction
                gfx_instruction[g_settings->ucode()][rdp.cmd0 >> 24]();

                // check DL counter
                if (rdp.dl_count != -1)
                {
                    rdp.dl_count--;
                    if (rdp.dl_count == 0)
                    {
                        rdp.dl_count = -1;

                        WriteTrace(TraceRDP, TraceDebug, "End of DL");
                        rdp.pc_i--;
                    }
                }

#ifdef PERFORMANCE
                perf_next = CDateTime().SetToNow().Value();
                sprintf(out_buf, "perf %08lx: %016I64d", a - 8, (perf_next - perf_cur).Format(_T("%l")).mb_str());
                rdp_log << out_buf;
#endif
            } while (!rdp.halt);
        }
#ifdef CATCH_EXCEPTIONS
    }
    catch (...) {
        if (g_fullscreen)
        {
            ReleaseGfx ();
            rdp_reset();
            if (g_settings->ghq_use)
            {
                ext_ghq_shutdown();
                g_settings->ghq_use = 0;
            }
        }
        if (MessageBox(gfx.hWnd, "The GFX plugin caused an exception and has been disabled.\nWould you like to turn it back on and attempt to continue?","Glide64 Exception", MB_YESNO|MB_ICONEXCLAMATION) == MB_NO)
        {
            exception = TRUE;
        }
        else
        {
            to_fullscreen = TRUE;
        }
        return;
    }
#endif

    if (g_settings->fb_emulation_enabled())
    {
        rdp.scale_x = rdp.scale_x_bak;
        rdp.scale_y = rdp.scale_y_bak;
    }

    if (g_settings->hacks(CSettings::hack_OoT))
    {
        copyWhiteToRDRAM(); //Subscreen delay fix
    }
    else if (g_settings->fb_ref_enabled())
    {
        CopyFrameBuffer();
    }

    if (rdp.cur_image)
    {
        CloseTextureBuffer(rdp.read_whole_frame && (g_settings->hacks(CSettings::hack_PMario) || rdp.swap_ci_index >= 0));
    }

    if (g_settings->hacks(CSettings::hack_TGR2) && rdp.vi_org_reg != *gfx.VI_ORIGIN_REG && CI_SET)
    {
        newSwapBuffers();
        CI_SET = FALSE;
    }
    WriteTrace(TraceRDP, TraceDebug, "ProcessDList end");
}

// undef - undefined instruction, always ignore
static void undef()
{
    WriteTrace(TraceRDP, TraceWarning, "** undefined ** (%08lx) - IGNORED", rdp.cmd0);
#ifdef _ENDUSER_RELEASE_
    *gfx.MI_INTR_REG |= 0x20;
    gfx.CheckInterrupts();
    rdp.halt = 1;
#endif
}

// spnoop - no operation, always ignore
static void spnoop()
{
    WriteTrace(TraceRDP, TraceDebug, "spnoop");
}

// noop - no operation, always ignore
static void rdp_noop()
{
    WriteTrace(TraceRDP, TraceDebug, "noop");
}

static void ys_memrect()
{
    uint32_t tile = (uint16_t)((rdp.cmd1 & 0x07000000) >> 24);

    uint32_t lr_x = (uint16_t)((rdp.cmd0 & 0x00FFF000) >> 14);
    uint32_t lr_y = (uint16_t)((rdp.cmd0 & 0x00000FFF) >> 2);
    uint32_t ul_x = (uint16_t)((rdp.cmd1 & 0x00FFF000) >> 14);
    uint32_t ul_y = (uint16_t)((rdp.cmd1 & 0x00000FFF) >> 2);

    if (lr_y > rdp.scissor_o.lr_y)
        lr_y = rdp.scissor_o.lr_y;
    uint32_t off_x = ((rdp.cmd2 & 0xFFFF0000) >> 16) >> 5;
    uint32_t off_y = (rdp.cmd2 & 0x0000FFFF) >> 5;

    WriteTrace(TraceRDP, TraceDebug, "memrect (%d, %d, %d, %d), ci_width: %d", ul_x, ul_y, lr_x, lr_y, rdp.ci_width);
    if (off_x > 0)
        WriteTrace(TraceRDP, TraceDebug, "  off_x: %d", off_x);
    if (off_y > 0)
        WriteTrace(TraceRDP, TraceDebug, "  off_y: %d", off_y);

    uint32_t y, width = lr_x - ul_x;
    uint32_t tex_width = rdp.tiles[tile].line << 3;
    uint8_t * texaddr = gfx.RDRAM + rdp.addr[rdp.tiles[tile].t_mem] + tex_width*off_y + off_x;
    uint8_t * fbaddr = gfx.RDRAM + rdp.cimg + ul_x;

    for (y = ul_y; y < lr_y; y++) {
        uint8_t *src = texaddr + (y - ul_y) * tex_width;
        uint8_t *dst = fbaddr + y * rdp.ci_width;
        memcpy(dst, src, width);
    }
}

static void pm_palette_mod()
{
    uint8_t envr = (uint8_t)((float)((rdp.env_color >> 24) & 0xFF) / 255.0f*31.0f);
    uint8_t envg = (uint8_t)((float)((rdp.env_color >> 16) & 0xFF) / 255.0f*31.0f);
    uint8_t envb = (uint8_t)((float)((rdp.env_color >> 8) & 0xFF) / 255.0f*31.0f);
    uint16_t env16 = (uint16_t)((envr << 11) | (envg << 6) | (envb << 1) | 1);
    uint8_t prmr = (uint8_t)((float)((rdp.prim_color >> 24) & 0xFF) / 255.0f*31.0f);
    uint8_t prmg = (uint8_t)((float)((rdp.prim_color >> 16) & 0xFF) / 255.0f*31.0f);
    uint8_t prmb = (uint8_t)((float)((rdp.prim_color >> 8) & 0xFF) / 255.0f*31.0f);
    uint16_t prim16 = (uint16_t)((prmr << 11) | (prmg << 6) | (prmb << 1) | 1);
    uint16_t * dst = (uint16_t*)(gfx.RDRAM + rdp.cimg);
    for (int i = 0; i < 16; i++)
    {
        dst[i ^ 1] = (rdp.pal_8[i] & 1) ? prim16 : env16;
    }
    WriteTrace(TraceRDP, TraceDebug, "Texrect palette modification");
}

static void pd_zcopy()
{
    uint16_t ul_x = (uint16_t)((rdp.cmd1 & 0x00FFF000) >> 14);
    uint16_t lr_x = (uint16_t)((rdp.cmd0 & 0x00FFF000) >> 14) + 1;
    uint16_t ul_u = (uint16_t)((rdp.cmd2 & 0xFFFF0000) >> 21) + 1;
    uint16_t *ptr_dst = (uint16_t*)(gfx.RDRAM + rdp.cimg);
    uint16_t width = lr_x - ul_x;
    uint16_t * ptr_src = ((uint16_t*)rdp.tmem) + ul_u;
    uint16_t c;
    for (uint16_t x = 0; x < width; x++)
    {
        c = ptr_src[x];
        c = ((c << 8) & 0xFF00) | (c >> 8);
        ptr_dst[(ul_x + x) ^ 1] = c;
        //      WriteTrace(TraceRDP, TraceDebug, "dst[%d]=%04lx ", (x + ul_x)^1, c);
    }
}

static void DrawDepthBufferFog()
{
    if (rdp.zi_width < 200)
        return;
    FB_TO_SCREEN_INFO fb_info;
    fb_info.addr = rdp.zimg;
    fb_info.size = 2;
    fb_info.width = rdp.zi_width;
    fb_info.height = rdp.ci_height;
    fb_info.ul_x = rdp.scissor_o.ul_x;
    fb_info.lr_x = rdp.scissor_o.lr_x;
    fb_info.ul_y = rdp.scissor_o.ul_y;
    fb_info.lr_y = rdp.scissor_o.lr_y;
    fb_info.opaque = 0;
    DrawDepthBufferToScreen(fb_info);
}

static void rdp_texrect()
{
    if (!rdp.LLE)
    {
        uint32_t a = rdp.pc[rdp.pc_i];
        uint8_t cmdHalf1 = gfx.RDRAM[a + 3];
        uint8_t cmdHalf2 = gfx.RDRAM[a + 11];
        a >>= 2;
        if ((cmdHalf1 == 0xE1 && cmdHalf2 == 0xF1) || (cmdHalf1 == 0xB4 && cmdHalf2 == 0xB3) || (cmdHalf1 == 0xB3 && cmdHalf2 == 0xB2))
        {
            //gSPTextureRectangle
            rdp.cmd2 = ((uint32_t*)gfx.RDRAM)[a + 1];
            rdp.cmd3 = ((uint32_t*)gfx.RDRAM)[a + 3];
            rdp.pc[rdp.pc_i] += 16;
        }
        else
        {
            //gDPTextureRectangle
			if (g_settings->hacks(CSettings::hack_Winback))
            {
				rdp.pc[rdp.pc_i] += 8;
				return;
			}

            if (g_settings->hacks(CSettings::hack_ASB))
            {
                rdp.cmd2 = 0;
            }
            else
            {
                rdp.cmd2 = ((uint32_t*)gfx.RDRAM)[a + 0];
            }

			rdp.cmd3 = ((uint32_t*)gfx.RDRAM)[a + 1];
            rdp.pc[rdp.pc_i] += 8;
        }
    }
    if (g_settings->hacks(CSettings::hack_Yoshi) && g_settings->ucode() == CSettings::ucode_S2DEX)
    {
        ys_memrect();
        return;
    }

	if (rdp.skip_drawing || (!g_settings->fb_emulation_enabled() && (rdp.cimg == rdp.zimg)))
    {
        if (g_settings->hacks(CSettings::hack_PMario) && rdp.ci_status == ci_useless)
        {
            pm_palette_mod();
        }
        else
        {
            WriteTrace(TraceRDP, TraceDebug, "Texrect skipped");
        }
        return;
    }

    if ((g_settings->ucode() == CSettings::ucode_CBFD) && rdp.cur_image && rdp.cur_image->format)
    {
        //WriteTrace(TraceRDP, TraceDebug, "Wrong Texrect. texaddr: %08lx, cimg: %08lx, cimg_end: %08lx", rdp.timg.addr, rdp.maincimg[1].addr, rdp.maincimg[1].addr+rdp.ci_width*rdp.ci_height*rdp.ci_size);
        WriteTrace(TraceRDP, TraceDebug, "Shadow texrect is skipped.");
        rdp.tri_n += 2;
        return;
    }

    if ((g_settings->ucode() == CSettings::ucode_PerfectDark) && rdp.ci_count > 0 && (rdp.frame_buffers[rdp.ci_count - 1].status == ci_zcopy))
    {
        pd_zcopy();
        WriteTrace(TraceRDP, TraceDebug, "Depth buffer copied.");
        rdp.tri_n += 2;
        return;
    }

    if ((rdp.othermode_l >> 16) == 0x3c18 && rdp.cycle1 == 0x03ffffff && rdp.cycle2 == 0x01ff1fff) //depth image based fog
    {
        if (!depth_buffer_fog)
            return;
        if (g_settings->fog)
            DrawDepthBufferFog();
        depth_buffer_fog = FALSE;
        return;
    }

    //  WriteTrace(TraceRDP, TraceDebug, "rdp.cycle1 %08lx, rdp.cycle2 %08lx", rdp.cycle1, rdp.cycle2);

    float ul_x, ul_y, lr_x, lr_y;
    if (rdp.cycle_mode == 2)
    {
        ul_x = maxval(0.0f, (short)((rdp.cmd1 & 0x00FFF000) >> 14));
        ul_y = maxval(0.0f, (short)((rdp.cmd1 & 0x00000FFF) >> 2));
        lr_x = maxval(0.0f, (short)((rdp.cmd0 & 0x00FFF000) >> 14));
        lr_y = maxval(0.0f, (short)((rdp.cmd0 & 0x00000FFF) >> 2));
    }
    else
    {
        ul_x = maxval(0.0f, ((short)((rdp.cmd1 & 0x00FFF000) >> 12)) / 4.0f);
        ul_y = maxval(0.0f, ((short)(rdp.cmd1 & 0x00000FFF)) / 4.0f);
        lr_x = maxval(0.0f, ((short)((rdp.cmd0 & 0x00FFF000) >> 12)) / 4.0f);
        lr_y = maxval(0.0f, ((short)(rdp.cmd0 & 0x00000FFF)) / 4.0f);
    }

    if (ul_x >= lr_x)
    {
        WriteTrace(TraceRDP, TraceDebug, "Wrong Texrect: ul_x: %f, lr_x: %f", ul_x, lr_x);
        return;
    }

    if (rdp.cycle_mode > 1)
    {
        lr_x += 1.0f;
        lr_y += 1.0f;
    }
    else if (lr_y - ul_y < 1.0f)
        lr_y = ceil(lr_y);

    if (g_settings->increase_texrect_edge)
    {
        if (floor(lr_x) != lr_x)
            lr_x = ceil(lr_x);
        if (floor(lr_y) != lr_y)
            lr_y = ceil(lr_y);
    }

    if (rdp.tbuff_tex && g_settings->fb_optimize_texrect_enabled())
    {
        WriteTrace(TraceRDP, TraceDebug, "Attempt to optimize texrect");
        if (!rdp.tbuff_tex->drawn)
        {
            DRAWIMAGE d;
            d.imageX = 0;
            d.imageW = (uint16_t)rdp.tbuff_tex->width;
            d.frameX = (uint16_t)ul_x;
            d.frameW = (uint16_t)(rdp.tbuff_tex->width);

            d.imageY = 0;
            d.imageH = (uint16_t)rdp.tbuff_tex->height;
            d.frameY = (uint16_t)ul_y;
            d.frameH = (uint16_t)(rdp.tbuff_tex->height);
            WriteTrace(TraceRDP, TraceDebug, "texrect. ul_x: %d, ul_y: %d, lr_x: %d, lr_y: %d, width: %d, height: %d", ul_x, ul_y, lr_x, lr_y, rdp.tbuff_tex->width, rdp.tbuff_tex->height);
            d.scaleX = 1.0f;
            d.scaleY = 1.0f;
            DrawHiresImage(d, rdp.tbuff_tex->width == rdp.ci_width);
            rdp.tbuff_tex->drawn = TRUE;
        }
        return;
    }
    //*/
    // framebuffer workaround for Zelda: MM LOT
    if ((rdp.othermode_l & 0xFFFF0000) == 0x0f5a0000)
        return;

    /*Gonetz*/
    //hack for Zelda MM. it removes black texrects which cover all geometry in "Link meets Zelda" cut scene
    if (g_settings->hacks(CSettings::hack_Zelda) && rdp.timg.addr >= rdp.cimg && rdp.timg.addr < rdp.ci_end)
    {
        WriteTrace(TraceRDP, TraceDebug, "Wrong Texrect. texaddr: %08lx, cimg: %08lx, cimg_end: %08lx", rdp.cur_cache[0]->addr, rdp.cimg, rdp.cimg + rdp.ci_width*rdp.ci_height * 2);
        rdp.tri_n += 2;
        return;
    }
    //*
    //hack for Banjo2. it removes black texrects under Banjo
    if (!g_settings->fb_hwfbe_enabled() && ((rdp.cycle1 << 16) | (rdp.cycle2 & 0xFFFF)) == 0xFFFFFFFF && (rdp.othermode_l & 0xFFFF0000) == 0x00500000)
    {
        rdp.tri_n += 2;
        return;
    }
    //*/
    //*
    //remove motion blur in night vision
    if (g_settings->ucode() == CSettings::ucode_PerfectDark && (rdp.maincimg[1].addr != rdp.maincimg[0].addr) && (rdp.timg.addr >= rdp.maincimg[1].addr) && (rdp.timg.addr < (rdp.maincimg[1].addr + rdp.ci_width*rdp.ci_height*rdp.ci_size)))
    {
        if (g_settings->fb_emulation_enabled() && rdp.ci_count > 0 && rdp.frame_buffers[rdp.ci_count - 1].status == ci_copy_self)
        {
            //WriteTrace(TraceRDP, TraceDebug, "Wrong Texrect. texaddr: %08lx, cimg: %08lx, cimg_end: %08lx", rdp.timg.addr, rdp.maincimg[1], rdp.maincimg[1]+rdp.ci_width*rdp.ci_height*rdp.ci_size);
            WriteTrace(TraceRDP, TraceDebug, "Wrong Texrect.");
            rdp.tri_n += 2;
            return;
        }
    }

    int i;

    uint32_t tile_no = (uint16_t)((rdp.cmd1 & 0x07000000) >> 24);

    rdp.texrecting = 1;

    uint32_t prev_tile = rdp.cur_tile;
    rdp.cur_tile = tile_no;

    const float Z = set_sprite_combine_mode();

    rdp.texrecting = 0;

    if (!rdp.cur_cache[0])
    {
        rdp.cur_tile = prev_tile;
        rdp.tri_n += 2;
        return;
    }
    // ****
    // ** Texrect offset by Gugaman **
    //
    //integer representation of texture coordinate.
    //needed to detect and avoid overflow after shifting
    int32_t off_x_i = (rdp.cmd2 >> 16) & 0xFFFF;
    int32_t off_y_i = rdp.cmd2 & 0xFFFF;
    float dsdx = (float)((short)((rdp.cmd3 & 0xFFFF0000) >> 16)) / 1024.0f;
    float dtdy = (float)((short)(rdp.cmd3 & 0x0000FFFF)) / 1024.0f;
    if (off_x_i & 0x8000) //check for sign bit
        off_x_i |= ~0xffff; //make it negative
    //the same as for off_x_i
    if (off_y_i & 0x8000)
        off_y_i |= ~0xffff;

    if (rdp.cycle_mode == 2)
        dsdx /= 4.0f;

    float s_ul_x = ul_x * rdp.scale_x + rdp.offset_x;
    float s_lr_x = lr_x * rdp.scale_x + rdp.offset_x;
    float s_ul_y = ul_y * rdp.scale_y + rdp.offset_y;
    float s_lr_y = lr_y * rdp.scale_y + rdp.offset_y;

    WriteTrace(TraceRDP, TraceDebug, "texrect (%.2f, %.2f, %.2f, %.2f), tile: %d, #%d, #%d", ul_x, ul_y, lr_x, lr_y, tile_no, rdp.tri_n, rdp.tri_n + 1);
    WriteTrace(TraceRDP, TraceDebug, "(%f, %f) -> (%f, %f), s: (%d, %d) -> (%d, %d)", s_ul_x, s_ul_y, s_lr_x, s_lr_y, rdp.scissor.ul_x, rdp.scissor.ul_y, rdp.scissor.lr_x, rdp.scissor.lr_y);
    WriteTrace(TraceRDP, TraceDebug, "\toff_x: %f, off_y: %f, dsdx: %f, dtdy: %f", off_x_i / 32.0f, off_y_i / 32.0f, dsdx, dtdy);

    float off_size_x;
    float off_size_y;

    if (((rdp.cmd0 >> 24) & 0xFF) == 0xE5) //texrectflip
    {
        if (rdp.cur_cache[0]->is_hires_tex)
        {
            off_size_x = (float)((lr_y - ul_y) * dsdx);
            off_size_y = (float)((lr_x - ul_x) * dtdy);
        }
        else
        {
            off_size_x = (lr_y - ul_y - 1) * dsdx;
            off_size_y = (lr_x - ul_x - 1) * dtdy;
        }
    }
    else
    {
        if (rdp.cur_cache[0]->is_hires_tex)
        {
            off_size_x = (float)((lr_x - ul_x) * dsdx);
            off_size_y = (float)((lr_y - ul_y) * dtdy);
        }
        else
        {
            off_size_x = (lr_x - ul_x - 1) * dsdx;
            off_size_y = (lr_y - ul_y - 1) * dtdy;
        }
    }

    struct {
        float ul_u, ul_v, lr_u, lr_v;
    } texUV[2]; //struct for texture coordinates
    //angrylion's macro, helps to cut overflowed values.
#define SIGN16(x) (((x) & 0x8000) ? ((x) | ~0xffff) : ((x) & 0xffff))

    //calculate texture coordinates
    for (int i = 0; i < 2; i++)
    {
        if (rdp.cur_cache[i] && (rdp.tex & (i + 1)))
        {
            float sx = 1, sy = 1;
            int x_i = off_x_i, y_i = off_y_i;
            TILE & tile = rdp.tiles[rdp.cur_tile + i];
            //shifting
            if (tile.shift_s)
            {
                if (tile.shift_s > 10)
                {
                    uint8_t iShift = (16 - tile.shift_s);
                    x_i <<= iShift;
                    sx = (float)(1 << iShift);
                }
                else
                {
                    uint8_t iShift = tile.shift_s;
                    x_i >>= iShift;
                    sx = 1.0f / (float)(1 << iShift);
                }
            }
            if (tile.shift_t)
            {
                if (tile.shift_t > 10)
                {
                    uint8_t iShift = (16 - tile.shift_t);
                    y_i <<= iShift;
                    sy = (float)(1 << iShift);
                }
                else
                {
                    uint8_t iShift = tile.shift_t;
                    y_i >>= iShift;
                    sy = 1.0f / (float)(1 << iShift);
                }
            }

            if (rdp.aTBuffTex[i]) //hwfbe texture
            {
                float t0_off_x;
                float t0_off_y;
                if (off_x_i + off_y_i == 0)
                {
                    t0_off_x = tile.ul_s;
                    t0_off_y = tile.ul_t;
                }
                else
                {
                    t0_off_x = off_x_i / 32.0f;
                    t0_off_y = off_y_i / 32.0f;
                }
                t0_off_x += rdp.aTBuffTex[i]->u_shift;// + tile.ul_s; //commented for Paper Mario motion blur
                t0_off_y += rdp.aTBuffTex[i]->v_shift;// + tile.ul_t;
                texUV[i].ul_u = t0_off_x * sx;
                texUV[i].ul_v = t0_off_y * sy;

                texUV[i].lr_u = texUV[i].ul_u + off_size_x * sx;
                texUV[i].lr_v = texUV[i].ul_v + off_size_y * sy;

                texUV[i].ul_u *= rdp.aTBuffTex[i]->u_scale;
                texUV[i].ul_v *= rdp.aTBuffTex[i]->v_scale;
                texUV[i].lr_u *= rdp.aTBuffTex[i]->u_scale;
                texUV[i].lr_v *= rdp.aTBuffTex[i]->v_scale;
                WriteTrace(TraceRDP, TraceDebug, "tbuff_tex[%d] ul_u: %f, ul_v: %f, lr_u: %f, lr_v: %f",
                    i, texUV[i].ul_u, texUV[i].ul_v, texUV[i].lr_u, texUV[i].lr_v);
            }
            else //common case
            {
                //kill 10.5 format overflow by SIGN16 macro
                texUV[i].ul_u = SIGN16(x_i) / 32.0f;
                texUV[i].ul_v = SIGN16(y_i) / 32.0f;

                texUV[i].ul_u -= tile.f_ul_s;
                texUV[i].ul_v -= tile.f_ul_t;

                texUV[i].lr_u = texUV[i].ul_u + off_size_x * sx;
                texUV[i].lr_v = texUV[i].ul_v + off_size_y * sy;

                texUV[i].ul_u = rdp.cur_cache[i]->c_off + rdp.cur_cache[i]->c_scl_x * texUV[i].ul_u;
                texUV[i].lr_u = rdp.cur_cache[i]->c_off + rdp.cur_cache[i]->c_scl_x * texUV[i].lr_u;
                texUV[i].ul_v = rdp.cur_cache[i]->c_off + rdp.cur_cache[i]->c_scl_y * texUV[i].ul_v;
                texUV[i].lr_v = rdp.cur_cache[i]->c_off + rdp.cur_cache[i]->c_scl_y * texUV[i].lr_v;
            }
        }
        else
        {
            texUV[i].ul_u = texUV[i].ul_v = texUV[i].lr_u = texUV[i].lr_v = 0;
        }
    }
    rdp.cur_tile = prev_tile;

    // ****

    WriteTrace(TraceRDP, TraceDebug, "  scissor: (%d, %d) -> (%d, %d)", rdp.scissor.ul_x, rdp.scissor.ul_y, rdp.scissor.lr_x, rdp.scissor.lr_y);

    CCLIP2(s_ul_x, s_lr_x, texUV[0].ul_u, texUV[0].lr_u, texUV[1].ul_u, texUV[1].lr_u, (float)rdp.scissor.ul_x, (float)rdp.scissor.lr_x);
    CCLIP2(s_ul_y, s_lr_y, texUV[0].ul_v, texUV[0].lr_v, texUV[1].ul_v, texUV[1].lr_v, (float)rdp.scissor.ul_y, (float)rdp.scissor.lr_y);

    WriteTrace(TraceRDP, TraceDebug, "  draw at: (%f, %f) -> (%f, %f)", s_ul_x, s_ul_y, s_lr_x, s_lr_y);

    VERTEX vstd[4] = {
        { s_ul_x, s_ul_y, Z, 1.0f, texUV[0].ul_u, texUV[0].ul_v, texUV[1].ul_u, texUV[1].ul_v, { 0, 0, 0, 0 }, 255 },
        { s_lr_x, s_ul_y, Z, 1.0f, texUV[0].lr_u, texUV[0].ul_v, texUV[1].lr_u, texUV[1].ul_v, { 0, 0, 0, 0 }, 255 },
        { s_ul_x, s_lr_y, Z, 1.0f, texUV[0].ul_u, texUV[0].lr_v, texUV[1].ul_u, texUV[1].lr_v, { 0, 0, 0, 0 }, 255 },
        { s_lr_x, s_lr_y, Z, 1.0f, texUV[0].lr_u, texUV[0].lr_v, texUV[1].lr_u, texUV[1].lr_v, { 0, 0, 0, 0 }, 255 } };

    if (((rdp.cmd0 >> 24) & 0xFF) == 0xE5) //texrectflip
    {
        vstd[1].u0 = texUV[0].ul_u;
        vstd[1].v0 = texUV[0].lr_v;
        vstd[1].u1 = texUV[1].ul_u;
        vstd[1].v1 = texUV[1].lr_v;

        vstd[2].u0 = texUV[0].lr_u;
        vstd[2].v0 = texUV[0].ul_v;
        vstd[2].u1 = texUV[1].lr_u;
        vstd[2].v1 = texUV[1].ul_v;
    }

    VERTEX *vptr = vstd;
    int n_vertices = 4;

    VERTEX *vnew = 0;
    //          for (int j =0; j < 4; j++)
    //            WriteTrace(TraceRDP, TraceDebug, "v[%d]  u0: %f, v0: %f, u1: %f, v1: %f", j, vstd[j].u0, vstd[j].v0, vstd[j].u1, vstd[j].v1);

    if (!rdp.aTBuffTex[0] && rdp.cur_cache[0]->splits != 1)
    {
        // ** LARGE TEXTURE HANDLING **
        // *VERY* simple algebra for texrects
        float min_u, min_x, max_u, max_x;
        if (vstd[0].u0 < vstd[1].u0)
        {
            min_u = vstd[0].u0;
            min_x = vstd[0].x;
            max_u = vstd[1].u0;
            max_x = vstd[1].x;
        }
        else
        {
            min_u = vstd[1].u0;
            min_x = vstd[1].x;
            max_u = vstd[0].u0;
            max_x = vstd[0].x;
        }

        int start_u_256, end_u_256;
        start_u_256 = (int)min_u >> 8;
        end_u_256 = (int)max_u >> 8;
        //WriteTrace(TraceRDP, TraceDebug, " min_u: %f, max_u: %f start: %d, end: %d", min_u, max_u, start_u_256, end_u_256);

        int splitheight = rdp.cur_cache[0]->splitheight;

        int num_verts_line = 2 + ((end_u_256 - start_u_256) << 1);
        n_vertices = num_verts_line << 1;
        vnew = new VERTEX[n_vertices];
        vptr = vnew;

        vnew[0] = vstd[0];
        vnew[0].u0 -= 256.0f * start_u_256;
        vnew[0].v0 += splitheight * start_u_256;
        vnew[0].u1 -= 256.0f * start_u_256;
        vnew[0].v1 += splitheight * start_u_256;
        vnew[1] = vstd[2];
        vnew[1].u0 -= 256.0f * start_u_256;
        vnew[1].v0 += splitheight * start_u_256;
        vnew[1].u1 -= 256.0f * start_u_256;
        vnew[1].v1 += splitheight * start_u_256;
        vnew[n_vertices - 2] = vstd[1];
        vnew[n_vertices - 2].u0 -= 256.0f * end_u_256;
        vnew[n_vertices - 2].v0 += splitheight * end_u_256;
        vnew[n_vertices - 2].u1 -= 256.0f * end_u_256;
        vnew[n_vertices - 2].v1 += splitheight * end_u_256;
        vnew[n_vertices - 1] = vstd[3];
        vnew[n_vertices - 1].u0 -= 256.0f * end_u_256;
        vnew[n_vertices - 1].v0 += splitheight * end_u_256;
        vnew[n_vertices - 1].u1 -= 256.0f * end_u_256;
        vnew[n_vertices - 1].v1 += splitheight * end_u_256;

        // find the equation of the line of u,x
        float m = (max_x - min_x) / (max_u - min_u);  // m = delta x / delta u
        float b = min_x - m * min_u;          // b = y - m * x

        for (i = start_u_256; i < end_u_256; i++)
        {
            // Find where x = current 256 multiple
            float x = m * ((i << 8) + 256) + b;

            int vn = 2 + ((i - start_u_256) << 2);
            vnew[vn] = vstd[0];
            vnew[vn].x = x;
            vnew[vn].u0 = 255.5f;
            vnew[vn].v0 += (float)splitheight * i;
            vnew[vn].u1 = 255.5f;
            vnew[vn].v1 += (float)splitheight * i;

            vn++;
            vnew[vn] = vstd[2];
            vnew[vn].x = x;
            vnew[vn].u0 = 255.5f;
            vnew[vn].v0 += (float)splitheight * i;
            vnew[vn].u1 = 255.5f;
            vnew[vn].v1 += (float)splitheight * i;

            vn++;
            vnew[vn] = vnew[vn - 2];
            vnew[vn].u0 = 0.5f;
            vnew[vn].v0 += (float)splitheight;
            vnew[vn].u1 = 0.5f;
            vnew[vn].v1 += (float)splitheight;

            vn++;
            vnew[vn] = vnew[vn - 2];
            vnew[vn].u0 = 0.5f;
            vnew[vn].v0 += (float)splitheight;
            vnew[vn].u1 = 0.5f;
            vnew[vn].v1 += (float)splitheight;
        }
        //*
        if (n_vertices > 12)
        {
            float texbound = (float)(splitheight << 1);
            for (int k = 0; k < n_vertices; k++)
            {
                if (vnew[k].v0 > texbound)
                    vnew[k].v0 = (float)fmod(vnew[k].v0, texbound);
            }
        }
        //*/
    }

    AllowShadeMods(vptr, n_vertices);
    for (i = 0; i < n_vertices; i++)
    {
        apply_shade_mods(&vptr[i]);
    }

    if (rdp.fog_mode >= RDP::fog_blend)
    {
        float fog;
        if (rdp.fog_mode == RDP::fog_blend)
            fog = 1.0f / maxval(1, rdp.fog_color & 0xFF);
        else
            fog = 1.0f / maxval(1, (~rdp.fog_color) & 0xFF);
        for (i = 0; i < n_vertices; i++)
        {
            vptr[i].f = fog;
        }
        grFogMode(GR_FOG_WITH_TABLE_ON_FOGCOORD_EXT);
    }

    ConvertCoordsConvert(vptr, n_vertices);

    if (g_settings->wireframe)
    {
        SetWireframeCol();
        grDrawLine(&vstd[0], &vstd[2]);
        grDrawLine(&vstd[2], &vstd[1]);
        grDrawLine(&vstd[1], &vstd[0]);
        grDrawLine(&vstd[2], &vstd[3]);
        grDrawLine(&vstd[3], &vstd[1]);
    }
    else
    {
        grDrawVertexArrayContiguous(GR_TRIANGLE_STRIP, n_vertices, vptr, sizeof(VERTEX));
    }

    rdp.tri_n += 2;

    delete[] vnew;
}

static void rdp_loadsync()
{
    WriteTrace(TraceRDP, TraceDebug, "loadsync - ignored");
}

static void rdp_pipesync()
{
    WriteTrace(TraceRDP, TraceDebug, "pipesync - ignored");
}

static void rdp_tilesync()
{
    WriteTrace(TraceRDP, TraceDebug, "tilesync - ignored");
}

static void rdp_fullsync()
{
    // Set an interrupt to allow the game to continue
    *gfx.MI_INTR_REG |= 0x20;
    gfx.CheckInterrupts();
    WriteTrace(TraceRDP, TraceDebug, "fullsync");
}

static void rdp_setkeygb()
{
    uint32_t sB = rdp.cmd1 & 0xFF;
    uint32_t cB = (rdp.cmd1 >> 8) & 0xFF;
    uint32_t sG = (rdp.cmd1 >> 16) & 0xFF;
    uint32_t cG = (rdp.cmd1 >> 24) & 0xFF;
    rdp.SCALE = (rdp.SCALE & 0xFF0000FF) | (sG << 16) | (sB << 8);
    rdp.CENTER = (rdp.CENTER & 0xFF0000FF) | (cG << 16) | (cB << 8);
    WriteTrace(TraceRDP, TraceDebug, "setkeygb. cG=%02lx, sG=%02lx, cB=%02lx, sB=%02lx", cG, sG, cB, sB);
}

static void rdp_setkeyr()
{
    uint32_t sR = rdp.cmd1 & 0xFF;
    uint32_t cR = (rdp.cmd1 >> 8) & 0xFF;
    rdp.SCALE = (rdp.SCALE & 0x00FFFFFF) | (sR << 24);
    rdp.CENTER = (rdp.CENTER & 0x00FFFFFF) | (cR << 24);
    WriteTrace(TraceRDP, TraceDebug, "setkeyr. cR=%02lx, sR=%02lx", cR, sR);
}

static void rdp_setconvert()
{
    /*
    rdp.YUV_C0 = 1.1647f  ;
    rdp.YUV_C1 = 0.79931f ;
    rdp.YUV_C2 = -0.1964f ;
    rdp.YUV_C3 = -0.40651f;
    rdp.YUV_C4 = 1.014f   ;
    */
    rdp.K4 = (uint8_t)(rdp.cmd1 >> 9) & 0x1FF;
    rdp.K5 = (uint8_t)(rdp.cmd1 & 0x1FF);
    WriteTrace(TraceRDP, TraceDebug, "setconvert. K4=%02lx K5=%02lx", rdp.K4, rdp.K5);
}

//
// setscissor - sets the screen clipping rectangle
//

static void rdp_setscissor()
{
    // clipper resolution is 320x240, scale based on computer resolution
    rdp.scissor_o.ul_x = /*minval(*/(uint32_t)(((rdp.cmd0 & 0x00FFF000) >> 14))/*, 320)*/;
    rdp.scissor_o.ul_y = /*minval(*/(uint32_t)(((rdp.cmd0 & 0x00000FFF) >> 2))/*, 240)*/;
    rdp.scissor_o.lr_x = /*minval(*/(uint32_t)(((rdp.cmd1 & 0x00FFF000) >> 14))/*, 320)*/;
    rdp.scissor_o.lr_y = /*minval(*/(uint32_t)(((rdp.cmd1 & 0x00000FFF) >> 2))/*, 240)*/;

    rdp.ci_upper_bound = rdp.scissor_o.ul_y;
    rdp.ci_lower_bound = rdp.scissor_o.lr_y;
    rdp.scissor_set = TRUE;

    WriteTrace(TraceRDP, TraceDebug, "setscissor: (%d,%d) -> (%d,%d)", rdp.scissor_o.ul_x, rdp.scissor_o.ul_y,
        rdp.scissor_o.lr_x, rdp.scissor_o.lr_y);

    rdp.update |= UPDATE_SCISSOR;

    if (rdp.view_scale[0] == 0) //viewport is not set?
    {
        rdp.view_scale[0] = (rdp.scissor_o.lr_x >> 1)*rdp.scale_x;
        rdp.view_scale[1] = (rdp.scissor_o.lr_y >> 1)*-rdp.scale_y;
        rdp.view_trans[0] = rdp.view_scale[0];
        rdp.view_trans[1] = -rdp.view_scale[1];
        rdp.update |= UPDATE_VIEWPORT;
    }
}

static void rdp_setprimdepth()
{
    rdp.prim_depth = (uint16_t)((rdp.cmd1 >> 16) & 0x7FFF);
    rdp.prim_dz = (uint16_t)(rdp.cmd1 & 0x7FFF);

    WriteTrace(TraceRDP, TraceDebug, "setprimdepth: %d", rdp.prim_depth);
}

static void rdp_setothermode()
{
#define F3DEX2_SETOTHERMODE(cmd,sft,len,data) { \
    rdp.cmd0 = (uint32_t)((cmd<<24) | ((32-(sft)-(len))<<8) | (((len)-1))); \
    rdp.cmd1 = (uint32_t)(data); \
    gfx_instruction[g_settings->ucode()][cmd] (); \
}
#define SETOTHERMODE(cmd,sft,len,data) { \
    rdp.cmd0 = (uint32_t)((cmd<<24) | ((sft)<<8) | (len)); \
    rdp.cmd1 = (uint32_t)data; \
    gfx_instruction[g_settings->ucode()][cmd] (); \
}

    WriteTrace(TraceRDP, TraceDebug, "rdp_setothermode");

    if (g_settings->ucode() == CSettings::ucode_F3DEX2 || g_settings->ucode() == CSettings::ucode_CBFD)
    {
        int cmd0 = rdp.cmd0;
        F3DEX2_SETOTHERMODE(0xE2, 0, 32, rdp.cmd1);         // SETOTHERMODE_L
        F3DEX2_SETOTHERMODE(0xE3, 0, 32, cmd0 & 0x00FFFFFF);    // SETOTHERMODE_H
    }
    else
    {
        int cmd0 = rdp.cmd0;
        SETOTHERMODE(0xB9, 0, 32, rdp.cmd1);            // SETOTHERMODE_L
        SETOTHERMODE(0xBA, 0, 32, cmd0 & 0x00FFFFFF);       // SETOTHERMODE_H
    }
}

void load_palette(uint32_t addr, uint16_t start, uint16_t count)
{
    WriteTrace(TraceRDP, TraceDebug, "Loading palette... ");
    uint16_t *dpal = rdp.pal_8 + start;
    uint16_t end = start + count;
    uint16_t *spal = (uint16_t*)(gfx.RDRAM + (addr & BMASK));

    for (uint16_t i = start; i < end; i++)
    {
        *(dpal++) = *(uint16_t *)(gfx.RDRAM + (addr ^ 2));
        addr += 2;

        WriteTrace(TraceTLUT, TraceDebug, "%d: %08lx", i, *(uint16_t *)(gfx.RDRAM + (addr ^ 2)));
    }
    if (g_settings->ghq_hirs)
    {
        memcpy((uint8_t*)(rdp.pal_8_rice + start), spal, count << 1);
    }
    start >>= 4;
    end = start + (count >> 4);
    if (end == start) // it can be if count < 16
        end = start + 1;
    for (uint16_t p = start; p < end; p++)
    {
        rdp.pal_8_crc[p] = CRC32(0xFFFFFFFF, &rdp.pal_8[(p << 4)], 32);
    }
    rdp.pal_256_crc = CRC32(0xFFFFFFFF, rdp.pal_8_crc, 64);
    WriteTrace(TraceRDP, TraceDebug, "Done.");
}

static void rdp_loadtlut()
{
    uint32_t tile = (rdp.cmd1 >> 24) & 0x07;
    uint16_t start = rdp.tiles[tile].t_mem - 256; // starting location in the palettes
    //  uint16_t start = ((uint16_t)(rdp.cmd1 >> 2) & 0x3FF) + 1;
    uint16_t count = ((uint16_t)(rdp.cmd1 >> 14) & 0x3FF) + 1;    // number to copy

    if (rdp.timg.addr + (count << 1) > BMASK)
        count = (uint16_t)((BMASK - rdp.timg.addr) >> 1);

    if (start + count > 256) count = 256 - start;

    WriteTrace(TraceRDP, TraceDebug, "loadtlut: tile: %d, start: %d, count: %d, from: %08lx", tile, start, count,
        rdp.timg.addr);

    load_palette(rdp.timg.addr, start, count);

    rdp.timg.addr += count << 1;

    if (rdp.tbuff_tex) //paranoid check.
    {
        //the buffer is definitely wrong, as there must be no CI frame buffers
        //find and remove it
        for (int i = 0; i < voodoo.num_tmu; i++)
        {
            for (int j = 0; j < rdp.texbufs[i].count; j++)
            {
                if (&(rdp.texbufs[i].images[j]) == rdp.tbuff_tex)
                {
                    rdp.texbufs[i].count--;
                    if (j < rdp.texbufs[i].count)
                        memcpy(&(rdp.texbufs[i].images[j]), &(rdp.texbufs[i].images[j + 1]), sizeof(TBUFF_COLOR_IMAGE)*(rdp.texbufs[i].count - j));
                    return;
                }
            }
        }
    }
}

int tile_set = 0;
static void rdp_settilesize()
{
    uint32_t tile = (rdp.cmd1 >> 24) & 0x07;
    rdp.last_tile_size = tile;

    rdp.tiles[tile].f_ul_s = (float)((rdp.cmd0 >> 12) & 0xFFF) / 4.0f;
    rdp.tiles[tile].f_ul_t = (float)(rdp.cmd0 & 0xFFF) / 4.0f;

    int ul_s = (rdp.cmd0 >> 14) & 0x03ff;
    int ul_t = (rdp.cmd0 >> 2) & 0x03ff;
    int lr_s = (rdp.cmd1 >> 14) & 0x03ff;
    int lr_t = (rdp.cmd1 >> 2) & 0x03ff;

    if (lr_s == 0 && ul_s == 0)  //pokemon puzzle league set such tile size
        wrong_tile = tile;
    else if (wrong_tile == (int)tile)
        wrong_tile = -1;

    if (g_settings->use_sts1_only)
    {
        // ** USE FIRST SETTILESIZE ONLY **
        // This option helps certain textures while using the 'Alternate texture size method',
        //  but may break others.  (should help more than break)

        if (tile_set)
        {
            // coords in 10.2 format
            rdp.tiles[tile].ul_s = ul_s;
            rdp.tiles[tile].ul_t = ul_t;
            rdp.tiles[tile].lr_s = lr_s;
            rdp.tiles[tile].lr_t = lr_t;
            tile_set = 0;
        }
    }
    else
    {
        // coords in 10.2 format
        rdp.tiles[tile].ul_s = ul_s;
        rdp.tiles[tile].ul_t = ul_t;
        rdp.tiles[tile].lr_s = lr_s;
        rdp.tiles[tile].lr_t = lr_t;
    }

    // handle wrapping
    if (rdp.tiles[tile].lr_s < rdp.tiles[tile].ul_s) rdp.tiles[tile].lr_s += 0x400;
    if (rdp.tiles[tile].lr_t < rdp.tiles[tile].ul_t) rdp.tiles[tile].lr_t += 0x400;

    rdp.update |= UPDATE_TEXTURE;

    rdp.first = 1;

    WriteTrace(TraceRDP, TraceDebug, "settilesize: tile: %d, ul_s: %d, ul_t: %d, lr_s: %d, lr_t: %d, f_ul_s: %f, f_ul_t: %f",
        tile, ul_s, ul_t, lr_s, lr_t, rdp.tiles[tile].f_ul_s, rdp.tiles[tile].f_ul_t);
}

void setTBufTex(uint16_t t_mem, uint32_t cnt)
{
    WriteTrace(TraceRDP, TraceDebug, "setTBufTex t_mem=%d, cnt=%d", t_mem, cnt);
    TBUFF_COLOR_IMAGE * pTbufTex = rdp.tbuff_tex;
    for (int i = 0; i < 2; i++)
    {
        WriteTrace(TraceRDP, TraceDebug, "Before: ");
        if (rdp.aTBuffTex[i]) {
            WriteTrace(TraceRDP, TraceDebug, "rdp.aTBuffTex[%d]: tmu=%d t_mem=%d tile=%d", i, rdp.aTBuffTex[i]->tmu, rdp.aTBuffTex[i]->t_mem, rdp.aTBuffTex[i]->tile);
        }
        else {
            WriteTrace(TraceRDP, TraceDebug, "rdp.aTBuffTex[%d]=0", i);
        }
        if ((rdp.aTBuffTex[i] == 0 && rdp.aTBuffTex[i ^ 1] != pTbufTex) || (rdp.aTBuffTex[i] && rdp.aTBuffTex[i]->t_mem >= t_mem && rdp.aTBuffTex[i]->t_mem < t_mem + cnt))
        {
            if (pTbufTex)
            {
                rdp.aTBuffTex[i] = pTbufTex;
                rdp.aTBuffTex[i]->t_mem = t_mem;
                pTbufTex = 0;
                WriteTrace(TraceRDP, TraceDebug, "rdp.aTBuffTex[%d] tmu=%d t_mem=%d", i, rdp.aTBuffTex[i]->tmu, rdp.aTBuffTex[i]->t_mem);
            }
            else
            {
                rdp.aTBuffTex[i] = 0;
                WriteTrace(TraceRDP, TraceDebug, "rdp.aTBuffTex[%d]=0", i);
            }
        }
    }
}

static inline void loadBlock(uint32_t *src, uint32_t *dst, uint32_t off, int dxt, int cnt)
{
    uint32_t *v5;
    int v6;
    uint32_t *v7;
    uint32_t v8;
    int v9;
    uint32_t v10;
    uint32_t *v11;
    uint32_t v12;
    uint32_t v13;
    uint32_t v14;
    int v15;
    int v16;
    uint32_t *v17;
    int v18;
    uint32_t v19;
    uint32_t v20;
    int i;

    v5 = dst;
    v6 = cnt;
    if (cnt)
    {
        v7 = (uint32_t *)((char *)src + (off & 0xFFFFFFFC));
        v8 = off & 3;
        if (!(off & 3))
            goto LABEL_23;
        v9 = 4 - v8;
        v10 = *v7;
        v11 = v7 + 1;
        do
        {
            v10 = __ROL__(v10, 8);
            --v8;
        } while (v8);
        do
        {
            v10 = __ROL__(v10, 8);
            *(uint8_t *)v5 = v10;
            v5 = (uint32_t *)((char *)v5 + 1);
            --v9;
        } while (v9);
        v12 = *v11;
        v7 = v11 + 1;
        *v5 = bswap32(v12);
        ++v5;
        v6 = cnt - 1;
        if (cnt != 1)
        {
        LABEL_23:
            do
            {
                *v5 = bswap32(*v7);
                v5[1] = bswap32(v7[1]);
                v7 += 2;
                v5 += 2;
                --v6;
            } while (v6);
        }
        v13 = off & 3;
        if (off & 3)
        {
            v14 = *(uint32_t *)((char *)src + ((8 * cnt + off) & 0xFFFFFFFC));
            do
            {
                v14 = __ROL__(v14, 8);
                *(uint8_t *)v5 = v14;
                v5 = (uint32_t *)((char *)v5 + 1);
                --v13;
            } while (v13);
        }
    }
    v15 = cnt;
    v16 = 0;
    v17 = dst;
    v18 = 0;
dxt_test:
    while (1)
    {
        v17 += 2;
        --v15;
        if (!v15)
            break;
        v16 += dxt;
        if (v16 < 0)
        {
            while (1)
            {
                ++v18;
                --v15;
                if (!v15)
                    goto end_dxt_test;
                v16 += dxt;
                if (v16 >= 0)
                {
                    for (i = v15; v18; --v18)
                    {
                        v19 = *v17;
                        *v17 = v17[1];
                        v17[1] = v19;
                        v17 += 2;
                    }
                    v15 = i;
                    goto dxt_test;
                }
            }
        }
    }
end_dxt_test:
    while (v18)
    {
        v20 = *v17;
        *v17 = v17[1];
        v17[1] = v20;
        v17 += 2;
        --v18;
    }
}

void LoadBlock32b(uint32_t tile, uint32_t ul_s, uint32_t ul_t, uint32_t lr_s, uint32_t dxt);
static void rdp_loadblock()
{
    if (rdp.skip_drawing)
    {
        WriteTrace(TraceRDP, TraceDebug, "loadblock skipped");
        return;
    }
    uint32_t tile = (uint32_t)((rdp.cmd1 >> 24) & 0x07);
    uint32_t dxt = (uint32_t)(rdp.cmd1 & 0x0FFF);
    uint16_t lr_s = (uint16_t)(rdp.cmd1 >> 14) & 0x3FF;
    if (ucode5_texshiftaddr)
    {
        if (ucode5_texshift % ((lr_s + 1) << 3))
        {
            rdp.timg.addr -= ucode5_texshift;
            ucode5_texshiftaddr = 0;
            ucode5_texshift = 0;
            ucode5_texshiftcount = 0;
        }
        else
            ucode5_texshiftcount++;
    }

    rdp.addr[rdp.tiles[tile].t_mem] = rdp.timg.addr;

    // ** DXT is used for swapping every other line
    /*  double fdxt = (double)0x8000000F/(double)((uint32_t)(2047/(dxt-1))); // F for error
    uint32_t _dxt = (uint32_t)fdxt;*/

    // 0x00000800 -> 0x80000000 (so we can check the sign bit instead of the 11th bit)
    uint32_t _dxt = dxt << 20;

    uint32_t addr = segoffset(rdp.timg.addr) & BMASK;

    // lr_s specifies number of 64-bit words to copy
    // 10.2 format
    uint16_t ul_s = (uint16_t)((rdp.cmd0 >> 14) & 0x3FF);
    uint16_t ul_t = (uint16_t)((rdp.cmd0 >> 2) & 0x3FF);

    rdp.tiles[tile].ul_s = ul_s;
    rdp.tiles[tile].ul_t = ul_t;
    rdp.tiles[tile].lr_s = lr_s;

    rdp.timg.set_by = 0;  // load block

    LOAD_TILE_INFO &info = rdp.load_info[rdp.tiles[tile].t_mem];
    info.tile_width = lr_s;
    info.dxt = dxt;

    // do a quick boundary check before copying to eliminate the possibility for exception
    if (ul_s >= 512) {
        lr_s = 1;   // 1 so that it doesn't die on memcpy
        ul_s = 511;
    }
    if (ul_s + lr_s > 512)
        lr_s = 512 - ul_s;

    if (addr + (lr_s << 3) > BMASK + 1)
        lr_s = (uint16_t)((BMASK - addr) >> 3);

    //angrylion's advice to use ul_s in texture image offset and cnt calculations.
    //Helps to fix Vigilante 8 jpeg backgrounds and logos
    uint32_t off = rdp.timg.addr + (ul_s << rdp.tiles[tile].size >> 1);
    unsigned char *dst = ((unsigned char *)rdp.tmem) + (rdp.tiles[tile].t_mem << 3);
    uint32_t cnt = lr_s - ul_s + 1;
    if (rdp.tiles[tile].size == 3)
        cnt <<= 1;

    if (((rdp.tiles[tile].t_mem + cnt) << 3) > sizeof(rdp.tmem)) {
        cnt = (sizeof(rdp.tmem) >> 3) - (rdp.tiles[tile].t_mem);
    }

    if (rdp.timg.size == 3)
        LoadBlock32b(tile, ul_s, ul_t, lr_s, dxt);
    else
        loadBlock((uint32_t *)gfx.RDRAM, (uint32_t *)dst, off, _dxt, cnt);

    rdp.timg.addr += cnt << 3;
    rdp.tiles[tile].lr_t = ul_t + ((dxt*cnt) >> 11);

    rdp.update |= UPDATE_TEXTURE;

    WriteTrace(TraceRDP, TraceDebug, "loadblock: tile: %d, ul_s: %d, ul_t: %d, lr_s: %d, dxt: %08lx -> %08lx",
        tile, ul_s, ul_t, lr_s,
        dxt, _dxt);

    if (g_settings->fb_hwfbe_enabled())
    {
        setTBufTex(rdp.tiles[tile].t_mem, cnt);
    }
}

static inline void loadTile(uint32_t *src, uint32_t *dst, int width, int height, int line, int off, uint32_t *end)
{
    uint32_t *v7;
    int v8;
    uint32_t *v9;
    int v10;
    int v11;
    int v12;
    uint32_t *v13;
    int v14;
    int v15;
    uint32_t v16;
    uint32_t *v17;
    uint32_t v18;
    int v19;
    uint32_t v20;
    int v21;
    uint32_t v22;
    int v23;
    uint32_t *v24;
    int v25;
    int v26;
    uint32_t *v27;
    int v28;
    int v29;
    int v30;
    uint32_t *v31;

    v7 = dst;
    v8 = width;
    v9 = src;
    v10 = off;
    v11 = 0;
    v12 = height;
    do
    {
        if (end < v7)
            break;
        v31 = v7;
        v30 = v8;
        v29 = v12;
        v28 = v11;
        v27 = v9;
        v26 = v10;
        if (v8)
        {
            v25 = v8;
            v24 = v9;
            v23 = v10;
            v13 = (uint32_t *)((char *)v9 + (v10 & 0xFFFFFFFC));
            v14 = v10 & 3;
            if (!(v10 & 3))
                goto LABEL_20;
            v15 = 4 - v14;
            v16 = *v13;
            v17 = v13 + 1;
            do
            {
                v16 = __ROL__(v16, 8);
                --v14;
            } while (v14);
            do
            {
                v16 = __ROL__(v16, 8);
                *(uint8_t *)v7 = (v16  & 0xFF);
                v7 = (uint32_t *)((char *)v7 + 1);
                --v15;
            } while (v15);
            v18 = *v17;
            v13 = v17 + 1;
            *v7 = bswap32(v18);
            ++v7;
            --v8;
            if (v8)
            {
            LABEL_20:
                do
                {
                    *v7 = bswap32(*v13);
                    v7[1] = bswap32(v13[1]);
                    v13 += 2;
                    v7 += 2;
                    --v8;
                } while (v8);
            }
            v19 = v23 & 3;
            if (v23 & 3)
            {
                v20 = *(uint32_t *)((char *)v24 + ((8 * v25 + v23) & 0xFFFFFFFC));
                do
                {
                    v20 = __ROL__(v20, 8);
                    *(uint8_t *)v7 = (v20 & 0xFF);
                    v7 = (uint32_t *)((char *)v7 + 1);
                    --v19;
                } while (v19);
            }
        }
        v9 = v27;
        v21 = v29;
        v8 = v30;
        v11 = v28 ^ 1;
        if (v28 == 1)
        {
            v7 = v31;
            if (v30)
            {
                do
                {
                    v22 = *v7;
                    *v7 = v7[1];
                    v7[1] = v22;
                    v7 += 2;
                    --v8;
                } while (v8);
            }
            v21 = v29;
            v8 = v30;
        }
        v10 = line + v26;
        v12 = v21 - 1;
    } while (v12);
}

void LoadTile32b(uint32_t tile, uint32_t ul_s, uint32_t ul_t, uint32_t width, uint32_t height);
static void rdp_loadtile()
{
    if (rdp.skip_drawing)
    {
        WriteTrace(TraceRDP, TraceDebug, "loadtile skipped");
        return;
    }
    rdp.timg.set_by = 1;  // load tile

    uint32_t tile = (uint32_t)((rdp.cmd1 >> 24) & 0x07);

    rdp.addr[rdp.tiles[tile].t_mem] = rdp.timg.addr;

    uint16_t ul_s = (uint16_t)((rdp.cmd0 >> 14) & 0x03FF);
    uint16_t ul_t = (uint16_t)((rdp.cmd0 >> 2) & 0x03FF);
    uint16_t lr_s = (uint16_t)((rdp.cmd1 >> 14) & 0x03FF);
    uint16_t lr_t = (uint16_t)((rdp.cmd1 >> 2) & 0x03FF);

    if (lr_s < ul_s || lr_t < ul_t) return;

    if (wrong_tile >= 0)  //there was a tile with zero length
    {
        rdp.tiles[wrong_tile].lr_s = lr_s;

        if (rdp.tiles[tile].size > rdp.tiles[wrong_tile].size)
            rdp.tiles[wrong_tile].lr_s <<= (rdp.tiles[tile].size - rdp.tiles[wrong_tile].size);
        else if (rdp.tiles[tile].size < rdp.tiles[wrong_tile].size)
            rdp.tiles[wrong_tile].lr_s >>= (rdp.tiles[wrong_tile].size - rdp.tiles[tile].size);
        rdp.tiles[wrong_tile].lr_t = lr_t;
        rdp.tiles[wrong_tile].mask_s = rdp.tiles[wrong_tile].mask_t = 0;
        //     wrong_tile = -1;
    }

    if (rdp.tbuff_tex)// && (rdp.tiles[tile].format == 0))
    {
        WriteTrace(TraceRDP, TraceDebug, "loadtile: tbuff_tex ul_s: %d, ul_t:%d", ul_s, ul_t);
        rdp.tbuff_tex->tile_uls = ul_s;
        rdp.tbuff_tex->tile_ult = ul_t;
    }

    if (g_settings->hacks(CSettings::hack_Tonic) && tile == 7)
    {
        rdp.tiles[0].ul_s = ul_s;
        rdp.tiles[0].ul_t = ul_t;
        rdp.tiles[0].lr_s = lr_s;
        rdp.tiles[0].lr_t = lr_t;
    }

    uint32_t height = lr_t - ul_t + 1;   // get height
    uint32_t width = lr_s - ul_s + 1;

    LOAD_TILE_INFO &info = rdp.load_info[rdp.tiles[tile].t_mem];
    info.tile_ul_s = ul_s;
    info.tile_ul_t = ul_t;
    info.tile_width = (rdp.tiles[tile].mask_s ? minval((uint16_t)width, 1 << rdp.tiles[tile].mask_s) : (uint16_t)width);
    info.tile_height = (rdp.tiles[tile].mask_t ? minval((uint16_t)height, 1 << rdp.tiles[tile].mask_t) : (uint16_t)height);
    if (g_settings->hacks(CSettings::hack_MK64))
    {
        if (info.tile_width % 2)
        {
            info.tile_width--;
        }
        if (info.tile_height % 2)
        {
            info.tile_height--;
        }
    }
    info.tex_width = rdp.timg.width;
    info.tex_size = rdp.timg.size;

    int line_n = rdp.timg.width << rdp.tiles[tile].size >> 1;
    uint32_t offs = ul_t * line_n;
    offs += ul_s << rdp.tiles[tile].size >> 1;
    offs += rdp.timg.addr;
    if (offs >= BMASK)
        return;

    if (rdp.timg.size == 3)
    {
        LoadTile32b(tile, ul_s, ul_t, width, height);
    }
    else
    {
        // check if points to bad location
        if (offs + line_n*height > BMASK)
            height = (BMASK - offs) / line_n;
        if (height == 0)
            return;

        uint32_t wid_64 = rdp.tiles[tile].line;
        unsigned char *dst = ((unsigned char *)rdp.tmem) + (rdp.tiles[tile].t_mem << 3);
        unsigned char *end = ((unsigned char *)rdp.tmem) + 4096 - (wid_64 << 3);
        loadTile((uint32_t *)gfx.RDRAM, (uint32_t *)dst, wid_64, height, line_n, offs, (uint32_t *)end);
    }
    WriteTrace(TraceRDP, TraceDebug, "loadtile: tile: %d, ul_s: %d, ul_t: %d, lr_s: %d, lr_t: %d", tile,
        ul_s, ul_t, lr_s, lr_t);

    if (g_settings->fb_hwfbe_enabled())
    {
        setTBufTex(rdp.tiles[tile].t_mem, rdp.tiles[tile].line*height);
    }
}

static void rdp_settile()
{
    tile_set = 1; // used to check if we only load the first settilesize

    rdp.first = 0;

    rdp.last_tile = (uint32_t)((rdp.cmd1 >> 24) & 0x07);
    TILE *tile = &rdp.tiles[rdp.last_tile];

    tile->format = (uint8_t)((rdp.cmd0 >> 21) & 0x07);
    tile->size = (uint8_t)((rdp.cmd0 >> 19) & 0x03);
    tile->line = (uint16_t)((rdp.cmd0 >> 9) & 0x01FF);
    tile->t_mem = (uint16_t)(rdp.cmd0 & 0x1FF);
    tile->palette = (uint8_t)((rdp.cmd1 >> 20) & 0x0F);
    tile->clamp_t = (uint8_t)((rdp.cmd1 >> 19) & 0x01);
    tile->mirror_t = (uint8_t)((rdp.cmd1 >> 18) & 0x01);
    tile->mask_t = (uint8_t)((rdp.cmd1 >> 14) & 0x0F);
    tile->shift_t = (uint8_t)((rdp.cmd1 >> 10) & 0x0F);
    tile->clamp_s = (uint8_t)((rdp.cmd1 >> 9) & 0x01);
    tile->mirror_s = (uint8_t)((rdp.cmd1 >> 8) & 0x01);
    tile->mask_s = (uint8_t)((rdp.cmd1 >> 4) & 0x0F);
    tile->shift_s = (uint8_t)(rdp.cmd1 & 0x0F);

    rdp.update |= UPDATE_TEXTURE;

    WriteTrace(TraceRDP, TraceDebug, "settile: tile: %d, format: %s, size: %s, line: %d, "
        "t_mem: %08lx, palette: %d, clamp_t/mirror_t: %s, mask_t: %d, "
        "shift_t: %d, clamp_s/mirror_s: %s, mask_s: %d, shift_s: %d",
        rdp.last_tile, str_format[tile->format], str_size[tile->size], tile->line,
        tile->t_mem, tile->palette, str_cm[(tile->clamp_t << 1) | tile->mirror_t], tile->mask_t,
        tile->shift_t, str_cm[(tile->clamp_s << 1) | tile->mirror_s], tile->mask_s, tile->shift_s);

    if (g_settings->fb_hwfbe_enabled() && rdp.last_tile < rdp.cur_tile + 2)
    {
        for (int i = 0; i < 2; i++)
        {
            if (rdp.aTBuffTex[i])
            {
                if (rdp.aTBuffTex[i]->t_mem == tile->t_mem)
                {
                    if (rdp.aTBuffTex[i]->size == tile->size)
                    {
                        rdp.aTBuffTex[i]->tile = rdp.last_tile;
                        rdp.aTBuffTex[i]->info.format = tile->format == 0 ? GR_TEXFMT_RGB_565 : GR_TEXFMT_ALPHA_INTENSITY_88;
                        WriteTrace(TraceRDP, TraceDebug, "rdp.aTBuffTex[%d] tile=%d, format=%s", i, rdp.last_tile, tile->format == 0 ? "RGB565" : "Alpha88");
                    }
                    else
                        rdp.aTBuffTex[i] = 0;
                    break;
                }
                else if (rdp.aTBuffTex[i]->tile == rdp.last_tile) //wrong! t_mem must be the same
                    rdp.aTBuffTex[i] = 0;
            }
        }
    }
}

//
// fillrect - fills a rectangle
//

static void rdp_fillrect()
{
    uint32_t ul_x = ((rdp.cmd1 & 0x00FFF000) >> 14);
    uint32_t ul_y = (rdp.cmd1 & 0x00000FFF) >> 2;
    uint32_t lr_x = ((rdp.cmd0 & 0x00FFF000) >> 14) + 1;
    uint32_t lr_y = ((rdp.cmd0 & 0x00000FFF) >> 2) + 1;
    if ((ul_x > lr_x) || (ul_y > lr_y))
    {
        WriteTrace(TraceRDP, TraceDebug, "Fillrect. Wrong coordinates. Skipped");
        return;
    }
    bool pd_multiplayer = g_settings->ucode() == CSettings::ucode_PerfectDark && rdp.cycle_mode == 3 && rdp.fill_color == 0xFFFCFFFC;
    if ((rdp.cimg == rdp.zimg) || (g_settings->fb_emulation_enabled() && rdp.ci_count > 0 && rdp.frame_buffers[rdp.ci_count - 1].status == ci_zimg) || pd_multiplayer)
    {
        WriteTrace(TraceRDP, TraceDebug, "Fillrect - cleared the depth buffer");
        if (!g_settings->hacks(CSettings::hack_Hyperbike) || rdp.ci_width > 64) //do not clear main depth buffer for aux depth buffers
        {
            update_scissor();
            grDepthMask(FXTRUE);
            grColorMask(FXFALSE, FXFALSE);
            grBufferClear(0, 0, rdp.fill_color ? rdp.fill_color & 0xFFFF : 0xFFFF);
            grColorMask(FXTRUE, FXTRUE);
            rdp.update |= UPDATE_ZBUF_ENABLED;
        }
        ul_x = minval(maxval(ul_x, rdp.scissor_o.ul_x), rdp.scissor_o.lr_x);
        lr_x = minval(maxval(lr_x, rdp.scissor_o.ul_x), rdp.scissor_o.lr_x);
        ul_y = minval(maxval(ul_y, rdp.scissor_o.ul_y), rdp.scissor_o.lr_y);
        lr_y = minval(maxval(lr_y, rdp.scissor_o.ul_y), rdp.scissor_o.lr_y);
        uint32_t zi_width_in_dwords = rdp.ci_width >> 1;
        ul_x >>= 1;
        lr_x >>= 1;
        uint32_t * dst = (uint32_t*)(gfx.RDRAM + rdp.cimg);
        dst += ul_y * zi_width_in_dwords;
        for (uint32_t y = ul_y; y < lr_y; y++)
        {
            for (uint32_t x = ul_x; x < lr_x; x++)
            {
                dst[x] = rdp.fill_color;
            }
            dst += zi_width_in_dwords;
        }
        return;
    }

    if (rdp.skip_drawing)
    {
        WriteTrace(TraceRDP, TraceDebug, "Fillrect skipped");
        return;
    }

    if (rdp.cur_image && (rdp.cur_image->format != 0) && (rdp.cycle_mode == 3) && (rdp.cur_image->width == lr_x - ul_x) && (rdp.cur_image->height == lr_y - ul_y))
    {
        uint32_t color = rdp.fill_color;
        if (rdp.ci_size < 3)
        {
            color = ((color & 1) ? 0xFF : 0) |
                ((uint32_t)((float)((color & 0xF800) >> 11) / 31.0f * 255.0f) << 24) |
                ((uint32_t)((float)((color & 0x07C0) >> 6) / 31.0f * 255.0f) << 16) |
                ((uint32_t)((float)((color & 0x003E) >> 1) / 31.0f * 255.0f) << 8);
        }
        grDepthMask(FXFALSE);
        grBufferClear(color, 0, 0xFFFF);
        grDepthMask(FXTRUE);
        rdp.update |= UPDATE_ZBUF_ENABLED;
        WriteTrace(TraceRDP, TraceDebug, "Fillrect - cleared the texture buffer");
        return;
    }

    // Update scissor
    update_scissor();

    if (g_settings->decrease_fillrect_edge && rdp.cycle_mode == 0)
    {
        lr_x--; lr_y--;
    }
    WriteTrace(TraceRDP, TraceDebug, "fillrect (%d,%d) -> (%d,%d), cycle mode: %d, #%d, #%d", ul_x, ul_y, lr_x, lr_y, rdp.cycle_mode,
        rdp.tri_n, rdp.tri_n + 1);

    WriteTrace(TraceRDP, TraceDebug, "scissor (%d,%d) -> (%d,%d)", rdp.scissor.ul_x, rdp.scissor.ul_y, rdp.scissor.lr_x,
        rdp.scissor.lr_y);

    // KILL the floating point error with 0.01f
    int32_t s_ul_x = (uint32_t)minval(maxval(ul_x * rdp.scale_x + rdp.offset_x + 0.01f, rdp.scissor.ul_x), rdp.scissor.lr_x);
    int32_t s_lr_x = (uint32_t)minval(maxval(lr_x * rdp.scale_x + rdp.offset_x + 0.01f, rdp.scissor.ul_x), rdp.scissor.lr_x);
    int32_t s_ul_y = (uint32_t)minval(maxval(ul_y * rdp.scale_y + rdp.offset_y + 0.01f, rdp.scissor.ul_y), rdp.scissor.lr_y);
    int32_t s_lr_y = (uint32_t)minval(maxval(lr_y * rdp.scale_y + rdp.offset_y + 0.01f, rdp.scissor.ul_y), rdp.scissor.lr_y);

    if (s_lr_x < 0) s_lr_x = 0;
    if (s_lr_y < 0) s_lr_y = 0;
    if ((uint32_t)s_ul_x > g_settings->res_x()) { s_ul_x = g_settings->res_x(); }
    if ((uint32_t)s_ul_y > g_settings->res_y()) { s_ul_y = g_settings->res_y(); }

    WriteTrace(TraceRDP, TraceDebug, " - %d, %d, %d, %d", s_ul_x, s_ul_y, s_lr_x, s_lr_y);

    grFogMode(GR_FOG_DISABLE);

    const float Z = (rdp.cycle_mode == 3) ? 0.0f : set_sprite_combine_mode();

    // Draw the rectangle
    VERTEX v[4] = {
        { (float)s_ul_x, (float)s_ul_y, Z, 1.0f, 0, 0, 0, 0, { 0, 0, 0, 0 }, 0, 0, 0, 0, 0, 0 },
        { (float)s_lr_x, (float)s_ul_y, Z, 1.0f, 0, 0, 0, 0, { 0, 0, 0, 0 }, 0, 0, 0, 0, 0, 0 },
        { (float)s_ul_x, (float)s_lr_y, Z, 1.0f, 0, 0, 0, 0, { 0, 0, 0, 0 }, 0, 0, 0, 0, 0, 0 },
        { (float)s_lr_x, (float)s_lr_y, Z, 1.0f, 0, 0, 0, 0, { 0, 0, 0, 0 }, 0, 0, 0, 0, 0, 0 } };

    if (rdp.cycle_mode == 3)
    {
        uint32_t color = rdp.fill_color;

        if (g_settings->hacks(CSettings::hack_PMario) && rdp.ci_count > 0 && rdp.frame_buffers[rdp.ci_count - 1].status == ci_aux)
        {
            //background of auxiliary frame buffers must have zero alpha.
            //make it black, set 0 alpha to plack pixels on frame buffer read
            color = 0;
        }
        else if (rdp.ci_size < 3)
        {
            color = ((color & 1) ? 0xFF : 0) |
                ((uint32_t)((float)((color & 0xF800) >> 11) / 31.0f * 255.0f) << 24) |
                ((uint32_t)((float)((color & 0x07C0) >> 6) / 31.0f * 255.0f) << 16) |
                ((uint32_t)((float)((color & 0x003E) >> 1) / 31.0f * 255.0f) << 8);
        }

        grConstantColorValue(color);

        grColorCombine(GR_COMBINE_FUNCTION_LOCAL,
            GR_COMBINE_FACTOR_NONE,
            GR_COMBINE_LOCAL_CONSTANT,
            GR_COMBINE_OTHER_NONE,
            FXFALSE);

        grAlphaCombine(GR_COMBINE_FUNCTION_LOCAL,
            GR_COMBINE_FACTOR_NONE,
            GR_COMBINE_LOCAL_CONSTANT,
            GR_COMBINE_OTHER_NONE,
            FXFALSE);

        grAlphaBlendFunction(GR_BLEND_ONE, GR_BLEND_ZERO, GR_BLEND_ONE, GR_BLEND_ZERO);

        grAlphaTestFunction(GR_CMP_ALWAYS);
        if (grStippleModeExt)
        {
            grStippleModeExt(GR_STIPPLE_DISABLE);
        }

        grCullMode(GR_CULL_DISABLE);
        grFogMode(GR_FOG_DISABLE);
        grDepthBufferFunction(GR_CMP_ALWAYS);
        grDepthMask(FXFALSE);

        rdp.update |= UPDATE_COMBINE | UPDATE_CULL_MODE | UPDATE_FOG_ENABLED | UPDATE_ZBUF_ENABLED;
    }
    else
    {
        uint32_t cmb_mode_c = (rdp.cycle1 << 16) | (rdp.cycle2 & 0xFFFF);
        uint32_t cmb_mode_a = (rdp.cycle1 & 0x0FFF0000) | ((rdp.cycle2 >> 16) & 0x00000FFF);
        if (cmb_mode_c == 0x9fff9fff || cmb_mode_a == 0x09ff09ff) //shade
        {
            AllowShadeMods(v, 4);
            for (int k = 0; k < 4; k++)
            {
                apply_shade_mods(&v[k]);
            }
        }
        if ((rdp.othermode_l & 0x4000) && ((rdp.othermode_l >> 16) == 0x0550)) //special blender mode for Bomberman64
        {
            grAlphaCombine(GR_COMBINE_FUNCTION_LOCAL,
                GR_COMBINE_FACTOR_NONE,
                GR_COMBINE_LOCAL_CONSTANT,
                GR_COMBINE_OTHER_NONE,
                FXFALSE);
            grConstantColorValue((cmb.ccolor & 0xFFFFFF00) | (rdp.fog_color & 0xFF));
            rdp.update |= UPDATE_COMBINE;
        }
    }

    if (g_settings->wireframe)
    {
        SetWireframeCol();
        grDrawLine(&v[0], &v[2]);
        grDrawLine(&v[2], &v[1]);
        grDrawLine(&v[1], &v[0]);
        grDrawLine(&v[2], &v[3]);
        grDrawLine(&v[3], &v[1]);
        //grDrawLine (&v[1], &v[2]);
    }
    else
    {
        grDrawTriangle(&v[0], &v[2], &v[1]);
        grDrawTriangle(&v[2], &v[3], &v[1]);
    }

    rdp.tri_n += 2;
}

//
// setfillcolor - sets the filling color
//

static void rdp_setfillcolor()
{
    rdp.fill_color = rdp.cmd1;
    rdp.update |= UPDATE_ALPHA_COMPARE | UPDATE_COMBINE;

    WriteTrace(TraceRDP, TraceDebug, "setfillcolor: %08lx", rdp.cmd1);
}

static void rdp_setfogcolor()
{
    rdp.fog_color = rdp.cmd1;
    rdp.update |= UPDATE_COMBINE | UPDATE_FOG_ENABLED;

    WriteTrace(TraceRDP, TraceDebug, "setfogcolor - %08lx", rdp.cmd1);
}

static void rdp_setblendcolor()
{
    rdp.blend_color = rdp.cmd1;
    rdp.update |= UPDATE_COMBINE;

    WriteTrace(TraceRDP, TraceDebug, "setblendcolor: %08lx", rdp.cmd1);
}

static void rdp_setprimcolor()
{
    rdp.prim_color = rdp.cmd1;
    rdp.prim_lodmin = (rdp.cmd0 >> 8) & 0xFF;
    rdp.prim_lodfrac = maxval(rdp.cmd0 & 0xFF, rdp.prim_lodmin);
    rdp.update |= UPDATE_COMBINE;

    WriteTrace(TraceRDP, TraceDebug, "setprimcolor: %08lx, lodmin: %d, lodfrac: %d", rdp.cmd1, rdp.prim_lodmin,
        rdp.prim_lodfrac);
}

static void rdp_setenvcolor()
{
    rdp.env_color = rdp.cmd1;
    rdp.update |= UPDATE_COMBINE;

    WriteTrace(TraceRDP, TraceDebug, "setenvcolor: %08lx", rdp.cmd1);
}

static void rdp_setcombine()
{
    rdp.c_a0 = (uint8_t)((rdp.cmd0 >> 20) & 0xF);
    rdp.c_b0 = (uint8_t)((rdp.cmd1 >> 28) & 0xF);
    rdp.c_c0 = (uint8_t)((rdp.cmd0 >> 15) & 0x1F);
    rdp.c_d0 = (uint8_t)((rdp.cmd1 >> 15) & 0x7);
    rdp.c_Aa0 = (uint8_t)((rdp.cmd0 >> 12) & 0x7);
    rdp.c_Ab0 = (uint8_t)((rdp.cmd1 >> 12) & 0x7);
    rdp.c_Ac0 = (uint8_t)((rdp.cmd0 >> 9) & 0x7);
    rdp.c_Ad0 = (uint8_t)((rdp.cmd1 >> 9) & 0x7);

    rdp.c_a1 = (uint8_t)((rdp.cmd0 >> 5) & 0xF);
    rdp.c_b1 = (uint8_t)((rdp.cmd1 >> 24) & 0xF);
    rdp.c_c1 = (uint8_t)((rdp.cmd0 >> 0) & 0x1F);
    rdp.c_d1 = (uint8_t)((rdp.cmd1 >> 6) & 0x7);
    rdp.c_Aa1 = (uint8_t)((rdp.cmd1 >> 21) & 0x7);
    rdp.c_Ab1 = (uint8_t)((rdp.cmd1 >> 3) & 0x7);
    rdp.c_Ac1 = (uint8_t)((rdp.cmd1 >> 18) & 0x7);
    rdp.c_Ad1 = (uint8_t)((rdp.cmd1 >> 0) & 0x7);

    rdp.cycle1 = (rdp.c_a0 << 0) | (rdp.c_b0 << 4) | (rdp.c_c0 << 8) | (rdp.c_d0 << 13) |
        (rdp.c_Aa0 << 16) | (rdp.c_Ab0 << 19) | (rdp.c_Ac0 << 22) | (rdp.c_Ad0 << 25);
    rdp.cycle2 = (rdp.c_a1 << 0) | (rdp.c_b1 << 4) | (rdp.c_c1 << 8) | (rdp.c_d1 << 13) |
        (rdp.c_Aa1 << 16) | (rdp.c_Ab1 << 19) | (rdp.c_Ac1 << 22) | (rdp.c_Ad1 << 25);

    rdp.update |= UPDATE_COMBINE;

    WriteTrace(TraceRDP, TraceDebug, "setcombine\na0=%s b0=%s c0=%s d0=%s\nAa0=%s Ab0=%s Ac0=%s Ad0=%s\na1=%s b1=%s c1=%s d1=%s\nAa1=%s Ab1=%s Ac1=%s Ad1=%s",
        Mode0[rdp.c_a0], Mode1[rdp.c_b0], Mode2[rdp.c_c0], Mode3[rdp.c_d0],
        Alpha0[rdp.c_Aa0], Alpha1[rdp.c_Ab0], Alpha2[rdp.c_Ac0], Alpha3[rdp.c_Ad0],
        Mode0[rdp.c_a1], Mode1[rdp.c_b1], Mode2[rdp.c_c1], Mode3[rdp.c_d1],
        Alpha0[rdp.c_Aa1], Alpha1[rdp.c_Ab1], Alpha2[rdp.c_Ac1], Alpha3[rdp.c_Ad1]);
}

//
// settextureimage - sets the source for an image copy
//

static void rdp_settextureimage()
{
    static const char *format[] = { "RGBA", "YUV", "CI", "IA", "I", "?", "?", "?" };
    static const char *size[] = { "4bit", "8bit", "16bit", "32bit" };

    rdp.timg.format = (uint8_t)((rdp.cmd0 >> 21) & 0x07);
    rdp.timg.size = (uint8_t)((rdp.cmd0 >> 19) & 0x03);
    rdp.timg.width = (uint16_t)(1 + (rdp.cmd0 & 0x00000FFF));
    rdp.timg.addr = segoffset(rdp.cmd1);
    if (ucode5_texshiftaddr)
    {
        if (rdp.timg.format == 0)
        {
            uint16_t * t = (uint16_t*)(gfx.RDRAM + ucode5_texshiftaddr);
            ucode5_texshift = t[ucode5_texshiftcount ^ 1];
            rdp.timg.addr += ucode5_texshift;
        }
        else
        {
            ucode5_texshiftaddr = 0;
            ucode5_texshift = 0;
            ucode5_texshiftcount = 0;
        }
    }
    rdp.s2dex_tex_loaded = TRUE;
    rdp.update |= UPDATE_TEXTURE;

    if (rdp.ci_count > 0 && rdp.frame_buffers[rdp.ci_count - 1].status == ci_copy_self && (rdp.timg.addr >= rdp.cimg) && (rdp.timg.addr < rdp.ci_end))
    {
        if (!rdp.fb_drawn)
        {
            if (!rdp.cur_image)
                CopyFrameBuffer();
            else
                CloseTextureBuffer(TRUE);
            rdp.fb_drawn = TRUE;
        }
    }

    if (g_settings->fb_hwfbe_enabled()) //search this texture among drawn texture buffers
        FindTextureBuffer(rdp.timg.addr, rdp.timg.width);

    WriteTrace(TraceRDP, TraceDebug, "settextureimage: format: %s, size: %s, width: %d, addr: %08lx",
        format[rdp.timg.format], size[rdp.timg.size],
        rdp.timg.width, rdp.timg.addr);
}

static void rdp_setdepthimage()
{
    rdp.zimg = segoffset(rdp.cmd1) & BMASK;
    rdp.zi_width = rdp.ci_width;
    WriteTrace(TraceRDP, TraceDebug, "setdepthimage - %08lx", rdp.zimg);
}

int SwapOK = TRUE;
static void RestoreScale()
{
    WriteTrace(TraceRDP, TraceDebug, "Return to original scale: x = %f, y = %f", rdp.scale_x_bak, rdp.scale_y_bak);
    rdp.scale_x = rdp.scale_x_bak;
    rdp.scale_y = rdp.scale_y_bak;
    //    update_scissor();
    rdp.view_scale[0] *= rdp.scale_x;
    rdp.view_scale[1] *= rdp.scale_y;
    rdp.view_trans[0] *= rdp.scale_x;
    rdp.view_trans[1] *= rdp.scale_y;
    rdp.update |= UPDATE_VIEWPORT | UPDATE_SCISSOR;
    //*
    grDepthMask(FXFALSE);
    grBufferClear(0, 0, 0xFFFF);
    grDepthMask(FXTRUE);
    //*/
}

static uint32_t swapped_addr = 0;

static void rdp_setcolorimage()
{
    if (g_settings->fb_emulation_enabled() && (rdp.num_of_ci < NUMTEXBUF))
    {
        COLOR_IMAGE & cur_fb = rdp.frame_buffers[rdp.ci_count];
        COLOR_IMAGE & prev_fb = rdp.frame_buffers[rdp.ci_count ? rdp.ci_count - 1 : 0];
        COLOR_IMAGE & next_fb = rdp.frame_buffers[rdp.ci_count + 1];
        switch (cur_fb.status)
        {
        case ci_main:
        {
            if (rdp.ci_count == 0)
            {
                if ((rdp.ci_status == ci_aux)) //for PPL
                {
                    float sx = rdp.scale_x;
                    float sy = rdp.scale_y;
                    rdp.scale_x = 1.0f;
                    rdp.scale_y = 1.0f;
                    CopyFrameBuffer();
                    rdp.scale_x = sx;
                    rdp.scale_y = sy;
                }
                if (!g_settings->fb_hwfbe_enabled())
                {
                    if ((rdp.num_of_ci > 1) &&
                        (next_fb.status == ci_aux) &&
                        (next_fb.width >= cur_fb.width))
                    {
                        rdp.scale_x = 1.0f;
                        rdp.scale_y = 1.0f;
                    }
                }
                else if (rdp.copy_ci_index && g_settings->hacks(CSettings::hack_PMario)) //tidal wave
                    OpenTextureBuffer(rdp.frame_buffers[rdp.main_ci_index]);
            }
            else if (!rdp.motionblur && g_settings->fb_hwfbe_enabled() && !SwapOK && (rdp.ci_count <= rdp.copy_ci_index))
            {
                if (next_fb.status == ci_aux_copy)
                    OpenTextureBuffer(rdp.frame_buffers[rdp.main_ci_index]);
                else
                    OpenTextureBuffer(rdp.frame_buffers[rdp.copy_ci_index]);
            }
            else if (g_settings->fb_hwfbe_enabled() && prev_fb.status == ci_aux)
            {
                if (rdp.motionblur)
                {
                    rdp.cur_image = &(rdp.texbufs[rdp.cur_tex_buf].images[0]);
                    grRenderBuffer(GR_BUFFER_TEXTUREBUFFER_EXT);
                    grTextureBufferExt(rdp.cur_image->tmu, rdp.cur_image->tex_addr, rdp.cur_image->info.smallLodLog2, rdp.cur_image->info.largeLodLog2,
                        rdp.cur_image->info.aspectRatioLog2, rdp.cur_image->info.format, GR_MIPMAPLEVELMASK_BOTH);
                }
                else if (rdp.read_whole_frame)
                {
                    OpenTextureBuffer(rdp.frame_buffers[rdp.main_ci_index]);
                }
            }
            //else if (rdp.ci_status == ci_aux && !rdp.copy_ci_index)
            //  CloseTextureBuffer();

            rdp.skip_drawing = FALSE;
        }
        break;
        case ci_copy:
        {
            if (!rdp.motionblur || g_settings->fb_motionblur_enabled())
            {
                if (cur_fb.width == rdp.ci_width)
                {
                    if (CopyTextureBuffer(prev_fb, cur_fb))
                    {
                        //                      if (CloseTextureBuffer(TRUE))
                        //*
                        if (g_settings->hacks(CSettings::hack_Zelda) && (rdp.frame_buffers[rdp.ci_count + 2].status == ci_aux) && !rdp.fb_drawn) //hack for photo camera in Zelda MM
                        {
                            CopyFrameBuffer(GR_BUFFER_TEXTUREBUFFER_EXT);
                            rdp.fb_drawn = TRUE;
                            memcpy(gfx.RDRAM + cur_fb.addr, gfx.RDRAM + rdp.cimg, (cur_fb.width*cur_fb.height) << cur_fb.size >> 1);
                        }
                        //*/
                    }
                    else
                    {
                        if (!rdp.fb_drawn || prev_fb.status == ci_copy_self)
                        {
                            CopyFrameBuffer();
                            rdp.fb_drawn = TRUE;
                        }
                        memcpy(gfx.RDRAM + cur_fb.addr, gfx.RDRAM + rdp.cimg, (cur_fb.width*cur_fb.height) << cur_fb.size >> 1);
                    }
                }
                else
                {
                    CloseTextureBuffer(TRUE);
                }
            }
            else
            {
                memset(gfx.RDRAM + cur_fb.addr, 0, cur_fb.width*cur_fb.height*rdp.ci_size);
            }
            rdp.skip_drawing = TRUE;
        }
        break;
        case ci_aux_copy:
        {
            rdp.skip_drawing = FALSE;
            if (CloseTextureBuffer(prev_fb.status != ci_aux_copy))
                ;
            else if (!rdp.fb_drawn)
            {
                CopyFrameBuffer();
                rdp.fb_drawn = TRUE;
            }
            if (g_settings->fb_hwfbe_enabled())
                OpenTextureBuffer(cur_fb);
        }
        break;
        case ci_old_copy:
        {
            if (!rdp.motionblur || g_settings->fb_motionblur_enabled())
            {
                if (cur_fb.width == rdp.ci_width)
                {
                    memcpy(gfx.RDRAM + cur_fb.addr, gfx.RDRAM + rdp.maincimg[1].addr, (cur_fb.width*cur_fb.height) << cur_fb.size >> 1);
                }
                //rdp.skip_drawing = TRUE;
            }
            else
            {
                memset(gfx.RDRAM + cur_fb.addr, 0, (cur_fb.width*cur_fb.height) << rdp.ci_size >> 1);
            }
        }
        break;
        /*
        else if (rdp.frame_buffers[rdp.ci_count].status == ci_main_i)
        {
        //       CopyFrameBuffer ();
        rdp.scale_x = rdp.scale_x_bak;
        rdp.scale_y = rdp.scale_y_bak;
        rdp.skip_drawing = FALSE;
        }
        */
        case ci_aux:
        {
            if (!g_settings->fb_hwfbe_enabled() && cur_fb.format != 0)
                rdp.skip_drawing = TRUE;
            else
            {
                rdp.skip_drawing = FALSE;
                if (g_settings->fb_hwfbe_enabled() && OpenTextureBuffer(cur_fb))
                    ;
                else
                {
                    if (cur_fb.format != 0)
                        rdp.skip_drawing = TRUE;
                    if (rdp.ci_count == 0)
                    {
                        //           if (rdp.num_of_ci > 1)
                        //           {
                        rdp.scale_x = 1.0f;
                        rdp.scale_y = 1.0f;
                        //           }
                    }
                    else if (!g_settings->fb_hwfbe_enabled() && (prev_fb.status == ci_main) &&
                        (prev_fb.width == cur_fb.width)) // for Pokemon Stadium
                        CopyFrameBuffer();
                }
            }
            cur_fb.status = ci_aux;
        }
        break;
        case ci_zimg:
            if (g_settings->ucode() != CSettings::ucode_PerfectDark)
            {
                if (g_settings->fb_hwfbe_enabled() && !rdp.copy_ci_index && (rdp.copy_zi_index || g_settings->hacks(CSettings::hack_BAR)))
                {
                    GrLOD_t LOD = g_settings->scr_res_x() > 1024 ? GR_LOD_LOG2_1024 : GR_LOD_LOG2_2048;
                    grTextureAuxBufferExt(rdp.texbufs[0].tmu, rdp.texbufs[0].begin, LOD, LOD,
                        GR_ASPECT_LOG2_1x1, GR_TEXFMT_RGB_565, GR_MIPMAPLEVELMASK_BOTH);
                    grAuxBufferExt(GR_BUFFER_TEXTUREAUXBUFFER_EXT);
                    WriteTrace(TraceRDP, TraceDebug, "rdp_setcolorimage - set texture depth buffer to TMU0");
                }
            }
            rdp.skip_drawing = TRUE;
            break;
        case ci_zcopy:
            if (g_settings->ucode() != CSettings::ucode_PerfectDark)
            {
                if (g_settings->fb_hwfbe_enabled() && !rdp.copy_ci_index && rdp.copy_zi_index == rdp.ci_count)
                {
                    CopyDepthBuffer();
                }
                rdp.skip_drawing = TRUE;
            }
            break;
        case ci_useless:
            rdp.skip_drawing = TRUE;
            break;
        case ci_copy_self:
            if (g_settings->fb_hwfbe_enabled() && (rdp.ci_count <= rdp.copy_ci_index) && (!SwapOK || g_settings->swapmode() == CSettings::SwapMode_Hybrid))
            {
                OpenTextureBuffer(cur_fb);
            }
            rdp.skip_drawing = FALSE;
            break;
        default:
            rdp.skip_drawing = FALSE;
        }

        if ((rdp.ci_count > 0) && (prev_fb.status >= ci_aux)) //for Pokemon Stadium
        {
            if (!g_settings->fb_hwfbe_enabled() && prev_fb.format == 0)
                CopyFrameBuffer();
            else if (g_settings->hacks(CSettings::hack_Knockout) && prev_fb.width < 100)
                CopyFrameBuffer(GR_BUFFER_TEXTUREBUFFER_EXT);
        }
        if (!g_settings->fb_hwfbe_enabled() && cur_fb.status == ci_copy)
        {
            if (!rdp.motionblur && (rdp.num_of_ci > rdp.ci_count + 1) && (next_fb.status != ci_aux))
            {
                RestoreScale();
            }
        }
        if (!g_settings->fb_hwfbe_enabled() && cur_fb.status == ci_aux)
        {
            if (cur_fb.format == 0)
            {
                if (g_settings->hacks(CSettings::hack_PPL) && (rdp.scale_x < 1.1f))  //need to put current image back to frame buffer
                {
                    int width = cur_fb.width;
                    int height = cur_fb.height;
                    uint16_t *ptr_dst = new uint16_t[width*height];
                    uint16_t *ptr_src = (uint16_t*)(gfx.RDRAM + cur_fb.addr);
                    uint16_t c;

                    for (int y = 0; y < height; y++)
                    {
                        for (int x = 0; x < width; x++)
                        {
                            c = ((ptr_src[(x + y * width) ^ 1]) >> 1) | 0x8000;
                            ptr_dst[x + y * width] = c;
                        }
                    }
                    grLfbWriteRegion(GR_BUFFER_BACKBUFFER,
                        (uint32_t)rdp.offset_x,
                        (uint32_t)rdp.offset_y,
                        GR_LFB_SRC_FMT_555,
                        width,
                        height,
                        FXFALSE,
                        width << 1,
                        ptr_dst);
                    delete[] ptr_dst;
                }
                /*
                else  //just clear buffer
                {
                grColorMask(FXTRUE, FXTRUE);
                grBufferClear (0, 0, 0xFFFF);
                }
                */
            }
        }

        if ((cur_fb.status == ci_main) && (rdp.ci_count > 0))
        {
            int to_org_res = TRUE;
            for (int i = rdp.ci_count + 1; i < rdp.num_of_ci; i++)
            {
                if ((rdp.frame_buffers[i].status != ci_main) && (rdp.frame_buffers[i].status != ci_zimg) && (rdp.frame_buffers[i].status != ci_zcopy))
                {
                    to_org_res = FALSE;
                    break;
                }
            }
            if (to_org_res)
            {
                WriteTrace(TraceRDP, TraceDebug, "return to original scale");
                rdp.scale_x = rdp.scale_x_bak;
                rdp.scale_y = rdp.scale_y_bak;
                if (g_settings->fb_hwfbe_enabled() && !rdp.read_whole_frame)
                    CloseTextureBuffer();
            }
            if (g_settings->fb_hwfbe_enabled() && !rdp.read_whole_frame && (prev_fb.status >= ci_aux) && (rdp.ci_count > rdp.copy_ci_index))
                CloseTextureBuffer();
        }
        rdp.ci_status = cur_fb.status;
        rdp.ci_count++;
    }

    rdp.ocimg = rdp.cimg;
    rdp.cimg = segoffset(rdp.cmd1) & BMASK;
    rdp.ci_width = (rdp.cmd0 & 0xFFF) + 1;
    if (g_settings->fb_emulation_enabled() && rdp.ci_count > 0)
        rdp.ci_height = rdp.frame_buffers[rdp.ci_count - 1].height;
    else if (rdp.ci_width == 32)
        rdp.ci_height = 32;
    else
        rdp.ci_height = rdp.scissor_o.lr_y;
    if (rdp.zimg == rdp.cimg)
    {
        rdp.zi_width = rdp.ci_width;
        //    int zi_height = minval((int)rdp.zi_width*3/4, (int)rdp.vi_height);
        //    rdp.zi_words = rdp.zi_width * zi_height;
    }
    uint32_t format = (rdp.cmd0 >> 21) & 0x7;
    rdp.ci_size = (rdp.cmd0 >> 19) & 0x3;
    rdp.ci_end = rdp.cimg + ((rdp.ci_width*rdp.ci_height) << (rdp.ci_size - 1));
    WriteTrace(TraceRDP, TraceDebug, "setcolorimage - %08lx, width: %d,  height: %d, format: %d, size: %d", rdp.cmd1, rdp.ci_width, rdp.ci_height, format, rdp.ci_size);
    WriteTrace(TraceRDP, TraceDebug, "cimg: %08lx, ocimg: %08lx, SwapOK: %d", rdp.cimg, rdp.ocimg, SwapOK);

    if (format != 0) //can't draw into non RGBA buffer
    {
        if (!rdp.cur_image)
        {
            if (g_settings->fb_hwfbe_enabled() && rdp.ci_width <= 64 && rdp.ci_count > 0)
                OpenTextureBuffer(rdp.frame_buffers[rdp.ci_count - 1]);
            else if (format > 2)
                rdp.skip_drawing = TRUE;
            return;
        }
    }
    else
    {
        if (!g_settings->fb_emulation_enabled())
            rdp.skip_drawing = FALSE;
    }

    CI_SET = TRUE;
    if (g_settings->swapmode() != CSettings::SwapMode_Old)
    {
        if (rdp.zimg == rdp.cimg)
        {
            rdp.updatescreen = 1;
        }

        int viSwapOK = ((g_settings->swapmode() == CSettings::SwapMode_Hybrid) && (rdp.vi_org_reg == *gfx.VI_ORIGIN_REG)) ? FALSE : TRUE;
        if ((rdp.zimg != rdp.cimg) && (rdp.ocimg != rdp.cimg) && SwapOK && viSwapOK && !rdp.cur_image)
        {
            if (g_settings->fb_emulation_enabled())
            {
                rdp.maincimg[0] = rdp.frame_buffers[rdp.main_ci_index];
            }
            else
            {
                rdp.maincimg[0].addr = rdp.cimg;
            }
            rdp.last_drawn_ci_addr = (g_settings->swapmode() == CSettings::SwapMode_Hybrid) ? swapped_addr : rdp.maincimg[0].addr;
            swapped_addr = rdp.cimg;
            newSwapBuffers();
            rdp.vi_org_reg = *gfx.VI_ORIGIN_REG;
            SwapOK = FALSE;
            if (g_settings->fb_hwfbe_enabled())
            {
                if (rdp.copy_ci_index && (rdp.frame_buffers[rdp.ci_count - 1].status != ci_zimg))
                {
                    int idx = (rdp.frame_buffers[rdp.ci_count].status == ci_aux_copy) ? rdp.main_ci_index : rdp.copy_ci_index;
                    WriteTrace(TraceRDP, TraceDebug, "attempt open tex buffer. status: %s, addr: %08lx", CIStatus[rdp.frame_buffers[idx].status], rdp.frame_buffers[idx].addr);
                    OpenTextureBuffer(rdp.frame_buffers[idx]);
                    if (rdp.frame_buffers[rdp.copy_ci_index].status == ci_main) //tidal wave
                        rdp.copy_ci_index = 0;
                }
                else if (rdp.read_whole_frame && !rdp.cur_image)
                {
                    OpenTextureBuffer(rdp.frame_buffers[rdp.main_ci_index]);
                }
            }
        }
    }
}

static void rsp_reserved0()
{
    if (g_settings->ucode() == CSettings::ucode_DiddyKong)
    {
        ucode5_texshiftaddr = segoffset(rdp.cmd1);
        ucode5_texshiftcount = 0;
        WriteTrace(TraceRDP, TraceDebug, "uc5_texshift. addr: %08lx", ucode5_texshiftaddr);
    }
    else
    {
        WriteTrace(TraceRDP, TraceWarning, "reserved0 - IGNORED");
    }
}

static void rsp_reserved1()
{
    WriteTrace(TraceRDP, TraceDebug, "reserved1 - ignored");
}

static void rsp_reserved2()
{
    WriteTrace(TraceRDP, TraceDebug, "reserved2");
}

static void rsp_reserved3()
{
    WriteTrace(TraceRDP, TraceDebug, "reserved3 - ignored");
}

void SetWireframeCol()
{
    switch (g_settings->wfmode)
    {
        //case 0: // normal colors, don't do anything
    case 1: // vertex colors
        grColorCombine(GR_COMBINE_FUNCTION_LOCAL,
            GR_COMBINE_FACTOR_NONE,
            GR_COMBINE_LOCAL_ITERATED,
            GR_COMBINE_OTHER_NONE,
            FXFALSE);
        grAlphaCombine(GR_COMBINE_FUNCTION_LOCAL,
            GR_COMBINE_FACTOR_NONE,
            GR_COMBINE_LOCAL_ITERATED,
            GR_COMBINE_OTHER_NONE,
            FXFALSE);
        grAlphaBlendFunction(GR_BLEND_ONE,
            GR_BLEND_ZERO,
            GR_BLEND_ZERO,
            GR_BLEND_ZERO);
        grTexCombine(GR_TMU0,
            GR_COMBINE_FUNCTION_ZERO,
            GR_COMBINE_FACTOR_NONE,
            GR_COMBINE_FUNCTION_ZERO,
            GR_COMBINE_FACTOR_NONE,
            FXFALSE, FXFALSE);
        grTexCombine(GR_TMU1,
            GR_COMBINE_FUNCTION_ZERO,
            GR_COMBINE_FACTOR_NONE,
            GR_COMBINE_FUNCTION_ZERO,
            GR_COMBINE_FACTOR_NONE,
            FXFALSE, FXFALSE);
        break;
    case 2: // red only
        grColorCombine(GR_COMBINE_FUNCTION_LOCAL,
            GR_COMBINE_FACTOR_NONE,
            GR_COMBINE_LOCAL_CONSTANT,
            GR_COMBINE_OTHER_NONE,
            FXFALSE);
        grAlphaCombine(GR_COMBINE_FUNCTION_LOCAL,
            GR_COMBINE_FACTOR_NONE,
            GR_COMBINE_LOCAL_CONSTANT,
            GR_COMBINE_OTHER_NONE,
            FXFALSE);
        grConstantColorValue(0xFF0000FF);
        grAlphaBlendFunction(GR_BLEND_ONE,
            GR_BLEND_ZERO,
            GR_BLEND_ZERO,
            GR_BLEND_ZERO);
        grTexCombine(GR_TMU0,
            GR_COMBINE_FUNCTION_ZERO,
            GR_COMBINE_FACTOR_NONE,
            GR_COMBINE_FUNCTION_ZERO,
            GR_COMBINE_FACTOR_NONE,
            FXFALSE, FXFALSE);
        grTexCombine(GR_TMU1,
            GR_COMBINE_FUNCTION_ZERO,
            GR_COMBINE_FACTOR_NONE,
            GR_COMBINE_FUNCTION_ZERO,
            GR_COMBINE_FACTOR_NONE,
            FXFALSE, FXFALSE);
        break;
    }

    grAlphaTestFunction(GR_CMP_ALWAYS);
    grCullMode(GR_CULL_DISABLE);

    rdp.update |= UPDATE_COMBINE | UPDATE_ALPHA_COMPARE;
}

/******************************************************************
Function: FrameBufferRead
Purpose:  This function is called to notify the dll that the
frame buffer memory is beening read at the given address.
DLL should copy content from its render buffer to the frame buffer
in N64 RDRAM
DLL is responsible to maintain its own frame buffer memory addr list
DLL should copy 4KB block content back to RDRAM frame buffer.
Emulator should not call this function again if other memory
is read within the same 4KB range
input:    addr          rdram address
val                     val
size            1 = uint8_t, 2 = uint16_t, 4 = uint32_t
output:   none
*******************************************************************/
EXPORT void CALL FBRead(uint32_t addr)
{
    WriteTrace(TraceGlide64, TraceDebug, "-");

    if (cpu_fb_ignore)
        return;
    if (cpu_fb_write_called)
    {
        cpu_fb_ignore = TRUE;
        cpu_fb_write = FALSE;
        return;
    }
    cpu_fb_read_called = TRUE;
    uint32_t a = segoffset(addr);
    WriteTrace(TraceRDP, TraceDebug, "FBRead. addr: %08lx", a);
    if (!rdp.fb_drawn && (a >= rdp.cimg) && (a < rdp.ci_end))
    {
        fbreads_back++;
        //if (fbreads_back > 2) //&& (rdp.ci_width <= 320))
        {
            CopyFrameBuffer();
            rdp.fb_drawn = TRUE;
        }
    }
    if (!rdp.fb_drawn_front && (a >= rdp.maincimg[1].addr) && (a < rdp.maincimg[1].addr + rdp.ci_width*rdp.ci_height * 2))
    {
        fbreads_front++;
        //if (fbreads_front > 2)//&& (rdp.ci_width <= 320))
        {
            uint32_t cimg = rdp.cimg;
            rdp.cimg = rdp.maincimg[1].addr;
            if (g_settings->fb_emulation_enabled())
            {
                rdp.ci_width = rdp.maincimg[1].width;
                rdp.ci_count = 0;
                uint32_t h = rdp.frame_buffers[0].height;
                rdp.frame_buffers[0].height = rdp.maincimg[1].height;
                CopyFrameBuffer(GR_BUFFER_FRONTBUFFER);
                rdp.frame_buffers[0].height = h;
            }
            else
            {
                CopyFrameBuffer(GR_BUFFER_FRONTBUFFER);
            }
            rdp.cimg = cimg;
            rdp.fb_drawn_front = TRUE;
        }
    }
}

/******************************************************************
Function: FrameBufferWriteList
Purpose:  This function is called to notify the dll that the
frame buffer has been modified by CPU at the given address.
input:    FrameBufferModifyEntry *plist
size = size of the plist, max = 1024
output:   none
*******************************************************************/
EXPORT void CALL FBWList(FrameBufferModifyEntry* /*plist*/, uint32_t size)
{
    WriteTrace(TraceGlide64, TraceDebug, "size: %d", size);
}

/******************************************************************
Function: FrameBufferWrite
Purpose:  This function is called to notify the dll that the
frame buffer has been modified by CPU at the given address.
input:    addr          rdram address
val                     val
size            1 = uint8_t, 2 = uint16_t, 4 = uint32_t
output:   none
*******************************************************************/
EXPORT void CALL FBWrite(uint32_t addr, uint32_t /*size*/)
{
    WriteTrace(TraceGlide64, TraceDebug, "-");
    if (cpu_fb_ignore)
        return;
    if (cpu_fb_read_called)
    {
        cpu_fb_ignore = TRUE;
        cpu_fb_write = FALSE;
        return;
    }
    cpu_fb_write_called = TRUE;
    uint32_t a = segoffset(addr);
    WriteTrace(TraceRDP, TraceDebug, "FBWrite. addr: %08lx", a);
    if (a < rdp.cimg || a > rdp.ci_end)
        return;
    cpu_fb_write = TRUE;
    uint32_t shift_l = (a - rdp.cimg) >> 1;
    uint32_t shift_r = shift_l + 2;

    d_ul_x = minval(d_ul_x, shift_l%rdp.ci_width);
    d_ul_y = minval(d_ul_y, shift_l / rdp.ci_width);
    d_lr_x = maxval(d_lr_x, shift_r%rdp.ci_width);
    d_lr_y = maxval(d_lr_y, shift_r / rdp.ci_width);
}

/************************************************************************
Function: FBGetFrameBufferInfo
Purpose:  This function is called by the emulator core to retrieve frame
buffer information from the video plugin in order to be able
to notify the video plugin about CPU frame buffer read/write
operations

size:
= 1           byte
= 2           word (16 bit) <-- this is N64 default depth buffer format
= 4           dword (32 bit)

when frame buffer information is not available yet, set all values
in the FrameBufferInfo structure to 0

input:    FrameBufferInfo pinfo[6]
pinfo is pointed to a FrameBufferInfo structure which to be
filled in by this function
output:   Values are return in the FrameBufferInfo structure
Plugin can return up to 6 frame buffer info
************************************************************************/
///*
typedef struct
{
    uint32_t addr;
    uint32_t size;
    uint32_t width;
    uint32_t height;
} FrameBufferInfo;
EXPORT void CALL FBGetFrameBufferInfo(void *p)
{
    WriteTrace(TraceGlide64, TraceDebug, "-");
    FrameBufferInfo * pinfo = (FrameBufferInfo *)p;
    memset(pinfo, 0, sizeof(FrameBufferInfo) * 6);
    if (!g_settings->fb_get_info_enabled())
    {
        return;
    }
    WriteTrace(TraceRDP, TraceDebug, "FBGetFrameBufferInfo ()");

    if (g_settings->fb_emulation_enabled())
    {
        pinfo[0].addr = rdp.maincimg[1].addr;
        pinfo[0].size = rdp.maincimg[1].size;
        pinfo[0].width = rdp.maincimg[1].width;
        pinfo[0].height = rdp.maincimg[1].height;
        int info_index = 1;
        for (int i = 0; i < rdp.num_of_ci && info_index < 6; i++)
        {
            COLOR_IMAGE & cur_fb = rdp.frame_buffers[i];
            if (cur_fb.status == ci_main || cur_fb.status == ci_copy_self ||
                cur_fb.status == ci_old_copy)
            {
                pinfo[info_index].addr = cur_fb.addr;
                pinfo[info_index].size = cur_fb.size;
                pinfo[info_index].width = cur_fb.width;
                pinfo[info_index].height = cur_fb.height;
                info_index++;
            }
        }
    }
    else
    {
        pinfo[0].addr = rdp.maincimg[0].addr;
        pinfo[0].size = rdp.ci_size;
        pinfo[0].width = rdp.ci_width;
        pinfo[0].height = rdp.ci_width * 3 / 4;
        pinfo[1].addr = rdp.maincimg[1].addr;
        pinfo[1].size = rdp.ci_size;
        pinfo[1].width = rdp.ci_width;
        pinfo[1].height = rdp.ci_width * 3 / 4;
    }
    //*/
}
//*/
#include "ucodeFB.h"

void DetectFrameBufferUsage()
{
    WriteTrace(TraceRDP, TraceDebug, "DetectFrameBufferUsage");

    uint32_t dlist_start = *(uint32_t*)(gfx.DMEM + 0xFF0);
    uint32_t a;

    int tidal = FALSE;
    if (g_settings->hacks(CSettings::hack_PMario) && (rdp.copy_ci_index || rdp.frame_buffers[rdp.copy_ci_index].status == ci_copy_self))
        tidal = TRUE;
    uint32_t ci = rdp.cimg, zi = rdp.zimg;
    uint32_t ci_height = rdp.frame_buffers[(rdp.ci_count > 0) ? rdp.ci_count - 1 : 0].height;
    rdp.main_ci = rdp.main_ci_end = rdp.main_ci_bg = rdp.ci_count = 0;
    rdp.main_ci_index = rdp.copy_ci_index = rdp.copy_zi_index = 0;
    rdp.zimg_end = 0;
    rdp.tmpzimg = 0;
    rdp.motionblur = FALSE;
    rdp.main_ci_last_tex_addr = 0;
    int previous_ci_was_read = rdp.read_previous_ci;
    rdp.read_previous_ci = FALSE;
    rdp.read_whole_frame = FALSE;
    rdp.swap_ci_index = rdp.black_ci_index = -1;
    SwapOK = TRUE;

    // Start executing at the start of the display list
    rdp.pc_i = 0;
    rdp.pc[rdp.pc_i] = dlist_start;
    rdp.dl_count = -1;
    rdp.halt = 0;
    rdp.scale_x_bak = rdp.scale_x;
    rdp.scale_y_bak = rdp.scale_y;

    // MAIN PROCESSING LOOP
    do {
        // Get the address of the next command
        a = rdp.pc[rdp.pc_i] & BMASK;

        // Load the next command and its input
        rdp.cmd0 = ((uint32_t*)gfx.RDRAM)[a >> 2];   // \ Current command, 64 bit
        rdp.cmd1 = ((uint32_t*)gfx.RDRAM)[(a >> 2) + 1]; // /

        // Output the address before the command

        // Go to the next instruction
        rdp.pc[rdp.pc_i] = (a + 8) & BMASK;

        if (uintptr_t(reinterpret_cast<void*>(gfx_instruction_lite[g_settings->ucode()][rdp.cmd0 >> 24])))
            gfx_instruction_lite[g_settings->ucode()][rdp.cmd0 >> 24]();

        // check DL counter
        if (rdp.dl_count != -1)
        {
            rdp.dl_count--;
            if (rdp.dl_count == 0)
            {
                rdp.dl_count = -1;

                WriteTrace(TraceRDP, TraceDebug, "End of DL");
                rdp.pc_i--;
            }
        }
    } while (!rdp.halt);
    SwapOK = TRUE;
    if (rdp.ci_count > NUMTEXBUF) //overflow
    {
        rdp.cimg = ci;
        rdp.zimg = zi;
        rdp.num_of_ci = rdp.ci_count;
        rdp.scale_x = rdp.scale_x_bak;
        rdp.scale_y = rdp.scale_y_bak;
        return;
    }

    if (rdp.black_ci_index > 0 && rdp.black_ci_index < rdp.copy_ci_index)
        rdp.frame_buffers[rdp.black_ci_index].status = ci_main;

    if (rdp.frame_buffers[rdp.ci_count - 1].status == ci_unknown)
    {
        if (rdp.ci_count > 1)
            rdp.frame_buffers[rdp.ci_count - 1].status = ci_aux;
        else
            rdp.frame_buffers[rdp.ci_count - 1].status = ci_main;
    }

    if ((rdp.frame_buffers[rdp.ci_count - 1].status == ci_aux) &&
        (rdp.frame_buffers[rdp.main_ci_index].width < 320) &&
        (rdp.frame_buffers[rdp.ci_count - 1].width > rdp.frame_buffers[rdp.main_ci_index].width))
    {
        for (int i = 0; i < rdp.ci_count; i++)
        {
            if (rdp.frame_buffers[i].status == ci_main)
                rdp.frame_buffers[i].status = ci_aux;
            else if (rdp.frame_buffers[i].addr == rdp.frame_buffers[rdp.ci_count - 1].addr)
                rdp.frame_buffers[i].status = ci_main;
            //                        WriteTrace(TraceRDP, TraceDebug, "rdp.frame_buffers[%d].status = %d", i, rdp.frame_buffers[i].status);
        }
        rdp.main_ci_index = rdp.ci_count - 1;
    }

    int all_zimg = TRUE;
    int i;
    for (i = 0; i < rdp.ci_count; i++)
    {
        if (rdp.frame_buffers[i].status != ci_zimg)
        {
            all_zimg = FALSE;
            break;
        }
    }
    if (all_zimg)
    {
        for (i = 0; i < rdp.ci_count; i++)
            rdp.frame_buffers[i].status = ci_main;
    }

    WriteTrace(TraceRDP, TraceDebug, "detect fb final results: ");
    for (i = 0; i < rdp.ci_count; i++)
    {
        WriteTrace(TraceRDP, TraceDebug, "rdp.frame_buffers[%d].status = %s, addr: %08lx, height: %d", i, CIStatus[rdp.frame_buffers[i].status], rdp.frame_buffers[i].addr, rdp.frame_buffers[i].height);
    }

    rdp.cimg = ci;
    rdp.zimg = zi;
    rdp.num_of_ci = rdp.ci_count;
    if (rdp.read_previous_ci && previous_ci_was_read)
    {
        if (!g_settings->fb_hwfbe_enabled() || !rdp.copy_ci_index)
            rdp.motionblur = TRUE;
    }
    if (rdp.motionblur || g_settings->fb_hwfbe_enabled() || (rdp.frame_buffers[rdp.copy_ci_index].status == ci_aux_copy))
    {
        rdp.scale_x = rdp.scale_x_bak;
        rdp.scale_y = rdp.scale_y_bak;
    }

    if ((rdp.read_previous_ci || previous_ci_was_read) && !rdp.copy_ci_index)
        rdp.read_whole_frame = TRUE;
    if (rdp.read_whole_frame)
    {
        if (g_settings->fb_hwfbe_enabled())
        {
            if (rdp.read_previous_ci && !previous_ci_was_read && (g_settings->swapmode() != CSettings::SwapMode_Hybrid) && (g_settings->ucode() != CSettings::ucode_PerfectDark))
            {
                int ind = (rdp.ci_count > 0) ? rdp.ci_count - 1 : 0;
                uint32_t height = rdp.frame_buffers[ind].height;
                rdp.frame_buffers[ind].height = ci_height;
                CopyFrameBuffer();
                rdp.frame_buffers[ind].height = height;
            }
            if (rdp.swap_ci_index < 0)
            {
                rdp.texbufs[0].clear_allowed = rdp.texbufs[1].clear_allowed = TRUE;
                OpenTextureBuffer(rdp.frame_buffers[rdp.main_ci_index]);
            }
        }
        else
        {
            if (rdp.motionblur)
            {
                if (g_settings->fb_motionblur_enabled())
                {
                    CopyFrameBuffer();
                }
                else
                {
                    memset(gfx.RDRAM + rdp.cimg, 0, rdp.ci_width*rdp.ci_height*rdp.ci_size);
                }
            }
            else //if (ci_width == rdp.frame_buffers[rdp.main_ci_index].width)
            {
                if (rdp.maincimg[0].height > 65) //for 1080
                {
                    rdp.cimg = rdp.maincimg[0].addr;
                    rdp.ci_width = rdp.maincimg[0].width;
                    rdp.ci_count = 0;
                    uint32_t h = rdp.frame_buffers[0].height;
                    rdp.frame_buffers[0].height = rdp.maincimg[0].height;
                    CopyFrameBuffer();
                    rdp.frame_buffers[0].height = h;
                }
                else //conker
                {
                    CopyFrameBuffer();
                }
            }
        }
    }

    if (g_settings->fb_hwfbe_enabled())
    {
        for (i = 0; i < voodoo.num_tmu; i++)
        {
            rdp.texbufs[i].clear_allowed = TRUE;
            for (int j = 0; j < 256; j++)
            {
                rdp.texbufs[i].images[j].drawn = FALSE;
                rdp.texbufs[i].images[j].clear = TRUE;
            }
        }
        if (tidal)
        {
            //WriteTrace(TraceRDP, TraceDebug, "Tidal wave!");
            rdp.copy_ci_index = rdp.main_ci_index;
        }
    }
    rdp.ci_count = 0;
    if (g_settings->hacks(CSettings::hack_Banjo2))
    {
        rdp.cur_tex_buf = 0;
    }
    rdp.maincimg[0] = rdp.frame_buffers[rdp.main_ci_index];
    //    rdp.scale_x = rdp.scale_x_bak;
    //    rdp.scale_y = rdp.scale_y_bak;
    WriteTrace(TraceRDP, TraceDebug, "DetectFrameBufferUsage End");
}

/*******************************************
 *          ProcessRDPList                 *
 *******************************************
 *    based on sources of ziggy's z64      *
 *******************************************/

static uint32_t rdp_cmd_ptr = 0;
static uint32_t rdp_cmd_cur = 0;
static uint32_t rdp_cmd_data[0x1000];

void lle_triangle(uint32_t w1, uint32_t w2, int shade, int texture, int zbuffer,
    uint32_t * rdp_cmd)
{
    rdp.cur_tile = (w1 >> 16) & 0x7;
    int j;
    int xleft, xright, xleft_inc, xright_inc;
    int r, g, b, a, z, s, t, w;
    int drdx = 0, dgdx = 0, dbdx = 0, dadx = 0, dzdx = 0, dsdx = 0, dtdx = 0, dwdx = 0;
    int drde = 0, dgde = 0, dbde = 0, dade = 0, dzde = 0, dsde = 0, dtde = 0, dwde = 0;
    int flip = (w1 & 0x800000) ? 1 : 0;

    int32_t yl, ym, yh;
    int32_t xl, xm, xh;
    int32_t dxldy, dxhdy, dxmdy;
    uint32_t w3, w4, w5, w6, w7, w8;

    uint32_t * shade_base = rdp_cmd + 8;
    uint32_t * texture_base = rdp_cmd + 8;
    uint32_t * zbuffer_base = rdp_cmd + 8;

    if (shade)
    {
        texture_base += 16;
        zbuffer_base += 16;
    }
    if (texture)
    {
        zbuffer_base += 16;
    }

    w3 = rdp_cmd[2];
    w4 = rdp_cmd[3];
    w5 = rdp_cmd[4];
    w6 = rdp_cmd[5];
    w7 = rdp_cmd[6];
    w8 = rdp_cmd[7];

    yl = (w1 & 0x3fff);
    ym = ((w2 >> 16) & 0x3fff);
    yh = ((w2 >> 0) & 0x3fff);
    xl = (int32_t)(w3);
    xh = (int32_t)(w5);
    xm = (int32_t)(w7);
    dxldy = (int32_t)(w4);
    dxhdy = (int32_t)(w6);
    dxmdy = (int32_t)(w8);

    if (yl & (0x800 << 2)) yl |= 0xfffff000 << 2;
    if (ym & (0x800 << 2)) ym |= 0xfffff000 << 2;
    if (yh & (0x800 << 2)) yh |= 0xfffff000 << 2;

    yh &= ~3;

    r = 0xff; g = 0xff; b = 0xff; a = 0xff; z = 0xffff0000; s = 0;  t = 0;  w = 0x30000;

    if (shade)
    {
        r = (shade_base[0] & 0xffff0000) | ((shade_base[+4] >> 16) & 0x0000ffff);
        g = ((shade_base[0] << 16) & 0xffff0000) | (shade_base[4] & 0x0000ffff);
        b = (shade_base[1] & 0xffff0000) | ((shade_base[5] >> 16) & 0x0000ffff);
        a = ((shade_base[1] << 16) & 0xffff0000) | (shade_base[5] & 0x0000ffff);
        drdx = (shade_base[2] & 0xffff0000) | ((shade_base[6] >> 16) & 0x0000ffff);
        dgdx = ((shade_base[2] << 16) & 0xffff0000) | (shade_base[6] & 0x0000ffff);
        dbdx = (shade_base[3] & 0xffff0000) | ((shade_base[7] >> 16) & 0x0000ffff);
        dadx = ((shade_base[3] << 16) & 0xffff0000) | (shade_base[7] & 0x0000ffff);
        drde = (shade_base[8] & 0xffff0000) | ((shade_base[12] >> 16) & 0x0000ffff);
        dgde = ((shade_base[8] << 16) & 0xffff0000) | (shade_base[12] & 0x0000ffff);
        dbde = (shade_base[9] & 0xffff0000) | ((shade_base[13] >> 16) & 0x0000ffff);
        dade = ((shade_base[9] << 16) & 0xffff0000) | (shade_base[13] & 0x0000ffff);
    }
    if (texture)
    {
        s = (texture_base[0] & 0xffff0000) | ((texture_base[4] >> 16) & 0x0000ffff);
        t = ((texture_base[0] << 16) & 0xffff0000) | (texture_base[4] & 0x0000ffff);
        w = (texture_base[1] & 0xffff0000) | ((texture_base[5] >> 16) & 0x0000ffff);
        //    w = abs(w);
        dsdx = (texture_base[2] & 0xffff0000) | ((texture_base[6] >> 16) & 0x0000ffff);
        dtdx = ((texture_base[2] << 16) & 0xffff0000) | (texture_base[6] & 0x0000ffff);
        dwdx = (texture_base[3] & 0xffff0000) | ((texture_base[7] >> 16) & 0x0000ffff);
        dsde = (texture_base[8] & 0xffff0000) | ((texture_base[12] >> 16) & 0x0000ffff);
        dtde = ((texture_base[8] << 16) & 0xffff0000) | (texture_base[12] & 0x0000ffff);
        dwde = (texture_base[9] & 0xffff0000) | ((texture_base[13] >> 16) & 0x0000ffff);
    }
    if (zbuffer)
    {
        z = zbuffer_base[0];
        dzdx = zbuffer_base[1];
        dzde = zbuffer_base[2];
    }

    xh <<= 2;  xm <<= 2;  xl <<= 2;
    r <<= 2;  g <<= 2;  b <<= 2;  a <<= 2;
    dsde >>= 2;  dtde >>= 2;  dsdx >>= 2;  dtdx >>= 2;
    dzdx >>= 2;  dzde >>= 2;
    dwdx >>= 2;  dwde >>= 2;

#define XSCALE(x) (float(x)/(1<<18))
#define YSCALE(y) (float(y)/(1<<2))
#define ZSCALE(z) ((rdp.zsrc == 1)? float(rdp.prim_depth) : float(uint32_t(z))/0xffff0000)
    //#define WSCALE(w) (rdp.Persp_en? (float(uint32_t(w) + 0x10000)/0xffff0000) : 1.0f)
    //#define WSCALE(w) (rdp.Persp_en? 4294901760.0/(w + 65536) : 1.0f)
#define WSCALE(w) (rdp.Persp_en? 65536.0f/float((w+ 0xffff)>>16) : 1.0f)
#define CSCALE(c) (((c)>0x3ff0000? 0x3ff0000:((c)<0? 0 : (c)))>>18)
#define _PERSP(w) ( w )
#define PERSP(s, w) ( ((int64)(s) << 20) / (_PERSP(w)? _PERSP(w):1) )
#define SSCALE(s, _w) (rdp.Persp_en? float(PERSP(s, _w))/(1 << 10) : float(s)/(1<<21))
#define TSCALE(s, w) (rdp.Persp_en? float(PERSP(s, w))/(1 << 10) : float(s)/(1<<21))

    int nbVtxs = 0;
    VERTEX vtxbuf[12];
    VERTEX * vtx = &vtxbuf[nbVtxs++];

    xleft = xm;
    xright = xh;
    xleft_inc = dxmdy;
    xright_inc = dxhdy;

    while (yh < ym &&
        !((!flip && xleft < xright + 0x10000) ||
        (flip && xleft > xright - 0x10000))) {
        xleft += xleft_inc;
        xright += xright_inc;
        s += dsde;    t += dtde;    w += dwde;
        r += drde;    g += dgde;    b += dbde;    a += dade;
        z += dzde;
        yh++;
    }

    j = ym - yh;
    if (j > 0)
    {
        int dx = (xleft - xright) >> 16;
        if ((!flip && xleft < xright) ||
            (flip/* && xleft > xright*/))
        {
            if (shade) {
                vtx->r = CSCALE(r + drdx*dx);
                vtx->g = CSCALE(g + dgdx*dx);
                vtx->b = CSCALE(b + dbdx*dx);
                vtx->a = CSCALE(a + dadx*dx);
            }
            if (texture) {
                vtx->ou = SSCALE(s + dsdx*dx, w + dwdx*dx);
                vtx->ov = TSCALE(t + dtdx*dx, w + dwdx*dx);
            }
            vtx->x = XSCALE(xleft);
            vtx->y = YSCALE(yh);
            vtx->z = ZSCALE(z + dzdx*dx);
            vtx->w = WSCALE(w + dwdx*dx);
            vtx = &vtxbuf[nbVtxs++];
        }
        if ((!flip/* && xleft < xright*/) ||
            (flip && xleft > xright))
        {
            if (shade) {
                vtx->r = CSCALE(r);
                vtx->g = CSCALE(g);
                vtx->b = CSCALE(b);
                vtx->a = CSCALE(a);
            }
            if (texture) {
                vtx->ou = SSCALE(s, w);
                vtx->ov = TSCALE(t, w);
            }
            vtx->x = XSCALE(xright);
            vtx->y = YSCALE(yh);
            vtx->z = ZSCALE(z);
            vtx->w = WSCALE(w);
            vtx = &vtxbuf[nbVtxs++];
        }
        xleft += xleft_inc*j;  xright += xright_inc*j;
        s += dsde*j;  t += dtde*j;
        if (w + dwde*j) w += dwde*j;
        else w += dwde*(j - 1);
        r += drde*j;  g += dgde*j;  b += dbde*j;  a += dade*j;
        z += dzde*j;
        // render ...
    }

    if (xl != xh)
        xleft = xl;

    //if (yl-ym > 0)
    {
        int dx = (xleft - xright) >> 16;
        if ((!flip && xleft <= xright) ||
            (flip/* && xleft >= xright*/))
        {
            if (shade) {
                vtx->r = CSCALE(r + drdx*dx);
                vtx->g = CSCALE(g + dgdx*dx);
                vtx->b = CSCALE(b + dbdx*dx);
                vtx->a = CSCALE(a + dadx*dx);
            }
            if (texture) {
                vtx->ou = SSCALE(s + dsdx*dx, w + dwdx*dx);
                vtx->ov = TSCALE(t + dtdx*dx, w + dwdx*dx);
            }
            vtx->x = XSCALE(xleft);
            vtx->y = YSCALE(ym);
            vtx->z = ZSCALE(z + dzdx*dx);
            vtx->w = WSCALE(w + dwdx*dx);
            vtx = &vtxbuf[nbVtxs++];
        }
        if ((!flip/* && xleft <= xright*/) ||
            (flip && xleft >= xright))
        {
            if (shade) {
                vtx->r = CSCALE(r);
                vtx->g = CSCALE(g);
                vtx->b = CSCALE(b);
                vtx->a = CSCALE(a);
            }
            if (texture) {
                vtx->ou = SSCALE(s, w);
                vtx->ov = TSCALE(t, w);
            }
            vtx->x = XSCALE(xright);
            vtx->y = YSCALE(ym);
            vtx->z = ZSCALE(z);
            vtx->w = WSCALE(w);
            vtx = &vtxbuf[nbVtxs++];
        }
    }
    xleft_inc = dxldy;
    xright_inc = dxhdy;

    j = yl - ym;
    //j--; // ?
    xleft += xleft_inc*j;  xright += xright_inc*j;
    s += dsde*j;  t += dtde*j;  w += dwde*j;
    r += drde*j;  g += dgde*j;  b += dbde*j;  a += dade*j;
    z += dzde*j;

    while (yl > ym &&
        !((!flip && xleft < xright + 0x10000) ||
        (flip && xleft > xright - 0x10000))) {
        xleft -= xleft_inc;    xright -= xright_inc;
        s -= dsde;    t -= dtde;    w -= dwde;
        r -= drde;    g -= dgde;    b -= dbde;    a -= dade;
        z -= dzde;
        j--;
        yl--;
    }

    // render ...
    if (j >= 0) {
        int dx = (xleft - xright) >> 16;
        if ((!flip && xleft <= xright) ||
            (flip/* && xleft >= xright*/))
        {
            if (shade) {
                vtx->r = CSCALE(r + drdx*dx);
                vtx->g = CSCALE(g + dgdx*dx);
                vtx->b = CSCALE(b + dbdx*dx);
                vtx->a = CSCALE(a + dadx*dx);
            }
            if (texture) {
                vtx->ou = SSCALE(s + dsdx*dx, w + dwdx*dx);
                vtx->ov = TSCALE(t + dtdx*dx, w + dwdx*dx);
            }
            vtx->x = XSCALE(xleft);
            vtx->y = YSCALE(yl);
            vtx->z = ZSCALE(z + dzdx*dx);
            vtx->w = WSCALE(w + dwdx*dx);
            vtx = &vtxbuf[nbVtxs++];
        }
        if ((!flip/* && xleft <= xright*/) ||
            (flip && xleft >= xright))
        {
            if (shade) {
                vtx->r = CSCALE(r);
                vtx->g = CSCALE(g);
                vtx->b = CSCALE(b);
                vtx->a = CSCALE(a);
            }
            if (texture) {
                vtx->ou = SSCALE(s, w);
                vtx->ov = TSCALE(t, w);
            }
            vtx->x = XSCALE(xright);
            vtx->y = YSCALE(yl);
            vtx->z = ZSCALE(z);
            vtx->w = WSCALE(w);
            vtx = &vtxbuf[nbVtxs++];
        }
    }

    update();
    for (int k = 0; k < nbVtxs - 1; k++)
    {
        VERTEX * v = &vtxbuf[k];
        v->x = v->x * rdp.scale_x + rdp.offset_x;
        v->y = v->y * rdp.scale_y + rdp.offset_y;
        //    v->z = 1.0f;///v->w;
        v->q = 1.0f / v->w;
        v->u1 = v->u0 = v->ou;
        v->v1 = v->v0 = v->ov;
        if (rdp.tex >= 1 && rdp.cur_cache[0])
        {
            if (rdp.tiles[rdp.cur_tile].shift_s)
            {
                if (rdp.tiles[rdp.cur_tile].shift_s > 10)
                    v->u0 *= (float)(1 << (16 - rdp.tiles[rdp.cur_tile].shift_s));
                else
                    v->u0 /= (float)(1 << rdp.tiles[rdp.cur_tile].shift_s);
            }
            if (rdp.tiles[rdp.cur_tile].shift_t)
            {
                if (rdp.tiles[rdp.cur_tile].shift_t > 10)
                    v->v0 *= (float)(1 << (16 - rdp.tiles[rdp.cur_tile].shift_t));
                else
                    v->v0 /= (float)(1 << rdp.tiles[rdp.cur_tile].shift_t);
            }

            v->u0 -= rdp.tiles[rdp.cur_tile].f_ul_s;
            v->v0 -= rdp.tiles[rdp.cur_tile].f_ul_t;
            v->u0 = rdp.cur_cache[0]->c_off + rdp.cur_cache[0]->c_scl_x * v->u0;
            v->v0 = rdp.cur_cache[0]->c_off + rdp.cur_cache[0]->c_scl_y * v->v0;
            v->u0 /= v->w;
            v->v0 /= v->w;
        }

        if (rdp.tex >= 2 && rdp.cur_cache[1])
        {
            if (rdp.tiles[rdp.cur_tile + 1].shift_s)
            {
                if (rdp.tiles[rdp.cur_tile + 1].shift_s > 10)
                    v->u1 *= (float)(1 << (16 - rdp.tiles[rdp.cur_tile + 1].shift_s));
                else
                    v->u1 /= (float)(1 << rdp.tiles[rdp.cur_tile + 1].shift_s);
            }
            if (rdp.tiles[rdp.cur_tile + 1].shift_t)
            {
                if (rdp.tiles[rdp.cur_tile + 1].shift_t > 10)
                    v->v1 *= (float)(1 << (16 - rdp.tiles[rdp.cur_tile + 1].shift_t));
                else
                    v->v1 /= (float)(1 << rdp.tiles[rdp.cur_tile + 1].shift_t);
            }

            v->u1 -= rdp.tiles[rdp.cur_tile + 1].f_ul_s;
            v->v1 -= rdp.tiles[rdp.cur_tile + 1].f_ul_t;
            v->u1 = rdp.cur_cache[1]->c_off + rdp.cur_cache[1]->c_scl_x * v->u1;
            v->v1 = rdp.cur_cache[1]->c_off + rdp.cur_cache[1]->c_scl_y * v->v1;
            v->u1 /= v->w;
            v->v1 /= v->w;
        }
        apply_shade_mods(v);
    }
    ConvertCoordsConvert(vtxbuf, nbVtxs);
    grCullMode(GR_CULL_DISABLE);
    grDrawVertexArrayContiguous(GR_TRIANGLE_STRIP, nbVtxs - 1, vtxbuf, sizeof(VERTEX));
}

static void rdp_triangle(int shade, int texture, int zbuffer)
{
    lle_triangle(rdp.cmd0, rdp.cmd1, shade, texture, zbuffer, rdp_cmd_data + rdp_cmd_cur);
}

static void rdp_trifill()
{
    rdp_triangle(0, 0, 0);
    WriteTrace(TraceRDP, TraceDebug, "trifill");
}

static void rdp_trishade()
{
    rdp_triangle(1, 0, 0);
    WriteTrace(TraceRDP, TraceDebug, "trishade");
}

static void rdp_tritxtr()
{
    rdp_triangle(0, 1, 0);
    WriteTrace(TraceRDP, TraceDebug, "tritxtr");
}

static void rdp_trishadetxtr()
{
    rdp_triangle(1, 1, 0);
    WriteTrace(TraceRDP, TraceDebug, "trishadetxtr");
}

static void rdp_trifillz()
{
    rdp_triangle(0, 0, 1);
    WriteTrace(TraceRDP, TraceDebug, "trifillz");
}

static void rdp_trishadez()
{
    rdp_triangle(1, 0, 1);
    WriteTrace(TraceRDP, TraceDebug, "trishadez");
}

static void rdp_tritxtrz()
{
    rdp_triangle(0, 1, 1);
    WriteTrace(TraceRDP, TraceDebug, "tritxtrz");
}

static void rdp_trishadetxtrz()
{
    rdp_triangle(1, 1, 1);
    WriteTrace(TraceRDP, TraceDebug, "trishadetxtrz");
}

static rdp_instr rdp_command_table[64] =
{
    /* 0x00 */
    spnoop, undef, undef, undef,
    undef, undef, undef, undef,
    rdp_trifill, rdp_trifillz, rdp_tritxtr, rdp_tritxtrz,
    rdp_trishade, rdp_trishadez, rdp_trishadetxtr, rdp_trishadetxtrz,
    /* 0x10 */
    undef, undef, undef, undef,
    undef, undef, undef, undef,
    undef, undef, undef, undef,
    undef, undef, undef, undef,
    /* 0x20 */
    undef, undef, undef, undef,
    rdp_texrect, rdp_texrect, rdp_loadsync, rdp_pipesync,
    rdp_tilesync, rdp_fullsync, rdp_setkeygb, rdp_setkeyr,
    rdp_setconvert, rdp_setscissor, rdp_setprimdepth, rdp_setothermode,
    /* 0x30 */
    rdp_loadtlut, undef, rdp_settilesize, rdp_loadblock,
    rdp_loadtile, rdp_settile, rdp_fillrect, rdp_setfillcolor,
    rdp_setfogcolor, rdp_setblendcolor, rdp_setprimcolor, rdp_setenvcolor,
    rdp_setcombine, rdp_settextureimage, rdp_setdepthimage, rdp_setcolorimage
};

static const uint32_t rdp_command_length[64] =
{
    8,                      // 0x00, No Op
    8,                      // 0x01, ???
    8,                      // 0x02, ???
    8,                      // 0x03, ???
    8,                      // 0x04, ???
    8,                      // 0x05, ???
    8,                      // 0x06, ???
    8,                      // 0x07, ???
    32,                     // 0x08, Non-Shaded Triangle
    32 + 16,          // 0x09, Non-Shaded, Z-Buffered Triangle
    32 + 64,          // 0x0a, Textured Triangle
    32 + 64 + 16,       // 0x0b, Textured, Z-Buffered Triangle
    32 + 64,          // 0x0c, Shaded Triangle
    32 + 64 + 16,       // 0x0d, Shaded, Z-Buffered Triangle
    32 + 64 + 64,       // 0x0e, Shaded+Textured Triangle
    32 + 64 + 64 + 16,// 0x0f, Shaded+Textured, Z-Buffered Triangle
    8,                      // 0x10, ???
    8,                      // 0x11, ???
    8,                      // 0x12, ???
    8,                      // 0x13, ???
    8,                      // 0x14, ???
    8,                      // 0x15, ???
    8,                      // 0x16, ???
    8,                      // 0x17, ???
    8,                      // 0x18, ???
    8,                      // 0x19, ???
    8,                      // 0x1a, ???
    8,                      // 0x1b, ???
    8,                      // 0x1c, ???
    8,                      // 0x1d, ???
    8,                      // 0x1e, ???
    8,                      // 0x1f, ???
    8,                      // 0x20, ???
    8,                      // 0x21, ???
    8,                      // 0x22, ???
    8,                      // 0x23, ???
    16,                     // 0x24, Texture_Rectangle
    16,                     // 0x25, Texture_Rectangle_Flip
    8,                      // 0x26, Sync_Load
    8,                      // 0x27, Sync_Pipe
    8,                      // 0x28, Sync_Tile
    8,                      // 0x29, Sync_Full
    8,                      // 0x2a, Set_Key_GB
    8,                      // 0x2b, Set_Key_R
    8,                      // 0x2c, Set_Convert
    8,                      // 0x2d, Set_Scissor
    8,                      // 0x2e, Set_Prim_Depth
    8,                      // 0x2f, Set_Other_Modes
    8,                      // 0x30, Load_TLUT
    8,                      // 0x31, ???
    8,                      // 0x32, Set_Tile_Size
    8,                      // 0x33, Load_Block
    8,                      // 0x34, Load_Tile
    8,                      // 0x35, Set_Tile
    8,                      // 0x36, Fill_Rectangle
    8,                      // 0x37, Set_Fill_Color
    8,                      // 0x38, Set_Fog_Color
    8,                      // 0x39, Set_Blend_Color
    8,                      // 0x3a, Set_Prim_Color
    8,                      // 0x3b, Set_Env_Color
    8,                      // 0x3c, Set_Combine
    8,                      // 0x3d, Set_Texture_Image
    8,                      // 0x3e, Set_Mask_Image
    8                       // 0x3f, Set_Color_Image
};

#define rdram ((uint32_t*)gfx.RDRAM)
#define rsp_dmem ((uint32_t*)gfx.DMEM)

#define dp_start (*(uint32_t*)gfx.DPC_START_REG)
#define dp_end (*(uint32_t*)gfx.DPC_END_REG)
#define dp_current (*(uint32_t*)gfx.DPC_CURRENT_REG)
#define dp_status (*(uint32_t*)gfx.DPC_STATUS_REG)

inline uint32_t READ_RDP_DATA(uint32_t address)
{
    if (dp_status & 0x1)          // XBUS_DMEM_DMA enabled
        return rsp_dmem[(address & 0xfff) >> 2];
    else
        return rdram[address >> 2];
}

static void rdphalf_1()
{
    uint32_t cmd = rdp.cmd1 >> 24;
    if (cmd >= 0xc8 && cmd <= 0xcf) //triangle command
    {
        WriteTrace(TraceRDP, TraceDebug, "rdphalf_1 - lle triangle");
        rdp_cmd_ptr = 0;
        rdp_cmd_cur = 0;
        uint32_t a;

        do
        {
            rdp_cmd_data[rdp_cmd_ptr++] = rdp.cmd1;
            // check DL counter
            if (rdp.dl_count != -1)
            {
                rdp.dl_count--;
                if (rdp.dl_count == 0)
                {
                    rdp.dl_count = -1;

                    WriteTrace(TraceRDP, TraceDebug, "End of DL");
                    rdp.pc_i--;
                }
            }

            // Get the address of the next command
            a = rdp.pc[rdp.pc_i] & BMASK;

            // Load the next command and its input
            rdp.cmd0 = ((uint32_t*)gfx.RDRAM)[a >> 2];   // \ Current command, 64 bit
            rdp.cmd1 = ((uint32_t*)gfx.RDRAM)[(a >> 2) + 1]; // /

            // Go to the next instruction
            rdp.pc[rdp.pc_i] = (a + 8) & BMASK;
        } while ((rdp.cmd0 >> 24) != 0xb3);
        rdp_cmd_data[rdp_cmd_ptr++] = rdp.cmd1;
        cmd = (rdp_cmd_data[rdp_cmd_cur] >> 24) & 0x3f;
        rdp.cmd0 = rdp_cmd_data[rdp_cmd_cur + 0];
        rdp.cmd1 = rdp_cmd_data[rdp_cmd_cur + 1];
        /*
        uint32_t cmd3 = ((uint32_t*)gfx.RDRAM)[(a>>2)+2];
        if ((cmd3>>24) == 0xb4)
        rglSingleTriangle = TRUE;
        else
        rglSingleTriangle = FALSE;
        */
        rdp_command_table[cmd]();
    }
    else
    {
        WriteTrace(TraceRDP, TraceDebug, "rdphalf_1 - IGNORED");
    }
}

static void rdphalf_2()
{
    WriteTrace(TraceRDP, TraceWarning, "rdphalf_2 - IGNORED");
}

static void rdphalf_cont()
{
    WriteTrace(TraceRDP, TraceWarning, "rdphalf_cont - IGNORED");
}

/******************************************************************
Function: ProcessRDPList
Purpose:  This function is called when there is a Dlist to be
processed. (Low level GFX list)
input:    none
output:   none
*******************************************************************/
void CALL ProcessRDPList(void)
{
#ifdef _WIN32
    CGuard guard(*g_ProcessDListCS);
#endif
    WriteTrace(TraceGlide64, TraceDebug, "-");

    no_dlist = false;
    update_screen_count = 0;
    ChangeSize();

    // Switch to fullscreen?
    if (to_fullscreen)
        GoToFullScreen();

    //* Set states *//
    if (g_settings->swapmode() != CSettings::SwapMode_Old)
    {
        SwapOK = TRUE;
    }
    rdp.updatescreen = 1;

    rdp.tri_n = 0;  // 0 triangles so far this frame
    rdp.debug_n = 0;

    rdp.model_i = 0; // 0 matrices so far in stack
    //stack_size can be less then 32! Important for Silicon Vally. Thanks Orkin!
    rdp.model_stack_size = minval(32, (*(uint32_t*)(gfx.DMEM + 0x0FE4)) >> 6);
    if (rdp.model_stack_size == 0)
        rdp.model_stack_size = 32;
    rdp.Persp_en = TRUE;
    rdp.fb_drawn = rdp.fb_drawn_front = FALSE;
    rdp.update = 0x7FFFFFFF;  // All but clear cache
    rdp.geom_mode = 0;
    rdp.acmp = 0;
    rdp.maincimg[1] = rdp.maincimg[0];
    rdp.skip_drawing = FALSE;
    rdp.s2dex_tex_loaded = FALSE;
    rdp.bg_image_height = 0xFFFF;
    fbreads_front = fbreads_back = 0;
    rdp.fog_multiplier = rdp.fog_offset = 0;
    rdp.zsrc = 0;
    if (rdp.vi_org_reg != *gfx.VI_ORIGIN_REG)
        rdp.tlut_mode = 0; //is it correct?
    rdp.scissor_set = FALSE;
    ucode5_texshiftaddr = ucode5_texshiftcount = 0;
    cpu_fb_write = FALSE;
    cpu_fb_read_called = FALSE;
    cpu_fb_write_called = FALSE;
    cpu_fb_ignore = FALSE;
    d_ul_x = 0xffff;
    d_ul_y = 0xffff;
    d_lr_x = 0;
    d_lr_y = 0;
    depth_buffer_fog = TRUE;

    const uint32_t length = dp_end - dp_current;

    dp_status &= ~0x0002;

    if (dp_end <= dp_current) return;

    rdp.LLE = TRUE;

    // load command data
    for (uint32_t i = 0; i < length; i += 4)
    {
        rdp_cmd_data[rdp_cmd_ptr] = READ_RDP_DATA(dp_current + i);
        rdp_cmd_ptr = (rdp_cmd_ptr + 1) & maxCMDMask;
    }

    bool setZero = true;

    while (rdp_cmd_cur != rdp_cmd_ptr)
    {
        uint32_t cmd = (rdp_cmd_data[rdp_cmd_cur] >> 24) & 0x3f;

        if ((((rdp_cmd_ptr - rdp_cmd_cur)&maxCMDMask) * 4) < rdp_command_length[cmd]) {
            setZero = false;
            break;
        }

        if (rdp_cmd_cur + rdp_command_length[cmd] / 4 > MAXCMD)
            ::memcpy(rdp_cmd_data + MAXCMD, rdp_cmd_data, rdp_command_length[cmd] - (MAXCMD - rdp_cmd_cur) * 4);

        // execute the command
        rdp.cmd0 = rdp_cmd_data[rdp_cmd_cur + 0];
        rdp.cmd1 = rdp_cmd_data[rdp_cmd_cur + 1];
        rdp.cmd2 = rdp_cmd_data[rdp_cmd_cur + 2];
        rdp.cmd3 = rdp_cmd_data[rdp_cmd_cur + 3];
        //RSP.cmd = cmd;
        rdp_command_table[cmd]();

        rdp_cmd_cur = (rdp_cmd_cur + rdp_command_length[cmd] / 4) & maxCMDMask;
    }

    if (setZero) 
    {
        rdp_cmd_ptr = 0;
        rdp_cmd_cur = 0;
    }

    rdp.LLE = FALSE;

    dp_start = dp_current = dp_end;
}