[mupen64plus-pandora.git] / source / rice_gles / 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;

#ifndef HAVE_GLES
    COGLGraphicsContext *pcontext = (COGLGraphicsContext *)(CGraphicsContext::g_pGraphicsContext);
    if( pcontext->IsExtensionSupported(OSAL_GL_ARB_TEXTURE_ENV_ADD) || pcontext->IsExtensionSupported("GL_EXT_texture_env_add") )
#endif
    {
        m_bSupportAdd = true;
    }
#ifndef HAVE_GLES
    if( pcontext->IsExtensionSupported("GL_EXT_blend_subtract") )
#endif
    {
        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
d07c171f	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	#ifndef HAVE_GLES
75	COGLGraphicsContext pcontext = (COGLGraphicsContext )(CGraphicsContext::g_pGraphicsContext);
76	if( pcontext->IsExtensionSupported(OSAL_GL_ARB_TEXTURE_ENV_ADD) \|\| pcontext->IsExtensionSupported("GL_EXT_texture_env_add") )
77	#endif
78	{
79	m_bSupportAdd = true;
80	}
81	#ifndef HAVE_GLES
82	if( pcontext->IsExtensionSupported("GL_EXT_blend_subtract") )
83	#endif
84	{
85	m_bSupportSubtract = true;
86	}
87
88	return true;
89	}
90
91	void COGLColorCombiner::DisableCombiner(void)
92	{
93	m_pOGLRender->DisableMultiTexture();
94	glEnable(GL_BLEND);
95	OPENGL_CHECK_ERRORS;
96	glBlendFunc(GL_ONE, GL_ZERO);
97	OPENGL_CHECK_ERRORS;
98
99	if( m_bTexelsEnable )
100	{
101	COGLTexture* pTexture = g_textures[gRSP.curTile].m_pCOGLTexture;
102	if( pTexture )
103	{
104	m_pOGLRender->EnableTexUnit(0,TRUE);
105	m_pOGLRender->BindTexture(pTexture->m_dwTextureName, 0);
106	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
107	OPENGL_CHECK_ERRORS;
108	m_pOGLRender->SetAllTexelRepeatFlag();
109	}
110	#ifdef DEBUGGER
111	else
112	{
113	DebuggerAppendMsg("Check me, texture is NULL but it is enabled");
114	}
115	#endif
116	}
117	else
118	{
119	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
120	OPENGL_CHECK_ERRORS;
121	m_pOGLRender->EnableTexUnit(0,FALSE);
122	}
123	}
124
125	void COGLColorCombiner::InitCombinerCycleCopy(void)
126	{
127	m_pOGLRender->DisableMultiTexture();
128	m_pOGLRender->EnableTexUnit(0,TRUE);
129	COGLTexture* pTexture = g_textures[gRSP.curTile].m_pCOGLTexture;
130	if( pTexture )
131	{
132	m_pOGLRender->BindTexture(pTexture->m_dwTextureName, 0);
133	m_pOGLRender->SetTexelRepeatFlags(gRSP.curTile);
134	}
135	#ifdef DEBUGGER
136	else
137	{
138	DebuggerAppendMsg("Check me, texture is NULL");
139	}
140	#endif
141
142	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
143	OPENGL_CHECK_ERRORS;
144	}
145
146	void COGLColorCombiner::InitCombinerCycleFill(void)
147	{
148	m_pOGLRender->DisableMultiTexture();
149	m_pOGLRender->EnableTexUnit(0,FALSE);
150	}
151
152
153	void COGLColorCombiner::InitCombinerCycle12(void)
154	{
155	m_pOGLRender->DisableMultiTexture();
156	if( !m_bTexelsEnable )
157	{
158	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
159	OPENGL_CHECK_ERRORS;
160	m_pOGLRender->EnableTexUnit(0,FALSE);
161	return;
162	}
163
164	#if SDL_VIDEO_OPENGL
165	uint32 mask = 0x1f;
166	COGLTexture* pTexture = g_textures[gRSP.curTile].m_pCOGLTexture;
167	if( pTexture )
168	{
169	m_pOGLRender->EnableTexUnit(0,TRUE);
170	m_pOGLRender->BindTexture(pTexture->m_dwTextureName, 0);
171	m_pOGLRender->SetAllTexelRepeatFlag();
172	}
173	#ifdef DEBUGGER
174	else
175	{
176	DebuggerAppendMsg("Check me, texture is NULL");
177	}
178	#endif
179
180	bool texIsUsed = m_pDecodedMux->isUsed(MUX_TEXEL0);
181	bool shadeIsUsedInColor = m_pDecodedMux->isUsedInCycle(MUX_SHADE, 0, COLOR_CHANNEL);
182	bool texIsUsedInColor = m_pDecodedMux->isUsedInCycle(MUX_TEXEL0, 0, COLOR_CHANNEL);
183
184	if( texIsUsed )
185	{
186	// Parse the simplified the mux, because the OGL 1.1 combiner function is so much
187	// limited, we only parse the 1st N64 combiner setting and only the RGB part
188
189	N64CombinerType & comb = m_pDecodedMux->m_n64Combiners[0];
190	switch( m_pDecodedMux->mType )
191	{
192	case CM_FMT_TYPE_NOT_USED:
193	case CM_FMT_TYPE_D: // = A
194	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
195	OPENGL_CHECK_ERRORS;
196	break;
197	case CM_FMT_TYPE_A_ADD_D: // = A+D
198	if( shadeIsUsedInColor && texIsUsedInColor )
199	{
200	if( m_bSupportAdd )
201	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_ADD);
202	else
203	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
204	}
205	else if( texIsUsedInColor )
206	{
207	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
208	}
209	else
210	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
211	OPENGL_CHECK_ERRORS;
212	break;
213	case CM_FMT_TYPE_A_SUB_B: // = A-B
214	if( shadeIsUsedInColor && texIsUsedInColor )
215	{
216	if( m_bSupportSubtract )
217	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_SUBTRACT_ARB);
218	else
219	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
220	}
221	else if( texIsUsedInColor )
222	{
223	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
224	}
225	else
226	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
227	OPENGL_CHECK_ERRORS;
228	break;
229	case CM_FMT_TYPE_A_MOD_C: // = A*C
230	case CM_FMT_TYPE_A_MOD_C_ADD_D: // = A*C+D
231	if( shadeIsUsedInColor && texIsUsedInColor )
232	{
233	if( ((comb.c & mask) == MUX_SHADE && !(comb.c&MUX_COMPLEMENT)) \|\|
234	((comb.a & mask) == MUX_SHADE && !(comb.a&MUX_COMPLEMENT)) )
235	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
236	else
237	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
238	}
239	else if( texIsUsedInColor )
240	{
241	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
242	}
243	else
244	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
245	OPENGL_CHECK_ERRORS;
246	break;
247	case CM_FMT_TYPE_A_LERP_B_C: // = A*C+D
248	if( (comb.b&mask) == MUX_SHADE && (comb.c&mask)==MUX_TEXEL0 && ((comb.a&mask)==MUX_PRIM\|\|(comb.a&mask)==MUX_ENV))
249	{
250	float *fv;
251	if( (comb.a&mask)==MUX_PRIM )
252	{
253	fv = GetPrimitiveColorfv();
254	}
255	else
256	{
257	fv = GetEnvColorfv();
258	}
259
260	glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,fv);
261	OPENGL_CHECK_ERRORS;
262	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_BLEND);
263	OPENGL_CHECK_ERRORS;
264	break;
265	}
266	default: // = (A-B)*C+D
267	if( shadeIsUsedInColor )
268	{
269	if( ((comb.c & mask) == MUX_SHADE && !(comb.c&MUX_COMPLEMENT)) \|\|
270	((comb.a & mask) == MUX_SHADE && !(comb.a&MUX_COMPLEMENT)) )
271	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
272	else
273	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
274	}
275	else
276	{
277	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
278	}
279	OPENGL_CHECK_ERRORS;
280	break;
281	}
282	}
283	else
284	{
285	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
286	OPENGL_CHECK_ERRORS;
287	}
288	#endif
289	}
290
291	void COGLBlender::NormalAlphaBlender(void)
292	{
293	glEnable(GL_BLEND);
294	OPENGL_CHECK_ERRORS;
295	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
296	OPENGL_CHECK_ERRORS;
297	}
298
299	void COGLBlender::DisableAlphaBlender(void)
300	{
301	glEnable(GL_BLEND);
302	OPENGL_CHECK_ERRORS;
303	glBlendFunc(GL_ONE, GL_ZERO);
304	OPENGL_CHECK_ERRORS;
305	}
306
307
308	void COGLBlender::BlendFunc(uint32 srcFunc, uint32 desFunc)
309	{
310	glBlendFunc(DirectX_OGL_BlendFuncMaps[srcFunc], DirectX_OGL_BlendFuncMaps[desFunc]);
311	OPENGL_CHECK_ERRORS;
312	}
313
314	void COGLBlender::Enable()
315	{
316	glEnable(GL_BLEND);
317	OPENGL_CHECK_ERRORS;
318	}
319
320	void COGLBlender::Disable()
321	{
322	glDisable(GL_BLEND);
323	OPENGL_CHECK_ERRORS;
324	}
325
326	void COGLColorCombiner::InitCombinerBlenderForSimpleTextureDraw(uint32 tile)
327	{
328	m_pOGLRender->DisableMultiTexture();
329	if( g_textures[tile].m_pCTexture )
330	{
331	m_pOGLRender->EnableTexUnit(0,TRUE);
332	glBindTexture(GL_TEXTURE_2D, ((COGLTexture*)(g_textures[tile].m_pCTexture))->m_dwTextureName);
333	OPENGL_CHECK_ERRORS;
334	}
335	m_pOGLRender->SetAllTexelRepeatFlag();
336
337	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
338	OPENGL_CHECK_ERRORS;
339	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
340	OPENGL_CHECK_ERRORS;
341	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,GL_LINEAR); // Linear Filtering
342	OPENGL_CHECK_ERRORS;
343	glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER,GL_LINEAR); // Linear Filtering
344	OPENGL_CHECK_ERRORS;
345
346	glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
347	OPENGL_CHECK_ERRORS;
348	m_pOGLRender->SetAlphaTestEnable(FALSE);
349	}
350
351	#ifdef DEBUGGER
352	extern const char *translatedCombTypes[];
353	void COGLColorCombiner::DisplaySimpleMuxString(void)
354	{
355	TRACE0("\nSimplified Mux\n");
356	m_pDecodedMux->DisplaySimpliedMuxString("Used");
357	}
358	#endif
359