[mupen64plus-pandora.git] / source / rice_gles / src / OGLFragmentShaders.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 "OGLExtensions.h"
#include "OGLDebug.h"
#include "OGLFragmentShaders.h"
#include "OGLRender.h"
#include "OGLGraphicsContext.h"

COGLFragmentShaderCombiner::COGLFragmentShaderCombiner(CRender *pRender)
: COGLColorCombiner(pRender)
{
    m_bShaderIsSupported = false;
}
COGLFragmentShaderCombiner::~COGLFragmentShaderCombiner()
{
}

bool COGLFragmentShaderCombiner::Initialize(void)
{
    if( !COGLColorCombiner::Initialize() )
        return false;

    COGLGraphicsContext *pcontext = (COGLGraphicsContext *)(CGraphicsContext::g_pGraphicsContext);
    if( pcontext->IsExtensionSupported("GL_ARB_fragment_shader") )
    {
        m_bShaderIsSupported = true;
    }

    return true;
}

void COGLFragmentShaderCombiner::InitCombinerCycle12(void)
{
}
void COGLFragmentShaderCombiner::DisableCombiner(void)
{
    COGLColorCombiner::DisableCombiner();
}

void COGLFragmentShaderCombiner::InitCombinerCycleCopy(void)
{
    COGLColorCombiner::InitCombinerCycleCopy();
}

void COGLFragmentShaderCombiner::InitCombinerCycleFill(void)
{
    COGLColorCombiner::InitCombinerCycleFill();
}
void COGLFragmentShaderCombiner::InitCombinerBlenderForSimpleTextureDraw(uint32 tile)
{
    COGLColorCombiner::InitCombinerBlenderForSimpleTextureDraw(tile);
}

#ifdef DEBUGGER
void COGLFragmentShaderCombiner::DisplaySimpleMuxString(void)
{
    COGLColorCombiner::DisplaySimpleMuxString();
}
#endif


COGL_FragmentProgramCombiner::COGL_FragmentProgramCombiner(CRender *pRender)
: COGLColorCombiner4(pRender)
{
    delete m_pDecodedMux;
    m_pDecodedMux = new DecodedMuxForPixelShader;
    m_bFragmentProgramIsSupported = false;
}
COGL_FragmentProgramCombiner::~COGL_FragmentProgramCombiner()
{
    int size = m_vCompiledShaders.size();
    for (int i=0; i<size; i++)
    {
        GLuint ID = m_vCompiledShaders[i].programID;
        pglDeleteProgramsARB(1, &ID);
        OPENGL_CHECK_ERRORS;
        m_vCompiledShaders[i].programID = 0;
    }

    m_vCompiledShaders.clear();
}

bool COGL_FragmentProgramCombiner::Initialize(void)
{
    if( !COGLColorCombiner4::Initialize() )
        return false;

    COGLGraphicsContext *pcontext = (COGLGraphicsContext *)(CGraphicsContext::g_pGraphicsContext);
    if( pcontext->IsExtensionSupported("GL_ARB_fragment_program") )
    {
        m_bFragmentProgramIsSupported = true;
    }

    return true;
}


void COGL_FragmentProgramCombiner::DisableCombiner(void)
{
    glDisable(GL_FRAGMENT_PROGRAM_ARB);
    OPENGL_CHECK_ERRORS;
    COGLColorCombiner4::DisableCombiner();
}

void COGL_FragmentProgramCombiner::InitCombinerCycleCopy(void)
{
    glDisable(GL_FRAGMENT_PROGRAM_ARB);
    OPENGL_CHECK_ERRORS;
    COGLColorCombiner4::InitCombinerCycleCopy();
}

void COGL_FragmentProgramCombiner::InitCombinerCycleFill(void)
{
    glDisable(GL_FRAGMENT_PROGRAM_ARB);
    OPENGL_CHECK_ERRORS;
    COGLColorCombiner4::InitCombinerCycleFill();
}

const char *muxToFP_Maps[][2] = {
//color -- alpha
{"0", "0"},                                //MUX_0 = 0,
{"1", "1"},                                //MUX_1,
{"comb", "comb.a"},                        //MUX_COMBINED,
{"t0", "t0.a"},                            //MUX_TEXEL0,
{"t1", "t1.a"},                            //MUX_TEXEL1,
{"program.env[2]", "program.env[2].a"},    //MUX_PRIM,
{"fragment.color", "fragment.color.a"},    //MUX_SHADE,
{"program.env[1]", "program.env[1].a"},    //MUX_ENV,
{"comb.a", "comb.a"},                      //MUX_COMBALPHA,
{"t0.a", "t0.a"},                          //MUX_T0_ALPHA,
{"t1.a", "t1.a"},                          //MUX_T1_ALPHA,
{"primcolor.a", "primcolor.a"},            //MUX_PRIM_ALPHA,
{"fragment.color.a", "fragment.color.a"},  //MUX_SHADE_ALPHA,
{"envcolor.a", "envcolor.a"},              //MUX_ENV_ALPHA,
{"program.env[3]", "program.env[3]"},      //MUX_LODFRAC,
{"program.env[4]", "program.env[4]"},      //MUX_PRIMLODFRAC,
{"1", "1"},                                //MUX_K5,
{"1", "1"},                                //MUX_UNK,  // Should not be used
};


const char *oglFPTest = 
"!!ARBfp1.0\n"
"#Declarations\n"
"TEMP t0;\n"
"TEMP t1;\n"
"TEMP comb;\n"
"TEMP comb2;\n"
"\n"
"ATTRIB coord0 = fragment.texcoord[0];\n"
"ATTRIB coord1 = fragment.texcoord[1];\n"
"ATTRIB shade = fragment.color;\n"
"ATTRIB fogfactor = fragment.fogcoord;\n"
"\n"
"OUTPUT out = result.color;\n"
"\n"
"#Instructions\n"
"TEX t0, coord0, texture[0], 2D;\n"
"TEX t1, coord1, texture[1], 2D;\n"
"\n"
"MAD_SAT out, t0, program.env[1],program.env[0];\n"
//"SUB comb.rgb,    t0, 0;\n"
//"MAD_SAT out.rgb, comb, program.env[1], 0;\n"
//"SUB comb.a,      t0, 0;\n"
//"MAD_SAT out.a,   comb, program.env[1], 0;\n"
"END\n";

char oglNewFP[4092];

char* MuxToOC(uint8 val)
{
// For color channel
if( val&MUX_ALPHAREPLICATE )
    return (char*)muxToFP_Maps[val&0x1F][1];
else
    return (char*)muxToFP_Maps[val&0x1F][0];
}

char* MuxToOA(uint8 val)
{
// For alpha channel
return (char*)muxToFP_Maps[val&0x1F][0];
}

static void CheckFpVars(uint8 MuxVar, bool &bNeedT0, bool &bNeedT1)
{
    MuxVar &= 0x1f;
    if (MuxVar == MUX_TEXEL0 || MuxVar == MUX_T0_ALPHA)
        bNeedT0 = true;
    if (MuxVar == MUX_TEXEL1 || MuxVar == MUX_T1_ALPHA)
        bNeedT1 = true;
}

void COGL_FragmentProgramCombiner::GenerateProgramStr()
{
    DecodedMuxForPixelShader &mux = *(DecodedMuxForPixelShader*)m_pDecodedMux;

    mux.splitType[0] = mux.splitType[1] = mux.splitType[2] = mux.splitType[3] = CM_FMT_TYPE_NOT_CHECKED;
    m_pDecodedMux->Reformat(false);

    char tempstr[500], newFPBody[4092];
    bool bNeedT0 = false, bNeedT1 = false, bNeedComb2 = false;
    newFPBody[0] = 0;

    for( int cycle=0; cycle<2; cycle++ )
    {
        for( int channel=0; channel<2; channel++)
        {
            char* (*func)(uint8) = channel==0?MuxToOC:MuxToOA;
            char *dst = channel==0?(char*)"rgb":(char*)"a";
            N64CombinerType &m = mux.m_n64Combiners[cycle*2+channel];
            switch( mux.splitType[cycle*2+channel] )
            {
            case CM_FMT_TYPE_NOT_USED:
                tempstr[0] = 0;
                break;
            case CM_FMT_TYPE_D:
                sprintf(tempstr, "MOV comb.%s, %s;\n", dst, func(m.d));
                CheckFpVars(m.d, bNeedT0, bNeedT1);
                break;
            case CM_FMT_TYPE_A_MOD_C:
                sprintf(tempstr, "MUL comb.%s, %s, %s;\n", dst, func(m.a), func(m.c));
                CheckFpVars(m.a, bNeedT0, bNeedT1);
                CheckFpVars(m.c, bNeedT0, bNeedT1);
                break;
            case CM_FMT_TYPE_A_ADD_D:
                sprintf(tempstr, "ADD_SAT comb.%s, %s, %s;\n", dst, func(m.a), func(m.d));
                CheckFpVars(m.a, bNeedT0, bNeedT1);
                CheckFpVars(m.d, bNeedT0, bNeedT1);
                break;
            case CM_FMT_TYPE_A_SUB_B:
                sprintf(tempstr, "SUB comb.%s, %s, %s;\n", dst, func(m.a), func(m.b));
                CheckFpVars(m.a, bNeedT0, bNeedT1);
                CheckFpVars(m.b, bNeedT0, bNeedT1);
                break;
            case CM_FMT_TYPE_A_MOD_C_ADD_D:
                sprintf(tempstr, "MAD_SAT comb.%s, %s, %s, %s;\n", dst, func(m.a), func(m.c), func(m.d));
                CheckFpVars(m.a, bNeedT0, bNeedT1);
                CheckFpVars(m.c, bNeedT0, bNeedT1);
                CheckFpVars(m.d, bNeedT0, bNeedT1);
                break;
            case CM_FMT_TYPE_A_LERP_B_C:
                sprintf(tempstr, "LRP_SAT comb.%s, %s, %s, %s;\n", dst, func(m.c), func(m.a), func(m.b));
                CheckFpVars(m.a, bNeedT0, bNeedT1);
                CheckFpVars(m.b, bNeedT0, bNeedT1);
                CheckFpVars(m.c, bNeedT0, bNeedT1);
                //sprintf(tempstr, "SUB comb.%s, %s, %s;\nMAD_SAT comb.%s, comb, %s, %s;\n", dst, func(m.a), func(m.b), dst, func(m.c), func(m.b));
                break;
            default:
                sprintf(tempstr, "SUB comb2.%s, %s, %s;\nMAD_SAT comb.%s, comb2, %s, %s;\n", dst, func(m.a), func(m.b), dst, func(m.c), func(m.d));
                CheckFpVars(m.a, bNeedT0, bNeedT1);
                CheckFpVars(m.b, bNeedT0, bNeedT1);
                CheckFpVars(m.c, bNeedT0, bNeedT1);
                CheckFpVars(m.d, bNeedT0, bNeedT1);
                bNeedComb2 = true;
                break;
            }
            strcat(newFPBody, tempstr);
        }
    }

    strcpy(oglNewFP, "!!ARBfp1.0\n");
    strcat(oglNewFP, "#Declarations\n");
    if (gRDP.bFogEnableInBlender && gRSP.bFogEnabled)
        strcat(oglNewFP, "OPTION ARB_fog_linear;\n");
    if (bNeedT0)
        strcat(oglNewFP, "TEMP t0;\n");
    if (bNeedT1)
        strcat(oglNewFP, "TEMP t1;\n");
    strcat(oglNewFP, "TEMP comb;\n");
    if (bNeedComb2)
        strcat(oglNewFP, "TEMP comb2;\n");
    strcat(oglNewFP, "#Instructions\n");
    if (bNeedT0)
        strcat(oglNewFP, "TEX t0, fragment.texcoord[0], texture[0], 2D;\n");
    if (bNeedT1)
        strcat(oglNewFP, "TEX t1, fragment.texcoord[1], texture[1], 2D;\n");
    strcat(oglNewFP, "# N64 cycle 1, result is in comb\n");

    strcat(oglNewFP, newFPBody);

    strcat(oglNewFP, "MOV result.color, comb;\n");
    strcat(oglNewFP, "END\n\n");
}

int COGL_FragmentProgramCombiner::ParseDecodedMux()
{
    if( !m_bFragmentProgramIsSupported )
        return COGLColorCombiner4::ParseDecodedMux();

    OGLShaderCombinerSaveType res;

    pglGenProgramsARB( 1, &res.programID);
    OPENGL_CHECK_ERRORS;
    pglBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, res.programID);
    OPENGL_CHECK_ERRORS;
    GenerateProgramStr();

    pglProgramStringARB( GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(oglNewFP), oglNewFP);
    OPENGL_CHECK_ERRORS;
    //pglProgramStringARB(   GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(oglFPTest), oglFPTest);

    if (glGetError() != 0)
    {
        GLint position;
#ifdef DEBUGGER
        char *str = (char*)glGetString(GL_PROGRAM_ERROR_STRING_ARB);
#endif
        glGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB, &position);
        if( position >= 0 )
        {
#ifdef DEBUGGER
            if( m_lastIndex >= 0 ) COGLColorCombiner4::DisplaySimpleMuxString();
            DebugMessage(M64MSG_ERROR, "%s - %s", str, oglNewFP+position);
#endif
            glDisable(GL_FRAGMENT_PROGRAM_ARB);
            return COGLColorCombiner4::ParseDecodedMux();
        }
    }

    glEnable(GL_FRAGMENT_PROGRAM_ARB);
    OPENGL_CHECK_ERRORS;
    res.dwMux0 = m_pDecodedMux->m_dwMux0;
    res.dwMux1 = m_pDecodedMux->m_dwMux1;
    res.fogIsUsed = gRDP.bFogEnableInBlender && gRSP.bFogEnabled;

    m_vCompiledShaders.push_back(res);
    m_lastIndex = m_vCompiledShaders.size()-1;

    return m_lastIndex;
}

void COGL_FragmentProgramCombiner::GenerateCombinerSetting(int index)
{
    GLuint ID = m_vCompiledShaders[index].programID;
    pglBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, ID );
    OPENGL_CHECK_ERRORS;
    glEnable(GL_FRAGMENT_PROGRAM_ARB);
    OPENGL_CHECK_ERRORS;
}

void COGL_FragmentProgramCombiner::GenerateCombinerSettingConstants(int index)
{
    float *pf;
    pf = GetEnvColorfv();
    pglProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, 1, pf);
    OPENGL_CHECK_ERRORS;
    pf = GetPrimitiveColorfv();
    pglProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, 2, pf);
    OPENGL_CHECK_ERRORS;

    float frac = gRDP.LODFrac / 255.0f;
    float tempf[4] = {frac,frac,frac,frac};
    pglProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, 3, tempf);
    OPENGL_CHECK_ERRORS;

    float frac2 = gRDP.primLODFrac / 255.0f;
    float tempf2[4] = {frac2,frac2,frac2,frac2};
    pglProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, 4, tempf2);
    OPENGL_CHECK_ERRORS;

    float tempf3[4] = {0,0,0,0};
    pglProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, 0, tempf3);
    OPENGL_CHECK_ERRORS;
    pglProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, 6, tempf3);
    OPENGL_CHECK_ERRORS;
}

int COGL_FragmentProgramCombiner::FindCompiledMux()
{
#ifdef DEBUGGER
    if( debuggerDropCombiners )
    {
        m_vCompiledShaders.clear();
        //m_dwLastMux0 = m_dwLastMux1 = 0;
        debuggerDropCombiners = false;
    }
#endif
    for( uint32 i=0; i<m_vCompiledShaders.size(); i++ )
    {
        if( m_vCompiledShaders[i].dwMux0 == m_pDecodedMux->m_dwMux0 
            && m_vCompiledShaders[i].dwMux1 == m_pDecodedMux->m_dwMux1 
            && m_vCompiledShaders[i].fogIsUsed == (gRDP.bFogEnableInBlender && gRSP.bFogEnabled) )
            return (int)i;
    }

    return -1;
}

//////////////////////////////////////////////////////////////////////////
void COGL_FragmentProgramCombiner::InitCombinerCycle12(void)
{
    if( !m_bFragmentProgramIsSupported )    
    {
        COGLColorCombiner4::InitCombinerCycle12();
        return;
    }

#ifdef DEBUGGER
    if( debuggerDropCombiners )
    {
        UpdateCombiner(m_pDecodedMux->m_dwMux0,m_pDecodedMux->m_dwMux1);
        m_vCompiledShaders.clear();
        m_dwLastMux0 = m_dwLastMux1 = 0;
        debuggerDropCombiners = false;
    }
#endif

    m_pOGLRender->EnableMultiTexture();

    bool combinerIsChanged = false;

    if( m_pDecodedMux->m_dwMux0 != m_dwLastMux0 || m_pDecodedMux->m_dwMux1 != m_dwLastMux1 || m_lastIndex < 0 )
    {
        combinerIsChanged = true;
        m_lastIndex = FindCompiledMux();
        if( m_lastIndex < 0 )       // Can not found
        {
            m_lastIndex = ParseDecodedMux();
        }

        m_dwLastMux0 = m_pDecodedMux->m_dwMux0;
        m_dwLastMux1 = m_pDecodedMux->m_dwMux1;
    }


    GenerateCombinerSettingConstants(m_lastIndex);
    if( m_bCycleChanged || combinerIsChanged || gRDP.texturesAreReloaded || gRDP.colorsAreReloaded )
    {
        if( m_bCycleChanged || combinerIsChanged )
        {
            GenerateCombinerSettingConstants(m_lastIndex);
            GenerateCombinerSetting(m_lastIndex);
        }
        else if( gRDP.colorsAreReloaded )
        {
            GenerateCombinerSettingConstants(m_lastIndex);
        }

        m_pOGLRender->SetAllTexelRepeatFlag();

        gRDP.colorsAreReloaded = false;
        gRDP.texturesAreReloaded = false;
    }
    else
    {
        m_pOGLRender->SetAllTexelRepeatFlag();
    }
}

#ifdef DEBUGGER
void COGL_FragmentProgramCombiner::DisplaySimpleMuxString(void)
{
    COGLColorCombiner::DisplaySimpleMuxString();
    DecodedMuxForPixelShader &mux = *(DecodedMuxForPixelShader*)m_pDecodedMux;
    mux.Reformat(false);
    GenerateProgramStr();
    //sprintf(oglNewFP, oglFP, 
    //  MuxToOC(mux.aRGB0), MuxToOC(mux.bRGB0), MuxToOC(mux.cRGB0), MuxToOC(mux.dRGB0),
    //  MuxToOA(mux.aA0), MuxToOA(mux.bA0), MuxToOA(mux.cA0), MuxToOA(mux.dA0),
    //  MuxToOC(mux.aRGB1), MuxToOC(mux.bRGB1), MuxToOC(mux.cRGB1), MuxToOC(mux.dRGB1),
    //  MuxToOA(mux.aA1), MuxToOA(mux.bA1), MuxToOA(mux.cA1), MuxToOA(mux.dA1)
    //  );

    TRACE0("OGL Fragment Program:");
    TRACE0(oglNewFP);
}
#endif
Commit	Line	Data
d07c171f	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 "OGLExtensions.h"
	20	#include "OGLDebug.h"
	21	#include "OGLFragmentShaders.h"
	22	#include "OGLRender.h"
	23	#include "OGLGraphicsContext.h"
	24
	25	COGLFragmentShaderCombiner::COGLFragmentShaderCombiner(CRender *pRender)
	26	: COGLColorCombiner(pRender)
	27	{
	28	m_bShaderIsSupported = false;
	29	}
	30	COGLFragmentShaderCombiner::~COGLFragmentShaderCombiner()
	31	{
	32	}
	33
	34	bool COGLFragmentShaderCombiner::Initialize(void)
	35	{
	36	if( !COGLColorCombiner::Initialize() )
	37	return false;
	38
	39	COGLGraphicsContext pcontext = (COGLGraphicsContext )(CGraphicsContext::g_pGraphicsContext);
	40	if( pcontext->IsExtensionSupported("GL_ARB_fragment_shader") )
	41	{
	42	m_bShaderIsSupported = true;
	43	}
	44
	45	return true;
	46	}
	47
	48	void COGLFragmentShaderCombiner::InitCombinerCycle12(void)
	49	{
	50	}
	51	void COGLFragmentShaderCombiner::DisableCombiner(void)
	52	{
	53	COGLColorCombiner::DisableCombiner();
	54	}
	55
	56	void COGLFragmentShaderCombiner::InitCombinerCycleCopy(void)
	57	{
	58	COGLColorCombiner::InitCombinerCycleCopy();
	59	}
	60
	61	void COGLFragmentShaderCombiner::InitCombinerCycleFill(void)
	62	{
	63	COGLColorCombiner::InitCombinerCycleFill();
	64	}
65	void COGLFragmentShaderCombiner::InitCombinerBlenderForSimpleTextureDraw(uint32 tile)
66	{
67	COGLColorCombiner::InitCombinerBlenderForSimpleTextureDraw(tile);
68	}
69
70	#ifdef DEBUGGER
71	void COGLFragmentShaderCombiner::DisplaySimpleMuxString(void)
72	{
73	COGLColorCombiner::DisplaySimpleMuxString();
74	}
75	#endif
76
77
78
79	COGL_FragmentProgramCombiner::COGL_FragmentProgramCombiner(CRender *pRender)
80	: COGLColorCombiner4(pRender)
81	{
82	delete m_pDecodedMux;
83	m_pDecodedMux = new DecodedMuxForPixelShader;
84	m_bFragmentProgramIsSupported = false;
85	}
86	COGL_FragmentProgramCombiner::~COGL_FragmentProgramCombiner()
87	{
88	int size = m_vCompiledShaders.size();
89	for (int i=0; i<size; i++)
90	{
91	GLuint ID = m_vCompiledShaders[i].programID;
92	pglDeleteProgramsARB(1, &ID);
93	OPENGL_CHECK_ERRORS;
94	m_vCompiledShaders[i].programID = 0;
95	}
96
97	m_vCompiledShaders.clear();
98	}
99
100	bool COGL_FragmentProgramCombiner::Initialize(void)
101	{
102	if( !COGLColorCombiner4::Initialize() )
103	return false;
104
105	COGLGraphicsContext pcontext = (COGLGraphicsContext )(CGraphicsContext::g_pGraphicsContext);
106	if( pcontext->IsExtensionSupported("GL_ARB_fragment_program") )
107	{
108	m_bFragmentProgramIsSupported = true;
109	}
110
111	return true;
112	}
113
114
115
116	void COGL_FragmentProgramCombiner::DisableCombiner(void)
117	{
118	glDisable(GL_FRAGMENT_PROGRAM_ARB);
119	OPENGL_CHECK_ERRORS;
120	COGLColorCombiner4::DisableCombiner();
121	}
122
123	void COGL_FragmentProgramCombiner::InitCombinerCycleCopy(void)
124	{
125	glDisable(GL_FRAGMENT_PROGRAM_ARB);
126	OPENGL_CHECK_ERRORS;
127	COGLColorCombiner4::InitCombinerCycleCopy();
128	}
129
130	void COGL_FragmentProgramCombiner::InitCombinerCycleFill(void)
131	{
132	glDisable(GL_FRAGMENT_PROGRAM_ARB);
133	OPENGL_CHECK_ERRORS;
134	COGLColorCombiner4::InitCombinerCycleFill();
135	}
136
137	const char *muxToFP_Maps[][2] = {
138	//color -- alpha
139	{"0", "0"}, //MUX_0 = 0,
140	{"1", "1"}, //MUX_1,
141	{"comb", "comb.a"}, //MUX_COMBINED,
142	{"t0", "t0.a"}, //MUX_TEXEL0,
143	{"t1", "t1.a"}, //MUX_TEXEL1,
144	{"program.env[2]", "program.env[2].a"}, //MUX_PRIM,
145	{"fragment.color", "fragment.color.a"}, //MUX_SHADE,
146	{"program.env[1]", "program.env[1].a"}, //MUX_ENV,
147	{"comb.a", "comb.a"}, //MUX_COMBALPHA,
148	{"t0.a", "t0.a"}, //MUX_T0_ALPHA,
149	{"t1.a", "t1.a"}, //MUX_T1_ALPHA,
150	{"primcolor.a", "primcolor.a"}, //MUX_PRIM_ALPHA,
151	{"fragment.color.a", "fragment.color.a"}, //MUX_SHADE_ALPHA,
152	{"envcolor.a", "envcolor.a"}, //MUX_ENV_ALPHA,
153	{"program.env[3]", "program.env[3]"}, //MUX_LODFRAC,
154	{"program.env[4]", "program.env[4]"}, //MUX_PRIMLODFRAC,
155	{"1", "1"}, //MUX_K5,
156	{"1", "1"}, //MUX_UNK, // Should not be used
157	};
158
159
160	const char *oglFPTest =
161	"!!ARBfp1.0\n"
162	"#Declarations\n"
163	"TEMP t0;\n"
164	"TEMP t1;\n"
165	"TEMP comb;\n"
166	"TEMP comb2;\n"
167	"\n"
168	"ATTRIB coord0 = fragment.texcoord[0];\n"
169	"ATTRIB coord1 = fragment.texcoord[1];\n"
170	"ATTRIB shade = fragment.color;\n"
171	"ATTRIB fogfactor = fragment.fogcoord;\n"
172	"\n"
173	"OUTPUT out = result.color;\n"
174	"\n"
175	"#Instructions\n"
176	"TEX t0, coord0, texture[0], 2D;\n"
177	"TEX t1, coord1, texture[1], 2D;\n"
178	"\n"
179	"MAD_SAT out, t0, program.env[1],program.env[0];\n"
180	//"SUB comb.rgb, t0, 0;\n"
181	//"MAD_SAT out.rgb, comb, program.env[1], 0;\n"
182	//"SUB comb.a, t0, 0;\n"
183	//"MAD_SAT out.a, comb, program.env[1], 0;\n"
184	"END\n";
185
186	char oglNewFP[4092];
187
188	char* MuxToOC(uint8 val)
189	{
190	// For color channel
191	if( val&MUX_ALPHAREPLICATE )
192	return (char*)muxToFP_Maps[val&0x1F][1];
193	else
194	return (char*)muxToFP_Maps[val&0x1F][0];
195	}
196
197	char* MuxToOA(uint8 val)
198	{
199	// For alpha channel
200	return (char*)muxToFP_Maps[val&0x1F][0];
201	}
202
203	static void CheckFpVars(uint8 MuxVar, bool &bNeedT0, bool &bNeedT1)
204	{
205	MuxVar &= 0x1f;
206	if (MuxVar == MUX_TEXEL0 \|\| MuxVar == MUX_T0_ALPHA)
207	bNeedT0 = true;
208	if (MuxVar == MUX_TEXEL1 \|\| MuxVar == MUX_T1_ALPHA)
209	bNeedT1 = true;
210	}
211
212	void COGL_FragmentProgramCombiner::GenerateProgramStr()
213	{
214	DecodedMuxForPixelShader &mux = (DecodedMuxForPixelShader)m_pDecodedMux;
215
216	mux.splitType[0] = mux.splitType[1] = mux.splitType[2] = mux.splitType[3] = CM_FMT_TYPE_NOT_CHECKED;
217	m_pDecodedMux->Reformat(false);
218
219	char tempstr[500], newFPBody[4092];
220	bool bNeedT0 = false, bNeedT1 = false, bNeedComb2 = false;
221	newFPBody[0] = 0;
222
223	for( int cycle=0; cycle<2; cycle++ )
224	{
225	for( int channel=0; channel<2; channel++)
226	{
227	char* (*func)(uint8) = channel==0?MuxToOC:MuxToOA;
228	char dst = channel==0?(char)"rgb":(char*)"a";
229	N64CombinerType &m = mux.m_n64Combiners[cycle*2+channel];
230	switch( mux.splitType[cycle*2+channel] )
231	{
232	case CM_FMT_TYPE_NOT_USED:
233	tempstr[0] = 0;
234	break;
235	case CM_FMT_TYPE_D:
236	sprintf(tempstr, "MOV comb.%s, %s;\n", dst, func(m.d));
237	CheckFpVars(m.d, bNeedT0, bNeedT1);
238	break;
239	case CM_FMT_TYPE_A_MOD_C:
240	sprintf(tempstr, "MUL comb.%s, %s, %s;\n", dst, func(m.a), func(m.c));
241	CheckFpVars(m.a, bNeedT0, bNeedT1);
242	CheckFpVars(m.c, bNeedT0, bNeedT1);
243	break;
244	case CM_FMT_TYPE_A_ADD_D:
245	sprintf(tempstr, "ADD_SAT comb.%s, %s, %s;\n", dst, func(m.a), func(m.d));
246	CheckFpVars(m.a, bNeedT0, bNeedT1);
247	CheckFpVars(m.d, bNeedT0, bNeedT1);
248	break;
249	case CM_FMT_TYPE_A_SUB_B:
250	sprintf(tempstr, "SUB comb.%s, %s, %s;\n", dst, func(m.a), func(m.b));
251	CheckFpVars(m.a, bNeedT0, bNeedT1);
252	CheckFpVars(m.b, bNeedT0, bNeedT1);
253	break;
254	case CM_FMT_TYPE_A_MOD_C_ADD_D:
255	sprintf(tempstr, "MAD_SAT comb.%s, %s, %s, %s;\n", dst, func(m.a), func(m.c), func(m.d));
256	CheckFpVars(m.a, bNeedT0, bNeedT1);
257	CheckFpVars(m.c, bNeedT0, bNeedT1);
258	CheckFpVars(m.d, bNeedT0, bNeedT1);
259	break;
260	case CM_FMT_TYPE_A_LERP_B_C:
261	sprintf(tempstr, "LRP_SAT comb.%s, %s, %s, %s;\n", dst, func(m.c), func(m.a), func(m.b));
262	CheckFpVars(m.a, bNeedT0, bNeedT1);
263	CheckFpVars(m.b, bNeedT0, bNeedT1);
264	CheckFpVars(m.c, bNeedT0, bNeedT1);
265	//sprintf(tempstr, "SUB comb.%s, %s, %s;\nMAD_SAT comb.%s, comb, %s, %s;\n", dst, func(m.a), func(m.b), dst, func(m.c), func(m.b));
266	break;
267	default:
268	sprintf(tempstr, "SUB comb2.%s, %s, %s;\nMAD_SAT comb.%s, comb2, %s, %s;\n", dst, func(m.a), func(m.b), dst, func(m.c), func(m.d));
269	CheckFpVars(m.a, bNeedT0, bNeedT1);
270	CheckFpVars(m.b, bNeedT0, bNeedT1);
271	CheckFpVars(m.c, bNeedT0, bNeedT1);
272	CheckFpVars(m.d, bNeedT0, bNeedT1);
273	bNeedComb2 = true;
274	break;
275	}
276	strcat(newFPBody, tempstr);
277	}
278	}
279
280	strcpy(oglNewFP, "!!ARBfp1.0\n");
281	strcat(oglNewFP, "#Declarations\n");
282	if (gRDP.bFogEnableInBlender && gRSP.bFogEnabled)
283	strcat(oglNewFP, "OPTION ARB_fog_linear;\n");
284	if (bNeedT0)
285	strcat(oglNewFP, "TEMP t0;\n");
286	if (bNeedT1)
287	strcat(oglNewFP, "TEMP t1;\n");
288	strcat(oglNewFP, "TEMP comb;\n");
289	if (bNeedComb2)
290	strcat(oglNewFP, "TEMP comb2;\n");
291	strcat(oglNewFP, "#Instructions\n");
292	if (bNeedT0)
293	strcat(oglNewFP, "TEX t0, fragment.texcoord[0], texture[0], 2D;\n");
294	if (bNeedT1)
295	strcat(oglNewFP, "TEX t1, fragment.texcoord[1], texture[1], 2D;\n");
296	strcat(oglNewFP, "# N64 cycle 1, result is in comb\n");
297
298	strcat(oglNewFP, newFPBody);
299
300	strcat(oglNewFP, "MOV result.color, comb;\n");
301	strcat(oglNewFP, "END\n\n");
302	}
303
304	int COGL_FragmentProgramCombiner::ParseDecodedMux()
305	{
306	if( !m_bFragmentProgramIsSupported )
307	return COGLColorCombiner4::ParseDecodedMux();
308
309	OGLShaderCombinerSaveType res;
310
311	pglGenProgramsARB( 1, &res.programID);
312	OPENGL_CHECK_ERRORS;
313	pglBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, res.programID);
314	OPENGL_CHECK_ERRORS;
315	GenerateProgramStr();
316
317	pglProgramStringARB( GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(oglNewFP), oglNewFP);
318	OPENGL_CHECK_ERRORS;
319	//pglProgramStringARB( GL_FRAGMENT_PROGRAM_ARB, GL_PROGRAM_FORMAT_ASCII_ARB, strlen(oglFPTest), oglFPTest);
320
321	if (glGetError() != 0)
322	{
323	GLint position;
324	#ifdef DEBUGGER
325	char str = (char)glGetString(GL_PROGRAM_ERROR_STRING_ARB);
326	#endif
327	glGetIntegerv( GL_PROGRAM_ERROR_POSITION_ARB, &position);
328	if( position >= 0 )
329	{
330	#ifdef DEBUGGER
331	if( m_lastIndex >= 0 ) COGLColorCombiner4::DisplaySimpleMuxString();
332	DebugMessage(M64MSG_ERROR, "%s - %s", str, oglNewFP+position);
333	#endif
334	glDisable(GL_FRAGMENT_PROGRAM_ARB);
335	return COGLColorCombiner4::ParseDecodedMux();
336	}
337	}
338
339	glEnable(GL_FRAGMENT_PROGRAM_ARB);
340	OPENGL_CHECK_ERRORS;
341	res.dwMux0 = m_pDecodedMux->m_dwMux0;
342	res.dwMux1 = m_pDecodedMux->m_dwMux1;
343	res.fogIsUsed = gRDP.bFogEnableInBlender && gRSP.bFogEnabled;
344
345	m_vCompiledShaders.push_back(res);
346	m_lastIndex = m_vCompiledShaders.size()-1;
347
348	return m_lastIndex;
349	}
350
351	void COGL_FragmentProgramCombiner::GenerateCombinerSetting(int index)
352	{
353	GLuint ID = m_vCompiledShaders[index].programID;
354	pglBindProgramARB( GL_FRAGMENT_PROGRAM_ARB, ID );
355	OPENGL_CHECK_ERRORS;
356	glEnable(GL_FRAGMENT_PROGRAM_ARB);
357	OPENGL_CHECK_ERRORS;
358	}
359
360	void COGL_FragmentProgramCombiner::GenerateCombinerSettingConstants(int index)
361	{
362	float *pf;
363	pf = GetEnvColorfv();
364	pglProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, 1, pf);
365	OPENGL_CHECK_ERRORS;
366	pf = GetPrimitiveColorfv();
367	pglProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, 2, pf);
368	OPENGL_CHECK_ERRORS;
369
370	float frac = gRDP.LODFrac / 255.0f;
371	float tempf[4] = {frac,frac,frac,frac};
372	pglProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, 3, tempf);
373	OPENGL_CHECK_ERRORS;
374
375	float frac2 = gRDP.primLODFrac / 255.0f;
376	float tempf2[4] = {frac2,frac2,frac2,frac2};
377	pglProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, 4, tempf2);
378	OPENGL_CHECK_ERRORS;
379
380	float tempf3[4] = {0,0,0,0};
381	pglProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, 0, tempf3);
382	OPENGL_CHECK_ERRORS;
383	pglProgramEnvParameter4fvARB(GL_FRAGMENT_PROGRAM_ARB, 6, tempf3);
384	OPENGL_CHECK_ERRORS;
385	}
386
387	int COGL_FragmentProgramCombiner::FindCompiledMux()
388	{
389	#ifdef DEBUGGER
390	if( debuggerDropCombiners )
391	{
392	m_vCompiledShaders.clear();
393	//m_dwLastMux0 = m_dwLastMux1 = 0;
394	debuggerDropCombiners = false;
395	}
396	#endif
397	for( uint32 i=0; i<m_vCompiledShaders.size(); i++ )
398	{
399	if( m_vCompiledShaders[i].dwMux0 == m_pDecodedMux->m_dwMux0
400	&& m_vCompiledShaders[i].dwMux1 == m_pDecodedMux->m_dwMux1
401	&& m_vCompiledShaders[i].fogIsUsed == (gRDP.bFogEnableInBlender && gRSP.bFogEnabled) )
402	return (int)i;
403	}
404
405	return -1;
406	}
407
408	//////////////////////////////////////////////////////////////////////////
409	void COGL_FragmentProgramCombiner::InitCombinerCycle12(void)
410	{
411	if( !m_bFragmentProgramIsSupported )
412	{
413	COGLColorCombiner4::InitCombinerCycle12();
414	return;
415	}
416
417	#ifdef DEBUGGER
418	if( debuggerDropCombiners )
419	{
420	UpdateCombiner(m_pDecodedMux->m_dwMux0,m_pDecodedMux->m_dwMux1);
421	m_vCompiledShaders.clear();
422	m_dwLastMux0 = m_dwLastMux1 = 0;
423	debuggerDropCombiners = false;
424	}
425	#endif
426
427	m_pOGLRender->EnableMultiTexture();
428
429	bool combinerIsChanged = false;
430
431	if( m_pDecodedMux->m_dwMux0 != m_dwLastMux0 \|\| m_pDecodedMux->m_dwMux1 != m_dwLastMux1 \|\| m_lastIndex < 0 )
432	{
433	combinerIsChanged = true;
434	m_lastIndex = FindCompiledMux();
435	if( m_lastIndex < 0 ) // Can not found
436	{
437	m_lastIndex = ParseDecodedMux();
438	}
439
440	m_dwLastMux0 = m_pDecodedMux->m_dwMux0;
441	m_dwLastMux1 = m_pDecodedMux->m_dwMux1;
442	}
443
444
445	GenerateCombinerSettingConstants(m_lastIndex);
446	if( m_bCycleChanged \|\| combinerIsChanged \|\| gRDP.texturesAreReloaded \|\| gRDP.colorsAreReloaded )
447	{
448	if( m_bCycleChanged \|\| combinerIsChanged )
449	{
450	GenerateCombinerSettingConstants(m_lastIndex);
451	GenerateCombinerSetting(m_lastIndex);
452	}
453	else if( gRDP.colorsAreReloaded )
454	{
455	GenerateCombinerSettingConstants(m_lastIndex);
456	}
457
458	m_pOGLRender->SetAllTexelRepeatFlag();
459
460	gRDP.colorsAreReloaded = false;
461	gRDP.texturesAreReloaded = false;
462	}
463	else
464	{
465	m_pOGLRender->SetAllTexelRepeatFlag();
466	}
467	}
468
469	#ifdef DEBUGGER
470	void COGL_FragmentProgramCombiner::DisplaySimpleMuxString(void)
471	{
472	COGLColorCombiner::DisplaySimpleMuxString();
473	DecodedMuxForPixelShader &mux = (DecodedMuxForPixelShader)m_pDecodedMux;
474	mux.Reformat(false);
475	GenerateProgramStr();
476	//sprintf(oglNewFP, oglFP,
477	// MuxToOC(mux.aRGB0), MuxToOC(mux.bRGB0), MuxToOC(mux.cRGB0), MuxToOC(mux.dRGB0),
478	// MuxToOA(mux.aA0), MuxToOA(mux.bA0), MuxToOA(mux.cA0), MuxToOA(mux.dA0),
479	// MuxToOC(mux.aRGB1), MuxToOC(mux.bRGB1), MuxToOC(mux.cRGB1), MuxToOC(mux.dRGB1),
480	// MuxToOA(mux.aA1), MuxToOA(mux.bA1), MuxToOA(mux.cA1), MuxToOA(mux.dA1)
481	// );
482
483	TRACE0("OGL Fragment Program:");
484	TRACE0(oglNewFP);
485	}
486	#endif
487