home *** CD-ROM | disk | FTP | other *** search
/ Xentax forum attachments archive / xentax.7z / 5257 / source.7z / main.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2012-04-05  |  17.8 KB  |  520 lines
  1. #include "xentax.h"
  2. #include "stdres.h"
  3. #include "x_pssg.h"
  4.  
  5. // GAMES (PS3)
  6. #include "ps3_touchshot.h"
  7. #include "ps3_one_piece.h"
  8. #include "ps3_neptunia_mk2.h"
  9.  
  10. // GAMES (XBOX360)
  11. #include "xb360_onechanbara2.h"
  12.  
  13. #include "x_stream.h"
  14. #include "x_smc.h"
  15. #include "x_lwo.h"
  16.  
  17. //bool TestG1M_0034(const char* filename);
  18. //bool TestG1MG0044(const binary_stream& bs);
  19.  
  20. #include "x_file.h"
  21.  
  22. int main()
  23. {
  24.  //XB360::Onechanbara2::extract();
  25.  PSSG::extract();
  26.  
  27.  //PS3::OnePiece::extract();
  28.  //PS3::TOUCHSHOT::extract();
  29.  //PS3::NEPTUNIA_MK2::extract();
  30.  
  31.  //TestG1M_0034("test.g1m");
  32.  return 0;
  33. }
  34.  
  35. /*
  36. bool TestG1M_0034(const char* filename)
  37. {
  38.  using namespace std;
  39.  
  40.  // open file
  41.  ifstream ifile(filename, ios::binary);
  42.  if(!ifile) return error("Failed to open file.");
  43.  
  44.  // compute filesize
  45.  ifile.seekg(0, ios::end);
  46.  uint32 filesize = (uint32)ifile.tellg();
  47.  ifile.seekg(0, ios::beg);
  48.  
  49.  // read file
  50.  boost::shared_array<char> data(new char[filesize]);
  51.  ifile.read(data.get(), filesize);
  52.  
  53.  // create binary stream
  54.  binary_stream bs(data, filesize);
  55.  
  56.  // read header
  57.  uint32 head01 = bs.BE_read_uint32(); // magic
  58.  uint32 head02 = bs.BE_read_uint32(); // version
  59.  uint32 head03 = bs.BE_read_uint32(); // total section size
  60.  uint32 head04 = bs.BE_read_uint32(); // start offset
  61.  uint32 head05 = bs.BE_read_uint32(); // 0x00
  62.  uint32 head06 = bs.BE_read_uint32(); // number of chunks to read
  63.  
  64.  // validate header
  65.  if(head01 != 0x47314D5F) return error("Expecting G1M_ section.");
  66.  if(head02 != 0x30303334) return error("Invalid G1M_ version.");
  67.  if(head03 == 0) return error("Invalid G1M_.");
  68.  if(head04 == 0) return error("Invalid G1M_.");
  69.  
  70.  // move to start
  71.  bs.seek(head04);
  72.  if(bs.fail()) return error("processG1M: Seek failure.");
  73.  
  74.  // read chunks
  75.  for(uint32 i = 0; i < head06; i++)
  76.     {
  77.      // read first chunk
  78.      uint32 chunkname = bs.BE_read_uint32(); // chunk name
  79.      uint32 chunkvers = bs.BE_read_uint32(); // chunk version
  80.      uint32 chunksize = bs.BE_read_uint32(); // chunk size
  81.  
  82.      // process chunk
  83.      switch(chunkname) {
  84.        case(0x47314D46) : { // G1MF
  85.             bs.move(chunksize - 0x0C);
  86.             break;
  87.            }
  88.        case(0x47314D53) : { // G1MS
  89.             bs.move(chunksize - 0x0C);
  90.             break;
  91.            }
  92.        case(0x47314D4D) : { // G1MM
  93.             bs.move(chunksize - 0x0C);
  94.             break;
  95.            }
  96.        case(0x47314D47) : { // G1MG
  97.             if(!TestG1MG0044(bs)) return false;
  98.             bs.move(chunksize - 0x0C);
  99.             break;
  100.            }
  101.        case(0x45585452) : { // EXTR
  102.             bs.move(chunksize - 0x0C);
  103.             break;
  104.            }
  105.        default : {
  106.             stringstream ss;
  107.             ss << "processG1M: Unknown chunk 0x" << std::hex << chunkname << std::dec << ".";
  108.             return error(ss.str().c_str());
  109.            }
  110.       }
  111.     }
  112.  
  113.  return true;
  114. }
  115.  
  116. bool TestG1MG0044(const binary_stream& bs)
  117. {
  118.  using namespace std;
  119.  
  120.  // copy stream
  121.  binary_stream stream(bs);
  122.  if(stream.fail()) return error("Cannot copy binary stream.");
  123.  
  124.  // read header
  125.  uint32 platform = stream.BE_read_uint32();
  126.  uint32 unknown1 = stream.BE_read_uint32();
  127.  real32 min_x = stream.BE_read_real32();
  128.  real32 min_y = stream.BE_read_real32();
  129.  real32 min_z = stream.BE_read_real32();
  130.  real32 max_x = stream.BE_read_real32();
  131.  real32 max_y = stream.BE_read_real32();
  132.  real32 max_z = stream.BE_read_real32();
  133.  uint32 sections = stream.BE_read_uint32();
  134.  
  135.  // validate header
  136.  if(platform != 0x50533300) return error("Only PS3 version of game is supported.");
  137.  if(sections == 0) return error("Invalid number of sections.");
  138.  
  139.  cout << "HEADER:" << endl;
  140.  cout << " Number of sections: " << sections << endl;
  141.  cout << endl;
  142.  
  143.  // section information
  144.  struct G1MG0044_ITEM {
  145.   uint32 type;
  146.   uint32 size;
  147.   uint32 elem;
  148.   boost::shared_array<char> data;
  149.  };
  150.  
  151.  // read section information
  152.  deque<G1MG0044_ITEM> items;
  153.  for(size_t i = 0; i < sections; i++) {
  154.      G1MG0044_ITEM item;
  155.      item.type = stream.BE_read_uint32();
  156.      item.size = stream.BE_read_uint32();
  157.      item.elem = stream.BE_read_uint32();
  158.      item.data.reset(new char[item.size - 0xC]);
  159.      stream.read(item.data.get(), item.size - 0xC);
  160.      items.push_back(item);
  161.     }
  162.  
  163.  // test OBJ
  164.  ofstream ofile("test.obj");
  165.  ofile << "o test.obj" << endl;
  166.  
  167.  // for each section
  168.  for(size_t i = 0; i < items.size(); i++)
  169.     {
  170.      // 
  171.      if(items[i].type == 0x00010001)
  172.        {
  173.         cout << "0x00010001: " << items[i].elem << endl;
  174.        }
  175.      // 
  176.      else if(items[i].type == 0x00010002)
  177.        {
  178.         cout << "0x00010002: " << items[i].elem << endl;
  179.        }
  180.      // 
  181.      else if(items[i].type == 0x00010003)
  182.        {
  183.         cout << "0x00010003: " << items[i].elem << endl;
  184.        }
  185.      // vertex section
  186.      else if(items[i].type == 0x00010004)
  187.        {
  188.         cout << "0x00010004: " << items[i].elem << endl;
  189.  
  190.         // binary stream from data
  191.         binary_stream ss(items[i].data, items[i].size - 0x8);
  192.         ss.seek(0);
  193.  
  194.         // read vertex sections
  195.         uint32 n_meshes = items[i].elem;
  196.         cout << "Meshes = " << n_meshes << endl;
  197.  
  198.         for(size_t j = 0; j < n_meshes; j++)
  199.            {
  200.             // read mesh vertex info
  201.             uint32 unknown1 = ss.BE_read_uint32();
  202.             uint32 vertsize = ss.BE_read_uint32();
  203.             uint32 vertices = ss.BE_read_uint32();
  204.             uint32 unknown2 = ss.BE_read_uint32();
  205.  
  206.             cout << "Mesh #" << j << endl;
  207.             cout << " vertsize = " << vertsize << endl;
  208.             cout << " vertices = " << vertices << endl;
  209.  
  210.             // buffer name
  211.             stringstream name;
  212.             name << "vb_" << setfill('0') << setw(2) << i;
  213.  
  214.             // set vertex buffer properties
  215.             VTX_BUFFER vb;
  216.             vb.flags = 0;
  217.             vb.name = name.str();
  218.             vb.elem = vertices;
  219.             vb.data.reset(new VERTEX[vertices]);
  220.  
  221.             // set vertex buffer flags
  222.             if(vertsize == 0x10) {
  223.                vb.flags |= VERTEX_POSITION;
  224.                vb.flags |= VERTEX_NORMAL;
  225.                vb.flags |= VERTEX_UV;
  226.               }
  227.             else if(vertsize == 0x14) {
  228.                vb.flags |= VERTEX_POSITION;
  229.                vb.flags |= VERTEX_NORMAL;
  230.                vb.flags |= VERTEX_UV;
  231.               }
  232.             else if(vertsize == 0x18) {
  233.                vb.flags |= VERTEX_POSITION;
  234.                vb.flags |= VERTEX_NORMAL;
  235.               }
  236.             else if(vertsize == 0x1C) {
  237.                vb.flags |= VERTEX_POSITION;
  238.                vb.flags |= VERTEX_NORMAL;
  239.                vb.flags |= VERTEX_UV;
  240.               }
  241.             else if(vertsize == 0x20) {
  242.                vb.flags |= VERTEX_POSITION;
  243.                vb.flags |= VERTEX_NORMAL;
  244.                vb.flags |= VERTEX_UV;
  245.               }
  246.             else if(vertsize == 0x24) {
  247.                vb.flags |= VERTEX_POSITION;
  248.                vb.flags |= VERTEX_NORMAL;
  249.                vb.flags |= VERTEX_UV;
  250.               }
  251.             else if(vertsize == 0x28) {
  252.               }
  253.             else if(vertsize == 0x38) {
  254.                vb.flags |= VERTEX_POSITION;
  255.                vb.flags |= VERTEX_NORMAL;
  256.                vb.flags |= VERTEX_UV;
  257.               }
  258.             else
  259.                return error("Unknown vertex format.");
  260.  
  261.             // read vertices
  262.             for(size_t k = 0; k < vertices; k++)
  263.                {
  264.                 VERTEX vertex;
  265.                 if(vertsize == 0x10) {
  266.                    vertex.vx = ss.BE_read_real16();
  267.                    vertex.vy = ss.BE_read_real16();
  268.                    vertex.vz = ss.BE_read_real16();
  269.                    ss.BE_read_real16();
  270.                    vertex.nx = ss.BE_read_real16();
  271.                    vertex.ny = ss.BE_read_real16();
  272.                    vertex.nz = ss.BE_read_real16();
  273.                    ss.BE_read_real16();
  274.                   }
  275.                 else if(vertsize == 0x14) {
  276.                    vertex.vx = ss.BE_read_real16();
  277.                    vertex.vy = ss.BE_read_real16();
  278.                    vertex.vz = ss.BE_read_real16();
  279.                    ss.BE_read_real16();
  280.                    vertex.nx = ss.BE_read_real16();
  281.                    vertex.ny = ss.BE_read_real16();
  282.                    vertex.nz = ss.BE_read_real16();
  283.                    ss.BE_read_real16();
  284.                    vertex.tu = ss.BE_read_real16();
  285.                    vertex.tv = ss.BE_read_real16();
  286.                   }
  287.                 else if(vertsize == 0x18) {
  288.                    vertex.vx = ss.BE_read_real32();
  289.                    vertex.vy = ss.BE_read_real32();
  290.                    vertex.vz = ss.BE_read_real32();
  291.                    vertex.nx = ss.BE_read_real16();
  292.                    vertex.ny = ss.BE_read_real16();
  293.                    vertex.nz = ss.BE_read_real16();
  294.                    ss.BE_read_real16();
  295.                    ss.BE_read_real32();
  296.                   }
  297.                 else if(vertsize == 0x1C) {
  298.                    vertex.vx = ss.BE_read_real32();
  299.                    vertex.vy = ss.BE_read_real32();
  300.                    vertex.vz = ss.BE_read_real32();
  301.                    vertex.nx = ss.BE_read_real16();
  302.                    vertex.ny = ss.BE_read_real16();
  303.                    vertex.nz = ss.BE_read_real16();
  304.                    ss.BE_read_real16();
  305.                    ss.BE_read_real32();
  306.                    vertex.tu = ss.BE_read_real16();
  307.                    vertex.tv = ss.BE_read_real16();
  308.                   }
  309.                 else if(vertsize == 0x20) {
  310.                    vertex.vx = ss.BE_read_real32();
  311.                    vertex.vy = ss.BE_read_real32();
  312.                    vertex.vz = ss.BE_read_real32();
  313.                    vertex.nx = ss.BE_read_real16();
  314.                    vertex.ny = ss.BE_read_real16();
  315.                    vertex.nz = ss.BE_read_real16();
  316.                    ss.BE_read_real16();
  317.                    ss.BE_read_real32();
  318.                    ss.BE_read_real16();
  319.                    ss.BE_read_real16();
  320.                    vertex.tu = ss.BE_read_real16();
  321.                    vertex.tv = ss.BE_read_real16();
  322.                   }
  323.                 else if(vertsize == 0x24) {
  324.                    vertex.vx = ss.BE_read_real32();
  325.                    vertex.vy = ss.BE_read_real32();
  326.                    vertex.vz = ss.BE_read_real32();
  327.                    vertex.nx = ss.BE_read_real32();
  328.                    vertex.ny = ss.BE_read_real32();
  329.                    vertex.nz = ss.BE_read_real32();
  330.                    ss.BE_read_real32();
  331.                    vertex.tu = ss.BE_read_real32();
  332.                    vertex.tv = ss.BE_read_real32();
  333.                   }
  334.                 else if(vertsize == 0x28) {
  335.                    ss.BE_read_real32(); // TODO
  336.                    ss.BE_read_real32();
  337.                    ss.BE_read_real32();
  338.                    ss.BE_read_real32();
  339.                    ss.BE_read_real32();
  340.                    ss.BE_read_real32();
  341.                    ss.BE_read_real32();
  342.                    ss.BE_read_real32();
  343.                    ss.BE_read_real32();
  344.                    ss.BE_read_real32();
  345.                   }
  346.                 else if(vertsize == 0x38) {
  347.                    vertex.vx = ss.BE_read_real32(); // x
  348.                    vertex.vy = ss.BE_read_real32(); // y
  349.                    vertex.vz = ss.BE_read_real32(); // z
  350.                    ss.BE_read_real32(); // 1.0
  351.                    ss.BE_read_real32(); // w1
  352.                    ss.BE_read_real32(); // w2
  353.                    ss.BE_read_real32(); // w3
  354.                    (uint32)ss.BE_read_uint08();
  355.                    (uint32)ss.BE_read_uint08();
  356.                    (uint32)ss.BE_read_uint08();
  357.                    (uint32)ss.BE_read_uint08();
  358.                    ss.BE_read_real16();
  359.                    ss.BE_read_real16();
  360.                    ss.BE_read_real16();
  361.                    ss.BE_read_real16();
  362.                    vertex.tu = ss.BE_read_real32(); // u
  363.                    vertex.tv = ss.BE_read_real32(); // v
  364.                    ss.BE_read_real32();
  365.                    ss.BE_read_real32();
  366.  
  367.                    ofile << "v " << vertex.vx << " " << vertex.vy << " " << vertex.vz << endl;
  368.                   }
  369.  
  370.                 // save vertex
  371.                 vb.data[k] = vertex;
  372.                }
  373.            }
  374.        }
  375.      // 
  376.      else if(items[i].type == 0x00010005)
  377.        {
  378.         cout << "0x00010005: " << items[i].elem << endl;
  379.        }
  380.      // 
  381.      else if(items[i].type == 0x00010006)
  382.        {
  383.         cout << "0x00010006: " << items[i].elem << endl;
  384.        }
  385.      // index buffer section
  386.      else if(items[i].type == 0x00010007)
  387.        {
  388.         cout << "0x00010007: " << items[i].elem << endl;
  389.  
  390.         // binary stream from data
  391.         binary_stream ss(items[i].data, items[i].size - 0x8);
  392.         ss.seek(0);
  393.  
  394.         // read face sections
  395.         uint32 n_meshes = items[i].elem;
  396.         uint32 vb_index = 0;
  397.         for(size_t j = 0; j < n_meshes; j++)
  398.            {
  399.             // read face data
  400.             uint32 numindex = ss.BE_read_uint32();
  401.             uint32 datatype = ss.BE_read_uint32();
  402.             uint32 unknown1 = ss.BE_read_uint32();
  403.  
  404.             // set index buffer properties
  405.             IDX_BUFFER ib;
  406.             ib.type = FACE_TYPE_TRISTRIP;
  407.             ib.elem = numindex;
  408.             if(datatype == 0x10) ib.format = FACE_FORMAT_UINT_16;
  409.             else if(datatype == 0x20) ib.format = FACE_FORMAT_UINT_32;
  410.             else return error("Unknown index buffer data format.");
  411.  
  412.             // set index buffer name
  413.             stringstream surface;
  414.             surface << "surface_" << setfill('0') << setw(3) << j << ends;
  415.             ib.name = surface.str();
  416.  
  417.             // determine index buffer data type size
  418.             unsigned int typesize = 0;
  419.             if(datatype == 0x10) typesize = sizeof(uint16);
  420.             else if(datatype == 0x20) typesize = sizeof(uint32);
  421.             else return error("Unknown index buffer data type.");
  422.  
  423.             // read face data
  424.             unsigned int total_bytes = ib.elem*typesize;
  425.             ib.data.reset(new char[total_bytes]);
  426.             if(ib.format == FACE_FORMAT_UINT_16) ss.BE_read_array(reinterpret_cast<uint16*>(ib.data.get()), ib.elem);
  427.             else if(ib.format == FACE_FORMAT_UINT_32) ss.BE_read_array(reinterpret_cast<uint32*>(ib.data.get()), ib.elem);
  428.  
  429.             // test face data
  430.             uint32 min_index = 0;
  431.             uint32 max_index = 0;
  432.             if(ib.format == FACE_FORMAT_UINT_16) {
  433.                //uint16 a; minimum(reinterpret_cast<uint16*>(ib.data.get()), ib.elem, a);
  434.                //uint16 b; maximum(reinterpret_cast<uint16*>(ib.data.get()), ib.elem, b);
  435.                //min_index = a;
  436.                //max_index = b;
  437.               }
  438.             else if(ib.format == FACE_FORMAT_UINT_32) {
  439.                //uint32 a; minimum(reinterpret_cast<uint32*>(ib.data.get()), ib.elem, a);
  440.                //uint32 b; maximum(reinterpret_cast<uint32*>(ib.data.get()), ib.elem, b);
  441.                //min_index = a;
  442.                //max_index = b;
  443.               }
  444.             cout << " min index = " << min_index << endl;
  445.             cout << " max index = " << max_index << endl;
  446.  
  447.             // set vertex buffer reference
  448.             //if(min_index == 0) vb_index++; // there has got to be a better way
  449.             //if(vb_index > 0) ib.reference = vb_index - 1;
  450.             //else return error("Unexpected vertex buffer reference.");
  451.  
  452.             // save face data
  453.             //fdlist.push_back(ib);
  454.            }
  455.        }
  456.      // 
  457.      else if(items[i].type == 0x00010008)
  458.        {
  459.         cout << "0x00010008: " << items[i].elem << endl;
  460.  
  461.         // binary stream from data
  462.         binary_stream ss(items[i].data, items[i].size - 0x8);
  463.         ss.seek(0);
  464.  
  465.         struct G10008 {
  466.          uint32 p01; // C0 00 00 D0
  467.          uint32 p02; // 00 00 00 00
  468.          uint32 p03; // 00 00 00 00
  469.          uint32 p04; // 00 00 00 00
  470.          uint32 p05; // 00 00 00 00
  471.          uint32 p06; // 00 00 00 00
  472.          uint32 p07; // 00 00 00 00
  473.          uint32 p08; // 00 00 00 00
  474.          uint32 p09; // 00 00 00 01
  475.          uint32 p10; // 00 00 00 04
  476.          uint32 p11; // 00 00 00 00
  477.          uint32 p12; // 00 00 00 42
  478.          uint32 p13; // 00 00 00 00
  479.          uint32 p14; // 00 00 00 BE
  480.         };
  481.         deque<G10008> infolist;
  482.         for(uint32 j = 0; j < items[i].elem; j++) {
  483.             G10008 info;
  484.             info.p01 = ss.BE_read_uint32();
  485.             info.p02 = ss.BE_read_uint32();
  486.             info.p03 = ss.BE_read_uint32();
  487.             info.p04 = ss.BE_read_uint32();
  488.             info.p05 = ss.BE_read_uint32();
  489.             info.p06 = ss.BE_read_uint32();
  490.             info.p07 = ss.BE_read_uint32();
  491.             info.p08 = ss.BE_read_uint32();
  492.             info.p09 = ss.BE_read_uint32();
  493.             info.p10 = ss.BE_read_uint32();
  494.             info.p11 = ss.BE_read_uint32();
  495.             info.p12 = ss.BE_read_uint32();
  496.             info.p13 = ss.BE_read_uint32();
  497.             info.p14 = ss.BE_read_uint32();
  498.             infolist.push_back(info);
  499.             cout << "info" << endl;
  500.             cout << " " << info.p01 << endl;
  501.             cout << " " << info.p02 << endl;
  502.             cout << " " << info.p03 << endl;
  503.             cout << " " << info.p04 << endl;
  504.             cout << " " << info.p05 << endl;
  505.             cout << " " << info.p06 << endl;
  506.             cout << " " << info.p07 << endl;
  507.             cout << " " << info.p08 << endl;
  508.             cout << " " << info.p09 << endl;
  509.             cout << " " << info.p10 << endl;
  510.             cout << " " << info.p11 << endl;
  511.             cout << " " << info.p12 << endl;
  512.             cout << " " << info.p13 << endl;
  513.             cout << " " << info.p14 << endl;
  514.            }
  515.        }
  516.     }
  517.  
  518.  return true;
  519. }
  520. */