[mupen64plus-pandora.git] / source / gles2rice / src / Blender.cpp

/*
Copyright (C) 2003 Rice1964

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 (at your option) 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.
*/

#include "Render.h"

const char * sc_szBlClr[4]      = { "In", "Mem", "Bl", "Fog" };
const char * sc_szBlA1[4]       = { "AIn", "AFog", "AShade", "0" };
const char * sc_szBlA2[4]       = { "1-A", "AMem", "1", "0" };

//========================================================================
void CBlender::InitBlenderMode(void)                    // Set Alpha Blender mode
{
    //1. Z_COMPARE        -- Enable / Disable Zbuffer compare
    //  1   -   Enable ZBuffer
    //  0   -   Disable ZBuffer

    //2. Z_UPDATE        -- Enable / Disable Zbuffer update
    //  1   -   Enable ZBuffer writeable
    //  0   -   Zbuffer not writeable

    //3. AA_EN and IM_RD        -- Anti-Alias
    //  AA_EN           -   Enable anti-aliase
    //  AA_EN | IM_RD   -   Reduced anti-aliase
    //  IM_RD           -   ??
    //  -               -   Disable anti-aliase

    //4.  ZMode       
    //  #define ZMODE_OPA   0           -- Usually used with Z_COMPARE and Z_UPDATE
    //                                             or used without neither Z_COMPARE or Z_UPDATE
    //                                             if used with Z_COMPARE and Z_UPDATE, then this is
    //                                             the regular ZBuffer mode, with compare and update
    //  #define ZMODE_INTER 0x400
    //  #define ZMODE_XLU   0x800       -- Usually used with Z_COMPARE, but not with Z_UPDATE
    //                                             Do only compare, no zbuffer update.
    //                                             Not output if the z value is the same
    //  #define ZMODE_DEC   0xc00       -- Usually used with Z_COMPARE, but not with Z_UPDATE
    //                                             Do only compare, no update, but because this is
    //                                             decal mode, so image should be updated even
    //                                             the z value is the same as compared.

    CRender *render = CRender::g_pRender;

    //  Alpha Blender Modes 

    /*
6. FORCE_BL     - Alpha blending at blender stage
    1   -   Enable alpha blending at blender
    0   -   Disable alpha blending at blender

    Alpha blending at blender is usually used to render XLU surface
    if enabled, then use the blending setting of C1 and C2

7. ALPHA_CVG_SEL    - Output full alpha from the color combiner, usually not used together
                      with FORCE_BL. If it is used together with FORCE_BL, then ignore this

8. CVG_X_ALPHA      - Before output the color from color combiner, mod it with alpha

9. TEX_EDGE         - Ignore this

10.CLR_ON_CVG       - Used with XLU surfaces, ignore it

11.CVG_DST
#define CVG_DST_CLAMP   0           -   Usually used with OPA surface
#define CVG_DST_WRAP    0x100       -   Usually used with XLU surface or OPA line
#define CVG_DST_FULL    0x200       -   ?
#define CVG_DST_SAVE    0x300       -   ?


Possible Blending Inputs:

    In  -   Input from color combiner
    Mem -   Input from current frame buffer
    Fog -   Fog generator
    BL  -   Blender

Possible Blending Factors:
    A-IN    -   Alpha from color combiner
    A-MEM   -   Alpha from current frame buffer
    (1-A)   -   
    A-FOG   -   Alpha of fog color
    A-SHADE -   Alpha of shade
    1   -   1
    0   -   0
*/
#define BLEND_NOOP              0x0000

#define BLEND_NOOP5             0xcc48  // Fog * 0 + Mem * 1
#define BLEND_NOOP4             0xcc08  // Fog * 0 + In * 1
#define BLEND_FOG_ASHADE        0xc800
#define BLEND_FOG_3             0xc000  // Fog * AIn + In * 1-A
#define BLEND_FOG_MEM           0xc440  // Fog * AFog + Mem * 1-A
#define BLEND_FOG_APRIM         0xc400  // Fog * AFog + In * 1-A

#define BLEND_BLENDCOLOR        0x8c88
#define BLEND_BI_AFOG           0x8400  // Bl * AFog + In * 1-A
#define BLEND_BI_AIN            0x8040  // Bl * AIn + Mem * 1-A

#define BLEND_MEM               0x4c40  // Mem*0 + Mem*(1-0)?!
#define BLEND_FOG_MEM_3         0x44c0  // Mem * AFog + Fog * 1-A

#define BLEND_NOOP3             0x0c48  // In * 0 + Mem * 1
#define BLEND_PASS              0x0c08  // In * 0 + In * 1
#define BLEND_FOG_MEM_IN_MEM    0x0440  // In * AFog + Mem * 1-A
#define BLEND_FOG_MEM_FOG_MEM   0x04c0  // In * AFog + Fog * 1-A
#define BLEND_OPA               0x0044  //  In * AIn + Mem * AMem
#define BLEND_XLU               0x0040
#define BLEND_MEM_ALPHA_IN      0x4044  //  Mem * AIn + Mem * AMem


    uint32 blendmode_1 = (uint32)( gRDP.otherMode.blender & 0xcccc );
    uint32 blendmode_2 = (uint32)( gRDP.otherMode.blender & 0x3333 );
    uint32 cycletype = gRDP.otherMode.cycle_type;

    switch( cycletype )
    {
    case CYCLE_TYPE_FILL:
        //BlendFunc(BLEND_ONE, BLEND_ZERO);
        //Enable();
        Disable();
        break;
    case CYCLE_TYPE_COPY:
        //Disable();
        BlendFunc(BLEND_ONE, BLEND_ZERO);
        Enable();
        break;
    case CYCLE_TYPE_2:
        if( gRDP.otherMode.force_bl && gRDP.otherMode.z_cmp )
        {
            BlendFunc(BLEND_SRCALPHA, BLEND_INVSRCALPHA);
            Enable();
            break;
        }

        /*
        if( gRDP.otherMode.alpha_cvg_sel && gRDP.otherMode.cvg_x_alpha==0 )
        {
            BlendFunc(BLEND_ONE, BLEND_ZERO);
            Enable();
            break;
        }
        */

        switch( blendmode_1+blendmode_2 )
        {
        case BLEND_PASS+(BLEND_PASS>>2):    // In * 0 + In * 1
        case BLEND_FOG_APRIM+(BLEND_PASS>>2):
            BlendFunc(BLEND_ONE, BLEND_ZERO);
            if( gRDP.otherMode.alpha_cvg_sel )
            {
                Enable();
            }
            else
            {
                Disable();
            }

            render->SetAlphaTestEnable( ((gRDP.otherModeL >> RSP_SETOTHERMODE_SHIFT_ALPHACOMPARE) & 0x3)==1 ? TRUE : FALSE);
            break;
        case BLEND_PASS+(BLEND_OPA>>2):
            // 0x0c19
            // Cycle1:  In * 0 + In * 1
            // Cycle2:  In * AIn + Mem * AMem
            if( gRDP.otherMode.cvg_x_alpha && gRDP.otherMode.alpha_cvg_sel )
            {
                BlendFunc(BLEND_SRCALPHA, BLEND_INVSRCALPHA);
                Enable();
            }
            else
            {
                BlendFunc(BLEND_ONE, BLEND_ZERO);
                Enable();
            }
            break;
        case BLEND_PASS + (BLEND_XLU>>2):
            // 0x0c18
            // Cycle1:  In * 0 + In * 1
            // Cycle2:  In * AIn + Mem * 1-A
        case BLEND_FOG_ASHADE + (BLEND_XLU>>2):
            //Cycle1:   Fog * AShade + In * 1-A
            //Cycle2:   In * AIn + Mem * 1-A    
        case BLEND_FOG_APRIM + (BLEND_XLU>>2):
            //Cycle1:   Fog * AFog + In * 1-A
            //Cycle2:   In * AIn + Mem * 1-A    
        //case BLEND_FOG_MEM_FOG_MEM + (BLEND_OPA>>2):
            //Cycle1:   In * AFog + Fog * 1-A
            //Cycle2:   In * AIn + Mem * AMem   
        case BLEND_FOG_MEM_FOG_MEM + (BLEND_PASS>>2):
            //Cycle1:   In * AFog + Fog * 1-A
            //Cycle2:   In * 0 + In * 1
        case BLEND_XLU + (BLEND_XLU>>2):
            //Cycle1:   Fog * AFog + In * 1-A
            //Cycle2:   In * AIn + Mem * 1-A    
        case BLEND_BI_AFOG + (BLEND_XLU>>2):
            //Cycle1:   Bl * AFog + In * 1-A
            //Cycle2:   In * AIn + Mem * 1-A    
        case BLEND_XLU + (BLEND_FOG_MEM_IN_MEM>>2):
            //Cycle1:   In * AIn + Mem * 1-A
            //Cycle2:   In * AFog + Mem * 1-A   
        case BLEND_PASS + (BLEND_FOG_MEM_IN_MEM>>2):
            //Cycle1:   In * 0 + In * 1
            //Cycle2:   In * AFog + Mem * 1-A   
            BlendFunc(BLEND_SRCALPHA, BLEND_INVSRCALPHA);
            Enable();
            break;
        case BLEND_FOG_MEM_FOG_MEM + (BLEND_OPA>>2):
            //Cycle1:   In * AFog + Fog * 1-A
            //Cycle2:   In * AIn + Mem * AMem   
            BlendFunc(BLEND_ONE, BLEND_ZERO);
            Enable();
            break;

        case BLEND_FOG_APRIM + (BLEND_OPA>>2):
            // For Golden Eye
            //Cycle1:   Fog * AFog + In * 1-A
            //Cycle2:   In * AIn + Mem * AMem   
        case BLEND_FOG_ASHADE + (BLEND_OPA>>2):
            //Cycle1:   Fog * AShade + In * 1-A
            //Cycle2:   In * AIn + Mem * AMem   
        case BLEND_BI_AFOG + (BLEND_OPA>>2):
            //Cycle1:   Bl * AFog + In * 1-A
            //Cycle2:   In * AIn + Mem * 1-AMem 
        case BLEND_FOG_ASHADE + (BLEND_NOOP>>2):
            //Cycle1:   Fog * AShade + In * 1-A
            //Cycle2:   In * AIn + In * 1-A
        case BLEND_NOOP + (BLEND_OPA>>2):
            //Cycle1:   In * AIn + In * 1-A
            //Cycle2:   In * AIn + Mem * AMem
        case BLEND_NOOP4 + (BLEND_NOOP>>2):
            //Cycle1:   Fog * AIn + In * 1-A
            //Cycle2:   In * 0 + In * 1
        case BLEND_FOG_ASHADE+(BLEND_PASS>>2):
            //Cycle1:   Fog * AShade + In * 1-A
            //Cycle2:   In * 0 + In * 1
        case BLEND_FOG_3+(BLEND_PASS>>2):
            BlendFunc(BLEND_ONE, BLEND_ZERO);
            Enable();
            break;
        case BLEND_FOG_ASHADE+0x0301:
            // c800 - Cycle1:   Fog * AShade + In * 1-A
            // 0301 - Cycle2:   In * 0 + In * AMem
            BlendFunc(BLEND_SRCALPHA, BLEND_ZERO);
            Enable();
            break;
        case 0x0c08+0x1111:
            // 0c08 - Cycle1:   In * 0 + In * 1
            // 1111 - Cycle2:   Mem * AFog + Mem * AMem
            BlendFunc(BLEND_ZERO, BLEND_DESTALPHA);
            Enable();
            break;
        default:
#ifdef DEBUGGER
            if( pauseAtNext )
            {
                uint32 dwM1A_1 = (gRDP.otherMode.blender>>14) & 0x3;
                uint32 dwM1B_1 = (gRDP.otherMode.blender>>10) & 0x3;
                uint32 dwM2A_1 = (gRDP.otherMode.blender>>6) & 0x3;
                uint32 dwM2B_1 = (gRDP.otherMode.blender>>2) & 0x3;

                uint32 dwM1A_2 = (gRDP.otherMode.blender>>12) & 0x3;
                uint32 dwM1B_2 = (gRDP.otherMode.blender>>8) & 0x3;
                uint32 dwM2A_2 = (gRDP.otherMode.blender>>4) & 0x3;
                uint32 dwM2B_2 = (gRDP.otherMode.blender   ) & 0x3;

                TRACE0("Unknown Blender Mode: 2 cycle");
                DebuggerAppendMsg( "\tblender:\t\t%04x - Cycle1:\t%s * %s + %s * %s\n\t\t%04x - Cycle2:\t%s * %s + %s * %s", blendmode_1,
                    sc_szBlClr[dwM1A_1], sc_szBlA1[dwM1B_1], sc_szBlClr[dwM2A_1], sc_szBlA2[dwM2B_1], blendmode_2,
                    sc_szBlClr[dwM1A_2], sc_szBlA1[dwM1B_2], sc_szBlClr[dwM2A_2], sc_szBlA2[dwM2B_2]);

            }
#endif
            if( blendmode_2 == (BLEND_PASS>>2) )
            {
                BlendFunc(BLEND_ONE, BLEND_ZERO);
            }
            else
            {
                BlendFunc(BLEND_SRCALPHA, BLEND_INVSRCALPHA);
            }
            Enable();
            break;
        }
        break;
    default:    // 1/2 Cycle or Copy
        if( gRDP.otherMode.force_bl && gRDP.otherMode.z_cmp && blendmode_1 != BLEND_FOG_ASHADE )
        {
            BlendFunc(BLEND_SRCALPHA, BLEND_INVSRCALPHA);
            Enable();
            break;
        }
        if( gRDP.otherMode.force_bl && options.enableHackForGames == HACK_FOR_COMMANDCONQUER )
        {
            BlendFunc(BLEND_SRCALPHA, BLEND_INVSRCALPHA);
            Enable();
            break;
        }

#ifdef DEBUGGER
        //if( (blendmode_1>>2) != blendmode_2 )
        //{
        //  DebuggerAppendMsg("Warning: in 1 cycle mode, blend1!=blend2");
        //}
#endif

        switch ( blendmode_1 )
        //switch ( blendmode_2<<2 )
        {
        case BLEND_XLU: // IN * A_IN + MEM * (1-A_IN)
        case BLEND_BI_AIN:  // Bl * AIn + Mem * 1-A
        case BLEND_FOG_MEM: // c440 - Cycle1:   Fog * AFog + Mem * 1-A
        case BLEND_FOG_MEM_IN_MEM:  // c440 - Cycle1:   In * AFog + Mem * 1-A
        case BLEND_BLENDCOLOR:  //Bl * 0 + Bl * 1
        case 0x00c0:    //In * AIn + Fog * 1-A
            BlendFunc(BLEND_SRCALPHA, BLEND_INVSRCALPHA);
            Enable();
            break;
        case BLEND_MEM_ALPHA_IN:    //  Mem * AIn + Mem * AMem
            BlendFunc(BLEND_ZERO, BLEND_DESTALPHA);
            Enable();
            break;
        case BLEND_PASS:    // IN * 0 + IN * 1
            BlendFunc(BLEND_ONE, BLEND_ZERO);
            if( gRDP.otherMode.alpha_cvg_sel )
            {
                Enable();
            }
            else
            {
                Disable();
            }
            break;
        case BLEND_OPA:     // IN * A_IN + MEM * A_MEM
            if( options.enableHackForGames == HACK_FOR_MARIO_TENNIS )
            {
                BlendFunc(BLEND_SRCALPHA, BLEND_INVSRCALPHA);
            }
            else
            {
                BlendFunc(BLEND_ONE, BLEND_ZERO);
            }
            Enable();
            break;
        case BLEND_NOOP:        // IN * A_IN + IN * (1 - A_IN)
        case BLEND_FOG_ASHADE:  // Fog * AShade + In * 1-A
        case BLEND_FOG_MEM_3:   // Mem * AFog + Fog * 1-A
        case BLEND_BI_AFOG:     // Bl * AFog + In * 1-A
            BlendFunc(BLEND_ONE, BLEND_ZERO);
            Enable();
            break;
        case BLEND_FOG_APRIM:   // Fog * AFog + In * 1-A
            BlendFunc(BLEND_INVSRCALPHA, BLEND_ZERO);
            Enable();
            break;
        case BLEND_NOOP3:       // In * 0 + Mem * 1
        case BLEND_NOOP5:       // Fog * 0 + Mem * 1
            BlendFunc(BLEND_ZERO, BLEND_ONE);
            Enable();
            break;
        case BLEND_MEM:     // Mem * 0 + Mem * 1-A
            // WaveRace
            BlendFunc(BLEND_ZERO, BLEND_ONE);
            Enable();
            break;
        default:
#ifdef DEBUGGER
            if( pauseAtNext )
            {
                uint32 dwM1A_1 = (gRDP.otherMode.blender>>14) & 0x3;
                uint32 dwM1B_1 = (gRDP.otherMode.blender>>10) & 0x3;
                uint32 dwM2A_1 = (gRDP.otherMode.blender>>6) & 0x3;
                uint32 dwM2B_1 = (gRDP.otherMode.blender>>2) & 0x3;

                uint32 dwM1A_2 = (gRDP.otherMode.blender>>12) & 0x3;
                uint32 dwM1B_2 = (gRDP.otherMode.blender>>8) & 0x3;
                uint32 dwM2A_2 = (gRDP.otherMode.blender>>4) & 0x3;
                uint32 dwM2B_2 = (gRDP.otherMode.blender   ) & 0x3;

                TRACE0("Unknown Blender Mode: 1 cycle");
                DebuggerAppendMsg( "\tblender:\t\t%04x - Cycle1:\t%s * %s + %s * %s\n\t\t\tCycle2:\t%s * %s + %s * %s", blendmode_1,
                    sc_szBlClr[dwM1A_1], sc_szBlA1[dwM1B_1], sc_szBlClr[dwM2A_1], sc_szBlA2[dwM2B_1],
                    sc_szBlClr[dwM1A_2], sc_szBlA1[dwM1B_2], sc_szBlClr[dwM2A_2], sc_szBlA2[dwM2B_2]);
            }
#endif
            BlendFunc(BLEND_SRCALPHA, BLEND_INVSRCALPHA);
            Enable();
            render->SetAlphaTestEnable(TRUE);
            break;
        }
    }
}
Commit	Line	Data
292f9317	1	/*
	2	Copyright (C) 2003 Rice1964
	3
	4	This program is free software; you can redistribute it and/or
	5	modify it under the terms of the GNU General Public License
	6	as published by the Free Software Foundation; either version 2
	7	of the License, or (at your option) any later version.
	8
	9	This program is distributed in the hope that it will be useful,
	10	but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	GNU General Public License for more details.
	13
	14	You should have received a copy of the GNU General Public License
	15	along with this program; if not, write to the Free Software
	16	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	17	*/
	18
	19	#include "Render.h"
	20
	21	const char * sc_szBlClr[4] = { "In", "Mem", "Bl", "Fog" };
	22	const char * sc_szBlA1[4] = { "AIn", "AFog", "AShade", "0" };
	23	const char * sc_szBlA2[4] = { "1-A", "AMem", "1", "0" };
	24
	25	//========================================================================
	26	void CBlender::InitBlenderMode(void) // Set Alpha Blender mode
	27	{
	28	//1. Z_COMPARE -- Enable / Disable Zbuffer compare
	29	// 1 - Enable ZBuffer
	30	// 0 - Disable ZBuffer
	31
	32	//2. Z_UPDATE -- Enable / Disable Zbuffer update
	33	// 1 - Enable ZBuffer writeable
	34	// 0 - Zbuffer not writeable
	35
	36	//3. AA_EN and IM_RD -- Anti-Alias
	37	// AA_EN - Enable anti-aliase
	38	// AA_EN \| IM_RD - Reduced anti-aliase
	39	// IM_RD - ??
	40	// - - Disable anti-aliase
	41
	42	//4. ZMode
	43	// #define ZMODE_OPA 0 -- Usually used with Z_COMPARE and Z_UPDATE
	44	// or used without neither Z_COMPARE or Z_UPDATE
	45	// if used with Z_COMPARE and Z_UPDATE, then this is
	46	// the regular ZBuffer mode, with compare and update
	47	// #define ZMODE_INTER 0x400
	48	// #define ZMODE_XLU 0x800 -- Usually used with Z_COMPARE, but not with Z_UPDATE
	49	// Do only compare, no zbuffer update.
	50	// Not output if the z value is the same
	51	// #define ZMODE_DEC 0xc00 -- Usually used with Z_COMPARE, but not with Z_UPDATE
	52	// Do only compare, no update, but because this is
	53	// decal mode, so image should be updated even
	54	// the z value is the same as compared.
	55
	56	CRender *render = CRender::g_pRender;
	57
	58	// Alpha Blender Modes
	59
	60	/*
	61	6. FORCE_BL - Alpha blending at blender stage
	62	1 - Enable alpha blending at blender
	63	0 - Disable alpha blending at blender
	64
65	Alpha blending at blender is usually used to render XLU surface
66	if enabled, then use the blending setting of C1 and C2
67
68	7. ALPHA_CVG_SEL - Output full alpha from the color combiner, usually not used together
69	with FORCE_BL. If it is used together with FORCE_BL, then ignore this
70
71	8. CVG_X_ALPHA - Before output the color from color combiner, mod it with alpha
72
73	9. TEX_EDGE - Ignore this
74
75	10.CLR_ON_CVG - Used with XLU surfaces, ignore it
76
77	11.CVG_DST
78	#define CVG_DST_CLAMP 0 - Usually used with OPA surface
79	#define CVG_DST_WRAP 0x100 - Usually used with XLU surface or OPA line
80	#define CVG_DST_FULL 0x200 - ?
81	#define CVG_DST_SAVE 0x300 - ?
82
83
84	Possible Blending Inputs:
85
86	In - Input from color combiner
87	Mem - Input from current frame buffer
88	Fog - Fog generator
89	BL - Blender
90
91	Possible Blending Factors:
92	A-IN - Alpha from color combiner
93	A-MEM - Alpha from current frame buffer
94	(1-A) -
95	A-FOG - Alpha of fog color
96	A-SHADE - Alpha of shade
97	1 - 1
98	0 - 0
99	*/
100	#define BLEND_NOOP 0x0000
101
102	#define BLEND_NOOP5 0xcc48 // Fog * 0 + Mem * 1
103	#define BLEND_NOOP4 0xcc08 // Fog * 0 + In * 1
104	#define BLEND_FOG_ASHADE 0xc800
105	#define BLEND_FOG_3 0xc000 // Fog * AIn + In * 1-A
106	#define BLEND_FOG_MEM 0xc440 // Fog * AFog + Mem * 1-A
107	#define BLEND_FOG_APRIM 0xc400 // Fog * AFog + In * 1-A
108
109	#define BLEND_BLENDCOLOR 0x8c88
110	#define BLEND_BI_AFOG 0x8400 // Bl * AFog + In * 1-A
111	#define BLEND_BI_AIN 0x8040 // Bl * AIn + Mem * 1-A
112
113	#define BLEND_MEM 0x4c40 // Mem0 + Mem(1-0)?!
114	#define BLEND_FOG_MEM_3 0x44c0 // Mem * AFog + Fog * 1-A
115
116	#define BLEND_NOOP3 0x0c48 // In * 0 + Mem * 1
117	#define BLEND_PASS 0x0c08 // In * 0 + In * 1
118	#define BLEND_FOG_MEM_IN_MEM 0x0440 // In * AFog + Mem * 1-A
119	#define BLEND_FOG_MEM_FOG_MEM 0x04c0 // In * AFog + Fog * 1-A
120	#define BLEND_OPA 0x0044 // In * AIn + Mem * AMem
121	#define BLEND_XLU 0x0040
122	#define BLEND_MEM_ALPHA_IN 0x4044 // Mem * AIn + Mem * AMem
123
124
125	uint32 blendmode_1 = (uint32)( gRDP.otherMode.blender & 0xcccc );
126	uint32 blendmode_2 = (uint32)( gRDP.otherMode.blender & 0x3333 );
127	uint32 cycletype = gRDP.otherMode.cycle_type;
128
129	switch( cycletype )
130	{
131	case CYCLE_TYPE_FILL:
132	//BlendFunc(BLEND_ONE, BLEND_ZERO);
133	//Enable();
134	Disable();
135	break;
136	case CYCLE_TYPE_COPY:
137	//Disable();
138	BlendFunc(BLEND_ONE, BLEND_ZERO);
139	Enable();
140	break;
141	case CYCLE_TYPE_2:
142	if( gRDP.otherMode.force_bl && gRDP.otherMode.z_cmp )
143	{
144	BlendFunc(BLEND_SRCALPHA, BLEND_INVSRCALPHA);
145	Enable();
146	break;
147	}
148
149	/*
150	if( gRDP.otherMode.alpha_cvg_sel && gRDP.otherMode.cvg_x_alpha==0 )
151	{
152	BlendFunc(BLEND_ONE, BLEND_ZERO);
153	Enable();
154	break;
155	}
156	*/
157
158	switch( blendmode_1+blendmode_2 )
159	{
160	case BLEND_PASS+(BLEND_PASS>>2): // In * 0 + In * 1
161	case BLEND_FOG_APRIM+(BLEND_PASS>>2):
162	BlendFunc(BLEND_ONE, BLEND_ZERO);
163	if( gRDP.otherMode.alpha_cvg_sel )
164	{
165	Enable();
166	}
167	else
168	{
169	Disable();
170	}
171
172	render->SetAlphaTestEnable( ((gRDP.otherModeL >> RSP_SETOTHERMODE_SHIFT_ALPHACOMPARE) & 0x3)==1 ? TRUE : FALSE);
173	break;
174	case BLEND_PASS+(BLEND_OPA>>2):
175	// 0x0c19
176	// Cycle1: In * 0 + In * 1
177	// Cycle2: In * AIn + Mem * AMem
178	if( gRDP.otherMode.cvg_x_alpha && gRDP.otherMode.alpha_cvg_sel )
179	{
180	BlendFunc(BLEND_SRCALPHA, BLEND_INVSRCALPHA);
181	Enable();
182	}
183	else
184	{
185	BlendFunc(BLEND_ONE, BLEND_ZERO);
186	Enable();
187	}
188	break;
189	case BLEND_PASS + (BLEND_XLU>>2):
190	// 0x0c18
191	// Cycle1: In * 0 + In * 1
192	// Cycle2: In * AIn + Mem * 1-A
193	case BLEND_FOG_ASHADE + (BLEND_XLU>>2):
194	//Cycle1: Fog * AShade + In * 1-A
195	//Cycle2: In * AIn + Mem * 1-A
196	case BLEND_FOG_APRIM + (BLEND_XLU>>2):
197	//Cycle1: Fog * AFog + In * 1-A
198	//Cycle2: In * AIn + Mem * 1-A
199	//case BLEND_FOG_MEM_FOG_MEM + (BLEND_OPA>>2):
200	//Cycle1: In * AFog + Fog * 1-A
201	//Cycle2: In * AIn + Mem * AMem
202	case BLEND_FOG_MEM_FOG_MEM + (BLEND_PASS>>2):
203	//Cycle1: In * AFog + Fog * 1-A
204	//Cycle2: In * 0 + In * 1
205	case BLEND_XLU + (BLEND_XLU>>2):
206	//Cycle1: Fog * AFog + In * 1-A
207	//Cycle2: In * AIn + Mem * 1-A
208	case BLEND_BI_AFOG + (BLEND_XLU>>2):
209	//Cycle1: Bl * AFog + In * 1-A
210	//Cycle2: In * AIn + Mem * 1-A
211	case BLEND_XLU + (BLEND_FOG_MEM_IN_MEM>>2):
212	//Cycle1: In * AIn + Mem * 1-A
213	//Cycle2: In * AFog + Mem * 1-A
214	case BLEND_PASS + (BLEND_FOG_MEM_IN_MEM>>2):
215	//Cycle1: In * 0 + In * 1
216	//Cycle2: In * AFog + Mem * 1-A
217	BlendFunc(BLEND_SRCALPHA, BLEND_INVSRCALPHA);
218	Enable();
219	break;
220	case BLEND_FOG_MEM_FOG_MEM + (BLEND_OPA>>2):
221	//Cycle1: In * AFog + Fog * 1-A
222	//Cycle2: In * AIn + Mem * AMem
223	BlendFunc(BLEND_ONE, BLEND_ZERO);
224	Enable();
225	break;
226
227	case BLEND_FOG_APRIM + (BLEND_OPA>>2):
228	// For Golden Eye
229	//Cycle1: Fog * AFog + In * 1-A
230	//Cycle2: In * AIn + Mem * AMem
231	case BLEND_FOG_ASHADE + (BLEND_OPA>>2):
232	//Cycle1: Fog * AShade + In * 1-A
233	//Cycle2: In * AIn + Mem * AMem
234	case BLEND_BI_AFOG + (BLEND_OPA>>2):
235	//Cycle1: Bl * AFog + In * 1-A
236	//Cycle2: In * AIn + Mem * 1-AMem
237	case BLEND_FOG_ASHADE + (BLEND_NOOP>>2):
238	//Cycle1: Fog * AShade + In * 1-A
239	//Cycle2: In * AIn + In * 1-A
240	case BLEND_NOOP + (BLEND_OPA>>2):
241	//Cycle1: In * AIn + In * 1-A
242	//Cycle2: In * AIn + Mem * AMem
243	case BLEND_NOOP4 + (BLEND_NOOP>>2):
244	//Cycle1: Fog * AIn + In * 1-A
245	//Cycle2: In * 0 + In * 1
246	case BLEND_FOG_ASHADE+(BLEND_PASS>>2):
247	//Cycle1: Fog * AShade + In * 1-A
248	//Cycle2: In * 0 + In * 1
249	case BLEND_FOG_3+(BLEND_PASS>>2):
250	BlendFunc(BLEND_ONE, BLEND_ZERO);
251	Enable();
252	break;
253	case BLEND_FOG_ASHADE+0x0301:
254	// c800 - Cycle1: Fog * AShade + In * 1-A
255	// 0301 - Cycle2: In * 0 + In * AMem
256	BlendFunc(BLEND_SRCALPHA, BLEND_ZERO);
257	Enable();
258	break;
259	case 0x0c08+0x1111:
260	// 0c08 - Cycle1: In * 0 + In * 1
261	// 1111 - Cycle2: Mem * AFog + Mem * AMem
262	BlendFunc(BLEND_ZERO, BLEND_DESTALPHA);
263	Enable();
264	break;
265	default:
266	#ifdef DEBUGGER
267	if( pauseAtNext )
268	{
269	uint32 dwM1A_1 = (gRDP.otherMode.blender>>14) & 0x3;
270	uint32 dwM1B_1 = (gRDP.otherMode.blender>>10) & 0x3;
271	uint32 dwM2A_1 = (gRDP.otherMode.blender>>6) & 0x3;
272	uint32 dwM2B_1 = (gRDP.otherMode.blender>>2) & 0x3;
273
274	uint32 dwM1A_2 = (gRDP.otherMode.blender>>12) & 0x3;
275	uint32 dwM1B_2 = (gRDP.otherMode.blender>>8) & 0x3;
276	uint32 dwM2A_2 = (gRDP.otherMode.blender>>4) & 0x3;
277	uint32 dwM2B_2 = (gRDP.otherMode.blender ) & 0x3;
278
279	TRACE0("Unknown Blender Mode: 2 cycle");
280	DebuggerAppendMsg( "\tblender:\t\t%04x - Cycle1:\t%s * %s + %s * %s\n\t\t%04x - Cycle2:\t%s * %s + %s * %s", blendmode_1,
281	sc_szBlClr[dwM1A_1], sc_szBlA1[dwM1B_1], sc_szBlClr[dwM2A_1], sc_szBlA2[dwM2B_1], blendmode_2,
282	sc_szBlClr[dwM1A_2], sc_szBlA1[dwM1B_2], sc_szBlClr[dwM2A_2], sc_szBlA2[dwM2B_2]);
283
284	}
285	#endif
286	if( blendmode_2 == (BLEND_PASS>>2) )
287	{
288	BlendFunc(BLEND_ONE, BLEND_ZERO);
289	}
290	else
291	{
292	BlendFunc(BLEND_SRCALPHA, BLEND_INVSRCALPHA);
293	}
294	Enable();
295	break;
296	}
297	break;
298	default: // 1/2 Cycle or Copy
299	if( gRDP.otherMode.force_bl && gRDP.otherMode.z_cmp && blendmode_1 != BLEND_FOG_ASHADE )
300	{
301	BlendFunc(BLEND_SRCALPHA, BLEND_INVSRCALPHA);
302	Enable();
303	break;
304	}
305	if( gRDP.otherMode.force_bl && options.enableHackForGames == HACK_FOR_COMMANDCONQUER )
306	{
307	BlendFunc(BLEND_SRCALPHA, BLEND_INVSRCALPHA);
308	Enable();
309	break;
310	}
311
312	#ifdef DEBUGGER
313	//if( (blendmode_1>>2) != blendmode_2 )
314	//{
315	// DebuggerAppendMsg("Warning: in 1 cycle mode, blend1!=blend2");
316	//}
317	#endif
318
319	switch ( blendmode_1 )
320	//switch ( blendmode_2<<2 )
321	{
322	case BLEND_XLU: // IN * A_IN + MEM * (1-A_IN)
323	case BLEND_BI_AIN: // Bl * AIn + Mem * 1-A
324	case BLEND_FOG_MEM: // c440 - Cycle1: Fog * AFog + Mem * 1-A
325	case BLEND_FOG_MEM_IN_MEM: // c440 - Cycle1: In * AFog + Mem * 1-A
326	case BLEND_BLENDCOLOR: //Bl * 0 + Bl * 1
327	case 0x00c0: //In * AIn + Fog * 1-A
328	BlendFunc(BLEND_SRCALPHA, BLEND_INVSRCALPHA);
329	Enable();
330	break;
331	case BLEND_MEM_ALPHA_IN: // Mem * AIn + Mem * AMem
332	BlendFunc(BLEND_ZERO, BLEND_DESTALPHA);
333	Enable();
334	break;
335	case BLEND_PASS: // IN * 0 + IN * 1
336	BlendFunc(BLEND_ONE, BLEND_ZERO);
337	if( gRDP.otherMode.alpha_cvg_sel )
338	{
339	Enable();
340	}
341	else
342	{
343	Disable();
344	}
345	break;
346	case BLEND_OPA: // IN * A_IN + MEM * A_MEM
347	if( options.enableHackForGames == HACK_FOR_MARIO_TENNIS )
348	{
349	BlendFunc(BLEND_SRCALPHA, BLEND_INVSRCALPHA);
350	}
351	else
352	{
353	BlendFunc(BLEND_ONE, BLEND_ZERO);
354	}
355	Enable();
356	break;
357	case BLEND_NOOP: // IN * A_IN + IN * (1 - A_IN)
358	case BLEND_FOG_ASHADE: // Fog * AShade + In * 1-A
359	case BLEND_FOG_MEM_3: // Mem * AFog + Fog * 1-A
360	case BLEND_BI_AFOG: // Bl * AFog + In * 1-A
361	BlendFunc(BLEND_ONE, BLEND_ZERO);
362	Enable();
363	break;
364	case BLEND_FOG_APRIM: // Fog * AFog + In * 1-A
365	BlendFunc(BLEND_INVSRCALPHA, BLEND_ZERO);
366	Enable();
367	break;
368	case BLEND_NOOP3: // In * 0 + Mem * 1
369	case BLEND_NOOP5: // Fog * 0 + Mem * 1
370	BlendFunc(BLEND_ZERO, BLEND_ONE);
371	Enable();
372	break;
373	case BLEND_MEM: // Mem * 0 + Mem * 1-A
374	// WaveRace
375	BlendFunc(BLEND_ZERO, BLEND_ONE);
376	Enable();
377	break;
378	default:
379	#ifdef DEBUGGER
380	if( pauseAtNext )
381	{
382	uint32 dwM1A_1 = (gRDP.otherMode.blender>>14) & 0x3;
383	uint32 dwM1B_1 = (gRDP.otherMode.blender>>10) & 0x3;
384	uint32 dwM2A_1 = (gRDP.otherMode.blender>>6) & 0x3;
385	uint32 dwM2B_1 = (gRDP.otherMode.blender>>2) & 0x3;
386
387	uint32 dwM1A_2 = (gRDP.otherMode.blender>>12) & 0x3;
388	uint32 dwM1B_2 = (gRDP.otherMode.blender>>8) & 0x3;
389	uint32 dwM2A_2 = (gRDP.otherMode.blender>>4) & 0x3;
390	uint32 dwM2B_2 = (gRDP.otherMode.blender ) & 0x3;
391
392	TRACE0("Unknown Blender Mode: 1 cycle");
393	DebuggerAppendMsg( "\tblender:\t\t%04x - Cycle1:\t%s * %s + %s * %s\n\t\t\tCycle2:\t%s * %s + %s * %s", blendmode_1,
394	sc_szBlClr[dwM1A_1], sc_szBlA1[dwM1B_1], sc_szBlClr[dwM2A_1], sc_szBlA2[dwM2B_1],
395	sc_szBlClr[dwM1A_2], sc_szBlA1[dwM1B_2], sc_szBlClr[dwM2A_2], sc_szBlA2[dwM2B_2]);
396	}
397	#endif
398	BlendFunc(BLEND_SRCALPHA, BLEND_INVSRCALPHA);
399	Enable();
400	render->SetAlphaTestEnable(TRUE);
401	break;
402	}
403	}
404	}
405