2 Copyright (C) 2002 Rice1964
4 This program is free software; you can redistribute it and/or
5 modify it under the terms of the GNU General Public License
6 as published by the Free Software Foundation; either version 2
7 of the License, or (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
20 // A few ucode used in DKR and Others Special games
26 #include "osal_preproc.h"
28 uint32 dwConkerVtxZAddr=0;
30 static void RDP_GFX_DumpVtxInfoDKR(uint32 dwAddr, uint32 dwV0, uint32 dwN);
32 void RDP_GFX_DLInMem(Gfx *gfx)
34 uint32 dwLimit = ((gfx->words.w0) >> 16) & 0xFF;
35 uint32 dwPush = RSP_DLIST_PUSH; //((gfx->words.w0) >> 16) & 0xFF;
36 uint32 dwAddr = 0x00000000 | (gfx->words.w1); //RSPSegmentAddr((gfx->words.w1));
38 LOG_UCODE(" Address=0x%08x Push: 0x%02x", dwAddr, dwPush);
43 LOG_UCODE(" Pushing DisplayList 0x%08x", dwAddr);
45 gDlistStack[gDlistStackPointer].pc = dwAddr;
46 gDlistStack[gDlistStackPointer].countdown = dwLimit;
49 case RSP_DLIST_NOPUSH:
50 LOG_UCODE(" Jumping to DisplayList 0x%08x", dwAddr);
51 gDlistStack[gDlistStackPointer].pc = dwAddr;
52 gDlistStack[gDlistStackPointer].countdown = dwLimit;
57 LOG_UCODE("\\/ \\/ \\/ \\/ \\/ \\/ \\/ \\/ \\/ \\/ \\/ \\/ \\/ \\/ \\/");
58 LOG_UCODE("#############################################");
61 extern Matrix ALIGN(16, dkrMatrixTransposed)
62 void RSP_Mtx_DKR(Gfx *gfx)
64 uint32 dwAddr = RSPSegmentAddr((gfx->words.w1));
65 uint32 dwCommand = ((gfx->words.w0)>>16)&0xFF;
66 //uint32 dwLength = ((gfx->words.w0)) &0xFFFF;
68 dwAddr = (gfx->words.w1)+RSPSegmentAddr(gRSP.dwDKRMatrixAddr);
70 //gRSP.DKRCMatrixIndex = ((gfx->words.w0)>>22)&3;
76 gRSP.DKRCMatrixIndex = index = 3;
79 gRSP.DKRCMatrixIndex = index = 2;
82 gRSP.DKRCMatrixIndex = index = 1;
85 gRSP.DKRCMatrixIndex = index = 0;
88 gRSP.DKRCMatrixIndex = index = 0;
92 gRSP.DKRCMatrixIndex = index = 1;
96 gRSP.DKRCMatrixIndex = index = 2;
100 gRSP.DKRCMatrixIndex = index = 3;
115 DebuggerAppendMsg("Fix me, mtx DKR, cmd=%08X", dwCommand);
119 // Load matrix from dwAddr
120 Matrix &mat = gRSP.DKRMatrixes[index];
125 mat = matToLoad*gRSP.DKRMatrixes[0];
132 if( status.isSSEEnabled )
133 MatrixTranspose(&dkrMatrixTransposed, &mat);
135 DEBUGGER_IF_DUMP(logMatrix,TRACE3("DKR Matrix: cmd=0x%X, idx = %d, mul=%d", dwCommand, index, mul));
136 LOG_UCODE(" DKR Loading Mtx: %d, command=%d", index, dwCommand);
137 DEBUGGER_PAUSE_AND_DUMP(NEXT_MATRIX_CMD,{TRACE0("Paused at DKR Matrix Cmd");});
140 void RSP_Vtx_DKR(Gfx *gfx)
142 uint32 dwAddr = RSPSegmentAddr((gfx->words.w1));
143 uint32 dwV0 = (((gfx->words.w0) >> 9 )&0x1F);
144 uint32 dwN = (((gfx->words.w0) >>19 )&0x1F)+1;
146 if( gfx->words.w0 & 0x00010000 )
148 if( gRSP.DKRBillBoard )
149 gRSP.DKRVtxCount = 1;
153 gRSP.DKRVtxCount = 0;
156 dwV0 += gRSP.DKRVtxCount;
158 LOG_UCODE(" Address 0x%08x, v0: %d, Num: %d", dwAddr, dwV0, dwN);
159 DEBUGGER_ONLY_IF( (pauseAtNext && (eventToPause==NEXT_VERTEX_CMD||eventToPause==NEXT_MATRIX_CMD)), {DebuggerAppendMsg("DKR Vtx: Cmd0=%08X, Cmd1=%08X", (gfx->words.w0), (gfx->words.w1));});
161 VTX_DUMP(TRACE2("Vtx_DKR, cmd0=%08X cmd1=%08X", (gfx->words.w0), (gfx->words.w1)));
162 VTX_DUMP(TRACE2("Vtx_DKR, v0=%d n=%d", dwV0, dwN));
167 if ((dwV0 + dwN) > 32)
169 WARNING(TRACE0("Warning, attempting to load into invalid vertex positions"));
174 //if( dwAddr == 0 || dwAddr < 0x2000)
176 dwAddr = (gfx->words.w1)+RSPSegmentAddr(gRSP.dwDKRVtxAddr);
179 // Check that address is valid...
180 if ((dwAddr + (dwN*16)) > g_dwRamSize)
182 WARNING(TRACE1("ProcessVertexData: Address out of range (0x%08x)", dwAddr));
186 ProcessVertexDataDKR(dwAddr, dwV0, dwN);
188 status.dwNumVertices += dwN;
190 RDP_GFX_DumpVtxInfoDKR(dwAddr, dwV0, dwN);
195 void RSP_Vtx_Gemini(Gfx *gfx)
197 uint32 dwAddr = RSPSegmentAddr((gfx->words.w1));
198 uint32 dwV0 = (((gfx->words.w0)>>9)&0x1F);
199 uint32 dwN = (((gfx->words.w0) >>19 )&0x1F);
201 LOG_UCODE(" Address 0x%08x, v0: %d, Num: %d", dwAddr, dwV0, dwN);
202 DEBUGGER_ONLY_IF( (pauseAtNext && (eventToPause==NEXT_VERTEX_CMD||eventToPause==NEXT_MATRIX_CMD)), {DebuggerAppendMsg("DKR Vtx: Cmd0=%08X, Cmd1=%08X", (gfx->words.w0), (gfx->words.w1));});
204 VTX_DUMP(TRACE2("Vtx_DKR, cmd0=%08X cmd1=%08X", (gfx->words.w0), (gfx->words.w1)));
209 if ((dwV0 + dwN) > 32)
211 TRACE0("Warning, attempting to load into invalid vertex positions");
216 //if( dwAddr == 0 || dwAddr < 0x2000)
218 dwAddr = (gfx->words.w1)+RSPSegmentAddr(gRSP.dwDKRVtxAddr);
221 // Check that address is valid...
222 if ((dwAddr + (dwN*16)) > g_dwRamSize)
224 TRACE1("ProcessVertexData: Address out of range (0x%08x)", dwAddr);
228 ProcessVertexDataDKR(dwAddr, dwV0, dwN);
230 status.dwNumVertices += dwN;
232 RDP_GFX_DumpVtxInfoDKR(dwAddr, dwV0, dwN);
236 // DKR verts are extra 4 bytes
237 void RDP_GFX_DumpVtxInfoDKR(uint32 dwAddr, uint32 dwV0, uint32 dwN)
243 short * psSrc = (short *)(g_pRDRAMu8 + dwAddr);
246 for (dwV = dwV0; dwV < dwV0 + dwN; dwV++)
248 float x = (float)psSrc[(i + 0) ^ 1];
249 float y = (float)psSrc[(i + 1) ^ 1];
250 float z = (float)psSrc[(i + 2) ^ 1];
252 //uint16 wFlags = CRender::g_pRender->m_dwVecFlags[dwV]; //(uint16)psSrc[3^0x1];
254 uint16 wA = psSrc[(i + 3) ^ 1];
255 uint16 wB = psSrc[(i + 4) ^ 1];
262 XVECTOR4 & t = g_vecProjected[dwV];
265 LOG_UCODE(" #%02d Pos: {% 6f,% 6f,% 6f} Extra: %02x %02x %02x %02x (transf: {% 6f,% 6f,% 6f})",
266 dwV, x, y, z, a, b, c, d, t.x, t.y, t.z );
272 uint16 * pwSrc = (uint16 *)(g_pRDRAMu8 + dwAddr);
274 for (dwV = dwV0; dwV < dwV0 + dwN; dwV++)
276 LOG_UCODE(" #%02d %04x %04x %04x %04x %04x",
277 dwV, pwSrc[(i + 0) ^ 1],
289 void DLParser_Set_Addr_Ucode6(Gfx *gfx)
291 gRSP.dwDKRMatrixAddr = (gfx->words.w0)&0x00FFFFFF;
292 gRSP.dwDKRVtxAddr = (gfx->words.w1)&0x00FFFFFF;
298 void RSP_Vtx_WRUS(Gfx *gfx)
300 uint32 dwAddr = RSPSegmentAddr((gfx->words.w1));
301 uint32 dwLength = ((gfx->words.w0))&0xFFFF;
303 uint32 dwN= (dwLength + 1) / 0x210;
304 //uint32 dwN= (dwLength >> 9);
305 //uint32 dwV0 = (((gfx->words.w0)>>16)&0x3f)/5;
306 uint32 dwV0 = (((gfx->words.w0)>>16)&0xFF)/5;
308 LOG_UCODE(" Address 0x%08x, v0: %d, Num: %d, Length: 0x%04x", dwAddr, dwV0, dwN, dwLength);
313 if ((dwV0 + dwN) > 32)
315 TRACE0("Warning, attempting to load into invalid vertex positions");
319 ProcessVertexData(dwAddr, dwV0, dwN);
321 status.dwNumVertices += dwN;
323 DisplayVertexInfo(dwAddr, dwV0, dwN);
326 void RSP_Vtx_ShadowOfEmpire(Gfx *gfx)
328 uint32 dwAddr = RSPSegmentAddr((gfx->words.w1));
329 uint32 dwLength = ((gfx->words.w0))&0xFFFF;
331 uint32 dwN= (((gfx->words.w0) >> 4) & 0xFFF) / 33 + 1;
334 LOG_UCODE(" Address 0x%08x, v0: %d, Num: %d, Length: 0x%04x", dwAddr, dwV0, dwN, dwLength);
339 if ((dwV0 + dwN) > 32)
341 TRACE0("Warning, attempting to load into invalid vertex positions");
345 ProcessVertexData(dwAddr, dwV0, dwN);
347 status.dwNumVertices += dwN;
349 DisplayVertexInfo(dwAddr, dwV0, dwN);
353 void RSP_DL_In_MEM_DKR(Gfx *gfx)
355 // This cmd is likely to execute number of ucode at the given address
356 uint32 dwAddr = (gfx->words.w1);//RSPSegmentAddr((gfx->words.w1));
358 gDlistStackPointer++;
359 gDlistStack[gDlistStackPointer].pc = dwAddr;
360 gDlistStack[gDlistStackPointer].countdown = (((gfx->words.w0)>>16)&0xFF);
363 uint16 ConvertYUVtoR5G5B5X1(int y, int u, int v)
365 float r = y + (1.370705f * (v-128));
366 float g = y - (0.698001f * (v-128)) - (0.337633f * (u-128));
367 float b = y + (1.732446f * (u-128));
372 //clipping the result
380 uint16 c = (uint16)(((uint16)(r) << 11) |
382 ((uint16)(b) << 1) | 1);
386 void TexRectToN64FrameBuffer_YUV_16b(uint32 x0, uint32 y0, uint32 width, uint32 height)
388 // Convert YUV image at TImg and Copy the texture into the N64 RDRAM framebuffer memory
390 uint32 n64CIaddr = g_CI.dwAddr;
391 uint32 n64CIwidth = g_CI.dwWidth;
393 for (uint32 y = 0; y < height; y++)
395 uint32* pN64Src = (uint32*)(g_pRDRAMu8+(g_TI.dwAddr&(g_dwRamSize-1)))+y*(g_TI.dwWidth>>1);
396 uint16* pN64Dst = (uint16*)(g_pRDRAMu8+(n64CIaddr&(g_dwRamSize-1)))+(y+y0)*n64CIwidth;
398 for (uint32 x = 0; x < width; x+=2)
400 uint32 val = *pN64Src++;
401 int y0 = (uint8)val&0xFF;
402 int v = (uint8)(val>>8)&0xFF;
403 int y1 = (uint8)(val>>16)&0xFF;
404 int u = (uint8)(val>>24)&0xFF;
406 pN64Dst[x+x0] = ConvertYUVtoR5G5B5X1(y0,u,v);
407 pN64Dst[x+x0+1] = ConvertYUVtoR5G5B5X1(y1,u,v);
412 extern uObjMtxReal gObjMtxReal;
413 void DLParser_OgreBatter64BG(Gfx *gfx)
416 uint32 dwAddr = RSPSegmentAddr((gfx->words.w1));
417 uObjTxSprite *ptr = (uObjTxSprite*)(g_pRDRAMu8+dwAddr);
422 CTexture *ptexture = g_textures[0].m_pCTexture;
423 TexRectToN64FrameBuffer_16b( (uint32)gObjMtxReal.X, (uint32)gObjMtxReal.Y, ptexture->m_dwWidth, ptexture->m_dwHeight, gRSP.curTile);
426 CRender::g_pRender->DrawSpriteR(*ptr, false);
428 DEBUGGER_PAUSE_AT_COND_AND_DUMP_COUNT_N((pauseAtNext &&
429 (eventToPause==NEXT_OBJ_TXT_CMD|| eventToPause==NEXT_FLUSH_TRI)),
430 {DebuggerAppendMsg("OgreBatter 64 BG: Addr=%08X\n", dwAddr);});
434 void DLParser_Bomberman2TextRect(Gfx *gfx)
436 // Bomberman 64 - The Second Attack! (U) [!]
437 // The 0x02 cmd, list a TexRect cmd
439 if( options.enableHackForGames == HACK_FOR_OGRE_BATTLE && gRDP.tiles[7].dwFormat == TXT_FMT_YUV )
441 TexRectToN64FrameBuffer_YUV_16b( (uint32)gObjMtxReal.X, (uint32)gObjMtxReal.Y, 16, 16);
442 //DLParser_OgreBatter64BG((gfx->words.w0), (gfx->words.w1));
446 uint32 dwAddr = RSPSegmentAddr((gfx->words.w1));
447 uObjSprite *info = (uObjSprite*)(g_pRDRAMu8+dwAddr);
449 uint32 dwTile = gRSP.curTile;
453 //CRender::g_pRender->SetCombinerAndBlender();
455 uObjTxSprite drawinfo;
456 memcpy( &(drawinfo.sprite), info, sizeof(uObjSprite));
457 CRender::g_pRender->DrawSpriteR(drawinfo, false, dwTile, 0, 0, drawinfo.sprite.imageW/32, drawinfo.sprite.imageH/32);
459 DEBUGGER_PAUSE_AT_COND_AND_DUMP_COUNT_N((pauseAtNext && (eventToPause==NEXT_TRIANGLE|| eventToPause==NEXT_FLUSH_TRI)),
461 DebuggerAppendMsg("Bomberman 64 - TextRect: Addr=%08X\n", dwAddr);
462 dwAddr &= (g_dwRamSize-1);
463 DebuggerAppendMsg("%08X-%08X-%08X-%08X-%08X-%08X\n", RDRAM_UWORD(dwAddr), RDRAM_UWORD(dwAddr+4),
464 RDRAM_UWORD(dwAddr+8), RDRAM_UWORD(dwAddr+12), RDRAM_UWORD(dwAddr+16), RDRAM_UWORD(dwAddr+20) );
470 void RSP_MoveWord_DKR(Gfx *gfx)
472 SP_Timing(RSP_GBI1_MoveWord);
475 switch ((gfx->words.w0) & 0xFF)
477 case RSP_MOVE_WORD_NUMLIGHT:
478 dwNumLights = (gfx->words.w1)&0x7;
479 LOG_UCODE(" RSP_MOVE_WORD_NUMLIGHT: Val:%d", dwNumLights);
481 gRSP.ambientLightIndex = dwNumLights;
482 SetNumLights(dwNumLights);
483 //gRSP.DKRBillBoard = (gfx->words.w1)&0x1 ? true : false;
484 gRSP.DKRBillBoard = (gfx->words.w1)&0x7 ? true : false;
486 LOG_UCODE(" gRSP.DKRBillBoard = %d", gRSP.DKRBillBoard);
487 DEBUGGER_PAUSE_AND_DUMP_COUNT_N(NEXT_MATRIX_CMD, {DebuggerAppendMsg("DKR Moveword, select gRSP.DKRBillBoard %s, cmd0=%08X, cmd1=%08X", gRSP.DKRBillBoard?"true":"false", (gfx->words.w0), (gfx->words.w1));});
489 case RSP_MOVE_WORD_LIGHTCOL:
490 gRSP.DKRCMatrixIndex = ((gfx->words.w1)>>6)&7;
491 //gRSP.DKRCMatrixIndex = ((gfx->words.w1)>>6)&3;
492 LOG_UCODE(" gRSP.DKRCMatrixIndex = %d", gRSP.DKRCMatrixIndex);
493 DEBUGGER_PAUSE_AND_DUMP_COUNT_N(NEXT_MATRIX_CMD, {DebuggerAppendMsg("DKR Moveword, select matrix %d, cmd0=%08X, cmd1=%08X", gRSP.DKRCMatrixIndex, (gfx->words.w0), (gfx->words.w1));});
496 RSP_GBI1_MoveWord(gfx);
502 void RSP_DMA_Tri_DKR(Gfx *gfx)
504 BOOL bTrisAdded = FALSE;
505 uint32 dwAddr = RSPSegmentAddr((gfx->words.w1));
506 uint32 flag = ((gfx->words.w0) & 0xFF0000) >> 16;
508 CRender::g_pRender->SetCullMode(false,true);
510 CRender::g_pRender->SetCullMode(false,false);
512 uint32 dwNum = (((gfx->words.w0) & 0xFFF0) >>4 );
513 uint32 * pData = (uint32*)&g_pRDRAMu32[dwAddr/4];
515 if( dwAddr+16*dwNum >= g_dwRamSize )
517 TRACE0("DMATRI invalid memory pointer");
521 TRI_DUMP(TRACE2("DMATRI, addr=%08X, Cmd0=%08X\n", dwAddr, (gfx->words.w0)));
523 status.primitiveType = PRIM_DMA_TRI;
525 for (uint32 i = 0; i < dwNum; i++)
527 LOG_UCODE(" 0x%08x: %08x %08x %08x %08x", dwAddr + i*16,
528 pData[0], pData[1], pData[2], pData[3]);
530 uint32 dwInfo = pData[0];
532 uint32 dwV0 = (dwInfo >> 16) & 0x1F;
533 uint32 dwV1 = (dwInfo >> 8) & 0x1F;
534 uint32 dwV2 = (dwInfo ) & 0x1F;
536 TRI_DUMP(TRACE5("DMATRI: %d, %d, %d (%08X-%08X)", dwV0,dwV1,dwV2,(gfx->words.w0),(gfx->words.w1)));
538 //if (IsTriangleVisible(dwV0, dwV1, dwV2))
540 DEBUG_DUMP_VERTEXES("DmaTri", dwV0, dwV1, dwV2);
541 LOG_UCODE(" Tri: %d,%d,%d", dwV0, dwV1, dwV2);
542 if (!bTrisAdded )//&& CRender::g_pRender->IsTextureEnabled())
545 InitVertexTextureConstants();
548 // Generate texture coordinates
549 short s0 = ((short)(pData[1]>>16));
550 short t0 = ((short)(pData[1]&0xFFFF));
551 short s1 = ((short)(pData[2]>>16));
552 short t1 = ((short)(pData[2]&0xFFFF));
553 short s2 = ((short)(pData[3]>>16));
554 short t2 = ((short)(pData[3]&0xFFFF));
558 DebuggerAppendMsg(" (%d,%d), (%d,%d), (%d,%d)",s0,t0,s1,t1,s2,t2);
559 DebuggerAppendMsg(" (%08X), (%08X), (%08X), (%08X)",pData[0],pData[1],pData[2],pData[3]);
561 CRender::g_pRender->SetVtxTextureCoord(dwV0, s0, t0);
562 CRender::g_pRender->SetVtxTextureCoord(dwV1, s1, t1);
563 CRender::g_pRender->SetVtxTextureCoord(dwV2, s2, t2);
567 CRender::g_pRender->SetCombinerAndBlender();
571 PrepareTriangle(dwV0, dwV1, dwV2);
580 CRender::g_pRender->DrawTriangles();
585 uint32 dwPDCIAddr = 0;
586 void ProcessVertexDataPD(uint32 dwAddr, uint32 dwV0, uint32 dwNum);
587 void RSP_Vtx_PD(Gfx *gfx)
589 SP_Timing(RSP_GBI0_Vtx);
591 uint32 dwAddr = RSPSegmentAddr((gfx->words.w1));
592 uint32 dwV0 = ((gfx->words.w0)>>16)&0x0F;
593 uint32 dwN = (((gfx->words.w0)>>20)&0x0F)+1;
594 //uint32 dwLength = ((gfx->words.w0))&0xFFFF;
596 LOG_UCODE(" Address 0x%08x, v0: %d, Num: %d", dwAddr, dwV0, dwN);
598 ProcessVertexDataPD(dwAddr, dwV0, dwN);
599 status.dwNumVertices += dwN;
602 void RSP_Set_Vtx_CI_PD(Gfx *gfx)
604 // Color index buf address
605 dwPDCIAddr = RSPSegmentAddr((gfx->words.w1));
608 void RSP_Tri4_PD(Gfx *gfx)
610 uint32 w0 = gfx->words.w0;
611 uint32 w1 = gfx->words.w1;
613 status.primitiveType = PRIM_TRI2;
615 // While the next command pair is Tri2, add vertices
616 uint32 dwPC = gDlistStack[gDlistStackPointer].pc;
618 BOOL bTrisAdded = FALSE;
621 uint32 dwFlag = (w0>>16)&0xFF;
622 LOG_UCODE(" PD Tri4: 0x%08x 0x%08x Flag: 0x%02x", w0, w1, dwFlag);
625 for( uint32 i=0; i<4; i++)
627 uint32 v0 = (w1>>(4+(i<<3))) & 0xF;
628 uint32 v1 = (w1>>( (i<<3))) & 0xF;
629 uint32 v2 = (w0>>( (i<<2))) & 0xF;
630 bVisible = IsTriangleVisible(v0, v2, v1);
631 LOG_UCODE(" (%d, %d, %d) %s", v0, v1, v2, bVisible ? "": "(clipped)");
634 DEBUG_DUMP_VERTEXES("Tri4_PerfectDark 1/2", v0, v1, v2);
635 if (!bTrisAdded && CRender::g_pRender->IsTextureEnabled())
638 InitVertexTextureConstants();
643 CRender::g_pRender->SetCombinerAndBlender();
647 PrepareTriangle(v0, v2, v1);
651 w0 = *(uint32 *)(g_pRDRAMu8 + dwPC+0);
652 w1 = *(uint32 *)(g_pRDRAMu8 + dwPC+4);
656 } while (!(pauseAtNext && eventToPause==NEXT_TRIANGLE) && (w0>>24) == (uint8)RSP_TRI2);
658 } while ((w0>>24) == (uint8)RSP_TRI2);
661 gDlistStack[gDlistStackPointer].pc = dwPC-8;
665 CRender::g_pRender->DrawTriangles();
668 DEBUG_TRIANGLE(TRACE0("Pause at PD Tri4"));
672 void DLParser_Tri4_Conker(Gfx *gfx)
674 uint32 w0 = gfx->words.w0;
675 uint32 w1 = gfx->words.w1;
677 status.primitiveType = PRIM_TRI2;
679 // While the next command pair is Tri2, add vertices
680 uint32 dwPC = gDlistStack[gDlistStackPointer].pc;
682 BOOL bTrisAdded = FALSE;
685 LOG_UCODE(" Conker Tri4: 0x%08x 0x%08x", w0, w1);
688 idx[1] = (w1>> 5)&0x1F;
689 idx[2] = (w1>>10)&0x1F;
690 idx[3] = (w1>>15)&0x1F;
691 idx[4] = (w1>>20)&0x1F;
692 idx[5] = (w1>>25)&0x1F;
695 idx[7] = (w0>> 5)&0x1F;
696 idx[8] = (w0>>10)&0x1F;
698 idx[ 9] = (((w0>>15)&0x7)<<2)|(w1>>30);
699 idx[10] = (w0>>18)&0x1F;
700 idx[11] = (w0>>23)&0x1F;
703 for( uint32 i=0; i<4; i++)
706 uint32 v1=idx[i*3+1];
707 uint32 v2=idx[i*3+2];
708 bVisible = IsTriangleVisible(v0, v1, v2);
709 LOG_UCODE(" (%d, %d, %d) %s", v0, v1, v2, bVisible ? "": "(clipped)");
712 DEBUG_DUMP_VERTEXES("Tri4 Conker:", v0, v1, v2);
713 if (!bTrisAdded && CRender::g_pRender->IsTextureEnabled())
716 InitVertexTextureConstants();
721 CRender::g_pRender->SetCombinerAndBlender();
725 PrepareTriangle(v0, v1, v2);
729 w0 = *(uint32 *)(g_pRDRAMu8 + dwPC+0);
730 w1 = *(uint32 *)(g_pRDRAMu8 + dwPC+4);
734 } while (!(pauseAtNext && eventToPause==NEXT_TRIANGLE) && (w0>>28) == 1 );
736 } while ((w0>>28) == 1);
739 gDlistStack[gDlistStackPointer].pc = dwPC-8;
743 CRender::g_pRender->DrawTriangles();
746 DEBUG_TRIANGLE(TRACE0("Pause at Conker Tri4"));
749 void RDP_GFX_Force_Vertex_Z_Conker(uint32 dwAddr)
753 s8 * pcBase = g_pRDRAMs8 + (dwAddr&(g_dwRamSize-1));
754 uint32 * pdwBase = (uint32 *)pcBase;
756 for (int i = 0; i < 4; i++)
758 DebuggerAppendMsg(" %08x %08x %08x %08x", pdwBase[0], pdwBase[1], pdwBase[2], pdwBase[3]);
763 dwConkerVtxZAddr = dwAddr;
764 DEBUGGER_PAUSE_AND_DUMP(NEXT_VERTEX_CMD,{TRACE0("Paused at RDP_GFX_Force_Matrix_Conker Cmd");});
769 void DLParser_MoveMem_Conker(Gfx *gfx)
771 uint32 dwType = ((gfx->words.w0) ) & 0xFE;
772 uint32 dwAddr = RSPSegmentAddr((gfx->words.w1));
773 if( dwType == RSP_GBI2_MV_MEM__MATRIX )
775 LOG_UCODE(" DLParser_MoveMem_Conker");
776 RDP_GFX_Force_Vertex_Z_Conker(dwAddr);
778 else if( dwType == RSP_GBI2_MV_MEM__LIGHT )
780 LOG_UCODE(" MoveMem Light Conker");
781 uint32 dwOffset2 = ((gfx->words.w0) >> 5) & 0x3FFF;
783 if( dwOffset2 >= 0x30 )
785 dwLight = (dwOffset2 - 0x30)/0x30;
786 LOG_UCODE(" Light %d:", dwLight);
787 RSP_MoveMemLight(dwLight, dwAddr);
792 //TRACE0("Check me in DLParser_MoveMem_Conker - MoveMem Light");
794 DEBUGGER_PAUSE_AND_DUMP_COUNT_N( NEXT_SET_LIGHT,
796 DebuggerAppendMsg("RSP_MoveMemLight: %d, Addr=%08X, cmd0=%08X", dwLight, dwAddr, (gfx->words.w0));
797 TRACE0("Pause after MoveMemLight");
802 RSP_GBI2_MoveMem(gfx);
806 extern void ProcessVertexDataConker(uint32 dwAddr, uint32 dwV0, uint32 dwNum);
807 void RSP_Vtx_Conker(Gfx *gfx)
809 uint32 dwAddr = RSPSegmentAddr((gfx->words.w1));
810 uint32 dwVEnd = (((gfx->words.w0) )&0xFFF)/2;
811 uint32 dwN = (((gfx->words.w0)>>12)&0xFFF);
812 uint32 dwV0 = dwVEnd - dwN;
814 LOG_UCODE(" Vtx: Address 0x%08x, vEnd: %d, v0: %d, Num: %d", dwAddr, dwVEnd, dwV0, dwN);
816 ProcessVertexDataConker(dwAddr, dwV0, dwN);
817 status.dwNumVertices += dwN;
818 DisplayVertexInfo(dwAddr, dwV0, dwN);
822 void DLParser_MoveWord_Conker(Gfx *gfx)
824 uint32 dwType = ((gfx->words.w0) >> 16) & 0xFF;
825 if( dwType != RSP_MOVE_WORD_NUMLIGHT )
827 RSP_GBI2_MoveWord(gfx);
831 uint32 dwNumLights = ((gfx->words.w1)/48);
832 LOG_UCODE("Conker RSP_MOVE_WORD_NUMLIGHT: %d", dwNumLights);
833 gRSP.ambientLightIndex = dwNumLights+1;
834 SetNumLights(dwNumLights);
835 DEBUGGER_PAUSE_AND_DUMP_COUNT_N( NEXT_SET_LIGHT,
837 DebuggerAppendMsg("SetNumLights: %d", dwNumLights);
838 TRACE0("Pause after SetNumLights");
843 void DLParser_Ucode8_0x0(Gfx *gfx)
845 LOG_UCODE("DLParser_Ucode8_0x0");
847 if( (gfx->words.w0) == 0 && (gfx->words.w1) )
849 uint32 newaddr = RSPSegmentAddr((gfx->words.w1));
851 if( newaddr && newaddr < g_dwRamSize)
853 if( gDlistStackPointer < MAX_DL_STACK_SIZE-1 )
855 gDlistStackPointer++;
856 gDlistStack[gDlistStackPointer].pc = newaddr+8; // Always skip the first 2 entries
857 gDlistStack[gDlistStackPointer].countdown = MAX_DL_COUNT;
861 DebuggerAppendMsg("Error, gDlistStackPointer overflow");
867 LOG_UCODE("DLParser_Ucode8_0x0, skip 0x%08X, 0x%08x", (gfx->words.w0), (gfx->words.w1));
868 gDlistStack[gDlistStackPointer].pc += 8;
873 uint32 Rogue_Squadron_Vtx_XYZ_Cmd;
874 uint32 Rogue_Squadron_Vtx_XYZ_Addr;
875 uint32 Rogue_Squadron_Vtx_Color_Cmd;
876 uint32 Rogue_Squadron_Vtx_Color_Addr;
877 uint32 GSBlkAddrSaves[100][2];
879 void ProcessVertexData_Rogue_Squadron(uint32 dwXYZAddr, uint32 dwColorAddr, uint32 dwXYZCmd, uint32 dwColorCmd);
881 void DLParser_RS_Color_Buffer(Gfx *gfx)
883 uint32 dwPC = gDlistStack[gDlistStackPointer].pc-8;
884 uint32 dwAddr = RSPSegmentAddr((gfx->words.w1));
886 if( dwAddr > g_dwRamSize )
888 TRACE0("DL, addr is wrong");
889 dwAddr = (gfx->words.w1)&(g_dwRamSize-1);
892 Rogue_Squadron_Vtx_Color_Cmd = (gfx->words.w0);
893 Rogue_Squadron_Vtx_Color_Addr = dwAddr;
895 LOG_UCODE("Vtx_Color at PC=%08X: 0x%08x 0x%08x\n", dwPC-8, (gfx->words.w0), (gfx->words.w1));
897 if( pauseAtNext && (eventToPause == NEXT_VERTEX_CMD ) )
899 DebuggerAppendMsg("Vtx_Color at PC=%08X: 0x%08x 0x%08x\n", dwPC-8, (gfx->words.w0), (gfx->words.w1));
900 if( dwAddr < g_dwRamSize )
902 DumpHex(dwAddr, min(64, g_dwRamSize-dwAddr));
907 ProcessVertexData_Rogue_Squadron(Rogue_Squadron_Vtx_XYZ_Addr, Rogue_Squadron_Vtx_Color_Addr, Rogue_Squadron_Vtx_XYZ_Cmd, Rogue_Squadron_Vtx_Color_Cmd);
912 void DLParser_RS_Vtx_Buffer(Gfx *gfx)
914 uint32 dwPC = gDlistStack[gDlistStackPointer].pc-8;
915 uint32 dwAddr = RSPSegmentAddr((gfx->words.w1));
916 if( dwAddr > g_dwRamSize )
918 TRACE0("DL, addr is wrong");
919 dwAddr = (gfx->words.w1)&(g_dwRamSize-1);
922 LOG_UCODE("Vtx_XYZ at PC=%08X: 0x%08x 0x%08x\n", dwPC-8, (gfx->words.w0), (gfx->words.w1));
923 Rogue_Squadron_Vtx_XYZ_Cmd = (gfx->words.w0);
924 Rogue_Squadron_Vtx_XYZ_Addr = dwAddr;
927 if( pauseAtNext && (eventToPause == NEXT_VERTEX_CMD ) )
929 DebuggerAppendMsg("Vtx_XYZ at PC=%08X: 0x%08x 0x%08x\n", dwPC-8, (gfx->words.w0), (gfx->words.w1));
930 if( dwAddr < g_dwRamSize )
932 DumpHex(dwAddr, min(64, g_dwRamSize-dwAddr));
939 void DLParser_RS_Block(Gfx *gfx)
941 uint32 dwPC = gDlistStack[gDlistStackPointer].pc-8;
942 LOG_UCODE("ucode 0x80 at PC=%08X: 0x%08x 0x%08x\n", dwPC, (gfx->words.w0), (gfx->words.w1));
945 void DLParser_RS_MoveMem(Gfx *gfx)
947 //uint32 dwPC = gDlistStack[gDlistStackPointer].pc;
948 //uint32 cmd1 = ((dwPC)&0x00FFFFFF)|0x80000000;
949 RSP_GBI1_MoveMem(gfx);
951 LOG_UCODE("RS_MoveMem", ((gfx->words.w0)>>24));
952 LOG_UCODE("\tPC=%08X: 0x%08x 0x%08x", dwPC, (gfx->words.w0), (gfx->words.w1));
954 uint32 dwCmd2 = *(uint32 *)(g_pRDRAMu8 + dwPC);
955 uint32 dwCmd3 = *(uint32 *)(g_pRDRAMu8 + dwPC+4);
956 LOG_UCODE("\tPC=%08X: 0x%08x 0x%08x", dwPC, dwCmd2, dwCmd3);
958 uint32 dwCmd4 = *(uint32 *)(g_pRDRAMu8 + dwPC);
959 uint32 dwCmd5 = *(uint32 *)(g_pRDRAMu8 + dwPC+4);
960 LOG_UCODE("\tPC=%08X: 0x%08x 0x%08x\n", dwPC, dwCmd4, dwCmd5);
962 gDlistStack[gDlistStackPointer].pc += 16;
964 //DEBUGGER_PAUSE_AND_DUMP(NEXT_SET_MODE_CMD, {
965 // DebuggerAppendMsg("Pause after RS_MoveMem at: %08X\n", dwPC-8);
970 void DLParser_RS_0xbe(Gfx *gfx)
972 uint32 dwPC = gDlistStack[gDlistStackPointer].pc-8;
973 LOG_UCODE("ucode %02X, skip 1", ((gfx->words.w0)>>24));
974 LOG_UCODE("\tPC=%08X: 0x%08x 0x%08x", dwPC, (gfx->words.w0), (gfx->words.w1));
976 uint32 dwCmd2 = *(uint32 *)(g_pRDRAMu8 + dwPC);
977 uint32 dwCmd3 = *(uint32 *)(g_pRDRAMu8 + dwPC+4);
978 LOG_UCODE("\tPC=%08X: 0x%08x 0x%08x\n", dwPC, dwCmd2, dwCmd3);
979 gDlistStack[gDlistStackPointer].pc += 8;
981 DEBUGGER_PAUSE_AND_DUMP(NEXT_SET_MODE_CMD, {
982 DebuggerAppendMsg("Pause after RS_0xbe at: %08X\n", dwPC-8);
983 DebuggerAppendMsg("\t0x%08x 0x%08x", (gfx->words.w0), (gfx->words.w1));
984 DebuggerAppendMsg("\t0x%08x 0x%08x", dwCmd2, dwCmd3);
989 void DLParser_Ucode8_EndDL(Gfx *gfx)
992 uint32 dwPC = gDlistStack[gDlistStackPointer].pc-8;
996 DEBUGGER_PAUSE_AND_DUMP(NEXT_DLIST, DebuggerAppendMsg("PC=%08X: EndDL, return to %08X\n\n", dwPC, gDlistStack[gDlistStackPointer].pc));
999 void DLParser_Ucode8_DL(Gfx *gfx) // DL Function Call
1002 uint32 dwPC = gDlistStack[gDlistStackPointer].pc-8;
1005 uint32 dwAddr = RSPSegmentAddr((gfx->words.w1));
1006 uint32 dwCmd2 = *(uint32 *)(g_pRDRAMu8 + dwAddr);
1007 uint32 dwCmd3 = *(uint32 *)(g_pRDRAMu8 + dwAddr+4);
1009 if( dwAddr > g_dwRamSize )
1011 TRACE0("DL, addr is wrong");
1012 dwAddr = (gfx->words.w1)&(g_dwRamSize-1);
1016 /*if(gDlistStackPointer>0 )
1018 for( int i=0; i<gDlistStackPointer; i++ )
1020 if(gDlistStack[i].addr == dwAddr+8)
1022 TRACE1("Detected DL looping, PC=%08X", dwPC );
1023 DLParser_Ucode8_EndDL(0,0);
1029 if( gDlistStackPointer < MAX_DL_STACK_SIZE-1 )
1031 gDlistStackPointer++;
1032 gDlistStack[gDlistStackPointer].pc = dwAddr+16;
1033 gDlistStack[gDlistStackPointer].countdown = MAX_DL_COUNT;
1037 DebuggerAppendMsg("Error, gDlistStackPointer overflow");
1041 GSBlkAddrSaves[gDlistStackPointer][0]=GSBlkAddrSaves[gDlistStackPointer][1]=0;
1042 if( (dwCmd2>>24) == 0x80 )
1044 GSBlkAddrSaves[gDlistStackPointer][0] = dwCmd2;
1045 GSBlkAddrSaves[gDlistStackPointer][1] = dwCmd3;
1048 DEBUGGER_PAUSE_AND_DUMP(NEXT_DLIST,
1049 DebuggerAppendMsg("\nPC=%08X: Call DL at Address %08X - %08X, %08X\n\n",
1050 dwPC, dwAddr, dwCmd2, dwCmd3));
1053 void DLParser_Ucode8_JUMP(Gfx *gfx) // DL Function Call
1055 if( ((gfx->words.w0)&0x00FFFFFF) == 0 )
1058 uint32 dwPC = gDlistStack[gDlistStackPointer].pc-8;
1061 uint32 dwAddr = RSPSegmentAddr((gfx->words.w1));
1063 if( dwAddr > g_dwRamSize )
1065 TRACE0("DL, addr is wrong");
1066 dwAddr = (gfx->words.w1)&(g_dwRamSize-1);
1070 uint32 dwCmd2 = *(uint32 *)(g_pRDRAMu8 + dwAddr);
1071 uint32 dwCmd3 = *(uint32 *)(g_pRDRAMu8 + dwAddr+4);
1074 gDlistStack[gDlistStackPointer].pc = dwAddr+8; // Jump to new address
1075 DEBUGGER_PAUSE_AND_DUMP(NEXT_DLIST,
1076 DebuggerAppendMsg("\nPC=%08X: Jump to Address %08X - %08X, %08X\n\n", dwPC, dwAddr, dwCmd2, dwCmd3));
1080 uint32 dwPC = gDlistStack[gDlistStackPointer].pc-8;
1081 LOG_UCODE("ucode 0x07 at PC=%08X: 0x%08x 0x%08x\n", dwPC, (gfx->words.w0), (gfx->words.w1));
1085 void DLParser_Ucode8_Unknown(Gfx *gfx)
1087 uint32 dwPC = gDlistStack[gDlistStackPointer].pc-8;
1088 LOG_UCODE("ucode %02X at PC=%08X: 0x%08x 0x%08x\n", ((gfx->words.w0)>>24), dwPC, (gfx->words.w0), (gfx->words.w1));
1091 void DLParser_Unknown_Skip1(Gfx *gfx)
1093 uint32 dwPC = gDlistStack[gDlistStackPointer].pc-8;
1094 LOG_UCODE("ucode %02X, skip 1", ((gfx->words.w0)>>24));
1096 LOG_UCODE("\tPC=%08X: 0x%08x 0x%08x", dwPC, (gfx->words.w0), (gfx->words.w1));
1099 LOG_UCODE("\tPC=%08X: 0x%08x 0x%08x\n", dwPC, (gfx->words.w0), (gfx->words.w1));
1100 gDlistStack[gDlistStackPointer].pc += 8;
1103 void DLParser_Unknown_Skip2(Gfx *gfx)
1105 uint32 dwPC = gDlistStack[gDlistStackPointer].pc-8;
1106 LOG_UCODE("ucode %02X, skip 2", ((gfx->words.w0)>>24));
1108 LOG_UCODE("\tPC=%08X: 0x%08x 0x%08x", dwPC, (gfx->words.w0), (gfx->words.w1));
1111 LOG_UCODE("\tPC=%08X: 0x%08x 0x%08x", dwPC, (gfx->words.w0), (gfx->words.w1));
1114 LOG_UCODE("\tPC=%08X: 0x%08x 0x%08x\n", dwPC, (gfx->words.w0), (gfx->words.w1));
1115 gDlistStack[gDlistStackPointer].pc += 16;
1118 void DLParser_Unknown_Skip3(Gfx *gfx)
1120 uint32 dwPC = gDlistStack[gDlistStackPointer].pc-8;
1121 LOG_UCODE("ucode %02X, skip 3", ((gfx->words.w0)>>24));
1123 LOG_UCODE("\tPC=%08X: 0x%08x 0x%08x", dwPC, (gfx->words.w0), (gfx->words.w1));
1126 LOG_UCODE("\tPC=%08X: 0x%08x 0x%08x", dwPC, (gfx->words.w0), (gfx->words.w1));
1129 LOG_UCODE("\tPC=%08X: 0x%08x 0x%08x", dwPC, (gfx->words.w0), (gfx->words.w1));
1132 LOG_UCODE("\tPC=%08X: 0x%08x 0x%08x\n", dwPC, (gfx->words.w0), (gfx->words.w1));
1133 gDlistStack[gDlistStackPointer].pc += 24;
1136 void DLParser_Unknown_Skip4(Gfx *gfx)
1138 uint32 dwPC = gDlistStack[gDlistStackPointer].pc-8;
1139 LOG_UCODE("ucode %02X, skip 4", ((gfx->words.w0)>>24));
1141 LOG_UCODE("\tPC=%08X: 0x%08x 0x%08x", dwPC, (gfx->words.w0), (gfx->words.w1));
1144 LOG_UCODE("\tPC=%08X: 0x%08x 0x%08x", dwPC, (gfx->words.w0), (gfx->words.w1));
1147 LOG_UCODE("\tPC=%08X: 0x%08x 0x%08x", dwPC, (gfx->words.w0), (gfx->words.w1));
1150 LOG_UCODE("\tPC=%08X: 0x%08x 0x%08x", dwPC, (gfx->words.w0), (gfx->words.w1));
1153 LOG_UCODE("\tPC=%08X: 0x%08x 0x%08x\n", dwPC, (gfx->words.w0), (gfx->words.w1));
1154 gDlistStack[gDlistStackPointer].pc += 32;
1157 void DLParser_Ucode8_0x05(Gfx *gfx)
1159 // Be careful, 0x05 is variable length ucode
1161 0028E4E0: 05020088, 04D0000F - Reserved1
1162 0028E4E8: 6BDC0306, 00000000 - G_NOTHING
1163 0028E4F0: 05010130, 01B0000F - Reserved1
1164 0028E4F8: 918A01CA, 1EC5FF3B - G_NOTHING
1165 0028E500: 05088C68, F5021809 - Reserved1
1166 0028E508: 04000405, 00000000 - RSP_VTX
1167 0028E510: 102ECE60, 202F2AA0 - G_NOTHING
1168 0028E518: 05088C90, F5021609 - Reserved1
1169 0028E520: 04050405, F0F0F0F0 - RSP_VTX
1170 0028E528: 102ED0C0, 202F2D00 - G_NOTHING
1171 0028E530: B5000000, 00000000 - RSP_LINE3D
1172 0028E538: 8028E640, 8028E430 - G_NOTHING
1173 0028E540: 00000000, 00000000 - RSP_SPNOOP
1176 if((gfx->words.w1) == 0)
1179 DLParser_Unknown_Skip4(gfx);
1182 void DLParser_Ucode8_0xb4(Gfx *gfx)
1185 uint32 dwPC = gDlistStack[gDlistStackPointer].pc;
1188 if(((gfx->words.w0)&0xFF) == 0x06)
1189 DLParser_Unknown_Skip3(gfx);
1190 else if(((gfx->words.w0)&0xFF) == 0x04)
1191 DLParser_Unknown_Skip1(gfx);
1192 else if(((gfx->words.w0)&0xFFF) == 0x600)
1193 DLParser_Unknown_Skip3(gfx);
1199 DebuggerAppendMsg("ucode 0xb4 at PC=%08X: 0x%08x 0x%08x\n", dwPC-8,
1200 (gfx->words.w0), (gfx->words.w1));
1203 DLParser_Unknown_Skip3(gfx);
1207 void DLParser_Ucode8_0xb5(Gfx *gfx)
1209 uint32 dwPC = gDlistStack[gDlistStackPointer].pc-8;
1210 LOG_UCODE("ucode 0xB5 at PC=%08X: 0x%08x 0x%08x\n", dwPC-8, (gfx->words.w0), (gfx->words.w1));
1212 uint32 dwCmd2 = *(uint32 *)(g_pRDRAMu8 + dwPC+8);
1213 uint32 dwCmd3 = *(uint32 *)(g_pRDRAMu8 + dwPC+12);
1214 LOG_UCODE(" : 0x%08x 0x%08x\n", dwCmd2, dwCmd3);
1216 //if( dwCmd2 == 0 && dwCmd3 == 0 )
1218 DLParser_Ucode8_EndDL(gfx); // Check me
1222 gDlistStack[gDlistStackPointer].pc += 8;
1226 if( GSBlkAddrSaves[gDlistStackPointer][0] == 0 || GSBlkAddrSaves[gDlistStackPointer][1] == 0 )
1229 if( pauseAtNext && eventToPause == NEXT_DLIST)
1231 DebuggerAppendMsg("PC=%08X: 0xB5 - %08X : %08X, %08X, EndDL, no next blk\n", dwPC, (gfx->words.w1), dwCmd2, dwCmd3);
1234 DLParser_Ucode8_EndDL(gfx); // Check me
1238 if( ((dwCmd2>>24)!=0x80 && (dwCmd2>>24)!=0x00 ) || ((dwCmd3>>24)!=0x80 && (dwCmd3>>24)!=0x00 ) )
1241 if( pauseAtNext && eventToPause == NEXT_DLIST)
1243 DebuggerAppendMsg("PC=%08X: 0xB5 - %08X : %08X, %08X, EndDL, Unknown\n", dwPC, (gfx->words.w1), dwCmd2, dwCmd3);
1246 DLParser_Ucode8_EndDL(gfx); // Check me
1250 if( (dwCmd2>>24)!= (dwCmd3>>24) )
1253 if( pauseAtNext && eventToPause == NEXT_DLIST)
1255 DebuggerAppendMsg("PC=%08X: 0xB5 - %08X : %08X, %08X, EndDL, Unknown\n", dwPC, (gfx->words.w1), dwCmd2, dwCmd3);
1258 DLParser_Ucode8_EndDL(gfx); // Check me
1263 if( (dwCmd2>>24)==0x80 && (dwCmd3>>24)==0x80 )
1265 if( dwCmd2 < dwCmd3 )
1267 // All right, the next block is not ucode, but data
1269 if( pauseAtNext && eventToPause == NEXT_DLIST)
1271 DebuggerAppendMsg("PC=%08X: 0xB5 - %08X : %08X, %08X, EndDL, next blk is data\n", dwPC, (gfx->words.w1), dwCmd2, dwCmd3);
1274 DLParser_Ucode8_EndDL(gfx); // Check me
1278 uint32 dwCmd4 = *(uint32 *)(g_pRDRAMu8 + (dwCmd2&0x00FFFFFF));
1279 uint32 dwCmd5 = *(uint32 *)(g_pRDRAMu8 + (dwCmd2&0x00FFFFFF)+4);
1280 uint32 dwCmd6 = *(uint32 *)(g_pRDRAMu8 + (dwCmd3&0x00FFFFFF));
1281 uint32 dwCmd7 = *(uint32 *)(g_pRDRAMu8 + (dwCmd3&0x00FFFFFF)+4);
1282 if( (dwCmd4>>24) != 0x80 || (dwCmd5>>24) != 0x80 || (dwCmd6>>24) != 0x80 || (dwCmd7>>24) != 0x80 || dwCmd4 < dwCmd5 || dwCmd6 < dwCmd7 )
1284 // All right, the next block is not ucode, but data
1286 if( pauseAtNext && eventToPause == NEXT_DLIST)
1288 DebuggerAppendMsg("PC=%08X: 0xB5 - %08X : %08X, %08X, EndDL, next blk is data\n", dwPC, (gfx->words.w1), dwCmd2, dwCmd3);
1289 DebuggerAppendMsg("%08X, %08X %08X,%08X\n", dwCmd4, dwCmd5, dwCmd6, dwCmd7);
1292 DLParser_Ucode8_EndDL(gfx); // Check me
1296 gDlistStack[gDlistStackPointer].pc += 8;
1297 DEBUGGER_PAUSE_AND_DUMP(NEXT_DLIST,
1298 DebuggerAppendMsg("PC=%08X: 0xB5 - %08X : %08X, %08X, continue\n", dwPC, (gfx->words.w1), dwCmd2, dwCmd3);
1302 else if( (dwCmd2>>24)==0x00 && (dwCmd3>>24)==0x00 )
1305 if( pauseAtNext && eventToPause == NEXT_DLIST)
1307 DebuggerAppendMsg("PC=%08X: 0xB5 - %08X : %08X, %08X, EndDL, next blk is data\n", dwPC, (gfx->words.w1), dwCmd2, dwCmd3);
1310 DLParser_Ucode8_EndDL(gfx); // Check me
1313 else if( (dwCmd2>>24)==0x00 && (dwCmd3>>24)==0x00 )
1315 dwCmd2 = *(uint32 *)(g_pRDRAMu8 + dwPC+16);
1316 dwCmd3 = *(uint32 *)(g_pRDRAMu8 + dwPC+20);
1317 if( (dwCmd2>>24)==0x80 && (dwCmd3>>24)==0x80 && dwCmd2 < dwCmd3 )
1319 // All right, the next block is not ucode, but data
1321 if( pauseAtNext && eventToPause == NEXT_DLIST)
1323 DebuggerAppendMsg("PC=%08X: 0xB5 - %08X : %08X, %08X, EndDL, next blk is data\n", dwPC, (gfx->words.w1), dwCmd2, dwCmd3);
1326 DLParser_Ucode8_EndDL(gfx); // Check me
1331 gDlistStack[gDlistStackPointer].pc += 8;
1332 DEBUGGER_PAUSE_AND_DUMP(NEXT_DLIST,
1333 DebuggerAppendMsg("PC=%08X: 0xB5 - %08X : %08X, %08X, continue\n", dwPC, (gfx->words.w1), dwCmd2, dwCmd3)
1340 uint32 dwAddr1 = RSPSegmentAddr(dwCmd2);
1341 uint32 dwAddr2 = RSPSegmentAddr(dwCmd3);
1343 if( (gfx->words.w1) != 0 )
1345 DebuggerAppendMsg("!!!! PC=%08X: 0xB5 - %08X : %08X, %08X\n", dwPC, (gfx->words.w1), dwCmd2, dwCmd3);
1349 DEBUGGER_PAUSE_AND_DUMP(NEXT_DLIST,
1350 DebuggerAppendMsg("PC=%08X: 0xB5 - %08X : %08X, %08X, continue\n", dwPC, (gfx->words.w1), dwAddr1, dwAddr2)
1356 void DLParser_Ucode8_0xbc(Gfx *gfx)
1358 if( ((gfx->words.w0)&0xFFF) == 0x58C )
1360 DLParser_Ucode8_DL(gfx);
1364 uint32 dwPC = gDlistStack[gDlistStackPointer].pc-8;
1365 LOG_UCODE("ucode 0xBC at PC=%08X: 0x%08x 0x%08x\n", dwPC, (gfx->words.w0), (gfx->words.w1));
1369 void DLParser_Ucode8_0xbd(Gfx *gfx)
1372 00359A68: BD000000, DB5B0077 - RSP_POPMTX
1373 00359A70: C8C0A000, 00240024 - RDP_TriFill
1374 00359A78: 01000100, 00000000 - RSP_MTX
1375 00359A80: BD000501, DB5B0077 - RSP_POPMTX
1376 00359A88: C8C0A000, 00240024 - RDP_TriFill
1377 00359A90: 01000100, 00000000 - RSP_MTX
1378 00359A98: BD000A02, DB5B0077 - RSP_POPMTX
1379 00359AA0: C8C0A000, 00240024 - RDP_TriFill
1380 00359AA8: 01000100, 00000000 - RSP_MTX
1381 00359AB0: BD000F04, EB6F0087 - RSP_POPMTX
1382 00359AB8: C8C0A000, 00280028 - RDP_TriFill
1383 00359AC0: 01000100, 00000000 - RSP_MTX
1384 00359AC8: BD001403, DB5B0077 - RSP_POPMTX
1385 00359AD0: C8C0A000, 00240024 - RDP_TriFill
1386 00359AD8: 01000100, 00000000 - RSP_MTX
1387 00359AE0: B5000000, 00000000 - RSP_LINE3D
1388 00359AE8: 1A000000, 16000200 - G_NOTHING
1391 if( (gfx->words.w1) != 0 )
1393 DLParser_Unknown_Skip2(gfx);
1397 uint32 dwPC = gDlistStack[gDlistStackPointer].pc;
1398 LOG_UCODE("ucode 0xbd at PC=%08X: 0x%08x 0x%08x\n", dwPC-8, (gfx->words.w0), (gfx->words.w1));
1401 void DLParser_Ucode8_0xbf(Gfx *gfx)
1403 if( ((gfx->words.w0)&0xFF) == 0x02 )
1404 DLParser_Unknown_Skip3(gfx);
1406 DLParser_Unknown_Skip1(gfx);
1409 void PD_LoadMatrix_0xb4(uint32 addr)
1411 const float fRecip = 1.0f / 65536.0f;
1414 data[0] = *(uint32*)(g_pRDRAMu8+addr+4+ 0);
1415 data[1] = *(uint32*)(g_pRDRAMu8+addr+4+ 8);
1416 data[2] = *(uint32*)(g_pRDRAMu8+addr+4+16);
1417 data[3] = *(uint32*)(g_pRDRAMu8+addr+4+24);
1419 data[8] = *(uint32*)(g_pRDRAMu8+addr+4+32);
1420 data[9] = *(uint32*)(g_pRDRAMu8+addr+4+40);
1421 data[10] = *(uint32*)(g_pRDRAMu8+addr+4+48);
1422 data[11] = *(uint32*)(g_pRDRAMu8+addr+4+56);
1424 data[4] = *(uint32*)(g_pRDRAMu8+addr+4+ 0+64);
1425 data[5] = *(uint32*)(g_pRDRAMu8+addr+4+ 8+64);
1426 data[6] = *(uint32*)(g_pRDRAMu8+addr+4+16+64);
1427 data[7] = *(uint32*)(g_pRDRAMu8+addr+4+24+64);
1429 data[12] = *(uint32*)(g_pRDRAMu8+addr+4+32+64);
1430 data[13] = *(uint32*)(g_pRDRAMu8+addr+4+40+64);
1431 data[14] = *(uint32*)(g_pRDRAMu8+addr+4+48+64);
1432 data[15] = *(uint32*)(g_pRDRAMu8+addr+4+56+64);
1435 for (int i = 0; i < 4; i++)
1437 for (int j = 0; j < 4; j++)
1439 int hi = *(short *)((unsigned char*)data + (((i<<3)+(j<<1) )^0x2));
1440 int lo = *(uint16*)((unsigned char*)data + (((i<<3)+(j<<1) + 32)^0x2));
1441 matToLoad.m[i][j] = (float)((hi<<16) | lo) * fRecip;
1448 " %#+12.5f %#+12.5f %#+12.5f %#+12.5f\r\n"
1449 " %#+12.5f %#+12.5f %#+12.5f %#+12.5f\r\n"
1450 " %#+12.5f %#+12.5f %#+12.5f %#+12.5f\r\n"
1451 " %#+12.5f %#+12.5f %#+12.5f %#+12.5f\r\n",
1452 matToLoad.m[0][0], matToLoad.m[0][1], matToLoad.m[0][2], matToLoad.m[0][3],
1453 matToLoad.m[1][0], matToLoad.m[1][1], matToLoad.m[1][2], matToLoad.m[1][3],
1454 matToLoad.m[2][0], matToLoad.m[2][1], matToLoad.m[2][2], matToLoad.m[2][3],
1455 matToLoad.m[3][0], matToLoad.m[3][1], matToLoad.m[3][2], matToLoad.m[3][3]);
1459 void DLParser_RDPHalf_1_0xb4_GoldenEye(Gfx *gfx)
1461 SP_Timing(RSP_GBI1_RDPHalf_1);
1462 if( ((gfx->words.w1)>>24) == 0xce )
1465 CRender::g_pRender->SetCombinerAndBlender();
1467 uint32 dwPC = gDlistStack[gDlistStackPointer].pc; // This points to the next instruction
1469 //PD_LoadMatrix_0xb4(dwPC + 8*16 - 8);
1471 uint32 dw1 = *(uint32 *)(g_pRDRAMu8 + dwPC+8*0+4);
1472 //uint32 dw2 = *(uint32 *)(g_pRDRAMu8 + dwPC+8*1+4);
1473 //uint32 dw3 = *(uint32 *)(g_pRDRAMu8 + dwPC+8*2+4);
1474 //uint32 dw4 = *(uint32 *)(g_pRDRAMu8 + dwPC+8*3+4);
1475 //uint32 dw5 = *(uint32 *)(g_pRDRAMu8 + dwPC+8*4+4);
1476 //uint32 dw6 = *(uint32 *)(g_pRDRAMu8 + dwPC+8*5+4);
1477 //uint32 dw7 = *(uint32 *)(g_pRDRAMu8 + dwPC+8*6+4);
1478 uint32 dw8 = *(uint32 *)(g_pRDRAMu8 + dwPC+8*7+4);
1479 uint32 dw9 = *(uint32 *)(g_pRDRAMu8 + dwPC+8*8+4);
1481 uint32 r = (dw8>>16)&0xFF;
1482 uint32 g = (dw8 )&0xFF;
1483 uint32 b = (dw9>>16)&0xFF;
1484 uint32 a = (dw9 )&0xFF;
1485 uint32 color = COLOR_RGBA(r, g, b, a);
1488 //int x1 = gRDP.scissor.right;
1489 int x0 = gRSP.nVPLeftN;
1490 int x1 = gRSP.nVPRightN;
1491 int y0 = int(dw1&0xFFFF)/4;
1492 int y1 = int(dw1>>16)/4;
1494 float xscale = g_textures[0].m_pCTexture->m_dwWidth / (float)(x1-x0);
1495 float yscale = g_textures[0].m_pCTexture->m_dwHeight / (float)(y1-y0);
1496 //float fs0 = (short)(dw3&0xFFFF)/32768.0f*g_textures[0].m_pCTexture->m_dwWidth;
1497 //float ft0 = (short)(dw3>>16)/32768.0f*256;
1498 CRender::g_pRender->TexRect(x0,y0,x1,y1,0,0,xscale,yscale,true,color);
1500 gDlistStack[gDlistStackPointer].pc += 312;
1506 LOG_UCODE("GoldenEye Sky at PC=%08X: 0x%08x 0x%08x", dwPC, (gfx->words.w0), (gfx->words.w1));
1507 uint32 *ptr = (uint32 *)(g_pRDRAMu8 + dwPC);
1508 for( int i=0; i<21; i++, dwPC+=16,ptr+=4 )
1510 LOG_UCODE("%08X: %08X %08X %08X %08X", dwPC, ptr[0], ptr[1], ptr[2], ptr[3]);
1515 DEBUGGER_PAUSE_AND_DUMP_COUNT_N(NEXT_FLUSH_TRI, {
1516 TRACE0("Pause after Golden Sky Drawing\n");
1521 void DLParser_RSP_DL_WorldDriver(Gfx *gfx)
1523 uint32 dwAddr = RSPSegmentAddr((gfx->words.w1));
1524 if( dwAddr > g_dwRamSize )
1526 RSP_RDP_NOIMPL("Error: DL addr = %08X out of range, PC=%08X", dwAddr, gDlistStack[gDlistStackPointer].pc );
1527 dwAddr &= (g_dwRamSize-1);
1528 DebuggerPauseCountN( NEXT_DLIST );
1531 LOG_UCODE(" WorldDriver DisplayList 0x%08x", dwAddr);
1532 gDlistStackPointer++;
1533 gDlistStack[gDlistStackPointer].pc = dwAddr;
1534 gDlistStack[gDlistStackPointer].countdown = MAX_DL_COUNT;
1536 LOG_UCODE("Level=%d", gDlistStackPointer+1);
1537 LOG_UCODE("^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^");
1540 void DLParser_RSP_Pop_DL_WorldDriver(Gfx *gfx)
1545 void DLParser_RSP_Last_Legion_0x80(Gfx *gfx)
1547 gDlistStack[gDlistStackPointer].pc += 16;
1548 LOG_UCODE("DLParser_RSP_Last_Legion_0x80");
1551 void DLParser_RSP_Last_Legion_0x00(Gfx *gfx)
1553 LOG_UCODE("DLParser_RSP_Last_Legion_0x00");
1554 gDlistStack[gDlistStackPointer].pc += 16;
1556 if( (gfx->words.w0) == 0 && (gfx->words.w1) )
1558 uint32 newaddr = RSPSegmentAddr((gfx->words.w1));
1559 if( newaddr >= g_dwRamSize )
1565 //uint32 dw1 = *(uint32 *)(g_pRDRAMu8 + newaddr+8*0+4);
1566 uint32 pc1 = *(uint32 *)(g_pRDRAMu8 + newaddr+8*1+4);
1567 uint32 pc2 = *(uint32 *)(g_pRDRAMu8 + newaddr+8*4+4);
1568 pc1 = RSPSegmentAddr(pc1);
1569 pc2 = RSPSegmentAddr(pc2);
1571 if( pc1 && pc1 != 0xffffff && pc1 < g_dwRamSize)
1573 // Need to call both DL
1574 gDlistStackPointer++;
1575 gDlistStack[gDlistStackPointer].pc = pc1;
1576 gDlistStack[gDlistStackPointer].countdown = MAX_DL_COUNT;
1579 if( pc2 && pc2 != 0xffffff && pc2 < g_dwRamSize )
1581 gDlistStackPointer++;
1582 gDlistStack[gDlistStackPointer].pc = pc2;
1583 gDlistStack[gDlistStackPointer].countdown = MAX_DL_COUNT;
1586 else if( (gfx->words.w1) == 0 )
1592 // (gfx->words.w0) != 0
1593 RSP_RDP_Nothing(gfx);
1598 void DLParser_TexRect_Last_Legion(Gfx *gfx)
1600 if( !status.bCIBufferIsRendered )
1601 g_pFrameBufferManager->ActiveTextureBuffer();
1603 status.primitiveType = PRIM_TEXTRECT;
1605 // This command used 128bits, and not 64 bits. This means that we have to look one
1606 // Command ahead in the buffer, and update the PC.
1607 uint32 dwPC = gDlistStack[gDlistStackPointer].pc; // This points to the next instruction
1608 uint32 dwCmd2 = *(uint32 *)(g_pRDRAMu8 + dwPC);
1609 uint32 dwCmd3 = *(uint32 *)(g_pRDRAMu8 + dwPC+4);
1611 gDlistStack[gDlistStackPointer].pc += 8;
1614 LOG_UCODE("0x%08x: %08x %08x", dwPC, *(uint32 *)(g_pRDRAMu8 + dwPC+0), *(uint32 *)(g_pRDRAMu8 + dwPC+4));
1616 uint32 dwXH = (((gfx->words.w0)>>12)&0x0FFF)/4;
1617 uint32 dwYH = (((gfx->words.w0) )&0x0FFF)/4;
1618 uint32 tileno = ((gfx->words.w1)>>24)&0x07;
1619 uint32 dwXL = (((gfx->words.w1)>>12)&0x0FFF)/4;
1620 uint32 dwYL = (((gfx->words.w1) )&0x0FFF)/4;
1623 if( (int)dwXL >= gRDP.scissor.right || (int)dwYL >= gRDP.scissor.bottom || (int)dwXH < gRDP.scissor.left || (int)dwYH < gRDP.scissor.top )
1629 uint16 uS = (uint16)( dwCmd2>>16)&0xFFFF;
1630 uint16 uT = (uint16)( dwCmd2 )&0xFFFF;
1631 short s16S = *(short*)(&uS);
1632 short s16T = *(short*)(&uT);
1634 uint16 uDSDX = (uint16)(( dwCmd3>>16)&0xFFFF);
1635 uint16 uDTDY = (uint16)(( dwCmd3 )&0xFFFF);
1636 short s16DSDX = *(short*)(&uDSDX);
1637 short s16DTDY = *(short*)(&uDTDY);
1639 uint32 curTile = gRSP.curTile;
1640 ForceMainTextureIndex(tileno);
1642 float fS0 = s16S / 32.0f;
1643 float fT0 = s16T / 32.0f;
1645 float fDSDX = s16DSDX / 1024.0f;
1646 float fDTDY = s16DTDY / 1024.0f;
1648 uint32 cycletype = gRDP.otherMode.cycle_type;
1650 if (cycletype == CYCLE_TYPE_COPY)
1652 fDSDX /= 4.0f; // In copy mode 4 pixels are copied at once.
1656 else if (cycletype == CYCLE_TYPE_FILL)
1662 if( fDSDX == 0 ) fDSDX = 1;
1663 if( fDTDY == 0 ) fDTDY = 1;
1665 float fS1 = fS0 + (fDSDX * (dwXH - dwXL));
1666 float fT1 = fT0 + (fDTDY * (dwYH - dwYL));
1668 LOG_UCODE(" Tile:%d Screen(%d,%d) -> (%d,%d)", tileno, dwXL, dwYL, dwXH, dwYH);
1669 LOG_UCODE(" Tex:(%#5f,%#5f) -> (%#5f,%#5f) (DSDX:%#5f DTDY:%#5f)",
1670 fS0, fT0, fS1, fT1, fDSDX, fDTDY);
1673 float t0u0 = (fS0-gRDP.tiles[tileno].hilite_sl) * gRDP.tiles[tileno].fShiftScaleS;
1674 float t0v0 = (fT0-gRDP.tiles[tileno].hilite_tl) * gRDP.tiles[tileno].fShiftScaleT;
1675 float t0u1 = t0u0 + (fDSDX * (dwXH - dwXL))*gRDP.tiles[tileno].fShiftScaleS;
1676 float t0v1 = t0v0 + (fDTDY * (dwYH - dwYL))*gRDP.tiles[tileno].fShiftScaleT;
1678 if( dwXL==0 && dwYL==0 && dwXH==windowSetting.fViWidth-1 && dwYH==windowSetting.fViHeight-1 &&
1679 t0u0 == 0 && t0v0==0 && t0u1==0 && t0v1==0 )
1681 //Using TextRect to clear the screen
1685 if( status.bHandleN64RenderTexture && //status.bDirectWriteIntoRDRAM &&
1686 g_pRenderTextureInfo->CI_Info.dwFormat == gRDP.tiles[tileno].dwFormat &&
1687 g_pRenderTextureInfo->CI_Info.dwSize == gRDP.tiles[tileno].dwSize &&
1688 gRDP.tiles[tileno].dwFormat == TXT_FMT_CI && gRDP.tiles[tileno].dwSize == TXT_SIZE_8b )
1690 if( options.enableHackForGames == HACK_FOR_YOSHI )
1692 // Hack for Yoshi background image
1694 TexRectToFrameBuffer_8b(dwXL, dwYL, dwXH, dwYH, t0u0, t0v0, t0u1, t0v1, tileno);
1695 DEBUGGER_PAUSE_AT_COND_AND_DUMP_COUNT_N((eventToPause == NEXT_FLUSH_TRI || eventToPause == NEXT_TEXTRECT), {
1696 DebuggerAppendMsg("TexRect: tile=%d, X0=%d, Y0=%d, X1=%d, Y1=%d,\nfS0=%f, fT0=%f, ScaleS=%f, ScaleT=%f\n",
1697 gRSP.curTile, dwXL, dwYL, dwXH, dwYH, fS0, fT0, fDSDX, fDTDY);
1698 DebuggerAppendMsg("Pause after TexRect for Yoshi\n");
1703 if( frameBufferOptions.bUpdateCIInfo )
1706 TexRectToFrameBuffer_8b(dwXL, dwYL, dwXH, dwYH, t0u0, t0v0, t0u1, t0v1, tileno);
1709 if( !status.bDirectWriteIntoRDRAM )
1711 CRender::g_pRender->TexRect(dwXL, dwYL, dwXH, dwYH, fS0, fT0, fDSDX, fDTDY);
1713 status.dwNumTrisRendered += 2;
1719 CRender::g_pRender->TexRect(dwXL, dwYL, dwXH, dwYH, fS0, fT0, fDSDX, fDTDY);
1720 status.bFrameBufferDrawnByTriangles = true;
1722 status.dwNumTrisRendered += 2;
1726 if( status.bHandleN64RenderTexture )
1727 g_pRenderTextureInfo->maxUsedHeight = max(g_pRenderTextureInfo->maxUsedHeight,(int)dwYH);
1729 ForceMainTextureIndex(curTile);