mirror of
https://github.com/dolphin-emu/dolphin.git
synced 2024-11-15 22:09:19 -07:00
80d48a08d8
Also some cleanup in BPStructs and I think this should be SETTLUT not LOADTLUT, because there is already a LOADTLUT earlier in the reg list. git-svn-id: https://dolphin-emu.googlecode.com/svn/trunk@2898 8ced0084-cf51-0410-be5f-012b33b47a6e
506 lines
18 KiB
C++
506 lines
18 KiB
C++
// Copyright (C) 2003-2009 Dolphin Project.
|
|
|
|
// 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, version 2.0.
|
|
|
|
// 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 2.0 for more details.
|
|
|
|
// A copy of the GPL 2.0 should have been included with the program.
|
|
// If not, see http://www.gnu.org/licenses/
|
|
|
|
// Official SVN repository and contact information can be found at
|
|
// http://code.google.com/p/dolphin-emu/
|
|
|
|
#include <cmath>
|
|
|
|
#include "Profiler.h"
|
|
#include "Statistics.h"
|
|
#include "VideoCommon.h"
|
|
#include "PixelShaderManager.h"
|
|
#include "BPFunctions.h"
|
|
#include "BPStructs.h"
|
|
#include "TextureDecoder.h"
|
|
#include "OpcodeDecoding.h"
|
|
#include "VertexLoader.h"
|
|
#include "VertexShaderManager.h"
|
|
|
|
using namespace BPFunctions;
|
|
|
|
void BPInit()
|
|
{
|
|
memset(&bpmem, 0, sizeof(bpmem));
|
|
bpmem.bpMask = 0xFFFFFF;
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------------------------------
|
|
// Write to the Bypass Memory
|
|
/* ------------------
|
|
Called:
|
|
At the end of every: OpcodeDecoding.cpp ExecuteDisplayList > Decode() > LoadBPReg
|
|
TODO:
|
|
Turn into function table. The (future) DisplayList (DL) jit can then call the functions directly,
|
|
getting rid of dynamic dispatch. Unfortunately, few games use DLs properly - most\
|
|
just stuff geometry in them and don't put state changes there. */
|
|
// ----------------------------------------------------------------------------------------------------------
|
|
void BPWritten(const Bypass& bp)
|
|
{
|
|
|
|
// --------------------------------------------------------------------------------------------------------
|
|
// First the pipeline is flushed then update the bpmem with the new value.
|
|
// Some of the BP cases have to call certain functions while others just update the bpmem.
|
|
// some bp cases check the changes variable, because they might not have to be updated all the time
|
|
// NOTE: it seems not all bp cases like checking changes, so calling if (bp.changes == 0 ? false : true)
|
|
// had to be ditched and the games seem to work fine with out it.
|
|
// --------------------------------------------------------------------------------------------------------
|
|
|
|
FlushPipeline();
|
|
((u32*)&bpmem)[bp.address] = bp.newvalue;
|
|
|
|
switch (bp.address)
|
|
{
|
|
case BPMEM_GENMODE: // Set the Generation Mode
|
|
PRIM_LOG("genmode: texgen=%d, col=%d, ms_en=%d, tev=%d, culmode=%d, ind=%d, zfeeze=%d",
|
|
bpmem.genMode.numtexgens, bpmem.genMode.numcolchans,
|
|
bpmem.genMode.ms_en, bpmem.genMode.numtevstages+1, bpmem.genMode.cullmode,
|
|
bpmem.genMode.numindstages, bpmem.genMode.zfreeze);
|
|
SetGenerationMode(bp);
|
|
break;
|
|
case BPMEM_IND_MTXA: // Index Matrix Changed
|
|
case BPMEM_IND_MTXB:
|
|
case BPMEM_IND_MTXC:
|
|
case BPMEM_IND_MTXA+3:
|
|
case BPMEM_IND_MTXB+3:
|
|
case BPMEM_IND_MTXC+3:
|
|
case BPMEM_IND_MTXA+6:
|
|
case BPMEM_IND_MTXB+6:
|
|
case BPMEM_IND_MTXC+6:
|
|
PixelShaderManager::SetIndMatrixChanged((bp.address - BPMEM_IND_MTXA) / 3);
|
|
break;
|
|
case BPMEM_RAS1_SS0: // Index Texture Coordinate Scale 0
|
|
case BPMEM_RAS1_SS1: // Index Texture Coordinate Scale 1
|
|
PixelShaderManager::SetIndTexScaleChanged();
|
|
break;
|
|
case BPMEM_SCISSORTL: // Scissor Rectable Top, Left
|
|
case BPMEM_SCISSORBR: // Scissor Rectable Bottom, Right
|
|
case BPMEM_SCISSOROFFSET: // Scissor Offset
|
|
SetScissor(bp);
|
|
break;
|
|
case BPMEM_LINEPTWIDTH: // Line Width
|
|
SetLineWidth(bp);
|
|
break;
|
|
case BPMEM_ZMODE: // Depth Control
|
|
PRIM_LOG("zmode: test=%d, func=%d, upd=%d", bpmem.zmode.testenable, bpmem.zmode.func,
|
|
bpmem.zmode.updateenable);
|
|
SetDepthMode(bp);
|
|
break;
|
|
case BPMEM_BLENDMODE: // Blending Control
|
|
if (bp.changes & 0xFFFF)
|
|
{
|
|
PRIM_LOG("blendmode: en=%d, open=%d, colupd=%d, alphaupd=%d, dst=%d, src=%d, sub=%d, mode=%d",
|
|
bpmem.blendmode.blendenable, bpmem.blendmode.logicopenable, bpmem.blendmode.colorupdate, bpmem.blendmode.alphaupdate,
|
|
bpmem.blendmode.dstfactor, bpmem.blendmode.srcfactor, bpmem.blendmode.subtract, bpmem.blendmode.logicmode);
|
|
// Set LogicOp Blending Mode
|
|
if (bp.changes & 2)
|
|
{
|
|
SETSTAT(stats.logicOpMode, bpmem.blendmode.logicopenable != 0 ? bpmem.blendmode.logicmode : stats.logicOpMode);
|
|
SetLogicOpMode(bp);
|
|
}
|
|
// Set Dithering Mode
|
|
if (bp.changes & 4)
|
|
{
|
|
SETSTAT(stats.dither, bpmem.blendmode.dither);
|
|
SetDitherMode(bp);
|
|
}
|
|
// Set Blending Mode
|
|
if (bp.changes & 0xFE1)
|
|
{
|
|
SETSTAT(stats.srcFactor, bpmem.blendmode.srcfactor);
|
|
SETSTAT(stats.dstFactor, bpmem.blendmode.dstfactor);
|
|
SetBlendMode(bp);
|
|
}
|
|
// Set Color Mask
|
|
if (bp.changes & 0x18)
|
|
{
|
|
SETSTAT(stats.alphaUpdate, bpmem.blendmode.alphaupdate);
|
|
SETSTAT(stats.colorUpdate, bpmem.blendmode.colorupdate);
|
|
SetColorMask(bp);
|
|
}
|
|
}
|
|
break;
|
|
case BPMEM_CONSTANTALPHA: // Set Destination Alpha
|
|
PRIM_LOG("constalpha: alp=%d, en=%d", bpmem.dstalpha.alpha, bpmem.dstalpha.enable);
|
|
SETSTAT(stats.dstAlphaEnable, bpmem.dstalpha.enable);
|
|
SETSTAT_UINT(stats.dstAlpha, bpmem.dstalpha.alpha);
|
|
PixelShaderManager::SetDestAlpha(bpmem.dstalpha);
|
|
break;
|
|
case BPMEM_SETDRAWDONE: // This is called when the game is done drawing (eg: like in DX: Begin(); Draw(); End();)
|
|
switch (bp.newvalue & 0xFF)
|
|
{
|
|
case 0x02:
|
|
g_VideoInitialize.pSetPEFinish(); // may generate interrupt
|
|
DEBUG_LOG(VIDEO, "GXSetDrawDone SetPEFinish (value: 0x%02X)", (bp.newvalue & 0xFFFF));
|
|
break;
|
|
|
|
default:
|
|
DEBUG_LOG(VIDEO, "GXSetDrawDone ??? (value 0x%02X)", (bp.newvalue & 0xFFFF));
|
|
break;
|
|
}
|
|
break;
|
|
case BPMEM_PE_TOKEN_ID: // Pixel Engine Token ID
|
|
g_VideoInitialize.pSetPEToken(static_cast<u16>(bp.newvalue & 0xFFFF), FALSE);
|
|
DEBUG_LOG(VIDEO, "SetPEToken 0x%04x", (bp.newvalue & 0xFFFF));
|
|
break;
|
|
case BPMEM_PE_TOKEN_INT_ID: // Pixel Engine Interrupt Token ID
|
|
g_VideoInitialize.pSetPEToken(static_cast<u16>(bp.newvalue & 0xFFFF), TRUE);
|
|
DEBUG_LOG(VIDEO, "SetPEToken + INT 0x%04x", (bp.newvalue & 0xFFFF));
|
|
break;
|
|
// ------------------------
|
|
// EFB copy command. This copies a rectangle from the EFB to either RAM in a texture format or to XFB as YUYV.
|
|
// It can also optionally clear the EFB while copying from it. To emulate this, we of course copy first and clear afterwards.
|
|
case BPMEM_TRIGGER_EFB_COPY: // Copy EFB Region or Render to the XFB or Clear the screen.
|
|
{
|
|
DVSTARTSUBPROFILE("LoadBPReg:swap");
|
|
// The bottom right is within the rectangle
|
|
// The values in bpmem.copyTexSrcXY and bpmem.copyTexSrcWH are updated in case 0x49 and 0x4a in this function
|
|
TRectangle rc = {
|
|
(int)(bpmem.copyTexSrcXY.x),
|
|
(int)(bpmem.copyTexSrcXY.y),
|
|
(int)((bpmem.copyTexSrcXY.x + bpmem.copyTexSrcWH.x + 1)),
|
|
(int)((bpmem.copyTexSrcXY.y + bpmem.copyTexSrcWH.y + 1))
|
|
};
|
|
|
|
float MValueX = GetRendererTargetScaleX();
|
|
float MValueY = GetRendererTargetScaleY();
|
|
|
|
// Need another rc here to get it to scale.
|
|
// Here the bottom right is the out of the rectangle.
|
|
TRectangle multirc = {
|
|
(int)(bpmem.copyTexSrcXY.x * MValueX),
|
|
(int)(bpmem.copyTexSrcXY.y * MValueY),
|
|
(int)((bpmem.copyTexSrcXY.x * MValueX + (bpmem.copyTexSrcWH.x + 1) * MValueX)),
|
|
(int)((bpmem.copyTexSrcXY.y * MValueY + (bpmem.copyTexSrcWH.y + 1) * MValueY))
|
|
};
|
|
UPE_Copy PE_copy;
|
|
PE_copy.Hex = bpmem.triggerEFBCopy;
|
|
// ----------------------------------------------------------
|
|
// Check to where we should copy the image data from the EFB.
|
|
// ----------------------------------------------------------
|
|
if (PE_copy.copy_to_xfb == 0)
|
|
{
|
|
if (GetConfig(CONFIG_SHOWEFBREGIONS))
|
|
stats.efb_regions.push_back(rc);
|
|
|
|
CopyEFB(bp, rc, bpmem.copyTexDest << 5,
|
|
bpmem.zcontrol.pixel_format == PIXELFMT_Z24,
|
|
PE_copy.intensity_fmt > 0,
|
|
((PE_copy.target_pixel_format / 2) + ((PE_copy.target_pixel_format & 1) * 8)),
|
|
PE_copy.half_scale > 0);
|
|
}
|
|
else
|
|
{
|
|
// the number of lines copied is determined by the y scale * source efb height
|
|
const float yScale = bpmem.dispcopyyscale / 256.0f;
|
|
const float xfbLines = ((bpmem.copyTexSrcWH.y + 1.0f) * yScale);
|
|
RenderToXFB(bp, multirc, yScale, xfbLines,
|
|
Memory_GetPtr(bpmem.copyTexDest << 5),
|
|
bpmem.copyMipMapStrideChannels << 4,
|
|
(u32)ceil(xfbLines));
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------------
|
|
// Clear the picture after it's done and submitted, to prepare for the next picture
|
|
// ----------------------------------------------------------------------------------
|
|
if (PE_copy.clear)
|
|
ClearScreen(bp, multirc);
|
|
|
|
RestoreRenderState(bp);
|
|
|
|
break;
|
|
}
|
|
case BPMEM_LOADTLUT0: // Load the Texture Look Up Table
|
|
case BPMEM_LOADTLUT1:
|
|
{
|
|
DVSTARTSUBPROFILE("LoadBPReg:GXLoadTlut");
|
|
|
|
u32 tlutTMemAddr = (bp.newvalue & 0x3FF) << 9;
|
|
u32 tlutXferCount = (bp.newvalue & 0x1FFC00) >> 5;
|
|
|
|
u8 *ptr = 0;
|
|
|
|
// TODO - figure out a cleaner way.
|
|
if (GetConfig(CONFIG_ISWII))
|
|
ptr = GetPointer(bpmem.tlutXferSrc << 5);
|
|
else
|
|
ptr = GetPointer((bpmem.tlutXferSrc & 0xFFFFF) << 5);
|
|
|
|
if (ptr)
|
|
memcpy_gc(texMem + tlutTMemAddr, ptr, tlutXferCount);
|
|
else
|
|
PanicAlert("Invalid palette pointer %08x %08x %08x", bpmem.tlutXferSrc, bpmem.tlutXferSrc << 5, (bpmem.tlutXferSrc & 0xFFFFF)<< 5);
|
|
|
|
// TODO(ector) : kill all textures that use this palette
|
|
// Not sure if it's a good idea, though. For now, we hash texture palettes
|
|
}
|
|
break;
|
|
case BPMEM_FOGRANGE: // Fog Settings Control
|
|
case BPMEM_FOGPARAM0:
|
|
case BPMEM_FOGBMAGNITUDE:
|
|
case BPMEM_FOGBEXPONENT:
|
|
case BPMEM_FOGPARAM3:
|
|
if(!GetConfig(CONFIG_DISABLEFOG))
|
|
PixelShaderManager::SetFogParamChanged();
|
|
break;
|
|
case BPMEM_FOGCOLOR: // Fog Color
|
|
PixelShaderManager::SetFogColorChanged();
|
|
break;
|
|
case BPMEM_ALPHACOMPARE:
|
|
PRIM_LOG("alphacmp: ref0=%d, ref1=%d, comp0=%d, comp1=%d, logic=%d", bpmem.alphaFunc.ref0,
|
|
bpmem.alphaFunc.ref1, bpmem.alphaFunc.comp0, bpmem.alphaFunc.comp1, bpmem.alphaFunc.logic);
|
|
PixelShaderManager::SetAlpha(bpmem.alphaFunc);
|
|
break;
|
|
case BPMEM_ZTEX1: // BIAS
|
|
PRIM_LOG("ztex bias=0x%x", bpmem.ztex1.bias);
|
|
PixelShaderManager::SetZTextureBias(bpmem.ztex1.bias);
|
|
break;
|
|
case BPMEM_ZTEX2: // Z Texture type
|
|
{
|
|
if (bp.changes & 3)
|
|
PixelShaderManager::SetZTextureTypeChanged();
|
|
#if defined(_DEBUG) || defined(DEBUGFAST)
|
|
const char* pzop[] = {"DISABLE", "ADD", "REPLACE", "?"};
|
|
const char* pztype[] = {"Z8", "Z16", "Z24", "?"};
|
|
PRIM_LOG("ztex op=%s, type=%s", pzop[bpmem.ztex2.op], pztype[bpmem.ztex2.type]);
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
case BPMEM_DISPLAYCOPYFILER: // Display Filtering Control
|
|
case BPMEM_DISPLAYCOPYFILER+1:
|
|
case BPMEM_DISPLAYCOPYFILER+2:
|
|
case BPMEM_DISPLAYCOPYFILER+3:
|
|
case BPMEM_COPYFILTER0:
|
|
case BPMEM_COPYFILTER1:
|
|
break;
|
|
case BPMEM_SU_COUNTER: // Counters
|
|
case BPMEM_RAS_COUNTER:
|
|
break;
|
|
case BPMEM_FIELDMASK: // Field Control
|
|
case BPMEM_FIELDMODE:
|
|
break;
|
|
case BPMEM_CLOCK0: // Debugging info
|
|
case BPMEM_CLOCK1:
|
|
case BPMEM_SETGPMETRIC:
|
|
break;
|
|
case BPMEM_EFB_TL: // EFB Source Rect. Top, Left
|
|
case BPMEM_EFB_BR: // EFB Source Rect. Bottom, Right (w, h - 1)
|
|
case BPMEM_EFB_ADDR: // EFB Target Address
|
|
break;
|
|
case BPMEM_CLEAR_AR: // Set Clear Alpha and Red Components
|
|
case BPMEM_CLEAR_GB: // Green and Blue
|
|
case BPMEM_CLEAR_Z: // Clear Z, 24-bit Z Value
|
|
break;
|
|
case BPMEM_CLEARBBOX1: // let's hope not many games use bboxes..
|
|
case BPMEM_CLEARBBOX2: // TODO(ector): add something that watches bboxes
|
|
break;
|
|
case BPMEM_IREF:
|
|
case BPMEM_PE_CONTROL: // Pixel Engine Control (GXSetZCompLoc, GXPixModeSync)
|
|
case BPMEM_TEXINVALIDATE: // Used, if game has manual control the Texture Cache, which we don't allow
|
|
case BPMEM_MIPMAP_STRIDE: // MipMap Stride Channel
|
|
case BPMEM_COPYYSCALE: // Display Copy Y Scale
|
|
break;
|
|
case BPMEM_TEV_KSEL: // Texture Environment Swap Mode Table 0
|
|
case BPMEM_TEV_KSEL+1:// Texture Environment Swap Mode Table 1
|
|
case BPMEM_TEV_KSEL+2:// Texture Environment Swap Mode Table 2
|
|
case BPMEM_TEV_KSEL+3:// Texture Environment Swap Mode Table 3
|
|
case BPMEM_TEV_KSEL+4:// Texture Environment Swap Mode Table 4
|
|
case BPMEM_TEV_KSEL+5:// Texture Environment Swap Mode Table 5
|
|
case BPMEM_TEV_KSEL+6:// Texture Environment Swap Mode Table 6
|
|
case BPMEM_TEV_KSEL+7:// Texture Environment Swap Mode Table 7
|
|
break;
|
|
case BPMEM_BP_MASK: // Masks
|
|
case BPMEM_IND_IMASK:
|
|
break;
|
|
case BPMEM_UNKNOWN: // This is always set to 0xF at boot of any game, so this sounds like a useless reg
|
|
|
|
// ------------------------------------------------
|
|
// On Default, we try to look for other things
|
|
// before we give up and say its an unknown opcode
|
|
// ------------------------------------------------
|
|
default:
|
|
switch (bp.address & 0xFC) // Texture sampler filter
|
|
{
|
|
case BPMEM_TREF: // Texture Environment Order
|
|
case BPMEM_TREF+1:
|
|
case BPMEM_TREF+2:
|
|
case BPMEM_TREF+3:
|
|
case BPMEM_TREF+4:
|
|
case BPMEM_TREF+5:
|
|
case BPMEM_TREF+6:
|
|
case BPMEM_TREF+7:
|
|
break;
|
|
// -------------------------------------
|
|
// This could be Level Of Detail control for Wrap
|
|
case BPMEM_SU_SSIZE: // Texture Wrap Size U?
|
|
case BPMEM_SU_TSIZE: // Texture Wrap Size V?
|
|
case BPMEM_SU_SSIZE+2:
|
|
case BPMEM_SU_TSIZE+2:
|
|
case BPMEM_SU_SSIZE+4:
|
|
case BPMEM_SU_TSIZE+4:
|
|
case BPMEM_SU_SSIZE+6:
|
|
case BPMEM_SU_TSIZE+6:
|
|
case BPMEM_SU_SSIZE+8:
|
|
case BPMEM_SU_TSIZE+8:
|
|
case BPMEM_SU_SSIZE+10:
|
|
case BPMEM_SU_TSIZE+10:
|
|
case BPMEM_SU_SSIZE+12:
|
|
case BPMEM_SU_TSIZE+12:
|
|
case BPMEM_SU_SSIZE+14:
|
|
case BPMEM_SU_TSIZE+14:
|
|
break;
|
|
case BPMEM_TX_SETMODE0: // 0x90 for Linear, Index 0
|
|
case BPMEM_TX_SETMODE0+1:
|
|
case BPMEM_TX_SETMODE0+2:
|
|
case BPMEM_TX_SETMODE0+3: // Index 4
|
|
case BPMEM_TX_SETMODE1:
|
|
case BPMEM_TX_SETMODE1+1:
|
|
case BPMEM_TX_SETMODE1+2:
|
|
case BPMEM_TX_SETMODE1+3:
|
|
case BPMEM_TX_SETMODE0_4:
|
|
case BPMEM_TX_SETMODE0_4+1:
|
|
case BPMEM_TX_SETMODE0_4+2:
|
|
case BPMEM_TX_SETMODE0_4+3:
|
|
case BPMEM_TX_SETMODE1_4:
|
|
case BPMEM_TX_SETMODE1_4+1:
|
|
case BPMEM_TX_SETMODE1_4+2:
|
|
case BPMEM_TX_SETMODE1_4+3:
|
|
SetSamplerState(bp);
|
|
break;
|
|
case BPMEM_TX_SETIMAGE0:
|
|
case BPMEM_TX_SETIMAGE0+1:
|
|
case BPMEM_TX_SETIMAGE0+2:
|
|
case BPMEM_TX_SETIMAGE0+3:
|
|
case BPMEM_TX_SETIMAGE0_4:
|
|
case BPMEM_TX_SETIMAGE0_4+1:
|
|
case BPMEM_TX_SETIMAGE0_4+2:
|
|
case BPMEM_TX_SETIMAGE0_4+3:
|
|
case BPMEM_TX_SETIMAGE1:
|
|
case BPMEM_TX_SETIMAGE1+1:
|
|
case BPMEM_TX_SETIMAGE1+2:
|
|
case BPMEM_TX_SETIMAGE1+3:
|
|
case BPMEM_TX_SETIMAGE1_4:
|
|
case BPMEM_TX_SETIMAGE1_4+1:
|
|
case BPMEM_TX_SETIMAGE1_4+2:
|
|
case BPMEM_TX_SETIMAGE1_4+3:
|
|
case BPMEM_TX_SETIMAGE2:
|
|
case BPMEM_TX_SETIMAGE2+1:
|
|
case BPMEM_TX_SETIMAGE2+2:
|
|
case BPMEM_TX_SETIMAGE2+3:
|
|
case BPMEM_TX_SETIMAGE2_4:
|
|
case BPMEM_TX_SETIMAGE2_4+1:
|
|
case BPMEM_TX_SETIMAGE2_4+2:
|
|
case BPMEM_TX_SETIMAGE2_4+3:
|
|
case BPMEM_TX_SETIMAGE3: // Texture Pointer
|
|
case BPMEM_TX_SETIMAGE3+1:
|
|
case BPMEM_TX_SETIMAGE3+2:
|
|
case BPMEM_TX_SETIMAGE3+3:
|
|
case BPMEM_TX_SETIMAGE3_4:
|
|
case BPMEM_TX_SETIMAGE3_4+1:
|
|
case BPMEM_TX_SETIMAGE3_4+2:
|
|
case BPMEM_TX_SETIMAGE3_4+3:
|
|
break;
|
|
case BPMEM_TX_SETTLUT:
|
|
case BPMEM_TX_SETTLUT+1:
|
|
case BPMEM_TX_SETTLUT+2:
|
|
case BPMEM_TX_SETTLUT+3:
|
|
case BPMEM_TX_SETLUT_4:
|
|
case BPMEM_TX_SETLUT_4+1:
|
|
case BPMEM_TX_SETLUT_4+2:
|
|
case BPMEM_TX_SETLUT_4+3:
|
|
break;
|
|
case BPMEM_TEV_REGISTER_L: // Reg 1
|
|
case BPMEM_TEV_REGISTER_H:
|
|
case BPMEM_TEV_REGISTER_L+2: // Reg 2
|
|
case BPMEM_TEV_REGISTER_H+2:
|
|
case BPMEM_TEV_REGISTER_L+4: // Reg 3
|
|
case BPMEM_TEV_REGISTER_H+4:
|
|
case BPMEM_TEV_REGISTER_L+6: // Reg 4
|
|
case BPMEM_TEV_REGISTER_H+6:
|
|
if (bp.address & 1)
|
|
{
|
|
// don't compare with changes!
|
|
int num = (bp.address >> 1 ) & 0x3;
|
|
PixelShaderManager::SetColorChanged(bpmem.tevregs[num].high.type, num);
|
|
}
|
|
break;
|
|
// ------------------------------------------------
|
|
// On Default, we try to look for other things
|
|
// before we give up and say its an unknown opcode
|
|
// again ...
|
|
// ------------------------------------------------
|
|
default:
|
|
switch (bp.address & 0xF0)
|
|
{
|
|
case BPMEM_IND_CMD:
|
|
case BPMEM_IND_CMD+1:
|
|
case BPMEM_IND_CMD+2:
|
|
case BPMEM_IND_CMD+3:
|
|
case BPMEM_IND_CMD+4:
|
|
case BPMEM_IND_CMD+5:
|
|
case BPMEM_IND_CMD+6:
|
|
case BPMEM_IND_CMD+7:
|
|
case BPMEM_IND_CMD+8:
|
|
case BPMEM_IND_CMD+9:
|
|
case BPMEM_IND_CMD+10:
|
|
case BPMEM_IND_CMD+11:
|
|
case BPMEM_IND_CMD+12:
|
|
case BPMEM_IND_CMD+13:
|
|
case BPMEM_IND_CMD+14:
|
|
case BPMEM_IND_CMD+15:
|
|
break;
|
|
case BPMEM_TEV_COLOR_ENV: // Texture Environment 1
|
|
case BPMEM_TEV_ALPHA_ENV:
|
|
case BPMEM_TEV_COLOR_ENV+2: // Texture Environment 2
|
|
case BPMEM_TEV_ALPHA_ENV+2:
|
|
case BPMEM_TEV_COLOR_ENV+4: // Texture Environment 3
|
|
case BPMEM_TEV_ALPHA_ENV+4:
|
|
case BPMEM_TEV_COLOR_ENV+8: // Texture Environment 4
|
|
case BPMEM_TEV_ALPHA_ENV+8:
|
|
case BPMEM_TEV_COLOR_ENV+10: // Texture Environment 5
|
|
case BPMEM_TEV_ALPHA_ENV+10:
|
|
case BPMEM_TEV_COLOR_ENV+12: // Texture Environment 6
|
|
case BPMEM_TEV_ALPHA_ENV+12:
|
|
case BPMEM_TEV_COLOR_ENV+14: // Texture Environment 7
|
|
case BPMEM_TEV_ALPHA_ENV+14:
|
|
case BPMEM_TEV_COLOR_ENV+16: // Texture Environment 8
|
|
case BPMEM_TEV_ALPHA_ENV+16:
|
|
case BPMEM_TEV_COLOR_ENV+18: // Texture Environment 9
|
|
case BPMEM_TEV_ALPHA_ENV+18:
|
|
case BPMEM_TEV_COLOR_ENV+20: // Texture Environment 10
|
|
case BPMEM_TEV_ALPHA_ENV+20:
|
|
case BPMEM_TEV_COLOR_ENV+22: // Texture Environment 11
|
|
case BPMEM_TEV_ALPHA_ENV+22:
|
|
case BPMEM_TEV_COLOR_ENV+24: // Texture Environment 12
|
|
case BPMEM_TEV_ALPHA_ENV+24:
|
|
case BPMEM_TEV_COLOR_ENV+26: // Texture Environment 13
|
|
case BPMEM_TEV_ALPHA_ENV+26:
|
|
case BPMEM_TEV_COLOR_ENV+28: // Texture Environment 14
|
|
case BPMEM_TEV_ALPHA_ENV+28:
|
|
case BPMEM_TEV_COLOR_ENV+30: // Texture Environment 15
|
|
case BPMEM_TEV_ALPHA_ENV+30:
|
|
case BPMEM_TEV_COLOR_ENV+32: // Texture Environment 16
|
|
case BPMEM_TEV_ALPHA_ENV+32:
|
|
break;
|
|
default:
|
|
WARN_LOG(VIDEO, "Unknown Bypass opcode: address = %08x value = %08x", bp.address, bp.newvalue);
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|