Source/Plugins/Plugin_VideoDX9/Src/DLCompiler.cpp

   1 #include "stdafx.h"
   2
   3 #if 0
   4
   5 #include "OpcodeDecoding.h"
   6 #include "VertexLoader.h"
   7 #include "VertexHandler.h"
   8 #include "DataReader.h"
   9 #include "BPStructs.h"
  10 #include "CPStructs.h"
  11 #include "XFStructs.h"
  12 #include "DLCompiler.h"
  13 #include "x86.h"
  14 #include "main.h"
  15 #include "Utils.h"
  16
  17 CompiledDList::CompiledDList(u32 _addr, u32 _size)
  18 {
  19         dataSize = 0;
  20         data = 0;
  21         code = 0;
  22         addr = _addr;
  23         size = _size;
  24         pass = 0;
  25         numBatches = 0;
  26         batches = 0;
  27 }
  28
  29 CompiledDList::~CompiledDList()
  30 {
  31         if (data)
  32                 delete [] data;
  33         if (code)
  34                 delete [] code;
  35         if (batches)
  36                 delete [] batches;
  37 }
  38
  39
  40 bool CompiledDList::Call()
  41 {
  42         switch(pass) {
  43         case 0: // First compiling pass : find data size
  44                 if (Pass1())
  45                 {
  46                         pass = 1;
  47                         return true;
  48                 }
  49                 else
  50                         return false;
  51         case 1: // Second compiling pass : actually compile
  52                 //if pass1 succeeded, pass2 will too
  53                 Pass2();
  54                 pass = 2;
  55                 return true;
  56         case 2: // Run pass - we have a compiled dlist, just call it
  57                 Run();
  58                 return true;
  59         default:
  60                 //ERROR
  61                 return false;
  62         }
  63 }
  64
  65
  66 bool CompiledDList::Pass1()
  67 {
  68 /*      //find the size of code + data, if the dlist is worth recompiling etc
  69         // at the same time, do the ordinary stuff
  70         g_pDataReader = &dlistReader;
  71         OpcodeReaders::SetDListReader(addr, addr+size);
  72         dataSize = 0;
  73         codeSize = 0;
  74         numBatches = 0;
  75         bool lastIsPrim = false;
  76         while (OpcodeReaders::IsDListOKToRead())
  77         {
  78                 int Cmd = g_pDataReader->Read8();
  79                 switch(Cmd)
  80                 {
  81                 case GX_LOAD_CP_REG: //0x08
  82                         {
  83                                 u32 SubCmd = g_pDataReader->Read8();
  84                                 u32 Value = g_pDataReader->Read32();
  85                                 LoadCPReg(SubCmd,Value);
  86                                 //COMPILER
  87                                 codeSize+=13;
  88                         }
  89                         break;
  90
  91                 case GX_LOAD_XF_REG:
  92                         {
  93                                 u32 Cmd2 = g_pDataReader->Read32();
  94                                 int dwTransferSize = ((Cmd2>>16)&15) + 1;
  95                                 DWORD dwAddress = Cmd2 & 0xFFFF;
  96                                 static u32 pData[16];
  97                                 for (int i=0; i<dwTransferSize; i++)
  98                                         pData[i] = g_pDataReader->Read32();
  99                                 LoadXFReg(dwTransferSize,dwAddress,pData);
 100                                 //COMPILER
 101                                 dataSize+=dwTransferSize;
 102                                 codeSize+=17;
 103                         }
 104                         break;
 105
 106                 case GX_LOAD_BP_REG: //0x61
 107                         {
 108                                 u32 cmd=g_pDataReader->Read32();
 109                                 LoadBPReg(cmd);
 110                                 codeSize+=9;
 111                         }
 112                         break;
 113
 114                 case GX_LOAD_INDX_A: //used for position matrices
 115                         LoadIndexedXF(g_pDataReader->Read32(),0xC);
 116                         codeSize+=13;
 117                         break;
 118                 case GX_LOAD_INDX_B: //used for normal matrices
 119                         LoadIndexedXF(g_pDataReader->Read32(),0xD);
 120                         codeSize+=13;
 121                         break;
 122                 case GX_LOAD_INDX_C: //used for postmatrices
 123                         LoadIndexedXF(g_pDataReader->Read32(),0xE);
 124                         codeSize+=13;
 125                         break;
 126                 case GX_LOAD_INDX_D: //used for lights
 127                         LoadIndexedXF(g_pDataReader->Read32(),0xF);
 128                         codeSize+=13;
 129                         break;
 130
 131                 case GX_CMD_CALL_DL:
 132                         MessageBox(0,"Display lists can't recurse!!","error",0);
 133                         break;
 134
 135                 case GX_CMD_INVL_VC:// Invalidate       (vertex cache?)
 136                         break;
 137                 case GX_NOP:
 138                         break;
 139                 default:
 140                         if (Cmd&0x80)
 141                         {
 142                                 int primitive = (Cmd&GX_PRIMITIVE_MASK) >> GX_PRIMITIVE_SHIFT;
 143                                 if (lastIsPrim)
 144                                 {
 145                                         //join to last
 146                                 }
 147                                 else
 148                                 {
 149                                         //finish up last and commit
 150                                 }
 151                                 u16 numVertices = g_pDataReader->Read16();
 152                                 tempvarray.Reset();
 153                                 VertexLoader::SetVArray(&tempvarray);
 154                                 VertexLoader *loader = &VertexLoader[Cmd&GX_VAT_MASK];
 155                                 loader->Setup();
 156                                 loader->PrepareRun();
 157                                 int vsize = loader->GetVertexSize();
 158                                 loader->RunVertices(numVertices);
 159                                 CVertexHandler::DrawVertices(primitive, numVertices, &tempvarray);
 160                                 CVertexHandler::Flush();
 161                                 //COMPILER
 162                                 codeSize+=21;
 163                                 numBatches++;
 164                                 lastIsPrim = true;
 165                         }
 166                         break;
 167                 }
 168         }
 169         if (lastIsPrim)
 170         {
 171                 //finish up last and commit
 172         }
 173         codeSize*=2;*/
 174         return true;
 175 }
 176
 177
 178 void CompiledDList::Pass2()
 179 {
 180 /*      OpcodeReaders::SetDListReader(addr, addr+size);
 181
 182         data = new u32[dataSize];
 183         code = new u8[codeSize]; //at least
 184
 185         batches = new Batch[numBatches];
 186         int batchCount = 0;
 187         u32 *dataptr = data;
 188
 189         x86Init();
 190         x86SetPtr((s8*)code);
 191         //WC8(0xCC);
 192
 193     //actually do the recompiling, emit code and data, protect the memory
 194         // but again, at the same time do the ordinary stuff
 195         // so the compiled display list won't be run until the third time actually
 196         bool dump = false,lastIsGeom=false;
 197         FILE *f;
 198
 199 #ifndef TEASER
 200         if (dump)
 201         {
 202                 f=fopen("D:\\dlistlogs.txt","a");
 203                 fprintf(f,"===========================================\n");
 204         }
 205 #endif
 206
 207         while (OpcodeReaders::IsDListOKToRead())
 208         {
 209                 int Cmd = g_pDataReader->Read8();
 210                 switch(Cmd)
 211                 {
 212                 case GX_LOAD_CP_REG: //0x08
 213                         {
 214                                 lastIsGeom = false;
 215                                 u32 SubCmd = g_pDataReader->Read8();
 216                                 u32 Value = g_pDataReader->Read32();
 217                                 if (dump)
 218                                         fprintf(f,"CP   | %02x %08x\n",SubCmd,Value);
 219
 220                                 LoadCPReg(SubCmd,Value);
 221                                 //COMPILER
 222                                 PUSH_WordToStack(Value);
 223                                 PUSH_WordToStack(SubCmd);
 224                                 CALLFunc((u32)LoadCPReg);
 225                         }
 226                         break;
 227
 228                 case GX_LOAD_XF_REG:
 229                         {
 230                                 lastIsGeom = false;
 231                                 u32 Cmd2 = g_pDataReader->Read32();
 232                                 int dwTransferSize = ((Cmd2>>16)&15) + 1;
 233                                 u32 dwAddress = Cmd2 & 0xFFFF;
 234                                 static u32 pData[16];
 235
 236                                 u32 *oldDataPtr = dataptr;
 237
 238                                 if (dump)
 239                                 {
 240                                         fprintf(f,"XF   | %01xx %04x\n",dwTransferSize,dwAddress);
 241                                         for (int i=0; i<dwTransferSize; i++)
 242                                                 fprintf(f, "%08x | %f\n",oldDataPtr[i], *((float*)oldDataPtr+i));
 243                                 }
 244
 245
 246                                 for (int i=0; i<dwTransferSize; i++) // a little compiler here too
 247                                         *dataptr++ = g_pDataReader->Read32();
 248
 249
 250                                 LoadXFReg(dwTransferSize,dwAddress,oldDataPtr);
 251
 252                                 //COMPILER
 253                                 PUSH_WordToStack((u32)oldDataPtr);
 254                                 PUSH_WordToStack(dwAddress);
 255                                 PUSH_WordToStack(dwTransferSize);
 256                                 CALLFunc((u32)LoadXFReg);
 257                         }
 258                         break;
 259
 260                 case GX_LOAD_BP_REG: //0x61
 261                         {
 262                                 lastIsGeom = false;
 263                                 u32 cmd=g_pDataReader->Read32();
 264                                 if (dump)
 265                                         fprintf(f,"BP   | %08x\n",cmd);
 266
 267                                 LoadBPReg(cmd);
 268                                 //COMPILER
 269                                 PUSH_WordToStack(cmd);
 270                                 CALLFunc((u32)LoadBPReg);
 271                         }
 272                         break;
 273
 274                 case GX_LOAD_INDX_A: //usually used for position matrices
 275                         {
 276                                 lastIsGeom = false;
 277                                 u32 value = g_pDataReader->Read32();
 278                                 LoadIndexedXF(value,0xC);
 279                                 //COMPILER
 280                                 PUSH_WordToStack(0xC);
 281                                 PUSH_WordToStack(value);
 282                                 CALLFunc((u32)LoadIndexedXF);
 283                                 if (dump)
 284                                         fprintf(f,"LOADINDEXA | pos matrix\n");
 285                         }
 286                         break;
 287                 case GX_LOAD_INDX_B: //usually used for normal matrices
 288                         {
 289                                 lastIsGeom = false;
 290                                 u32 value = g_pDataReader->Read32();
 291                                 LoadIndexedXF(value,0xD);
 292                                 //COMPILER
 293                                 PUSH_WordToStack(0xD);
 294                                 PUSH_WordToStack(value);
 295                                 CALLFunc((u32)LoadIndexedXF);
 296                                 if (dump)
 297                                         fprintf(f,"LOADINDEXB | nrm matrix\n");
 298                         }
 299                         break;
 300                 case GX_LOAD_INDX_C: //usually used for postmatrices
 301                         {
 302                                 lastIsGeom = false;
 303                                 u32 value = g_pDataReader->Read32();
 304                                 LoadIndexedXF(value,0xE);
 305                                 //COMPILER
 306                                 PUSH_WordToStack(0xE);
 307                                 PUSH_WordToStack(value);
 308                                 CALLFunc((u32)LoadIndexedXF);
 309                                 if (dump)
 310                                         fprintf(f,"LOADINDEXC | post matrix\n");
 311                         }
 312                         break;
 313                 case GX_LOAD_INDX_D: //usually used for lights
 314                         {
 315                                 lastIsGeom = false;
 316                                 u32 value = g_pDataReader->Read32();
 317                                 LoadIndexedXF(value,0xF);
 318                                 //COMPILER
 319                                 PUSH_WordToStack(0xF);
 320                                 PUSH_WordToStack(value);
 321                                 CALLFunc((u32)LoadIndexedXF);
 322                                 if (dump)
 323                                         fprintf(f,"LOADINDEXD | light\n");
 324                         }
 325                         break;
 326                 case GX_CMD_CALL_DL:
 327                         // ERORRR
 328                         break;
 329
 330                 case GX_CMD_INVL_VC:// Invalidate       (vertex cache?)
 331                         if (dump)
 332                                 fprintf(f,"invalidate vc\n");
 333                         break;
 334                 case GX_NOP:
 335                         if (dump)
 336                                 fprintf(f,"nop\n");
 337                         break;
 338                 default:
 339                         if (Cmd&0x80)
 340                         {
 341                                 int primitive = (Cmd&GX_PRIMITIVE_MASK) >> GX_PRIMITIVE_SHIFT;
 342                                 //if (lastIsGeom) INCSTAT(stats.numJoins);
 343                                 u16 numVertices = g_pDataReader->Read16();
 344                                 if (dump)
 345                                         fprintf(f,"DP: prim=%02x numv=%i\n",primitive,numVertices);
 346                                 DecodedVArray &va = batches[batchCount].varray;
 347
 348                                 VertexLoader *loader = &VertexLoader[Cmd&GX_VAT_MASK];
 349                                 TVtxDesc &vd = loader->GetVtxDesc();
 350
 351                                 VertexLoader::SetVArray(&va);
 352                                 loader->Setup();
 353                                 loader->PrepareRun();
 354 //                                      va.numColors  = loader->GetNumColors();
 355 //                                      va.numUVs     = loader->GetNumTCs();
 356 //                                      va.numNormals = loader->GetNumNormals();
 357                                 //va.num
 358                                 va.Create(numVertices,vd.PosMatIdx,
 359                                         vd.Tex0MatIdx+vd.Tex1MatIdx+vd.Tex2MatIdx+vd.Tex3MatIdx+
 360                                         vd.Tex4MatIdx+vd.Tex5MatIdx+vd.Tex6MatIdx+vd.Tex7MatIdx,
 361                                         va.numNormals, va.numColors, va.numTCs);
 362
 363                                 int vsize = loader->GetVertexSize();
 364                                 loader->RunVertices(numVertices);
 365                                 CVertexHandler::DrawVertices(primitive, numVertices, &va);
 366                                 CVertexHandler::Flush();
 367                                 // YES we have now filled our varray
 368                                 //LETS COMPILE
 369                                 PUSH_WordToStack(primitive);
 370                                 PUSH_WordToStack(batchCount);
 371                                 PUSH_WordToStack((u32)this);
 372                                 CALLFunc((u32)DrawHelperHelper);
 373                                 batchCount++;
 374                                 lastIsGeom = true;
 375                                 if (dump)
 376                                         fprintf(f,"DRAW PRIMITIVE: prim=%02x numv=%i\n",primitive,numVertices);
 377                         }
 378                         break;
 379                 }
 380         }
 381         if (dump)
 382         {
 383                 fprintf(f,"***************************************\n\n\n");
 384         }
 385         RET();
 386         if (dump)
 387                 fclose(f);*/
 388         //we're done, next time just kick the compiled list off, much much faster than interpreting!
 389 }
 390
 391 void CompiledDList::DrawHelperHelper(CompiledDList *dl, int vno, int prim)
 392 {
 393         Batch &b = dl->batches[vno];
 394         CVertexHandler::DrawVertices(prim, b.varray.GetSize(), &b.varray);
 395 }
 396
 397 void CompiledDList::Run()
 398 {
 399         //run the code
 400         ((void (*)())(code))();
 401         CVertexHandler::Flush();
 402 }
 403
 404 DListCache::DLCache DListCache::dlists;
 405
 406
 407
 408 void DListCache::Init()
 409 {
 410
 411 }
 412
 413
 414 void DListCache::Shutdown()
 415 {
 416         DLCache::iterator iter = dlists.begin();
 417         for (;iter!=dlists.end();iter++)
 418                 iter->second.Destroy();
 419         dlists.clear();
 420 }
 421
 422
 423 void DListCache::Call(u32 _addr, u32 _size)
 424 {
 425         DLCache::iterator iter;
 426         iter = dlists.find(_addr);
 427
 428         if (iter != dlists.end())
 429         {
 430                 if (iter->second.size == _size)
 431                 {
 432                         iter->second.dlist->Call();
 433                         return;
 434                 }
 435                 else // wrong size, need to recompile
 436                 {
 437                         iter->second.Destroy();
 438                         iter=dlists.erase(iter);
 439                 }
 440         }
 441
 442                 //Make an entry in the table
 443         DLCacheEntry entry;
 444         entry.dlist = new CompiledDList(_addr, _size);
 445         entry.dlist->Call();
 446         entry.frameCount = frameCount;
 447         entry.size = _size;
 448         dlists[_addr] = entry;
 449
 450         INCSTAT(stats.numDListsCreated);
 451         SETSTAT(stats.numDListsAlive,(int)dlists.size());
 452 }
 453
 454 void DListCache::Cleanup()
 455 {
 456         for (DLCache::iterator iter=dlists.begin(); iter!=dlists.end();iter++)
 457         {
 458                 DLCacheEntry &entry = iter->second;
 459                 if (entry.frameCount<frameCount-80)
 460                 {
 461                         entry.Destroy();
 462                         iter = dlists.erase(iter);
 463                 }
 464         }
 465         SETSTAT(stats.numDListsAlive,(int)dlists.size());
 466 }
 467
 468 #endif