Book a Demo!
CoCalc Logo Icon
StoreFeaturesDocsShareSupportNewsAboutPoliciesSign UpSign In
alexbevi
GitHub Repository: alexbevi/BizHawk
 Path: blob/master/libmupen64plus/mupen64plus-video-rice/src/OGLExtCombiner.cpp
2 views
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 <algorithm>

20
#include "osal_opengl.h"

21


22
#if SDL_VIDEO_OPENGL

23
#include "OGLExtensions.h"

24
#endif

25
#include "OGLDebug.h"

26
#include "OGLExtCombiner.h"

27
#include "OGLExtRender.h"

28
#include "OGLDecodedMux.h"

29
#include "OGLGraphicsContext.h"

30
#include "OGLTexture.h"

31
#include "DirectXDecodedMux.h"

32


33
#define GL_MODULATE_ADD_ATI        0x8744

34
#define GL_MODULATE_SUBTRACT_ATI   0x8746

35


36
//========================================================================

37
COGLColorCombiner4::COGLColorCombiner4(CRender *pRender)

38
        :COGLColorCombiner(pRender), m_maxTexUnits(0), m_lastIndex(-1),

39
        m_dwLastMux0(0), m_dwLastMux1(0)

40
{

41
    m_bOGLExtCombinerSupported=false;

42
    m_bSupportModAdd_ATI = false;

43
    m_bSupportModSub_ATI = false;

44
    delete m_pDecodedMux;

45
    m_pDecodedMux = new COGLExtDecodedMux;

46
}

47


48
COGLColorCombiner4v2::COGLColorCombiner4v2(CRender *pRender)

49
    :COGLColorCombiner4(pRender)

50
{

51
    delete m_pDecodedMux;

52
    m_pDecodedMux = new DecodedMuxForOGL14V2;

53
}

54


55
COGLColorCombiner2::COGLColorCombiner2(CRender *pRender)

56
        :COGLColorCombiner4(pRender)

57
{

58
    delete m_pDecodedMux;

59
    m_pDecodedMux = new CDirectXDecodedMux;     // Use Mux for DirectX because we support only 1 texture for each stage

60
    m_ppGeneralDecodedMux = &m_pDecodedMux;

61
}

62


63
//////////////////////////////////////////////////////////////////////////

64
bool COGLColorCombiner4::Initialize(void)

65
{

66
    m_bOGLExtCombinerSupported = false;

67
    m_bSupportModAdd_ATI = false;

68
    m_bSupportModSub_ATI = false;

69
    m_maxTexUnits = 1;

70


71
#if SDL_VIDEO_OPENGL

72
    if( COGLColorCombiner::Initialize() )

73
    {

74
        m_bSupportMultiTexture = true;

75
        COGLGraphicsContext *pcontext = (COGLGraphicsContext *)(CGraphicsContext::g_pGraphicsContext);

76


77
        if( pcontext->IsExtensionSupported("GL_EXT_texture_env_combine") || pcontext->IsExtensionSupported("GL_ARB_texture_env_combine") )

78
        {

79
            m_bOGLExtCombinerSupported = true;

80
            glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB,&m_maxTexUnits);

81
            OPENGL_CHECK_ERRORS;

82
            if( m_maxTexUnits > 8 ) m_maxTexUnits = 8;

83


84
            TRACE0("Starting Ogl 1.4 multitexture combiner" );

85
            TRACE1("m_maxTexUnits = %d", m_maxTexUnits);

86
            if( pcontext->IsExtensionSupported("ATI_texture_env_combine3") )

87
            {

88
                m_bSupportModAdd_ATI = true;

89
                m_bSupportModSub_ATI = true;

90
            }

91
        }

92
        else

93
        {

94
            DebugMessage(M64MSG_ERROR, "Your video card does not support OpenGL extension combiner, you can only use the basic OpenGL combiner functions");

95
        }

96
        m_supportedStages = m_maxTexUnits;

97
        return true;

98
    }

99
    return false;

100


101
#elif SDL_VIDEO_OPENGL_ES2

102
    return true;

103
#endif

104
}

105


106
bool COGLColorCombiner2::Initialize(void)

107
{

108
    TRACE0("Starting Ogl 1.2/1.3 multitexture combiner" );

109
    if( COGLColorCombiner4::Initialize() )

110
    {

111
        // For general combiner flags

112
        m_dwGeneralMaxStages = m_supportedStages;

113


114
        m_bTxtOpAdd = m_bSupportAdd;

115
        m_bTxtOpSub = m_bSupportSubtract;

116
        m_bTxtOpLerp = true;

117


118
        m_bTxtOpAddSmooth = true;

119
        m_bTxtOpBlendCurAlpha = true;

120
        m_bTxtOpBlendDifAlpha = true;

121
        m_bTxtOpBlendFacAlpha = true;

122
        m_bTxtOpBlendTxtAlpha = true;

123
        m_bTxtOpMulAdd = m_bSupportModAdd_ATI;

124


125
        return true;

126
    }

127
    else

128
    {

129
        return false;

130
    }

131
}

132
//========================================================================

133
void COGLColorCombiner4::InitCombinerCycleFill(void)

134
{

135
    for( int i=0; i<m_supportedStages; i++ )

136
    {

137
        pglActiveTexture(GL_TEXTURE0_ARB+i);

138
        OPENGL_CHECK_ERRORS;

139
        m_pOGLRender->EnableTexUnit(i,FALSE);

140
    }

141


142
    //pglActiveTexture(GL_TEXTURE0_ARB);

143
    //m_pOGLRender->EnableTexUnit(0,FALSE);

144
    //pglActiveTexture(GL_TEXTURE1_ARB);

145
    //m_pOGLRender->EnableTexUnit(1,FALSE);

146
}

147


148
//////////////////////////////////////////////////////////////////////////

149
void COGLColorCombiner4::InitCombinerCycle12(void)

150
{

151
    if( !m_bOGLExtCombinerSupported )   

152
    {

153
        COGLColorCombiner::InitCombinerCycle12();

154
        return;

155
    }

156


157
#ifdef DEBUGGER

158
    if( debuggerDropCombiners )

159
    {

160
        UpdateCombiner(m_pDecodedMux->m_dwMux0,m_pDecodedMux->m_dwMux1);

161
        m_vCompiledSettings.clear();

162
        m_dwLastMux0 = m_dwLastMux1 = 0;

163
        debuggerDropCombiners = false;

164
    }

165
#endif

166


167
    m_pOGLRender->EnableMultiTexture();

168


169
    bool combinerIsChanged = false;

170


171
    if( m_pDecodedMux->m_dwMux0 != m_dwLastMux0 || m_pDecodedMux->m_dwMux1 != m_dwLastMux1 || m_lastIndex < 0 )

172
    {

173
        combinerIsChanged = true;

174
        m_lastIndex = FindCompiledMux();

175
        if( m_lastIndex < 0 )       // Can not found

176
        {

177
            m_lastIndex = ParseDecodedMux();

178
#ifdef DEBUGGER

179
            DisplaySimpleMuxString();

180
#endif

181
        }

182


183
        m_dwLastMux0 = m_pDecodedMux->m_dwMux0;

184
        m_dwLastMux1 = m_pDecodedMux->m_dwMux1;

185
    }

186
    

187


188
    if( m_bCycleChanged || combinerIsChanged || gRDP.texturesAreReloaded || gRDP.colorsAreReloaded )

189
    {

190
        if( m_bCycleChanged || combinerIsChanged )

191
        {

192
            GenerateCombinerSettingConstants(m_lastIndex);

193
            GenerateCombinerSetting(m_lastIndex);

194
        }

195
        else if( gRDP.colorsAreReloaded )

196
        {

197
            GenerateCombinerSettingConstants(m_lastIndex);

198
        }

199


200
        m_pOGLRender->SetAllTexelRepeatFlag();

201


202
        gRDP.colorsAreReloaded = false;

203
        gRDP.texturesAreReloaded = false;

204
    }

205
    else

206
    {

207
        m_pOGLRender->SetAllTexelRepeatFlag();

208
    }

209
}

210


211
//////////////////////////////////////////////////////////////////////////

212
int COGLColorCombiner4::ParseDecodedMux()

213
{

214
#define nextUnit()  {unitNo++;}

215
#if SDL_VIDEO_OPENGL

216
    if( m_maxTexUnits<3) 

217
        return  ParseDecodedMux2Units();

218


219
    OGLExtCombinerSaveType res;

220
    for( int k=0; k<8; k++ )

221
        res.units[k].tex = -1;

222
    

223
    COGLDecodedMux &mux = *(COGLDecodedMux*)m_pDecodedMux;

224


225
    int unitNos[2];

226
    for( int rgbalpha = 0; rgbalpha<2; rgbalpha++ )

227
    {

228
        unitNos[rgbalpha] = 0;

229
        for( int cycle = 0; cycle<2; cycle++ )

230
        {

231
            int &unitNo = unitNos[rgbalpha];

232
            OGLExtCombinerType &unit = res.units[unitNo];

233
            OGLExt1CombType &comb = unit.Combs[rgbalpha];

234
            CombinerFormatType type = m_pDecodedMux->splitType[cycle*2+rgbalpha];

235
            N64CombinerType &m = m_pDecodedMux->m_n64Combiners[cycle*2+rgbalpha];

236
            comb.arg0 = comb.arg1 = comb.arg2 = CM_IGNORE_BYTE;

237


238
            switch( type )

239
            {

240
            case CM_FMT_TYPE_NOT_USED:

241
                comb.arg0 = MUX_COMBINED;

242
                unit.ops[rgbalpha] = GL_REPLACE;

243
                nextUnit();

244
                break;

245
            case CM_FMT_TYPE_D:                 // = A

246
                comb.arg0 = m.d;

247
                unit.ops[rgbalpha] = GL_REPLACE;

248
                nextUnit();

249
                break;

250
            case CM_FMT_TYPE_A_ADD_D:           // = A+D

251
                comb.arg0 = m.a;

252
                comb.arg1 = m.d;

253
                unit.ops[rgbalpha] = GL_ADD;

254
                nextUnit();

255
                break;

256
            case CM_FMT_TYPE_A_SUB_B:           // = A-B

257
                comb.arg0 = m.a;

258
                comb.arg1 = m.b;

259
                unit.ops[rgbalpha] = GL_SUBTRACT_ARB;

260
                nextUnit();

261
                break;

262
            case CM_FMT_TYPE_A_MOD_C:           // = A*C

263
                comb.arg0 = m.a;

264
                comb.arg1 = m.c;

265
                unit.ops[rgbalpha] = GL_MODULATE;

266
                nextUnit();

267
                break;

268
            case CM_FMT_TYPE_A_MOD_C_ADD_D:     // = A*C+D

269
                if( m_bSupportModAdd_ATI )

270
                {

271
                    comb.arg0 = m.a;

272
                    comb.arg2 = m.c;

273
                    comb.arg1 = m.d;

274
                    unit.ops[rgbalpha] = GL_MODULATE_ADD_ATI;

275
                    nextUnit();

276
                }

277
                else

278
                {

279
                    if( unitNo < m_maxTexUnits-1 )

280
                    {

281
                        comb.arg0 = m.a;

282
                        comb.arg1 = m.c;

283
                        unit.ops[rgbalpha] = GL_MODULATE;

284
                        nextUnit();

285
                        res.units[unitNo].Combs[rgbalpha].arg0 = MUX_COMBINED;

286
                        res.units[unitNo].Combs[rgbalpha].arg1 = m.d;

287
                        res.units[unitNo].ops[rgbalpha] = GL_ADD;

288
                        nextUnit();

289
                    }

290
                    else

291
                    {

292
                        comb.arg0 = m.a;

293
                        comb.arg1 = m.c;

294
                        comb.arg2 = m.d;

295
                        unit.ops[rgbalpha] = GL_INTERPOLATE_ARB;

296
                        nextUnit();

297
                    }

298
                }

299
                break;

300
            case CM_FMT_TYPE_A_LERP_B_C:        // = (A-B)*C+B

301
                comb.arg0 = m.a;

302
                comb.arg1 = m.b;

303
                comb.arg2 = m.c;

304
                unit.ops[rgbalpha] = GL_INTERPOLATE_ARB;

305
                nextUnit();

306
                break;

307
            case CM_FMT_TYPE_A_SUB_B_ADD_D:     // = A-B+D

308
                if( unitNo < m_maxTexUnits-1 )

309
                {

310
                    comb.arg0 = m.a;

311
                    comb.arg1 = m.b;

312
                    unit.ops[rgbalpha] = GL_SUBTRACT_ARB;

313
                    nextUnit();

314
                    res.units[unitNo].Combs[rgbalpha].arg0 = MUX_COMBINED;

315
                    res.units[unitNo].Combs[rgbalpha].arg1 = m.d;

316
                    res.units[unitNo].ops[rgbalpha] = GL_ADD;

317
                    nextUnit();

318
                }

319
                else

320
                {

321
                    comb.arg0 = m.a;

322
                    comb.arg1 = m.c;

323
                    comb.arg2 = m.d;

324
                    unit.ops[rgbalpha] = GL_INTERPOLATE_ARB;

325
                    nextUnit();

326
                }

327
                break;

328
            case CM_FMT_TYPE_A_SUB_B_MOD_C:     // = (A-B)*C

329
                if( unitNo < m_maxTexUnits-1 )

330
                {

331
                    comb.arg0 = m.a;

332
                    comb.arg1 = m.b;

333
                    unit.ops[rgbalpha] = GL_SUBTRACT_ARB;

334
                    nextUnit();

335
                    res.units[unitNo].Combs[rgbalpha].arg0 = MUX_COMBINED;

336
                    res.units[unitNo].Combs[rgbalpha].arg1 = m.c;

337
                    res.units[unitNo].ops[rgbalpha] = GL_MODULATE;

338
                    nextUnit();

339
                }

340
                else

341
                {

342
                    comb.arg0 = m.a;

343
                    comb.arg1 = m.c;

344
                    comb.arg2 = m.d;

345
                    unit.ops[rgbalpha] = GL_INTERPOLATE_ARB;

346
                    nextUnit();

347
                }

348
                break;

349
            case CM_FMT_TYPE_A_B_C_D:           // = (A-B)*C+D

350
            default:

351
                if( unitNo < m_maxTexUnits-1 )

352
                {

353
                    comb.arg0 = m.a;

354
                    comb.arg1 = m.b;

355
                    unit.ops[rgbalpha] = GL_SUBTRACT_ARB;

356
                    nextUnit();

357
                    if( m_bSupportModAdd_ATI )

358
                    {

359
                        res.units[unitNo].Combs[rgbalpha].arg0 = MUX_COMBINED;

360
                        res.units[unitNo].Combs[rgbalpha].arg2 = m.c;

361
                        res.units[unitNo].Combs[rgbalpha].arg1 = m.d;

362
                        res.units[unitNo].ops[rgbalpha] = GL_MODULATE_ADD_ATI;

363
                        nextUnit();

364
                    }

365
                    else

366
                    {

367
                        res.units[unitNo].Combs[rgbalpha].arg0 = m.a;

368
                        res.units[unitNo].Combs[rgbalpha].arg1 = m.b;

369
                        res.units[unitNo].Combs[rgbalpha].arg2 = m.c;

370
                        res.units[unitNo].ops[rgbalpha] = GL_INTERPOLATE_ARB;

371
                        nextUnit();

372
                    }

373
                }

374
                else

375
                {

376
                    comb.arg0 = m.a;

377
                    comb.arg1 = m.c;

378
                    comb.arg2 = m.d;

379
                    unit.ops[rgbalpha] = GL_INTERPOLATE_ARB;

380
                    nextUnit();

381
                }

382
                break;

383
            }

384
        }

385
    }

386
        

387
    res.numOfUnits = min(m_maxTexUnits, max(unitNos[0],unitNos[1]));

388


389
    if( unitNos[0]>m_maxTexUnits || unitNos[1]>m_maxTexUnits ) 

390
    {

391
        TRACE0("Unit overflows");

392
    }

393


394
    for( int j=0; j<2; j++ )

395
    {

396
        if( unitNos[j]<res.numOfUnits )

397
        {

398
            for( int i=unitNos[j]; i<res.numOfUnits; i++ )

399
            {

400
                res.units[i].Combs[j].arg0 = MUX_COMBINED;

401
                res.units[i].ops[j] = GL_REPLACE;

402
            }

403
        }

404
    }

405


406
    res.units[0].tex = 0;

407
    res.units[1].tex = 1;

408


409
    res.primIsUsed = mux.isUsed(MUX_PRIM);

410
    res.envIsUsed = mux.isUsed(MUX_ENV);

411
    res.lodFracIsUsed = mux.isUsed(MUX_LODFRAC) || mux.isUsed(MUX_PRIMLODFRAC);

412


413
    return SaveParsedResult(res);

414


415
#elif SDL_VIDEO_OPENGL_ES2

416
    return 0;

417
#endif

418
}

419


420
int COGLColorCombiner4::ParseDecodedMux2Units()

421
{

422
    OGLExtCombinerSaveType res;

423
    for( int k=0; k<8; k++ )

424
        res.units[k].tex = -1;

425


426
    res.numOfUnits = 2;

427


428
    for( int i=0; i<res.numOfUnits*2; i++ ) // Set combiner for each texture unit

429
    {

430
        // For each texture unit, set both RGB and Alpha channel

431
        // Keep in mind that the m_pDecodeMux has been reformated and simplified very well

432


433
        OGLExtCombinerType &unit = res.units[i/2];

434
        OGLExt1CombType &comb = unit.Combs[i%2];

435


436
        CombinerFormatType type = m_pDecodedMux->splitType[i];

437
        N64CombinerType &m = m_pDecodedMux->m_n64Combiners[i];

438


439
        comb.arg0 = comb.arg1 = comb.arg2 = MUX_0;

440


441
        switch( type )

442
        {

443
        case CM_FMT_TYPE_NOT_USED:

444
            comb.arg0 = MUX_COMBINED;

445
            unit.ops[i%2] = GL_REPLACE;

446
            break;

447
        case CM_FMT_TYPE_D:                 // = A

448
            comb.arg0 = m.d;

449
            unit.ops[i%2] = GL_REPLACE;

450
            break;

451
#if SDL_VIDEO_OPENGL

452
        case CM_FMT_TYPE_A_ADD_D:           // = A+D

453
            comb.arg0 = m.a;

454
            comb.arg1 = m.d;

455
            unit.ops[i%2] = GL_ADD;

456
            break;

457
        case CM_FMT_TYPE_A_SUB_B:           // = A-B

458
            comb.arg0 = m.a;

459
            comb.arg1 = m.b;

460
            unit.ops[i%2] = GL_SUBTRACT_ARB;

461
            break;

462
        case CM_FMT_TYPE_A_MOD_C:           // = A*C

463
            comb.arg0 = m.a;

464
            comb.arg1 = m.c;

465
            unit.ops[i%2] = GL_MODULATE;

466
            break;

467
        case CM_FMT_TYPE_A_MOD_C_ADD_D:     // = A*C+D

468
            comb.arg0 = m.a;

469
            comb.arg1 = m.c;

470
            comb.arg2 = m.d;

471
            unit.ops[i%2] = GL_INTERPOLATE_ARB;

472
            break;

473
        case CM_FMT_TYPE_A_LERP_B_C:        // = (A-B)*C+B

474
            comb.arg0 = m.a;

475
            comb.arg1 = m.b;

476
            comb.arg2 = m.c;

477
            unit.ops[i%2] = GL_INTERPOLATE_ARB;

478
            break;

479
        case CM_FMT_TYPE_A_SUB_B_ADD_D:     // = A-B+D

480
            // fix me, to use 2 texture units

481
            comb.arg0 = m.a;

482
            comb.arg1 = m.b;

483
            unit.ops[i%2] = GL_SUBTRACT_ARB;

484
            break;

485
        case CM_FMT_TYPE_A_SUB_B_MOD_C:     // = (A-B)*C

486
            // fix me, to use 2 texture units

487
            comb.arg0 = m.a;

488
            comb.arg1 = m.c;

489
            unit.ops[i%2] = GL_MODULATE;

490
            break;

491
            break;

492
        case CM_FMT_TYPE_A_B_C_D:           // = (A-B)*C+D

493
#endif

494
        default:

495
            comb.arg0 = m.a;

496
            comb.arg1 = m.b;

497
            comb.arg2 = m.c;

498
            unit.ops[i%2] = GL_INTERPOLATE_ARB;

499
            break;

500
        }

501
    }

502


503
    if( m_pDecodedMux->splitType[2] == CM_FMT_TYPE_NOT_USED && m_pDecodedMux->splitType[3] == CM_FMT_TYPE_NOT_USED && !m_bTex1Enabled )

504
    {

505
        res.numOfUnits = 1;

506
    }

507


508
    res.units[0].tex = 0;

509
    res.units[1].tex = 1;

510


511
    return SaveParsedResult(res);

512
}

513


514
const char* COGLColorCombiner4::GetOpStr(GLenum op)

515
{

516
    switch( op )

517
    {

518
    case GL_REPLACE:

519
        return "REPLACE";

520
#if SDL_VIDEO_OPENGL

521
    case GL_MODULATE:

522
        return "MOD";

523
    case GL_ADD:

524
        return "ADD";

525
    case GL_ADD_SIGNED_ARB:

526
        return "ADD_SIGNED";

527
    case GL_INTERPOLATE_ARB:

528
        return "INTERPOLATE";

529
    case GL_SUBTRACT_ARB:

530
        return "SUB";

531
#endif

532
    case GL_MODULATE_ADD_ATI:

533
        return "MULADD";

534
    default:

535
        return "SUB";

536
    }

537
}

538


539
int COGLColorCombiner4::SaveParsedResult(OGLExtCombinerSaveType &result)

540
{

541
    result.dwMux0 = m_pDecodedMux->m_dwMux0;

542
    result.dwMux1 = m_pDecodedMux->m_dwMux1;

543


544
    for( int n=0; n<result.numOfUnits; n++ )

545
    {

546
        for( int i=0; i<3; i++ )

547
        {

548
            result.units[n].glRGBArgs[i] = 0;

549
            result.units[n].glRGBFlags[i] = 0;

550
            result.units[n].glAlphaArgs[i] = 0;

551
            result.units[n].glAlphaFlags[i] = 0;

552
            if( result.units[n].rgbComb.args[i] != CM_IGNORE_BYTE )

553
            {

554
                result.units[n].glRGBArgs[i] = MapRGBArgs(result.units[n].rgbComb.args[i]);

555
                result.units[n].glRGBFlags[i] = MapRGBArgFlags(result.units[n].rgbComb.args[i]);

556
            }

557
            if( result.units[n].alphaComb.args[i] != CM_IGNORE_BYTE )

558
            {

559
                result.units[n].glAlphaArgs[i] = MapAlphaArgs(result.units[n].alphaComb.args[i]);

560
                result.units[n].glAlphaFlags[i] = MapAlphaArgFlags(result.units[n].alphaComb.args[i]);

561
            }

562
        }

563
    }

564


565
    m_vCompiledSettings.push_back(result);

566
    m_lastIndex = m_vCompiledSettings.size()-1;

567


568
#ifdef DEBUGGER

569
    if( logCombiners )

570
    {

571
        DisplaySimpleMuxString();

572
    }

573
#endif

574


575
    return m_lastIndex;

576
}

577


578
bool isGLtex(GLint val)

579
{

580
    if( val >= GL_TEXTURE0_ARB && val <= GL_TEXTURE7_ARB )

581
        return true;

582
    else

583
        return false;

584
}

585


586
int COGLColorCombiner4v2::SaveParsedResult(OGLExtCombinerSaveType &result)

587
{

588
    result.dwMux0 = m_pDecodedMux->m_dwMux0;

589
    result.dwMux1 = m_pDecodedMux->m_dwMux1;

590


591
    int n;

592


593
    for( n=0; n<result.numOfUnits; n++ )

594
    {

595
        for( int i=0; i<3; i++ )

596
        {

597
            result.units[n].glRGBArgs[i] = 0;

598
            result.units[n].glRGBFlags[i] = 0;

599
            result.units[n].glAlphaArgs[i] = 0;

600
            result.units[n].glAlphaFlags[i] = 0;

601
            if( result.units[n].rgbComb.args[i] != CM_IGNORE_BYTE )

602
            {

603
                result.units[n].glRGBArgs[i] = MapRGBArgs(result.units[n].rgbComb.args[i]);

604
                if( result.units[n].glRGBArgs[i] == GL_TEXTURE3_ARB && !result.envIsUsed )

605
                    result.units[n].glRGBArgs[i] = GL_TEXTURE2_ARB;

606


607
                result.units[n].glRGBFlags[i] = MapRGBArgFlags(result.units[n].rgbComb.args[i]);

608
            }

609
            if( result.units[n].alphaComb.args[i] != CM_IGNORE_BYTE )

610
            {

611
                result.units[n].glAlphaArgs[i] = MapAlphaArgs(result.units[n].alphaComb.args[i]);

612
                if( result.units[n].glAlphaArgs[i] == GL_TEXTURE3_ARB && !result.envIsUsed )

613
                    result.units[n].glAlphaArgs[i] = GL_TEXTURE2_ARB;

614


615
                result.units[n].glAlphaFlags[i] = MapAlphaArgFlags(result.units[n].alphaComb.args[i]);

616
            }

617
        }

618


619
        if( isGLtex(result.units[n].glRGBArgs[0]) && isGLtex(result.units[n].glRGBArgs[1]) && isGLtex(result.units[n].glRGBArgs[2]) )

620
        {

621
            result.units[n].glRGBArgs[2] = GL_CONSTANT_ARB;

622
        }

623
        if( isGLtex(result.units[n].glAlphaArgs[0]) && isGLtex(result.units[n].glAlphaArgs[1]) && isGLtex(result.units[n].glAlphaArgs[2]) )

624
        {

625
            result.units[n].glRGBArgs[2] = GL_CONSTANT_ARB;

626
        }

627
    }

628


629
    int extraUnit = 0;

630
    if( result.envIsUsed )  extraUnit++;

631
    if( result.lodFracIsUsed ) extraUnit++;

632
    for( n=result.numOfUnits; n<result.numOfUnits+extraUnit; n++ )

633
    {

634
        for( int i=0; i<3; i++ )

635
        {

636
            result.units[n].rgbComb.args[i]=CM_IGNORE_BYTE;

637
            result.units[n].alphaComb.args[i]=CM_IGNORE_BYTE;

638
            result.units[n].glRGBArgs[i] = 0;

639
            result.units[n].glRGBFlags[i] = 0;

640
            result.units[n].glAlphaArgs[i] = 0;

641
            result.units[n].glAlphaFlags[i] = 0;

642
        }

643
        

644
        result.units[n].rgbComb.args[0]=MUX_COMBINED;

645
        result.units[n].alphaComb.args[0]=MUX_COMBINED;

646
        result.units[n].rgbOp = GL_REPLACE;

647
        result.units[n].alphaOp = GL_REPLACE;

648
        result.units[n].glRGBArgs[0] = GL_PREVIOUS_ARB;

649
        result.units[n].glRGBArgs[1] = GL_PREVIOUS_ARB;

650
        result.units[n].rgbFlag0gl = GL_SRC_COLOR;

651
        result.units[n].rgbFlag1gl = GL_SRC_COLOR;

652
        result.units[n].glAlphaArgs[0] = GL_PREVIOUS_ARB;

653
        result.units[n].glAlphaArgs[1] = GL_PREVIOUS_ARB;

654
        result.units[n].alphaFlag0gl = GL_SRC_ALPHA;

655
        result.units[n].alphaFlag1gl = GL_SRC_ALPHA;

656
    }

657


658
    result.numOfUnits += extraUnit;

659


660
    m_vCompiledSettings.push_back(result);

661
    m_lastIndex = m_vCompiledSettings.size()-1;

662


663
#ifdef DEBUGGER

664
    if( logCombiners )

665
    {

666
        DisplaySimpleMuxString();

667
    }

668
#endif

669


670
    return m_lastIndex;

671
}

672


673


674
#ifdef DEBUGGER

675
extern const char *translatedCombTypes[];

676
void COGLColorCombiner4::DisplaySimpleMuxString(void)

677
{

678
    char buf0[30], buf1[30], buf2[30];

679
    OGLExtCombinerSaveType &result = m_vCompiledSettings[m_lastIndex];

680


681
    COGLColorCombiner::DisplaySimpleMuxString();

682
    DebuggerAppendMsg("OpenGL 1.2: %d Stages", result.numOfUnits);      

683
    for( int i=0; i<result.numOfUnits; i++ )

684
    {

685
        DebuggerAppendMsg("//aRGB%d:\t%s: %s, %s, %s\n", i,GetOpStr(result.units[i].rgbOp), DecodedMux::FormatStr(result.units[i].rgbArg0,buf0), DecodedMux::FormatStr(result.units[i].rgbArg1,buf1), DecodedMux::FormatStr(result.units[i].rgbArg2,buf2));     

686
        DebuggerAppendMsg("//aAlpha%d:\t%s: %s, %s, %s\n", i,GetOpStr(result.units[i].alphaOp), DecodedMux::FormatStr(result.units[i].alphaArg0,buf0), DecodedMux::FormatStr(result.units[i].alphaArg1,buf1), DecodedMux::FormatStr(result.units[i].alphaArg2,buf2));       

687
    }

688
    TRACE0("\n\n");

689
}

690
void COGLColorCombiner2::DisplaySimpleMuxString(void)

691
{

692
    char buf0[30], buf1[30], buf2[30];

693
    OGLExtCombinerSaveType &result = m_vCompiledSettings[m_lastIndex];

694


695
    COGLColorCombiner::DisplaySimpleMuxString();

696
    int generalCombinerIndex = CGeneralCombiner::FindCompiledMux();

697
    if( generalCombinerIndex < 0 )      // Can not found

698
    {

699
        generalCombinerIndex = CGeneralCombiner::ParseDecodedMux();

700
    }

701
    DebuggerAppendMsg("Generated general combiners:");

702
    GeneralCombinerInfo &generalRes = m_vCompiledCombinerStages[generalCombinerIndex];

703
    General_DisplayBlendingStageInfo(generalRes);

704


705
    DebuggerAppendMsg("OpenGL 1.2: %d Stages", result.numOfUnits);      

706
    for( int i=0; i<result.numOfUnits; i++ )

707
    {

708
        DebuggerAppendMsg("//aRGB%d:\t%s: %s, %s, %s\n", i,GetOpStr(result.units[i].rgbOp), DecodedMux::FormatStr(result.units[i].rgbArg0,buf0), DecodedMux::FormatStr(result.units[i].rgbArg1,buf1), DecodedMux::FormatStr(result.units[i].rgbArg2,buf2));     

709
        DebuggerAppendMsg("//aAlpha%d:\t%s: %s, %s, %s\n", i,GetOpStr(result.units[i].alphaOp), DecodedMux::FormatStr(result.units[i].alphaArg0,buf0), DecodedMux::FormatStr(result.units[i].alphaArg1,buf1), DecodedMux::FormatStr(result.units[i].alphaArg2,buf2));       

710
    }

711
    TRACE0("\n\n");

712
}

713
#endif

714


715


716
//////////////////////////////////////////////////////////////////////////

717
int COGLColorCombiner4::FindCompiledMux()

718
{

719
#ifdef DEBUGGER

720
    if( debuggerDropCombiners )

721
    {

722
        m_vCompiledSettings.clear();

723
        //m_dwLastMux0 = m_dwLastMux1 = 0;

724
        debuggerDropCombiners = false;

725
    }

726
#endif

727
    for( uint32 i=0; i<m_vCompiledSettings.size(); i++ )

728
    {

729
        if( m_vCompiledSettings[i].dwMux0 == m_pDecodedMux->m_dwMux0 && m_vCompiledSettings[i].dwMux1 == m_pDecodedMux->m_dwMux1 )

730
            return (int)i;

731
    }

732


733
    return -1;

734
}

735


736
//========================================================================

737


738
GLint COGLColorCombiner4::RGBArgsMap4[] =

739
{

740
#if SDL_VIDEO_OPENGL

741
    GL_PRIMARY_COLOR_ARB,           //MUX_0

742
    GL_PRIMARY_COLOR_ARB,           //MUX_1

743
    GL_PREVIOUS_ARB,                //MUX_COMBINED,

744
#endif

745
    GL_TEXTURE0_ARB,                //MUX_TEXEL0,

746
#if SDL_VIDEO_OPENGL

747
    GL_TEXTURE1_ARB,                //MUX_TEXEL1,

748
    GL_CONSTANT_ARB,                //MUX_PRIM,

749
    GL_PRIMARY_COLOR_ARB,           //MUX_SHADE,

750
    GL_CONSTANT_ARB,                //MUX_ENV,

751
    GL_PREVIOUS_ARB,                //MUX_COMBALPHA,

752
#endif

753
    GL_TEXTURE0_ARB,                //MUX_T0_ALPHA,

754
#if SDL_VIDEO_OPENGL

755
    GL_TEXTURE1_ARB,                //MUX_T1_ALPHA,

756
    GL_CONSTANT_ARB,                //MUX_PRIM_ALPHA,

757
    GL_PRIMARY_COLOR_ARB,           //MUX_SHADE_ALPHA,

758
    GL_CONSTANT_ARB,                //MUX_ENV_ALPHA,

759
    GL_CONSTANT_ARB,                //MUX_LODFRAC,

760
    GL_CONSTANT_ARB,                //MUX_PRIMLODFRAC,

761
    GL_PRIMARY_COLOR_ARB,           //MUX_K5

762
    GL_PRIMARY_COLOR_ARB            //MUX_UNK

763
#endif

764
};

765


766
GLint COGLColorCombiner4v2::RGBArgsMap4v2[] =

767
{

768
#if SDL_VIDEO_OPENGL

769
    GL_PRIMARY_COLOR_ARB,           //MUX_0

770
    GL_PRIMARY_COLOR_ARB,           //MUX_1

771
    GL_PREVIOUS_ARB,                //MUX_COMBINED,

772
#endif

773
    GL_TEXTURE0_ARB,                //MUX_TEXEL0,

774
#if SDL_VIDEO_OPENGL

775
    GL_TEXTURE1_ARB,                //MUX_TEXEL1,

776
    GL_CONSTANT_ARB,                //MUX_PRIM,

777
    GL_PRIMARY_COLOR_ARB,           //MUX_SHADE,

778
    GL_TEXTURE2_ARB,                //MUX_ENV,

779
    //{GL_TEXTURE1_ARB,         },  //MUX_ENV,

780
    GL_PREVIOUS_ARB,                //MUX_COMBALPHA,

781
    GL_TEXTURE0_ARB,                //MUX_T0_ALPHA,

782
    GL_TEXTURE1_ARB,                //MUX_T1_ALPHA,

783
    GL_CONSTANT_ARB,                //MUX_PRIM_ALPHA,

784
    GL_PRIMARY_COLOR_ARB,           //MUX_SHADE_ALPHA,

785
    GL_TEXTURE2_ARB,                //MUX_ENV_ALPHA,

786
    //{GL_TEXTURE1_ARB,         },  //MUX_ENV_ALPHA,

787
    //{GL_TEXTURE3_ARB,         },  //MUX_LODFRAC,

788
    //{GL_TEXTURE3_ARB,         },  //MUX_PRIMLODFRAC,

789
    GL_TEXTURE1_ARB,                //MUX_LODFRAC,

790
        GL_TEXTURE1_ARB,                //MUX_PRIMLODFRAC,

791
    GL_PRIMARY_COLOR_ARB,           //MUX_K5

792
    GL_PRIMARY_COLOR_ARB            //MUX_UNK

793
#endif

794
};

795


796
GLint COGLColorCombiner2::RGBArgsMap2[] =

797
{

798
#if SDL_VIDEO_OPENGL

799
    GL_PRIMARY_COLOR_ARB,           //MUX_0

800
    GL_PRIMARY_COLOR_ARB,           //MUX_1

801
    GL_PREVIOUS_ARB,                //MUX_COMBINED,

802
    //{GL_TEXTURE,              },  //MUX_TEXEL0,

803
    //{GL_TEXTURE,              },  //MUX_TEXEL1,

804
#endif

805
    GL_TEXTURE0_ARB,                //MUX_TEXEL0,

806
#if SDL_VIDEO_OPENGL

807
    GL_TEXTURE1_ARB,                //MUX_TEXEL1,

808
    GL_CONSTANT_ARB,                //MUX_PRIM,

809
    GL_PRIMARY_COLOR_ARB,           //MUX_SHADE,

810
    GL_CONSTANT_ARB,                //MUX_ENV,

811
    GL_PREVIOUS_ARB,                //MUX_COMBALPHA,

812
    //{GL_TEXTURE,              },  //MUX_T0_ALPHA,

813
    //{GL_TEXTURE,              },  //MUX_T1_ALPHA,

814
    GL_TEXTURE0_ARB,                //MUX_TEXEL0,

815
    GL_TEXTURE1_ARB,                //MUX_TEXEL1,

816
    GL_CONSTANT_ARB,                //MUX_PRIM_ALPHA,

817
    GL_PRIMARY_COLOR_ARB,           //MUX_SHADE_ALPHA,

818
    GL_CONSTANT_ARB,                //MUX_ENV_ALPHA,

819
    GL_CONSTANT_ARB,                //MUX_LODFRAC,

820
    GL_CONSTANT_ARB,                //MUX_PRIMLODFRAC,

821
    GL_PRIMARY_COLOR_ARB,           //MUX_K5

822
    GL_PRIMARY_COLOR_ARB            //MUX_UNK

823
#endif

824
};

825


826
//========================================================================

827


828
GLint COGLColorCombiner4::MapRGBArgs(uint8 arg)

829
{

830
    return RGBArgsMap4[arg&MUX_MASK];

831
}

832


833
GLint COGLColorCombiner4v2::MapRGBArgs(uint8 arg)

834
{

835
    return RGBArgsMap4v2[arg&MUX_MASK];

836
}

837


838
GLint COGLColorCombiner2::MapRGBArgs(uint8 arg)

839
{

840
    return RGBArgsMap2[arg&MUX_MASK];

841
}

842


843
GLint COGLColorCombiner4::MapRGBArgFlags(uint8 arg)

844
{

845
    if( (arg & MUX_ALPHAREPLICATE) && (arg & MUX_COMPLEMENT) )

846
    {

847
        return GL_ONE_MINUS_SRC_ALPHA;

848
    }

849
    else if( (arg & MUX_ALPHAREPLICATE) )

850
    {

851
        return GL_SRC_ALPHA;

852
    }

853
    else if(arg & MUX_COMPLEMENT) 

854
    {

855
        return GL_ONE_MINUS_SRC_COLOR;

856
    }

857
    else

858
        return GL_SRC_COLOR;

859
}

860


861
GLint COGLColorCombiner4::MapAlphaArgs(uint8 arg)

862
{

863
    return RGBArgsMap4[arg&MUX_MASK];

864
}

865


866
GLint COGLColorCombiner4v2::MapAlphaArgs(uint8 arg)

867
{

868
    return RGBArgsMap4v2[arg&MUX_MASK];

869
}

870


871
GLint COGLColorCombiner2::MapAlphaArgs(uint8 arg)

872
{

873
    return RGBArgsMap2[arg&MUX_MASK];

874
}

875


876
GLint COGLColorCombiner4::MapAlphaArgFlags(uint8 arg)

877
{

878
    if(arg & MUX_COMPLEMENT) 

879
    {

880
        return GL_ONE_MINUS_SRC_ALPHA;

881
    }

882
    else

883
        return GL_SRC_ALPHA;

884
}

885


886
//========================================================================

887


888
void ApplyFor1Unit(OGLExtCombinerType &unit)

889
{

890
#if SDL_VIDEO_OPENGL

891
    glTexEnvi(GL_TEXTURE_ENV, GL_COMBINE_RGB_ARB, unit.rgbOp);

892
    OPENGL_CHECK_ERRORS;

893


894
    if( unit.rgbArg0 != CM_IGNORE_BYTE )

895
    {

896
        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_RGB_ARB, (unit.rgbArg0gl));

897
        OPENGL_CHECK_ERRORS;

898
        glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_RGB_ARB, (unit.rgbFlag0gl));

899
        OPENGL_CHECK_ERRORS;

900
    }

901


902
    if( unit.rgbArg1 != CM_IGNORE_BYTE )

903
    {

904
        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_RGB_ARB, (unit.rgbArg1gl));

905
        OPENGL_CHECK_ERRORS;

906
        glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_RGB_ARB, (unit.rgbFlag1gl));

907
        OPENGL_CHECK_ERRORS;

908
    }

909


910
    if( unit.rgbArg2 != CM_IGNORE_BYTE )

911
    {

912
        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_RGB_ARB, (unit.rgbArg2gl));

913
        OPENGL_CHECK_ERRORS;

914
        glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_RGB_ARB, (unit.rgbFlag2gl));

915
        OPENGL_CHECK_ERRORS;

916
    }

917


918
    if( unit.alphaArg0 != CM_IGNORE_BYTE )

919
    {

920
        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE0_ALPHA_ARB, (unit.alphaArg0gl));

921
        OPENGL_CHECK_ERRORS;

922
        glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND0_ALPHA_ARB, (unit.alphaFlag0gl));

923
        OPENGL_CHECK_ERRORS;

924
    }

925


926
    if( unit.alphaArg1 != CM_IGNORE_BYTE )

927
    {

928
        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE1_ALPHA_ARB, (unit.alphaArg1gl));

929
        OPENGL_CHECK_ERRORS;

930
        glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND1_ALPHA_ARB, (unit.alphaFlag1gl));

931
        OPENGL_CHECK_ERRORS;

932
    }

933


934
    if( unit.alphaArg2 != CM_IGNORE_BYTE )

935
    {

936
        glTexEnvi(GL_TEXTURE_ENV, GL_SOURCE2_ALPHA_ARB, (unit.alphaArg2gl));

937
        OPENGL_CHECK_ERRORS;

938
        glTexEnvi(GL_TEXTURE_ENV, GL_OPERAND2_ALPHA_ARB, (unit.alphaFlag2gl));

939
        OPENGL_CHECK_ERRORS;

940
    }

941
#endif

942
}

943


944
//////////////////////////////////////////////////////////////////////////

945


946
void COGLColorCombiner4::GenerateCombinerSetting(int index)

947
{

948
    OGLExtCombinerSaveType &res = m_vCompiledSettings[index];

949


950
    // Texture unit 0

951
    COGLTexture* pTexture = NULL;

952
    COGLTexture* pTexture1 = NULL;

953


954
    if( m_bTex0Enabled || m_bTex1Enabled || gRDP.otherMode.cycle_type  == CYCLE_TYPE_COPY )

955
    {

956
        if( m_bTex0Enabled || gRDP.otherMode.cycle_type  == CYCLE_TYPE_COPY )

957
        {

958
            pTexture = g_textures[gRSP.curTile].m_pCOGLTexture;

959
            if( pTexture )  m_pOGLRender->BindTexture(pTexture->m_dwTextureName, 0);

960
        }

961
        if( m_bTex1Enabled )

962
        {

963
            pTexture1 = g_textures[(gRSP.curTile+1)&7].m_pCOGLTexture;

964
            if( pTexture1 ) m_pOGLRender->BindTexture(pTexture1->m_dwTextureName, 1);

965
        }

966
    }

967


968


969


970
    for( int i=0; i<res.numOfUnits; i++ )

971
    {

972
        pglActiveTexture(GL_TEXTURE0_ARB+i);

973
        OPENGL_CHECK_ERRORS;

974
        m_pOGLRender->EnableTexUnit(i,TRUE);

975
        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);

976
        OPENGL_CHECK_ERRORS;

977
        ApplyFor1Unit(res.units[i]);

978
    }

979


980
    if( res.numOfUnits < m_maxTexUnits )

981
    {

982
        for( int i=res.numOfUnits; i<m_maxTexUnits; i++ )

983
        {

984
            pglActiveTexture(GL_TEXTURE0_ARB+i);

985
            OPENGL_CHECK_ERRORS;

986
            m_pOGLRender->DisBindTexture(0, i);

987
            m_pOGLRender->EnableTexUnit(i,FALSE);

988
        }

989
    }

990
}

991


992


993
void COGLColorCombiner4::GenerateCombinerSettingConstants(int index)

994
{

995
    OGLExtCombinerSaveType &res = m_vCompiledSettings[index];

996


997
    float *fv;

998
    float tempf[4];

999


1000
    bool isused = true;

1001


1002
    if( res.primIsUsed )

1003
    {

1004
        fv = GetPrimitiveColorfv(); // CONSTANT COLOR

1005
    }

1006
    else if( res.envIsUsed )

1007
    {

1008
        fv = GetEnvColorfv();   // CONSTANT COLOR

1009
    }

1010
    else if( res.lodFracIsUsed )

1011
    {

1012
        float frac = gRDP.LODFrac / 255.0f;

1013
        tempf[0] = tempf[1] = tempf[2] = tempf[3] = frac;

1014
        fv = &tempf[0];

1015
    }

1016
    else

1017
    {

1018
        isused = false;

1019
    }

1020


1021
    if( isused )

1022
    {

1023
        for( int i=0; i<res.numOfUnits; i++ )

1024
        {

1025
            pglActiveTexture(GL_TEXTURE0_ARB+i);

1026
            OPENGL_CHECK_ERRORS;

1027
            glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,fv);

1028
            OPENGL_CHECK_ERRORS;

1029
        }

1030
    }

1031
}

1032


1033


1034
void COGLColorCombiner4v2::GenerateCombinerSettingConstants(int index)

1035
{

1036
    //COGLColorCombiner4::GenerateCombinerSettingConstants(index);

1037
    //return;

1038


1039
    OGLExtCombinerSaveType &res = m_vCompiledSettings[index];

1040
    COGLExtRender *prender = (COGLExtRender *)m_pRender;

1041


1042
    if( res.primIsUsed )

1043
    {

1044
        float *fv = GetPrimitiveColorfv();  // CONSTANT COLOR

1045
        for( int i=0; i<res.numOfUnits; i++ )

1046
        {

1047
            pglActiveTexture(GL_TEXTURE0_ARB+i);

1048
            OPENGL_CHECK_ERRORS;

1049
            glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,fv);

1050
            OPENGL_CHECK_ERRORS;

1051
        }

1052
    }

1053


1054
    if( res.envIsUsed )

1055
    {

1056
        // Set Texture unit 2 to ENV

1057
        pglActiveTexture(GL_TEXTURE2_ARB);

1058
        OPENGL_CHECK_ERRORS;

1059
        prender->EnableTexUnit(2,TRUE);

1060
        TxtrCacheEntry *pEntry = gTextureManager.GetConstantColorTexture(MUX_ENV);

1061
        prender->SetCurrentTexture( (gRSP.curTile+2)%7, pEntry->pTexture, 4, 4, pEntry);

1062
        prender->SetTexelRepeatFlags((gRSP.curTile+2)%7);

1063
    }

1064


1065
    if( res.lodFracIsUsed)

1066
    {

1067
        int unit = 3;

1068
        if( !res.envIsUsed )

1069
            unit = 2;

1070


1071
        // Set Texture unit 3 to LODFRAC

1072
        pglActiveTexture(GL_TEXTURE0_ARB+unit);

1073
        OPENGL_CHECK_ERRORS;

1074
        prender->EnableTexUnit(unit,TRUE);

1075
        TxtrCacheEntry *pEntry = gTextureManager.GetConstantColorTexture(MUX_LODFRAC);

1076
        prender->SetCurrentTexture( (gRSP.curTile+unit)%7, pEntry->pTexture, 4, 4, pEntry);

1077
        prender->SetTexelRepeatFlags((gRSP.curTile+unit)%7);

1078
    }

1079
    else

1080
    {

1081
        int unit = 3;

1082
        if( !res.envIsUsed )

1083
            unit = 2;

1084


1085
        // Disable texture unit 3

1086
        pglActiveTexture(GL_TEXTURE0_ARB+unit);

1087
        OPENGL_CHECK_ERRORS;

1088
        prender->EnableTexUnit(unit,FALSE);

1089
        prender->SetTextureToTextureUnitMap(-1,unit);

1090
    }

1091
}

1092


1093


1094
GLenum GeneralToGLMaps[]=

1095
{

1096
    GL_REPLACE,             //CM_REPLACE,

1097
#if SDL_VIDEO_OPENGL

1098
    GL_MODULATE,            //CM_MODULATE,

1099
    GL_ADD,                 //CM_ADD,

1100
    GL_SUBTRACT_ARB,        //CM_SUBTRACT,

1101
    GL_INTERPOLATE_ARB,     //CM_INTERPOLATE,

1102
    GL_INTERPOLATE_ARB,     //CM_ADDSMOOTH,     

1103
    GL_INTERPOLATE_ARB,     //CM_BLENDCURRENTALPHA

1104
    GL_INTERPOLATE_ARB,     //CM_BLENDDIFFUSEALPHA

1105
    GL_INTERPOLATE_ARB,     //CM_BLENDFACTORALPHA,

1106
    GL_INTERPOLATE_ARB,     //CM_BLENDTEXTUREALPHA

1107
#endif

1108
    GL_MODULATE_ADD_ATI,    //CM_MULTIPLYADD,       

1109
};

1110


1111


1112
//////////////////////////////////////////////////////////////////////////

1113
int COGLColorCombiner2::ParseDecodedMux()

1114
{

1115
    //return COGLColorCombiner4::ParseDecodedMux();

1116


1117
    int generalCombinerIndex = CGeneralCombiner::FindCompiledMux();

1118
    if( generalCombinerIndex < 0 )      // Can not found

1119
    {

1120
        generalCombinerIndex = CGeneralCombiner::ParseDecodedMux();

1121
    }

1122


1123
    GeneralCombinerInfo &generalRes = m_vCompiledCombinerStages[generalCombinerIndex];

1124
    OGLExtCombinerSaveType res;

1125


1126
    // Convert generalRes to OGLExtCombinerSaveType

1127
    for( int unitNo=0; unitNo<generalRes.nStages; unitNo++ )

1128
    {

1129
        OGLExtCombinerType &unit = res.units[unitNo];

1130
        //OGLExt1CombType &colorComb = unit.Combs[0];

1131
        //OGLExt1CombType &alphaComb = unit.Combs[1];

1132


1133
        unit.rgbArg0 = (uint8)generalRes.stages[unitNo].colorOp.Arg1;

1134
        unit.rgbArg1 = (uint8)generalRes.stages[unitNo].colorOp.Arg2;

1135
        unit.rgbArg2 = (uint8)generalRes.stages[unitNo].colorOp.Arg0;

1136
        unit.alphaArg0 = (uint8)generalRes.stages[unitNo].alphaOp.Arg1;

1137
        unit.alphaArg1 = (uint8)generalRes.stages[unitNo].alphaOp.Arg2;

1138
        unit.alphaArg2 = (uint8)generalRes.stages[unitNo].alphaOp.Arg0;

1139


1140
        unit.rgbOp = GeneralToGLMaps[generalRes.stages[unitNo].colorOp.op];

1141
        if( unit.rgbOp == GL_MODULATE_ADD_ATI && !m_bTxtOpMulAdd )

1142
        {

1143
            if( (unit.rgbArg0&MUX_MASK) == (unit.rgbArg2&MUX_MASK) && (unit.rgbArg0&MUX_COMPLEMENT) )

1144
            {

1145
                unit.rgbOp = GL_ADD;

1146
                unit.rgbArg0 &= ~MUX_COMPLEMENT;

1147
            }

1148
            else

1149
            {

1150
                unit.rgbOp = GL_MODULATE;

1151
            }

1152
        }

1153
        unit.alphaOp = GeneralToGLMaps[generalRes.stages[unitNo].alphaOp.op];

1154
        if( unit.alphaOp == GL_MODULATE_ADD_ATI && !m_bTxtOpMulAdd )    

1155
        {

1156
            if( (unit.alphaArg0&MUX_MASK) == (unit.alphaArg2&MUX_MASK) && (unit.alphaArg0&MUX_COMPLEMENT) )

1157
            {

1158
                unit.alphaOp = GL_ADD;

1159
                unit.alphaArg0 &= ~MUX_COMPLEMENT;

1160
            }

1161
            else

1162
            {

1163
                unit.alphaOp = GL_MODULATE;

1164
            }

1165
        }

1166


1167
        unit.tex = generalRes.stages[unitNo].dwTexture;

1168
        unit.textureIsUsed = generalRes.stages[unitNo].bTextureUsed;

1169
    }

1170


1171
    res.numOfUnits = generalRes.nStages;

1172
    res.constantColor = generalRes.TFactor;

1173
    return SaveParsedResult(res);

1174
}

1175


1176


1177
void COGLColorCombiner2::GenerateCombinerSettingConstants(int index)

1178
{

1179
    OGLExtCombinerSaveType &res = m_vCompiledSettings[index];

1180


1181
    bool isused = true;

1182


1183
    float *fv;

1184
    float tempf[4];

1185


1186
    if( res.primIsUsed )

1187
    {

1188
        fv = GetPrimitiveColorfv(); // CONSTANT COLOR

1189
    }

1190
    else if( res.envIsUsed )

1191
    {

1192
        fv = GetEnvColorfv();   // CONSTANT COLOR

1193
    }

1194
    else if( res.lodFracIsUsed )

1195
    {

1196
        float frac = gRDP.LODFrac / 255.0f;

1197
        tempf[0] = tempf[1] = tempf[2] = tempf[3] = frac;

1198
        fv = &tempf[0];

1199
    }

1200
    else

1201
    {

1202
        isused = false;

1203
    }

1204


1205
    if( isused )

1206
    {

1207
        for( int i=0; i<res.numOfUnits; i++ )

1208
        {

1209
            pglActiveTextureARB(GL_TEXTURE0_ARB+i);

1210
            OPENGL_CHECK_ERRORS;

1211
            glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR,fv);

1212
            OPENGL_CHECK_ERRORS;

1213
        }

1214
    }

1215
}

1216
void COGLColorCombiner2::GenerateCombinerSetting(int index)

1217
{

1218
    OGLExtCombinerSaveType &res = m_vCompiledSettings[index];

1219
    COGLExtRender *prender = (COGLExtRender *)m_pRender;

1220


1221
    for( int i=0; i<res.numOfUnits; i++ )

1222
    {

1223
        pglActiveTextureARB(GL_TEXTURE0_ARB+i);

1224
        OPENGL_CHECK_ERRORS;

1225
        //if(res.units[i].textureIsUsed)

1226
        {

1227
            prender->SetTextureToTextureUnitMap(res.units[i].tex,i);

1228
            m_pOGLRender->EnableTexUnit(i,TRUE);

1229
            COGLTexture* pTexture = g_textures[(gRSP.curTile+res.units[i].tex)&7].m_pCOGLTexture;

1230
            if( pTexture )  m_pOGLRender->BindTexture(pTexture->m_dwTextureName, i);

1231
        }

1232
        /*

1233
        else

1234
        {

1235
            m_pOGLRender->EnableTexUnit(i,TRUE);

1236
            prender->SetTextureToTextureUnitMap(-1,i);

1237
            //m_pOGLRender->EnableTexUnit(i,FALSE);

1238
            //m_pOGLRender->DisBindTexture(0, i);

1239
        }

1240
        */

1241


1242
        glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_COMBINE_ARB);

1243
        OPENGL_CHECK_ERRORS;

1244
        ApplyFor1Unit(res.units[i]);

1245
    }

1246


1247
    if( res.numOfUnits < m_maxTexUnits )

1248
    {

1249
        for( int i=res.numOfUnits; i<m_maxTexUnits; i++ )

1250
        {

1251
            pglActiveTextureARB(GL_TEXTURE0_ARB+i);

1252
            OPENGL_CHECK_ERRORS;

1253
            m_pOGLRender->EnableTexUnit(i,FALSE);

1254
            prender->SetTextureToTextureUnitMap(-1,i);

1255
        }

1256
    }

1257
}

1258


1259


1260