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

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 *   Mupen64plus - OGLCombiner.cpp                                         *
 *   Mupen64Plus homepage: http://code.google.com/p/mupen64plus/           *
 *   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.,                                       *
 *   51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.          *
 * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */

#include "osal_opengl.h"

#include "OGLCombiner.h"
#include "OGLDebug.h"
#include "OGLRender.h"
#include "OGLGraphicsContext.h"
#include "OGLDecodedMux.h"
#include "OGLTexture.h"

//========================================================================
uint32 DirectX_OGL_BlendFuncMaps [] =
{
    GL_SRC_ALPHA,               //Nothing
    GL_ZERO,                    //BLEND_ZERO               = 1,
    GL_ONE,                     //BLEND_ONE                = 2,
    GL_SRC_COLOR,               //BLEND_SRCCOLOR           = 3,
    GL_ONE_MINUS_SRC_COLOR,     //BLEND_INVSRCCOLOR        = 4,
    GL_SRC_ALPHA,               //BLEND_SRCALPHA           = 5,
    GL_ONE_MINUS_SRC_ALPHA,     //BLEND_INVSRCALPHA        = 6,
    GL_DST_ALPHA,               //BLEND_DESTALPHA          = 7,
    GL_ONE_MINUS_DST_ALPHA,     //BLEND_INVDESTALPHA       = 8,
    GL_DST_COLOR,               //BLEND_DESTCOLOR          = 9,
    GL_ONE_MINUS_DST_COLOR,     //BLEND_INVDESTCOLOR       = 10,
    GL_SRC_ALPHA_SATURATE,      //BLEND_SRCALPHASAT        = 11,
    GL_SRC_ALPHA_SATURATE,      //BLEND_BOTHSRCALPHA       = 12,    
    GL_SRC_ALPHA_SATURATE,      //BLEND_BOTHINVSRCALPHA    = 13,
};

//========================================================================
COGLColorCombiner::COGLColorCombiner(CRender *pRender) :
    CColorCombiner(pRender),
    m_pOGLRender((OGLRender*)pRender),
    m_bSupportAdd(false), m_bSupportSubtract(false)
{
    m_pDecodedMux = new COGLDecodedMux;
    m_pDecodedMux->m_maxConstants = 0;
    m_pDecodedMux->m_maxTextures = 1;
}

COGLColorCombiner::~COGLColorCombiner()
{
    delete m_pDecodedMux;
    m_pDecodedMux = NULL;
}

bool COGLColorCombiner::Initialize(void)
{
    m_bSupportAdd = false;
    m_bSupportSubtract = false;
    m_supportedStages = 1;
    m_bSupportMultiTexture = false;

    COGLGraphicsContext *pcontext = (COGLGraphicsContext *)(CGraphicsContext::g_pGraphicsContext);
    if( pcontext->IsExtensionSupported(OSAL_GL_ARB_TEXTURE_ENV_ADD) || pcontext->IsExtensionSupported("GL_EXT_texture_env_add") )
    {
        m_bSupportAdd = true;
    }

    if( pcontext->IsExtensionSupported("GL_EXT_blend_subtract") )
    {
        m_bSupportSubtract = true;
    }

    return true;
}

void COGLColorCombiner::DisableCombiner(void)
{
    m_pOGLRender->DisableMultiTexture();
    glEnable(GL_BLEND);
    OPENGL_CHECK_ERRORS;
    glBlendFunc(GL_ONE, GL_ZERO);
    OPENGL_CHECK_ERRORS;
    
    if( m_bTexelsEnable )
    {
        COGLTexture* pTexture = g_textures[gRSP.curTile].m_pCOGLTexture;
        if( pTexture ) 
        {
            m_pOGLRender->EnableTexUnit(0,TRUE);
            m_pOGLRender->BindTexture(pTexture->m_dwTextureName, 0);
            glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
            OPENGL_CHECK_ERRORS;
            m_pOGLRender->SetAllTexelRepeatFlag();
        }
#ifdef DEBUGGER
        else
        {
            DebuggerAppendMsg("Check me, texture is NULL but it is enabled");
        }
#endif
    }
    else
    {
        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
        OPENGL_CHECK_ERRORS;
        m_pOGLRender->EnableTexUnit(0,FALSE);
    }
}

void COGLColorCombiner::InitCombinerCycleCopy(void)
{
    m_pOGLRender->DisableMultiTexture();
    m_pOGLRender->EnableTexUnit(0,TRUE);
    COGLTexture* pTexture = g_textures[gRSP.curTile].m_pCOGLTexture;
    if( pTexture )
    {
        m_pOGLRender->BindTexture(pTexture->m_dwTextureName, 0);
        m_pOGLRender->SetTexelRepeatFlags(gRSP.curTile);
    }
#ifdef DEBUGGER
    else
    {
        DebuggerAppendMsg("Check me, texture is NULL");
    }
#endif

    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    OPENGL_CHECK_ERRORS;
}

void COGLColorCombiner::InitCombinerCycleFill(void)
{
    m_pOGLRender->DisableMultiTexture();
    m_pOGLRender->EnableTexUnit(0,FALSE);
}


void COGLColorCombiner::InitCombinerCycle12(void)
{
    m_pOGLRender->DisableMultiTexture();
    if( !m_bTexelsEnable )
    {
        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
        OPENGL_CHECK_ERRORS;
        m_pOGLRender->EnableTexUnit(0,FALSE);
        return;
    }

#if SDL_VIDEO_OPENGL
    uint32 mask = 0x1f;
    COGLTexture* pTexture = g_textures[gRSP.curTile].m_pCOGLTexture;
    if( pTexture )
    {
        m_pOGLRender->EnableTexUnit(0,TRUE);
        m_pOGLRender->BindTexture(pTexture->m_dwTextureName, 0);
        m_pOGLRender->SetAllTexelRepeatFlag();
    }
#ifdef DEBUGGER
    else
    {
        DebuggerAppendMsg("Check me, texture is NULL");
    }
#endif

    bool texIsUsed = m_pDecodedMux->isUsed(MUX_TEXEL0);
    bool shadeIsUsedInColor = m_pDecodedMux->isUsedInCycle(MUX_SHADE, 0, COLOR_CHANNEL);
    bool texIsUsedInColor = m_pDecodedMux->isUsedInCycle(MUX_TEXEL0, 0, COLOR_CHANNEL);

    if( texIsUsed )
    {
        // Parse the simplified the mux, because the OGL 1.1 combiner function is so much
        // limited, we only parse the 1st N64 combiner setting and only the RGB part

        N64CombinerType & comb = m_pDecodedMux->m_n64Combiners[0];
        switch( m_pDecodedMux->mType )
        {
        case CM_FMT_TYPE_NOT_USED:
        case CM_FMT_TYPE_D:             // = A
            glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
            OPENGL_CHECK_ERRORS;
            break;
        case CM_FMT_TYPE_A_ADD_D:           // = A+D
            if( shadeIsUsedInColor && texIsUsedInColor )
            {
                if( m_bSupportAdd )
                    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
                else
                    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
            }
            else if( texIsUsedInColor )
            {
                glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
            }
            else
                glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
            OPENGL_CHECK_ERRORS;
            break;
        case CM_FMT_TYPE_A_SUB_B:           // = A-B
            if( shadeIsUsedInColor && texIsUsedInColor )
            {
                if( m_bSupportSubtract )
                    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_SUBTRACT_ARB);
                else
                    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
            }
            else if( texIsUsedInColor )
            {
                glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
            }
            else
                glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
            OPENGL_CHECK_ERRORS;
            break;
        case CM_FMT_TYPE_A_MOD_C:           // = A*C
        case CM_FMT_TYPE_A_MOD_C_ADD_D: // = A*C+D
            if( shadeIsUsedInColor && texIsUsedInColor )
            {
                if( ((comb.c & mask) == MUX_SHADE && !(comb.c&MUX_COMPLEMENT)) ||
                    ((comb.a & mask) == MUX_SHADE && !(comb.a&MUX_COMPLEMENT)) )
                    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
                else
                    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
            }
            else if( texIsUsedInColor )
            {
                glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
            }
            else
                glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
            OPENGL_CHECK_ERRORS;
            break;
        case CM_FMT_TYPE_A_LERP_B_C:    // = A*C+D
            if( (comb.b&mask) == MUX_SHADE && (comb.c&mask)==MUX_TEXEL0 && ((comb.a&mask)==MUX_PRIM||(comb.a&mask)==MUX_ENV))
            {
                float *fv;
                if( (comb.a&mask)==MUX_PRIM )
                {
                    fv = GetPrimitiveColorfv();
                }
                else
                {
                    fv = GetEnvColorfv();
                }

                glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,fv);
                OPENGL_CHECK_ERRORS;
                glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
                OPENGL_CHECK_ERRORS;
                break;
            }
        default:        // = (A-B)*C+D
            if( shadeIsUsedInColor )
            {
                if( ((comb.c & mask) == MUX_SHADE && !(comb.c&MUX_COMPLEMENT)) ||
                    ((comb.a & mask) == MUX_SHADE && !(comb.a&MUX_COMPLEMENT)) )
                    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
                else
                    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
            }
            else
            {
                glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
            }
            OPENGL_CHECK_ERRORS;
            break;
        }
    }
    else
    {
        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
        OPENGL_CHECK_ERRORS;
    }
#endif
}

void COGLBlender::NormalAlphaBlender(void)
{
    glEnable(GL_BLEND);
    OPENGL_CHECK_ERRORS;
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    OPENGL_CHECK_ERRORS;
}

void COGLBlender::DisableAlphaBlender(void)
{
    glEnable(GL_BLEND);
    OPENGL_CHECK_ERRORS;
    glBlendFunc(GL_ONE, GL_ZERO);
    OPENGL_CHECK_ERRORS;
}


void COGLBlender::BlendFunc(uint32 srcFunc, uint32 desFunc)
{
    glBlendFunc(DirectX_OGL_BlendFuncMaps[srcFunc], DirectX_OGL_BlendFuncMaps[desFunc]);
    OPENGL_CHECK_ERRORS;
}

void COGLBlender::Enable()
{
    glEnable(GL_BLEND);
    OPENGL_CHECK_ERRORS;
}

void COGLBlender::Disable()
{
    glDisable(GL_BLEND);
    OPENGL_CHECK_ERRORS;
}

void COGLColorCombiner::InitCombinerBlenderForSimpleTextureDraw(uint32 tile)
{
    m_pOGLRender->DisableMultiTexture();
    if( g_textures[tile].m_pCTexture )
    {
        m_pOGLRender->EnableTexUnit(0,TRUE);
        glBindTexture(GL_TEXTURE_2D, ((COGLTexture*)(g_textures[tile].m_pCTexture))->m_dwTextureName);
        OPENGL_CHECK_ERRORS;
    }
    m_pOGLRender->SetAllTexelRepeatFlag();

    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
    OPENGL_CHECK_ERRORS;
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
    OPENGL_CHECK_ERRORS;
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); // Linear Filtering
    OPENGL_CHECK_ERRORS;
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // Linear Filtering
    OPENGL_CHECK_ERRORS;

    glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
    OPENGL_CHECK_ERRORS;
    m_pOGLRender->SetAlphaTestEnable(FALSE);
}

#ifdef DEBUGGER
extern const char *translatedCombTypes[];
void COGLColorCombiner::DisplaySimpleMuxString(void)
{
    TRACE0("\nSimplified Mux\n");
    m_pDecodedMux->DisplaySimpliedMuxString("Used");
}
#endif
Commit	Line	Data
292f9317	1	/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
	2	* Mupen64plus - OGLCombiner.cpp *
	3	* Mupen64Plus homepage: http://code.google.com/p/mupen64plus/ *
	4	* Copyright (C) 2003 Rice1964 *
	5	* *
	6	* This program is free software; you can redistribute it and/or modify *
	7	* it under the terms of the GNU General Public License as published by *
	8	* the Free Software Foundation; either version 2 of the License, or *
	9	* (at your option) any later version. *
	10	* *
	11	* This program is distributed in the hope that it will be useful, *
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of *
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
	14	* GNU General Public License for more details. *
	15	* *
	16	* You should have received a copy of the GNU General Public License *
	17	* along with this program; if not, write to the *
	18	* Free Software Foundation, Inc., *
	19	* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
	20	* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
	21
	22	#include "osal_opengl.h"
	23
	24	#include "OGLCombiner.h"
	25	#include "OGLDebug.h"
	26	#include "OGLRender.h"
	27	#include "OGLGraphicsContext.h"
	28	#include "OGLDecodedMux.h"
	29	#include "OGLTexture.h"
	30
	31	//========================================================================
	32	uint32 DirectX_OGL_BlendFuncMaps [] =
	33	{
	34	GL_SRC_ALPHA, //Nothing
	35	GL_ZERO, //BLEND_ZERO = 1,
	36	GL_ONE, //BLEND_ONE = 2,
	37	GL_SRC_COLOR, //BLEND_SRCCOLOR = 3,
	38	GL_ONE_MINUS_SRC_COLOR, //BLEND_INVSRCCOLOR = 4,
	39	GL_SRC_ALPHA, //BLEND_SRCALPHA = 5,
	40	GL_ONE_MINUS_SRC_ALPHA, //BLEND_INVSRCALPHA = 6,
	41	GL_DST_ALPHA, //BLEND_DESTALPHA = 7,
	42	GL_ONE_MINUS_DST_ALPHA, //BLEND_INVDESTALPHA = 8,
	43	GL_DST_COLOR, //BLEND_DESTCOLOR = 9,
	44	GL_ONE_MINUS_DST_COLOR, //BLEND_INVDESTCOLOR = 10,
	45	GL_SRC_ALPHA_SATURATE, //BLEND_SRCALPHASAT = 11,
	46	GL_SRC_ALPHA_SATURATE, //BLEND_BOTHSRCALPHA = 12,
	47	GL_SRC_ALPHA_SATURATE, //BLEND_BOTHINVSRCALPHA = 13,
	48	};
	49
	50	//========================================================================
	51	COGLColorCombiner::COGLColorCombiner(CRender *pRender) :
	52	CColorCombiner(pRender),
	53	m_pOGLRender((OGLRender*)pRender),
	54	m_bSupportAdd(false), m_bSupportSubtract(false)
	55	{
	56	m_pDecodedMux = new COGLDecodedMux;
	57	m_pDecodedMux->m_maxConstants = 0;
	58	m_pDecodedMux->m_maxTextures = 1;
	59	}
	60
	61	COGLColorCombiner::~COGLColorCombiner()
	62	{
	63	delete m_pDecodedMux;
	64	m_pDecodedMux = NULL;
65	}
66
67	bool COGLColorCombiner::Initialize(void)
68	{
69	m_bSupportAdd = false;
70	m_bSupportSubtract = false;
71	m_supportedStages = 1;
72	m_bSupportMultiTexture = false;
73
74	COGLGraphicsContext pcontext = (COGLGraphicsContext )(CGraphicsContext::g_pGraphicsContext);
75	if( pcontext->IsExtensionSupported(OSAL_GL_ARB_TEXTURE_ENV_ADD) \|\| pcontext->IsExtensionSupported("GL_EXT_texture_env_add") )
76	{
77	m_bSupportAdd = true;
78	}
79
80	if( pcontext->IsExtensionSupported("GL_EXT_blend_subtract") )
81	{
82	m_bSupportSubtract = true;
83	}
84
85	return true;
86	}
87
88	void COGLColorCombiner::DisableCombiner(void)
89	{
90	m_pOGLRender->DisableMultiTexture();
91	glEnable(GL_BLEND);
92	OPENGL_CHECK_ERRORS;
93	glBlendFunc(GL_ONE, GL_ZERO);
94	OPENGL_CHECK_ERRORS;
95
96	if( m_bTexelsEnable )
97	{
98	COGLTexture* pTexture = g_textures[gRSP.curTile].m_pCOGLTexture;
99	if( pTexture )
100	{
101	m_pOGLRender->EnableTexUnit(0,TRUE);
102	m_pOGLRender->BindTexture(pTexture->m_dwTextureName, 0);
103	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
104	OPENGL_CHECK_ERRORS;
105	m_pOGLRender->SetAllTexelRepeatFlag();
106	}
107	#ifdef DEBUGGER
108	else
109	{
110	DebuggerAppendMsg("Check me, texture is NULL but it is enabled");
111	}
112	#endif
113	}
114	else
115	{
116	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
117	OPENGL_CHECK_ERRORS;
118	m_pOGLRender->EnableTexUnit(0,FALSE);
119	}
120	}
121
122	void COGLColorCombiner::InitCombinerCycleCopy(void)
123	{
124	m_pOGLRender->DisableMultiTexture();
125	m_pOGLRender->EnableTexUnit(0,TRUE);
126	COGLTexture* pTexture = g_textures[gRSP.curTile].m_pCOGLTexture;
127	if( pTexture )
128	{
129	m_pOGLRender->BindTexture(pTexture->m_dwTextureName, 0);
130	m_pOGLRender->SetTexelRepeatFlags(gRSP.curTile);
131	}
132	#ifdef DEBUGGER
133	else
134	{
135	DebuggerAppendMsg("Check me, texture is NULL");
136	}
137	#endif
138
139	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
140	OPENGL_CHECK_ERRORS;
141	}
142
143	void COGLColorCombiner::InitCombinerCycleFill(void)
144	{
145	m_pOGLRender->DisableMultiTexture();
146	m_pOGLRender->EnableTexUnit(0,FALSE);
147	}
148
149
150	void COGLColorCombiner::InitCombinerCycle12(void)
151	{
152	m_pOGLRender->DisableMultiTexture();
153	if( !m_bTexelsEnable )
154	{
155	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
156	OPENGL_CHECK_ERRORS;
157	m_pOGLRender->EnableTexUnit(0,FALSE);
158	return;
159	}
160
161	#if SDL_VIDEO_OPENGL
162	uint32 mask = 0x1f;
163	COGLTexture* pTexture = g_textures[gRSP.curTile].m_pCOGLTexture;
164	if( pTexture )
165	{
166	m_pOGLRender->EnableTexUnit(0,TRUE);
167	m_pOGLRender->BindTexture(pTexture->m_dwTextureName, 0);
168	m_pOGLRender->SetAllTexelRepeatFlag();
169	}
170	#ifdef DEBUGGER
171	else
172	{
173	DebuggerAppendMsg("Check me, texture is NULL");
174	}
175	#endif
176
177	bool texIsUsed = m_pDecodedMux->isUsed(MUX_TEXEL0);
178	bool shadeIsUsedInColor = m_pDecodedMux->isUsedInCycle(MUX_SHADE, 0, COLOR_CHANNEL);
179	bool texIsUsedInColor = m_pDecodedMux->isUsedInCycle(MUX_TEXEL0, 0, COLOR_CHANNEL);
180
181	if( texIsUsed )
182	{
183	// Parse the simplified the mux, because the OGL 1.1 combiner function is so much
184	// limited, we only parse the 1st N64 combiner setting and only the RGB part
185
186	N64CombinerType & comb = m_pDecodedMux->m_n64Combiners[0];
187	switch( m_pDecodedMux->mType )
188	{
189	case CM_FMT_TYPE_NOT_USED:
190	case CM_FMT_TYPE_D: // = A
191	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
192	OPENGL_CHECK_ERRORS;
193	break;
194	case CM_FMT_TYPE_A_ADD_D: // = A+D
195	if( shadeIsUsedInColor && texIsUsedInColor )
196	{
197	if( m_bSupportAdd )
198	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
199	else
200	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
201	}
202	else if( texIsUsedInColor )
203	{
204	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
205	}
206	else
207	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
208	OPENGL_CHECK_ERRORS;
209	break;
210	case CM_FMT_TYPE_A_SUB_B: // = A-B
211	if( shadeIsUsedInColor && texIsUsedInColor )
212	{
213	if( m_bSupportSubtract )
214	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_SUBTRACT_ARB);
215	else
216	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
217	}
218	else if( texIsUsedInColor )
219	{
220	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
221	}
222	else
223	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
224	OPENGL_CHECK_ERRORS;
225	break;
226	case CM_FMT_TYPE_A_MOD_C: // = A*C
227	case CM_FMT_TYPE_A_MOD_C_ADD_D: // = A*C+D
228	if( shadeIsUsedInColor && texIsUsedInColor )
229	{
230	if( ((comb.c & mask) == MUX_SHADE && !(comb.c&MUX_COMPLEMENT)) \|\|
231	((comb.a & mask) == MUX_SHADE && !(comb.a&MUX_COMPLEMENT)) )
232	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
233	else
234	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
235	}
236	else if( texIsUsedInColor )
237	{
238	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
239	}
240	else
241	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
242	OPENGL_CHECK_ERRORS;
243	break;
244	case CM_FMT_TYPE_A_LERP_B_C: // = A*C+D
245	if( (comb.b&mask) == MUX_SHADE && (comb.c&mask)==MUX_TEXEL0 && ((comb.a&mask)==MUX_PRIM\|\|(comb.a&mask)==MUX_ENV))
246	{
247	float *fv;
248	if( (comb.a&mask)==MUX_PRIM )
249	{
250	fv = GetPrimitiveColorfv();
251	}
252	else
253	{
254	fv = GetEnvColorfv();
255	}
256
257	glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,fv);
258	OPENGL_CHECK_ERRORS;
259	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
260	OPENGL_CHECK_ERRORS;
261	break;
262	}
263	default: // = (A-B)*C+D
264	if( shadeIsUsedInColor )
265	{
266	if( ((comb.c & mask) == MUX_SHADE && !(comb.c&MUX_COMPLEMENT)) \|\|
267	((comb.a & mask) == MUX_SHADE && !(comb.a&MUX_COMPLEMENT)) )
268	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
269	else
270	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
271	}
272	else
273	{
274	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
275	}
276	OPENGL_CHECK_ERRORS;
277	break;
278	}
279	}
280	else
281	{
282	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
283	OPENGL_CHECK_ERRORS;
284	}
285	#endif
286	}
287
288	void COGLBlender::NormalAlphaBlender(void)
289	{
290	glEnable(GL_BLEND);
291	OPENGL_CHECK_ERRORS;
292	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
293	OPENGL_CHECK_ERRORS;
294	}
295
296	void COGLBlender::DisableAlphaBlender(void)
297	{
298	glEnable(GL_BLEND);
299	OPENGL_CHECK_ERRORS;
300	glBlendFunc(GL_ONE, GL_ZERO);
301	OPENGL_CHECK_ERRORS;
302	}
303
304
305	void COGLBlender::BlendFunc(uint32 srcFunc, uint32 desFunc)
306	{
307	glBlendFunc(DirectX_OGL_BlendFuncMaps[srcFunc], DirectX_OGL_BlendFuncMaps[desFunc]);
308	OPENGL_CHECK_ERRORS;
309	}
310
311	void COGLBlender::Enable()
312	{
313	glEnable(GL_BLEND);
314	OPENGL_CHECK_ERRORS;
315	}
316
317	void COGLBlender::Disable()
318	{
319	glDisable(GL_BLEND);
320	OPENGL_CHECK_ERRORS;
321	}
322
323	void COGLColorCombiner::InitCombinerBlenderForSimpleTextureDraw(uint32 tile)
324	{
325	m_pOGLRender->DisableMultiTexture();
326	if( g_textures[tile].m_pCTexture )
327	{
328	m_pOGLRender->EnableTexUnit(0,TRUE);
329	glBindTexture(GL_TEXTURE_2D, ((COGLTexture*)(g_textures[tile].m_pCTexture))->m_dwTextureName);
330	OPENGL_CHECK_ERRORS;
331	}
332	m_pOGLRender->SetAllTexelRepeatFlag();
333
334	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
335	OPENGL_CHECK_ERRORS;
336	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
337	OPENGL_CHECK_ERRORS;
338	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); // Linear Filtering
339	OPENGL_CHECK_ERRORS;
340	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // Linear Filtering
341	OPENGL_CHECK_ERRORS;
342
343	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
344	OPENGL_CHECK_ERRORS;
345	m_pOGLRender->SetAlphaTestEnable(FALSE);
346	}
347
348	#ifdef DEBUGGER
349	extern const char *translatedCombTypes[];
350	void COGLColorCombiner::DisplaySimpleMuxString(void)
351	{
352	TRACE0("\nSimplified Mux\n");
353	m_pDecodedMux->DisplaySimpliedMuxString("Used");
354	}
355	#endif
356