piwalker/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2025-07-25 15:19:42 -06:00
Code Issues Packages Projects Releases Wiki Activity

BPMemory: Make use of BitField in a number of structures.

Browse Source
This commit is contained in:
Tony Wasserka
2014-03-24 20:21:34 +01:00
parent 8941f19cdb
commit 16105db709
8 changed files with 266 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Source/Core/VideoBackends/D3D/PSTextureEncoder.cpp
View File

@ -10,7 +10,6 @@
#include "VideoBackends/D3D/PSTextureEncoder.h" #include "VideoBackends/D3D/PSTextureEncoder.h"
#include "VideoBackends/D3D/Render.h" #include "VideoBackends/D3D/Render.h"
#include "VideoBackends/D3D/TextureCache.h" #include "VideoBackends/D3D/TextureCache.h"
#include "VideoCommon/BPMemory.h"
// "Static mode" will compile a new EFB encoder shader for every combination of // "Static mode" will compile a new EFB encoder shader for every combination of
// encoding configurations. It's compatible with Shader Model 4. // encoding configurations. It's compatible with Shader Model 4.

5
Source/Core/VideoBackends/D3D/TextureEncoder.h
View File

@ -4,6 +4,7 @@
#pragma once #pragma once
#include "VideoCommon/BPMemory.h"
#include "VideoCommon/VideoCommon.h" #include "VideoCommon/VideoCommon.h"
namespace DX11 namespace DX11
@ -111,8 +112,8 @@ public:
virtual void Shutdown() = 0; virtual void Shutdown() = 0;
// Returns size in bytes of encoded block of memory // Returns size in bytes of encoded block of memory
virtual size_t Encode(u8* dst, unsigned int dstFormat, virtual size_t Encode(u8* dst, unsigned int dstFormat,
PEControl::PixelFormat srcFormat, const EFBRectangle& srcRect, PEControl::PixelFormat srcFormat, const EFBRectangle& srcRect,
bool isIntensity, bool scaleByHalf) = 0; bool isIntensity, bool scaleByHalf) = 0;
}; };

12
Source/Core/VideoBackends/OGL/Render.cpp
View File

@ -1279,18 +1279,18 @@ void Renderer::SetBlendMode(bool forceUpdate)
// adjust alpha factors // adjust alpha factors
if (useDualSource) if (useDualSource)
{ {
srcidx = GX_BL_ONE; srcidx = BlendMode::ONE;
dstidx = GX_BL_ZERO; dstidx = BlendMode::ZERO;
} }
else else
{ {
// we can't use GL_DST_COLOR or GL_ONE_MINUS_DST_COLOR for source in alpha channel so use their alpha equivalent instead // we can't use GL_DST_COLOR or GL_ONE_MINUS_DST_COLOR for source in alpha channel so use their alpha equivalent instead
if (srcidx == GX_BL_DSTCLR) srcidx = GX_BL_DSTALPHA; if (srcidx == BlendMode::DSTCLR) srcidx = BlendMode::DSTALPHA;
if (srcidx == GX_BL_INVDSTCLR) srcidx = GX_BL_INVDSTALPHA; if (srcidx == BlendMode::INVDSTCLR) srcidx = BlendMode::INVDSTALPHA;
// we can't use GL_SRC_COLOR or GL_ONE_MINUS_SRC_COLOR for destination in alpha channel so use their alpha equivalent instead // we can't use GL_SRC_COLOR or GL_ONE_MINUS_SRC_COLOR for destination in alpha channel so use their alpha equivalent instead
if (dstidx == GX_BL_SRCCLR) dstidx = GX_BL_SRCALPHA; if (dstidx == BlendMode::SRCCLR) dstidx = BlendMode::SRCALPHA;
if (dstidx == GX_BL_INVSRCCLR) dstidx = GX_BL_INVSRCALPHA; if (dstidx == BlendMode::INVSRCCLR) dstidx = BlendMode::INVSRCALPHA;
} }
GLenum srcFactorAlpha = glSrcFactors[srcidx]; GLenum srcFactorAlpha = glSrcFactors[srcidx];
GLenum dstFactorAlpha = glDestFactors[dstidx]; GLenum dstFactorAlpha = glDestFactors[dstidx];

290
Source/Core/VideoBackends/Software/EfbInterface.cpp
View File

@ -225,81 +225,83 @@ namespace EfbInterface
return depth; return depth;
} }
u32 GetSourceFactor(u8 *srcClr, u8 *dstClr, int mode) u32 GetSourceFactor(u8 *srcClr, u8 *dstClr, BlendMode::BlendFactor mode)
{ {
switch (mode) { switch (mode)
case 0: // zero {
return 0; case BlendMode::ZERO:
case 1: // one return 0;
return 0xffffffff; case BlendMode::ONE:
case 2: // dstclr return 0xffffffff;
return *(u32*)dstClr; case BlendMode::DSTCLR:
case 3: // invdstclr return *(u32*)dstClr;
return 0xffffffff - *(u32*)dstClr; case BlendMode::INVDSTCLR:
case 4: // srcalpha return 0xffffffff - *(u32*)dstClr;
{ case BlendMode::SRCALPHA:
u8 alpha = srcClr[ALP_C]; {
u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha; u8 alpha = srcClr[ALP_C];
return factor; u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha;
} return factor;
case 5: // invsrcalpha }
{ case BlendMode::INVSRCALPHA:
u8 alpha = 0xff - srcClr[ALP_C]; {
u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha; u8 alpha = 0xff - srcClr[ALP_C];
return factor; u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha;
} return factor;
case 6: // dstalpha }
{ case BlendMode::DSTALPHA:
u8 alpha = dstClr[ALP_C]; {
u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha; u8 alpha = dstClr[ALP_C];
return factor; u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha;
} return factor;
case 7: // invdstalpha }
{ case BlendMode::INVDSTALPHA:
u8 alpha = 0xff - dstClr[ALP_C]; {
u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha; u8 alpha = 0xff - dstClr[ALP_C];
return factor; u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha;
} return factor;
}
} }
return 0; return 0;
} }
u32 GetDestinationFactor(u8 *srcClr, u8 *dstClr, int mode) u32 GetDestinationFactor(u8 *srcClr, u8 *dstClr, BlendMode::BlendFactor mode)
{ {
switch (mode) { switch (mode)
case 0: // zero {
return 0; case BlendMode::ZERO:
case 1: // one return 0;
return 0xffffffff; case BlendMode::ONE:
case 2: // srcclr return 0xffffffff;
return *(u32*)srcClr; case BlendMode::SRCCLR:
case 3: // invsrcclr return *(u32*)srcClr;
return 0xffffffff - *(u32*)srcClr; case BlendMode::INVSRCCLR:
case 4: // srcalpha return 0xffffffff - *(u32*)srcClr;
{ case BlendMode::SRCALPHA:
u8 alpha = srcClr[ALP_C]; {
u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha; u8 alpha = srcClr[ALP_C];
return factor; u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha;
} return factor;
case 5: // invsrcalpha }
{ case BlendMode::INVSRCALPHA:
u8 alpha = 0xff - srcClr[ALP_C]; {
u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha; u8 alpha = 0xff - srcClr[ALP_C];
return factor; u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha;
} return factor;
case 6: // dstalpha }
{ case BlendMode::DSTALPHA:
u8 alpha = dstClr[ALP_C] & 0xff; {
u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha; u8 alpha = dstClr[ALP_C] & 0xff;
return factor; u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha;
} return factor;
case 7: // invdstalpha }
{ case BlendMode::INVDSTALPHA:
u8 alpha = 0xff - dstClr[ALP_C]; {
u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha; u8 alpha = 0xff - dstClr[ALP_C];
return factor; u32 factor = alpha << 24 | alpha << 16 | alpha << 8 | alpha;
} return factor;
}
} }
return 0; return 0;
@ -327,58 +329,58 @@ namespace EfbInterface
} }
} }
void LogicBlend(u32 srcClr, u32 &dstClr, int op) void LogicBlend(u32 srcClr, u32 &dstClr, BlendMode::LogicOp op)
{ {
switch (op) switch (op)
{ {
case 0: // clear case BlendMode::CLEAR:
dstClr = 0; dstClr = 0;
break; break;
case 1: // and case BlendMode::AND:
dstClr = srcClr & dstClr; dstClr = srcClr & dstClr;
break; break;
case 2: // revand case BlendMode::AND_REVERSE:
dstClr = srcClr & (~dstClr); dstClr = srcClr & (~dstClr);
break; break;
case 3: // copy case BlendMode::COPY:
dstClr = srcClr; dstClr = srcClr;
break; break;
case 4: // invand case BlendMode::AND_INVERTED:
dstClr = (~srcClr) & dstClr; dstClr = (~srcClr) & dstClr;
break; break;
case 5: // noop case BlendMode::NOOP:
// Do nothing // Do nothing
break; break;
case 6: // xor case BlendMode::XOR:
dstClr = srcClr ^ dstClr; dstClr = srcClr ^ dstClr;
break; break;
case 7: // or case BlendMode::OR:
dstClr = srcClr | dstClr; dstClr = srcClr | dstClr;
break; break;
case 8: // nor case BlendMode::NOR:
dstClr = ~(srcClr | dstClr); dstClr = ~(srcClr | dstClr);
break; break;
case 9: // equiv case BlendMode::EQUIV:
dstClr = ~(srcClr ^ dstClr); dstClr = ~(srcClr ^ dstClr);
break; break;
case 10: // inv case BlendMode::INVERT:
dstClr = ~dstClr; dstClr = ~dstClr;
break; break;
case 11: // revor case BlendMode::OR_REVERSE:
dstClr = srcClr | (~dstClr); dstClr = srcClr | (~dstClr);
break; break;
case 12: // invcopy case BlendMode::COPY_INVERTED:
dstClr = ~srcClr; dstClr = ~srcClr;
break; break;
case 13: // invor case BlendMode::OR_INVERTED:
dstClr = (~srcClr) | dstClr; dstClr = (~srcClr) | dstClr;
break; break;
case 14: // nand case BlendMode::NAND:
dstClr = ~(srcClr & dstClr); dstClr = ~(srcClr & dstClr);
break; break;
case 15: // set case BlendMode::SET:
dstClr = 0xffffffff; dstClr = 0xffffffff;
break; break;
} }
} }
@ -584,33 +586,33 @@ namespace EfbInterface
switch (bpmem.zmode.func) switch (bpmem.zmode.func)
{ {
case COMPARE_NEVER: case ZMode::NEVER:
pass = false; pass = false;
break; break;
case COMPARE_LESS: case ZMode::LESS:
pass = z < depth; pass = z < depth;
break; break;
case COMPARE_EQUAL: case ZMode::EQUAL:
pass = z == depth; pass = z == depth;
break; break;
case COMPARE_LEQUAL: case ZMode::LEQUAL:
pass = z <= depth; pass = z <= depth;
break; break;
case COMPARE_GREATER: case ZMode::GREATER:
pass = z > depth; pass = z > depth;
break; break;
case COMPARE_NEQUAL: case ZMode::NEQUAL:
pass = z != depth; pass = z != depth;
break; break;
case COMPARE_GEQUAL: case ZMode::GEQUAL:
pass = z >= depth; pass = z >= depth;
break; break;
case COMPARE_ALWAYS: case ZMode::ALWAYS:
pass = true; pass = true;
break; break;
default: default:
pass = false; pass = false;
ERROR_LOG(VIDEO, "Bad Z compare mode %i", bpmem.zmode.func); ERROR_LOG(VIDEO, "Bad Z compare mode %i", (int)bpmem.zmode.func);
} }
if (pass && bpmem.zmode.updateenable) if (pass && bpmem.zmode.updateenable)

18
Source/Core/VideoBackends/Software/Tev.cpp
View File

@ -413,17 +413,17 @@ void Tev::DrawAlphaCompare(TevStageCombiner::AlphaCombiner &ac)
} }
} }
static bool AlphaCompare(int alpha, int ref, int comp) static bool AlphaCompare(int alpha, int ref, AlphaTest::CompareMode comp)
{ {
switch (comp) { switch (comp) {
case ALPHACMP_ALWAYS: return true; case AlphaTest::ALWAYS: return true;
case ALPHACMP_NEVER: return false; case AlphaTest::NEVER: return false;
case ALPHACMP_LEQUAL: return alpha <= ref; case AlphaTest::LEQUAL: return alpha <= ref;
case ALPHACMP_LESS: return alpha < ref; case AlphaTest::LESS: return alpha < ref;
case ALPHACMP_GEQUAL: return alpha >= ref; case AlphaTest::GEQUAL: return alpha >= ref;
case ALPHACMP_GREATER: return alpha > ref; case AlphaTest::GREATER: return alpha > ref;
case ALPHACMP_EQUAL: return alpha == ref; case AlphaTest::EQUAL: return alpha == ref;
case ALPHACMP_NEQUAL: return alpha != ref; case AlphaTest::NEQUAL: return alpha != ref;
} }
return true; return true;
} }

2
Source/Core/VideoCommon/BPMemory.cpp
View File

@ -292,7 +292,7 @@ void GetBPRegInfo(const u8* data, char* name, size_t name_size, char* desc, size
snprintf(desc, desc_size, "test 1: %s (ref: %#02x)\n" snprintf(desc, desc_size, "test 1: %s (ref: %#02x)\n"
"test 2: %s (ref: %#02x)\n" "test 2: %s (ref: %#02x)\n"
"logic: %s\n", "logic: %s\n",
functions[test.comp0], test.ref0, functions[test.comp1], test.ref1, logic[test.logic]); functions[test.comp0], (int)test.ref0, functions[test.comp1], (int)test.ref1, logic[test.logic]);
break; break;
} }

164
Source/Core/VideoCommon/BPMemory.h
View File

@ -149,27 +149,6 @@
#define GX_TEVREG1 2 #define GX_TEVREG1 2
#define GX_TEVREG2 3 #define GX_TEVREG2 3
#define ALPHACMP_NEVER 0
#define ALPHACMP_LESS 1
#define ALPHACMP_EQUAL 2
#define ALPHACMP_LEQUAL 3
#define ALPHACMP_GREATER 4
#define ALPHACMP_NEQUAL 5
#define ALPHACMP_GEQUAL 6
#define ALPHACMP_ALWAYS 7
enum Compare
{
COMPARE_NEVER = 0,
COMPARE_LESS,
COMPARE_EQUAL,
COMPARE_LEQUAL,
COMPARE_GREATER,
COMPARE_NEQUAL,
COMPARE_GEQUAL,
COMPARE_ALWAYS
};
#define ZTEXTURE_DISABLE 0 #define ZTEXTURE_DISABLE 0
#define ZTEXTURE_ADD 1 #define ZTEXTURE_ADD 1
#define ZTEXTURE_REPLACE 2 #define ZTEXTURE_REPLACE 2
@ -179,14 +158,6 @@ enum Compare
#define TevBias_SUBHALF 2 #define TevBias_SUBHALF 2
#define TevBias_COMPARE 3 #define TevBias_COMPARE 3
enum AlphaOp
{
ALPHAOP_AND = 0,
ALPHAOP_OR,
ALPHAOP_XOR,
ALPHAOP_XNOR,
};
union IND_MTXA union IND_MTXA
{ {
struct struct
@ -610,31 +581,52 @@ union X10Y10
// Framebuffer/pixel stuff (incl fog) // Framebuffer/pixel stuff (incl fog)
#define GX_BL_ZERO 0
#define GX_BL_ONE 1
#define GX_BL_SRCCLR 2 // for dst factor
#define GX_BL_INVSRCCLR 3 // for dst factor
#define GX_BL_SRCALPHA 4
#define GX_BL_INVSRCALPHA 5
#define GX_BL_DSTALPHA 6
#define GX_BL_INVDSTALPHA 7
#define GX_BL_DSTCLR GX_BL_SRCCLR // for src factor
#define GX_BL_INVDSTCLR GX_BL_INVSRCCLR // for src factor
union BlendMode union BlendMode
{ {
struct enum BlendFactor : u32
{ {
u32 blendenable : 1; ZERO = 0,
u32 logicopenable : 1; ONE = 1,
u32 dither : 1; SRCCLR = 2, // for dst factor
u32 colorupdate : 1; INVSRCCLR = 3, // for dst factor
u32 alphaupdate : 1; DSTCLR = SRCCLR, // for src factor
u32 dstfactor : 3; //BLEND_ONE, BLEND_INV_SRc etc INVDSTCLR = INVSRCCLR, // for src factor
u32 srcfactor : 3; SRCALPHA = 4,
u32 subtract : 1; INVSRCALPHA = 5,
u32 logicmode : 4; DSTALPHA = 6,
INVDSTALPHA = 7
}; };
enum LogicOp : u32
{
CLEAR = 0,
AND = 1,
AND_REVERSE = 2,
COPY = 3,
AND_INVERTED = 4,
NOOP = 5,
XOR = 6,
OR = 7,
NOR = 8,
EQUIV = 9,
INVERT = 10,
OR_REVERSE = 11,
COPY_INVERTED = 12,
OR_INVERTED = 13,
NAND = 14,
SET = 15
};
BitField< 0,1,u32> blendenable;
BitField< 1,1,u32> logicopenable;
BitField< 2,1,u32> dither;
BitField< 3,1,u32> colorupdate;
BitField< 4,1,u32> alphaupdate;
BitField< 5,3,BlendFactor> dstfactor;
BitField< 8,3,BlendFactor> srcfactor;
BitField<11,1,u32> subtract;
BitField<12,4,LogicOp> logicmode;
u32 hex; u32 hex;
}; };
@ -734,12 +726,22 @@ struct FogParams
union ZMode union ZMode
{ {
struct enum CompareMode : u32
{ {
u32 testenable : 1; NEVER = 0,
u32 func : 3; LESS = 1,
u32 updateenable : 1; //size? EQUAL = 2,
LEQUAL = 3,
GREATER = 4,
NEQUAL = 5,
GEQUAL = 6,
ALWAYS = 7
}; };
BitField<0,1,u32> testenable;
BitField<1,3,CompareMode> func;
BitField<4,1,u32> updateenable;
u32 hex; u32 hex;
}; };
@ -870,14 +872,32 @@ union TevKSel
union AlphaTest union AlphaTest
{ {
struct enum CompareMode : u32
{ {
u32 ref0 : 8; NEVER = 0,
u32 ref1 : 8; LESS = 1,
u32 comp0 : 3; EQUAL = 2,
u32 comp1 : 3; LEQUAL = 3,
u32 logic : 2; GREATER = 4,
NEQUAL = 5,
GEQUAL = 6,
ALWAYS = 7
}; };
enum Op
{
AND = 0,
OR = 1,
XOR = 2,
XNOR = 3
};
BitField< 0,8, u32> ref0;
BitField< 8,8, u32> ref1;
BitField<16,3, CompareMode> comp0;
BitField<19,3, CompareMode> comp1;
BitField<22,2, Op> logic;
u32 hex; u32 hex;
enum TEST_RESULT enum TEST_RESULT
@ -891,31 +911,31 @@ union AlphaTest
{ {
switch (logic) switch (logic)
{ {
case 0: // AND case AND:
if (comp0 == ALPHACMP_ALWAYS && comp1 == ALPHACMP_ALWAYS) if (comp0 == ALWAYS && comp1 == ALWAYS)
return PASS; return PASS;
if (comp0 == ALPHACMP_NEVER || comp1 == ALPHACMP_NEVER) if (comp0 == NEVER || comp1 == NEVER)
return FAIL; return FAIL;
break; break;
case 1: // OR case OR:
if (comp0 == ALPHACMP_ALWAYS || comp1 == ALPHACMP_ALWAYS) if (comp0 == ALWAYS || comp1 == ALWAYS)
return PASS; return PASS;
if (comp0 == ALPHACMP_NEVER && comp1 == ALPHACMP_NEVER) if (comp0 == NEVER && comp1 == NEVER)
return FAIL; return FAIL;
break; break;
case 2: // XOR case XOR:
if ((comp0 == ALPHACMP_ALWAYS && comp1 == ALPHACMP_NEVER) || (comp0 == ALPHACMP_NEVER && comp1 == ALPHACMP_ALWAYS)) if ((comp0 == ALWAYS && comp1 == NEVER) || (comp0 == NEVER && comp1 == ALWAYS))
return PASS; return PASS;
if ((comp0 == ALPHACMP_ALWAYS && comp1 == ALPHACMP_ALWAYS) || (comp0 == ALPHACMP_NEVER && comp1 == ALPHACMP_NEVER)) if ((comp0 == ALWAYS && comp1 == ALWAYS) || (comp0 == NEVER && comp1 == NEVER))
return FAIL; return FAIL;
break; break;
case 3: // XNOR case XNOR:
if ((comp0 == ALPHACMP_ALWAYS && comp1 == ALPHACMP_NEVER) || (comp0 == ALPHACMP_NEVER && comp1 == ALPHACMP_ALWAYS)) if ((comp0 == ALWAYS && comp1 == NEVER) || (comp0 == NEVER && comp1 == ALWAYS))
return FAIL; return FAIL;
if ((comp0 == ALPHACMP_ALWAYS && comp1 == ALPHACMP_ALWAYS) || (comp0 == ALPHACMP_NEVER && comp1 == ALPHACMP_NEVER)) if ((comp0 == ALWAYS && comp1 == ALWAYS) || (comp0 == NEVER && comp1 == NEVER))
return PASS; return PASS;
break; break;
} }

15
Source/Core/VideoCommon/BPStructs.cpp
View File

@ -133,8 +133,8 @@ void BPWritten(const BPCmd& bp)
SetLineWidth(); SetLineWidth();
break; break;
case BPMEM_ZMODE: // Depth Control case BPMEM_ZMODE: // Depth Control
PRIM_LOG("zmode: test=%d, func=%d, upd=%d", bpmem.zmode.testenable, bpmem.zmode.func, PRIM_LOG("zmode: test=%d, func=%d, upd=%d", (int)bpmem.zmode.testenable,
bpmem.zmode.updateenable); (int)bpmem.zmode.func, (int)bpmem.zmode.updateenable);
SetDepthMode(); SetDepthMode();
break; break;
case BPMEM_BLENDMODE: // Blending Control case BPMEM_BLENDMODE: // Blending Control
@ -142,8 +142,9 @@ void BPWritten(const BPCmd& bp)
if (bp.changes & 0xFFFF) if (bp.changes & 0xFFFF)
{ {
PRIM_LOG("blendmode: en=%d, open=%d, colupd=%d, alphaupd=%d, dst=%d, src=%d, sub=%d, mode=%d", 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, (int)bpmem.blendmode.blendenable, (int)bpmem.blendmode.logicopenable, (int)bpmem.blendmode.colorupdate,
bpmem.blendmode.dstfactor, bpmem.blendmode.srcfactor, bpmem.blendmode.subtract, bpmem.blendmode.logicmode); (int)bpmem.blendmode.alphaupdate, (int)bpmem.blendmode.dstfactor, (int)bpmem.blendmode.srcfactor,
(int)bpmem.blendmode.subtract, (int)bpmem.blendmode.logicmode);
// Set LogicOp Blending Mode // Set LogicOp Blending Mode
if (bp.changes & 0xF002) // logicopenable | logicmode if (bp.changes & 0xF002) // logicopenable | logicmode
@ -304,8 +305,10 @@ void BPWritten(const BPCmd& bp)
PixelShaderManager::SetFogColorChanged(); PixelShaderManager::SetFogColorChanged();
break; break;
case BPMEM_ALPHACOMPARE: // Compare Alpha Values case BPMEM_ALPHACOMPARE: // Compare Alpha Values
PRIM_LOG("alphacmp: ref0=%d, ref1=%d, comp0=%d, comp1=%d, logic=%d", bpmem.alpha_test.ref0, PRIM_LOG("alphacmp: ref0=%d, ref1=%d, comp0=%d, comp1=%d, logic=%d",
bpmem.alpha_test.ref1, bpmem.alpha_test.comp0, bpmem.alpha_test.comp1, bpmem.alpha_test.logic); (int)bpmem.alpha_test.ref0, (int)bpmem.alpha_test.ref1,
(int)bpmem.alpha_test.comp0, (int)bpmem.alpha_test.comp1,
(int)bpmem.alpha_test.logic);
if (bp.changes & 0xFFFF) if (bp.changes & 0xFFFF)
PixelShaderManager::SetAlpha(); PixelShaderManager::SetAlpha();
if (bp.changes) if (bp.changes)