?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Replace Tmem_nasm.asm with C++ code. Patch by pyro.
[Glide64.git] / ucode05.h
blobccef8507d723ed892f5abb2dabc6b32e93eb877d
1 /*
2 * Glide64 - Glide video plugin for Nintendo 64 emulators.
3 * Copyright (c) 2002 Dave2001
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18 */
19
20 //****************************************************************
21 //
22 // Glide64 - Glide Plugin for Nintendo 64 emulators (tested mostly with Project64)
23 // Project started on December 29th, 2001
24 //
25 // To modify Glide64:
26 // * Write your name and (optional)email, commented by your work, so I know who did it, and so that you can find which parts you modified when it comes time to send it to me.
27 // * Do NOT send me the whole project or file that you modified. Take out your modified code sections, and tell me where to put them. If people sent the whole thing, I would have many different versions, but no idea how to combine them all.
28 //
29 // Official Glide64 development channel: #Glide64 on EFnet
30 //
31 // Original author: Dave2001 (Dave2999@hotmail.com)
32 // Other authors: Gonetz, Gugaman
33 //
34 //****************************************************************
35
36 int cur_mtx = 0;
37 BOOL billboarding = 0;
38 int vtx_last = 0;
39 DWORD dma_offset_mtx = 0;
40 DWORD dma_offset_vtx = 0;
41
42 static void uc5_dma_offsets ()
43 {
44 dma_offset_mtx = rdp.cmd0 & 0x00FFFFFF;
45 dma_offset_vtx = rdp.cmd1 & 0x00FFFFFF;
46 vtx_last = 0;
47 FRDP("uc5:dma_offsets - mtx: %08lx, vtx: %08lx\n", dma_offset_mtx, dma_offset_vtx);
48 }
49
50 static void uc5_matrix ()
51 {
52 // Use segment offset to get the address
53 DWORD addr = dma_offset_mtx + (segoffset(rdp.cmd1) & BMASK);
54
55 BYTE n = (BYTE)((rdp.cmd0 >> 16) & 0xF);
56 BYTE multiply;
57
58 if (n == 0) //DKR
59 {
60 n = (BYTE)((rdp.cmd0 >> 22) & 0x3);
61 multiply = 0;
62 }
63 else //JF
64 {
65 multiply = (BYTE)((rdp.cmd0 >> 23) & 0x1);
66 }
67
68 cur_mtx = n;
69
70 FRDP("uc5:matrix - #%d, addr: %08lx\n", n, addr);
71
72 addr >>= 1;
73
74 int x,y; // matrix index
75
76 if (multiply)
77 {
78 __declspec( align(16) ) float m[4][4];
79 for (x=0; x<16; x+=4) { // Adding 4 instead of one, just to remove mult. later
80 for (y=0; y<4; y++) {
81 m[x>>2][y] = (float)(
82 (((__int32)((WORD*)gfx.RDRAM)[(addr+x+y)^1]) << 16) |
83 ((WORD*)gfx.RDRAM)[(addr+x+y+16)^1]
84 ) / 65536.0f;
85 }
86 }
87 __declspec( align(16) ) float m_src[4][4];
88 memcpy (m_src, rdp.dkrproj[0], 64);
89 MulMatrices(m, m_src, rdp.dkrproj[n]);
90 }
91 else
92 {
93 for (x=0; x<16; x+=4) { // Adding 4 instead of one, just to remove mult. later
94 for (y=0; y<4; y++) {
95 rdp.dkrproj[n][x>>2][y] = (float)(
96 (((__int32)((WORD*)gfx.RDRAM)[(addr+x+y)^1]) << 16) |
97 ((WORD*)gfx.RDRAM)[(addr+x+y+16)^1]
98 ) / 65536.0f;
99 }
100 }
101 }
102 rdp.update |= UPDATE_MULT_MAT;
103
104 #ifdef EXTREME_LOGGING
105 FRDP ("{%f,%f,%f,%f}\n", rdp.dkrproj[n][0][0], rdp.dkrproj[n][0][1], rdp.dkrproj[n][0][2], rdp.dkrproj[n][0][3]);
106 FRDP ("{%f,%f,%f,%f}\n", rdp.dkrproj[n][1][0], rdp.dkrproj[n][1][1], rdp.dkrproj[n][1][2], rdp.dkrproj[n][1][3]);
107 FRDP ("{%f,%f,%f,%f}\n", rdp.dkrproj[n][2][0], rdp.dkrproj[n][2][1], rdp.dkrproj[n][2][2], rdp.dkrproj[n][2][3]);
108 FRDP ("{%f,%f,%f,%f}\n", rdp.dkrproj[n][3][0], rdp.dkrproj[n][3][1], rdp.dkrproj[n][3][2], rdp.dkrproj[n][3][3]);
109
110 for (int i=0; i<3; i++)
111 {
112 FRDP ("proj %d\n", i);
113 FRDP ("{%f,%f,%f,%f}\n", rdp.dkrproj[i][0][0], rdp.dkrproj[i][0][1], rdp.dkrproj[i][0][2], rdp.dkrproj[i][0][3]);
114 FRDP ("{%f,%f,%f,%f}\n", rdp.dkrproj[i][1][0], rdp.dkrproj[i][1][1], rdp.dkrproj[i][1][2], rdp.dkrproj[i][1][3]);
115 FRDP ("{%f,%f,%f,%f}\n", rdp.dkrproj[i][2][0], rdp.dkrproj[i][2][1], rdp.dkrproj[i][2][2], rdp.dkrproj[i][2][3]);
116 FRDP ("{%f,%f,%f,%f}\n", rdp.dkrproj[i][3][0], rdp.dkrproj[i][3][1], rdp.dkrproj[i][3][2], rdp.dkrproj[i][3][3]);
117 }
118 #endif
119 }
120
121 static void uc5_vertex ()
122 {
123 DWORD addr = dma_offset_vtx + (segoffset(rdp.cmd1) & BMASK);
124
125 // | cccc cccc 1111 1??? 0000 0002 2222 2222 | cmd1 = address |
126 // c = vtx command
127 // 1 = method #1 of getting count
128 // 2 = method #2 of getting count
129 // ? = unknown, but used
130 // 0 = unused
131
132 int n = ((rdp.cmd0 >> 19) & 0x1F);// + 1;
133 if (settings.diddy)
134 n++;
135 //int n = ((rdp.cmd0 & 0x1FF) - 8) / 18; // same thing!
136
137 if (rdp.cmd0 & 0x00010000)
138 {
139 if (billboarding)
140 vtx_last = 1;
141 }
142 else
143 vtx_last = 0;
144
145 int first = ((rdp.cmd0 >> 9) & 0x1F) + vtx_last;
146 FRDP ("uc5:vertex - addr: %08lx, first: %d, count: %d, matrix: %08lx\n", addr, first, n, cur_mtx);
147
148 int prj = cur_mtx;
149
150 int start = 0;
151 float x, y, z;
152 for (int i=first; i<first+n; i++)
153 {
154 start = (i-first) * 10;
155 VERTEX *v = &rdp.vtx[i];
156 x = (float)((short*)gfx.RDRAM)[(((addr+start) >> 1) + 0)^1];
157 y = (float)((short*)gfx.RDRAM)[(((addr+start) >> 1) + 1)^1];
158 z = (float)((short*)gfx.RDRAM)[(((addr+start) >> 1) + 2)^1];
159
160 v->x = x*rdp.dkrproj[prj][0][0] + y*rdp.dkrproj[prj][1][0] + z*rdp.dkrproj[prj][2][0] + rdp.dkrproj[prj][3][0];
161 v->y = x*rdp.dkrproj[prj][0][1] + y*rdp.dkrproj[prj][1][1] + z*rdp.dkrproj[prj][2][1] + rdp.dkrproj[prj][3][1];
162 v->z = x*rdp.dkrproj[prj][0][2] + y*rdp.dkrproj[prj][1][2] + z*rdp.dkrproj[prj][2][2] + rdp.dkrproj[prj][3][2];
163 v->w = x*rdp.dkrproj[prj][0][3] + y*rdp.dkrproj[prj][1][3] + z*rdp.dkrproj[prj][2][3] + rdp.dkrproj[prj][3][3];
164
165 if (billboarding)
166 {
167 v->x += rdp.vtx[0].x;
168 v->y += rdp.vtx[0].y;
169 v->z += rdp.vtx[0].z;
170 v->w += rdp.vtx[0].w;
171 }
172
173 #ifdef EXTREME_LOGGING
174 FRDP ("v%d - x: %f, y: %f, z: %f, w: %f\n", i, v->x, v->y, v->z, v->w);
175 #endif
176
177 v->oow = 1.0f / v->w;
178 v->x_w = v->x * v->oow;
179 v->y_w = v->y * v->oow;
180 v->z_w = v->z * v->oow;
181
182 v->uv_calculated = 0xFFFFFFFF;
183 v->screen_translated = 0;
184 v->shade_mods_allowed = 1;
185
186 v->scr_off = 0;
187 if (v->x < -v->w) v->scr_off |= 1;
188 if (v->x > v->w) v->scr_off |= 2;
189 if (v->y < -v->w) v->scr_off |= 4;
190 if (v->y > v->w) v->scr_off |= 8;
191 if (v->w < 0.1f) v->scr_off |= 16;
192
193 v->r = ((BYTE*)gfx.RDRAM)[(addr+start + 6)^3];
194 v->g = ((BYTE*)gfx.RDRAM)[(addr+start + 7)^3];
195 v->b = ((BYTE*)gfx.RDRAM)[(addr+start + 8)^3];
196 v->a = ((BYTE*)gfx.RDRAM)[(addr+start + 9)^3];
197 CalculateFog (v);
198
199 #ifdef EXTREME_LOGGING
200 FRDP ("vtx%d: x: %f, y: %f, z: %f, w: %f\n", i, v->x, v->y, v->z, v->w);
201 #endif
202 }
203
204 vtx_last += n;
205 }
206
207 static void uc5_tridma ()
208 {
209 vtx_last = 0; // we've drawn something, so the vertex index needs resetting
210 if (rdp.skip_drawing)
211 return;
212
213 // | cccc cccc 2222 0000 1111 1111 1111 0000 | cmd1 = address |
214 // c = tridma command
215 // 1 = method #1 of getting count
216 // 2 = method #2 of getting count
217 // 0 = unused
218
219 DWORD addr = segoffset(rdp.cmd1) & BMASK;
220 int num = (rdp.cmd0 & 0xFFF0) >> 4;
221 //int num = ((rdp.cmd0 & 0x00F00000) >> 20) + 1; // same thing!
222 FRDP("uc5:tridma #%d - addr: %08lx, count: %d\n", rdp.tri_n, addr, num);
223
224 int start, v0, v1, v2, flags;
225 for (int i=0; i<num; i++)
226 {
227 start = i << 4;
228 v0 = gfx.RDRAM[addr+start];
229 v1 = gfx.RDRAM[addr+start+1];
230 v2 = gfx.RDRAM[addr+start+2];
231
232 FRDP("tri #%d - %d, %d, %d\n", rdp.tri_n, v0, v1, v2);
233
234 VERTEX *v[3] = {
235 &rdp.vtx[v0],
236 &rdp.vtx[v1],
237 &rdp.vtx[v2]
238 };
239
240 flags = gfx.RDRAM[addr+start+3];
241
242 if (flags & 0x40) { // no cull
243 rdp.flags &= ~CULLMASK;
244 grCullMode (GR_CULL_DISABLE);
245 }
246 else { // front cull
247 rdp.flags &= ~CULLMASK;
248 if (rdp.view_scale[0] < 0) {
249 rdp.flags |= CULL_BACK; // agh, backwards culling
250 grCullMode (GR_CULL_POSITIVE);
251 }
252 else {
253 rdp.flags |= CULL_FRONT;
254 grCullMode (GR_CULL_NEGATIVE);
255 }
256 }
257 start += 4;
258
259 v[0]->ou = (float)((short*)gfx.RDRAM)[((addr+start) >> 1) + 5] / 32.0f;
260 v[0]->ov = (float)((short*)gfx.RDRAM)[((addr+start) >> 1) + 4] / 32.0f;
261 v[1]->ou = (float)((short*)gfx.RDRAM)[((addr+start) >> 1) + 3] / 32.0f;
262 v[1]->ov = (float)((short*)gfx.RDRAM)[((addr+start) >> 1) + 2] / 32.0f;
263 v[2]->ou = (float)((short*)gfx.RDRAM)[((addr+start) >> 1) + 1] / 32.0f;
264 v[2]->ov = (float)((short*)gfx.RDRAM)[((addr+start) >> 1) + 0] / 32.0f;
265
266 v[0]->uv_calculated = 0xFFFFFFFF;
267 v[1]->uv_calculated = 0xFFFFFFFF;
268 v[2]->uv_calculated = 0xFFFFFFFF;
269
270 if (cull_tri(v))
271 rdp.tri_n ++;
272 else
273 {
274 update ();
275
276 DrawTri (v);
277 rdp.tri_n ++;
278 }
279 }
280 }
281
282 static void uc5_dl_in_mem ()
283 {
284 DWORD addr = segoffset(rdp.cmd1) & BMASK;
285 int count = (rdp.cmd0 & 0x00FF0000) >> 16;
286 FRDP ("uc5:dl_in_mem - addr: %08lx, count: %d\n", addr, count);
287
288 if (rdp.pc_i >= 9) {
289 RDP_E ("** DL stack overflow **\n");
290 RDP ("** DL stack overflow **\n");
291 return;
292 }
293 rdp.pc_i ++; // go to the next PC in the stack
294 rdp.pc[rdp.pc_i] = addr; // jump to the address
295 rdp.dl_count = count + 1;
296 }
297
298 static void uc5_moveword()
299 {
300 RDP("uc5:moveword ");
301
302 // Find which command this is (lowest byte of cmd0)
303 switch (rdp.cmd0 & 0xFF)
304 {
305 case 0x02: // moveword matrix 2 billboard
306 billboarding = (rdp.cmd1 & 1);
307 FRDP ("matrix billboard - %s\n", str_offon[billboarding]);
308 break;
309
310 case 0x04: // clip (verified same)
311 FRDP ("clip %08lx, %08lx\n", rdp.cmd0, rdp.cmd1);
312 break;
313
314 case 0x06: // segment (verified same)
315 FRDP ("segment: %08lx -> seg%d\n", rdp.cmd1, (rdp.cmd0 >> 10) & 0x0F);
316 rdp.segment[(rdp.cmd0 >> 10) & 0x0F] = rdp.cmd1;
317 break;
318
319 case 0x08:
320 {
321 rdp.fog_multiplier = (short)(rdp.cmd1 >> 16);
322 rdp.fog_offset = (short)(rdp.cmd1 & 0x0000FFFF);
323 FRDP ("fog: multiplier: %f, offset: %f\n", rdp.fog_multiplier, rdp.fog_offset);
324 // rdp.update |= UPDATE_FOG_ENABLED;
325 }
326 break;
327
328 case 0x0a: // moveword matrix select
329 cur_mtx = (rdp.cmd1 >> 6) & 3;
330 FRDP ("matrix select - mtx: %d\n", cur_mtx);
331 break;
332
333 default:
334 FRDP ("(unknown) %02lx - IGNORED\n", rdp.cmd0&0xFF);
335 }
336 }
337
338 static void uc5_setgeometrymode()
339 {
340 FRDP("uc0:setgeometrymode %08lx\n", rdp.cmd1);
341
342 rdp.geom_mode |= rdp.cmd1;
343
344 if (rdp.cmd1 & 0x00000001) // Z-Buffer enable
345 {
346 if (!(rdp.flags & ZBUF_ENABLED))
347 {
348 rdp.flags |= ZBUF_ENABLED;
349 rdp.update |= UPDATE_ZBUF_ENABLED;
350 }
351 }
352
353 //Added by Gonetz
354 if (rdp.cmd1 & 0x00010000) // Fog enable
355 {
356 if (!(rdp.flags & FOG_ENABLED))
357 {
358 rdp.flags |= FOG_ENABLED;
359 rdp.update |= UPDATE_FOG_ENABLED;
360 }
361 }
362 }
363
364 static void uc5_cleargeometrymode()
365 {
366 FRDP("uc0:cleargeometrymode %08lx\n", rdp.cmd1);
367
368 rdp.geom_mode &= (~rdp.cmd1);
369
370 if (rdp.cmd1 & 0x00000001) // Z-Buffer enable
371 {
372 if (rdp.flags & ZBUF_ENABLED)
373 {
374 rdp.flags ^= ZBUF_ENABLED;
375 rdp.update |= UPDATE_ZBUF_ENABLED;
376 }
377 }
378 //Added by Gonetz
379 if (rdp.cmd1 & 0x00010000) // Fog enable
380 {
381 if (rdp.flags & FOG_ENABLED)
382 {
383 rdp.flags ^= FOG_ENABLED;
384 rdp.update |= UPDATE_FOG_ENABLED;
385 }
386 }
387 }
Graphic Plugin for a Nintendo64 emulator