~ubuntu-branches/ubuntu/karmic/xmame/karmic

« back to all changes in this revision

Viewing changes to src/vidhrdw/vooddefs.h

  • Committer: Bazaar Package Importer
  • Author(s): Bruno Barrera C.
  • Date: 2007-02-16 10:06:54 UTC
  • mfrom: (2.1.5 edgy)
  • Revision ID: james.westby@ubuntu.com-20070216100654-iztas2cl47k5j039
Tags: 0.106-2
* Added Italian debconf templates translation. (closes: #382672)
* Added German debconf templates translation. (closes: #396610)
* Added Japanese debconf templates translation. (closes: #400011)
* Added Portuguese debconf templates translation. (closes: #409960)

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/*************************************************************************
 
2
 
 
3
    3dfx Voodoo Graphics SST-1/2 emulator
 
4
 
 
5
    emulator by Aaron Giles
 
6
 
 
7
**************************************************************************/
 
8
 
 
9
 
 
10
/*************************************
 
11
 *
 
12
 *  Misc. constants
 
13
 *
 
14
 *************************************/
 
15
 
 
16
/* enumeration describing reasons we might be stalled */
 
17
enum
 
18
{
 
19
        NOT_STALLED = 0,
 
20
        STALLED_UNTIL_FIFO_LWM,
 
21
        STALLED_UNTIL_FIFO_EMPTY
 
22
};
 
23
 
 
24
/* maximum number of TMUs */
 
25
#define MAX_TMU                                 2
 
26
 
 
27
/* accumulate operations less than this number of clocks */
 
28
#define ACCUMULATE_THRESHOLD    0
 
29
 
 
30
/* number of clocks to set up a triangle (just a guess) */
 
31
#define TRIANGLE_SETUP_CLOCKS   100
 
32
 
 
33
/* maximum number of rasterizers */
 
34
#define MAX_RASTERIZERS                 1024
 
35
 
 
36
/* size of the rasterizer hash table */
 
37
#define RASTER_HASH_SIZE                97
 
38
 
 
39
/* flags for LFB writes */
 
40
#define LFB_RGB_PRESENT                 1
 
41
#define LFB_ALPHA_PRESENT               2
 
42
#define LFB_DEPTH_PRESENT               4
 
43
#define LFB_DEPTH_PRESENT_MSW   8
 
44
 
 
45
/* flags for the register access array */
 
46
#define REGISTER_READ                   0x01            /* reads are allowed */
 
47
#define REGISTER_WRITE                  0x02            /* writes are allowed */
 
48
#define REGISTER_PIPELINED              0x04            /* writes are pipelined */
 
49
#define REGISTER_FIFO                   0x08            /* writes go to FIFO */
 
50
#define REGISTER_WRITETHRU              0x10            /* writes are valid even for CMDFIFO */
 
51
 
 
52
/* shorter combinations to make the table smaller */
 
53
#define REG_R                                   (REGISTER_READ)
 
54
#define REG_W                                   (REGISTER_WRITE)
 
55
#define REG_WT                                  (REGISTER_WRITE | REGISTER_WRITETHRU)
 
56
#define REG_RW                                  (REGISTER_READ | REGISTER_WRITE)
 
57
#define REG_RWT                                 (REGISTER_READ | REGISTER_WRITE | REGISTER_WRITETHRU)
 
58
#define REG_RP                                  (REGISTER_READ | REGISTER_PIPELINED)
 
59
#define REG_WP                                  (REGISTER_WRITE | REGISTER_PIPELINED)
 
60
#define REG_RWP                                 (REGISTER_READ | REGISTER_WRITE | REGISTER_PIPELINED)
 
61
#define REG_RWPT                                (REGISTER_READ | REGISTER_WRITE | REGISTER_PIPELINED | REGISTER_WRITETHRU)
 
62
#define REG_RF                                  (REGISTER_READ | REGISTER_FIFO)
 
63
#define REG_WF                                  (REGISTER_WRITE | REGISTER_FIFO)
 
64
#define REG_RWF                                 (REGISTER_READ | REGISTER_WRITE | REGISTER_FIFO)
 
65
#define REG_RPF                                 (REGISTER_READ | REGISTER_PIPELINED | REGISTER_FIFO)
 
66
#define REG_WPF                                 (REGISTER_WRITE | REGISTER_PIPELINED | REGISTER_FIFO)
 
67
#define REG_RWPF                                (REGISTER_READ | REGISTER_WRITE | REGISTER_PIPELINED | REGISTER_FIFO)
 
68
 
 
69
/* lookup bits is the log2 of the size of the reciprocal/log table */
 
70
#define RECIPLOG_LOOKUP_BITS    9
 
71
 
 
72
/* input precision is how many fraction bits the input value has; this is a 64-bit number */
 
73
#define RECIPLOG_INPUT_PREC             32
 
74
 
 
75
/* lookup precision is how many fraction bits each table entry contains */
 
76
#define RECIPLOG_LOOKUP_PREC    22
 
77
 
 
78
/* output precision is how many fraction bits the result should have */
 
79
#define RECIP_OUTPUT_PREC               15
 
80
#define LOG_OUTPUT_PREC                 8
 
81
 
 
82
 
 
83
 
 
84
/*************************************
 
85
 *
 
86
 *  Register constants
 
87
 *
 
88
 *************************************/
 
89
 
 
90
/* Codes to the right:
 
91
    R = readable
 
92
    W = writeable
 
93
    P = pipelined
 
94
    F = goes to FIFO
 
95
*/
 
96
 
 
97
/* 0x000 */
 
98
#define status                  (0x000/4)       /* R  P  */
 
99
#define intrCtrl                (0x004/4)       /* RW P   -- Voodoo2/Banshee only */
 
100
#define vertexAx                (0x008/4)       /*  W PF */
 
101
#define vertexAy                (0x00c/4)       /*  W PF */
 
102
#define vertexBx                (0x010/4)       /*  W PF */
 
103
#define vertexBy                (0x014/4)       /*  W PF */
 
104
#define vertexCx                (0x018/4)       /*  W PF */
 
105
#define vertexCy                (0x01c/4)       /*  W PF */
 
106
#define startR                  (0x020/4)       /*  W PF */
 
107
#define startG                  (0x024/4)       /*  W PF */
 
108
#define startB                  (0x028/4)       /*  W PF */
 
109
#define startZ                  (0x02c/4)       /*  W PF */
 
110
#define startA                  (0x030/4)       /*  W PF */
 
111
#define startS                  (0x034/4)       /*  W PF */
 
112
#define startT                  (0x038/4)       /*  W PF */
 
113
#define startW                  (0x03c/4)       /*  W PF */
 
114
 
 
115
/* 0x040 */
 
116
#define dRdX                    (0x040/4)       /*  W PF */
 
117
#define dGdX                    (0x044/4)       /*  W PF */
 
118
#define dBdX                    (0x048/4)       /*  W PF */
 
119
#define dZdX                    (0x04c/4)       /*  W PF */
 
120
#define dAdX                    (0x050/4)       /*  W PF */
 
121
#define dSdX                    (0x054/4)       /*  W PF */
 
122
#define dTdX                    (0x058/4)       /*  W PF */
 
123
#define dWdX                    (0x05c/4)       /*  W PF */
 
124
#define dRdY                    (0x060/4)       /*  W PF */
 
125
#define dGdY                    (0x064/4)       /*  W PF */
 
126
#define dBdY                    (0x068/4)       /*  W PF */
 
127
#define dZdY                    (0x06c/4)       /*  W PF */
 
128
#define dAdY                    (0x070/4)       /*  W PF */
 
129
#define dSdY                    (0x074/4)       /*  W PF */
 
130
#define dTdY                    (0x078/4)       /*  W PF */
 
131
#define dWdY                    (0x07c/4)       /*  W PF */
 
132
 
 
133
/* 0x080 */
 
134
#define triangleCMD             (0x080/4)       /*  W PF */
 
135
#define fvertexAx               (0x088/4)       /*  W PF */
 
136
#define fvertexAy               (0x08c/4)       /*  W PF */
 
137
#define fvertexBx               (0x090/4)       /*  W PF */
 
138
#define fvertexBy               (0x094/4)       /*  W PF */
 
139
#define fvertexCx               (0x098/4)       /*  W PF */
 
140
#define fvertexCy               (0x09c/4)       /*  W PF */
 
141
#define fstartR                 (0x0a0/4)       /*  W PF */
 
142
#define fstartG                 (0x0a4/4)       /*  W PF */
 
143
#define fstartB                 (0x0a8/4)       /*  W PF */
 
144
#define fstartZ                 (0x0ac/4)       /*  W PF */
 
145
#define fstartA                 (0x0b0/4)       /*  W PF */
 
146
#define fstartS                 (0x0b4/4)       /*  W PF */
 
147
#define fstartT                 (0x0b8/4)       /*  W PF */
 
148
#define fstartW                 (0x0bc/4)       /*  W PF */
 
149
 
 
150
/* 0x0c0 */
 
151
#define fdRdX                   (0x0c0/4)       /*  W PF */
 
152
#define fdGdX                   (0x0c4/4)       /*  W PF */
 
153
#define fdBdX                   (0x0c8/4)       /*  W PF */
 
154
#define fdZdX                   (0x0cc/4)       /*  W PF */
 
155
#define fdAdX                   (0x0d0/4)       /*  W PF */
 
156
#define fdSdX                   (0x0d4/4)       /*  W PF */
 
157
#define fdTdX                   (0x0d8/4)       /*  W PF */
 
158
#define fdWdX                   (0x0dc/4)       /*  W PF */
 
159
#define fdRdY                   (0x0e0/4)       /*  W PF */
 
160
#define fdGdY                   (0x0e4/4)       /*  W PF */
 
161
#define fdBdY                   (0x0e8/4)       /*  W PF */
 
162
#define fdZdY                   (0x0ec/4)       /*  W PF */
 
163
#define fdAdY                   (0x0f0/4)       /*  W PF */
 
164
#define fdSdY                   (0x0f4/4)       /*  W PF */
 
165
#define fdTdY                   (0x0f8/4)       /*  W PF */
 
166
#define fdWdY                   (0x0fc/4)       /*  W PF */
 
167
 
 
168
/* 0x100 */
 
169
#define ftriangleCMD    (0x100/4)       /*  W PF */
 
170
#define fbzColorPath    (0x104/4)       /* RW PF */
 
171
#define fogMode                 (0x108/4)       /* RW PF */
 
172
#define alphaMode               (0x10c/4)       /* RW PF */
 
173
#define fbzMode                 (0x110/4)       /* RW  F */
 
174
#define lfbMode                 (0x114/4)       /* RW  F */
 
175
#define clipLeftRight   (0x118/4)       /* RW  F */
 
176
#define clipLowYHighY   (0x11c/4)       /* RW  F */
 
177
#define nopCMD                  (0x120/4)       /*  W  F */
 
178
#define fastfillCMD             (0x124/4)       /*  W  F */
 
179
#define swapbufferCMD   (0x128/4)       /*  W  F */
 
180
#define fogColor                (0x12c/4)       /*  W  F */
 
181
#define zaColor                 (0x130/4)       /*  W  F */
 
182
#define chromaKey               (0x134/4)       /*  W  F */
 
183
#define chromaRange             (0x138/4)       /*  W  F  -- Voodoo2/Banshee only */
 
184
#define userIntrCMD             (0x13c/4)       /*  W  F  -- Voodoo2/Banshee only */
 
185
 
 
186
/* 0x140 */
 
187
#define stipple                 (0x140/4)       /* RW  F */
 
188
#define color0                  (0x144/4)       /* RW  F */
 
189
#define color1                  (0x148/4)       /* RW  F */
 
190
#define fbiPixelsIn             (0x14c/4)       /* R     */
 
191
#define fbiChromaFail   (0x150/4)       /* R     */
 
192
#define fbiZfuncFail    (0x154/4)       /* R     */
 
193
#define fbiAfuncFail    (0x158/4)       /* R     */
 
194
#define fbiPixelsOut    (0x15c/4)       /* R     */
 
195
#define fogTable                (0x160/4)       /*  W  F */
 
196
 
 
197
/* 0x1c0 */
 
198
#define cmdFifoBaseAddr (0x1e0/4)       /* RW     -- Voodoo2 only */
 
199
#define cmdFifoBump             (0x1e4/4)       /* RW     -- Voodoo2 only */
 
200
#define cmdFifoRdPtr    (0x1e8/4)       /* RW     -- Voodoo2 only */
 
201
#define cmdFifoAMin             (0x1ec/4)       /* RW     -- Voodoo2 only */
 
202
#define colBufferAddr   (0x1ec/4)       /* RW     -- Banshee only */
 
203
#define cmdFifoAMax             (0x1f0/4)       /* RW     -- Voodoo2 only */
 
204
#define colBufferStride (0x1f0/4)       /* RW     -- Banshee only */
 
205
#define cmdFifoDepth    (0x1f4/4)       /* RW     -- Voodoo2 only */
 
206
#define auxBufferAddr   (0x1f4/4)       /* RW     -- Banshee only */
 
207
#define cmdFifoHoles    (0x1f8/4)       /* RW     -- Voodoo2 only */
 
208
#define auxBufferStride (0x1f8/4)       /* RW     -- Banshee only */
 
209
 
 
210
/* 0x200 */
 
211
#define fbiInit4                (0x200/4)       /* RW     -- Voodoo/Voodoo2 only */
 
212
#define clipLeftRight1  (0x200/4)       /* RW     -- Banshee only */
 
213
#define vRetrace                (0x204/4)       /* R      -- Voodoo/Voodoo2 only */
 
214
#define clipTopBottom1  (0x204/4)       /* RW     -- Banshee only */
 
215
#define backPorch               (0x208/4)       /* RW     -- Voodoo/Voodoo2 only */
 
216
#define videoDimensions (0x20c/4)       /* RW     -- Voodoo/Voodoo2 only */
 
217
#define fbiInit0                (0x210/4)       /* RW     -- Voodoo/Voodoo2 only */
 
218
#define fbiInit1                (0x214/4)       /* RW     -- Voodoo/Voodoo2 only */
 
219
#define fbiInit2                (0x218/4)       /* RW     -- Voodoo/Voodoo2 only */
 
220
#define fbiInit3                (0x21c/4)       /* RW     -- Voodoo/Voodoo2 only */
 
221
#define hSync                   (0x220/4)       /*  W     -- Voodoo/Voodoo2 only */
 
222
#define vSync                   (0x224/4)       /*  W     -- Voodoo/Voodoo2 only */
 
223
#define clutData                (0x228/4)       /*  W  F  -- Voodoo/Voodoo2 only */
 
224
#define dacData                 (0x22c/4)       /*  W     -- Voodoo/Voodoo2 only */
 
225
#define maxRgbDelta             (0x230/4)       /*  W     -- Voodoo/Voodoo2 only */
 
226
#define hBorder                 (0x234/4)       /*  W     -- Voodoo2 only */
 
227
#define vBorder                 (0x238/4)       /*  W     -- Voodoo2 only */
 
228
#define borderColor             (0x23c/4)       /*  W     -- Voodoo2 only */
 
229
 
 
230
/* 0x240 */
 
231
#define hvRetrace               (0x240/4)       /* R      -- Voodoo2 only */
 
232
#define fbiInit5                (0x244/4)       /* RW     -- Voodoo2 only */
 
233
#define fbiInit6                (0x248/4)       /* RW     -- Voodoo2 only */
 
234
#define fbiInit7                (0x24c/4)       /* RW     -- Voodoo2 only */
 
235
#define swapPending             (0x24c/4)       /*  W     -- Banshee only */
 
236
#define leftOverlayBuf  (0x250/4)       /*  W     -- Banshee only */
 
237
#define rightOverlayBuf (0x254/4)       /*  W     -- Banshee only */
 
238
#define fbiSwapHistory  (0x258/4)       /* R      -- Voodoo2/Banshee only */
 
239
#define fbiTrianglesOut (0x25c/4)       /* R      -- Voodoo2/Banshee only */
 
240
#define sSetupMode              (0x260/4)       /*  W PF  -- Voodoo2/Banshee only */
 
241
#define sVx                             (0x264/4)       /*  W PF  -- Voodoo2/Banshee only */
 
242
#define sVy                             (0x268/4)       /*  W PF  -- Voodoo2/Banshee only */
 
243
#define sARGB                   (0x26c/4)       /*  W PF  -- Voodoo2/Banshee only */
 
244
#define sRed                    (0x270/4)       /*  W PF  -- Voodoo2/Banshee only */
 
245
#define sGreen                  (0x274/4)       /*  W PF  -- Voodoo2/Banshee only */
 
246
#define sBlue                   (0x278/4)       /*  W PF  -- Voodoo2/Banshee only */
 
247
#define sAlpha                  (0x27c/4)       /*  W PF  -- Voodoo2/Banshee only */
 
248
 
 
249
/* 0x280 */
 
250
#define sVz                             (0x280/4)       /*  W PF  -- Voodoo2/Banshee only */
 
251
#define sWb                             (0x284/4)       /*  W PF  -- Voodoo2/Banshee only */
 
252
#define sWtmu0                  (0x288/4)       /*  W PF  -- Voodoo2/Banshee only */
 
253
#define sS_W0                   (0x28c/4)       /*  W PF  -- Voodoo2/Banshee only */
 
254
#define sT_W0                   (0x290/4)       /*  W PF  -- Voodoo2/Banshee only */
 
255
#define sWtmu1                  (0x294/4)       /*  W PF  -- Voodoo2/Banshee only */
 
256
#define sS_Wtmu1                (0x298/4)       /*  W PF  -- Voodoo2/Banshee only */
 
257
#define sT_Wtmu1                (0x29c/4)       /*  W PF  -- Voodoo2/Banshee only */
 
258
#define sDrawTriCMD             (0x2a0/4)       /*  W PF  -- Voodoo2/Banshee only */
 
259
#define sBeginTriCMD    (0x2a4/4)       /*  W PF  -- Voodoo2/Banshee only */
 
260
 
 
261
/* 0x2c0 */
 
262
#define bltSrcBaseAddr  (0x2c0/4)       /* RW PF  -- Voodoo2 only */
 
263
#define bltDstBaseAddr  (0x2c4/4)       /* RW PF  -- Voodoo2 only */
 
264
#define bltXYStrides    (0x2c8/4)       /* RW PF  -- Voodoo2 only */
 
265
#define bltSrcChromaRange (0x2cc/4)     /* RW PF  -- Voodoo2 only */
 
266
#define bltDstChromaRange (0x2d0/4)     /* RW PF  -- Voodoo2 only */
 
267
#define bltClipX                (0x2d4/4)       /* RW PF  -- Voodoo2 only */
 
268
#define bltClipY                (0x2d8/4)       /* RW PF  -- Voodoo2 only */
 
269
#define bltSrcXY                (0x2e0/4)       /* RW PF  -- Voodoo2 only */
 
270
#define bltDstXY                (0x2e4/4)       /* RW PF  -- Voodoo2 only */
 
271
#define bltSize                 (0x2e8/4)       /* RW PF  -- Voodoo2 only */
 
272
#define bltRop                  (0x2ec/4)       /* RW PF  -- Voodoo2 only */
 
273
#define bltColor                (0x2f0/4)       /* RW PF  -- Voodoo2 only */
 
274
#define bltCommand              (0x2f8/4)       /* RW PF  -- Voodoo2 only */
 
275
#define bltData                 (0x2fc/4)       /*  W PF  -- Voodoo2 only */
 
276
 
 
277
/* 0x300 */
 
278
#define textureMode             (0x300/4)       /*  W PF */
 
279
#define tLOD                    (0x304/4)       /*  W PF */
 
280
#define tDetail                 (0x308/4)       /*  W PF */
 
281
#define texBaseAddr             (0x30c/4)       /*  W PF */
 
282
#define texBaseAddr_1   (0x310/4)       /*  W PF */
 
283
#define texBaseAddr_2   (0x314/4)       /*  W PF */
 
284
#define texBaseAddr_3_8 (0x318/4)       /*  W PF */
 
285
#define trexInit0               (0x31c/4)       /*  W  F  -- Voodoo/Voodoo2 only */
 
286
#define trexInit1               (0x320/4)       /*  W  F */
 
287
#define nccTable                (0x324/4)       /*  W  F */
 
288
 
 
289
 
 
290
 
 
291
/*************************************
 
292
 *
 
293
 *  Alias map of the first 64
 
294
 *  registers when remapped
 
295
 *
 
296
 *************************************/
 
297
 
 
298
static const UINT8 register_alias_map[0x40] =
 
299
{
 
300
        status,         0x004/4,        vertexAx,       vertexAy,
 
301
        vertexBx,       vertexBy,       vertexCx,       vertexCy,
 
302
        startR,         dRdX,           dRdY,           startG,
 
303
        dGdX,           dGdY,           startB,         dBdX,
 
304
        dBdY,           startZ,         dZdX,           dZdY,
 
305
        startA,         dAdX,           dAdY,           startS,
 
306
        dSdX,           dSdY,           startT,         dTdX,
 
307
        dTdY,           startW,         dWdX,           dWdY,
 
308
 
 
309
        triangleCMD,0x084/4,    fvertexAx,      fvertexAy,
 
310
        fvertexBx,      fvertexBy,      fvertexCx,      fvertexCy,
 
311
        fstartR,        fdRdX,          fdRdY,          fstartG,
 
312
        fdGdX,          fdGdY,          fstartB,        fdBdX,
 
313
        fdBdY,          fstartZ,        fdZdX,          fdZdY,
 
314
        fstartA,        fdAdX,          fdAdY,          fstartS,
 
315
        fdSdX,          fdSdY,          fstartT,        fdTdX,
 
316
        fdTdY,          fstartW,        fdWdX,          fdWdY
 
317
};
 
318
 
 
319
 
 
320
 
 
321
/*************************************
 
322
 *
 
323
 *  Table of per-register access rights
 
324
 *
 
325
 *************************************/
 
326
 
 
327
static const UINT8 voodoo_register_access[0x100] =
 
328
{
 
329
        /* 0x000 */
 
330
        REG_RP,         0,                      REG_WPF,        REG_WPF,
 
331
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
332
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
333
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
334
 
 
335
        /* 0x040 */
 
336
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
337
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
338
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
339
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
340
 
 
341
        /* 0x080 */
 
342
        REG_WPF,        0,                      REG_WPF,        REG_WPF,
 
343
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
344
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
345
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
346
 
 
347
        /* 0x0c0 */
 
348
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
349
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
350
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
351
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
352
 
 
353
        /* 0x100 */
 
354
        REG_WPF,        REG_RWPF,       REG_RWPF,       REG_RWPF,
 
355
        REG_RWF,        REG_RWF,        REG_RWF,        REG_RWF,
 
356
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
357
        REG_WF,         REG_WF,         0,                      0,
 
358
 
 
359
        /* 0x140 */
 
360
        REG_RWF,        REG_RWF,        REG_RWF,        REG_R,
 
361
        REG_R,          REG_R,          REG_R,          REG_R,
 
362
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
363
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
364
 
 
365
        /* 0x180 */
 
366
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
367
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
368
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
369
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
370
 
 
371
        /* 0x1c0 */
 
372
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
373
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
374
        0,                      0,                      0,                      0,
 
375
        0,                      0,                      0,                      0,
 
376
 
 
377
        /* 0x200 */
 
378
        REG_RW,         REG_R,          REG_RW,         REG_RW,
 
379
        REG_RW,         REG_RW,         REG_RW,         REG_RW,
 
380
        REG_W,          REG_W,          REG_W,          REG_W,
 
381
        REG_W,          0,                      0,                      0,
 
382
 
 
383
        /* 0x240 */
 
384
        0,                      0,                      0,                      0,
 
385
        0,                      0,                      0,                      0,
 
386
        0,                      0,                      0,                      0,
 
387
        0,                      0,                      0,                      0,
 
388
 
 
389
        /* 0x280 */
 
390
        0,                      0,                      0,                      0,
 
391
        0,                      0,                      0,                      0,
 
392
        0,                      0,                      0,                      0,
 
393
        0,                      0,                      0,                      0,
 
394
 
 
395
        /* 0x2c0 */
 
396
        0,                      0,                      0,                      0,
 
397
        0,                      0,                      0,                      0,
 
398
        0,                      0,                      0,                      0,
 
399
        0,                      0,                      0,                      0,
 
400
 
 
401
        /* 0x300 */
 
402
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
403
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WF,
 
404
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
405
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
406
 
 
407
        /* 0x340 */
 
408
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
409
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
410
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
411
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
412
 
 
413
        /* 0x380 */
 
414
        REG_WF
 
415
};
 
416
 
 
417
 
 
418
static const UINT8 voodoo2_register_access[0x100] =
 
419
{
 
420
        /* 0x000 */
 
421
        REG_RP,         REG_RWPT,       REG_WPF,        REG_WPF,
 
422
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
423
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
424
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
425
 
 
426
        /* 0x040 */
 
427
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
428
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
429
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
430
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
431
 
 
432
        /* 0x080 */
 
433
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
434
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
435
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
436
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
437
 
 
438
        /* 0x0c0 */
 
439
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
440
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
441
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
442
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
443
 
 
444
        /* 0x100 */
 
445
        REG_WPF,        REG_RWPF,       REG_RWPF,       REG_RWPF,
 
446
        REG_RWF,        REG_RWF,        REG_RWF,        REG_RWF,
 
447
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
448
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
449
 
 
450
        /* 0x140 */
 
451
        REG_RWF,        REG_RWF,        REG_RWF,        REG_R,
 
452
        REG_R,          REG_R,          REG_R,          REG_R,
 
453
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
454
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
455
 
 
456
        /* 0x180 */
 
457
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
458
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
459
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
460
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
461
 
 
462
        /* 0x1c0 */
 
463
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
464
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
465
        REG_RWT,        REG_RWT,        REG_RWT,        REG_RWT,
 
466
        REG_RWT,        REG_RWT,        REG_RWT,        REG_RW,
 
467
 
 
468
        /* 0x200 */
 
469
        REG_RWT,        REG_R,          REG_RWT,        REG_RWT,
 
470
        REG_RWT,        REG_RWT,        REG_RWT,        REG_RWT,
 
471
        REG_WT,         REG_WT,         REG_WF,         REG_WT,
 
472
        REG_WT,         REG_WT,         REG_WT,         REG_WT,
 
473
 
 
474
        /* 0x240 */
 
475
        REG_R,          REG_RWT,        REG_RWT,        REG_RWT,
 
476
        0,                      0,                      REG_R,          REG_R,
 
477
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
478
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
479
 
 
480
        /* 0x280 */
 
481
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
482
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
483
        REG_WPF,        REG_WPF,        0,                      0,
 
484
        0,                      0,                      0,                      0,
 
485
 
 
486
        /* 0x2c0 */
 
487
        REG_RWPF,       REG_RWPF,       REG_RWPF,       REG_RWPF,
 
488
        REG_RWPF,       REG_RWPF,       REG_RWPF,       REG_RWPF,
 
489
        REG_RWPF,       REG_RWPF,       REG_RWPF,       REG_RWPF,
 
490
        REG_RWPF,       REG_RWPF,       REG_RWPF,       REG_WPF,
 
491
 
 
492
        /* 0x300 */
 
493
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
494
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WF,
 
495
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
496
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
497
 
 
498
        /* 0x340 */
 
499
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
500
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
501
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
502
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
503
 
 
504
        /* 0x380 */
 
505
        REG_WF
 
506
};
 
507
 
 
508
 
 
509
static const UINT8 banshee_register_access[0x100] =
 
510
{
 
511
        /* 0x000 */
 
512
        REG_RP,         REG_RWPT,       REG_WPF,        REG_WPF,
 
513
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
514
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
515
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
516
 
 
517
        /* 0x040 */
 
518
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
519
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
520
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
521
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
522
 
 
523
        /* 0x080 */
 
524
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
525
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
526
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
527
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
528
 
 
529
        /* 0x0c0 */
 
530
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
531
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
532
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
533
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
534
 
 
535
        /* 0x100 */
 
536
        REG_WPF,        REG_RWPF,       REG_RWPF,       REG_RWPF,
 
537
        REG_RWF,        REG_RWF,        REG_RWF,        REG_RWF,
 
538
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
539
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
540
 
 
541
        /* 0x140 */
 
542
        REG_RWF,        REG_RWF,        REG_RWF,        REG_R,
 
543
        REG_R,          REG_R,          REG_R,          REG_R,
 
544
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
545
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
546
 
 
547
        /* 0x180 */
 
548
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
549
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
550
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
551
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
552
 
 
553
        /* 0x1c0 */
 
554
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
555
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
556
        0,                      0,                      0,                      REG_RWF,
 
557
        REG_RWF,        REG_RWF,        REG_RWF,        0,
 
558
 
 
559
        /* 0x200 */
 
560
        REG_RWF,        REG_RWF,        0,                      0,
 
561
        0,                      0,                      0,                      0,
 
562
        0,                      0,                      0,                      0,
 
563
        0,                      0,                      0,                      0,
 
564
 
 
565
        /* 0x240 */
 
566
        0,                      0,                      0,                      REG_WT,
 
567
        REG_RWF,        REG_RWF,        REG_WPF,        REG_WPF,
 
568
        REG_WPF,        REG_WPF,        REG_R,          REG_R,
 
569
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
570
 
 
571
        /* 0x280 */
 
572
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
573
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
574
        REG_WPF,        REG_WPF,        0,                      0,
 
575
        0,                      0,                      0,                      0,
 
576
 
 
577
        /* 0x2c0 */
 
578
        0,                      0,                      0,                      0,
 
579
        0,                      0,                      0,                      0,
 
580
        0,                      0,                      0,                      0,
 
581
        0,                      0,                      0,                      0,
 
582
 
 
583
        /* 0x300 */
 
584
        REG_WPF,        REG_WPF,        REG_WPF,        REG_WPF,
 
585
        REG_WPF,        REG_WPF,        REG_WPF,        0,
 
586
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
587
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
588
 
 
589
        /* 0x340 */
 
590
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
591
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
592
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
593
        REG_WF,         REG_WF,         REG_WF,         REG_WF,
 
594
 
 
595
        /* 0x380 */
 
596
        REG_WF
 
597
};
 
598
 
 
599
 
 
600
 
 
601
/*************************************
 
602
 *
 
603
 *  Register string table for debug
 
604
 *
 
605
 *************************************/
 
606
 
 
607
static const char *voodoo_reg_name[] =
 
608
{
 
609
        /* 0x000 */
 
610
        "status",               "{intrCtrl}",   "vertexAx",             "vertexAy",
 
611
        "vertexBx",             "vertexBy",             "vertexCx",             "vertexCy",
 
612
        "startR",               "startG",               "startB",               "startZ",
 
613
        "startA",               "startS",               "startT",               "startW",
 
614
        /* 0x040 */
 
615
        "dRdX",                 "dGdX",                 "dBdX",                 "dZdX",
 
616
        "dAdX",                 "dSdX",                 "dTdX",                 "dWdX",
 
617
        "dRdY",                 "dGdY",                 "dBdY",                 "dZdY",
 
618
        "dAdY",                 "dSdY",                 "dTdY",                 "dWdY",
 
619
        /* 0x080 */
 
620
        "triangleCMD",  "reserved084",  "fvertexAx",    "fvertexAy",
 
621
        "fvertexBx",    "fvertexBy",    "fvertexCx",    "fvertexCy",
 
622
        "fstartR",              "fstartG",              "fstartB",              "fstartZ",
 
623
        "fstartA",              "fstartS",              "fstartT",              "fstartW",
 
624
        /* 0x0c0 */
 
625
        "fdRdX",                "fdGdX",                "fdBdX",                "fdZdX",
 
626
        "fdAdX",                "fdSdX",                "fdTdX",                "fdWdX",
 
627
        "fdRdY",                "fdGdY",                "fdBdY",                "fdZdY",
 
628
        "fdAdY",                "fdSdY",                "fdTdY",                "fdWdY",
 
629
        /* 0x100 */
 
630
        "ftriangleCMD", "fbzColorPath", "fogMode",              "alphaMode",
 
631
        "fbzMode",              "lfbMode",              "clipLeftRight","clipLowYHighY",
 
632
        "nopCMD",               "fastfillCMD",  "swapbufferCMD","fogColor",
 
633
        "zaColor",              "chromaKey",    "{chromaRange}","{userIntrCMD}",
 
634
        /* 0x140 */
 
635
        "stipple",              "color0",               "color1",               "fbiPixelsIn",
 
636
        "fbiChromaFail","fbiZfuncFail", "fbiAfuncFail", "fbiPixelsOut",
 
637
        "fogTable160",  "fogTable164",  "fogTable168",  "fogTable16c",
 
638
        "fogTable170",  "fogTable174",  "fogTable178",  "fogTable17c",
 
639
        /* 0x180 */
 
640
        "fogTable180",  "fogTable184",  "fogTable188",  "fogTable18c",
 
641
        "fogTable190",  "fogTable194",  "fogTable198",  "fogTable19c",
 
642
        "fogTable1a0",  "fogTable1a4",  "fogTable1a8",  "fogTable1ac",
 
643
        "fogTable1b0",  "fogTable1b4",  "fogTable1b8",  "fogTable1bc",
 
644
        /* 0x1c0 */
 
645
        "fogTable1c0",  "fogTable1c4",  "fogTable1c8",  "fogTable1cc",
 
646
        "fogTable1d0",  "fogTable1d4",  "fogTable1d8",  "fogTable1dc",
 
647
        "{cmdFifoBaseAddr}","{cmdFifoBump}","{cmdFifoRdPtr}","{cmdFifoAMin}",
 
648
        "{cmdFifoAMax}","{cmdFifoDepth}","{cmdFifoHoles}","reserved1fc",
 
649
        /* 0x200 */
 
650
        "fbiInit4",             "vRetrace",             "backPorch",    "videoDimensions",
 
651
        "fbiInit0",             "fbiInit1",             "fbiInit2",             "fbiInit3",
 
652
        "hSync",                "vSync",                "clutData",             "dacData",
 
653
        "maxRgbDelta",  "{hBorder}",    "{vBorder}",    "{borderColor}",
 
654
        /* 0x240 */
 
655
        "{hvRetrace}",  "{fbiInit5}",   "{fbiInit6}",   "{fbiInit7}",
 
656
        "reserved250",  "reserved254",  "{fbiSwapHistory}","{fbiTrianglesOut}",
 
657
        "{sSetupMode}", "{sVx}",                "{sVy}",                "{sARGB}",
 
658
        "{sRed}",               "{sGreen}",             "{sBlue}",              "{sAlpha}",
 
659
        /* 0x280 */
 
660
        "{sVz}",                "{sWb}",                "{sWtmu0}",             "{sS/Wtmu0}",
 
661
        "{sT/Wtmu0}",   "{sWtmu1}",             "{sS/Wtmu1}",   "{sT/Wtmu1}",
 
662
        "{sDrawTriCMD}","{sBeginTriCMD}","reserved2a8", "reserved2ac",
 
663
        "reserved2b0",  "reserved2b4",  "reserved2b8",  "reserved2bc",
 
664
        /* 0x2c0 */
 
665
        "{bltSrcBaseAddr}","{bltDstBaseAddr}","{bltXYStrides}","{bltSrcChromaRange}",
 
666
        "{bltDstChromaRange}","{bltClipX}","{bltClipY}","reserved2dc",
 
667
        "{bltSrcXY}",   "{bltDstXY}",   "{bltSize}",    "{bltRop}",
 
668
        "{bltColor}",   "reserved2f4",  "{bltCommand}", "{bltData}",
 
669
        /* 0x300 */
 
670
        "textureMode",  "tLOD",                 "tDetail",              "texBaseAddr",
 
671
        "texBaseAddr_1","texBaseAddr_2","texBaseAddr_3_8","trexInit0",
 
672
        "trexInit1",    "nccTable0.0",  "nccTable0.1",  "nccTable0.2",
 
673
        "nccTable0.3",  "nccTable0.4",  "nccTable0.5",  "nccTable0.6",
 
674
        /* 0x340 */
 
675
        "nccTable0.7",  "nccTable0.8",  "nccTable0.9",  "nccTable0.A",
 
676
        "nccTable0.B",  "nccTable1.0",  "nccTable1.1",  "nccTable1.2",
 
677
        "nccTable1.3",  "nccTable1.4",  "nccTable1.5",  "nccTable1.6",
 
678
        "nccTable1.7",  "nccTable1.8",  "nccTable1.9",  "nccTable1.A",
 
679
        /* 0x380 */
 
680
        "nccTable1.B"
 
681
};
 
682
 
 
683
 
 
684
static const char *banshee_reg_name[] =
 
685
{
 
686
        /* 0x000 */
 
687
        "status",               "intrCtrl",             "vertexAx",             "vertexAy",
 
688
        "vertexBx",             "vertexBy",             "vertexCx",             "vertexCy",
 
689
        "startR",               "startG",               "startB",               "startZ",
 
690
        "startA",               "startS",               "startT",               "startW",
 
691
        /* 0x040 */
 
692
        "dRdX",                 "dGdX",                 "dBdX",                 "dZdX",
 
693
        "dAdX",                 "dSdX",                 "dTdX",                 "dWdX",
 
694
        "dRdY",                 "dGdY",                 "dBdY",                 "dZdY",
 
695
        "dAdY",                 "dSdY",                 "dTdY",                 "dWdY",
 
696
        /* 0x080 */
 
697
        "triangleCMD",  "reserved084",  "fvertexAx",    "fvertexAy",
 
698
        "fvertexBx",    "fvertexBy",    "fvertexCx",    "fvertexCy",
 
699
        "fstartR",              "fstartG",              "fstartB",              "fstartZ",
 
700
        "fstartA",              "fstartS",              "fstartT",              "fstartW",
 
701
        /* 0x0c0 */
 
702
        "fdRdX",                "fdGdX",                "fdBdX",                "fdZdX",
 
703
        "fdAdX",                "fdSdX",                "fdTdX",                "fdWdX",
 
704
        "fdRdY",                "fdGdY",                "fdBdY",                "fdZdY",
 
705
        "fdAdY",                "fdSdY",                "fdTdY",                "fdWdY",
 
706
        /* 0x100 */
 
707
        "ftriangleCMD", "fbzColorPath", "fogMode",              "alphaMode",
 
708
        "fbzMode",              "lfbMode",              "clipLeftRight","clipLowYHighY",
 
709
        "nopCMD",               "fastfillCMD",  "swapbufferCMD","fogColor",
 
710
        "zaColor",              "chromaKey",    "chromaRange",  "userIntrCMD",
 
711
        /* 0x140 */
 
712
        "stipple",              "color0",               "color1",               "fbiPixelsIn",
 
713
        "fbiChromaFail","fbiZfuncFail", "fbiAfuncFail", "fbiPixelsOut",
 
714
        "fogTable160",  "fogTable164",  "fogTable168",  "fogTable16c",
 
715
        "fogTable170",  "fogTable174",  "fogTable178",  "fogTable17c",
 
716
        /* 0x180 */
 
717
        "fogTable180",  "fogTable184",  "fogTable188",  "fogTable18c",
 
718
        "fogTable190",  "fogTable194",  "fogTable198",  "fogTable19c",
 
719
        "fogTable1a0",  "fogTable1a4",  "fogTable1a8",  "fogTable1ac",
 
720
        "fogTable1b0",  "fogTable1b4",  "fogTable1b8",  "fogTable1bc",
 
721
        /* 0x1c0 */
 
722
        "fogTable1c0",  "fogTable1c4",  "fogTable1c8",  "fogTable1cc",
 
723
        "fogTable1d0",  "fogTable1d4",  "fogTable1d8",  "fogTable1dc",
 
724
        "reserved1e0",  "reserved1e4",  "reserved1e8",  "colBufferAddr",
 
725
        "colBufferStride","auxBufferAddr","auxBufferStride","reserved1fc",
 
726
        /* 0x200 */
 
727
        "clipLeftRight1","clipTopBottom1","reserved208","reserved20c",
 
728
        "reserved210",  "reserved214",  "reserved218",  "reserved21c",
 
729
        "reserved220",  "reserved224",  "reserved228",  "reserved22c",
 
730
        "reserved230",  "reserved234",  "reserved238",  "reserved23c",
 
731
        /* 0x240 */
 
732
        "reserved240",  "reserved244",  "reserved248",  "swapPending",
 
733
        "leftOverlayBuf","rightOverlayBuf","fbiSwapHistory","fbiTrianglesOut",
 
734
        "sSetupMode",   "sVx",                  "sVy",                  "sARGB",
 
735
        "sRed",                 "sGreen",               "sBlue",                "sAlpha",
 
736
        /* 0x280 */
 
737
        "sVz",                  "sWb",                  "sWtmu0",               "sS/Wtmu0",
 
738
        "sT/Wtmu0",             "sWtmu1",               "sS/Wtmu1",             "sT/Wtmu1",
 
739
        "sDrawTriCMD",  "sBeginTriCMD", "reserved2a8",  "reserved2ac",
 
740
        "reserved2b0",  "reserved2b4",  "reserved2b8",  "reserved2bc",
 
741
        /* 0x2c0 */
 
742
        "reserved2c0",  "reserved2c4",  "reserved2c8",  "reserved2cc",
 
743
        "reserved2d0",  "reserved2d4",  "reserved2d8",  "reserved2dc",
 
744
        "reserved2e0",  "reserved2e4",  "reserved2e8",  "reserved2ec",
 
745
        "reserved2f0",  "reserved2f4",  "reserved2f8",  "reserved2fc",
 
746
        /* 0x300 */
 
747
        "textureMode",  "tLOD",                 "tDetail",              "texBaseAddr",
 
748
        "texBaseAddr_1","texBaseAddr_2","texBaseAddr_3_8","reserved31c",
 
749
        "trexInit1",    "nccTable0.0",  "nccTable0.1",  "nccTable0.2",
 
750
        "nccTable0.3",  "nccTable0.4",  "nccTable0.5",  "nccTable0.6",
 
751
        /* 0x340 */
 
752
        "nccTable0.7",  "nccTable0.8",  "nccTable0.9",  "nccTable0.A",
 
753
        "nccTable0.B",  "nccTable1.0",  "nccTable1.1",  "nccTable1.2",
 
754
        "nccTable1.3",  "nccTable1.4",  "nccTable1.5",  "nccTable1.6",
 
755
        "nccTable1.7",  "nccTable1.8",  "nccTable1.9",  "nccTable1.A",
 
756
        /* 0x380 */
 
757
        "nccTable1.B"
 
758
};
 
759
 
 
760
 
 
761
 
 
762
/*************************************
 
763
 *
 
764
 *  Voodoo Banshee I/O space registers
 
765
 *
 
766
 *************************************/
 
767
 
 
768
/* 0x000 */
 
769
#define io_status                                               (0x000/4)       /*  */
 
770
#define io_pciInit0                                             (0x004/4)       /*  */
 
771
#define io_sipMonitor                                   (0x008/4)       /*  */
 
772
#define io_lfbMemoryConfig                              (0x00c/4)       /*  */
 
773
#define io_miscInit0                                    (0x010/4)       /*  */
 
774
#define io_miscInit1                                    (0x014/4)       /*  */
 
775
#define io_dramInit0                                    (0x018/4)       /*  */
 
776
#define io_dramInit1                                    (0x01c/4)       /*  */
 
777
#define io_agpInit                                              (0x020/4)       /*  */
 
778
#define io_tmuGbeInit                                   (0x024/4)       /*  */
 
779
#define io_vgaInit0                                             (0x028/4)       /*  */
 
780
#define io_vgaInit1                                             (0x02c/4)       /*  */
 
781
#define io_dramCommand                                  (0x030/4)       /*  */
 
782
#define io_dramData                                             (0x034/4)       /*  */
 
783
 
 
784
/* 0x040 */
 
785
#define io_pllCtrl0                                             (0x040/4)       /*  */
 
786
#define io_pllCtrl1                                             (0x044/4)       /*  */
 
787
#define io_pllCtrl2                                             (0x048/4)       /*  */
 
788
#define io_dacMode                                              (0x04c/4)       /*  */
 
789
#define io_dacAddr                                              (0x050/4)       /*  */
 
790
#define io_dacData                                              (0x054/4)       /*  */
 
791
#define io_rgbMaxDelta                                  (0x058/4)       /*  */
 
792
#define io_vidProcCfg                                   (0x05c/4)       /*  */
 
793
#define io_hwCurPatAddr                                 (0x060/4)       /*  */
 
794
#define io_hwCurLoc                                             (0x064/4)       /*  */
 
795
#define io_hwCurC0                                              (0x068/4)       /*  */
 
796
#define io_hwCurC1                                              (0x06c/4)       /*  */
 
797
#define io_vidInFormat                                  (0x070/4)       /*  */
 
798
#define io_vidInStatus                                  (0x074/4)       /*  */
 
799
#define io_vidSerialParallelPort                (0x078/4)       /*  */
 
800
#define io_vidInXDecimDeltas                    (0x07c/4)       /*  */
 
801
 
 
802
/* 0x080 */
 
803
#define io_vidInDecimInitErrs                   (0x080/4)       /*  */
 
804
#define io_vidInYDecimDeltas                    (0x084/4)       /*  */
 
805
#define io_vidPixelBufThold                             (0x088/4)       /*  */
 
806
#define io_vidChromaMin                                 (0x08c/4)       /*  */
 
807
#define io_vidChromaMax                                 (0x090/4)       /*  */
 
808
#define io_vidCurrentLine                               (0x094/4)       /*  */
 
809
#define io_vidScreenSize                                (0x098/4)       /*  */
 
810
#define io_vidOverlayStartCoords                (0x09c/4)       /*  */
 
811
#define io_vidOverlayEndScreenCoord             (0x0a0/4)       /*  */
 
812
#define io_vidOverlayDudx                               (0x0a4/4)       /*  */
 
813
#define io_vidOverlayDudxOffsetSrcWidth (0x0a8/4)       /*  */
 
814
#define io_vidOverlayDvdy                               (0x0ac/4)       /*  */
 
815
#define io_vgab0                                                (0x0b0/4)       /*  */
 
816
#define io_vgab4                                                (0x0b4/4)       /*  */
 
817
#define io_vgab8                                                (0x0b8/4)       /*  */
 
818
#define io_vgabc                                                (0x0bc/4)       /*  */
 
819
 
 
820
/* 0x0c0 */
 
821
#define io_vgac0                                                (0x0c0/4)       /*  */
 
822
#define io_vgac4                                                (0x0c4/4)       /*  */
 
823
#define io_vgac8                                                (0x0c8/4)       /*  */
 
824
#define io_vgacc                                                (0x0cc/4)       /*  */
 
825
#define io_vgad0                                                (0x0d0/4)       /*  */
 
826
#define io_vgad4                                                (0x0d4/4)       /*  */
 
827
#define io_vgad8                                                (0x0d8/4)       /*  */
 
828
#define io_vgadc                                                (0x0dc/4)       /*  */
 
829
#define io_vidOverlayDvdyOffset                 (0x0e0/4)       /*  */
 
830
#define io_vidDesktopStartAddr                  (0x0e4/4)       /*  */
 
831
#define io_vidDesktopOverlayStride              (0x0e8/4)       /*  */
 
832
#define io_vidInAddr0                                   (0x0ec/4)       /*  */
 
833
#define io_vidInAddr1                                   (0x0f0/4)       /*  */
 
834
#define io_vidInAddr2                                   (0x0f4/4)       /*  */
 
835
#define io_vidInStride                                  (0x0f8/4)       /*  */
 
836
#define io_vidCurrOverlayStartAddr              (0x0fc/4)       /*  */
 
837
 
 
838
 
 
839
 
 
840
/*************************************
 
841
 *
 
842
 *  Register string table for debug
 
843
 *
 
844
 *************************************/
 
845
 
 
846
static const char *banshee_io_reg_name[] =
 
847
{
 
848
        /* 0x000 */
 
849
        "status",               "pciInit0",             "sipMonitor",   "lfbMemoryConfig",
 
850
        "miscInit0",    "miscInit1",    "dramInit0",    "dramInit1",
 
851
        "agpInit",              "tmuGbeInit",   "vgaInit0",             "vgaInit1",
 
852
        "dramCommand",  "dramData",             "reserved38",   "reserved3c",
 
853
 
 
854
        /* 0x040 */
 
855
        "pllCtrl0",             "pllCtrl1",             "pllCtrl2",             "dacMode",
 
856
        "dacAddr",              "dacData",              "rgbMaxDelta",  "vidProcCfg",
 
857
        "hwCurPatAddr", "hwCurLoc",             "hwCurC0",              "hwCurC1",
 
858
        "vidInFormat",  "vidInStatus",  "vidSerialParallelPort","vidInXDecimDeltas",
 
859
 
 
860
        /* 0x080 */
 
861
        "vidInDecimInitErrs","vidInYDecimDeltas","vidPixelBufThold","vidChromaMin",
 
862
        "vidChromaMax", "vidCurrentLine","vidScreenSize","vidOverlayStartCoords",
 
863
        "vidOverlayEndScreenCoord","vidOverlayDudx","vidOverlayDudxOffsetSrcWidth","vidOverlayDvdy",
 
864
        "vga[b0]",              "vga[b4]",              "vga[b8]",              "vga[bc]",
 
865
 
 
866
        /* 0x0c0 */
 
867
        "vga[c0]",              "vga[c4]",              "vga[c8]",              "vga[cc]",
 
868
        "vga[d0]",              "vga[d4]",              "vga[d8]",              "vga[dc]",
 
869
        "vidOverlayDvdyOffset","vidDesktopStartAddr","vidDesktopOverlayStride","vidInAddr0",
 
870
        "vidInAddr1",   "vidInAddr2",   "vidInStride",  "vidCurrOverlayStartAddr"
 
871
};
 
872
 
 
873
 
 
874
 
 
875
/*************************************
 
876
 *
 
877
 *  Voodoo Banshee AGP space registers
 
878
 *
 
879
 *************************************/
 
880
 
 
881
/* 0x000 */
 
882
#define agpReqSize                              (0x000/4)       /*  */
 
883
#define agpHostAddressLow               (0x004/4)       /*  */
 
884
#define agpHostAddressHigh              (0x008/4)       /*  */
 
885
#define agpGraphicsAddress              (0x00c/4)       /*  */
 
886
#define agpGraphicsStride               (0x010/4)       /*  */
 
887
#define agpMoveCMD                              (0x014/4)       /*  */
 
888
#define cmdBaseAddr0                    (0x020/4)       /*  */
 
889
#define cmdBaseSize0                    (0x024/4)       /*  */
 
890
#define cmdBump0                                (0x028/4)       /*  */
 
891
#define cmdRdPtrL0                              (0x02c/4)       /*  */
 
892
#define cmdRdPtrH0                              (0x030/4)       /*  */
 
893
#define cmdAMin0                                (0x034/4)       /*  */
 
894
#define cmdAMax0                                (0x03c/4)       /*  */
 
895
 
 
896
/* 0x040 */
 
897
#define cmdFifoDepth0                   (0x044/4)       /*  */
 
898
#define cmdHoleCnt0                             (0x048/4)       /*  */
 
899
#define cmdBaseAddr1                    (0x050/4)       /*  */
 
900
#define cmdBaseSize1                    (0x054/4)       /*  */
 
901
#define cmdBump1                                (0x058/4)       /*  */
 
902
#define cmdRdPtrL1                              (0x05c/4)       /*  */
 
903
#define cmdRdPtrH1                              (0x060/4)       /*  */
 
904
#define cmdAMin1                                (0x064/4)       /*  */
 
905
#define cmdAMax1                                (0x06c/4)       /*  */
 
906
#define cmdFifoDepth1                   (0x074/4)       /*  */
 
907
#define cmdHoleCnt1                             (0x078/4)       /*  */
 
908
 
 
909
/* 0x080 */
 
910
#define cmdFifoThresh                   (0x080/4)       /*  */
 
911
#define cmdHoleInt                              (0x084/4)       /*  */
 
912
 
 
913
/* 0x100 */
 
914
#define yuvBaseAddress                  (0x100/4)       /*  */
 
915
#define yuvStride                               (0x104/4)       /*  */
 
916
#define crc1                                    (0x120/4)       /*  */
 
917
#define crc2                                    (0x130/4)       /*  */
 
918
 
 
919
 
 
920
 
 
921
/*************************************
 
922
 *
 
923
 *  Register string table for debug
 
924
 *
 
925
 *************************************/
 
926
 
 
927
static const char *banshee_agp_reg_name[] =
 
928
{
 
929
        /* 0x000 */
 
930
        "agpReqSize",   "agpHostAddressLow","agpHostAddressHigh","agpGraphicsAddress",
 
931
        "agpGraphicsStride","agpMoveCMD","reserved18",  "reserved1c",
 
932
        "cmdBaseAddr0", "cmdBaseSize0", "cmdBump0",             "cmdRdPtrL0",
 
933
        "cmdRdPtrH0",   "cmdAMin0",             "reserved38",   "cmdAMax0",
 
934
 
 
935
        /* 0x040 */
 
936
        "reserved40",   "cmdFifoDepth0","cmdHoleCnt0",  "reserved4c",
 
937
        "cmdBaseAddr1", "cmdBaseSize1", "cmdBump1",             "cmdRdPtrL1",
 
938
        "cmdRdPtrH1",   "cmdAMin1",             "reserved68",   "cmdAMax1",
 
939
        "reserved70",   "cmdFifoDepth1","cmdHoleCnt1",  "reserved7c",
 
940
 
 
941
        /* 0x080 */
 
942
        "cmdFifoThresh","cmdHoleInt",   "reserved88",   "reserved8c",
 
943
        "reserved90",   "reserved94",   "reserved98",   "reserved9c",
 
944
        "reserveda0",   "reserveda4",   "reserveda8",   "reservedac",
 
945
        "reservedb0",   "reservedb4",   "reservedb8",   "reservedbc",
 
946
 
 
947
        /* 0x0c0 */
 
948
        "reservedc0",   "reservedc4",   "reservedc8",   "reservedcc",
 
949
        "reservedd0",   "reservedd4",   "reservedd8",   "reserveddc",
 
950
        "reservede0",   "reservede4",   "reservede8",   "reservedec",
 
951
        "reservedf0",   "reservedf4",   "reservedf8",   "reservedfc",
 
952
 
 
953
        /* 0x100 */
 
954
        "yuvBaseAddress","yuvStride",   "reserved108",  "reserved10c",
 
955
        "reserved110",  "reserved114",  "reserved118",  "reserved11c",
 
956
        "crc1",                 "reserved124",  "reserved128",  "reserved12c",
 
957
        "crc2",                 "reserved134",  "reserved138",  "reserved13c"
 
958
};
 
959
 
 
960
 
 
961
 
 
962
/*************************************
 
963
 *
 
964
 *  Dithering tables
 
965
 *
 
966
 *************************************/
 
967
 
 
968
static const UINT8 dither_matrix_4x4[16] =
 
969
{
 
970
         0,  8,  2, 10,
 
971
        12,  4, 14,  6,
 
972
         3, 11,  1,  9,
 
973
        15,  7, 13,  5
 
974
};
 
975
 
 
976
static const UINT8 dither_matrix_2x2[4] =
 
977
{
 
978
         2, 10,
 
979
        14,  6
 
980
};
 
981
 
 
982
 
 
983
 
 
984
/*************************************
 
985
 *
 
986
 *  Macros for extracting pixels
 
987
 *
 
988
 *************************************/
 
989
 
 
990
#define EXTRACT_565_TO_888(val, a, b, c)                                        \
 
991
        (a) = (((val) >> 8) & 0xf8) | (((val) >> 13) & 0x07);   \
 
992
        (b) = (((val) >> 3) & 0xfc) | (((val) >> 9) & 0x03);    \
 
993
        (c) = (((val) << 3) & 0xf8) | (((val) >> 2) & 0x07);    \
 
994
 
 
995
#define EXTRACT_x555_TO_888(val, a, b, c)                                       \
 
996
        (a) = (((val) >> 7) & 0xf8) | (((val) >> 12) & 0x07);   \
 
997
        (b) = (((val) >> 2) & 0xf8) | (((val) >> 7) & 0x07);    \
 
998
        (c) = (((val) << 3) & 0xf8) | (((val) >> 2) & 0x07);    \
 
999
 
 
1000
#define EXTRACT_555x_TO_888(val, a, b, c)                                       \
 
1001
        (a) = (((val) >> 8) & 0xf8) | (((val) >> 13) & 0x07);   \
 
1002
        (b) = (((val) >> 3) & 0xf8) | (((val) >> 8) & 0x07);    \
 
1003
        (c) = (((val) << 2) & 0xf8) | (((val) >> 3) & 0x07);    \
 
1004
 
 
1005
#define EXTRACT_1555_TO_8888(val, a, b, c, d)                           \
 
1006
        (a) = ((INT16)(val) >> 15) & 0xff;                                              \
 
1007
        EXTRACT_x555_TO_888(val, b, c, d)                                               \
 
1008
 
 
1009
#define EXTRACT_5551_TO_8888(val, a, b, c, d)                           \
 
1010
        EXTRACT_555x_TO_888(val, a, b, c)                                               \
 
1011
        (d) = ((val) & 0x0001) ? 0xff : 0x00;                                   \
 
1012
 
 
1013
#define EXTRACT_x888_TO_888(val, a, b, c)                                       \
 
1014
        (a) = ((val) >> 16) & 0xff;                                                             \
 
1015
        (b) = ((val) >> 8) & 0xff;                                                              \
 
1016
        (c) = ((val) >> 0) & 0xff;                                                              \
 
1017
 
 
1018
#define EXTRACT_888x_TO_888(val, a, b, c)                                       \
 
1019
        (a) = ((val) >> 24) & 0xff;                                                             \
 
1020
        (b) = ((val) >> 16) & 0xff;                                                             \
 
1021
        (c) = ((val) >> 8) & 0xff;                                                              \
 
1022
 
 
1023
#define EXTRACT_8888_TO_8888(val, a, b, c, d)                           \
 
1024
        (a) = ((val) >> 24) & 0xff;                                                             \
 
1025
        (b) = ((val) >> 16) & 0xff;                                                             \
 
1026
        (c) = ((val) >> 8) & 0xff;                                                              \
 
1027
        (d) = ((val) >> 0) & 0xff;                                                              \
 
1028
 
 
1029
#define EXTRACT_4444_TO_8888(val, a, b, c, d)                           \
 
1030
        (a) = (((val) >> 8) & 0xf0) | (((val) >> 12) & 0x0f);   \
 
1031
        (b) = (((val) >> 4) & 0xf0) | (((val) >> 8) & 0x0f);    \
 
1032
        (c) = (((val) >> 0) & 0xf0) | (((val) >> 4) & 0x0f);    \
 
1033
        (d) = (((val) << 4) & 0xf0) | (((val) >> 0) & 0x0f);    \
 
1034
 
 
1035
#define EXTRACT_332_TO_888(val, a, b, c)                                        \
 
1036
        (a) = (((val) >> 0) & 0xe0) | (((val) >> 3) & 0x1c) | (((val) >> 6) & 0x03); \
 
1037
        (b) = (((val) << 3) & 0xe0) | (((val) >> 0) & 0x1c) | (((val) >> 3) & 0x03); \
 
1038
        (c) = (((val) << 6) & 0xc0) | (((val) << 4) & 0x30) | (((val) << 2) & 0xc0) | (((val) << 0) & 0x03); \
 
1039
 
 
1040
 
 
1041
 
 
1042
/*************************************
 
1043
 *
 
1044
 *  Misc. macros
 
1045
 *
 
1046
 *************************************/
 
1047
 
 
1048
/* macro for clamping a value between minimum and maximum values */
 
1049
#define CLAMP(val,min,max)              do { if ((val) < (min)) { (val) = (min); } else if ((val) > (max)) { (val) = (max); } } while (0)
 
1050
 
 
1051
/* macro to compute the base 2 log for LOD calculations */
 
1052
#define LOGB2(x)                                (log((double)(x)) / log(2.0))
 
1053
 
 
1054
 
 
1055
 
 
1056
/*************************************
 
1057
 *
 
1058
 *  Macros for extracting bitfields
 
1059
 *
 
1060
 *************************************/
 
1061
 
 
1062
#define INITEN_ENABLE_HW_INIT(val)                      (((val) >> 0) & 1)
 
1063
#define INITEN_ENABLE_PCI_FIFO(val)                     (((val) >> 1) & 1)
 
1064
#define INITEN_REMAP_INIT_TO_DAC(val)           (((val) >> 2) & 1)
 
1065
#define INITEN_ENABLE_SNOOP0(val)                       (((val) >> 4) & 1)
 
1066
#define INITEN_SNOOP0_MEMORY_MATCH(val)         (((val) >> 5) & 1)
 
1067
#define INITEN_SNOOP0_READWRITE_MATCH(val)      (((val) >> 6) & 1)
 
1068
#define INITEN_ENABLE_SNOOP1(val)                       (((val) >> 7) & 1)
 
1069
#define INITEN_SNOOP1_MEMORY_MATCH(val)         (((val) >> 8) & 1)
 
1070
#define INITEN_SNOOP1_READWRITE_MATCH(val)      (((val) >> 9) & 1)
 
1071
#define INITEN_SLI_BUS_OWNER(val)                       (((val) >> 10) & 1)
 
1072
#define INITEN_SLI_ODD_EVEN(val)                        (((val) >> 11) & 1)
 
1073
#define INITEN_SECONDARY_REV_ID(val)            (((val) >> 12) & 0xf)   /* voodoo 2 only */
 
1074
#define INITEN_MFCTR_FAB_ID(val)                        (((val) >> 16) & 0xf)   /* voodoo 2 only */
 
1075
#define INITEN_ENABLE_PCI_INTERRUPT(val)        (((val) >> 20) & 1)             /* voodoo 2 only */
 
1076
#define INITEN_PCI_INTERRUPT_TIMEOUT(val)       (((val) >> 21) & 1)             /* voodoo 2 only */
 
1077
#define INITEN_ENABLE_NAND_TREE_TEST(val)       (((val) >> 22) & 1)             /* voodoo 2 only */
 
1078
#define INITEN_ENABLE_SLI_ADDRESS_SNOOP(val) (((val) >> 23) & 1)        /* voodoo 2 only */
 
1079
#define INITEN_SLI_SNOOP_ADDRESS(val)           (((val) >> 24) & 0xff)  /* voodoo 2 only */
 
1080
 
 
1081
#define FBZCP_CC_RGBSELECT(val)                         (((val) >> 0) & 3)
 
1082
#define FBZCP_CC_ASELECT(val)                           (((val) >> 2) & 3)
 
1083
#define FBZCP_CC_LOCALSELECT(val)                       (((val) >> 4) & 1)
 
1084
#define FBZCP_CCA_LOCALSELECT(val)                      (((val) >> 5) & 3)
 
1085
#define FBZCP_CC_LOCALSELECT_OVERRIDE(val)      (((val) >> 7) & 1)
 
1086
#define FBZCP_CC_ZERO_OTHER(val)                        (((val) >> 8) & 1)
 
1087
#define FBZCP_CC_SUB_CLOCAL(val)                        (((val) >> 9) & 1)
 
1088
#define FBZCP_CC_MSELECT(val)                           (((val) >> 10) & 7)
 
1089
#define FBZCP_CC_REVERSE_BLEND(val)                     (((val) >> 13) & 1)
 
1090
#define FBZCP_CC_ADD_ACLOCAL(val)                       (((val) >> 14) & 3)
 
1091
#define FBZCP_CC_INVERT_OUTPUT(val)                     (((val) >> 16) & 1)
 
1092
#define FBZCP_CCA_ZERO_OTHER(val)                       (((val) >> 17) & 1)
 
1093
#define FBZCP_CCA_SUB_CLOCAL(val)                       (((val) >> 18) & 1)
 
1094
#define FBZCP_CCA_MSELECT(val)                          (((val) >> 19) & 7)
 
1095
#define FBZCP_CCA_REVERSE_BLEND(val)            (((val) >> 22) & 1)
 
1096
#define FBZCP_CCA_ADD_ACLOCAL(val)                      (((val) >> 23) & 3)
 
1097
#define FBZCP_CCA_INVERT_OUTPUT(val)            (((val) >> 25) & 1)
 
1098
#define FBZCP_CCA_SUBPIXEL_ADJUST(val)          (((val) >> 26) & 1)
 
1099
#define FBZCP_TEXTURE_ENABLE(val)                       (((val) >> 27) & 1)
 
1100
#define FBZCP_RGBZW_CLAMP(val)                          (((val) >> 28) & 1)             /* voodoo 2 only */
 
1101
#define FBZCP_ANTI_ALIAS(val)                           (((val) >> 29) & 1)             /* voodoo 2 only */
 
1102
 
 
1103
#define ALPHAMODE_ALPHATEST(val)                        (((val) >> 0) & 1)
 
1104
#define ALPHAMODE_ALPHAFUNCTION(val)            (((val) >> 1) & 7)
 
1105
#define ALPHAMODE_ALPHABLEND(val)                       (((val) >> 4) & 1)
 
1106
#define ALPHAMODE_ANTIALIAS(val)                        (((val) >> 5) & 1)
 
1107
#define ALPHAMODE_SRCRGBBLEND(val)                      (((val) >> 8) & 15)
 
1108
#define ALPHAMODE_DSTRGBBLEND(val)                      (((val) >> 12) & 15)
 
1109
#define ALPHAMODE_SRCALPHABLEND(val)            (((val) >> 16) & 15)
 
1110
#define ALPHAMODE_DSTALPHABLEND(val)            (((val) >> 20) & 15)
 
1111
#define ALPHAMODE_ALPHAREF(val)                         (((val) >> 24) & 0xff)
 
1112
 
 
1113
#define FOGMODE_ENABLE_FOG(val)                         (((val) >> 0) & 1)
 
1114
#define FOGMODE_FOG_ADD(val)                            (((val) >> 1) & 1)
 
1115
#define FOGMODE_FOG_MULT(val)                           (((val) >> 2) & 1)
 
1116
#define FOGMODE_FOG_ZALPHA(val)                         (((val) >> 3) & 3)
 
1117
#define FOGMODE_FOG_CONSTANT(val)                       (((val) >> 5) & 1)
 
1118
#define FOGMODE_FOG_DITHER(val)                         (((val) >> 6) & 1)              /* voodoo 2 only */
 
1119
#define FOGMODE_FOG_ZONES(val)                          (((val) >> 7) & 1)              /* voodoo 2 only */
 
1120
 
 
1121
#define FBZMODE_ENABLE_CLIPPING(val)            (((val) >> 0) & 1)
 
1122
#define FBZMODE_ENABLE_CHROMAKEY(val)           (((val) >> 1) & 1)
 
1123
#define FBZMODE_ENABLE_STIPPLE(val)                     (((val) >> 2) & 1)
 
1124
#define FBZMODE_WBUFFER_SELECT(val)                     (((val) >> 3) & 1)
 
1125
#define FBZMODE_ENABLE_DEPTHBUF(val)            (((val) >> 4) & 1)
 
1126
#define FBZMODE_DEPTH_FUNCTION(val)                     (((val) >> 5) & 7)
 
1127
#define FBZMODE_ENABLE_DITHERING(val)           (((val) >> 8) & 1)
 
1128
#define FBZMODE_RGB_BUFFER_MASK(val)            (((val) >> 9) & 1)
 
1129
#define FBZMODE_AUX_BUFFER_MASK(val)            (((val) >> 10) & 1)
 
1130
#define FBZMODE_DITHER_TYPE(val)                        (((val) >> 11) & 1)
 
1131
#define FBZMODE_STIPPLE_PATTERN(val)            (((val) >> 12) & 1)
 
1132
#define FBZMODE_ENABLE_ALPHA_MASK(val)          (((val) >> 13) & 1)
 
1133
#define FBZMODE_DRAW_BUFFER(val)                        (((val) >> 14) & 3)
 
1134
#define FBZMODE_ENABLE_DEPTH_BIAS(val)          (((val) >> 16) & 1)
 
1135
#define FBZMODE_Y_ORIGIN(val)                           (((val) >> 17) & 1)
 
1136
#define FBZMODE_ENABLE_ALPHA_PLANES(val)        (((val) >> 18) & 1)
 
1137
#define FBZMODE_ALPHA_DITHER_SUBTRACT(val)      (((val) >> 19) & 1)
 
1138
#define FBZMODE_DEPTH_SOURCE_COMPARE(val)       (((val) >> 20) & 1)
 
1139
#define FBZMODE_DEPTH_FLOAT_SELECT(val)         (((val) >> 21) & 1)             /* voodoo 2 only */
 
1140
 
 
1141
#define LFBMODE_WRITE_FORMAT(val)                       (((val) >> 0) & 0xf)
 
1142
#define LFBMODE_WRITE_BUFFER_SELECT(val)        (((val) >> 4) & 3)
 
1143
#define LFBMODE_READ_BUFFER_SELECT(val)         (((val) >> 6) & 3)
 
1144
#define LFBMODE_ENABLE_PIXEL_PIPELINE(val)      (((val) >> 8) & 1)
 
1145
#define LFBMODE_RGBA_LANES(val)                         (((val) >> 9) & 3)
 
1146
#define LFBMODE_WORD_SWAP_WRITES(val)           (((val) >> 11) & 1)
 
1147
#define LFBMODE_BYTE_SWIZZLE_WRITES(val)        (((val) >> 12) & 1)
 
1148
#define LFBMODE_Y_ORIGIN(val)                           (((val) >> 13) & 1)
 
1149
#define LFBMODE_WRITE_W_SELECT(val)                     (((val) >> 14) & 1)
 
1150
#define LFBMODE_WORD_SWAP_READS(val)            (((val) >> 15) & 1)
 
1151
#define LFBMODE_BYTE_SWIZZLE_READS(val)         (((val) >> 16) & 1)
 
1152
 
 
1153
#define CHROMARANGE_BLUE_EXCLUSIVE(val)         (((val) >> 24) & 1)
 
1154
#define CHROMARANGE_GREEN_EXCLUSIVE(val)        (((val) >> 25) & 1)
 
1155
#define CHROMARANGE_RED_EXCLUSIVE(val)          (((val) >> 26) & 1)
 
1156
#define CHROMARANGE_UNION_MODE(val)                     (((val) >> 27) & 1)
 
1157
#define CHROMARANGE_ENABLE(val)                         (((val) >> 28) & 1)
 
1158
 
 
1159
#define FBIINIT0_VGA_PASSTHRU(val)                      (((val) >> 0) & 1)
 
1160
#define FBIINIT0_GRAPHICS_RESET(val)            (((val) >> 1) & 1)
 
1161
#define FBIINIT0_FIFO_RESET(val)                        (((val) >> 2) & 1)
 
1162
#define FBIINIT0_SWIZZLE_REG_WRITES(val)        (((val) >> 3) & 1)
 
1163
#define FBIINIT0_STALL_PCIE_FOR_HWM(val)        (((val) >> 4) & 1)
 
1164
#define FBIINIT0_PCI_FIFO_LWM(val)                      (((val) >> 6) & 0x1f)
 
1165
#define FBIINIT0_LFB_TO_MEMORY_FIFO(val)        (((val) >> 11) & 1)
 
1166
#define FBIINIT0_TEXMEM_TO_MEMORY_FIFO(val) (((val) >> 12) & 1)
 
1167
#define FBIINIT0_ENABLE_MEMORY_FIFO(val)        (((val) >> 13) & 1)
 
1168
#define FBIINIT0_MEMORY_FIFO_HWM(val)           (((val) >> 14) & 0x7ff)
 
1169
#define FBIINIT0_MEMORY_FIFO_BURST(val)         (((val) >> 25) & 0x3f)
 
1170
 
 
1171
#define FBIINIT1_PCI_DEV_FUNCTION(val)          (((val) >> 0) & 1)
 
1172
#define FBIINIT1_PCI_WRITE_WAIT_STATES(val)     (((val) >> 1) & 1)
 
1173
#define FBIINIT1_MULTI_SST1(val)                        (((val) >> 2) & 1)              /* not on voodoo 2 */
 
1174
#define FBIINIT1_ENABLE_LFB(val)                        (((val) >> 3) & 1)
 
1175
#define FBIINIT1_X_VIDEO_TILES(val)                     (((val) >> 4) & 0xf)
 
1176
#define FBIINIT1_VIDEO_TIMING_RESET(val)        (((val) >> 8) & 1)
 
1177
#define FBIINIT1_SOFTWARE_OVERRIDE(val)         (((val) >> 9) & 1)
 
1178
#define FBIINIT1_SOFTWARE_HSYNC(val)            (((val) >> 10) & 1)
 
1179
#define FBIINIT1_SOFTWARE_VSYNC(val)            (((val) >> 11) & 1)
 
1180
#define FBIINIT1_SOFTWARE_BLANK(val)            (((val) >> 12) & 1)
 
1181
#define FBIINIT1_DRIVE_VIDEO_TIMING(val)        (((val) >> 13) & 1)
 
1182
#define FBIINIT1_DRIVE_VIDEO_BLANK(val)         (((val) >> 14) & 1)
 
1183
#define FBIINIT1_DRIVE_VIDEO_SYNC(val)          (((val) >> 15) & 1)
 
1184
#define FBIINIT1_DRIVE_VIDEO_DCLK(val)          (((val) >> 16) & 1)
 
1185
#define FBIINIT1_VIDEO_TIMING_VCLK(val)         (((val) >> 17) & 1)
 
1186
#define FBIINIT1_VIDEO_CLK_2X_DELAY(val)        (((val) >> 18) & 3)
 
1187
#define FBIINIT1_VIDEO_TIMING_SOURCE(val)       (((val) >> 20) & 3)
 
1188
#define FBIINIT1_ENABLE_24BPP_OUTPUT(val)       (((val) >> 22) & 1)
 
1189
#define FBIINIT1_ENABLE_SLI(val)                        (((val) >> 23) & 1)
 
1190
#define FBIINIT1_X_VIDEO_TILES_BIT5(val)        (((val) >> 24) & 1)             /* voodoo 2 only */
 
1191
#define FBIINIT1_ENABLE_EDGE_FILTER(val)        (((val) >> 25) & 1)
 
1192
#define FBIINIT1_INVERT_VID_CLK_2X(val)         (((val) >> 26) & 1)
 
1193
#define FBIINIT1_VID_CLK_2X_SEL_DELAY(val)      (((val) >> 27) & 3)
 
1194
#define FBIINIT1_VID_CLK_DELAY(val)                     (((val) >> 29) & 3)
 
1195
#define FBIINIT1_DISABLE_FAST_READAHEAD(val) (((val) >> 31) & 1)
 
1196
 
 
1197
#define FBIINIT2_DISABLE_DITHER_SUB(val)        (((val) >> 0) & 1)
 
1198
#define FBIINIT2_DRAM_BANKING(val)                      (((val) >> 1) & 1)
 
1199
#define FBIINIT2_ENABLE_TRIPLE_BUF(val)         (((val) >> 4) & 1)
 
1200
#define FBIINIT2_ENABLE_FAST_RAS_READ(val)      (((val) >> 5) & 1)
 
1201
#define FBIINIT2_ENABLE_GEN_DRAM_OE(val)        (((val) >> 6) & 1)
 
1202
#define FBIINIT2_ENABLE_FAST_READWRITE(val)     (((val) >> 7) & 1)
 
1203
#define FBIINIT2_ENABLE_PASSTHRU_DITHER(val) (((val) >> 8) & 1)
 
1204
#define FBIINIT2_SWAP_BUFFER_ALGORITHM(val)     (((val) >> 9) & 3)
 
1205
#define FBIINIT2_VIDEO_BUFFER_OFFSET(val)       (((val) >> 11) & 0x1ff)
 
1206
#define FBIINIT2_ENABLE_DRAM_BANKING(val)       (((val) >> 20) & 1)
 
1207
#define FBIINIT2_ENABLE_DRAM_READ_FIFO(val)     (((val) >> 21) & 1)
 
1208
#define FBIINIT2_ENABLE_DRAM_REFRESH(val)       (((val) >> 22) & 1)
 
1209
#define FBIINIT2_REFRESH_LOAD_VALUE(val)        (((val) >> 23) & 0x1ff)
 
1210
 
 
1211
#define FBIINIT3_TRI_REGISTER_REMAP(val)        (((val) >> 0) & 1)
 
1212
#define FBIINIT3_VIDEO_FIFO_THRESH(val)         (((val) >> 1) & 0x1f)
 
1213
#define FBIINIT3_DISABLE_TMUS(val)                      (((val) >> 6) & 1)
 
1214
#define FBIINIT3_FBI_MEMORY_TYPE(val)           (((val) >> 8) & 7)
 
1215
#define FBIINIT3_VGA_PASS_RESET_VAL(val)        (((val) >> 11) & 1)
 
1216
#define FBIINIT3_HARDCODE_PCI_BASE(val)         (((val) >> 12) & 1)
 
1217
#define FBIINIT3_FBI2TREX_DELAY(val)            (((val) >> 13) & 0xf)
 
1218
#define FBIINIT3_TREX2FBI_DELAY(val)            (((val) >> 17) & 0x1f)
 
1219
#define FBIINIT3_YORIGIN_SUBTRACT(val)          (((val) >> 22) & 0x3ff)
 
1220
 
 
1221
#define FBIINIT4_PCI_READ_WAITS(val)            (((val) >> 0) & 1)
 
1222
#define FBIINIT4_ENABLE_LFB_READAHEAD(val)      (((val) >> 1) & 1)
 
1223
#define FBIINIT4_MEMORY_FIFO_LWM(val)           (((val) >> 2) & 0x3f)
 
1224
#define FBIINIT4_MEMORY_FIFO_START_ROW(val)     (((val) >> 8) & 0x3ff)
 
1225
#define FBIINIT4_MEMORY_FIFO_STOP_ROW(val)      (((val) >> 18) & 0x3ff)
 
1226
#define FBIINIT4_VIDEO_CLOCKING_DELAY(val)      (((val) >> 29) & 7)             /* voodoo 2 only */
 
1227
 
 
1228
#define FBIINIT5_DISABLE_PCI_STOP(val)          (((val) >> 0) & 1)              /* voodoo 2 only */
 
1229
#define FBIINIT5_PCI_SLAVE_SPEED(val)           (((val) >> 1) & 1)              /* voodoo 2 only */
 
1230
#define FBIINIT5_DAC_DATA_OUTPUT_WIDTH(val)     (((val) >> 2) & 1)              /* voodoo 2 only */
 
1231
#define FBIINIT5_DAC_DATA_17_OUTPUT(val)        (((val) >> 3) & 1)              /* voodoo 2 only */
 
1232
#define FBIINIT5_DAC_DATA_18_OUTPUT(val)        (((val) >> 4) & 1)              /* voodoo 2 only */
 
1233
#define FBIINIT5_GENERIC_STRAPPING(val)         (((val) >> 5) & 0xf)    /* voodoo 2 only */
 
1234
#define FBIINIT5_BUFFER_ALLOCATION(val)         (((val) >> 9) & 3)              /* voodoo 2 only */
 
1235
#define FBIINIT5_DRIVE_VID_CLK_SLAVE(val)       (((val) >> 11) & 1)             /* voodoo 2 only */
 
1236
#define FBIINIT5_DRIVE_DAC_DATA_16(val)         (((val) >> 12) & 1)             /* voodoo 2 only */
 
1237
#define FBIINIT5_VCLK_INPUT_SELECT(val)         (((val) >> 13) & 1)             /* voodoo 2 only */
 
1238
#define FBIINIT5_MULTI_CVG_DETECT(val)          (((val) >> 14) & 1)             /* voodoo 2 only */
 
1239
#define FBIINIT5_SYNC_RETRACE_READS(val)        (((val) >> 15) & 1)             /* voodoo 2 only */
 
1240
#define FBIINIT5_ENABLE_RHBORDER_COLOR(val)     (((val) >> 16) & 1)             /* voodoo 2 only */
 
1241
#define FBIINIT5_ENABLE_LHBORDER_COLOR(val)     (((val) >> 17) & 1)             /* voodoo 2 only */
 
1242
#define FBIINIT5_ENABLE_BVBORDER_COLOR(val)     (((val) >> 18) & 1)             /* voodoo 2 only */
 
1243
#define FBIINIT5_ENABLE_TVBORDER_COLOR(val)     (((val) >> 19) & 1)             /* voodoo 2 only */
 
1244
#define FBIINIT5_DOUBLE_HORIZ(val)                      (((val) >> 20) & 1)             /* voodoo 2 only */
 
1245
#define FBIINIT5_DOUBLE_VERT(val)                       (((val) >> 21) & 1)             /* voodoo 2 only */
 
1246
#define FBIINIT5_ENABLE_16BIT_GAMMA(val)        (((val) >> 22) & 1)             /* voodoo 2 only */
 
1247
#define FBIINIT5_INVERT_DAC_HSYNC(val)          (((val) >> 23) & 1)             /* voodoo 2 only */
 
1248
#define FBIINIT5_INVERT_DAC_VSYNC(val)          (((val) >> 24) & 1)             /* voodoo 2 only */
 
1249
#define FBIINIT5_ENABLE_24BIT_DACDATA(val)      (((val) >> 25) & 1)             /* voodoo 2 only */
 
1250
#define FBIINIT5_ENABLE_INTERLACING(val)        (((val) >> 26) & 1)             /* voodoo 2 only */
 
1251
#define FBIINIT5_DAC_DATA_18_CONTROL(val)       (((val) >> 27) & 1)             /* voodoo 2 only */
 
1252
#define FBIINIT5_RASTERIZER_UNIT_MODE(val)      (((val) >> 30) & 3)             /* voodoo 2 only */
 
1253
 
 
1254
#define FBIINIT6_WINDOW_ACTIVE_COUNTER(val)     (((val) >> 0) & 7)              /* voodoo 2 only */
 
1255
#define FBIINIT6_WINDOW_DRAG_COUNTER(val)       (((val) >> 3) & 0x1f)   /* voodoo 2 only */
 
1256
#define FBIINIT6_SLI_SYNC_MASTER(val)           (((val) >> 8) & 1)              /* voodoo 2 only */
 
1257
#define FBIINIT6_DAC_DATA_22_OUTPUT(val)        (((val) >> 9) & 3)              /* voodoo 2 only */
 
1258
#define FBIINIT6_DAC_DATA_23_OUTPUT(val)        (((val) >> 11) & 3)             /* voodoo 2 only */
 
1259
#define FBIINIT6_SLI_SYNCIN_OUTPUT(val)         (((val) >> 13) & 3)             /* voodoo 2 only */
 
1260
#define FBIINIT6_SLI_SYNCOUT_OUTPUT(val)        (((val) >> 15) & 3)             /* voodoo 2 only */
 
1261
#define FBIINIT6_DAC_RD_OUTPUT(val)                     (((val) >> 17) & 3)             /* voodoo 2 only */
 
1262
#define FBIINIT6_DAC_WR_OUTPUT(val)                     (((val) >> 19) & 3)             /* voodoo 2 only */
 
1263
#define FBIINIT6_PCI_FIFO_LWM_RDY(val)          (((val) >> 21) & 0x7f)  /* voodoo 2 only */
 
1264
#define FBIINIT6_VGA_PASS_N_OUTPUT(val)         (((val) >> 28) & 3)             /* voodoo 2 only */
 
1265
#define FBIINIT6_X_VIDEO_TILES_BIT0(val)        (((val) >> 30) & 1)             /* voodoo 2 only */
 
1266
 
 
1267
#define FBIINIT7_GENERIC_STRAPPING(val)         (((val) >> 0) & 0xff)   /* voodoo 2 only */
 
1268
#define FBIINIT7_CMDFIFO_ENABLE(val)            (((val) >> 8) & 1)              /* voodoo 2 only */
 
1269
#define FBIINIT7_CMDFIFO_MEMORY_STORE(val)      (((val) >> 9) & 1)              /* voodoo 2 only */
 
1270
#define FBIINIT7_DISABLE_CMDFIFO_HOLES(val)     (((val) >> 10) & 1)             /* voodoo 2 only */
 
1271
#define FBIINIT7_CMDFIFO_READ_THRESH(val)       (((val) >> 11) & 0x1f)  /* voodoo 2 only */
 
1272
#define FBIINIT7_SYNC_CMDFIFO_WRITES(val)       (((val) >> 16) & 1)             /* voodoo 2 only */
 
1273
#define FBIINIT7_SYNC_CMDFIFO_READS(val)        (((val) >> 17) & 1)             /* voodoo 2 only */
 
1274
#define FBIINIT7_RESET_PCI_PACKER(val)          (((val) >> 18) & 1)             /* voodoo 2 only */
 
1275
#define FBIINIT7_ENABLE_CHROMA_STUFF(val)       (((val) >> 19) & 1)             /* voodoo 2 only */
 
1276
#define FBIINIT7_CMDFIFO_PCI_TIMEOUT(val)       (((val) >> 20) & 0x7f)  /* voodoo 2 only */
 
1277
#define FBIINIT7_ENABLE_TEXTURE_BURST(val)      (((val) >> 27) & 1)             /* voodoo 2 only */
 
1278
 
 
1279
#define TEXMODE_ENABLE_PERSPECTIVE(val)         (((val) >> 0) & 1)
 
1280
#define TEXMODE_MINIFICATION_FILTER(val)        (((val) >> 1) & 1)
 
1281
#define TEXMODE_MAGNIFICATION_FILTER(val)       (((val) >> 2) & 1)
 
1282
#define TEXMODE_CLAMP_NEG_W(val)                        (((val) >> 3) & 1)
 
1283
#define TEXMODE_ENABLE_LOD_DITHER(val)          (((val) >> 4) & 1)
 
1284
#define TEXMODE_NCC_TABLE_SELECT(val)           (((val) >> 5) & 1)
 
1285
#define TEXMODE_CLAMP_S(val)                            (((val) >> 6) & 1)
 
1286
#define TEXMODE_CLAMP_T(val)                            (((val) >> 7) & 1)
 
1287
#define TEXMODE_FORMAT(val)                                     (((val) >> 8) & 0xf)
 
1288
#define TEXMODE_TC_ZERO_OTHER(val)                      (((val) >> 12) & 1)
 
1289
#define TEXMODE_TC_SUB_CLOCAL(val)                      (((val) >> 13) & 1)
 
1290
#define TEXMODE_TC_MSELECT(val)                         (((val) >> 14) & 7)
 
1291
#define TEXMODE_TC_REVERSE_BLEND(val)           (((val) >> 17) & 1)
 
1292
#define TEXMODE_TC_ADD_ACLOCAL(val)                     (((val) >> 18) & 3)
 
1293
#define TEXMODE_TC_INVERT_OUTPUT(val)           (((val) >> 20) & 1)
 
1294
#define TEXMODE_TCA_ZERO_OTHER(val)                     (((val) >> 21) & 1)
 
1295
#define TEXMODE_TCA_SUB_CLOCAL(val)                     (((val) >> 22) & 1)
 
1296
#define TEXMODE_TCA_MSELECT(val)                        (((val) >> 23) & 7)
 
1297
#define TEXMODE_TCA_REVERSE_BLEND(val)          (((val) >> 26) & 1)
 
1298
#define TEXMODE_TCA_ADD_ACLOCAL(val)            (((val) >> 27) & 3)
 
1299
#define TEXMODE_TCA_INVERT_OUTPUT(val)          (((val) >> 29) & 1)
 
1300
#define TEXMODE_TRILINEAR(val)                          (((val) >> 30) & 1)
 
1301
#define TEXMODE_SEQ_8_DOWNLD(val)                       (((val) >> 31) & 1)
 
1302
 
 
1303
#define TEXLOD_LODMIN(val)                                      (((val) >> 0) & 0x3f)
 
1304
#define TEXLOD_LODMAX(val)                                      (((val) >> 6) & 0x3f)
 
1305
#define TEXLOD_LODBIAS(val)                                     (((val) >> 12) & 0x3f)
 
1306
#define TEXLOD_LOD_ODD(val)                                     (((val) >> 18) & 1)
 
1307
#define TEXLOD_LOD_TSPLIT(val)                          (((val) >> 19) & 1)
 
1308
#define TEXLOD_LOD_S_IS_WIDER(val)                      (((val) >> 20) & 1)
 
1309
#define TEXLOD_LOD_ASPECT(val)                          (((val) >> 21) & 3)
 
1310
#define TEXLOD_LOD_ZEROFRAC(val)                        (((val) >> 23) & 1)
 
1311
#define TEXLOD_TMULTIBASEADDR(val)                      (((val) >> 24) & 1)
 
1312
#define TEXLOD_TDATA_SWIZZLE(val)                       (((val) >> 25) & 1)
 
1313
#define TEXLOD_TDATA_SWAP(val)                          (((val) >> 26) & 1)
 
1314
#define TEXLOD_TDIRECT_WRITE(val)                       (((val) >> 27) & 1)             /* Voodoo 2 only */
 
1315
 
 
1316
#define TEXDETAIL_DETAIL_MAX(val)                       (((val) >> 0) & 0xff)
 
1317
#define TEXDETAIL_DETAIL_BIAS(val)                      (((val) >> 8) & 0x3f)
 
1318
#define TEXDETAIL_DETAIL_SCALE(val)                     (((val) >> 14) & 7)
 
1319
#define TEXDETAIL_RGB_MIN_FILTER(val)           (((val) >> 17) & 1)             /* Voodoo 2 only */
 
1320
#define TEXDETAIL_RGB_MAG_FILTER(val)           (((val) >> 18) & 1)             /* Voodoo 2 only */
 
1321
#define TEXDETAIL_ALPHA_MIN_FILTER(val)         (((val) >> 19) & 1)             /* Voodoo 2 only */
 
1322
#define TEXDETAIL_ALPHA_MAG_FILTER(val)         (((val) >> 20) & 1)             /* Voodoo 2 only */
 
1323
#define TEXDETAIL_SEPARATE_RGBA_FILTER(val)     (((val) >> 21) & 1)             /* Voodoo 2 only */
 
1324
 
 
1325
 
 
1326
 
 
1327
/*************************************
 
1328
 *
 
1329
 *  Core types
 
1330
 *
 
1331
 *************************************/
 
1332
 
 
1333
typedef struct _voodoo_state voodoo_state;
 
1334
 
 
1335
union _voodoo_reg
 
1336
{
 
1337
        INT32           i;
 
1338
        UINT32          u;
 
1339
        float           f;
 
1340
};
 
1341
typedef union _voodoo_reg voodoo_reg;
 
1342
 
 
1343
 
 
1344
struct _fifo_state
 
1345
{
 
1346
        UINT32 *        base;                                   /* base of the FIFO */
 
1347
        INT32           size;                                   /* size of the FIFO */
 
1348
        INT32           in;                                             /* input pointer */
 
1349
        INT32           out;                                    /* output pointer */
 
1350
};
 
1351
typedef struct _fifo_state fifo_state;
 
1352
 
 
1353
 
 
1354
struct _cmdfifo_info
 
1355
{
 
1356
        UINT8           enable;                                 /* enabled? */
 
1357
        UINT8           count_holes;                    /* count holes? */
 
1358
        UINT32          base;                                   /* base address in framebuffer RAM */
 
1359
        UINT32          end;                                    /* end address in framebuffer RAM */
 
1360
        UINT32          rdptr;                                  /* current read pointer */
 
1361
        UINT32          amin;                                   /* minimum address */
 
1362
        UINT32          amax;                                   /* maximum address */
 
1363
        UINT32          depth;                                  /* current depth */
 
1364
        UINT32          holes;                                  /* number of holes */
 
1365
};
 
1366
typedef struct _cmdfifo_info cmdfifo_info;
 
1367
 
 
1368
 
 
1369
struct _pci_state
 
1370
{
 
1371
        fifo_state      fifo;                                   /* PCI FIFO */
 
1372
        UINT32          fifo_mem[64*2];                 /* memory backing the PCI FIFO */
 
1373
        UINT32          init_enable;                    /* initEnable value */
 
1374
        UINT8           stall_state;                    /* state of the system if we're stalled */
 
1375
        void            (*stall_callback)(int); /* callback for stalling/unstalling */
 
1376
        UINT8           op_pending;                             /* true if an operation is pending */
 
1377
        mame_time       op_end_time;                    /* time when the pending operation ends */
 
1378
        mame_timer *continue_timer;                     /* timer to use to continue processing */
 
1379
};
 
1380
typedef struct _pci_state pci_state;
 
1381
 
 
1382
 
 
1383
struct _ncc_table
 
1384
{
 
1385
        UINT8           dirty;                                  /* is the texel lookup dirty? */
 
1386
        voodoo_reg *reg;                                        /* pointer to our registers */
 
1387
        INT32           ir[4], ig[4], ib[4];    /* I values for R,G,B */
 
1388
        INT32           qr[4], qg[4], qb[4];    /* Q values for R,G,B */
 
1389
        INT32           y[16];                                  /* Y values */
 
1390
        rgb_t           texel[256];                             /* texel lookup */
 
1391
        rgb_t *         palette;                                /* pointer to associated RGB palette */
 
1392
        rgb_t *         palettea;                               /* pointer to associated ARGB palette */
 
1393
};
 
1394
typedef struct _ncc_table ncc_table;
 
1395
 
 
1396
 
 
1397
struct _tmu_state
 
1398
{
 
1399
        UINT8 *         ram;                                    /* pointer to our RAM */
 
1400
        UINT32          mask;                                   /* mask to apply to pointers */
 
1401
        voodoo_reg *reg;                                        /* pointer to our register base */
 
1402
        UINT32          regdirty;                               /* true if the LOD/mode/base registers have changed */
 
1403
 
 
1404
        UINT32          texaddr_mask;                   /* mask for texture address */
 
1405
        UINT8           texaddr_shift;                  /* shift for texture address */
 
1406
 
 
1407
        INT64           starts, startt;                 /* starting S,T (14.18) */
 
1408
        INT64           startw;                                 /* starting W (2.30) */
 
1409
        INT64           dsdx, dtdx;                             /* delta S,T per X */
 
1410
        INT64           dwdx;                                   /* delta W per X */
 
1411
        INT64           dsdy, dtdy;                             /* delta S,T per Y */
 
1412
        INT64           dwdy;                                   /* delta W per Y */
 
1413
 
 
1414
        INT32           lodmin, lodmax;                 /* min, max LOD values */
 
1415
        INT32           lodbias;                                /* LOD bias */
 
1416
        UINT32          lodmask;                                /* mask of available LODs */
 
1417
        UINT32          lodoffset[9];                   /* offset of texture base for each LOD */
 
1418
        INT32           lodbase;                                /* used during rasterization */
 
1419
        INT32           detailmax;                              /* detail clamp */
 
1420
        INT32           detailbias;                             /* detail bias */
 
1421
        UINT8           detailscale;                    /* detail scale */
 
1422
 
 
1423
        UINT32          wmask;                                  /* mask for the current texture width */
 
1424
        UINT32          hmask;                                  /* mask for the current texture height */
 
1425
 
 
1426
        UINT32          bilinear_mask;                  /* mask for bilinear resolution (0xf0 for V1, 0xff for V2) */
 
1427
 
 
1428
        ncc_table       ncc[2];                                 /* two NCC tables */
 
1429
 
 
1430
        rgb_t *         lookup;                                 /* currently selected lookup */
 
1431
        rgb_t *         texel[16];                              /* texel lookups for each format */
 
1432
 
 
1433
        rgb_t           palette[256];                   /* palette lookup table */
 
1434
        rgb_t           palettea[256];                  /* palette+alpha lookup table */
 
1435
};
 
1436
typedef struct _tmu_state tmu_state;
 
1437
 
 
1438
 
 
1439
struct _tmu_shared_state
 
1440
{
 
1441
        rgb_t           rgb332[256];                    /* RGB 3-3-2 lookup table */
 
1442
        rgb_t           alpha8[256];                    /* alpha 8-bit lookup table */
 
1443
        rgb_t           int8[256];                              /* intensity 8-bit lookup table */
 
1444
        rgb_t           ai44[256];                              /* alpha, intensity 4-4 lookup table */
 
1445
 
 
1446
        rgb_t           rgb565[65536];                  /* RGB 5-6-5 lookup table */
 
1447
        rgb_t           argb1555[65536];                /* ARGB 1-5-5-5 lookup table */
 
1448
        rgb_t           argb4444[65536];                /* ARGB 4-4-4-4 lookup table */
 
1449
};
 
1450
typedef struct _tmu_shared_state tmu_shared_state;
 
1451
 
 
1452
 
 
1453
struct _setup_vertex
 
1454
{
 
1455
        float           x, y;                                   /* X, Y coordinates */
 
1456
        float           a, r, g, b;                             /* A, R, G, B values */
 
1457
        float           z, wb;                                  /* Z and broadcast W values */
 
1458
        float           w0, s0, t0;                             /* W, S, T for TMU 0 */
 
1459
        float           w1, s1, t1;                             /* W, S, T for TMU 1 */
 
1460
};
 
1461
typedef struct _setup_vertex setup_vertex;
 
1462
 
 
1463
 
 
1464
struct _fbi_state
 
1465
{
 
1466
        void *          ram;                                    /* pointer to frame buffer RAM */
 
1467
        UINT32          mask;                                   /* mask to apply to pointers */
 
1468
        UINT16 *        rgb[3];                                 /* pointer to 3 RGB buffers */
 
1469
        UINT16 *        aux;                                    /* pointer to 1 aux buffer */
 
1470
        UINT32          rgbmax[3];                              /* maximum valid offset in each RGB buffer */
 
1471
        UINT32          auxmax;                                 /* maximum valid offset in the aux buffer */
 
1472
 
 
1473
        UINT8           frontbuf;                               /* front buffer index */
 
1474
        UINT8           backbuf;                                /* back buffer index */
 
1475
        UINT8           swaps_pending;                  /* number of pending swaps */
 
1476
 
 
1477
        UINT32          yorigin;                                /* Y origin subtract value */
 
1478
        UINT32          lfb_base;                               /* base of LFB in memory */
 
1479
        UINT8           lfb_stride;                             /* stride of LFB accesses in bits */
 
1480
 
 
1481
        UINT32          width;                                  /* width of current frame buffer */
 
1482
        UINT32          height;                                 /* height of current frame buffer */
 
1483
        UINT32          rowpixels;                              /* pixels per row */
 
1484
        UINT32          tile_width;                             /* width of video tiles */
 
1485
        UINT32          tile_height;                    /* height of video tiles */
 
1486
        UINT32          x_tiles;                                /* number of tiles in the X direction */
 
1487
 
 
1488
        rgb_t           pen[65536];                             /* mapping from pixels to pens */
 
1489
        rgb_t           clut[512];                              /* clut gamma data */
 
1490
        UINT8           clut_dirty;                             /* do we need to recompute? */
 
1491
 
 
1492
        mame_timer *vblank_timer;                       /* VBLANK timer */
 
1493
        UINT8           vblank;                                 /* VBLANK state */
 
1494
        UINT8           vblank_count;                   /* number of VBLANKs since last swap */
 
1495
        UINT8           vblank_swap_pending;    /* a swap is pending, waiting for a vblank */
 
1496
        UINT8           vblank_swap;                    /* swap when we hit this count */
 
1497
        UINT8           vblank_dont_swap;               /* don't actually swap when we hit this point */
 
1498
        void            (*vblank_client)(int);  /* client callback */
 
1499
 
 
1500
        fifo_state      fifo;                                   /* framebuffer memory fifo */
 
1501
        cmdfifo_info cmdfifo[2];                        /* command FIFOs */
 
1502
 
 
1503
        UINT8           fogblend[64];                   /* 64-entry fog table */
 
1504
        UINT8           fogdelta[64];                   /* 64-entry fog table */
 
1505
        UINT8           fogdelta_mask;                  /* mask for for delta (0xff for V1, 0xfc for V2) */
 
1506
 
 
1507
        /* triangle setup info */
 
1508
        UINT8           cheating_allowed;               /* allow cheating? */
 
1509
        INT32           sign;                                   /* triangle sign */
 
1510
        INT16           ax, ay;                                 /* vertex A x,y (12.4) */
 
1511
        INT16           bx, by;                                 /* vertex B x,y (12.4) */
 
1512
        INT16           cx, cy;                                 /* vertex C x,y (12.4) */
 
1513
        INT32           startr, startg, startb, starta; /* starting R,G,B,A (12.12) */
 
1514
        INT32           startz;                                 /* starting Z (20.12) */
 
1515
        INT64           startw;                                 /* starting W (16.32) */
 
1516
        INT32           drdx, dgdx, dbdx, dadx; /* delta R,G,B,A per X */
 
1517
        INT32           dzdx;                                   /* delta Z per X */
 
1518
        INT64           dwdx;                                   /* delta W per X */
 
1519
        INT32           drdy, dgdy, dbdy, dady; /* delta R,G,B,A per Y */
 
1520
        INT32           dzdy;                                   /* delta Z per Y */
 
1521
        INT64           dwdy;                                   /* delta W per Y */
 
1522
 
 
1523
        UINT8           sverts;                                 /* number of vertices ready */
 
1524
        setup_vertex svert[3];                          /* 3 setup vertices */
 
1525
};
 
1526
typedef struct _fbi_state fbi_state;
 
1527
 
 
1528
 
 
1529
struct _dac_state
 
1530
{
 
1531
        UINT8           reg[8];                                 /* 8 registers */
 
1532
        UINT8           read_result;                    /* pending read result */
 
1533
};
 
1534
typedef struct _dac_state dac_state;
 
1535
 
 
1536
 
 
1537
struct _voodoo_stats
 
1538
{
 
1539
        char            buffer[1024];                   /* string */
 
1540
        UINT8           lastkey;                                /* last key state */
 
1541
        UINT8           display;                                /* display stats? */
 
1542
        INT32           swaps;                                  /* total swaps */
 
1543
        INT32           stalls;                                 /* total stalls */
 
1544
        INT32           total_triangles;                /* total triangles */
 
1545
        INT32           total_pixels_in;                /* total pixels in */
 
1546
        INT32           total_pixels_out;               /* total pixels out */
 
1547
        INT32           total_chroma_fail;              /* total chroma fail */
 
1548
        INT32           total_zfunc_fail;               /* total z func fail */
 
1549
        INT32           total_afunc_fail;               /* total a func fail */
 
1550
        INT32           total_clipped;                  /* total clipped */
 
1551
        INT32           total_stippled;                 /* total stippled */
 
1552
        INT32           lfb_writes;                             /* LFB writes */
 
1553
        INT32           lfb_reads;                              /* LFB reads */
 
1554
        INT32           reg_writes;                             /* register writes */
 
1555
        INT32           reg_reads;                              /* register reads */
 
1556
        INT32           tex_writes;                             /* texture writes */
 
1557
        INT32           texture_mode[16];               /* 16 different texture modes */
 
1558
        UINT8           render_override;                /* render override */
 
1559
};
 
1560
typedef struct _voodoo_stats voodoo_stats;
 
1561
 
 
1562
 
 
1563
struct _raster_info
 
1564
{
 
1565
        struct _raster_info *next;                      /* pointer to next entry with the same hash */
 
1566
        void            (*callback)(voodoo_state *, UINT16 *); /* callback pointer */
 
1567
        UINT8           is_generic;                             /* TRUE if this is one of the generic rasterizers */
 
1568
        UINT32          hits;                                   /* how many hits (pixels) we've used this for */
 
1569
        UINT32          polys;                                  /* how many polys we've used this for */
 
1570
        UINT32          eff_color_path;                 /* effective fbzColorPath value */
 
1571
        UINT32          eff_alpha_mode;                 /* effective alphaMode value */
 
1572
        UINT32          eff_fog_mode;                   /* effective fogMode value */
 
1573
        UINT32          eff_fbz_mode;                   /* effective fbzMode value */
 
1574
        UINT32          eff_tex_mode_0;                 /* effective textureMode value for TMU #0 */
 
1575
        UINT32          eff_tex_mode_1;                 /* effective textureMode value for TMU #1 */
 
1576
};
 
1577
typedef struct _raster_info raster_info;
 
1578
 
 
1579
 
 
1580
struct _banshee_info
 
1581
{
 
1582
        UINT32          io[0x40];                               /* I/O registers */
 
1583
        UINT32          agp[0x80];                              /* AGP registers */
 
1584
        UINT8           vga[0x20];                              /* VGA registers */
 
1585
        UINT8           crtc[0x27];                             /* VGA CRTC registers */
 
1586
        UINT8           seq[0x05];                              /* VGA sequencer registers */
 
1587
        UINT8           gc[0x05];                               /* VGA graphics controller registers */
 
1588
        UINT8           att[0x15];                              /* VGA attribute registers */
 
1589
        UINT8           attff;                                  /* VGA attribute flip-flop */
 
1590
};
 
1591
typedef struct _banshee_info banshee_info;
 
1592
 
 
1593
 
 
1594
struct _voodoo_state
 
1595
{
 
1596
        UINT8           index;                                  /* index of board */
 
1597
        UINT8           type;                                   /* type of system */
 
1598
        UINT8           chipmask;                               /* mask for which chips are available */
 
1599
        UINT32          freq;                                   /* operating frequency */
 
1600
        subseconds_t subseconds_per_cycle;      /* subseconds per cycle */
 
1601
        UINT32          extra_cycles;                   /* extra cycles not yet accounted for */
 
1602
        int                     trigger;                                /* trigger used for stalling */
 
1603
 
 
1604
        voodoo_reg      reg[0x400];                             /* raw registers */
 
1605
        const UINT8 *regaccess;                         /* register access array */
 
1606
        const char **regnames;                          /* register names array */
 
1607
        UINT8           alt_regmap;                             /* enable alternate register map? */
 
1608
 
 
1609
        pci_state       pci;                                    /* PCI state */
 
1610
        dac_state       dac;                                    /* DAC state */
 
1611
 
 
1612
        fbi_state       fbi;                                    /* FBI states */
 
1613
        tmu_state       tmu[MAX_TMU];                   /* TMU states */
 
1614
        tmu_shared_state tmushare;                      /* TMU shared state */
 
1615
        banshee_info banshee;                           /* Banshee state */
 
1616
 
 
1617
        voodoo_stats stats;                                     /* internal statistics */
 
1618
 
 
1619
        offs_t          last_status_pc;                 /* PC of last status read (for logging) */
 
1620
        UINT32          last_status_value;              /* value of last status read (for logging) */
 
1621
 
 
1622
        int                     next_rasterizer;                /* next rasterizer index */
 
1623
        raster_info     rasterizer[MAX_RASTERIZERS]; /* array of rasterizers */
 
1624
        raster_info *raster_hash[RASTER_HASH_SIZE]; /* hash table of rasterizers */
 
1625
};
 
1626
/* typedef struct _voodoo_state voodoo_state; -- declared above */
 
1627
 
 
1628
 
 
1629
 
 
1630
/*************************************
 
1631
 *
 
1632
 *  Inline FIFO management
 
1633
 *
 
1634
 *************************************/
 
1635
 
 
1636
INLINE void fifo_reset(fifo_state *f)
 
1637
{
 
1638
        f->in = f->out = 0;
 
1639
}
 
1640
 
 
1641
 
 
1642
INLINE void fifo_add(fifo_state *f, UINT32 data)
 
1643
{
 
1644
        INT32 next_in;
 
1645
 
 
1646
        /* compute the value of 'in' after we add this item */
 
1647
        next_in = f->in + 1;
 
1648
        if (next_in >= f->size)
 
1649
                next_in = 0;
 
1650
 
 
1651
        /* as long as it's not equal to the output pointer, we can do it */
 
1652
        if (next_in != f->out)
 
1653
        {
 
1654
                f->base[f->in] = data;
 
1655
                f->in = next_in;
 
1656
        }
 
1657
}
 
1658
 
 
1659
 
 
1660
INLINE UINT32 fifo_remove(fifo_state *f)
 
1661
{
 
1662
        UINT32 data = 0xffffffff;
 
1663
 
 
1664
        /* as long as we have data, we can do it */
 
1665
        if (f->out != f->in)
 
1666
        {
 
1667
                INT32 next_out;
 
1668
 
 
1669
                /* fetch the data */
 
1670
                data = f->base[f->out];
 
1671
 
 
1672
                /* advance the output pointer */
 
1673
                next_out = f->out + 1;
 
1674
                if (next_out >= f->size)
 
1675
                        next_out = 0;
 
1676
                f->out = next_out;
 
1677
        }
 
1678
        return data;
 
1679
}
 
1680
 
 
1681
 
 
1682
INLINE UINT32 fifo_peek(fifo_state *f)
 
1683
{
 
1684
        return f->base[f->out];
 
1685
}
 
1686
 
 
1687
 
 
1688
INLINE int fifo_empty(fifo_state *f)
 
1689
{
 
1690
        return (f->in == f->out);
 
1691
}
 
1692
 
 
1693
 
 
1694
INLINE int fifo_full(fifo_state *f)
 
1695
{
 
1696
        return (f->in + 1 == f->out || (f->in == f->size - 1 && f->out == 0));
 
1697
}
 
1698
 
 
1699
 
 
1700
INLINE INT32 fifo_items(fifo_state *f)
 
1701
{
 
1702
        INT32 items = f->in - f->out;
 
1703
        if (items < 0)
 
1704
                items += f->size;
 
1705
        return items;
 
1706
}
 
1707
 
 
1708
 
 
1709
INLINE INT32 fifo_space(fifo_state *f)
 
1710
{
 
1711
        INT32 items = f->in - f->out;
 
1712
        if (items < 0)
 
1713
                items += f->size;
 
1714
        return f->size - 1 - items;
 
1715
}
 
1716
 
 
1717
 
 
1718
 
 
1719
/*************************************
 
1720
 *
 
1721
 *  Computes a fast 16.16 reciprocal
 
1722
 *  of a 16.32 value; used for
 
1723
 *  computing 1/w in the rasterizer.
 
1724
 *
 
1725
 *  Since it is trivial to also
 
1726
 *  compute log2(1/w) = -log2(w) at
 
1727
 *  the same time, we do that as well
 
1728
 *  to 16.8 precision for LOD
 
1729
 *  calculations.
 
1730
 *
 
1731
 *  On a Pentium M, this routine is
 
1732
 *  20% faster than a 64-bit integer
 
1733
 *  divide and also produces the log
 
1734
 *  for free.
 
1735
 *
 
1736
 *************************************/
 
1737
 
 
1738
INLINE INT32 fast_reciplog(INT64 value, INT32 *log2)
 
1739
{
 
1740
        extern UINT32 reciplog[];
 
1741
        UINT32 temp, recip, rlog;
 
1742
        UINT32 interp;
 
1743
        UINT32 *table;
 
1744
        int neg = FALSE;
 
1745
        int lz, exp = 0;
 
1746
 
 
1747
        /* always work with unsigned numbers */
 
1748
        if (value < 0)
 
1749
        {
 
1750
                value = -value;
 
1751
                neg = TRUE;
 
1752
        }
 
1753
 
 
1754
        /* if we've spilled out of 32 bits, push it down under 32 */
 
1755
        if (value & U64(0xffff00000000))
 
1756
        {
 
1757
                temp = (UINT32)(value >> 16);
 
1758
                exp -= 16;
 
1759
        }
 
1760
        else
 
1761
                temp = (UINT32)value;
 
1762
 
 
1763
        /* if the resulting value is 0, the reciprocal is infinite */
 
1764
        if (UNEXPECTED(temp == 0))
 
1765
        {
 
1766
                *log2 = 1000 << LOG_OUTPUT_PREC;
 
1767
                return neg ? 0x80000000 : 0x7fffffff;
 
1768
        }
 
1769
 
 
1770
        /* determine how many leading zeros in the value and shift it up high */
 
1771
        lz = count_leading_zeros(temp);
 
1772
        temp <<= lz;
 
1773
        exp += lz;
 
1774
 
 
1775
        /* compute a pointer to the table entries we want */
 
1776
        /* math is a bit funny here because we shift one less than we need to in order */
 
1777
        /* to account for the fact that there are two UINT32's per table entry */
 
1778
        table = &reciplog[(temp >> (31 - RECIPLOG_LOOKUP_BITS - 1)) & ((2 << RECIPLOG_LOOKUP_BITS) - 2)];
 
1779
 
 
1780
        /* compute the interpolation value */
 
1781
        interp = (temp >> (31 - RECIPLOG_LOOKUP_BITS - 8)) & 0xff;
 
1782
 
 
1783
        /* do a linear interpolatation between the two nearest table values */
 
1784
        /* for both the log and the reciprocal */
 
1785
        rlog = (table[1] * (0x100 - interp) + table[3] * interp) >> 8;
 
1786
        recip = (table[0] * (0x100 - interp) + table[2] * interp) >> 8;
 
1787
 
 
1788
        /* the log result is the fractional part of the log; round it to the output precision */
 
1789
        rlog = (rlog + (1 << (RECIPLOG_LOOKUP_PREC - LOG_OUTPUT_PREC - 1))) >> (RECIPLOG_LOOKUP_PREC - LOG_OUTPUT_PREC);
 
1790
 
 
1791
        /* the exponent is the non-fractional part of the log; normally, we would subtract it from rlog */
 
1792
        /* but since we want the log(1/value) = -log(value), we subtract rlog from the exponent */
 
1793
        *log2 = ((exp - (31 - RECIPLOG_INPUT_PREC)) << LOG_OUTPUT_PREC) - rlog;
 
1794
 
 
1795
        /* adjust the exponent to account for all the reciprocal-related parameters to arrive at a final shift amount */
 
1796
        exp += (RECIP_OUTPUT_PREC - RECIPLOG_LOOKUP_PREC) - (31 - RECIPLOG_INPUT_PREC);
 
1797
 
 
1798
        /* shift by the exponent */
 
1799
        if (exp < 0)
 
1800
                recip >>= -exp;
 
1801
        else
 
1802
                recip <<= exp;
 
1803
 
 
1804
        /* on the way out, apply the original sign to the reciprocal */
 
1805
        return neg ? -recip : recip;
 
1806
}
 
1807
 
 
1808
 
 
1809
 
 
1810
/*************************************
 
1811
 *
 
1812
 *  Float-to-int conversions
 
1813
 *
 
1814
 *************************************/
 
1815
 
 
1816
INLINE INT32 float_to_int32(UINT32 data, int fixedbits)
 
1817
{
 
1818
        int exponent = ((data >> 23) & 0xff) - 127 - 23 + fixedbits;
 
1819
        INT32 result = (data & 0x7fffff) | 0x800000;
 
1820
        if (exponent < 0)
 
1821
        {
 
1822
                if (exponent > -32)
 
1823
                        result >>= -exponent;
 
1824
                else
 
1825
                        result = 0;
 
1826
        }
 
1827
        else
 
1828
        {
 
1829
                if (exponent < 32)
 
1830
                        result <<= exponent;
 
1831
                else
 
1832
                        result = 0x7fffffff;
 
1833
        }
 
1834
        if (data & 0x80000000)
 
1835
                result = -result;
 
1836
        return result;
 
1837
}
 
1838
 
 
1839
 
 
1840
INLINE INT64 float_to_int64(UINT32 data, int fixedbits)
 
1841
{
 
1842
        int exponent = ((data >> 23) & 0xff) - 127 - 23 + fixedbits;
 
1843
        INT64 result = (data & 0x7fffff) | 0x800000;
 
1844
        if (exponent < 0)
 
1845
        {
 
1846
                if (exponent > -64)
 
1847
                        result >>= -exponent;
 
1848
                else
 
1849
                        result = 0;
 
1850
        }
 
1851
        else
 
1852
        {
 
1853
                if (exponent < 64)
 
1854
                        result <<= exponent;
 
1855
                else
 
1856
                        result = U64(0x7fffffffffffffff);
 
1857
        }
 
1858
        if (data & 0x80000000)
 
1859
                result = -result;
 
1860
        return result;
 
1861
}
 
1862
 
 
1863
 
 
1864
 
 
1865
/*************************************
 
1866
 *
 
1867
 *  Rasterizer inlines
 
1868
 *
 
1869
 *************************************/
 
1870
 
 
1871
INLINE UINT32 normalize_color_path(UINT32 eff_color_path)
 
1872
{
 
1873
        /* ignore the subpixel adjust and texture enable flags */
 
1874
        eff_color_path &= ~((1 << 26) | (1 << 27));
 
1875
 
 
1876
        return eff_color_path;
 
1877
}
 
1878
 
 
1879
 
 
1880
INLINE UINT32 normalize_alpha_mode(UINT32 eff_alpha_mode)
 
1881
{
 
1882
        /* if not doing alpha testing, ignore the alpha function and ref value */
 
1883
        if (!ALPHAMODE_ALPHATEST(eff_alpha_mode))
 
1884
                eff_alpha_mode &= ~((7 << 1) | (0xff << 24));
 
1885
 
 
1886
        /* if not doing alpha blending, ignore the source and dest blending factors */
 
1887
        if (!ALPHAMODE_ALPHABLEND(eff_alpha_mode))
 
1888
                eff_alpha_mode &= ~((15 << 8) | (15 << 12) | (15 << 16) | (15 << 20));
 
1889
 
 
1890
        return eff_alpha_mode;
 
1891
}
 
1892
 
 
1893
 
 
1894
INLINE UINT32 normalize_fog_mode(UINT32 eff_fog_mode)
 
1895
{
 
1896
        /* if not doing fogging, ignore all the other fog bits */
 
1897
        if (!FOGMODE_ENABLE_FOG(eff_fog_mode))
 
1898
                eff_fog_mode = 0;
 
1899
 
 
1900
        return eff_fog_mode;
 
1901
}
 
1902
 
 
1903
 
 
1904
INLINE UINT32 normalize_fbz_mode(UINT32 eff_fbz_mode)
 
1905
{
 
1906
        /* ignore the draw buffer */
 
1907
        eff_fbz_mode &= ~(3 << 14);
 
1908
 
 
1909
        return eff_fbz_mode;
 
1910
}
 
1911
 
 
1912
 
 
1913
INLINE UINT32 normalize_tex_mode(UINT32 eff_tex_mode)
 
1914
{
 
1915
        /* ignore the NCC table and seq_8_downld flags */
 
1916
        eff_tex_mode &= ~((1 << 5) | (1 << 31));
 
1917
 
 
1918
        /* classify texture formats into 3 format categories */
 
1919
        if (TEXMODE_FORMAT(eff_tex_mode) < 8)
 
1920
                eff_tex_mode = (eff_tex_mode & ~(0xf << 8)) | (0 << 8);
 
1921
        else if (TEXMODE_FORMAT(eff_tex_mode) >= 10 && TEXMODE_FORMAT(eff_tex_mode) <= 12)
 
1922
                eff_tex_mode = (eff_tex_mode & ~(0xf << 8)) | (10 << 8);
 
1923
        else
 
1924
                eff_tex_mode = (eff_tex_mode & ~(0xf << 8)) | (8 << 8);
 
1925
 
 
1926
        return eff_tex_mode;
 
1927
}
 
1928
 
 
1929
 
 
1930
INLINE UINT32 compute_raster_hash(const raster_info *info)
 
1931
{
 
1932
        UINT32 hash;
 
1933
 
 
1934
        /* make a hash */
 
1935
        hash = info->eff_color_path;
 
1936
        hash = (hash << 1) | (hash >> 31);
 
1937
        hash ^= info->eff_fbz_mode;
 
1938
        hash = (hash << 1) | (hash >> 31);
 
1939
        hash ^= info->eff_alpha_mode;
 
1940
        hash = (hash << 1) | (hash >> 31);
 
1941
        hash ^= info->eff_fog_mode;
 
1942
        hash = (hash << 1) | (hash >> 31);
 
1943
        hash ^= info->eff_tex_mode_0;
 
1944
        hash = (hash << 1) | (hash >> 31);
 
1945
        hash ^= info->eff_tex_mode_1;
 
1946
 
 
1947
        return hash % RASTER_HASH_SIZE;
 
1948
}
 
1949
 
 
1950
 
 
1951
 
 
1952
/*************************************
 
1953
 *
 
1954
 *  Dithering macros
 
1955
 *
 
1956
 *************************************/
 
1957
 
 
1958
/* note that these equations and the dither matrixes have
 
1959
   been confirmed to be exact matches to the real hardware */
 
1960
#define DITHER_RB(val,dith)     ((((val) << 1) - ((val) >> 4) + ((val) >> 7) + (dith)) >> 1)
 
1961
#define DITHER_G(val,dith)      ((((val) << 2) - ((val) >> 4) + ((val) >> 6) + (dith)) >> 2)
 
1962
 
 
1963
#define APPLY_DITHER(FBZMODE, XX, YY, RR, GG, BB)                                                               \
 
1964
do                                                                                                                                                              \
 
1965
{                                                                                                                                                               \
 
1966
        /* apply dithering */                                                                                                           \
 
1967
        if (FBZMODE_ENABLE_DITHERING(FBZMODE))                                                                          \
 
1968
        {                                                                                                                                                       \
 
1969
                int dith;                                                                                                                               \
 
1970
                                                                                                                                                                \
 
1971
                /* look up the dither value from the appropriate matrix */                              \
 
1972
                if (FBZMODE_DITHER_TYPE(FBZMODE) == 0)                                                                  \
 
1973
                        dith = dither_matrix_4x4[(((YY) & 3) << 2) + ((XX) & 3)];                       \
 
1974
                else                                                                                                                                    \
 
1975
                        dith = dither_matrix_2x2[(((YY) & 1) << 1) + ((XX) & 1)];                       \
 
1976
                                                                                                                                                                \
 
1977
                /* apply dithering to R,G,B */                                                                                  \
 
1978
                (RR) = DITHER_RB((RR), dith);                                                                                   \
 
1979
                (GG) = DITHER_G ((GG), dith);                                                                                   \
 
1980
                (BB) = DITHER_RB((BB), dith);                                                                                   \
 
1981
        }                                                                                                                                                       \
 
1982
}                                                                                                                                                               \
 
1983
while (0)
 
1984
 
 
1985
 
 
1986
 
 
1987
/*************************************
 
1988
 *
 
1989
 *  Clamping macros
 
1990
 *
 
1991
 *************************************/
 
1992
 
 
1993
#define CLAMPED_ARGB(ITERR, ITERG, ITERB, ITERA, FBZCP, RESULT)                                 \
 
1994
do                                                                                                                                                              \
 
1995
{                                                                                                                                                               \
 
1996
        INT32 r = (INT32)(ITERR) >> 12;                                                                                         \
 
1997
        INT32 g = (INT32)(ITERG) >> 12;                                                                                         \
 
1998
        INT32 b = (INT32)(ITERB) >> 12;                                                                                         \
 
1999
        INT32 a = (INT32)(ITERA) >> 12;                                                                                         \
 
2000
                                                                                                                                                                \
 
2001
        if (FBZCP_RGBZW_CLAMP(FBZCP) == 0)                                                                                      \
 
2002
        {                                                                                                                                                       \
 
2003
                r &= 0xfff;                                                                                                                             \
 
2004
                if (r == 0xfff)                                                                                                                 \
 
2005
                        r = 0;                                                                                                                          \
 
2006
                else if (r == 0x100)                                                                                                    \
 
2007
                        r = 0xff;                                                                                                                       \
 
2008
                else                                                                                                                                    \
 
2009
                        r &= 0xff;                                                                                                                      \
 
2010
                                                                                                                                                                \
 
2011
                g &= 0xfff;                                                                                                                             \
 
2012
                if (g == 0xfff)                                                                                                                 \
 
2013
                        g = 0;                                                                                                                          \
 
2014
                else if (g == 0x100)                                                                                                    \
 
2015
                        g = 0xff;                                                                                                                       \
 
2016
                else                                                                                                                                    \
 
2017
                        g &= 0xff;                                                                                                                      \
 
2018
                                                                                                                                                                \
 
2019
                b &= 0xfff;                                                                                                                             \
 
2020
                if (b == 0xfff)                                                                                                                 \
 
2021
                        b = 0;                                                                                                                          \
 
2022
                else if (b == 0x100)                                                                                                    \
 
2023
                        b = 0xff;                                                                                                                       \
 
2024
                else                                                                                                                                    \
 
2025
                        b &= 0xff;                                                                                                                      \
 
2026
                                                                                                                                                                \
 
2027
                a &= 0xfff;                                                                                                                             \
 
2028
                if (a == 0xfff)                                                                                                                 \
 
2029
                        a = 0;                                                                                                                          \
 
2030
                else if (a == 0x100)                                                                                                    \
 
2031
                        a = 0xff;                                                                                                                       \
 
2032
                else                                                                                                                                    \
 
2033
                        a &= 0xff;                                                                                                                      \
 
2034
        }                                                                                                                                                       \
 
2035
        else                                                                                                                                            \
 
2036
        {                                                                                                                                                       \
 
2037
                CLAMP(r, 0, 0xff);                                                                                                              \
 
2038
                CLAMP(g, 0, 0xff);                                                                                                              \
 
2039
                CLAMP(b, 0, 0xff);                                                                                                              \
 
2040
                CLAMP(a, 0, 0xff);                                                                                                              \
 
2041
        }                                                                                                                                                       \
 
2042
        (RESULT) = MAKE_ARGB(a, r, g, b);                                                                                       \
 
2043
}                                                                                                                                                               \
 
2044
while (0)
 
2045
 
 
2046
 
 
2047
#define CLAMPED_Z(ITERZ, FBZCP, RESULT)                                                                                 \
 
2048
do                                                                                                                                                              \
 
2049
{                                                                                                                                                               \
 
2050
        (RESULT) = (INT32)(ITERZ) >> 12;                                                                                        \
 
2051
        if (FBZCP_RGBZW_CLAMP(FBZCP) == 0)                                                                                      \
 
2052
        {                                                                                                                                                       \
 
2053
                (RESULT) &= 0xfffff;                                                                                                    \
 
2054
                if ((RESULT) == 0xfffff)                                                                                                \
 
2055
                        (RESULT) = 0;                                                                                                           \
 
2056
                else if ((RESULT) == 0x10000)                                                                                   \
 
2057
                        (RESULT) = 0xffff;                                                                                                      \
 
2058
                else                                                                                                                                    \
 
2059
                        (RESULT) &= 0xffff;                                                                                                     \
 
2060
        }                                                                                                                                                       \
 
2061
        else                                                                                                                                            \
 
2062
        {                                                                                                                                                       \
 
2063
                CLAMP((RESULT), 0, 0xffff);                                                                                             \
 
2064
        }                                                                                                                                                       \
 
2065
}                                                                                                                                                               \
 
2066
while (0)
 
2067
 
 
2068
 
 
2069
#define CLAMPED_W(ITERW, FBZCP, RESULT)                                                                                 \
 
2070
do                                                                                                                                                              \
 
2071
{                                                                                                                                                               \
 
2072
        (RESULT) = (INT16)((ITERW) >> 32);                                                                                      \
 
2073
        if (FBZCP_RGBZW_CLAMP(FBZCP) == 0)                                                                                      \
 
2074
        {                                                                                                                                                       \
 
2075
                (RESULT) &= 0xffff;                                                                                                             \
 
2076
                if ((RESULT) == 0xffff)                                                                                                 \
 
2077
                        (RESULT) = 0;                                                                                                           \
 
2078
                else if ((RESULT) == 0x100)                                                                                             \
 
2079
                        (RESULT) = 0xff;                                                                                                        \
 
2080
                (RESULT) &= 0xff;                                                                                                               \
 
2081
        }                                                                                                                                                       \
 
2082
        else                                                                                                                                            \
 
2083
        {                                                                                                                                                       \
 
2084
                CLAMP((RESULT), 0, 0xff);                                                                                               \
 
2085
        }                                                                                                                                                       \
 
2086
}                                                                                                                                                               \
 
2087
while (0)
 
2088
 
 
2089
 
 
2090
 
 
2091
/*************************************
 
2092
 *
 
2093
 *  Chroma keying macro
 
2094
 *
 
2095
 *************************************/
 
2096
 
 
2097
#define APPLY_CHROMAKEY(VV, FBZMODE, COLOR)                                                                             \
 
2098
do                                                                                                                                                              \
 
2099
{                                                                                                                                                               \
 
2100
        if (FBZMODE_ENABLE_CHROMAKEY(FBZMODE))                                                                          \
 
2101
        {                                                                                                                                                       \
 
2102
                /* non-range version */                                                                                                 \
 
2103
                if (!CHROMARANGE_ENABLE((VV)->reg[chromaRange].u))                                              \
 
2104
                {                                                                                                                                               \
 
2105
                        if ((((COLOR) ^ (VV)->reg[chromaKey].u) & 0xffffff) == 0)                       \
 
2106
                        {                                                                                                                                       \
 
2107
                                (VV)->reg[fbiChromaFail].u++;                                                                   \
 
2108
                                goto skipdrawdepth;                                                                                             \
 
2109
                        }                                                                                                                                       \
 
2110
                }                                                                                                                                               \
 
2111
                                                                                                                                                                \
 
2112
                /* tricky range version */                                                                                              \
 
2113
                else                                                                                                                                    \
 
2114
                {                                                                                                                                               \
 
2115
                        UINT32 color = (COLOR);                                                                                         \
 
2116
                        INT32 low, high, test;                                                                                          \
 
2117
                        int results = 0;                                                                                                        \
 
2118
                                                                                                                                                                \
 
2119
                        /* check blue */                                                                                                        \
 
2120
                        low = RGB_BLUE((VV)->reg[chromaKey].u);                                                         \
 
2121
                        high = RGB_BLUE((VV)->reg[chromaRange].u);                                                      \
 
2122
                        test = RGB_BLUE(color);                                                                                         \
 
2123
                        results = (test >= low && test <= high);                                                        \
 
2124
                        results ^= CHROMARANGE_BLUE_EXCLUSIVE((VV)->reg[chromaRange].u);        \
 
2125
                        results <<= 1;                                                                                                          \
 
2126
                                                                                                                                                                \
 
2127
                        /* check green */                                                                                                       \
 
2128
                        low = RGB_GREEN((VV)->reg[chromaKey].u);                                                        \
 
2129
                        high = RGB_GREEN((VV)->reg[chromaRange].u);                                                     \
 
2130
                        test = RGB_GREEN(color);                                                                                        \
 
2131
                        results |= (test >= low && test <= high);                                                       \
 
2132
                        results ^= CHROMARANGE_GREEN_EXCLUSIVE((VV)->reg[chromaRange].u);       \
 
2133
                        results <<= 1;                                                                                                          \
 
2134
                                                                                                                                                                \
 
2135
                        /* check red */                                                                                                         \
 
2136
                        low = RGB_RED((VV)->reg[chromaKey].u);                                                          \
 
2137
                        high = RGB_RED((VV)->reg[chromaRange].u);                                                       \
 
2138
                        test = RGB_RED(color);                                                                                          \
 
2139
                        results |= (test >= low && test <= high);                                                       \
 
2140
                        results ^= CHROMARANGE_RED_EXCLUSIVE((VV)->reg[chromaRange].u);         \
 
2141
                                                                                                                                                                \
 
2142
                        /* final result */                                                                                                      \
 
2143
                        if (CHROMARANGE_UNION_MODE((VV)->reg[chromaRange].u))                           \
 
2144
                        {                                                                                                                                       \
 
2145
                                if (results != 0)                                                                                               \
 
2146
                                {                                                                                                                               \
 
2147
                                        (VV)->reg[fbiChromaFail].u++;                                                           \
 
2148
                                        goto skipdrawdepth;                                                                                     \
 
2149
                                }                                                                                                                               \
 
2150
                        }                                                                                                                                       \
 
2151
                        else                                                                                                                            \
 
2152
                        {                                                                                                                                       \
 
2153
                                if (results == 7)                                                                                               \
 
2154
                                {                                                                                                                               \
 
2155
                                        (VV)->reg[fbiChromaFail].u++;                                                           \
 
2156
                                        goto skipdrawdepth;                                                                                     \
 
2157
                                }                                                                                                                               \
 
2158
                        }                                                                                                                                       \
 
2159
                }                                                                                                                                               \
 
2160
        }                                                                                                                                                       \
 
2161
}                                                                                                                                                               \
 
2162
while (0)
 
2163
 
 
2164
 
 
2165
 
 
2166
/*************************************
 
2167
 *
 
2168
 *  Alpha masking macro
 
2169
 *
 
2170
 *************************************/
 
2171
 
 
2172
#define APPLY_ALPHAMASK(VV, FBZMODE, AA)                                                                                \
 
2173
do                                                                                                                                                              \
 
2174
{                                                                                                                                                               \
 
2175
        if (FBZMODE_ENABLE_ALPHA_MASK(FBZMODE))                                                                         \
 
2176
        {                                                                                                                                                       \
 
2177
                if (((AA) & 1) == 0)                                                                                                    \
 
2178
                {                                                                                                                                               \
 
2179
                        (VV)->reg[fbiAfuncFail].u++;                                                                            \
 
2180
                        goto skipdrawdepth;                                                                                                     \
 
2181
                }                                                                                                                                               \
 
2182
        }                                                                                                                                                       \
 
2183
}                                                                                                                                                               \
 
2184
while (0)
 
2185
 
 
2186
 
 
2187
 
 
2188
/*************************************
 
2189
 *
 
2190
 *  Alpha testing macro
 
2191
 *
 
2192
 *************************************/
 
2193
 
 
2194
#define APPLY_ALPHATEST(VV, ALPHAMODE, AA)                                                                              \
 
2195
do                                                                                                                                                              \
 
2196
{                                                                                                                                                               \
 
2197
        if (ALPHAMODE_ALPHATEST(ALPHAMODE))                                                                                     \
 
2198
        {                                                                                                                                                       \
 
2199
                switch (ALPHAMODE_ALPHAFUNCTION(ALPHAMODE))                                                             \
 
2200
                {                                                                                                                                               \
 
2201
                        case 0:         /* alphaOP = never */                                                                   \
 
2202
                                (VV)->reg[fbiAfuncFail].u++;                                                                    \
 
2203
                                goto skipdrawdepth;                                                                                             \
 
2204
                                                                                                                                                                \
 
2205
                        case 1:         /* alphaOP = less than */                                                               \
 
2206
                                if ((AA) >= ALPHAMODE_ALPHAREF(ALPHAMODE))                                              \
 
2207
                                {                                                                                                                               \
 
2208
                                        (VV)->reg[fbiAfuncFail].u++;                                                            \
 
2209
                                        goto skipdrawdepth;                                                                                     \
 
2210
                                }                                                                                                                               \
 
2211
                                break;                                                                                                                  \
 
2212
                                                                                                                                                                \
 
2213
                        case 2:         /* alphaOP = equal */                                                                   \
 
2214
                                if ((AA) != ALPHAMODE_ALPHAREF(ALPHAMODE))                                              \
 
2215
                                {                                                                                                                               \
 
2216
                                        (VV)->reg[fbiAfuncFail].u++;                                                            \
 
2217
                                        goto skipdrawdepth;                                                                                     \
 
2218
                                }                                                                                                                               \
 
2219
                                break;                                                                                                                  \
 
2220
                                                                                                                                                                \
 
2221
                        case 3:         /* alphaOP = less than or equal */                                              \
 
2222
                                if ((AA) > ALPHAMODE_ALPHAREF(ALPHAMODE))                                               \
 
2223
                                {                                                                                                                               \
 
2224
                                        (VV)->reg[fbiAfuncFail].u++;                                                            \
 
2225
                                        goto skipdrawdepth;                                                                                     \
 
2226
                                }                                                                                                                               \
 
2227
                                break;                                                                                                                  \
 
2228
                                                                                                                                                                \
 
2229
                        case 4:         /* alphaOP = greater than */                                                    \
 
2230
                                if ((AA) <= ALPHAMODE_ALPHAREF(ALPHAMODE))                                              \
 
2231
                                {                                                                                                                               \
 
2232
                                        (VV)->reg[fbiAfuncFail].u++;                                                            \
 
2233
                                        goto skipdrawdepth;                                                                                     \
 
2234
                                }                                                                                                                               \
 
2235
                                break;                                                                                                                  \
 
2236
                                                                                                                                                                \
 
2237
                        case 5:         /* alphaOP = not equal */                                                               \
 
2238
                                if ((AA) == ALPHAMODE_ALPHAREF(ALPHAMODE))                                              \
 
2239
                                {                                                                                                                               \
 
2240
                                        (VV)->reg[fbiAfuncFail].u++;                                                            \
 
2241
                                        goto skipdrawdepth;                                                                                     \
 
2242
                                }                                                                                                                               \
 
2243
                                break;                                                                                                                  \
 
2244
                                                                                                                                                                \
 
2245
                        case 6:         /* alphaOP = greater than or equal */                                   \
 
2246
                                if ((AA) < ALPHAMODE_ALPHAREF(ALPHAMODE))                                               \
 
2247
                                {                                                                                                                               \
 
2248
                                        (VV)->reg[fbiAfuncFail].u++;                                                            \
 
2249
                                        goto skipdrawdepth;                                                                                     \
 
2250
                                }                                                                                                                               \
 
2251
                                break;                                                                                                                  \
 
2252
                                                                                                                                                                \
 
2253
                        case 7:         /* alphaOP = always */                                                                  \
 
2254
                                break;                                                                                                                  \
 
2255
                }                                                                                                                                               \
 
2256
        }                                                                                                                                                       \
 
2257
}                                                                                                                                                               \
 
2258
while (0)
 
2259
 
 
2260
 
 
2261
 
 
2262
/*************************************
 
2263
 *
 
2264
 *  Alpha blending macro
 
2265
 *
 
2266
 *************************************/
 
2267
 
 
2268
#define APPLY_ALPHA_BLEND(FBZMODE, ALPHAMODE, XX, YY, RR, GG, BB, AA)                   \
 
2269
do                                                                                                                                                              \
 
2270
{                                                                                                                                                               \
 
2271
        if (ALPHAMODE_ALPHABLEND(ALPHAMODE))                                                                            \
 
2272
        {                                                                                                                                                       \
 
2273
                int dpix = dest[XX];                                                                                                    \
 
2274
                int dr = (dpix >> 8) & 0xf8;                                                                                    \
 
2275
                int dg = (dpix >> 3) & 0xfc;                                                                                    \
 
2276
                int db = (dpix << 3) & 0xf8;                                                                                    \
 
2277
                int da = FBZMODE_ENABLE_ALPHA_PLANES(FBZMODE) ? depth[XX] : 0xff;               \
 
2278
                int sr = (RR);                                                                                                                  \
 
2279
                int sg = (GG);                                                                                                                  \
 
2280
                int sb = (BB);                                                                                                                  \
 
2281
                int sa = (AA);                                                                                                                  \
 
2282
                int ta;                                                                                                                                 \
 
2283
                                                                                                                                                                \
 
2284
                /* apply dither subtraction */                                                                                  \
 
2285
                if (FBZMODE_ALPHA_DITHER_SUBTRACT(FBZMODE))                                                             \
 
2286
                {                                                                                                                                               \
 
2287
                        int dith;                                                                                                                       \
 
2288
                                                                                                                                                                \
 
2289
                        /* look up the dither value from the appropriate matrix */                      \
 
2290
                        if (FBZMODE_DITHER_TYPE(FBZMODE) == 0)                                                          \
 
2291
                                dith = dither_matrix_4x4[(((YY) & 3) << 2) + ((XX) & 3)];               \
 
2292
                        else                                                                                                                            \
 
2293
                                dith = dither_matrix_2x2[(((YY) & 1) << 1) + ((XX) & 1)];               \
 
2294
                                                                                                                                                                \
 
2295
                        /* subtract the dither value */                                                                         \
 
2296
                        dr = ((dr << 1) + 15 - dith) >> 1;                                                                      \
 
2297
                        dg = ((dg << 2) + 15 - dith) >> 2;                                                                      \
 
2298
                        db = ((db << 1) + 15 - dith) >> 1;                                                                      \
 
2299
                }                                                                                                                                               \
 
2300
                                                                                                                                                                \
 
2301
                /* compute source portion */                                                                                    \
 
2302
                switch (ALPHAMODE_SRCRGBBLEND(ALPHAMODE))                                                               \
 
2303
                {                                                                                                                                               \
 
2304
                        default:        /* reserved */                                                                                  \
 
2305
                        case 0:         /* AZERO */                                                                                             \
 
2306
                                (RR) = (GG) = (BB) = 0;                                                                                 \
 
2307
                                break;                                                                                                                  \
 
2308
                                                                                                                                                                \
 
2309
                        case 1:         /* ASRC_ALPHA */                                                                                \
 
2310
                                (RR) = (sr * (sa + 1)) >> 8;                                                                    \
 
2311
                                (GG) = (sg * (sa + 1)) >> 8;                                                                    \
 
2312
                                (BB) = (sb * (sa + 1)) >> 8;                                                                    \
 
2313
                                break;                                                                                                                  \
 
2314
                                                                                                                                                                \
 
2315
                        case 2:         /* A_COLOR */                                                                                   \
 
2316
                                (RR) = (sr * (dr + 1)) >> 8;                                                                    \
 
2317
                                (GG) = (sg * (dg + 1)) >> 8;                                                                    \
 
2318
                                (BB) = (sb * (db + 1)) >> 8;                                                                    \
 
2319
                                break;                                                                                                                  \
 
2320
                                                                                                                                                                \
 
2321
                        case 3:         /* ADST_ALPHA */                                                                                \
 
2322
                                (RR) = (sr * (da + 1)) >> 8;                                                                    \
 
2323
                                (GG) = (sg * (da + 1)) >> 8;                                                                    \
 
2324
                                (BB) = (sb * (da + 1)) >> 8;                                                                    \
 
2325
                                break;                                                                                                                  \
 
2326
                                                                                                                                                                \
 
2327
                        case 4:         /* AONE */                                                                                              \
 
2328
                                break;                                                                                                                  \
 
2329
                                                                                                                                                                \
 
2330
                        case 5:         /* AOMSRC_ALPHA */                                                                              \
 
2331
                                (RR) = (sr * (0x100 - sa)) >> 8;                                                                \
 
2332
                                (GG) = (sg * (0x100 - sa)) >> 8;                                                                \
 
2333
                                (BB) = (sb * (0x100 - sa)) >> 8;                                                                \
 
2334
                                break;                                                                                                                  \
 
2335
                                                                                                                                                                \
 
2336
                        case 6:         /* AOM_COLOR */                                                                                 \
 
2337
                                (RR) = (sr * (0x100 - dr)) >> 8;                                                                \
 
2338
                                (GG) = (sg * (0x100 - dg)) >> 8;                                                                \
 
2339
                                (BB) = (sb * (0x100 - db)) >> 8;                                                                \
 
2340
                                break;                                                                                                                  \
 
2341
                                                                                                                                                                \
 
2342
                        case 7:         /* AOMDST_ALPHA */                                                                              \
 
2343
                                (RR) = (sr * (0x100 - da)) >> 8;                                                                \
 
2344
                                (GG) = (sg * (0x100 - da)) >> 8;                                                                \
 
2345
                                (BB) = (sb * (0x100 - da)) >> 8;                                                                \
 
2346
                                break;                                                                                                                  \
 
2347
                                                                                                                                                                \
 
2348
                        case 15:        /* ASATURATE */                                                                                 \
 
2349
                                ta = (sa < (0x100 - da)) ? sa : (0x100 - da);                                   \
 
2350
                                (RR) = (sr * (ta + 1)) >> 8;                                                                    \
 
2351
                                (GG) = (sg * (ta + 1)) >> 8;                                                                    \
 
2352
                                (BB) = (sb * (ta + 1)) >> 8;                                                                    \
 
2353
                                break;                                                                                                                  \
 
2354
                }                                                                                                                                               \
 
2355
                                                                                                                                                                \
 
2356
                /* add in dest portion */                                                                                               \
 
2357
                switch (ALPHAMODE_DSTRGBBLEND(ALPHAMODE))                                                               \
 
2358
                {                                                                                                                                               \
 
2359
                        default:        /* reserved */                                                                                  \
 
2360
                        case 0:         /* AZERO */                                                                                             \
 
2361
                                break;                                                                                                                  \
 
2362
                                                                                                                                                                \
 
2363
                        case 1:         /* ASRC_ALPHA */                                                                                \
 
2364
                                (RR) += (dr * (sa + 1)) >> 8;                                                                   \
 
2365
                                (GG) += (dg * (sa + 1)) >> 8;                                                                   \
 
2366
                                (BB) += (db * (sa + 1)) >> 8;                                                                   \
 
2367
                                break;                                                                                                                  \
 
2368
                                                                                                                                                                \
 
2369
                        case 2:         /* A_COLOR */                                                                                   \
 
2370
                                (RR) += (dr * (sr + 1)) >> 8;                                                                   \
 
2371
                                (GG) += (dg * (sg + 1)) >> 8;                                                                   \
 
2372
                                (BB) += (db * (sb + 1)) >> 8;                                                                   \
 
2373
                                break;                                                                                                                  \
 
2374
                                                                                                                                                                \
 
2375
                        case 3:         /* ADST_ALPHA */                                                                                \
 
2376
                                (RR) += (dr * (da + 1)) >> 8;                                                                   \
 
2377
                                (GG) += (dg * (da + 1)) >> 8;                                                                   \
 
2378
                                (BB) += (db * (da + 1)) >> 8;                                                                   \
 
2379
                                break;                                                                                                                  \
 
2380
                                                                                                                                                                \
 
2381
                        case 4:         /* AONE */                                                                                              \
 
2382
                                (RR) += dr;                                                                                                             \
 
2383
                                (GG) += dg;                                                                                                             \
 
2384
                                (BB) += db;                                                                                                             \
 
2385
                                break;                                                                                                                  \
 
2386
                                                                                                                                                                \
 
2387
                        case 5:         /* AOMSRC_ALPHA */                                                                              \
 
2388
                                (RR) += (dr * (0x100 - sa)) >> 8;                                                               \
 
2389
                                (GG) += (dg * (0x100 - sa)) >> 8;                                                               \
 
2390
                                (BB) += (db * (0x100 - sa)) >> 8;                                                               \
 
2391
                                break;                                                                                                                  \
 
2392
                                                                                                                                                                \
 
2393
                        case 6:         /* AOM_COLOR */                                                                                 \
 
2394
                                (RR) += (dr * (0x100 - sr)) >> 8;                                                               \
 
2395
                                (GG) += (dg * (0x100 - sg)) >> 8;                                                               \
 
2396
                                (BB) += (db * (0x100 - sb)) >> 8;                                                               \
 
2397
                                break;                                                                                                                  \
 
2398
                                                                                                                                                                \
 
2399
                        case 7:         /* AOMDST_ALPHA */                                                                              \
 
2400
                                (RR) += (dr * (0x100 - da)) >> 8;                                                               \
 
2401
                                (GG) += (dg * (0x100 - da)) >> 8;                                                               \
 
2402
                                (BB) += (db * (0x100 - da)) >> 8;                                                               \
 
2403
                                break;                                                                                                                  \
 
2404
                                                                                                                                                                \
 
2405
                        case 15:        /* A_COLORBEFOREFOG */                                                                  \
 
2406
                                (RR) += (dr * (prefogr + 1)) >> 8;                                                              \
 
2407
                                (GG) += (dg * (prefogg + 1)) >> 8;                                                              \
 
2408
                                (BB) += (db * (prefogb + 1)) >> 8;                                                              \
 
2409
                                break;                                                                                                                  \
 
2410
                }                                                                                                                                               \
 
2411
                                                                                                                                                                \
 
2412
                /* blend the source alpha */                                                                                    \
 
2413
                (AA) = 0;                                                                                                                               \
 
2414
                if (ALPHAMODE_SRCALPHABLEND(ALPHAMODE) == 4)                                                    \
 
2415
                        (AA) = sa;                                                                                                                      \
 
2416
                                                                                                                                                                \
 
2417
                /* blend the dest alpha */                                                                                              \
 
2418
                if (ALPHAMODE_DSTALPHABLEND(ALPHAMODE) == 4)                                                    \
 
2419
                        (AA) += da;                                                                                                                     \
 
2420
                                                                                                                                                                \
 
2421
                /* clamp */                                                                                                                             \
 
2422
                CLAMP((RR), 0x00, 0xff);                                                                                                \
 
2423
                CLAMP((GG), 0x00, 0xff);                                                                                                \
 
2424
                CLAMP((BB), 0x00, 0xff);                                                                                                \
 
2425
                CLAMP((AA), 0x00, 0xff);                                                                                                \
 
2426
        }                                                                                                                                                       \
 
2427
}                                                                                                                                                               \
 
2428
while (0)
 
2429
 
 
2430
 
 
2431
 
 
2432
/*************************************
 
2433
 *
 
2434
 *  Fogging macro
 
2435
 *
 
2436
 *************************************/
 
2437
 
 
2438
#define APPLY_FOGGING(VV, FOGMODE, FBZCP, XX, YY, RR, GG, BB, ITERZ, ITERW, ITERAXXX)   \
 
2439
do                                                                                                                                                              \
 
2440
{                                                                                                                                                               \
 
2441
        if (FOGMODE_ENABLE_FOG(FOGMODE))                                                                                        \
 
2442
        {                                                                                                                                                       \
 
2443
                INT32 fr, fg, fb;                                                                                                               \
 
2444
                                                                                                                                                                \
 
2445
                /* constant fog bypasses everything else */                                                             \
 
2446
                if (FOGMODE_FOG_CONSTANT(FOGMODE))                                                                              \
 
2447
                {                                                                                                                                               \
 
2448
                        fr = RGB_RED((VV)->reg[fogColor].u);                                                            \
 
2449
                        fg = RGB_GREEN((VV)->reg[fogColor].u);                                                          \
 
2450
                        fb = RGB_BLUE((VV)->reg[fogColor].u);                                                           \
 
2451
                }                                                                                                                                               \
 
2452
                                                                                                                                                                \
 
2453
                /* non-constant fog comes from several sources */                                               \
 
2454
                else                                                                                                                                    \
 
2455
                {                                                                                                                                               \
 
2456
                        INT32 fogblend = 0;                                                                                                             \
 
2457
                                                                                                                                                                \
 
2458
                        /* if fog_add is zero, we start with the fog color */                           \
 
2459
                        if (FOGMODE_FOG_ADD(FOGMODE) == 0)                                                                      \
 
2460
                        {                                                                                                                                       \
 
2461
                                fr = RGB_RED((VV)->reg[fogColor].u);                                                    \
 
2462
                                fg = RGB_GREEN((VV)->reg[fogColor].u);                                                  \
 
2463
                                fb = RGB_BLUE((VV)->reg[fogColor].u);                                                   \
 
2464
                        }                                                                                                                                       \
 
2465
                        else                                                                                                                            \
 
2466
                                fr = fg = fb = 0;                                                                                               \
 
2467
                                                                                                                                                                \
 
2468
                        /* if fog_mult is zero, we subtract the incoming color */                       \
 
2469
                        if (FOGMODE_FOG_MULT(FOGMODE) == 0)                                                                     \
 
2470
                        {                                                                                                                                       \
 
2471
                                fr -= (RR);                                                                                                             \
 
2472
                                fg -= (GG);                                                                                                             \
 
2473
                                fb -= (BB);                                                                                                             \
 
2474
                        }                                                                                                                                       \
 
2475
                                                                                                                                                                \
 
2476
                        /* fog blending mode */                                                                                         \
 
2477
                        switch (FOGMODE_FOG_ZALPHA(FOGMODE))                                                            \
 
2478
                        {                                                                                                                                       \
 
2479
                                case 0:         /* fog table */                                                                         \
 
2480
                                {                                                                                                                               \
 
2481
                                        INT32 delta = (VV)->fbi.fogdelta[wfloat >> 10];                         \
 
2482
                                        INT32 deltaval;                                                                                         \
 
2483
                                                                                                                                                                \
 
2484
                                        /* perform the multiply against lower 8 bits of wfloat */       \
 
2485
                                        deltaval = (delta & (VV)->fbi.fogdelta_mask) *                          \
 
2486
                                                                ((wfloat >> 2) & 0xff);                                                 \
 
2487
                                                                                                                                                                \
 
2488
                                        /* fog zones allow for negating this value */                           \
 
2489
                                        if (FOGMODE_FOG_ZONES(FOGMODE) && (delta & 2))                          \
 
2490
                                                deltaval = -deltaval;                                                                   \
 
2491
                                        deltaval >>= 6;                                                                                         \
 
2492
                                                                                                                                                                \
 
2493
                                        /* apply dither */                                                                                      \
 
2494
                                        if (FOGMODE_FOG_DITHER(FOGMODE))                                                        \
 
2495
                                                deltaval += dither_matrix_4x4[(((YY) & 3) << 2) +               \
 
2496
                                                                                                                ((XX) & 3)];                    \
 
2497
                                        deltaval >>= 4;                                                                                         \
 
2498
                                                                                                                                                                \
 
2499
                                        /* add to the blending factor */                                                        \
 
2500
                                        fogblend = (VV)->fbi.fogblend[wfloat >> 10] + deltaval;         \
 
2501
                                        break;                                                                                                          \
 
2502
                                }                                                                                                                               \
 
2503
                                                                                                                                                                \
 
2504
                                case 1:         /* iterated A */                                                                        \
 
2505
                                        fogblend = (ITERAXXX) >> 24;                                                            \
 
2506
                                        break;                                                                                                          \
 
2507
                                                                                                                                                                \
 
2508
                                case 2:         /* iterated Z */                                                                        \
 
2509
                                        CLAMPED_Z((ITERZ), FBZCP, fogblend);                                            \
 
2510
                                        fogblend >>= 8;                                                                                         \
 
2511
                                        break;                                                                                                          \
 
2512
                                                                                                                                                                \
 
2513
                                case 3:         /* iterated W - Voodoo 2 only */                                        \
 
2514
                                        CLAMPED_W((ITERW), FBZCP, fogblend);                                            \
 
2515
                                        break;                                                                                                          \
 
2516
                        }                                                                                                                                       \
 
2517
                                                                                                                                                                \
 
2518
                        /* perform the blend */                                                                                         \
 
2519
                        fogblend++;                                                                                                                     \
 
2520
                        fr = (fr * fogblend) >> 8;                                                                                      \
 
2521
                        fg = (fg * fogblend) >> 8;                                                                                      \
 
2522
                        fb = (fb * fogblend) >> 8;                                                                                      \
 
2523
                }                                                                                                                                               \
 
2524
                                                                                                                                                                \
 
2525
                /* if fog_mult is 0, we add this to the original color */                               \
 
2526
                if (FOGMODE_FOG_MULT(FOGMODE) == 0)                                                                             \
 
2527
                {                                                                                                                                               \
 
2528
                        (RR) += fr;                                                                                                                     \
 
2529
                        (GG) += fg;                                                                                                                     \
 
2530
                        (BB) += fb;                                                                                                                     \
 
2531
                }                                                                                                                                               \
 
2532
                                                                                                                                                                \
 
2533
                /* otherwise this just becomes the new color */                                                 \
 
2534
                else                                                                                                                                    \
 
2535
                {                                                                                                                                               \
 
2536
                        (RR) = fr;                                                                                                                      \
 
2537
                        (GG) = fg;                                                                                                                      \
 
2538
                        (BB) = fb;                                                                                                                      \
 
2539
                }                                                                                                                                               \
 
2540
                                                                                                                                                                \
 
2541
                /* clamp */                                                                                                                             \
 
2542
                CLAMP((RR), 0x00, 0xff);                                                                                                \
 
2543
                CLAMP((GG), 0x00, 0xff);                                                                                                \
 
2544
                CLAMP((BB), 0x00, 0xff);                                                                                                \
 
2545
        }                                                                                                                                                       \
 
2546
}                                                                                                                                                               \
 
2547
while (0)
 
2548
 
 
2549
 
 
2550
 
 
2551
/*************************************
 
2552
 *
 
2553
 *  Texture pipeline macro
 
2554
 *
 
2555
 *************************************/
 
2556
 
 
2557
#define TEXTURE_PIPELINE(TT, XX, YY, TEXMODE, COTHER, LOOKUP, LODBASE, ITERS, ITERT, ITERW, RESULT) \
 
2558
do                                                                                                                                                              \
 
2559
{                                                                                                                                                               \
 
2560
        INT32 blendr, blendg, blendb, blenda;                                                                           \
 
2561
        INT32 tr, tg, tb, ta;                                                                                                           \
 
2562
        INT32 oow, s, t, lod, ilod;                                                                                                     \
 
2563
        INT32 smax, tmax;                                                                                                                       \
 
2564
        UINT32 texbase;                                                                                                                         \
 
2565
        rgb_t c_local;                                                                                                                          \
 
2566
                                                                                                                                                                \
 
2567
        /* determine the S/T/LOD values for this texture */                                                     \
 
2568
        if (TEXMODE_ENABLE_PERSPECTIVE(TEXMODE))                                                                        \
 
2569
        {                                                                                                                                                       \
 
2570
                oow = fast_reciplog((ITERW), &lod);                                                                             \
 
2571
                s = ((INT64)oow * (ITERS)) >> 29;                                                                               \
 
2572
                t = ((INT64)oow * (ITERT)) >> 29;                                                                               \
 
2573
                lod += (LODBASE);                                                                                                               \
 
2574
        }                                                                                                                                                       \
 
2575
        else                                                                                                                                            \
 
2576
        {                                                                                                                                                       \
 
2577
                s = (ITERS) >> 14;                                                                                                              \
 
2578
                t = (ITERT) >> 14;                                                                                                              \
 
2579
                lod = (LODBASE);                                                                                                                \
 
2580
        }                                                                                                                                                       \
 
2581
                                                                                                                                                                \
 
2582
        /* clamp W */                                                                                                                           \
 
2583
        if (TEXMODE_CLAMP_NEG_W(TEXMODE) && (ITERW) < 0)                                                        \
 
2584
                s = t = 0;                                                                                                                              \
 
2585
                                                                                                                                                                \
 
2586
        /* clamp the LOD */                                                                                                                     \
 
2587
        lod += (TT)->lodbias;                                                                                                           \
 
2588
        if (TEXMODE_ENABLE_LOD_DITHER(TEXMODE))                                                                         \
 
2589
                lod += dither_matrix_4x4[(((YY) & 3) << 2) + ((XX) & 3)] << 4;                  \
 
2590
        if (lod < (TT)->lodmin)                                                                                                         \
 
2591
                lod = (TT)->lodmin;                                                                                                             \
 
2592
        if (lod > (TT)->lodmax)                                                                                                         \
 
2593
                lod = (TT)->lodmax;                                                                                                             \
 
2594
                                                                                                                                                                \
 
2595
        /* now the LOD is in range; if we don't own this LOD, take the next one */      \
 
2596
        ilod = lod >> 8;                                                                                                                        \
 
2597
        if (!(((TT)->lodmask >> ilod) & 1))                                                                                     \
 
2598
                ilod++;                                                                                                                                 \
 
2599
                                                                                                                                                                \
 
2600
        /* fetch the texture base */                                                                                            \
 
2601
        texbase = (TT)->lodoffset[ilod];                                                                                        \
 
2602
                                                                                                                                                                \
 
2603
        /* compute the maximum s and t values at this LOD */                                            \
 
2604
        smax = (TT)->wmask >> ilod;                                                                                                     \
 
2605
        tmax = (TT)->hmask >> ilod;                                                                                                     \
 
2606
                                                                                                                                                                \
 
2607
        /* determine whether we are point-sampled or bilinear */                                        \
 
2608
        if ((lod == (TT)->lodmin && !TEXMODE_MAGNIFICATION_FILTER(TEXMODE)) ||          \
 
2609
                (lod != (TT)->lodmin && !TEXMODE_MINIFICATION_FILTER(TEXMODE)))                 \
 
2610
        {                                                                                                                                                       \
 
2611
                /* point sampled */                                                                                                             \
 
2612
                                                                                                                                                                \
 
2613
                UINT32 texel0;                                                                                                                  \
 
2614
                                                                                                                                                                \
 
2615
                /* adjust S/T for the LOD and strip off the fractions */                                \
 
2616
                s >>= ilod + 18;                                                                                                                \
 
2617
                t >>= ilod + 18;                                                                                                                \
 
2618
                                                                                                                                                                \
 
2619
                /* clamp/wrap S/T if necessary */                                                                               \
 
2620
                if (TEXMODE_CLAMP_S(TEXMODE))                                                                                   \
 
2621
                        CLAMP(s, 0, smax);                                                                                                      \
 
2622
                if (TEXMODE_CLAMP_T(TEXMODE))                                                                                   \
 
2623
                        CLAMP(t, 0, tmax);                                                                                                      \
 
2624
                s &= smax;                                                                                                                              \
 
2625
                t &= tmax;                                                                                                                              \
 
2626
                t *= smax + 1;                                                                                                                  \
 
2627
                                                                                                                                                                \
 
2628
                /* fetch texel data */                                                                                                  \
 
2629
                if (TEXMODE_FORMAT(TEXMODE) < 8)                                                                                \
 
2630
                {                                                                                                                                               \
 
2631
                        texel0 = *(UINT8 *)&(TT)->ram[(texbase + t + s) & (TT)->mask];          \
 
2632
                        c_local = (LOOKUP)[texel0];                                                                                     \
 
2633
                }                                                                                                                                               \
 
2634
                else                                                                                                                                    \
 
2635
                {                                                                                                                                               \
 
2636
                        texel0 = *(UINT16 *)&(TT)->ram[(texbase + 2*(t + s)) & (TT)->mask];     \
 
2637
                        if (TEXMODE_FORMAT(TEXMODE) >= 10 && TEXMODE_FORMAT(TEXMODE) <= 12)     \
 
2638
                                c_local = (LOOKUP)[texel0];                                                                             \
 
2639
                        else                                                                                                                            \
 
2640
                                c_local = ((LOOKUP)[texel0 & 0xff] & 0xffffff) |                                \
 
2641
                                                        ((texel0 & 0xff00) << 16);                                                      \
 
2642
                }                                                                                                                                               \
 
2643
        }                                                                                                                                                       \
 
2644
        else                                                                                                                                            \
 
2645
        {                                                                                                                                                       \
 
2646
                /* bilinear filtered */                                                                                                 \
 
2647
                                                                                                                                                                \
 
2648
                UINT32 texel0, texel1, texel2, texel3;                                                                  \
 
2649
                UINT32 factor, factorsum;                                                                                               \
 
2650
                UINT32 sfrac, tfrac;                                                                                                    \
 
2651
                UINT32 ag, rb;                                                                                                                  \
 
2652
                INT32 s1, t1;                                                                                                                   \
 
2653
                                                                                                                                                                \
 
2654
                /* adjust S/T for the LOD and strip off all but the low 8 bits of */    \
 
2655
                /* the fraction */                                                                                                              \
 
2656
                s >>= ilod + 10;                                                                                                                \
 
2657
                t >>= ilod + 10;                                                                                                                \
 
2658
                                                                                                                                                                \
 
2659
                /* also subtract 1/2 texel so that (0.5,0.5) = a full (0,0) texel */    \
 
2660
                s -= 0x80;                                                                                                                              \
 
2661
                t -= 0x80;                                                                                                                              \
 
2662
                                                                                                                                                                \
 
2663
                /* extract the fractions */                                                                                             \
 
2664
                sfrac = s & (TT)->bilinear_mask;                                                                                \
 
2665
                tfrac = t & (TT)->bilinear_mask;                                                                                \
 
2666
                                                                                                                                                                \
 
2667
                /* now toss the rest */                                                                                                 \
 
2668
                s >>= 8;                                                                                                                                \
 
2669
                t >>= 8;                                                                                                                                \
 
2670
                s1 = s + 1;                                                                                                                             \
 
2671
                t1 = t + 1;                                                                                                                             \
 
2672
                                                                                                                                                                \
 
2673
                /* clamp/wrap S/T if necessary */                                                                               \
 
2674
                if (TEXMODE_CLAMP_S(TEXMODE))                                                                                   \
 
2675
                {                                                                                                                                               \
 
2676
                        CLAMP(s, 0, smax);                                                                                                      \
 
2677
                        CLAMP(s1, 0, smax);                                                                                                     \
 
2678
                }                                                                                                                                               \
 
2679
                if (TEXMODE_CLAMP_T(TEXMODE))                                                                                   \
 
2680
                {                                                                                                                                               \
 
2681
                        CLAMP(t, 0, tmax);                                                                                                      \
 
2682
                        CLAMP(t1, 0, tmax);                                                                                                     \
 
2683
                }                                                                                                                                               \
 
2684
                s &= smax;                                                                                                                              \
 
2685
                s1 &= smax;                                                                                                                             \
 
2686
                t &= tmax;                                                                                                                              \
 
2687
                t1 &= tmax;                                                                                                                             \
 
2688
                t *= smax + 1;                                                                                                                  \
 
2689
                t1 *= smax + 1;                                                                                                                 \
 
2690
                                                                                                                                                                \
 
2691
                /* fetch texel data */                                                                                                  \
 
2692
                if (TEXMODE_FORMAT(TEXMODE) < 8)                                                                                \
 
2693
                {                                                                                                                                               \
 
2694
                        texel0 = *(UINT8 *)&(TT)->ram[(texbase + t + s) & (TT)->mask];          \
 
2695
                        texel1 = *(UINT8 *)&(TT)->ram[(texbase + t + s1) & (TT)->mask];         \
 
2696
                        texel2 = *(UINT8 *)&(TT)->ram[(texbase + t1 + s) & (TT)->mask];         \
 
2697
                        texel3 = *(UINT8 *)&(TT)->ram[(texbase + t1 + s1) & (TT)->mask];        \
 
2698
                        texel0 = (LOOKUP)[texel0];                                                                                      \
 
2699
                        texel1 = (LOOKUP)[texel1];                                                                                      \
 
2700
                        texel2 = (LOOKUP)[texel2];                                                                                      \
 
2701
                        texel3 = (LOOKUP)[texel3];                                                                                      \
 
2702
                }                                                                                                                                               \
 
2703
                else                                                                                                                                    \
 
2704
                {                                                                                                                                               \
 
2705
                        texel0 = *(UINT16 *)&(TT)->ram[(texbase + 2*(t + s)) & (TT)->mask];     \
 
2706
                        texel1 = *(UINT16 *)&(TT)->ram[(texbase + 2*(t + s1)) & (TT)->mask];\
 
2707
                        texel2 = *(UINT16 *)&(TT)->ram[(texbase + 2*(t1 + s)) & (TT)->mask];\
 
2708
                        texel3 = *(UINT16 *)&(TT)->ram[(texbase + 2*(t1 + s1)) & (TT)->mask];\
 
2709
                        if (TEXMODE_FORMAT(TEXMODE) >= 10 && TEXMODE_FORMAT(TEXMODE) <= 12)     \
 
2710
                        {                                                                                                                                       \
 
2711
                                texel0 = (LOOKUP)[texel0];                                                                              \
 
2712
                                texel1 = (LOOKUP)[texel1];                                                                              \
 
2713
                                texel2 = (LOOKUP)[texel2];                                                                              \
 
2714
                                texel3 = (LOOKUP)[texel3];                                                                              \
 
2715
                        }                                                                                                                                       \
 
2716
                        else                                                                                                                            \
 
2717
                        {                                                                                                                                       \
 
2718
                                texel0 = ((LOOKUP)[texel0 & 0xff] & 0xffffff) |                                 \
 
2719
                                                        ((texel0 & 0xff00) << 16);                                                      \
 
2720
                                texel1 = ((LOOKUP)[texel1 & 0xff] & 0xffffff) |                                 \
 
2721
                                                        ((texel1 & 0xff00) << 16);                                                      \
 
2722
                                texel2 = ((LOOKUP)[texel2 & 0xff] & 0xffffff) |                                 \
 
2723
                                                        ((texel2 & 0xff00) << 16);                                                      \
 
2724
                                texel3 = ((LOOKUP)[texel3 & 0xff] & 0xffffff) |                                 \
 
2725
                                                        ((texel3 & 0xff00) << 16);                                                      \
 
2726
                        }                                                                                                                                       \
 
2727
                }                                                                                                                                               \
 
2728
                                                                                                                                                                \
 
2729
                /* weigh in each texel */                                                                                               \
 
2730
                factorsum = factor = ((0x100 - sfrac) * (0x100 - tfrac)) >> 8;                  \
 
2731
                ag = ((texel0 >> 8) & 0x00ff00ff) * factor;                                                             \
 
2732
                rb = (texel0 & 0x00ff00ff) * factor;                                                                    \
 
2733
                                                                                                                                                                \
 
2734
                factorsum += factor = (sfrac * (0x100 - tfrac)) >> 8;                                   \
 
2735
                ag += ((texel1 >> 8) & 0x00ff00ff) * factor;                                                    \
 
2736
                rb += (texel1 & 0x00ff00ff) * factor;                                                                   \
 
2737
                                                                                                                                                                \
 
2738
                factorsum += factor = ((0x100 - sfrac) * tfrac) >> 8;                                   \
 
2739
                ag += ((texel2 >> 8) & 0x00ff00ff) * factor;                                                    \
 
2740
                rb += (texel2 & 0x00ff00ff) * factor;                                                                   \
 
2741
                                                                                                                                                                \
 
2742
                factor = 0x100 - factorsum;                                                                                             \
 
2743
                ag += ((texel3 >> 8) & 0x00ff00ff) * factor;                                                    \
 
2744
                rb += (texel3 & 0x00ff00ff) * factor;                                                                   \
 
2745
                                                                                                                                                                \
 
2746
                c_local = (ag & 0xff00ff00) | ((rb >> 8) & 0x00ff00ff);                                 \
 
2747
        }                                                                                                                                                       \
 
2748
                                                                                                                                                                \
 
2749
        /* select zero/other for RGB */                                                                                         \
 
2750
        if (!TEXMODE_TC_ZERO_OTHER(TEXMODE))                                                                            \
 
2751
        {                                                                                                                                                       \
 
2752
                tr = RGB_RED(COTHER);                                                                                                   \
 
2753
                tg = RGB_GREEN(COTHER);                                                                                                 \
 
2754
                tb = RGB_BLUE(COTHER);                                                                                                  \
 
2755
        }                                                                                                                                                       \
 
2756
        else                                                                                                                                            \
 
2757
                tr = tg = tb = 0;                                                                                                               \
 
2758
                                                                                                                                                                \
 
2759
        /* select zero/other for alpha */                                                                                       \
 
2760
        if (!TEXMODE_TCA_ZERO_OTHER(TEXMODE))                                                                           \
 
2761
                ta = RGB_ALPHA(COTHER);                                                                                                 \
 
2762
        else                                                                                                                                            \
 
2763
                ta = 0;                                                                                                                                 \
 
2764
                                                                                                                                                                \
 
2765
        /* potentially subtract c_local */                                                                                      \
 
2766
        if (TEXMODE_TC_SUB_CLOCAL(TEXMODE))                                                                                     \
 
2767
        {                                                                                                                                                       \
 
2768
                tr -= RGB_RED(c_local);                                                                                                 \
 
2769
                tg -= RGB_GREEN(c_local);                                                                                               \
 
2770
                tb -= RGB_BLUE(c_local);                                                                                                \
 
2771
        }                                                                                                                                                       \
 
2772
        if (TEXMODE_TCA_SUB_CLOCAL(TEXMODE))                                                                            \
 
2773
                ta -= RGB_ALPHA(c_local);                                                                                               \
 
2774
                                                                                                                                                                \
 
2775
        /* blend RGB */                                                                                                                         \
 
2776
        switch (TEXMODE_TC_MSELECT(TEXMODE))                                                                            \
 
2777
        {                                                                                                                                                       \
 
2778
                default:        /* reserved */                                                                                          \
 
2779
                case 0:         /* zero */                                                                                                      \
 
2780
                        blendr = blendg = blendb = 0;                                                                           \
 
2781
                        break;                                                                                                                          \
 
2782
                                                                                                                                                                \
 
2783
                case 1:         /* c_local */                                                                                           \
 
2784
                        blendr = RGB_RED(c_local);                                                                                      \
 
2785
                        blendg = RGB_GREEN(c_local);                                                                            \
 
2786
                        blendb = RGB_BLUE(c_local);                                                                                     \
 
2787
                        break;                                                                                                                          \
 
2788
                                                                                                                                                                \
 
2789
                case 2:         /* a_other */                                                                                           \
 
2790
                        blendr = blendg = blendb = RGB_ALPHA(COTHER);                                           \
 
2791
                        break;                                                                                                                          \
 
2792
                                                                                                                                                                \
 
2793
                case 3:         /* a_local */                                                                                           \
 
2794
                        blendr = blendg = blendb = RGB_ALPHA(c_local);                                          \
 
2795
                        break;                                                                                                                          \
 
2796
                                                                                                                                                                \
 
2797
                case 4:         /* LOD (detail factor) */                                                                       \
 
2798
                        if ((TT)->detailbias <= lod)                                                                            \
 
2799
                                blendr = blendg = blendb = 0;                                                                   \
 
2800
                        else                                                                                                                            \
 
2801
                        {                                                                                                                                       \
 
2802
                                blendr = ((((TT)->detailbias - lod) << (TT)->detailscale) >> 8);\
 
2803
                                if (blendr > (TT)->detailmax)                                                                   \
 
2804
                                        blendr = (TT)->detailmax;                                                                       \
 
2805
                                blendg = blendb = blendr;                                                                               \
 
2806
                        }                                                                                                                                       \
 
2807
                        break;                                                                                                                          \
 
2808
                                                                                                                                                                \
 
2809
                case 5:         /* LOD fraction */                                                                                      \
 
2810
                        blendr = blendg = blendb = lod & 0xff;                                                          \
 
2811
                        break;                                                                                                                          \
 
2812
        }                                                                                                                                                       \
 
2813
                                                                                                                                                                \
 
2814
        /* blend alpha */                                                                                                                       \
 
2815
        switch (TEXMODE_TCA_MSELECT(TEXMODE))                                                                           \
 
2816
        {                                                                                                                                                       \
 
2817
                default:        /* reserved */                                                                                          \
 
2818
                case 0:         /* zero */                                                                                                      \
 
2819
                        blenda = 0;                                                                                                                     \
 
2820
                        break;                                                                                                                          \
 
2821
                                                                                                                                                                \
 
2822
                case 1:         /* c_local */                                                                                           \
 
2823
                        blenda = RGB_ALPHA(c_local);                                                                            \
 
2824
                        break;                                                                                                                          \
 
2825
                                                                                                                                                                \
 
2826
                case 2:         /* a_other */                                                                                           \
 
2827
                        blenda = RGB_ALPHA(COTHER);                                                                                     \
 
2828
                        break;                                                                                                                          \
 
2829
                                                                                                                                                                \
 
2830
                case 3:         /* a_local */                                                                                           \
 
2831
                        blenda = RGB_ALPHA(c_local);                                                                            \
 
2832
                        break;                                                                                                                          \
 
2833
                                                                                                                                                                \
 
2834
                case 4:         /* LOD (detail factor) */                                                                       \
 
2835
                        if ((TT)->detailbias <= lod)                                                                            \
 
2836
                                blenda = 0;                                                                                                             \
 
2837
                        else                                                                                                                            \
 
2838
                        {                                                                                                                                       \
 
2839
                                blenda = ((((TT)->detailbias - lod) << (TT)->detailscale) >> 8);\
 
2840
                                if (blenda > (TT)->detailmax)                                                                   \
 
2841
                                        blenda = (TT)->detailmax;                                                                       \
 
2842
                        }                                                                                                                                       \
 
2843
                        break;                                                                                                                          \
 
2844
                                                                                                                                                                \
 
2845
                case 5:         /* LOD fraction */                                                                                      \
 
2846
                        blenda = lod & 0xff;                                                                                            \
 
2847
                        break;                                                                                                                          \
 
2848
        }                                                                                                                                                       \
 
2849
                                                                                                                                                                \
 
2850
        /* reverse the RGB blend */                                                                                                     \
 
2851
        if (!TEXMODE_TC_REVERSE_BLEND(TEXMODE))                                                                         \
 
2852
        {                                                                                                                                                       \
 
2853
                blendr ^= 0xff;                                                                                                                 \
 
2854
                blendg ^= 0xff;                                                                                                                 \
 
2855
                blendb ^= 0xff;                                                                                                                 \
 
2856
        }                                                                                                                                                       \
 
2857
                                                                                                                                                                \
 
2858
        /* reverse the alpha blend */                                                                                           \
 
2859
        if (!TEXMODE_TCA_REVERSE_BLEND(TEXMODE))                                                                        \
 
2860
                blenda ^= 0xff;                                                                                                                 \
 
2861
                                                                                                                                                                \
 
2862
        /* do the blend */                                                                                                                      \
 
2863
        tr = (tr * (blendr + 1)) >> 8;                                                                                          \
 
2864
        tg = (tg * (blendg + 1)) >> 8;                                                                                          \
 
2865
        tb = (tb * (blendb + 1)) >> 8;                                                                                          \
 
2866
        ta = (ta * (blenda + 1)) >> 8;                                                                                          \
 
2867
                                                                                                                                                                \
 
2868
        /* add clocal or alocal to RGB */                                                                                       \
 
2869
        switch (TEXMODE_TC_ADD_ACLOCAL(TEXMODE))                                                                        \
 
2870
        {                                                                                                                                                       \
 
2871
                case 3:         /* reserved */                                                                                          \
 
2872
                case 0:         /* nothing */                                                                                           \
 
2873
                        break;                                                                                                                          \
 
2874
                                                                                                                                                                \
 
2875
                case 1:         /* add c_local */                                                                                       \
 
2876
                        tr += RGB_RED(c_local);                                                                                         \
 
2877
                        tg += RGB_GREEN(c_local);                                                                                       \
 
2878
                        tb += RGB_BLUE(c_local);                                                                                        \
 
2879
                        break;                                                                                                                          \
 
2880
                                                                                                                                                                \
 
2881
                case 2:         /* add_alocal */                                                                                        \
 
2882
                        tr += RGB_ALPHA(c_local);                                                                                       \
 
2883
                        tg += RGB_ALPHA(c_local);                                                                                       \
 
2884
                        tb += RGB_ALPHA(c_local);                                                                                       \
 
2885
                        break;                                                                                                                          \
 
2886
        }                                                                                                                                                       \
 
2887
                                                                                                                                                                \
 
2888
        /* add clocal or alocal to alpha */                                                                                     \
 
2889
        if (TEXMODE_TCA_ADD_ACLOCAL(TEXMODE))                                                                           \
 
2890
                ta += RGB_ALPHA(c_local);                                                                                               \
 
2891
                                                                                                                                                                \
 
2892
        /* clamp */                                                                                                                                     \
 
2893
        CLAMP(tr, 0x00, 0xff);                                                                                                          \
 
2894
        CLAMP(tg, 0x00, 0xff);                                                                                                          \
 
2895
        CLAMP(tb, 0x00, 0xff);                                                                                                          \
 
2896
        CLAMP(ta, 0x00, 0xff);                                                                                                          \
 
2897
                                                                                                                                                                \
 
2898
        /* produce the final result */                                                                                          \
 
2899
        (RESULT) = MAKE_ARGB(ta, tr, tg, tb);                                                                           \
 
2900
                                                                                                                                                                \
 
2901
        /* invert */                                                                                                                            \
 
2902
        if (TEXMODE_TC_INVERT_OUTPUT(TEXMODE))                                                                          \
 
2903
                (RESULT) ^= 0x00ffffff;                                                                                                 \
 
2904
        if (TEXMODE_TCA_INVERT_OUTPUT(TEXMODE))                                                                         \
 
2905
                (RESULT) ^= 0xff000000;                                                                                                 \
 
2906
}                                                                                                                                                               \
 
2907
while (0)
 
2908
 
 
2909
 
 
2910
 
 
2911
/*************************************
 
2912
 *
 
2913
 *  Pixel pipeline macros
 
2914
 *
 
2915
 *************************************/
 
2916
 
 
2917
#define PIXEL_PIPELINE_BEGIN(VV, XX, YY, SCRY, FBZCOLORPATH, FBZMODE, ITERZ, ITERW)     \
 
2918
do                                                                                                                                                              \
 
2919
{                                                                                                                                                               \
 
2920
        INT32 depthval, wfloat;                                                                                                         \
 
2921
        INT32 prefogr, prefogg, prefogb;                                                                                        \
 
2922
        INT32 r, g, b, a;                                                                                                                       \
 
2923
                                                                                                                                                                \
 
2924
        (VV)->reg[fbiPixelsIn].u++;                                                                                                     \
 
2925
                                                                                                                                                                \
 
2926
        /* apply clipping */                                                                                                            \
 
2927
        if (FBZMODE_ENABLE_CLIPPING(FBZMODE))                                                                           \
 
2928
        {                                                                                                                                                       \
 
2929
                if ((XX) < (((VV)->reg[clipLeftRight].u >> 16) & 0x3ff) ||                              \
 
2930
                        (XX) >= ((VV)->reg[clipLeftRight].u & 0x3ff) ||                                         \
 
2931
                        (SCRY) < (((VV)->reg[clipLowYHighY].u >> 16) & 0x3ff) ||                        \
 
2932
                        (SCRY) >= ((VV)->reg[clipLowYHighY].u & 0x3ff))                                         \
 
2933
                {                                                                                                                                               \
 
2934
                        v->stats.total_clipped++;                                                                                       \
 
2935
                        goto skipdrawdepth;                                                                                                     \
 
2936
                }                                                                                                                                               \
 
2937
        }                                                                                                                                                       \
 
2938
                                                                                                                                                                \
 
2939
        /* rotate stipple pattern */                                                                                            \
 
2940
        if (FBZMODE_STIPPLE_PATTERN(FBZMODE) == 0)                                                                      \
 
2941
                (VV)->reg[stipple].u = ((VV)->reg[stipple].u << 1) | ((VV)->reg[stipple].u >> 31);\
 
2942
                                                                                                                                                                \
 
2943
        /* handle stippling */                                                                                                          \
 
2944
        if (FBZMODE_ENABLE_STIPPLE(FBZMODE))                                                                            \
 
2945
        {                                                                                                                                                       \
 
2946
                /* rotate mode */                                                                                                               \
 
2947
                if (FBZMODE_STIPPLE_PATTERN(FBZMODE) == 0)                                                              \
 
2948
                {                                                                                                                                               \
 
2949
                        if (((VV)->reg[stipple].u & 0x80000000) == 0)                                           \
 
2950
                        {                                                                                                                                       \
 
2951
                                v->stats.total_stippled++;                                                                              \
 
2952
                                goto skipdrawdepth;                                                                                             \
 
2953
                        }                                                                                                                                       \
 
2954
                }                                                                                                                                               \
 
2955
                                                                                                                                                                \
 
2956
                /* pattern mode */                                                                                                              \
 
2957
                else                                                                                                                                    \
 
2958
                {                                                                                                                                               \
 
2959
                        int stipple_index = (((YY) & 3) << 3) | (~(XX) & 7);                            \
 
2960
                        if ((((VV)->reg[stipple].u >> stipple_index) & 1) == 0)                         \
 
2961
                        {                                                                                                                                       \
 
2962
                                v->stats.total_stippled++;                                                                              \
 
2963
                                goto skipdrawdepth;                                                                                             \
 
2964
                        }                                                                                                                                       \
 
2965
                }                                                                                                                                               \
 
2966
        }                                                                                                                                                       \
 
2967
                                                                                                                                                                \
 
2968
        /* compute "floating point" W value (used for depth and fog) */                         \
 
2969
        if ((ITERW) & U64(0xffff00000000))                                                                                      \
 
2970
                wfloat = 0x0000;                                                                                                                \
 
2971
        else                                                                                                                                            \
 
2972
        {                                                                                                                                                       \
 
2973
                UINT32 temp = (UINT32)(ITERW);                                                                                  \
 
2974
                if ((temp & 0xffff0000) == 0)                                                                                   \
 
2975
                        wfloat = 0xffff;                                                                                                        \
 
2976
                else                                                                                                                                    \
 
2977
                {                                                                                                                                               \
 
2978
                        int exp = count_leading_zeros(temp);                                                            \
 
2979
                        wfloat = ((exp << 12) | ((~temp >> (19 - exp)) & 0xfff)) + 1;           \
 
2980
                }                                                                                                                                               \
 
2981
        }                                                                                                                                                       \
 
2982
                                                                                                                                                                \
 
2983
        /* compute depth value (W or Z) for this pixel */                                                       \
 
2984
        if (FBZMODE_WBUFFER_SELECT(FBZMODE) == 0)                                                                       \
 
2985
                CLAMPED_Z(ITERZ, FBZCOLORPATH, depthval);                                                               \
 
2986
        else if (FBZMODE_DEPTH_FLOAT_SELECT(FBZMODE) == 0)                                                      \
 
2987
                depthval = wfloat;                                                                                                              \
 
2988
        else                                                                                                                                            \
 
2989
        {                                                                                                                                                       \
 
2990
                if ((ITERZ) & 0xf0000000)                                                                                               \
 
2991
                        depthval = 0x0000;                                                                                                      \
 
2992
                else                                                                                                                                    \
 
2993
                {                                                                                                                                               \
 
2994
                        UINT32 temp = (ITERZ) << 4;                                                                                     \
 
2995
                        if ((temp & 0xffff0000) == 0)                                                                           \
 
2996
                                depthval = 0xffff;                                                                                              \
 
2997
                        else                                                                                                                            \
 
2998
                        {                                                                                                                                       \
 
2999
                                int exp = count_leading_zeros(temp);                                                    \
 
3000
                                depthval = ((exp << 12) | ((~temp >> (19 - exp)) & 0xfff)) + 1; \
 
3001
                        }                                                                                                                                       \
 
3002
                }                                                                                                                                               \
 
3003
        }                                                                                                                                                       \
 
3004
                                                                                                                                                                \
 
3005
        /* add the bias */                                                                                                                      \
 
3006
        if (FBZMODE_ENABLE_DEPTH_BIAS(FBZMODE))                                                                         \
 
3007
        {                                                                                                                                                       \
 
3008
                depthval += (INT16)v->reg[zaColor].u;                                                                   \
 
3009
                CLAMP(depthval, 0, 0xffff);                                                                                             \
 
3010
        }                                                                                                                                                       \
 
3011
                                                                                                                                                                \
 
3012
        /* handle depth buffer testing */                                                                                       \
 
3013
        if (FBZMODE_ENABLE_DEPTHBUF(FBZMODE))                                                                           \
 
3014
        {                                                                                                                                                       \
 
3015
                INT32 depthsource;                                                                                                              \
 
3016
                                                                                                                                                                \
 
3017
                /* the source depth is either the iterated W/Z+bias or a */                             \
 
3018
                /* constant value */                                                                                                    \
 
3019
                if (FBZMODE_DEPTH_SOURCE_COMPARE(FBZMODE) == 0)                                                 \
 
3020
                        depthsource = depthval;                                                                                         \
 
3021
                else                                                                                                                                    \
 
3022
                        depthsource = v->reg[zaColor].u & 0xffff;                                                       \
 
3023
                                                                                                                                                                \
 
3024
                /* test against the depth buffer */                                                                             \
 
3025
                switch (FBZMODE_DEPTH_FUNCTION(FBZMODE))                                                                \
 
3026
                {                                                                                                                                               \
 
3027
                        case 0:         /* depthOP = never */                                                                   \
 
3028
                                (VV)->reg[fbiZfuncFail].u++;                                                                    \
 
3029
                                goto skipdrawdepth;                                                                                             \
 
3030
                                                                                                                                                                \
 
3031
                        case 1:         /* depthOP = less than */                                                               \
 
3032
                                if (depthsource >= depth[XX])                                                                   \
 
3033
                                {                                                                                                                               \
 
3034
                                        (VV)->reg[fbiZfuncFail].u++;                                                            \
 
3035
                                        goto skipdrawdepth;                                                                                     \
 
3036
                                }                                                                                                                               \
 
3037
                                break;                                                                                                                  \
 
3038
                                                                                                                                                                \
 
3039
                        case 2:         /* depthOP = equal */                                                                   \
 
3040
                                if (depthsource != depth[XX])                                                                   \
 
3041
                                {                                                                                                                               \
 
3042
                                        (VV)->reg[fbiZfuncFail].u++;                                                            \
 
3043
                                        goto skipdrawdepth;                                                                                     \
 
3044
                                }                                                                                                                               \
 
3045
                                break;                                                                                                                  \
 
3046
                                                                                                                                                                \
 
3047
                        case 3:         /* depthOP = less than or equal */                                              \
 
3048
                                if (depthsource > depth[XX])                                                                    \
 
3049
                                {                                                                                                                               \
 
3050
                                        (VV)->reg[fbiZfuncFail].u++;                                                            \
 
3051
                                        goto skipdrawdepth;                                                                                     \
 
3052
                                }                                                                                                                               \
 
3053
                                break;                                                                                                                  \
 
3054
                                                                                                                                                                \
 
3055
                        case 4:         /* depthOP = greater than */                                                    \
 
3056
                                if (depthsource <= depth[XX])                                                                   \
 
3057
                                {                                                                                                                               \
 
3058
                                        (VV)->reg[fbiZfuncFail].u++;                                                            \
 
3059
                                        goto skipdrawdepth;                                                                                     \
 
3060
                                }                                                                                                                               \
 
3061
                                break;                                                                                                                  \
 
3062
                                                                                                                                                                \
 
3063
                        case 5:         /* depthOP = not equal */                                                               \
 
3064
                                if (depthsource == depth[XX])                                                                   \
 
3065
                                {                                                                                                                               \
 
3066
                                        (VV)->reg[fbiZfuncFail].u++;                                                            \
 
3067
                                        goto skipdrawdepth;                                                                                     \
 
3068
                                }                                                                                                                               \
 
3069
                                break;                                                                                                                  \
 
3070
                                                                                                                                                                \
 
3071
                        case 6:         /* depthOP = greater than or equal */                                   \
 
3072
                                if (depthsource < depth[XX])                                                                    \
 
3073
                                {                                                                                                                               \
 
3074
                                        (VV)->reg[fbiZfuncFail].u++;                                                            \
 
3075
                                        goto skipdrawdepth;                                                                                     \
 
3076
                                }                                                                                                                               \
 
3077
                                break;                                                                                                                  \
 
3078
                                                                                                                                                                \
 
3079
                        case 7:         /* depthOP = always */                                                                  \
 
3080
                                break;                                                                                                                  \
 
3081
                }                                                                                                                                               \
 
3082
        }
 
3083
 
 
3084
 
 
3085
#define PIXEL_PIPELINE_END(VV, XX, YY, dest, depth, FBZMODE, FBZCOLORPATH, ALPHAMODE, FOGMODE, ITERZ, ITERW, ITERAXXX) \
 
3086
                                                                                                                                                                \
 
3087
        /* perform fogging */                                                                                                           \
 
3088
        prefogr = r;                                                                                                                            \
 
3089
        prefogg = g;                                                                                                                            \
 
3090
        prefogb = b;                                                                                                                            \
 
3091
        APPLY_FOGGING(VV, FOGMODE, FBZCOLORPATH, XX, YY, r, g, b,                                       \
 
3092
                                        ITERZ, ITERW, ITERAXXX);                                                                        \
 
3093
                                                                                                                                                                \
 
3094
        /* perform alpha blending */                                                                                            \
 
3095
        APPLY_ALPHA_BLEND(FBZMODE, ALPHAMODE, XX, YY, r, g, b, a);                                      \
 
3096
                                                                                                                                                                \
 
3097
        /* modify the pixel for debugging purposes */                                                           \
 
3098
        MODIFY_PIXEL(VV);                                                                                                                       \
 
3099
                                                                                                                                                                \
 
3100
        /* write to framebuffer */                                                                                                      \
 
3101
        if (FBZMODE_RGB_BUFFER_MASK(FBZMODE))                                                                           \
 
3102
        {                                                                                                                                                       \
 
3103
                /* apply dithering */                                                                                                   \
 
3104
                APPLY_DITHER(FBZMODE, (XX), (YY), r, g, b);                                                             \
 
3105
                dest[XX] = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);   \
 
3106
        }                                                                                                                                                       \
 
3107
                                                                                                                                                                \
 
3108
        /* write to aux buffer */                                                                                                       \
 
3109
        if (depth && FBZMODE_AUX_BUFFER_MASK(FBZMODE))                                                          \
 
3110
        {                                                                                                                                                       \
 
3111
                if (FBZMODE_ENABLE_ALPHA_PLANES(FBZMODE) == 0)                                                  \
 
3112
                        depth[XX] = depthval;                                                                                           \
 
3113
                else                                                                                                                                    \
 
3114
                        depth[XX] = a;                                                                                                          \
 
3115
        }                                                                                                                                                       \
 
3116
                                                                                                                                                                \
 
3117
        /* track pixel writes to the frame buffer regardless of mask */                         \
 
3118
        (VV)->reg[fbiPixelsOut].u++;                                                                                            \
 
3119
                                                                                                                                                                \
 
3120
skipdrawdepth:                                                                                                                                  \
 
3121
        ;                                                                                                                                                       \
 
3122
}                                                                                                                                                               \
 
3123
while (0)
 
3124
 
 
3125
 
 
3126
 
 
3127
/*************************************
 
3128
 *
 
3129
 *  Colorpath pipeline macro
 
3130
 *
 
3131
 *************************************/
 
3132
 
 
3133
/*
 
3134
 
 
3135
    c_other_is_used:
 
3136
 
 
3137
        if (FBZMODE_ENABLE_CHROMAKEY(FBZMODE) ||
 
3138
            FBZCP_CC_ZERO_OTHER(FBZCOLORPATH) == 0)
 
3139
 
 
3140
    c_local_is_used:
 
3141
 
 
3142
        if (FBZCP_CC_SUB_CLOCAL(FBZCOLORPATH) ||
 
3143
            FBZCP_CC_MSELECT(FBZCOLORPATH) == 1 ||
 
3144
            FBZCP_CC_ADD_ACLOCAL(FBZCOLORPATH) == 1)
 
3145
 
 
3146
    NEEDS_ITER_RGB:
 
3147
 
 
3148
        if ((c_other_is_used && FBZCP_CC_RGBSELECT(FBZCOLORPATH) == 0) ||
 
3149
            (c_local_is_used && (FBZCP_CC_LOCALSELECT_OVERRIDE(FBZCOLORPATH) != 0 || FBZCP_CC_LOCALSELECT(FBZCOLORPATH) == 0))
 
3150
 
 
3151
    NEEDS_ITER_A:
 
3152
 
 
3153
        if ((a_other_is_used && FBZCP_CC_ASELECT(FBZCOLORPATH) == 0) ||
 
3154
            (a_local_is_used && FBZCP_CCA_LOCALSELECT(FBZCOLORPATH) == 0))
 
3155
 
 
3156
    NEEDS_ITER_Z:
 
3157
 
 
3158
        if (FBZMODE_WBUFFER_SELECT(FBZMODE) == 0 ||
 
3159
            FBZMODE_DEPTH_FLOAT_SELECT(FBZMODE) != 0 ||
 
3160
            FBZCP_CCA_LOCALSELECT(FBZCOLORPATH) == 2)
 
3161
 
 
3162
 
 
3163
*/
 
3164
 
 
3165
/*
 
3166
    Expects the following declarations to be outside of this scope:
 
3167
 
 
3168
    INT32 r, g, b, a;
 
3169
*/
 
3170
#define COLORPATH_PIPELINE(VV, FBZCOLORPATH, FBZMODE, ALPHAMODE, TEXELARGB, ITERZ, ITERW, ITERARGB) \
 
3171
do                                                                                                                                                              \
 
3172
{                                                                                                                                                               \
 
3173
        INT32 blendr, blendg, blendb, blenda;                                                                           \
 
3174
        rgb_t c_other;                                                                                                                          \
 
3175
        rgb_t c_local;                                                                                                                          \
 
3176
        int a_other;                                                                                                                            \
 
3177
        int a_local;                                                                                                                            \
 
3178
                                                                                                                                                                \
 
3179
        /* compute c_other */                                                                                                           \
 
3180
        switch (FBZCP_CC_RGBSELECT(FBZCOLORPATH))                                                                       \
 
3181
        {                                                                                                                                                       \
 
3182
                case 0:         /* iterated RGB */                                                                                      \
 
3183
                        c_other = (ITERARGB);                                                                                           \
 
3184
                        break;                                                                                                                          \
 
3185
                                                                                                                                                                \
 
3186
                case 1:         /* texture RGB */                                                                                       \
 
3187
                        c_other = (TEXELARGB);                                                                                          \
 
3188
                        break;                                                                                                                          \
 
3189
                                                                                                                                                                \
 
3190
                case 2:         /* color1 RGB */                                                                                        \
 
3191
                        c_other = (VV)->reg[color1].u;                                                                          \
 
3192
                        break;                                                                                                                          \
 
3193
                                                                                                                                                                \
 
3194
                default:        /* reserved */                                                                                          \
 
3195
                        c_other = 0;                                                                                                            \
 
3196
                        break;                                                                                                                          \
 
3197
        }                                                                                                                                                       \
 
3198
                                                                                                                                                                \
 
3199
        /* handle chroma key */                                                                                                         \
 
3200
        APPLY_CHROMAKEY(VV, FBZMODE, c_other);                                                                          \
 
3201
                                                                                                                                                                \
 
3202
        /* compute a_other */                                                                                                           \
 
3203
        switch (FBZCP_CC_ASELECT(FBZCOLORPATH))                                                                         \
 
3204
        {                                                                                                                                                       \
 
3205
                case 0:         /* iterated alpha */                                                                            \
 
3206
                        a_other = RGB_ALPHA(ITERARGB);                                                                          \
 
3207
                        break;                                                                                                                          \
 
3208
                                                                                                                                                                \
 
3209
                case 1:         /* texture alpha */                                                                                     \
 
3210
                        a_other = RGB_ALPHA(TEXELARGB);                                                                         \
 
3211
                        break;                                                                                                                          \
 
3212
                                                                                                                                                                \
 
3213
                case 2:         /* color1 alpha */                                                                                      \
 
3214
                        a_other = RGB_ALPHA((VV)->reg[color1].u);                                                       \
 
3215
                        break;                                                                                                                          \
 
3216
                                                                                                                                                                \
 
3217
                default:        /* reserved */                                                                                          \
 
3218
                        a_other = 0;                                                                                                            \
 
3219
                        break;                                                                                                                          \
 
3220
        }                                                                                                                                                       \
 
3221
                                                                                                                                                                \
 
3222
        /* handle alpha mask */                                                                                                         \
 
3223
        APPLY_ALPHAMASK(VV, FBZMODE, a_other);                                                                          \
 
3224
                                                                                                                                                                \
 
3225
        /* handle alpha test */                                                                                                         \
 
3226
        APPLY_ALPHATEST(VV, ALPHAMODE, a_other);                                                                        \
 
3227
                                                                                                                                                                \
 
3228
        /* compute c_local */                                                                                                           \
 
3229
        if (FBZCP_CC_LOCALSELECT_OVERRIDE(FBZCOLORPATH) == 0)                                           \
 
3230
        {                                                                                                                                                       \
 
3231
                if (FBZCP_CC_LOCALSELECT(FBZCOLORPATH) == 0)    /* iterated RGB */              \
 
3232
                        c_local = (ITERARGB);                                                                                           \
 
3233
                else                                                                                    /* color0 RGB */                \
 
3234
                        c_local = (VV)->reg[color0].u;                                                                          \
 
3235
        }                                                                                                                                                       \
 
3236
        else                                                                                                                                            \
 
3237
        {                                                                                                                                                       \
 
3238
                if (!((TEXELARGB) & 0x80000000))                                /* iterated RGB */              \
 
3239
                        c_local = (ITERARGB);                                                                                           \
 
3240
                else                                                                                    /* color0 RGB */                \
 
3241
                        c_local = (VV)->reg[color0].u;                                                                          \
 
3242
        }                                                                                                                                                       \
 
3243
                                                                                                                                                                \
 
3244
        /* compute a_local */                                                                                                           \
 
3245
        switch (FBZCP_CCA_LOCALSELECT(FBZCOLORPATH))                                                            \
 
3246
        {                                                                                                                                                       \
 
3247
                default:                                                                                                                                \
 
3248
                case 0:         /* iterated alpha */                                                                            \
 
3249
                        a_local = RGB_ALPHA(ITERARGB);                                                                          \
 
3250
                        break;                                                                                                                          \
 
3251
                                                                                                                                                                \
 
3252
                case 1:         /* color0 alpha */                                                                                      \
 
3253
                        a_local = RGB_ALPHA((VV)->reg[color0].u);                                                       \
 
3254
                        break;                                                                                                                          \
 
3255
                                                                                                                                                                \
 
3256
                case 2:         /* clamped iterated Z[27:20] */                                                         \
 
3257
                        CLAMPED_Z(ITERZ, FBZCOLORPATH, a_local);                                                        \
 
3258
                        break;                                                                                                                          \
 
3259
                                                                                                                                                                \
 
3260
                case 3:         /* clamped iterated W[39:32] */                                                         \
 
3261
                        CLAMPED_W(ITERW, FBZCOLORPATH, a_local);        /* Voodoo 2 only */             \
 
3262
                        break;                                                                                                                          \
 
3263
        }                                                                                                                                                       \
 
3264
                                                                                                                                                                \
 
3265
        /* select zero or c_other */                                                                                            \
 
3266
        if (FBZCP_CC_ZERO_OTHER(FBZCOLORPATH) == 0)                                                                     \
 
3267
        {                                                                                                                                                       \
 
3268
                r = RGB_RED(c_other);                                                                                                   \
 
3269
                g = RGB_GREEN(c_other);                                                                                                 \
 
3270
                b = RGB_BLUE(c_other);                                                                                                  \
 
3271
        }                                                                                                                                                       \
 
3272
        else                                                                                                                                            \
 
3273
                r = g = b = 0;                                                                                                                  \
 
3274
                                                                                                                                                                \
 
3275
        /* select zero or a_other */                                                                                            \
 
3276
        if (FBZCP_CCA_ZERO_OTHER(FBZCOLORPATH) == 0)                                                            \
 
3277
                a = a_other;                                                                                                                    \
 
3278
        else                                                                                                                                            \
 
3279
                a = 0;                                                                                                                                  \
 
3280
                                                                                                                                                                \
 
3281
        /* subtract c_local */                                                                                                          \
 
3282
        if (FBZCP_CC_SUB_CLOCAL(FBZCOLORPATH))                                                                          \
 
3283
        {                                                                                                                                                       \
 
3284
                r -= RGB_RED(c_local);                                                                                                  \
 
3285
                g -= RGB_GREEN(c_local);                                                                                                \
 
3286
                b -= RGB_BLUE(c_local);                                                                                                 \
 
3287
        }                                                                                                                                                       \
 
3288
                                                                                                                                                                \
 
3289
        /* subtract a_local */                                                                                                          \
 
3290
        if (FBZCP_CCA_SUB_CLOCAL(FBZCOLORPATH))                                                                         \
 
3291
                a -= a_local;                                                                                                                   \
 
3292
                                                                                                                                                                \
 
3293
        /* blend RGB */                                                                                                                         \
 
3294
        switch (FBZCP_CC_MSELECT(FBZCOLORPATH))                                                                         \
 
3295
        {                                                                                                                                                       \
 
3296
                default:        /* reserved */                                                                                          \
 
3297
                case 0:         /* 0 */                                                                                                         \
 
3298
                        blendr = blendg = blendb = 0;                                                                           \
 
3299
                        break;                                                                                                                          \
 
3300
                                                                                                                                                                \
 
3301
                case 1:         /* c_local */                                                                                           \
 
3302
                        blendr = RGB_RED(c_local);                                                                                      \
 
3303
                        blendg = RGB_GREEN(c_local);                                                                            \
 
3304
                        blendb = RGB_BLUE(c_local);                                                                                     \
 
3305
                        break;                                                                                                                          \
 
3306
                                                                                                                                                                \
 
3307
                case 2:         /* a_other */                                                                                           \
 
3308
                        blendr = blendg = blendb = a_other;                                                                     \
 
3309
                        break;                                                                                                                          \
 
3310
                                                                                                                                                                \
 
3311
                case 3:         /* a_local */                                                                                           \
 
3312
                        blendr = blendg = blendb = a_local;                                                                     \
 
3313
                        break;                                                                                                                          \
 
3314
                                                                                                                                                                \
 
3315
                case 4:         /* texture alpha */                                                                                     \
 
3316
                        blendr = blendg = blendb = (TEXELARGB) >> 24;                                           \
 
3317
                        break;                                                                                                                          \
 
3318
                                                                                                                                                                \
 
3319
                case 5:         /* texture RGB (Voodoo 2 only) */                                                       \
 
3320
                        blendr = RGB_RED(TEXELARGB);                                                                            \
 
3321
                        blendg = RGB_GREEN(TEXELARGB);                                                                          \
 
3322
                        blendb = RGB_BLUE(TEXELARGB);                                                                           \
 
3323
                        break;                                                                                                                          \
 
3324
        }                                                                                                                                                       \
 
3325
                                                                                                                                                                \
 
3326
        /* blend alpha */                                                                                                                       \
 
3327
        switch (FBZCP_CCA_MSELECT(FBZCOLORPATH))                                                                        \
 
3328
        {                                                                                                                                                       \
 
3329
                default:        /* reserved */                                                                                          \
 
3330
                case 0:         /* 0 */                                                                                                         \
 
3331
                        blenda = 0;                                                                                                                     \
 
3332
                        break;                                                                                                                          \
 
3333
                                                                                                                                                                \
 
3334
                case 1:         /* a_local */                                                                                           \
 
3335
                        blenda = a_local;                                                                                                       \
 
3336
                        break;                                                                                                                          \
 
3337
                                                                                                                                                                \
 
3338
                case 2:         /* a_other */                                                                                           \
 
3339
                        blenda = a_other;                                                                                                       \
 
3340
                        break;                                                                                                                          \
 
3341
                                                                                                                                                                \
 
3342
                case 3:         /* a_local */                                                                                           \
 
3343
                        blenda = a_local;                                                                                                       \
 
3344
                        break;                                                                                                                          \
 
3345
                                                                                                                                                                \
 
3346
                case 4:         /* texture alpha */                                                                                     \
 
3347
                        blenda = (TEXELARGB) >> 24;                                                                                     \
 
3348
                        break;                                                                                                                          \
 
3349
        }                                                                                                                                                       \
 
3350
                                                                                                                                                                \
 
3351
        /* reverse the RGB blend */                                                                                                     \
 
3352
        if (!FBZCP_CC_REVERSE_BLEND(FBZCOLORPATH))                                                                      \
 
3353
        {                                                                                                                                                       \
 
3354
                blendr ^= 0xff;                                                                                                                 \
 
3355
                blendg ^= 0xff;                                                                                                                 \
 
3356
                blendb ^= 0xff;                                                                                                                 \
 
3357
        }                                                                                                                                                       \
 
3358
                                                                                                                                                                \
 
3359
        /* reverse the alpha blend */                                                                                           \
 
3360
        if (!FBZCP_CCA_REVERSE_BLEND(FBZCOLORPATH))                                                                     \
 
3361
                blenda ^= 0xff;                                                                                                                 \
 
3362
                                                                                                                                                                \
 
3363
        /* do the blend */                                                                                                                      \
 
3364
        r = (r * (blendr + 1)) >> 8;                                                                                            \
 
3365
        g = (g * (blendg + 1)) >> 8;                                                                                            \
 
3366
        b = (b * (blendb + 1)) >> 8;                                                                                            \
 
3367
        a = (a * (blenda + 1)) >> 8;                                                                                            \
 
3368
                                                                                                                                                                \
 
3369
        /* add clocal or alocal to RGB */                                                                                       \
 
3370
        switch (FBZCP_CC_ADD_ACLOCAL(FBZCOLORPATH))                                                                     \
 
3371
        {                                                                                                                                                       \
 
3372
                case 3:         /* reserved */                                                                                          \
 
3373
                case 0:         /* nothing */                                                                                           \
 
3374
                        break;                                                                                                                          \
 
3375
                                                                                                                                                                \
 
3376
                case 1:         /* add c_local */                                                                                       \
 
3377
                        r += RGB_RED(c_local);                                                                                          \
 
3378
                        g += RGB_GREEN(c_local);                                                                                        \
 
3379
                        b += RGB_BLUE(c_local);                                                                                         \
 
3380
                        break;                                                                                                                          \
 
3381
                                                                                                                                                                \
 
3382
                case 2:         /* add_alocal */                                                                                        \
 
3383
                        r += a_local;                                                                                                           \
 
3384
                        g += a_local;                                                                                                           \
 
3385
                        b += a_local;                                                                                                           \
 
3386
                        break;                                                                                                                          \
 
3387
        }                                                                                                                                                       \
 
3388
                                                                                                                                                                \
 
3389
        /* add clocal or alocal to alpha */                                                                                     \
 
3390
        if (FBZCP_CCA_ADD_ACLOCAL(FBZCOLORPATH))                                                                        \
 
3391
                a += a_local;                                                                                                                   \
 
3392
                                                                                                                                                                \
 
3393
        /* clamp */                                                                                                                                     \
 
3394
        CLAMP(r, 0x00, 0xff);                                                                                                           \
 
3395
        CLAMP(g, 0x00, 0xff);                                                                                                           \
 
3396
        CLAMP(b, 0x00, 0xff);                                                                                                           \
 
3397
        CLAMP(a, 0x00, 0xff);                                                                                                           \
 
3398
                                                                                                                                                                \
 
3399
        /* invert */                                                                                                                            \
 
3400
        if (FBZCP_CC_INVERT_OUTPUT(FBZCOLORPATH))                                                                       \
 
3401
        {                                                                                                                                                       \
 
3402
                r ^= 0xff;                                                                                                                              \
 
3403
                g ^= 0xff;                                                                                                                              \
 
3404
                b ^= 0xff;                                                                                                                              \
 
3405
        }                                                                                                                                                       \
 
3406
        if (FBZCP_CCA_INVERT_OUTPUT(FBZCOLORPATH))                                                                      \
 
3407
                a ^= 0xff;                                                                                                                              \
 
3408
}                                                                                                                                                               \
 
3409
while (0)
 
3410
 
 
3411
 
 
3412
 
 
3413
/*************************************
 
3414
 *
 
3415
 *  Rasterizer generator macro
 
3416
 *
 
3417
 *************************************/
 
3418
 
 
3419
#define ITER_RGB(r,g,b) ((((r) << 4) & 0xff0000) | (((g) >> 4) & 0xff00) | (((b) >> 12) & 0xff))
 
3420
 
 
3421
#define RASTERIZER(name, TMUS, FBZCOLORPATH, FBZMODE, ALPHAMODE, FOGMODE, TEXMODE0, TEXMODE1) \
 
3422
                                                                                                                                                                \
 
3423
static void raster_##name(voodoo_state *v, UINT16 *drawbuf)                                             \
 
3424
{                                                                                                                                                               \
 
3425
        INT32 dxdy_minmid, dxdy_minmax, dxdy_midmax;                                                            \
 
3426
        INT32 minx, miny, midx, midy, maxx, maxy;                                                                       \
 
3427
        INT32 starty, stopy;                                                                                                            \
 
3428
        INT32 x, y;                                                                                                                                     \
 
3429
                                                                                                                                                                \
 
3430
        /* sort the vertices */                                                                                                         \
 
3431
        if (v->fbi.ay <= v->fbi.by)                                                                                                     \
 
3432
        {                                                                                                                                                       \
 
3433
                if (v->fbi.by <= v->fbi.cy)                                                                                             \
 
3434
                {                                                                                                                                               \
 
3435
                        minx = v->fbi.ax;       miny = v->fbi.ay;                                                               \
 
3436
                        midx = v->fbi.bx;       midy = v->fbi.by;                                                               \
 
3437
                        maxx = v->fbi.cx;       maxy = v->fbi.cy;                                                               \
 
3438
                }                                                                                                                                               \
 
3439
                else if (v->fbi.ay <= v->fbi.cy)                                                                                \
 
3440
                {                                                                                                                                               \
 
3441
                        minx = v->fbi.ax;       miny = v->fbi.ay;                                                               \
 
3442
                        midx = v->fbi.cx;       midy = v->fbi.cy;                                                               \
 
3443
                        maxx = v->fbi.bx;       maxy = v->fbi.by;                                                               \
 
3444
                }                                                                                                                                               \
 
3445
                else                                                                                                                                    \
 
3446
                {                                                                                                                                               \
 
3447
                        minx = v->fbi.cx;       miny = v->fbi.cy;                                                               \
 
3448
                        midx = v->fbi.ax;       midy = v->fbi.ay;                                                               \
 
3449
                        maxx = v->fbi.bx;       maxy = v->fbi.by;                                                               \
 
3450
                }                                                                                                                                               \
 
3451
        }                                                                                                                                                       \
 
3452
        else                                                                                                                                            \
 
3453
        {                                                                                                                                                       \
 
3454
                if (v->fbi.ay <= v->fbi.cy)                                                                                             \
 
3455
                {                                                                                                                                               \
 
3456
                        minx = v->fbi.bx;       miny = v->fbi.by;                                                               \
 
3457
                        midx = v->fbi.ax;       midy = v->fbi.ay;                                                               \
 
3458
                        maxx = v->fbi.cx;       maxy = v->fbi.cy;                                                               \
 
3459
                }                                                                                                                                               \
 
3460
                else if (v->fbi.by <= v->fbi.cy)                                                                                \
 
3461
                {                                                                                                                                               \
 
3462
                        minx = v->fbi.bx;       miny = v->fbi.by;                                                               \
 
3463
                        midx = v->fbi.cx;       midy = v->fbi.cy;                                                               \
 
3464
                        maxx = v->fbi.ax;       maxy = v->fbi.ay;                                                               \
 
3465
                }                                                                                                                                               \
 
3466
                else                                                                                                                                    \
 
3467
                {                                                                                                                                               \
 
3468
                        minx = v->fbi.cx;       miny = v->fbi.cy;                                                               \
 
3469
                        midx = v->fbi.bx;       midy = v->fbi.by;                                                               \
 
3470
                        maxx = v->fbi.ax;       maxy = v->fbi.ay;                                                               \
 
3471
                }                                                                                                                                               \
 
3472
        }                                                                                                                                                       \
 
3473
                                                                                                                                                                \
 
3474
        /* compute the slopes as 16.16 numbers */                                                                       \
 
3475
        dxdy_minmid = (miny == midy) ? 0 : ((midx - minx) << 16) / (midy - miny);       \
 
3476
        dxdy_minmax = (miny == maxy) ? 0 : ((maxx - minx) << 16) / (maxy - miny);       \
 
3477
        dxdy_midmax = (midy == maxy) ? 0 : ((maxx - midx) << 16) / (maxy - midy);       \
 
3478
                                                                                                                                                                \
 
3479
        /* clamp to full pixels */                                                                                                      \
 
3480
        starty = (miny + 7) >> 4;                                                                                                       \
 
3481
        stopy = (maxy + 7) >> 4;                                                                                                        \
 
3482
                                                                                                                                                                \
 
3483
        /* loop in Y */                                                                                                                         \
 
3484
        for (y = starty; y < stopy; y++)                                                                                        \
 
3485
        {                                                                                                                                                       \
 
3486
                INT32 iterr, iterg, iterb, itera;                                                                               \
 
3487
                INT32 iterz;                                                                                                                    \
 
3488
                INT64 iterw, iterw0 = 0, iterw1 = 0;                                                                    \
 
3489
                INT64 iters0 = 0, iters1 = 0;                                                                                   \
 
3490
                INT64 itert0 = 0, itert1 = 0;                                                                                   \
 
3491
                INT32 startx, stopx;                                                                                                    \
 
3492
                INT32 fully;                                                                                                                    \
 
3493
                UINT16 *depth;                                                                                                                  \
 
3494
                UINT16 *dest;                                                                                                                   \
 
3495
                INT32 dx, dy;                                                                                                                   \
 
3496
                INT32 scry;                                                                                                                             \
 
3497
                                                                                                                                                                \
 
3498
                /* compute X endpoints */                                                                                               \
 
3499
                fully = (y << 4) + 8;                                                                                                   \
 
3500
                startx = minx + (((fully - miny) * dxdy_minmax) >> 16);                                 \
 
3501
                if (fully < midy)                                                                                                               \
 
3502
                        stopx = minx + (((fully - miny) * dxdy_minmid) >> 16);                          \
 
3503
                else                                                                                                                                    \
 
3504
                        stopx = midx + (((fully - midy) * dxdy_midmax) >> 16);                          \
 
3505
                                                                                                                                                                \
 
3506
                /* clamp to full pixels */                                                                                              \
 
3507
                startx = (startx + 7) >> 4;                                                                                             \
 
3508
                stopx = (stopx + 7) >> 4;                                                                                               \
 
3509
                                                                                                                                                                \
 
3510
                /* force start < stop */                                                                                                \
 
3511
                if (startx > stopx)                                                                                                             \
 
3512
                {                                                                                                                                               \
 
3513
                        int temp = startx;                                                                                                      \
 
3514
                        startx = stopx;                                                                                                         \
 
3515
                        stopx = temp;                                                                                                           \
 
3516
                }                                                                                                                                               \
 
3517
                                                                                                                                                                \
 
3518
                /* determine the screen Y */                                                                                    \
 
3519
                scry = y;                                                                                                                               \
 
3520
                if (FBZMODE_Y_ORIGIN(FBZMODE))                                                                                  \
 
3521
                        scry = (v->fbi.yorigin - y) & 0x3ff;                                                            \
 
3522
                                                                                                                                                                \
 
3523
                /* get pointers to the target buffer and depth buffer */                                \
 
3524
                dest = drawbuf + scry * v->fbi.rowpixels;                                                               \
 
3525
                depth = v->fbi.aux ? (v->fbi.aux + scry * v->fbi.rowpixels) : NULL;             \
 
3526
                                                                                                                                                                \
 
3527
                /* compute the starting parameters */                                                                   \
 
3528
                dx = startx - (v->fbi.ax >> 4);                                                                                 \
 
3529
                dy = y - (v->fbi.ay >> 4);                                                                                              \
 
3530
                iterr = v->fbi.startr + dy * v->fbi.drdy + dx * v->fbi.drdx;                    \
 
3531
                iterg = v->fbi.startg + dy * v->fbi.dgdy + dx * v->fbi.dgdx;                    \
 
3532
                iterb = v->fbi.startb + dy * v->fbi.dbdy + dx * v->fbi.dbdx;                    \
 
3533
                itera = v->fbi.starta + dy * v->fbi.dady + dx * v->fbi.dadx;                    \
 
3534
                iterz = v->fbi.startz + dy * v->fbi.dzdy + dx * v->fbi.dzdx;                    \
 
3535
                iterw = v->fbi.startw + dy * v->fbi.dwdy + dx * v->fbi.dwdx;                    \
 
3536
                if (TMUS >= 1)                                                                                                                  \
 
3537
                {                                                                                                                                               \
 
3538
                        iterw0 = v->tmu[0].startw + dy * v->tmu[0].dwdy +                                       \
 
3539
                                                                                dx * v->tmu[0].dwdx;                                    \
 
3540
                        iters0 = v->tmu[0].starts + dy * v->tmu[0].dsdy +                                       \
 
3541
                                                                                dx * v->tmu[0].dsdx;                                    \
 
3542
                        itert0 = v->tmu[0].startt + dy * v->tmu[0].dtdy +                                       \
 
3543
                                                                                dx * v->tmu[0].dtdx;                                    \
 
3544
                }                                                                                                                                               \
 
3545
                if (TMUS >= 2)                                                                                                                  \
 
3546
                {                                                                                                                                               \
 
3547
                        iterw1 = v->tmu[1].startw + dy * v->tmu[1].dwdy +                                       \
 
3548
                                                                                dx * v->tmu[1].dwdx;                                    \
 
3549
                        iters1 = v->tmu[1].starts + dy * v->tmu[1].dsdy +                                       \
 
3550
                                                                                dx * v->tmu[1].dsdx;                                    \
 
3551
                        itert1 = v->tmu[1].startt + dy * v->tmu[1].dtdy +                                       \
 
3552
                                                                                dx * v->tmu[1].dtdx;                                    \
 
3553
                }                                                                                                                                               \
 
3554
                                                                                                                                                                \
 
3555
                /* loop in X */                                                                                                                 \
 
3556
                for (x = startx; x < stopx; x++)                                                                                \
 
3557
                {                                                                                                                                               \
 
3558
                        rgb_t iterargb = 0;                                                                                                     \
 
3559
                        rgb_t texel = 0;                                                                                                        \
 
3560
                                                                                                                                                                \
 
3561
                        /* pixel pipeline part 1 handles depth testing and stippling */         \
 
3562
                        PIXEL_PIPELINE_BEGIN(v, x, y, scry, FBZCOLORPATH, FBZMODE,                      \
 
3563
                                                                        iterz, iterw);                                                          \
 
3564
                                                                                                                                                                \
 
3565
                        /* run the texture pipeline on TMU1 to produce a value in texel */      \
 
3566
                        /* note that they set LOD min to 8 to "disable" a TMU */                        \
 
3567
                        if (TMUS >= 2 && v->tmu[1].lodmin < (8 << 8))                                           \
 
3568
                                TEXTURE_PIPELINE(&v->tmu[1], x, y, TEXMODE1, texel,                             \
 
3569
                                                                        v->tmu[1].lookup, v->tmu[1].lodbase,            \
 
3570
                                                                        iters1, itert1, iterw1, texel);                         \
 
3571
                                                                                                                                                                \
 
3572
                        /* run the texture pipeline on TMU0 to produce a final */                       \
 
3573
                        /* result in texel */                                                                                           \
 
3574
                        /* note that they set LOD min to 8 to "disable" a TMU */                        \
 
3575
                        if (TMUS >= 1 && v->tmu[0].lodmin < (8 << 8))                                           \
 
3576
                                TEXTURE_PIPELINE(&v->tmu[0], x, y, TEXMODE0, texel,                     \
 
3577
                                                                        v->tmu[0].lookup, v->tmu[0].lodbase,            \
 
3578
                                                                        iters0, itert0, iterw0, texel);                         \
 
3579
                                                                                                                                                                \
 
3580
                        /* colorpath pipeline selects source colors and does blending */        \
 
3581
                        CLAMPED_ARGB(iterr, iterg, iterb, itera, FBZCOLORPATH, iterargb);       \
 
3582
                        COLORPATH_PIPELINE(v, FBZCOLORPATH, FBZMODE, ALPHAMODE, texel,          \
 
3583
                                                                iterz, iterw, iterargb);                                                \
 
3584
                                                                                                                                                                \
 
3585
                        /* pixel pipeline part 2 handles fog, alpha, and final output */        \
 
3586
                        PIXEL_PIPELINE_END(v, x, y, dest, depth, FBZMODE, FBZCOLORPATH,         \
 
3587
                                                                        ALPHAMODE, FOGMODE, iterz, iterw, iterargb);\
 
3588
                                                                                                                                                                \
 
3589
                        /* update the iterated parameters */                                                            \
 
3590
                        iterr += v->fbi.drdx;                                                                                           \
 
3591
                        iterg += v->fbi.dgdx;                                                                                           \
 
3592
                        iterb += v->fbi.dbdx;                                                                                           \
 
3593
                        itera += v->fbi.dadx;                                                                                           \
 
3594
                        iterz += v->fbi.dzdx;                                                                                           \
 
3595
                        iterw += v->fbi.dwdx;                                                                                           \
 
3596
                        if (TMUS >= 1)                                                                                                          \
 
3597
                        {                                                                                                                                       \
 
3598
                                iterw0 += v->tmu[0].dwdx;                                                                               \
 
3599
                                iters0 += v->tmu[0].dsdx;                                                                               \
 
3600
                                itert0 += v->tmu[0].dtdx;                                                                               \
 
3601
                        }                                                                                                                                       \
 
3602
                        if (TMUS >= 2)                                                                                                          \
 
3603
                        {                                                                                                                                       \
 
3604
                                iterw1 += v->tmu[1].dwdx;                                                                               \
 
3605
                                iters1 += v->tmu[1].dsdx;                                                                               \
 
3606
                                itert1 += v->tmu[1].dtdx;                                                                               \
 
3607
                        }                                                                                                                                       \
 
3608
                }                                                                                                                                               \
 
3609
        }                                                                                                                                                       \
 
3610
}