API tools faq
paste
stoneharry

Untitled

stoneharry
Jun 30th, 2013
244
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 7.86 KB | None | 0 0
raw download clone embed print report
  1. //#include <stdlib.h>
  2. #include <iostream>
  3. #include <cassert>
  4. #include <vector>
  5. #include <stdint.h>
  6. #include <cfloat>
  7. #include <string>
  8.  
  9. const char* getfield(char* line, int num);
  10. int to_int(char const *s, size_t count);
  11.  
  12. template<int N>
  13. struct VecF
  14. {
  15.   float d[N];
  16.   VecF(float x[N])
  17.   {
  18.     for(int i=0;i<N;i++) d[i]=x[i];
  19.   }
  20.   VecF()
  21.   {
  22.     for(int i=0;i<N;i++) d[i]=0.0f;
  23.   }
  24. };
  25.  
  26. template<typename T>
  27. struct timestampedValue
  28. {
  29.   uint32_t stamp;
  30.   T data;
  31. };
  32.  
  33. template<typename T>
  34. void wr(char* file,size_t pos,T value)
  35. {
  36.   *((T*)(file+pos)) = value;
  37. }
  38.  
  39. void wrHeader(char* file)
  40. {
  41.   wr(file,0x000,'02DM');
  42.   wr(file,0x004,0x00000108);
  43.   wr(file,0x008,0x00000005);
  44.   wr(file,0x00c,0x00000130);
  45.   wr(file,0x01c,0x00000001);
  46.   wr(file,0x020,0x00000140);
  47.   wr(file,0x02c,0x00000001);
  48.   wr(file,0x030,0x00000180);
  49.   wr(file,0x034,0x00000001);
  50.   wr(file,0x038,0x000001e0);
  51.   wr(file,0x044,0x00000001);
  52.   wr(file,0x0a0,0x7F7FFFFF);
  53.   wr(file,0x0a4,0x7F7FFFFF);
  54.   wr(file,0x0a8,0x7F7FFFFF);
  55.   wr(file,0x0ac,0xFF7FFFFF);
  56.   wr(file,0x0b0,0xFF7FFFFF);
  57.   wr(file,0x0b4,0xFF7FFFFF);
  58.   wr(file,0x110,0x00000001);
  59.   wr(file,0x114,0x00000200);
  60.   wr(file,0x118,0x00000001);
  61.   wr(file,0x11c,0x000001f0);
  62.   wr(file,0x130,'_MAC');
  63. }
  64.  
  65. void wrAnimations(char* file, int animationlength)
  66. {
  67.   wr(file,0x144,animationlength);
  68.   wr(file,0x14c,0x00000020);
  69.   wr(file,0x150,0x00007fff);
  70.   wr(file,0x160,0x7F7FFFFF);
  71.   wr(file,0x164,0x7F7FFFFF);
  72.   wr(file,0x168,0x7F7FFFFF);
  73.   wr(file,0x16c,0xFF7FFFFF);
  74.   wr(file,0x170,0xFF7FFFFF);
  75.   wr(file,0x174,0xFF7FFFFF);
  76.   wr(file,0x17c,0x0000FFFF);
  77. }
  78.  
  79. void wrBones(char* file)
  80. {
  81.   wr(file,0x180,0xFFFFFFFF);
  82.   wr(file,0x188,0x0000FFFF);
  83.   wr(file,0x190,0xFFFF0000);
  84.   wr(file,0x1a4,0xFFFF0000);
  85.   wr(file,0x1b8,0xFFFF0000);
  86.  
  87.   wr(file,0x1e0,0x0000FFFF);
  88. }
  89.  
  90. void wrCameras(char* file, const VecF<3>& position, const VecF<3>& target, const std::vector<timestampedValue<VecF<3> > >& rolls, const std::vector<timestampedValue<VecF<9> > >& positions, const std::vector<timestampedValue<VecF<9> > >& targets)
  91. {
  92.   float fov = 0.785398f;
  93.   float farclip = 27.7778f;
  94.   float nearclip = 0.222222f;
  95.  
  96.   wr(file,0x1f0,0x0000FFFF);
  97.  
  98.   wr(file,0x200,0xFFFFFFFF);
  99.   wr(file,0x204,fov);
  100.   wr(file,0x208,farclip);
  101.   wr(file,0x20c,nearclip);
  102.   wr(file,0x210,0xFFFF0001);
  103.   wr(file,0x214,0x00000001);
  104.   wr(file,0x218,0x00000270);
  105.   wr(file,0x21c,0x00000001);
  106.   wr(file,0x220,0x00000278);
  107.   wr(file,0x224,position);
  108.   wr(file,0x230,0xFFFF0001);
  109.   wr(file,0x234,0x00000001);
  110.   wr(file,0x238,0x00000280);
  111.   wr(file,0x23c,0x00000001);
  112.   wr(file,0x240,0x00000288);
  113.   wr(file,0x244,target);
  114.   wr(file,0x250,0xFFFF0002);
  115.   wr(file,0x254,0x00000001);
  116.   wr(file,0x258,0x00000290);
  117.   wr(file,0x25c,0x00000001);
  118.   wr(file,0x260,0x00000298);
  119.  
  120.   uint32_t pos_timestamps = 0x2a0;
  121.   uint32_t pos_data = pos_timestamps + positions.size() * sizeof(uint32_t);
  122.  
  123.   uint32_t tar_timestamps = pos_data + positions.size() * sizeof(float)*9;
  124.   uint32_t tar_data = tar_timestamps + targets.size() * sizeof(uint32_t);
  125.  
  126.   uint32_t roll_timestamps = tar_data + targets.size() * sizeof(float)*9;
  127.   uint32_t roll_data = roll_timestamps + rolls.size() * sizeof(uint32_t);
  128.  
  129.   wr(file,0x270,positions.size());
  130.   wr(file,0x274,pos_timestamps);
  131.   wr(file,0x278,positions.size());
  132.   wr(file,0x27c,pos_data);
  133.   wr(file,0x280,targets.size());
  134.   wr(file,0x284,tar_timestamps);
  135.   wr(file,0x288,targets.size());
  136.   wr(file,0x28c,tar_data);
  137.   wr(file,0x290,rolls.size());
  138.   wr(file,0x294,roll_timestamps);
  139.   wr(file,0x298,rolls.size());
  140.   wr(file,0x29c,roll_data);
  141.  
  142.   for(int i=0;i<positions.size();++i)
  143.   {
  144.     wr(file,pos_timestamps+sizeof(uint32_t)*i,positions[i].stamp);
  145.     wr(file,pos_data+sizeof(float)*9*i,positions[i].data);
  146.   }
  147.  
  148.   for(int i=0;i<targets.size();++i)
  149.   {
  150.     wr(file,tar_timestamps+sizeof(uint32_t)*i,targets[i].stamp);
  151.     wr(file,tar_data+sizeof(float)*9*i,targets[i].data);
  152.   }
  153.  
  154.   for(int i=0;i<rolls.size();++i)
  155.   {
  156.     wr(file,roll_timestamps+sizeof(uint32_t)*i,rolls[i].stamp);
  157.     wr(file,roll_data+sizeof(float)*3*i,rolls[i].data);
  158.   }
  159. }
  160.  
  161. int main(int argc,char** argv)
  162. {
  163.     // Change this - it is how long the cinematic lasts for (30000 = 30 seconds)
  164.     int animationlength = 45000;
  165.  
  166.     std::vector<timestampedValue<VecF<3> > > rolls;
  167.     std::vector<timestampedValue<VecF<9> > > positions;
  168.     std::vector<timestampedValue<VecF<9> > > targets;
  169.  
  170.     // Hold temp data
  171.     timestampedValue<VecF<9> > fake9;
  172.  
  173.     // Positions push data into real vector
  174.     fake9.stamp = 0000; fake9.data.d[0] = 208.00f; fake9.data.d[1] = 3.00f; fake9.data.d[2] = 9.00f;
  175.     positions.push_back(fake9);
  176.     fake9.stamp = 19000; fake9.data.d[0] = 70.00f; fake9.data.d[1] = 3.00f; fake9.data.d[2] = 8.00f;
  177.     positions.push_back(fake9);
  178.     fake9.stamp = 25000; fake9.data.d[0] = 60.00f; fake9.data.d[1] = 40.00f; fake9.data.d[2] = 8.00f;
  179.     positions.push_back(fake9);
  180.     fake9.stamp = 30000; fake9.data.d[0] = 68.00f; fake9.data.d[1] = 66.00f; fake9.data.d[2] = 10.00f;
  181.     positions.push_back(fake9);
  182.     fake9.stamp = 34000; fake9.data.d[0] = 82.00f; fake9.data.d[1] = 66.00f; fake9.data.d[2] = 14.00f;
  183.     positions.push_back(fake9);
  184.     //fake9.stamp = 37000; fake9.data.d[0] = 90.00f; fake9.data.d[1] = 67.00f; fake9.data.d[2] = 16.00f;
  185.     //positions.push_back(fake9);
  186.     //fake9.stamp = 44000; fake9.data.d[0] = 70.00f; fake9.data.d[1] = 95.00f; fake9.data.d[2] = 16.00f;
  187.     //positions.push_back(fake9);
  188.     //fake9.stamp = 55000; fake9.data.d[0] = 60.00f; fake9.data.d[1] = 60.00f; fake9.data.d[2] = 16.50f;
  189.     //positions.push_back(fake9);
  190.     fake9.stamp = 34100; fake9.data.d[0] = 90.00f; fake9.data.d[1] = 120.00f; fake9.data.d[2] = 16.00f;
  191.     positions.push_back(fake9);
  192.     fake9.stamp = 40000; fake9.data.d[0] = 128.00f; fake9.data.d[1] = 124.00f; fake9.data.d[2] = 16.00f;
  193.     positions.push_back(fake9);
  194.  
  195.     // Targets push data into real vector
  196.     fake9.stamp = 0000; fake9.data.d[0] = 0.00f; fake9.data.d[1] = 0.00f; fake9.data.d[2] = 3.00f;
  197.     targets.push_back(fake9);
  198.     fake9.stamp = 18000; fake9.data.d[0] = 0.00f; fake9.data.d[1] = 0.00f; fake9.data.d[2] = 5.00f;
  199.     targets.push_back(fake9);
  200.     fake9.stamp = 20000; fake9.data.d[0] = 60.00f; fake9.data.d[1] = 40.00f; fake9.data.d[2] = 8.00f;
  201.     targets.push_back(fake9);
  202.     fake9.stamp = 30000; fake9.data.d[0] = 100.00f; fake9.data.d[1] = 100.00f; fake9.data.d[2] = 15.00f;
  203.     targets.push_back(fake9);
  204.     fake9.stamp = 35000; fake9.data.d[0] = 135.00f; fake9.data.d[1] = 125.00f; fake9.data.d[2] = 13.50f;
  205.     targets.push_back(fake9);
  206.    
  207.     VecF<3> position; position.d[0] = 0.0f; position.d[1] = 0.0f; position.d[2] = 1.0f;
  208.     VecF<3> target; target.d[0] = 0.0f; target.d[1] = 0.0f; target.d[2] = 2.0f;
  209.    
  210.     uint32_t size = 0x2a0 + (positions.size()+targets.size()) * (sizeof(uint32_t)+sizeof(float)*9) + rolls.size() * (sizeof(uint32_t)+sizeof(float)*3);
  211.  
  212.     char* file = new char[size];
  213.     memset(file,0,size);
  214.  
  215.     wrHeader(file);
  216.     wrAnimations(file, animationlength);
  217.     wrBones(file);
  218.     wrCameras(file, position, target, rolls, positions, targets);
  219.  
  220.     FILE* f = fopen("C:\\WoW 3.3.5\\Cameras\\FallOfDalaran.m2","w+");
  221.     fwrite(file,size,1,f);
  222.     fclose(f);
  223.  
  224.     delete[] file;
  225.  
  226.     return 0;
  227. }
  228.  
  229. const char* getfield(char* line, int num)
  230. {
  231.     const char* tok;
  232.     for (tok = strtok(line, ",");
  233.             tok && *tok;
  234.             tok = strtok(NULL, ",\n"))
  235.     {
  236.         if (!--num)
  237.             return tok;
  238.     }
  239.     return NULL;
  240. }
  241.  
  242. int to_int(char const *s, size_t count)
  243. {
  244.      size_t i = 0 ;
  245.      if ( s[0] == '+' || s[0] == '-' )
  246.           ++i;
  247.      int result = 0;
  248.      while(s[i] != '.')
  249.      {
  250.           if ( s[i] >= '0' && s[i] <= '9' )
  251.           {
  252.               result = result * 10  - (s[i] - '0');  //assume negative number
  253.           }
  254.           else
  255.               throw std::invalid_argument("invalid input string");
  256.           i++;
  257.      }
  258.      return s[0] == '-' ? result : -result; //-result is positive!
  259. }
Advertisement
Add Comment
Please, Sign In to add comment
Public Pastes
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!