CoCalc -- GeneralCombiner.cpp

GitHub Repository: alexbevi/BizHawk
Path: blob/master/libmupen64plus/mupen64plus-video-rice/src/GeneralCombiner.cpp
² 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

21
#include "GeneralCombiner.h"
22
#include "Combiner.h"
23
#include "Debugger.h"
24

25
extern const int numOf3StageCombiners;
26
extern const int numOf2StageCombiners;
27
extern GeneralCombinerInfo CombinerTable2Stages[];
28
extern GeneralCombinerInfo CombinerTable3Stages[];
29

30
CGeneralCombiner::CGeneralCombiner()
31
{
32
    m_lastGeneralIndex=0;
33
    m_ppGeneralDecodedMux=NULL;
34

35
    m_bTxtOpAdd=true;
36
    m_bTxtOpSub=false;
37
    m_bTxtOpLerp=false;         
38
    m_bTxtOpAddSmooth=false;        
39
    m_bTxtOpBlendCurAlpha=false;    
40
    m_bTxtOpBlendDifAlpha=true; 
41
    m_bTxtOpBlendFacAlpha=false;    
42
    m_bTxtOpBlendTxtAlpha=true; 
43
    m_bTxtOpMulAdd=false;       
44

45
    m_dwGeneralMaxStages=2;
46
}
47

48
bool isTex(uint32 val)
49
{
50
    return ( (val&MUX_MASK) == MUX_TEXEL0 || (val&MUX_MASK) == MUX_TEXEL1 );
51
}
52
int toTex(uint32 val)
53
{
54
    return (val&MUX_MASK)-MUX_TEXEL0;
55
}
56

57
bool isComb(uint32 val)
58
{
59
    return (val&MUX_MASK)==MUX_COMBINED;
60
}
61

62
#ifdef DEBUGGER
63
const char* BlendFuncStr[] = {
64
    "Enable both",
65
    "Disable alpha",
66
    "Disable color",
67
    "Disable both",
68
    "Color one",
69
    "Alpha one",
70
};
71
const char* cmopstrs[] = {
72
    "Sel",
73
    "Mod",
74
    "Add",
75
    "Sub",
76
    "Lerp",
77
    "AddSmooth",            
78
    "BlCurA",   
79
    "BlDifA",   
80
    "BlFacA",   
81
    "BlTexA",   
82
    "MulAdd",           
83
};
84

85
void CGeneralCombiner::General_DisplayBlendingStageInfo(GeneralCombinerInfo &gci)
86
{
87
    char str1[30],str2[30],str3[30];
88
    DebuggerAppendMsg("\nStages:%d, Alpha:%s, Factor:%s, Specular:%s Dif Color:0x%X Dif Alpha:0x%X\n", 
89
        gci.nStages, BlendFuncStr[gci.blendingFunc], DecodedMux::FormatStr((uint8)gci.TFactor,str1),
90
        DecodedMux::FormatStr((uint8)gci.specularPostOp,str2), gci.m_dwShadeColorChannelFlag, gci.m_dwShadeAlphaChannelFlag);
91

92
    for( int i=0; i<gci.nStages; i++ )
93
    {
94
        GeneralCombineStage &s = gci.stages[i];
95
        DebuggerAppendMsg("%d:Color: %s - %s, %s, %s%s\n", i,
96
            cmopstrs[s.colorOp.op], DecodedMux::FormatStr((uint8)s.colorOp.Arg1, str1),     s.colorOp.Arg2==CM_IGNORE?"":DecodedMux::FormatStr((uint8)s.colorOp.Arg2, str2), 
97
            s.colorOp.Arg0==CM_IGNORE?"":DecodedMux::FormatStr((uint8)s.colorOp.Arg0, str3),
98
            s.dwTexture!=0?" -Tex1":"");
99
    }
100
    
101
    for( int i=0; i<gci.nStages; i++ )
102
    {
103
        GeneralCombineStage &s = gci.stages[i];
104
        DebuggerAppendMsg("%d:Alpha: %s - %s, %s, %s%s\n", i,
105
            cmopstrs[s.alphaOp.op], DecodedMux::FormatStr((uint8)s.alphaOp.Arg1, str1), 
106
            s.alphaOp.Arg2==CM_IGNORE?"":DecodedMux::FormatStr((uint8)s.alphaOp.Arg2, str2),
107
            s.alphaOp.Arg0==CM_IGNORE?"":DecodedMux::FormatStr((uint8)s.alphaOp.Arg0, str3),
108
            s.dwTexture!=0?" -Tex1":"");
109
    }
110
    TRACE0("\n\n");
111
}
112
#endif
113

114

115
///////////////////////////////////////
116
// Combiner gci generating functions //
117
///////////////////////////////////////
118

119
bool textureUsedInStage[8][2];
120
bool resultIsGood;
121

122
void CGeneralCombiner::GenCI_Init(GeneralCombinerInfo &gci)
123
{
124
    gci.specularPostOp=gci.TFactor=MUX_0;
125

126
    gci.blendingFunc = ENABLE_BOTH;
127
    resultIsGood = true;
128

129
    //After the mux is reformated and simplified, we can use it to generate combine stages
130
    //return false if we can not generate it
131

132
    for( int i=0; i<8; i++)
133
    {
134
        gci.stages[i].dwTexture = 0;
135
        textureUsedInStage[i][0] = false;       // For color
136
        textureUsedInStage[i][1] = false;       // For alpha
137
        gci.stages[i].bTextureUsed = false;
138
        gci.stages[i].dwTexture = 0;
139
        gci.stages[i].colorOp.op = gci.stages[i].alphaOp.op = CM_REPLACE;
140
        gci.stages[i].colorOp.Arg1 = gci.stages[i].alphaOp.Arg1 = MUX_COMBINED;
141
        gci.stages[i].colorOp.Arg2 = gci.stages[i].alphaOp.Arg2 = CM_IGNORE;
142
        gci.stages[i].colorOp.Arg0 = gci.stages[i].alphaOp.Arg0 = CM_IGNORE;
143
    }
144

145
    DecodedMux &mux = *(*m_ppGeneralDecodedMux);
146

147
    // Check some special cases of alpha channel
148
    if( mux.splitType[N64Cycle0Alpha]==CM_FMT_TYPE_D && mux.splitType[N64Cycle1Alpha]==CM_FMT_TYPE_NOT_USED )
149
    {
150
        //if( mux.m_n64Combiners[N64Cycle0Alpha].d == MUX_0 )
151
        //  gci.blendingFunc = DISABLE_COLOR;
152
        //else 
153
        if( mux.m_n64Combiners[N64Cycle0Alpha].d == MUX_1  )
154
            gci.blendingFunc = DISABLE_ALPHA;
155
    }
156
    else if( mux.splitType[N64Cycle1Alpha]==CM_FMT_TYPE_D )
157
    {
158
        //if( mux.m_n64Combiners[N64Cycle1Alpha].d == MUX_0 )
159
        //  gci.blendingFunc = DISABLE_COLOR;
160
        //else 
161
        if( mux.m_n64Combiners[N64Cycle1Alpha].d == MUX_1  )
162
            gci.blendingFunc = DISABLE_ALPHA;
163
    }
164

165
    if( mux.splitType[N64Cycle0RGB]==CM_FMT_TYPE_D && mux.splitType[N64Cycle1RGB]==CM_FMT_TYPE_NOT_USED )
166
    {
167
        if( mux.m_n64Combiners[N64Cycle0RGB].d == MUX_0 )
168
            gci.blendingFunc = DISABLE_COLOR;
169
    }
170

171
}
172

173
int CGeneralCombiner::GenCI_Type_D(int curN64Stage, int curStage, GeneralCombinerInfo &gci)
174
{
175
    N64CombinerType &m = (*m_ppGeneralDecodedMux)->m_n64Combiners[curN64Stage];
176
    StageOperate *op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + (curN64Stage%2);
177
    if( ( m.d == MUX_0 || m.d == MUX_1 ) && curN64Stage==1 )
178
    {
179
        //if( m.d == MUX_0 )
180
        //  gci.blendingFunc = DISABLE_COLOR;
181
        //if( m.d == MUX_1 )
182
        //  gci.blendingFunc = DISABLE_ALPHA;
183

184
        op->op = CM_REPLACE;
185
        op->Arg1 = MUX_COMBINED;
186
        op->Arg2 = CM_IGNORE;
187
        op->Arg0 = CM_IGNORE;
188
    }
189
    else
190
    {
191
        if( isTex(m.d) )    Check1TxtrForAlpha(curN64Stage, curStage, gci, toTex(m.d));
192
        op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + (curN64Stage%2);
193

194
        op->op = CM_REPLACE;
195
        op->Arg1 = m.d;
196
        op->Arg2 = CM_IGNORE;
197
        op->Arg0 = CM_IGNORE;
198
    }
199

200
    if( !gci.stages[curStage].bTextureUsed )
201
        gci.stages[curStage].dwTexture = GetTexelNumber(m);
202
    textureUsedInStage[curStage][curN64Stage%2] = IsTxtrUsed(m);
203
    return curStage;
204
}
205

206
int CGeneralCombiner::GenCI_Type_A_MOD_C(int curN64Stage, int curStage, GeneralCombinerInfo &gci, uint32 dxop)
207
{
208
    N64CombinerType &m = (*m_ppGeneralDecodedMux)->m_n64Combiners[curN64Stage];
209
    StageOperate *op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + (curN64Stage%2);
210

211
    if( CountTexel1Cycle(m) == 2 )
212
    {
213
        // As we can not use both texture in one stage
214
        // we split them to two stages
215
        // Stage1: SELECT   txt1
216
        // Stage2: MOD      txt2
217

218
        if( gci.stages[curStage].bTextureUsed && gci.stages[curStage].dwTexture != (unsigned int)toTex(m.a) )
219
            swap(m.a,m.c);
220

221
        op->op =CM_REPLACE;
222
        op->Arg1 = m.a;
223
        op->Arg2 = CM_IGNORE;
224
        op->Arg0 = CM_IGNORE;
225
        gci.stages[curStage].dwTexture = toTex(m.a);
226
        textureUsedInStage[curStage][curN64Stage%2] = true;
227

228
        NextStage(curStage);
229
        Check1TxtrForAlpha(curN64Stage, curStage, gci, toTex(m.c));
230
        op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + (curN64Stage%2);
231

232
        op->op  =dxop;
233
        op->Arg1 = (m.c);
234
        op->Arg2 = MUX_COMBINED;
235
        op->Arg0 = CM_IGNORE;
236
        gci.stages[curStage].dwTexture = toTex(m.c);
237
        textureUsedInStage[curStage][curN64Stage%2] = true;
238
    }
239
    else
240
    {
241
        if( CountTexel1Cycle(m) == 1)
242
        {
243
            Check1TxtrForAlpha(curN64Stage, curStage, gci, GetTexelNumber(m));
244
            op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + (curN64Stage%2);
245
        }
246

247
        op->op = dxop;
248
        op->Arg1 = (m.a);
249
        op->Arg2 = (m.c);
250
        op->Arg0 = CM_IGNORE;
251
        if( !gci.stages[curStage].bTextureUsed )
252
            gci.stages[curStage].dwTexture = GetTexelNumber(m);
253
        textureUsedInStage[curStage][curN64Stage%2] = IsTxtrUsed(m);
254
    }
255

256
    return curStage;
257
}
258
int CGeneralCombiner::GenCI_Type_A_ADD_D(int curN64Stage, int curStage, GeneralCombinerInfo &gci)
259
{
260
    uint32 opToUse = m_bTxtOpAdd?CM_ADD:CM_MODULATE;
261
    N64CombinerType &m = (*m_ppGeneralDecodedMux)->m_n64Combiners[curN64Stage];
262
    swap(m.c, m.d);
263
    curStage = GenCI_Type_A_MOD_C(curN64Stage, curStage, gci, opToUse);
264
    swap(m.c, m.d);
265
    return curStage;
266
}
267

268
int CGeneralCombiner::GenCI_Type_A_SUB_B(int curN64Stage, int curStage, GeneralCombinerInfo &gci)
269
{
270
    N64CombinerType &m = (*m_ppGeneralDecodedMux)->m_n64Combiners[curN64Stage];
271
    if( !m_bTxtOpSub )
272
    {
273
        swap(m.c, m.b);
274
        curStage = GenCI_Type_A_MOD_C(curN64Stage, curStage, gci);
275
        swap(m.c, m.b);
276
        return curStage;
277
    }
278

279
    StageOperate *op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + (curN64Stage%2);
280

281
    if( CountTexel1Cycle(m) == 2 )
282
    {
283
        Check1TxtrForAlpha(curN64Stage, curStage, gci, toTex(m.b));
284
        op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + (curN64Stage%2);
285

286
        op->op =CM_REPLACE;
287
        op->Arg1 = (m.b);
288
        op->Arg2 = CM_IGNORE;
289
        op->Arg0 = CM_IGNORE;
290
        gci.stages[curStage].dwTexture = toTex(m.b);
291
        textureUsedInStage[curStage][curN64Stage%2] = true;
292

293
        NextStage(curStage);
294
        Check1TxtrForAlpha(curN64Stage, curStage, gci, toTex(m.a));
295
        op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + (curN64Stage%2);
296

297
        op->op  =CM_SUBTRACT;
298
        op->Arg1 = (m.a);
299
        op->Arg2 = MUX_COMBINED;
300
        op->Arg0 = CM_IGNORE;
301
        gci.stages[curStage].dwTexture = toTex(m.a);
302
        textureUsedInStage[curStage][curN64Stage%2] = true;
303
    }
304
    else
305
    {
306
        if( CountTexel1Cycle(m) == 1)
307
        {
308
            Check1TxtrForAlpha(curN64Stage, curStage, gci, GetTexelNumber(m));
309
            op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + (curN64Stage%2);
310
        }
311

312
        op->op = CM_SUBTRACT;
313
        op->Arg1 = (m.a);
314
        op->Arg2 = (m.b);
315
        op->Arg0 = CM_IGNORE;
316
        if( !gci.stages[curStage].bTextureUsed )
317
            gci.stages[curStage].dwTexture = GetTexelNumber(m);
318
        textureUsedInStage[curStage][curN64Stage%2] = IsTxtrUsed(m);
319
    }
320
    return curStage;
321
}
322

323
int CGeneralCombiner::GenCI_Type_A_MOD_C_ADD_D(int curN64Stage, int curStage, GeneralCombinerInfo &gci)
324
{
325
    N64CombinerType &m = (*m_ppGeneralDecodedMux)->m_n64Combiners[curN64Stage];
326
    StageOperate *op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + (curN64Stage%2);
327

328
    if( !m_bTxtOpMulAdd )
329
    {
330
        N64CombinerType save = m;
331
        m.d = MUX_0;
332
        curStage = GenCI_Type_A_MOD_C(curN64Stage, curStage, gci);
333
        m = save;
334
        m.c = MUX_0;
335
        m.a = MUX_COMBINED;
336
        NextStage(curStage);
337
        curStage = GenCI_Type_A_ADD_D(curN64Stage, curStage, gci);
338
        m = save;
339
        return curStage;
340
    }
341

342
    if( CountTexel1Cycle(m) == 2 )
343
    {
344
        if( !gci.stages[curStage].bTextureUsed )
345
        {
346
            gci.stages[curStage].dwTexture = 0;
347
            gci.stages[curStage].bTextureUsed = true;
348
        }
349

350
        op->op = CM_REPLACE;
351
        op->Arg2 = CM_IGNORE;
352
        op->Arg0 = CM_IGNORE;
353
        op->Arg1 = MUX_TEXEL0 + gci.stages[curStage].dwTexture ;
354

355
        N64CombinerType m2 = m;
356

357
        uint8* vals = (uint8*)&m2;
358
        for( int i=0; i<4; i++ )
359
        {
360
            if( (unsigned int)(vals[i]&MUX_MASK) == MUX_TEXEL0 + gci.stages[curStage].dwTexture )
361
            {
362
                vals[i] = MUX_COMBINED | (vals[i]&0xe0);
363
            }
364
        }
365

366
        NextStage(curStage);
367

368
        Check1TxtrForAlpha(curN64Stage, curStage, gci, GetTexelNumber(m2));
369
        op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + (curN64Stage%2);
370

371
        op->op = CM_MULTIPLYADD;
372
        op->Arg1 = m2.a;
373
        op->Arg2 = m2.c;
374
        op->Arg0 = m2.d;
375
        if( !gci.stages[curStage].bTextureUsed )
376
            gci.stages[curStage].dwTexture = GetTexelNumber(m2);
377
        textureUsedInStage[curStage][curN64Stage%2] = IsTxtrUsed(m2);
378
    }
379
    else
380
    {
381
        Check1TxtrForAlpha(curN64Stage, curStage, gci, GetTexelNumber(m));
382
        op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + (curN64Stage%2);
383

384
        op->op = CM_MULTIPLYADD;
385
        op->Arg1 = (m.a);
386
        op->Arg2 = (m.c);
387
        op->Arg0 = (m.d);
388
        if( !gci.stages[curStage].bTextureUsed )
389
            gci.stages[curStage].dwTexture = GetTexelNumber(m);
390
        textureUsedInStage[curStage][curN64Stage%2] = IsTxtrUsed(m);
391
    }
392

393
    return curStage;
394
}
395

396

397
int CGeneralCombiner::GenCI_Type_A_LERP_B_C(int curN64Stage, int curStage, GeneralCombinerInfo &gci)
398
{
399
    N64CombinerType &m = (*m_ppGeneralDecodedMux)->m_n64Combiners[curN64Stage];
400
    StageOperate *op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + (curN64Stage%2);
401

402
    N64CombinerType save = m;
403

404
    if( CountTexel1Cycle(m) == 2 )
405
    {
406
        // There are two textures
407
        int texToUse = CheckWhichTexToUseInThisStage(curN64Stage, curStage, gci);
408
        op->op =CM_REPLACE;
409
        op->Arg1 = (MUX_TEXEL0+texToUse);
410
        op->Arg2 = CM_IGNORE;
411
        op->Arg0 = CM_IGNORE;
412
        gci.stages[curStage].dwTexture = texToUse;
413
        textureUsedInStage[curStage][curN64Stage%2] = true;
414

415
        (*m_ppGeneralDecodedMux)->ReplaceVal(MUX_TEXEL0+texToUse, MUX_COMBINED, curN64Stage);
416
        NextStage(curStage);
417
        Check1TxtrForAlpha(curN64Stage, curStage, gci, GetTexelNumber(m));
418
        op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + (curN64Stage%2);
419
    }
420

421
    // Now we have only 1 texture left
422

423
    Check1TxtrForAlpha(curN64Stage, curStage, gci, GetTexelNumber(m));
424
    op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + (curN64Stage%2);
425

426
    if( m.a == MUX_1 )
427
    {
428
        op->op = CM_ADDSMOOTH;
429
        op->Arg1 = (m.b);
430
        op->Arg2 = (m.c);
431
        op->Arg0 = CM_IGNORE;
432
    }
433
    else if( m.a == MUX_0 )
434
    {
435
        op->op = CM_MODULATE;
436
        m.a = 0;
437
        op->Arg1 = (m.b);
438
        op->Arg2 = (m.c^MUX_COMPLEMENT);
439
        op->Arg0 = CM_IGNORE;
440
    }
441
    else
442
    {
443
        if( ((m.c&MUX_ALPHAREPLICATE) || (curN64Stage%2)==1 || m_bTxtOpLerp == false) && ((m.c&MUX_MASK)==MUX_SHADE || (m.c&MUX_MASK)==MUX_COMBINED || (m.c&MUX_MASK)==MUX_TEXEL0 || (m.c&MUX_MASK)==MUX_TEXEL1  ) )
444
        {
445
            if( curN64Stage == 2 && (m.c&MUX_ALPHAREPLICATE) == 0 )
446
            {
447
                op->op = CM_MODULATE;
448
                op->Arg1 = m.b;
449
                op->Arg2 = m.c|MUX_COMPLEMENT;
450
                op->Arg0 = CM_IGNORE;
451
                resultIsGood = false;
452
            }
453
            else
454
            {
455
                if( (m.c&MUX_MASK)==MUX_SHADE )
456
                {
457
                    op->op = CM_BLENDDIFFUSEALPHA;
458
                }
459
                else if( (m.c&MUX_MASK) == MUX_COMBINED )
460
                {
461
                    op->op = CM_BLENDCURRENTALPHA;
462
                }
463
                else if( (m.c&MUX_MASK) == MUX_TEXEL0 )
464
                {
465
                    op->op = CM_BLENDTEXTUREALPHA;
466
                }
467
                else if( (m.c&MUX_MASK)==MUX_TEXEL1 )
468
                {
469
                    op->op = CM_BLENDTEXTUREALPHA;
470
                }
471
                else
472
                {
473
                    op->op = CM_BLENDDIFFUSEALPHA;
474
                }
475
                op->Arg1 = (m.a);
476
                op->Arg2 = (m.b);
477
                op->Arg0 = m.c|MUX_ALPHAREPLICATE;
478
            }
479
        }
480
        else
481
        {
482
            if( ((m.c&MUX_ALPHAREPLICATE) || (curN64Stage%2)==1 || m_bTxtOpLerp == false) && ((((m.c&MUX_MASK)==MUX_ENV) || ((m.c&MUX_MASK)==MUX_PRIM)) ))
483
            {
484
                op->op = CM_BLENDFACTORALPHA;
485
                op->Arg1 = (m.a);
486
                op->Arg2 = (m.b);
487
                op->Arg0 = m.c|MUX_ALPHAREPLICATE;
488
            }
489
            else
490
            {
491
                op->op = CM_INTERPOLATE;
492
                op->Arg0 = (m.c);
493
                op->Arg1 = (m.a);
494
                op->Arg2 = (m.b);
495
            }
496
        }
497
    }
498
    gci.stages[curStage].dwTexture = GetTexelNumber(m);
499
    textureUsedInStage[curStage][curN64Stage%2] = IsTxtrUsed(m);
500

501
    m = save;
502
    return curStage;
503
}
504

505

506
int CGeneralCombiner::GenCI_Type_A_B_C_D(int curN64Stage, int curStage, GeneralCombinerInfo &gci)
507
{
508
    N64CombinerType &m = (*m_ppGeneralDecodedMux)->m_n64Combiners[curN64Stage];
509
    StageOperate *op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + (curN64Stage%2);
510

511
    N64CombinerType save = m;
512
    if( CountTexel1Cycle(m) == 2 )
513
    {
514
        if( isTex(m.a) && !isTex(m.c) && curN64Stage == 0 && isTex(m.d) && toTex(m.a) != toTex(m.d) )
515
        {
516
            if( m_dwGeneralMaxStages >= 4 )
517
            {
518
                op->op = CM_SUBTRACT;
519
                op->Arg1 = m.a;
520
                op->Arg2 = m.b;
521
                op->Arg0 = CM_IGNORE;
522
                gci.stages[curStage].dwTexture = toTex(m.a);
523
                textureUsedInStage[curStage][curN64Stage%2] = true;
524
                NextStage(curStage);
525
                op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + (curN64Stage%2);
526
                op->op = CM_MULTIPLYADD;
527
                op->Arg1 = MUX_COMBINED;
528
                op->Arg2 = m.c;
529
                op->Arg0 = m.d;
530
                gci.stages[curStage].dwTexture = toTex(m.d);
531
                textureUsedInStage[curStage][curN64Stage%2] = true;
532
                resultIsGood = true;
533
            }
534
            else
535
            {
536
                op->op = CM_MODULATE;
537
                op->Arg1 = m.a;
538
                op->Arg2 = m.c;
539
                op->Arg0 = CM_IGNORE;
540
                gci.stages[curStage].dwTexture = toTex(m.a);
541
                textureUsedInStage[curStage][curN64Stage%2] = true;
542
                NextStage(curStage);
543
                op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + (curN64Stage%2);
544
                op->op = CM_ADD;
545
                op->Arg1 = MUX_COMBINED;
546
                op->Arg2 = m.d;
547
                op->Arg0 = CM_IGNORE;
548
                gci.stages[curStage].dwTexture = toTex(m.d);
549
                textureUsedInStage[curStage][curN64Stage%2] = true;
550
                resultIsGood = false;
551
            }
552
        }
553
        else
554
        {
555
            // There are two textures
556
            int texToUse = CheckWhichTexToUseInThisStage(curN64Stage, curStage, gci);
557
            op->op =CM_REPLACE;
558
            op->Arg1 = (MUX_TEXEL0+texToUse);
559
            op->Arg2 = CM_IGNORE;
560
            op->Arg0 = CM_IGNORE;
561
            gci.stages[curStage].dwTexture = texToUse;
562
            textureUsedInStage[curStage][curN64Stage%2] = true;
563

564
            (*m_ppGeneralDecodedMux)->ReplaceVal(MUX_TEXEL0+texToUse, MUX_COMBINED, curN64Stage);
565

566
            NextStage(curStage);
567
            Check1TxtrForAlpha(curN64Stage, curStage, gci, GetTexelNumber(m));
568
            op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + (curN64Stage%2);
569

570
            m.a = MUX_COMBINED;
571
            m.c = MUX_TEXEL0+(1-texToUse);
572
            m.b = m.d = 0;
573
            curStage = GenCI_Type_A_MOD_C(curN64Stage, curStage, gci);
574
        }
575
    }
576
    else if( CountTexel1Cycle(m) == 1 )
577
    {
578
        if( m_dwGeneralMaxStages < 4 )
579
        {
580
            Check1TxtrForAlpha(curN64Stage, curStage, gci, GetTexelNumber(m));
581
            op->Arg1 = (MUX_TEXEL0+GetTexelNumber(m));
582
            if( (*m_ppGeneralDecodedMux)->isUsedInCycle(MUX_SHADE, curN64Stage) )
583
            {
584
                op->op =CM_MODULATE;
585
                op->Arg2 = MUX_SHADE;
586
            }
587
            else
588
            {
589
                op->op =CM_REPLACE;
590
                op->Arg2 = 0;
591
            }
592
            op->Arg0 = CM_IGNORE;
593
            gci.stages[curStage].dwTexture = GetTexelNumber(m);
594
            textureUsedInStage[curStage][curN64Stage%2] = true;
595
        }
596
        else
597
        {
598
            curStage = GenCI_Type_A_SUB_B_MOD_C(curN64Stage, curStage, gci);
599
            m.a = MUX_COMBINED;
600
            NextStage(curStage);
601
            curStage = GenCI_Type_A_ADD_D(curN64Stage, curStage, gci);
602
        }
603
    }
604
    else
605
    {
606
        m.d = 0;
607
        curStage = GenCI_Type_A_SUB_B_MOD_C(curN64Stage, curStage, gci);
608
        m = save;
609
        m.a = MUX_COMBINED;
610
        m.b = m.c = 0;
611
        NextStage(curStage);
612
        curStage = GenCI_Type_A_ADD_D(curN64Stage, curStage, gci);
613
    }
614

615
    m = save;
616
    return curStage;
617
}
618

619
int CGeneralCombiner::GenCI_Type_A_SUB_B_ADD_D(int curN64Stage, int curStage, GeneralCombinerInfo &gci)
620
{
621
    N64CombinerType &m = (*m_ppGeneralDecodedMux)->m_n64Combiners[curN64Stage];
622

623
    N64CombinerType save = m;
624
    m.d = MUX_0;
625
    curStage = GenCI_Type_A_SUB_B(curN64Stage, curStage, gci);
626
    m = save;
627
    m.a = MUX_COMBINED;
628
    m.b = MUX_0;
629
    NextStage(curStage);
630
    curStage = GenCI_Type_A_ADD_D(curN64Stage, curStage, gci);
631
    m = save;
632

633
    return curStage;
634
}
635

636

637
int CGeneralCombiner::GenCI_Type_A_ADD_B_MOD_C(int curN64Stage, int curStage, GeneralCombinerInfo &gci)
638
{
639
    N64CombinerType &m = (*m_ppGeneralDecodedMux)->m_n64Combiners[curN64Stage];
640

641
    N64CombinerType save = m;
642
    m.d = m.b; m.b = 0;
643
    curStage = GenCI_Type_A_ADD_D(curN64Stage, curStage, gci);
644
    m = save;
645
    m.b = MUX_0;
646
    m.a = MUX_COMBINED;
647
    NextStage(curStage);
648
    curStage = GenCI_Type_A_MOD_C(curN64Stage, curStage, gci);
649
    m = save;
650

651
    return curStage;
652
}
653

654
int CGeneralCombiner::GenCI_Type_A_B_C_A(int curN64Stage, int curStage, GeneralCombinerInfo &gci)
655
{
656
    // We can not do too much with this type, it is not a bad idea to use LERP to simplify it.
657
    //return GenCI_Type_A_LERP_B_C(curN64Stage, curStage, gci);
658
    return GenCI_Type_A_B_C_D(curN64Stage, curStage, gci);
659
}
660

661
int CGeneralCombiner::GenCI_Type_A_SUB_B_MOD_C(int curN64Stage, int curStage, GeneralCombinerInfo &gci)
662
{
663
    N64CombinerType &m = (*m_ppGeneralDecodedMux)->m_n64Combiners[curN64Stage];
664

665
    N64CombinerType save = m;
666
    m.c = MUX_0;
667
    curStage = GenCI_Type_A_SUB_B(curN64Stage, curStage, gci);
668
    m = save;
669
    m.b = MUX_0;
670
    m.a = MUX_COMBINED;
671
    NextStage(curStage);
672
    curStage = GenCI_Type_A_MOD_C(curN64Stage, curStage, gci);
673
    m = save;
674

675
    return curStage;
676
}
677

678
 /////////////////////////////////////
679
 // End of gci generating functions //
680
 /////////////////////////////////////
681

682

683
void CGeneralCombiner::SkipStage(StageOperate &op, int &curStage)
684
{
685
    op.op = CM_REPLACE;
686
    op.Arg1 = MUX_COMBINED;
687
    op.Arg2 = CM_IGNORE;
688
    op.Arg0 = CM_IGNORE;
689
    NextStage(curStage);
690
}
691

692
void CGeneralCombiner::NextStage(int &curStage)
693
{
694
    if( curStage < m_dwGeneralMaxStages-1 )
695
    {
696
        curStage++;
697
    }
698
    else
699
    {
700
        curStage++;
701
        resultIsGood = false;
702
        TRACE0("Stage overflow");
703
    }
704
}
705

706
void CGeneralCombiner::Check1TxtrForAlpha(int curN64Stage, int &curStage, GeneralCombinerInfo &gci, int tex)
707
{
708
    N64CombinerType &m = (*m_ppGeneralDecodedMux)->m_n64Combiners[curN64Stage];
709
    if( curN64Stage%2 && IsTxtrUsed(m) )
710
    {
711
        while (curStage<m_dwGeneralMaxStages-1 && textureUsedInStage[curStage][0] && gci.stages[curStage].dwTexture != (unsigned int)(tex) )
712
        {
713
            StageOperate &op = ((StageOperate*)(&(gci.stages[curStage].colorOp)))[curN64Stage%2];
714
            SkipStage(op, curStage);
715
        }
716
    }
717
}
718

719

720
int CGeneralCombiner::Check2TxtrForAlpha(int curN64Stage, int &curStage, GeneralCombinerInfo &gci, int tex1, int tex2)
721
{
722
    N64CombinerType &m = (*m_ppGeneralDecodedMux)->m_n64Combiners[curN64Stage];
723
    if( curN64Stage%2 && IsTxtrUsed(m) )
724
    {
725
        if( tex1 == tex2 )
726
        {
727
            while (curStage<m_dwGeneralMaxStages-1 && textureUsedInStage[curStage][0] && gci.stages[curStage].dwTexture != (unsigned int)tex1 )
728
            {
729
                StageOperate &op = ((StageOperate*)(&(gci.stages[curStage].colorOp)))[curN64Stage%2];
730
                SkipStage(op, curStage);
731
            }
732
            return 1;
733
        }
734
        else
735
        {
736
            int stage1 = curStage;
737
            int stage2 = curStage;
738

739
            while (stage1<m_dwGeneralMaxStages-1 && textureUsedInStage[stage1][0] && gci.stages[stage1].dwTexture != (unsigned int)tex1 )
740
            {
741
                StageOperate &op = ((StageOperate*)(&(gci.stages[stage1].colorOp)))[curN64Stage%2];
742
                SkipStage(op, stage1);
743
            }
744

745
            while (stage2<m_dwGeneralMaxStages-1 && textureUsedInStage[stage2][0] && gci.stages[stage2].dwTexture != (unsigned int)tex2 )
746
            {
747
                StageOperate &op = ((StageOperate*)(&(gci.stages[stage2].colorOp)))[curN64Stage%2];
748
                SkipStage(op, stage2);
749
            }
750

751
            if( stage1 <= stage2 )
752
            {
753
                curStage = stage1;
754
                return 1;
755
            }
756
            else
757
            {
758
                curStage = stage2;
759
                return 2;
760
            }
761
        }
762
    }
763
    else
764
    {
765
        return 0;
766
    }
767
}
768

769

770
int CGeneralCombiner::CheckWhichTexToUseInThisStage(int curN64Stage, int curStage, GeneralCombinerInfo &gci)
771
{
772
    // There are two texels to used, which one I should use in the current DirectX stage?
773
    if( curN64Stage%2 )
774
    {
775
        if( !textureUsedInStage[curStage][0] )
776
            return 0;
777
        else
778
            return gci.stages[curStage].dwTexture;
779
    }
780
    else
781
    {
782
        return 0;
783
    }
784
}
785

786
/*
787
 *  
788
 */
789

790
int CGeneralCombiner::ParseDecodedMux()
791
{
792
    GeneralCombinerInfo gci;
793
    int stages[2];
794

795
    DecodedMux &mux = *(*m_ppGeneralDecodedMux);
796

797
    GenCI_Init(gci);
798

799
    for( int i=0; i<2; i++ )
800
    {
801
        //i=0       Color Channel
802
        //i=1       Alpha Channel
803

804
        stages[i] = 0;
805
        int n=0;    //stage count
806

807
        for( int j=0; j<2; j++ )
808
        {
809
            switch( mux.splitType[i+j*2] )
810
            {
811
            case CM_FMT_TYPE_NOT_USED:
812
                continue;
813
            case CM_FMT_TYPE_D:     // = D
814
                // Alpha channel is using different texture from color channel
815
                // and the color channel has already used texture, so alpha
816
                // channel can not use different texture for this stage anymore,
817
                // alpha channel need to skip a stage
818
                n = GenCI_Type_D(j*2+i, n, gci);
819
                if( j==0 && mux.splitType[i+2] != CM_FMT_TYPE_NOT_USED ) NextStage(n);  else n++;
820
                break;
821
            case CM_FMT_TYPE_A_ADD_D:       // = A+D
822
                n=GenCI_Type_A_ADD_D(j*2+i, n, gci);
823
                if( j==0 && mux.splitType[i+2] != CM_FMT_TYPE_NOT_USED ) NextStage(n);  else n++;
824
                break;
825
            case CM_FMT_TYPE_A_MOD_C:       // = A*C        can mapped to MOD(arg1,arg2)
826
                n=GenCI_Type_A_MOD_C(j*2+i, n, gci);
827
                if( j==0 && mux.splitType[i+2] != CM_FMT_TYPE_NOT_USED ) NextStage(n);  else n++;
828
                break;
829
            case CM_FMT_TYPE_A_SUB_B:       // = A-B        can mapped to SUB(arg1,arg2)
830
                n=GenCI_Type_A_SUB_B(j*2+i, n, gci);
831
                if( j==0 && mux.splitType[i+2] != CM_FMT_TYPE_NOT_USED ) NextStage(n);  else n++;
832
                break;
833
            case CM_FMT_TYPE_A_MOD_C_ADD_D:     // = A*C+D      can mapped to MULTIPLYADD(arg1,arg2,arg0)
834
                n=GenCI_Type_A_MOD_C_ADD_D(j*2+i, n, gci);
835
                if( j==0 && mux.splitType[i+2] != CM_FMT_TYPE_NOT_USED ) NextStage(n);  else n++;
836
                break;
837
            case CM_FMT_TYPE_A_LERP_B_C:        // = (A-B)*C+B  can mapped to LERP(arg1,arg2,arg0)
838
                                    //              or mapped to BLENDALPHA(arg1,arg2) if C is
839
                                    //              alpha channel or DIF, TEX, FAC, CUR
840
                n=GenCI_Type_A_LERP_B_C(j*2+i, n, gci);
841
                if( j==0 && mux.splitType[i+2] != CM_FMT_TYPE_NOT_USED ) NextStage(n);  else n++;
842
                break;
843
            case CM_FMT_TYPE_A_SUB_B_ADD_D:     // = A-B+C      can not map very well in 1 stage
844
                n=GenCI_Type_A_SUB_B_ADD_D(j*2+i, n, gci);
845
                if( j==0 && mux.splitType[i+2] != CM_FMT_TYPE_NOT_USED ) NextStage(n);  else n++;
846
                break;
847
            case CM_FMT_TYPE_A_SUB_B_MOD_C:     // = (A-B)*C    can not map very well in 1 stage
848
                n=GenCI_Type_A_SUB_B_MOD_C(j*2+i, n, gci);
849
                if( j==0 && mux.splitType[i+2] != CM_FMT_TYPE_NOT_USED ) NextStage(n);  else n++;
850
                break;
851
            case CM_FMT_TYPE_A_ADD_B_MOD_C:
852
                n=GenCI_Type_A_ADD_B_MOD_C(j*2+i, n, gci);
853
                if( j==0 && mux.splitType[i+2] != CM_FMT_TYPE_NOT_USED ) NextStage(n);  else n++;
854
                break;
855
            case CM_FMT_TYPE_A_B_C_A:
856
                n=GenCI_Type_A_B_C_A(j*2+i, n, gci);
857
                if( j==0 && mux.splitType[i+2] != CM_FMT_TYPE_NOT_USED ) NextStage(n);  else n++;
858
                break;
859
            case CM_FMT_TYPE_A_B_C_D:       // = (A-B)*C+D  can not map very well in 1 stage
860
                n=GenCI_Type_A_B_C_D(j*2+i, n, gci);
861
                if( j==0 && mux.splitType[i+2] != CM_FMT_TYPE_NOT_USED ) NextStage(n);  else n++;
862
                break;
863
             default:
864
               break;
865
            }
866
        }
867
        stages[i] = n;
868
    }
869

870
    gci.nStages = max(stages[0], stages[1]);
871
    if( gci.nStages > m_dwGeneralMaxStages )
872
    {
873
        resultIsGood = false;
874
        gci.nStages = m_dwGeneralMaxStages;
875
    }
876

877
    if( mux.m_ColorTextureFlag[0] != 0 || mux.m_ColorTextureFlag[1] != 0  )
878
    {
879
        resultIsGood = false;
880
    }
881

882
    // The bResultIsGoodWithinStages is for Semi-Pixel shader combiner, don't move the code down
883
    gci.bResultIsGoodWithinStages = resultIsGood;
884
    if( mux.HowManyConstFactors() > 1 || gci.specularPostOp != MUX_0 || gci.blendingFunc != ENABLE_BOTH )
885
    {
886
        gci.bResultIsGoodWithinStages = false;
887
    }
888

889
    if( gci.nStages > stages[0] )   // Color has less stages
890
    {
891
        for( int i=stages[0]; i<gci.nStages; i++ )
892
        {
893
            gci.stages[i].colorOp.op = CM_REPLACE;
894
            gci.stages[i].colorOp.Arg1 = MUX_COMBINED;
895
            gci.stages[i].colorOp.Arg2 = CM_IGNORE;
896
            gci.stages[i].colorOp.Arg0 = CM_IGNORE;
897
        }
898
    }
899

900
    if( gci.nStages > stages[1] )   // Color has less stages
901
    {
902
        for( int i=stages[1]; i<gci.nStages; i++ )
903
        {
904
            gci.stages[i].alphaOp.op = CM_REPLACE;
905
            gci.stages[i].alphaOp.Arg1 = MUX_COMBINED;
906
            gci.stages[i].alphaOp.Arg2 = CM_IGNORE;
907
            gci.stages[i].alphaOp.Arg0 = CM_IGNORE;
908
        }
909
    }
910

911
    for( int i=0;i<gci.nStages;i++)
912
    {
913
        gci.stages[i].bTextureUsed = IsTextureUsedInStage(gci.stages[i]);
914
    }
915

916
    if( !resultIsGood && gci.nStages >= m_dwGeneralMaxStages )
917
    {
918
        extern int noOfTwoStages;
919
        extern GeneralCombinerInfo twostages[];
920

921
        for( int k=0; k<noOfTwoStages; k++ )
922
        {
923
            GeneralCombinerInfo &info = twostages[k];
924
            if( (mux.m_dwMux0 == info.dwMux0 && mux.m_dwMux1 == info.dwMux1) ||
925
                (info.dwMux0+info.dwMux1 == 0 && info.muxDWords[0] == mux.m_dWords[0] && 
926
                info.muxDWords[1] == mux.m_dWords[1] && info.muxDWords[2] == mux.m_dWords[2] && 
927
                info.muxDWords[3] == mux.m_dWords[3] && info.m_dwShadeAlphaChannelFlag == mux.m_dwShadeAlphaChannelFlag &&
928
                info.m_dwShadeColorChannelFlag == mux.m_dwShadeColorChannelFlag ) )
929
            {
930
                memcpy(&gci, &info, sizeof(GeneralCombinerInfo) );
931
                resultIsGood = true;
932
                break;
933
            }
934
        }
935
    }
936

937
#ifdef DEBUGGER
938
    if( !resultIsGood )
939
    {
940
        DecodedMux &mux = *(*m_ppGeneralDecodedMux);
941
        // Generated combiner mode is not good enough within the limited stages
942
        DebuggerAppendMsg("\n/*");
943
        mux.DisplayMuxString("Overflowed");
944
        mux.DisplaySimpliedMuxString("Overflowed");
945
        DebuggerAppendMsg("Generated combiners:");
946
        General_DisplayBlendingStageInfo(gci);
947
        DebuggerAppendMsg("*/\n");
948
        DebuggerAppendMsg("\n\n");
949
        DebuggerAppendMsg("{\n\t0x%08X, 0x%08X, 0x%08X, 0x%08X,\t// Simplified mux\n\t0x%08X, 0x%08X,\t\t// 64bit Mux\n",
950
            mux.m_dWords[0],mux.m_dWords[1],mux.m_dWords[2],mux.m_dWords[3],mux.m_dwMux0,mux.m_dwMux1);
951
        DebuggerAppendMsg("\t%d,\t// number of stages\n\tENABLE_BOTH,\n\t0,\t\t// Constant color\n\t0x%08X, 0x%08X, 0,\t// Shade and specular color flags\n\t0x%08X, 0x%08X,\t// constant color texture flags\n",
952
            2,mux.m_dwShadeColorChannelFlag, mux.m_dwShadeAlphaChannelFlag,mux.m_ColorTextureFlag[0],mux.m_ColorTextureFlag[1]);
953
        DebuggerAppendMsg("\t{\n\t\t{MOD(T0,DIF), MOD(T0,DIF), 0, true},    // Stage 0\n");
954
        DebuggerAppendMsg("\t\t{MOD(T0,DIF), SKIP, 1, true},    // Stage 1\n\t}\n},");
955
    }
956
#else
957
    if( !resultIsGood )
958
    {
959
        FILE *fp=NULL;
960
        fp = fopen("C:\\rice\\RiceVideoMUX.log","a");
961
        if( fp )
962
        {
963
            fprintf(fp,"\n/*\n");
964
            mux.LogMuxString("Overflowed",fp);
965
            fprintf(fp,"\n\n");
966
            mux.LogSimpliedMuxString("Overflowed",fp);
967
            fprintf(fp,"Generated combiners:");
968
            //General_DisplayBlendingStageInfo(gci);
969
            fprintf(fp,"\n*/\n");
970
            fprintf(fp,"\n");
971
            fprintf(fp,"{\n\t0x%08X, 0x%08X, 0x%08X, 0x%08X,\t// Simplified mux\n\t0x%08X, 0x%08X,\t\t// 64bit Mux\n",
972
                mux.m_dWords[0],mux.m_dWords[1],mux.m_dWords[2],mux.m_dWords[3],mux.m_dwMux0,mux.m_dwMux1);
973
            fprintf(fp,"\t%d,\t// number of stages\n\tENABLE_BOTH,\n\tMUX_ENV,\t\t// Constant color\n\t0x%08X, 0x%08X, 0,\t// Shade and specular color flags\n\t0x%08X, 0x%08X,\t// constant color texture flags\n",
974
                2,mux.m_dwShadeColorChannelFlag, mux.m_dwShadeAlphaChannelFlag,mux.m_ColorTextureFlag[0],mux.m_ColorTextureFlag[1]);
975
            fprintf(fp,"\t{\n\t\t{MOD(T0,DIF), MOD(T0,DIF), 0, true},   // Stage 0\n");
976
            fprintf(fp,"\t\t{LERP(T1,CUR,DIF), SKIP, 1, true},  // Stage 1\n\t}\n},");
977

978
            fclose(fp);
979
        }
980
    }
981
#endif
982

983
    return SaveParserResult(gci);
984
}
985

986

987
bool CGeneralCombiner::IsTextureUsedInStage(GeneralCombineStage &stage)
988
{
989
    if( (stage.colorOp.Arg1&MUX_MASK)==MUX_TEXEL0 || (stage.colorOp.Arg2&MUX_MASK)==MUX_TEXEL0 || (stage.colorOp.Arg0 &MUX_MASK)==MUX_TEXEL0 ||
990
        (stage.alphaOp.Arg1&MUX_MASK)==MUX_TEXEL0 || (stage.alphaOp.Arg2&MUX_MASK)==MUX_TEXEL0 || (stage.alphaOp.Arg0 &MUX_MASK)==MUX_TEXEL0 ||
991
        (stage.colorOp.Arg1&MUX_MASK)==MUX_TEXEL1 || (stage.colorOp.Arg2&MUX_MASK)==MUX_TEXEL1 || (stage.colorOp.Arg0 &MUX_MASK)==MUX_TEXEL1 ||
992
        (stage.alphaOp.Arg1&MUX_MASK)==MUX_TEXEL1 || (stage.alphaOp.Arg2&MUX_MASK)==MUX_TEXEL1 || (stage.alphaOp.Arg0 &MUX_MASK)==MUX_TEXEL1 )
993
    {
994
        return true;
995
    }
996
    else
997
        return false;
998
}
999

1000

1001
int CGeneralCombiner::SaveParserResult(GeneralCombinerInfo &result)
1002
{
1003
    result.muxDWords[0] = (*m_ppGeneralDecodedMux)->m_dWords[0];
1004
    result.muxDWords[1] = (*m_ppGeneralDecodedMux)->m_dWords[1];
1005
    result.muxDWords[2] = (*m_ppGeneralDecodedMux)->m_dWords[2];
1006
    result.muxDWords[3] = (*m_ppGeneralDecodedMux)->m_dWords[3];
1007
    result.m_dwShadeAlphaChannelFlag = (*m_ppGeneralDecodedMux)->m_dwShadeAlphaChannelFlag;
1008
    result.m_dwShadeColorChannelFlag = (*m_ppGeneralDecodedMux)->m_dwShadeColorChannelFlag;
1009
    result.colorTextureFlag[0] = (*m_ppGeneralDecodedMux)->m_ColorTextureFlag[0];
1010
    result.colorTextureFlag[1] = (*m_ppGeneralDecodedMux)->m_ColorTextureFlag[1];
1011
    result.dwMux0 = (*m_ppGeneralDecodedMux)->m_dwMux0;
1012
    result.dwMux1 = (*m_ppGeneralDecodedMux)->m_dwMux1;
1013

1014
    m_vCompiledCombinerStages.push_back(result);
1015
    m_lastGeneralIndex = m_vCompiledCombinerStages.size()-1;
1016

1017
    return m_lastGeneralIndex;
1018
}
1019

1020

1021
int CGeneralCombiner::FindCompiledMux( )
1022
{
1023
#ifdef DEBUGGER
1024
    if( debuggerDropCombiners || debuggerDropGeneralCombiners )
1025
    {
1026
        m_vCompiledCombinerStages.clear();
1027
        //m_dwLastMux0 = m_dwLastMux1 = 0;
1028
        debuggerDropCombiners = false;
1029
        debuggerDropGeneralCombiners = false;
1030
    }
1031
#endif
1032

1033
    for( uint32 i=0; i<m_vCompiledCombinerStages.size(); i++ )
1034
    {
1035
        if( m_vCompiledCombinerStages[i].dwMux0 == (*m_ppGeneralDecodedMux)->m_dwMux0 && m_vCompiledCombinerStages[i].dwMux1 == (*m_ppGeneralDecodedMux)->m_dwMux1 )
1036
        {
1037
            m_lastGeneralIndex = i;
1038
            return i;
1039
        }
1040
    }
1041

1042
    return -1;
1043
}
1044

1045

1046

1047
bool LM_textureUsedInStage[8];
1048
void CGeneralCombiner::LM_GenCI_Init(GeneralCombinerInfo &gci)
1049
{
1050
    gci.specularPostOp=gci.TFactor=MUX_0;
1051

1052
    gci.blendingFunc = ENABLE_BOTH;
1053

1054
    for( int i=0; i<8; i++)
1055
    {
1056
        gci.stages[i].dwTexture = 0;
1057
        LM_textureUsedInStage[i] = false;
1058
    }
1059
}
1060

1061

1062
//#define fillstage(opr,a1,a2,a3)   {op->op=opr;op->Arg1=a1;op->Arg2=a2;op->Arg0=a3;curStage++;}
1063
inline void FillStage(StageOperate &op, uint32 opr, uint32 a1, uint32 a2, uint32 a3)
1064
{
1065
    op.op = opr;
1066
    op.Arg1 = a1;
1067
    op.Arg2 = a2;
1068
    op.Arg0 = a3;
1069
}
1070

1071
/************************************************************************/
1072
/* New functions, will generate stages within stage limited             */
1073
/* and return the number of stages used.                                */
1074
/************************************************************************/
1075
int CGeneralCombiner::LM_GenCI_Type_D(N64CombinerType &m, int curStage, int limit, int channel, bool checktexture, GeneralCombinerInfo &gci)
1076
{
1077
    int originalstage=curStage;
1078
    StageOperate *op = ((StageOperate*)(&(gci.stages[curStage]))) + channel;
1079
    if( checktexture && LM_Check1TxtrForAlpha(curStage, gci, m.d ) )
1080
    {
1081
        if( limit > 1 )
1082
        {
1083
            FillStage(*op,CM_REPLACE,MUX_COMBINED,CM_IGNORE,CM_IGNORE);
1084
            curStage++;
1085
            op = ((StageOperate*)(&(gci.stages[curStage]))) + channel;
1086
            FillStage(*op,CM_REPLACE,m.d,CM_IGNORE,CM_IGNORE);
1087
        }
1088
        else
1089
        {
1090
            // It is not allowed to use two stages, what to do?
1091
            // It should not happen anyway
1092
            TRACE0("Check me here, at LM_GenCI_Type_D");
1093
        }
1094
    }
1095
    else
1096
    {
1097
        FillStage(*op,CM_REPLACE,m.d,CM_IGNORE,CM_IGNORE);
1098
    }
1099

1100
    gci.stages[curStage].dwTexture = GetTexelNumber(m);
1101
    LM_textureUsedInStage[curStage] = IsTxtrUsed(m);
1102
    curStage++;
1103

1104
    return curStage-originalstage;
1105
}
1106
int CGeneralCombiner::LM_GenCI_Type_A_MOD_C(N64CombinerType &m, int curStage, int limit, int channel, bool checktexture, GeneralCombinerInfo &gci, uint32 dxop)
1107
{
1108
    int originalstage=curStage;
1109
    StageOperate *op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + channel;
1110

1111
    int numberOfTex = CountTexel1Cycle(m);
1112

1113
    if( numberOfTex == 2 )
1114
    {
1115
        // As we can not use both texture in one stage
1116
        // we split them to two stages
1117
        // Stage1: SELECT   txt1
1118
        // Stage2: MOD      txt2
1119

1120
        if( checktexture )
1121
        {
1122
            if( LM_Check1TxtrForAlpha(curStage, gci, m.a ) )
1123
            {
1124
                FillStage(*op,CM_REPLACE,m.c,CM_IGNORE,CM_IGNORE);
1125
                gci.stages[curStage].dwTexture = toTex(m.c);
1126
                LM_textureUsedInStage[curStage] = true;
1127
                curStage++;
1128

1129
                op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + channel;
1130
                FillStage(*op,dxop,m.a,MUX_COMBINED,CM_IGNORE);
1131
                gci.stages[curStage].dwTexture = toTex(m.a);
1132
                LM_textureUsedInStage[curStage] = true;
1133
                curStage++;
1134
            }
1135
            else
1136
            {
1137
                FillStage(*op,CM_REPLACE,m.a,CM_IGNORE,CM_IGNORE);
1138
                gci.stages[curStage].dwTexture = toTex(m.a);
1139
                LM_textureUsedInStage[curStage] = true;
1140
                curStage++;
1141

1142
                op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + channel;
1143
                FillStage(*op,dxop,m.c,MUX_COMBINED,CM_IGNORE);
1144
                gci.stages[curStage].dwTexture = toTex(m.c);
1145
                LM_textureUsedInStage[curStage] = true;
1146
                curStage++;
1147
            }
1148
        }
1149
        else
1150
        {
1151
            FillStage(*op,CM_REPLACE,m.a,CM_IGNORE,CM_IGNORE);
1152
            gci.stages[curStage].dwTexture = toTex(m.a);
1153
            LM_textureUsedInStage[curStage] = true;
1154
            curStage++;
1155

1156
            op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + channel;
1157
            FillStage(*op,dxop,m.c,MUX_COMBINED,CM_IGNORE);
1158
            gci.stages[curStage].dwTexture = toTex(m.c);
1159
            LM_textureUsedInStage[curStage] = true;
1160
            curStage++;
1161
        }
1162
    }
1163
    else if( numberOfTex == 1)
1164
    {
1165
        if( checktexture )
1166
        {
1167
            if( isTex(m.a) )
1168
            {
1169
                if( LM_Check1TxtrForAlpha(curStage, gci, m.a ) )
1170
                {
1171
                    FillStage(*op,CM_REPLACE,m.c,CM_IGNORE,CM_IGNORE);
1172
                    curStage++;
1173

1174
                    op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + channel;
1175
                    FillStage(*op,dxop,m.a,MUX_COMBINED,CM_IGNORE);
1176
                    gci.stages[curStage].dwTexture = toTex(m.a);
1177
                    LM_textureUsedInStage[curStage] = true;
1178
                    curStage++;
1179
                }
1180
                else
1181
                {
1182
                    FillStage(*op,CM_REPLACE,m.a,CM_IGNORE,CM_IGNORE);
1183
                    gci.stages[curStage].dwTexture = toTex(m.a);
1184
                    LM_textureUsedInStage[curStage] = true;
1185
                    curStage++;
1186

1187
                    op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + channel;
1188
                    FillStage(*op,dxop,m.c,MUX_COMBINED,CM_IGNORE);
1189
                    curStage++;
1190
                }
1191
            }
1192
            else
1193
            {
1194
                if( LM_Check1TxtrForAlpha(curStage, gci, m.c ) )
1195
                {
1196
                    FillStage(*op,CM_REPLACE,m.a,CM_IGNORE,CM_IGNORE);
1197
                    curStage++;
1198

1199
                    op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + channel;
1200
                    FillStage(*op,dxop,m.c,MUX_COMBINED,CM_IGNORE);
1201
                    gci.stages[curStage].dwTexture = toTex(m.c);
1202
                    LM_textureUsedInStage[curStage] = true;
1203
                    curStage++;
1204
                }
1205
                else
1206
                {
1207
                    FillStage(*op,CM_REPLACE,m.c,CM_IGNORE,CM_IGNORE);
1208
                    gci.stages[curStage].dwTexture = toTex(m.c);
1209
                    LM_textureUsedInStage[curStage] = true;
1210
                    curStage++;
1211

1212
                    op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + channel;
1213
                    FillStage(*op,dxop,m.a,MUX_COMBINED,CM_IGNORE);
1214
                    curStage++;
1215
                }
1216
            }
1217
        }
1218
        else
1219
        {
1220
            if( isTex(m.a) )
1221
            {
1222
                FillStage(*op,CM_REPLACE,m.a,CM_IGNORE,CM_IGNORE);
1223
                gci.stages[curStage].dwTexture = toTex(m.a);
1224
                LM_textureUsedInStage[curStage] = true;
1225
                curStage++;
1226

1227
                op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + channel;
1228
                FillStage(*op,dxop,m.c,MUX_COMBINED,CM_IGNORE);
1229
                curStage++;
1230
            }
1231
            else
1232
            {
1233
                FillStage(*op,CM_REPLACE,m.c,CM_IGNORE,CM_IGNORE);
1234
                gci.stages[curStage].dwTexture = toTex(m.c);
1235
                LM_textureUsedInStage[curStage] = true;
1236
                curStage++;
1237

1238
                op = ((StageOperate*)(&(gci.stages[curStage].colorOp))) + channel;
1239
                FillStage(*op,dxop,m.a,MUX_COMBINED,CM_IGNORE);
1240
                curStage++;
1241
            }
1242

1243
        }
1244
    }
1245
    else
1246
    {
1247
        FillStage(*op,dxop,m.a,m.c,CM_IGNORE);
1248
        curStage++;
1249
    }
1250

1251
    return curStage-originalstage;
1252
}
1253
int CGeneralCombiner::LM_GenCI_Type_A_ADD_D(N64CombinerType &m, int curStage, int limit, int channel, bool checktexture, GeneralCombinerInfo &gci)
1254
{
1255
    return 0;
1256
}
1257
int CGeneralCombiner::LM_GenCI_Type_A_SUB_B(N64CombinerType &m, int curStage, int limit, int channel, bool checktexture, GeneralCombinerInfo &gci)
1258
{
1259
    return 0;
1260
}
1261
int CGeneralCombiner::LM_GenCI_Type_A_LERP_B_C(N64CombinerType &m, int curStage, int limit, int channel, bool checktexture, GeneralCombinerInfo &gci)
1262
{
1263
    return 0;
1264
}
1265
int CGeneralCombiner::LM_GenCI_Type_A_MOD_C_ADD_D(N64CombinerType &m, int curStage, int limit, int channel, bool checktexture, GeneralCombinerInfo &gci)
1266
{
1267
    return 0;
1268
}
1269
int CGeneralCombiner::LM_GenCI_Type_A_SUB_B_ADD_D(N64CombinerType &m, int curStage, int limit, int channel, bool checktexture, GeneralCombinerInfo &gci)
1270
{
1271
    return 0;
1272
}
1273
int CGeneralCombiner::LM_GenCI_Type_A_SUB_B_MOD_C(N64CombinerType &m, int curStage, int limit, int channel, bool checktexture, GeneralCombinerInfo &gci)
1274
{
1275
    return 0;
1276
}
1277
int CGeneralCombiner::LM_GenCI_Type_A_ADD_B_MOD_C(N64CombinerType &m, int curStage, int limit, int channel, bool checktexture, GeneralCombinerInfo &gci)
1278
{
1279
    return 0;
1280
}
1281
int CGeneralCombiner::LM_GenCI_Type_A_B_C_D(N64CombinerType &m, int curStage, int limit, int channel, bool checktexture, GeneralCombinerInfo &gci)
1282
{
1283
    return 0;
1284
}
1285
int CGeneralCombiner::LM_GenCI_Type_A_B_C_A(N64CombinerType &m, int curStage, int limit, int channel, bool checktexture, GeneralCombinerInfo &gci)
1286
{
1287
    return 0;
1288
}
1289

1290
int CGeneralCombiner::LM_ParseDecodedMux()
1291
{
1292
    return 0;
1293
}
1294

1295
bool CGeneralCombiner::LM_Check1TxtrForAlpha(int curStage, GeneralCombinerInfo &gci, uint32 val )
1296
{
1297
    return !( isTex(val) && LM_textureUsedInStage[curStage] && gci.stages[curStage].dwTexture != (unsigned int)toTex(val) );
1298
}
1299

1300

1301
void CGeneralCombiner::LM_SkipStage(StageOperate &op)
1302
{
1303
    op.op = CM_REPLACE;
1304
    op.Arg1 = MUX_COMBINED;
1305
    op.Arg2 = CM_IGNORE;
1306
    op.Arg0 = CM_IGNORE;
1307
}
1308

1309

1310
Product

Resources

Company
