API tools faq
paste
Advertisement
Twili

f3dex2zelda.c

Twili
Apr 12th, 2022
840
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C 14.58 KB | None | 0 0
raw download clone embed print report
  1. #define G_TEXTURE_ENABLE 0x000002
  2. #define G_SHADING_SMOOTH 0x000200
  3. #define G_CULL_FRONT     0x001000
  4. #define G_CULL_BACK      0x002000
  5. #define G_CLIPPING       0x800000
  6.  
  7. #define G_MWO_aLIGHT_1 0
  8. #define G_MWO_aLIGHT_2 0x20
  9. #define G_MWO_aLIGHT_3 0x40
  10. #define G_MWO_aLIGHT_4 0x60
  11. #define G_MWO_aLIGHT_5 0x80
  12. #define G_MWO_aLIGHT_6 0xa0
  13. #define G_MWO_aLIGHT_7 0xc0
  14. #define G_MWO_aLIGHT_8 0xe0
  15.  
  16. #define G_MW_NUMLIGHT 2
  17. #define G_MW_LIGHTCOL 0xA
  18.  
  19. #define G_MOVEMEM           3
  20. #define G_VTX               4
  21. #define G_DL                6
  22. #define G_CLEARGEOMETRYMODE 0xB6
  23. #define G_SETGEOMETRYMODE   0xB7
  24. #define G_ENDDL             0xB8
  25. #define G_SETOTHERMODE_L    0xB9
  26. #define G_SETOTHERMODE_H    0xBA
  27. #define G_TEXTURE           0xBB
  28. #define G_MOVEWORD          0xBC
  29. #define G_TRI1              0xBF
  30.  
  31. #define read24(pointer) (unsigned int)((RAM[pointer]<<16)|(RAM[pointer+1]<<8)|RAM[pointer+2])
  32. #define write24(data) \
  33. { \
  34.         OUT[pointer]=data>>16; \
  35.         OUT[pointer+1]=(data>>8)&0xFF; \
  36.         OUT[pointer+2]=data&0xFF; \
  37. }
  38. #define read32(pointer) (unsigned int)((RAM[pointer]<<24)|(RAM[pointer+1]<<16)|(RAM[pointer+2]<<8)|RAM[pointer+3])
  39. #define write32(data) \
  40. { \
  41.         OUT[pointer]=data>>24; \
  42.         OUT[pointer+1]=(data>>16)&0xFF; \
  43.         OUT[pointer+2]=(data>>8)&0xFF; \
  44.         OUT[pointer+3]=data&0xFF; \
  45. }
  46. #define ROM_PATCH(data) \
  47. { \
  48.         RAM[data]=(read24(data)+offset)>>16; \
  49.         RAM[data+1]=((read24(data)+offset)>>8)&0xFF; \
  50.         RAM[data+2]=(read24(data)+offset)&0xFF; \
  51. }
  52.  
  53. #include <stdio.h>
  54.  
  55. int main(int argc, char **argv)
  56. {
  57.     unsigned char gbi_table[0x10]={   4,    6,    2, 0xF1, 0xE1,    8, 0xD9, 0xD9,
  58.                      0xDF, 0xE2, 0xE3, 0xD7, 0xDB, 0xD8,    3,    5};
  59.     int BIG_LIST[0x1388], OPA[0x78]={0}, XLU[0x78]={0}, pointer=0, loop, loop2, map;
  60.     unsigned int geometry_mode;
  61.     int offset,end2, inst, n, v;
  62.     FILE *ROM=fopen(argv[1],"rb");
  63.     fseek(ROM,0,SEEK_END);
  64.     int end=ftell(ROM);
  65.     fseek(ROM,0,SEEK_SET);
  66.     unsigned char *RAM=malloc(end);
  67.     fread(RAM,1,end,ROM);
  68.     fclose(ROM);
  69.     unsigned char *OUT=calloc(0x40000,1);
  70.     printf("Overdump offset: ");
  71.     scanf("%x",&map);
  72.     printf("Bytes inserted: ");
  73.     scanf("%x",&offset);
  74.     unsigned char gbi=0, BIG_COUNT=0, OPA_COUNT=0, XLU_COUNT=0;
  75.     inst=map;
  76.     while(gbi!=0xA)
  77.     {
  78.         gbi=RAM[inst];
  79.         inst+=8;
  80.     }
  81.     pointer=read24(inst-3)+map;
  82.     ROM_PATCH(inst-3);
  83.     goto mesh_handler;
  84.     process_dlist:
  85.     printf("adddlist 0x03%06x\n",inst-map+offset);
  86.     while(gbi!=G_ENDDL)
  87.     {
  88.         gbi=RAM[inst];
  89.         switch(gbi)
  90.         {
  91.             case G_VTX:
  92.                 OUT[pointer]=1;
  93.                 pointer+=1;
  94.                 geometry_mode=read24(inst+1);
  95.                 n=(geometry_mode>>10)&0x3F;
  96.                 v=(geometry_mode>>17);
  97.                 v+=n;
  98.                 geometry_mode=(n<<12)|(v<<1);
  99.                 write24(geometry_mode);
  100.                 pointer+=3;
  101.                 write32(read32(inst+4));
  102.                 pointer+=7;
  103.                 break;
  104.             case G_CLEARGEOMETRYMODE:
  105.             case G_SETGEOMETRYMODE:
  106.                 OUT[pointer]=0xD9;
  107.                 pointer+=1;
  108.                 geometry_mode=read24(inst+5);
  109.                 if((geometry_mode&0x000002)==G_TEXTURE_ENABLE)
  110.                 {
  111.                     printf("We shouldn't encounter this.\n");
  112.                     geometry_mode=(geometry_mode^G_TEXTURE_ENABLE);
  113.                 }
  114.                 if((geometry_mode&0x000200)==G_SHADING_SMOOTH)
  115.                 {
  116.                     geometry_mode=(geometry_mode^G_SHADING_SMOOTH);
  117.                     geometry_mode|=0x200000;
  118.                 }
  119.                 if((geometry_mode&0x001000)==G_CULL_FRONT)
  120.                 {
  121.                     geometry_mode=(geometry_mode^G_CULL_FRONT);
  122.                     geometry_mode|=0x000200;
  123.                 }
  124.                 if((geometry_mode&0x002000)==G_CULL_BACK)
  125.                 {
  126.                     geometry_mode=(geometry_mode^G_CULL_BACK);
  127.                     geometry_mode|=0x000400;
  128.                 }
  129.                 if((geometry_mode&0x800000)==G_CLIPPING)
  130.                 {
  131.                     geometry_mode=(geometry_mode^G_CLIPPING);
  132.                 }
  133.                 if(gbi==G_CLEARGEOMETRYMODE)
  134.                 {
  135.                     write24(0xFFFFFF-geometry_mode);
  136.                     pointer+=7;
  137.                 }
  138.                 if(gbi==G_SETGEOMETRYMODE)
  139.                 {
  140.                     write24(0xFFFFFF);
  141.                     pointer+=4;
  142.                     write24(geometry_mode);
  143.                     pointer+=3;
  144.                 }
  145.                 break;
  146.             case G_TRI1:
  147.                 OUT[pointer]=5;
  148.                 OUT[pointer+1]=RAM[inst+5];
  149.                 OUT[pointer+2]=RAM[inst+6];
  150.                 OUT[pointer+3]=RAM[inst+7];
  151.                 break;
  152.             default:
  153.                 OUT[pointer]=gbi;
  154.                 if(gbi<0xE4&&gbi>=0xB0)
  155.                 {
  156.                     OUT[pointer]=gbi_table[gbi-0xB0];
  157.                 }
  158.                 for(loop=1;loop<8;loop+=1)
  159.                 {
  160.                     OUT[pointer+loop]=RAM[inst+loop];
  161.                 }
  162.                 if(gbi==G_MOVEMEM)
  163.                 {
  164.                     printf("Unhandled movemem %08X\n",pointer);
  165.                 }
  166.                 if(gbi==G_DL)
  167.                 {
  168.                     OUT[pointer]=0xDE;
  169.                 }
  170.                 if(gbi==G_SETOTHERMODE_L||gbi==G_SETOTHERMODE_H)
  171.                 {
  172.                     OUT[pointer+2]=0x20-(RAM[inst+2]+RAM[inst+3]);
  173.                     OUT[pointer+3]=RAM[inst+3]-1;
  174.                 }
  175.                 if(gbi==G_TEXTURE)
  176.                 {
  177.                     OUT[pointer+3]=RAM[inst+3]<<1;
  178.                 }
  179.                 if(gbi==G_MOVEWORD)
  180.                 {
  181.                     printf("Moveword %08X\n",pointer);
  182.                     switch(RAM[inst+3])
  183.                     {
  184.                         case G_MW_NUMLIGHT:
  185.                             OUT[pointer+3]=0;
  186.                             OUT[pointer+1]=G_MW_NUMLIGHT;
  187.                             geometry_mode=((read32(inst+4)-0x80000000)>>5)-1;
  188.                             geometry_mode=geometry_mode*24;
  189.                             pointer+=4;
  190.                             write32(geometry_mode);
  191.                             break;
  192.                         case G_MW_LIGHTCOL:
  193.                             OUT[pointer+3]=0;
  194.                             OUT[pointer+1]=G_MW_LIGHTCOL;
  195.                             geometry_mode=RAM[inst+2];
  196.                             if(geometry_mode==G_MWO_aLIGHT_1)
  197.                             {
  198.                                 OUT[pointer+2]=0;
  199.                                 OUT[pointer+3]=(geometry_mode/0x20)*0x18;
  200.                             }
  201.                             else if(geometry_mode==G_MWO_aLIGHT_2)
  202.                             {
  203.                                 OUT[pointer+2]=0;
  204.                                 OUT[pointer+3]=(geometry_mode/0x20)*0x18;
  205.                             }
  206.                             else if(geometry_mode==G_MWO_aLIGHT_3)
  207.                             {
  208.                                 OUT[pointer+2]=0;
  209.                                 OUT[pointer+3]=(geometry_mode/0x20)*0x18;
  210.                             }
  211.                             else if(geometry_mode==G_MWO_aLIGHT_4)
  212.                             {
  213.                                 OUT[pointer+2]=0;
  214.                                 OUT[pointer+3]=(geometry_mode/0x20)*0x18;
  215.                             }
  216.                             else if(geometry_mode==G_MWO_aLIGHT_5)
  217.                             {
  218.                                 OUT[pointer+2]=0;
  219.                                 OUT[pointer+3]=(geometry_mode/0x20)*0x18;
  220.                             }
  221.                             else if(geometry_mode==G_MWO_aLIGHT_6)
  222.                             {
  223.                                 OUT[pointer+2]=0;
  224.                                 OUT[pointer+3]=(geometry_mode/0x20)*0x18;
  225.                             }
  226.                             else if(geometry_mode==G_MWO_aLIGHT_7)
  227.                             {
  228.                                 OUT[pointer+2]=0;
  229.                                 OUT[pointer+3]=(geometry_mode/0x20)*0x18;
  230.                             }
  231.                             else if(geometry_mode==G_MWO_aLIGHT_8)
  232.                             {
  233.                                 OUT[pointer+2]=0;
  234.                                 OUT[pointer+3]=(geometry_mode/0x20)*0x18;
  235.                             }
  236.                             else
  237.                             {
  238.                                 printf("Unhandled light color.\n");
  239.                             }
  240.                             break;
  241.                         default:
  242.                             OUT[pointer+3]=0;
  243.                             OUT[pointer+1]=RAM[inst+3];
  244.                             printf("Unhandled moveword %08X\n",pointer);
  245.                             break;
  246.                     }
  247.                 }
  248.                 break;
  249.         }
  250.         inst+=8;
  251.         pointer=inst-map;
  252.         switch(gbi) //RECALCULATE THE POINTERS
  253.         {
  254.             case 4:
  255.             case 6:
  256.             case 0xFD:
  257.                 if(OUT[pointer-4]==3)
  258.                 {
  259.                     pointer-=3;
  260.                     write24(read24(inst-3)+offset);
  261.                     pointer+=3;
  262.                 }
  263.                 break;
  264.         }
  265.     }
  266.     geometry_mode=inst;
  267.     if(BIG_COUNT>0)
  268.     {
  269.         for(loop=(inst-map);loop<0x40000;loop+=8)
  270.         {
  271.             for(loop2=0;loop2<end2;loop2+=1)
  272.             {
  273.                 if(BIG_LIST[loop2]==loop+map){break;}
  274.             }
  275.             if(BIG_LIST[loop2]==loop+map){break;}
  276.         }
  277.         for(loop=inst;loop<BIG_LIST[loop2];loop+=1)
  278.         {
  279.             OUT[loop-map]=RAM[loop];
  280.         }
  281.     }
  282.     else
  283.     {
  284.         pointer=0x1000000;
  285.         while(end!=map)
  286.         {
  287.             end=read32(pointer);
  288.             pointer+=4;
  289.             if(end==map&&read32(pointer)==map)
  290.             {
  291.                 pointer+=8;
  292.             }
  293.             if(end==map&&read32(pointer)!=map)
  294.             {
  295.                 pointer+=4;
  296.             }
  297.         }
  298.         end=read32(pointer-4);
  299.         for(loop=inst;loop<end;loop+=1)
  300.         {
  301.             OUT[loop-map]=RAM[loop];
  302.         }
  303.     }
  304.     dlist_lookup:
  305.     if(BIG_COUNT>0)
  306.     {
  307.         gbi=0;
  308.         BIG_COUNT-=1;
  309.         for(loop=(geometry_mode-map);loop<0x40000;loop+=8)
  310.         {
  311.             for(loop2=0;loop2<end2;loop2+=1)
  312.             {
  313.                 if(BIG_LIST[loop2]==loop+map){break;}
  314.             }
  315.             if(BIG_LIST[loop2]==loop+map){break;}
  316.         }
  317.         inst=BIG_LIST[loop2];
  318.         pointer=inst-map;
  319.         end+=1;
  320.         goto process_dlist;
  321.     }
  322.     FILE *DL=fopen("map","wb");
  323.     fwrite(OUT,1,0x40000,DL);
  324.     fclose(DL);
  325.     free(OUT);
  326.     free(RAM);
  327.     system("pause");
  328.     return 0;
  329.     mesh_handler:
  330.     end=RAM[pointer+1];
  331.     inst=read24(pointer+5)+map;
  332.     ROM_PATCH(pointer+5);
  333.     ROM_PATCH(pointer+9);
  334.     switch(RAM[pointer])
  335.     {
  336.         case 0:
  337.             for(loop2=0;loop2<end;loop2+=1)
  338.             {
  339.                 if(RAM[inst+8*loop2]>0)
  340.                 {
  341.                     OPA[OPA_COUNT]=read24(inst+8*loop2+1)+map;
  342.                     OPA_COUNT+=1;
  343.                     ROM_PATCH(inst+8*loop2+1);
  344.                 }
  345.                 if(RAM[inst+8*loop2+4]>0)
  346.                 {
  347.                     XLU[XLU_COUNT]=read24(inst+8*loop2+5)+map;
  348.                     XLU_COUNT+=1;
  349.                     ROM_PATCH(inst+8*loop2+5);
  350.                 }
  351.             }
  352.             break;
  353.         case 2:
  354.             for(loop2=0;loop2<end;loop2+=1)
  355.             {
  356.                 if(RAM[inst+0x10*loop2+8]>0)
  357.                 {
  358.                     OPA[OPA_COUNT]=read24(inst+0x10*loop2+9)+map;
  359.                     OPA_COUNT+=1;
  360.                     ROM_PATCH(inst+0x10*loop2+9);
  361.                 }
  362.                 if(RAM[inst+0x10*loop2+0xC]>0)
  363.                 {
  364.                     XLU[XLU_COUNT]=read24(inst+0x10*loop2+0xD)+map;
  365.                     XLU_COUNT+=1;
  366.                     ROM_PATCH(inst+0x10*loop2+0xD);
  367.                 }
  368.             }
  369.             break;
  370.     }
  371.     end=0;
  372.     end2=0;
  373.     while(OPA_COUNT>0)
  374.     {
  375.         OPA_COUNT-=1;
  376.         pointer=OPA[end];
  377.         while(gbi!=G_ENDDL)
  378.         {
  379.             gbi=RAM[pointer];
  380.             if(gbi==G_DL&&RAM[pointer+4]==3)
  381.             {
  382.                 BIG_LIST[BIG_COUNT]=read24(pointer+5)+map;
  383.                 BIG_COUNT+=1;
  384.                 if(pointer==OPA[end])
  385.                 {
  386.                     printf("Display List %06X\n",pointer-map+offset);
  387.                 }
  388.             }
  389.             pointer+=8;
  390.         }
  391.         end+=1;
  392.         gbi=0;
  393.     }
  394.     while(XLU_COUNT>0)
  395.     {
  396.         XLU_COUNT-=1;
  397.         pointer=XLU[end2];
  398.         while(gbi!=G_ENDDL)
  399.         {
  400.             gbi=RAM[pointer];
  401.             if(gbi==G_DL&&RAM[pointer+4]==3)
  402.             {
  403.                 BIG_LIST[BIG_COUNT]=read24(pointer+5)+map;
  404.                 BIG_COUNT+=1;
  405.                 if(pointer==XLU[end2])
  406.                 {
  407.                     printf("Display List %06X\n",pointer-map+offset);
  408.                 }
  409.             }
  410.             pointer+=8;
  411.         }
  412.         end2+=1;
  413.         gbi=0;
  414.     }
  415.     end=0;
  416.     end2=0;
  417.     for(loop=0;loop<0x78;loop+=1)
  418.     {
  419.         if(OPA[loop]>0)
  420.         {
  421.             for(loop2=0;loop2<BIG_COUNT;loop2+=1)
  422.             {
  423.                 if(BIG_LIST[loop2]==OPA[loop])
  424.                 {
  425.                     break;
  426.                 }
  427.             }
  428.             if(loop2==BIG_COUNT)
  429.             {
  430.                 BIG_LIST[BIG_COUNT]=OPA[loop];
  431.                 BIG_COUNT+=1;
  432.             }
  433.         }
  434.         if(XLU[loop]>0)
  435.         {
  436.             for(loop2=0;loop2<BIG_COUNT;loop2+=1)
  437.             {
  438.                 if(BIG_LIST[loop2]==XLU[loop])
  439.                 {
  440.                     break;
  441.                 }
  442.             }
  443.             if(loop2==BIG_COUNT)
  444.             {
  445.                 BIG_LIST[BIG_COUNT]=XLU[loop];
  446.                 BIG_COUNT+=1;
  447.             }
  448.         }
  449.     }
  450.     for(loop=0;loop<0x40000;loop+=8)
  451.     {
  452.         for(loop2=0;loop2<BIG_COUNT;loop2+=1)
  453.         {
  454.             if(BIG_LIST[loop2]==loop+map){break;}
  455.         }
  456.         if(BIG_LIST[loop2]==loop+map){break;}
  457.     }
  458.     for(loop=map;loop<BIG_LIST[loop2];loop+=1)
  459.     {
  460.         OUT[loop-map]=RAM[loop];
  461.     }
  462.     end2=BIG_COUNT;
  463.     geometry_mode=map;
  464.     goto dlist_lookup;
  465. }
  466.  
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!