home *** CD-ROM | disk | FTP | other *** search
/ The Party 1994: Try This At Home / disk_image.bin / source / vexsrc / makescn.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1995-03-30  |  12.5 KB  |  643 lines
  1. /*****************************************************************************
  2.                                   ATTENTION!
  3.                            this source is VOTEWARE,
  4.               you may only use it to the conditions listed below:
  5.  
  6.   -You may modify it, or use parts of it in your own source as long as
  7.     this header stays on top of all files containing this source.
  8.   -You must give proper credit to the author, Niklas Beisert / pascal.
  9.   -You may not use it in commercial productions without the written
  10.     permission of the author.
  11.   -AND MOST IMPORTANT: you have to buy an Assembly '94 CD-ROM
  12.     by Sound Solutions (if you don't have it already) and vote for VEX-InTrO
  13.     in the PC-64k-Intro-Compo! (if you have already sent your voting card,
  14.     buy another one and fill it out CORRECTLY!!!)
  15. *****************************************************************************/
  16.  
  17.  
  18.  
  19. // compile the scenery (movements etc.)
  20. // a very stupid compiler, but it does its job...
  21.  
  22. #include <stdlib.h>
  23. #include <string.h>
  24. #include <math.h>
  25. #include <dir.h>
  26. #include <fstream.h>
  27. #include <io.h>
  28. #include <fcntl.h>
  29. #include <sys\stat.h>
  30.  
  31. #define MIN 0.00001
  32.  
  33. struct vector
  34. {
  35.   double v[3];
  36.   vector() { v[0]=v[1]=v[2]=0; }
  37.   double& operator [](int i) { return v[i]; }
  38.   double operator [](int i) const { return v[i]; }
  39. };
  40.  
  41. int operator ==(const vector &v1, const vector &v2)
  42. {
  43.   if (fabs(v1[0]-v2[0])>MIN)
  44.     return 0;
  45.   if (fabs(v1[1]-v2[1])>MIN)
  46.     return 0;
  47.   if (fabs(v1[2]-v2[2])>MIN)
  48.     return 0;
  49.   return 1;
  50. }
  51.  
  52. double operator *(const vector &v1, const vector &v2)
  53. {
  54.   return v1[0]*v2[0]+v1[1]*v2[1]+v1[2]*v2[2];
  55. }
  56.  
  57. vector operator *(const vector &v, double d)
  58. {
  59.   vector vr=v;
  60.   vr[0]*=d;
  61.   vr[1]*=d;
  62.   vr[2]*=d;
  63.   return vr;
  64. }
  65.  
  66. vector& operator /=(vector &v, double d)
  67. {
  68.   v[0]/=d;
  69.   v[1]/=d;
  70.   v[2]/=d;
  71.   return v;
  72. }
  73.  
  74. vector operator +(const vector &v1, const vector &v2)
  75. {
  76.   vector v;
  77.   v[0]=v1[0]+v2[0];
  78.   v[1]=v1[1]+v2[1];
  79.   v[2]=v1[2]+v2[2];
  80.   return v;
  81. }
  82.  
  83. vector operator -(const vector &v1, const vector &v2)
  84. {
  85.   vector v;
  86.   v[0]=v1[0]-v2[0];
  87.   v[1]=v1[1]-v2[1];
  88.   v[2]=v1[2]-v2[2];
  89.   return v;
  90. }
  91.  
  92. vector& operator +=(vector &v1, const vector &v2)
  93. {
  94.   v1[0]+=v2[0];
  95.   v1[1]+=v2[1];
  96.   v1[2]+=v2[2];
  97.   return v1;
  98. }
  99.  
  100. vector norm(const vector& v)
  101. {
  102.   return vector(v)/=sqrt(v*v);
  103. }
  104.  
  105. vector vecxmul(const vector &v1, const vector &v2)
  106. {
  107.   vector v;
  108.   v[0]=v1[1]*v2[2]-v1[2]*v2[1];
  109.   v[1]=v1[2]*v2[0]-v1[0]*v2[2];
  110.   v[2]=v1[0]*v2[1]-v1[1]*v2[0];
  111.   return v;
  112. }
  113.  
  114. istream& operator >>(istream& i, vector& v)
  115. {
  116.   return i >> v[0] >> v[1] >> v[2];
  117. }
  118.  
  119.  
  120. #define CMD_POS 0
  121. #define CMD_ANG 5
  122.  
  123.  
  124. ifstream ifile;
  125. int ofile;
  126.  
  127. char* buf;
  128. const unsigned buflen=16384;
  129.  
  130. void updatetx(vector* tx, double& t0, double t, int lev)
  131. {
  132.   t-=t0;
  133.   int fac[4]={1,1,2,6};
  134.   for (int i=0; i<(lev-1); i++)
  135.     for (int j=i+1; j<lev; j++)
  136.       tx[i]+=tx[j]*(pow(t, j-i)/fac[j-i]);
  137.   t0+=t;
  138. }
  139.  
  140. void writevecs(char* buf, unsigned& bufpos, const vector* v, int n)
  141. {
  142.   for (int i=0; i<n; i++)
  143.   {
  144.     *(long*)(buf+bufpos)=v[i][0]*65536;
  145.     bufpos+=4;
  146.     *(long*)(buf+bufpos)=v[i][1]*65536;
  147.     bufpos+=4;
  148.     *(long*)(buf+bufpos)=v[i][2]*65536;
  149.     bufpos+=4;
  150.   }
  151. }
  152.  
  153. void writeangs(char* buf, unsigned& bufpos, const vector* v, int n)
  154. {
  155.   for (int i=0; i<n; i++)
  156.   {
  157.     *(long*)(buf+bufpos)=v[i][0]*2048/360;
  158.     bufpos+=4;
  159.     *(long*)(buf+bufpos)=v[i][1]*2048/360;
  160.     bufpos+=4;
  161.     *(long*)(buf+bufpos)=v[i][2]*2048/360;
  162.     bufpos+=4;
  163.   }
  164. }
  165.  
  166. void writetx(char* buf, unsigned& bufpos, vector* tx, int& lev)
  167. {
  168.   vector v;
  169.   while (lev)
  170.   {
  171.     if (tx[lev-1]==v)
  172.       lev--;
  173.     else
  174.       break;
  175.   }
  176.   buf[bufpos++]=CMD_POS+lev;
  177.   writevecs(buf, bufpos, tx, lev);
  178. }
  179.  
  180. void writetxa(char* buf, unsigned& bufpos, vector* tx, int& lev)
  181. {
  182.   vector v;
  183.   while (lev)
  184.   {
  185.     if (tx[lev-1]==v)
  186.       lev--;
  187.     else
  188.       break;
  189.   }
  190.   buf[bufpos++]=CMD_ANG+lev;
  191.   writeangs(buf, bufpos, tx, lev);
  192. }
  193.  
  194. void readpalette()
  195. {
  196.   double lasttime=0;
  197.   unsigned bufpos=0;
  198.   while (1)
  199.   {
  200.     double time;
  201.     ifile >> time;
  202.     if (time<=0)
  203.       time=lasttime-time;
  204.     lasttime=time;
  205.     *(long*)(buf+bufpos)=time*65536;
  206.     bufpos+=4;
  207.     if (time>=10000)
  208.       break;
  209.  
  210.     char cmd[10];
  211.     ifile >> cmd;
  212.     if (!stricmp(cmd, "SETPALI"))
  213.     {
  214.       buf[bufpos++]=0;
  215.       short x;
  216.       ifile >> x;
  217.       buf[bufpos++]=x;
  218.       ifile >> x;
  219.       *(short*)(buf+bufpos)=x;
  220.       bufpos+=2;
  221.       ifile >> x;
  222.       buf[bufpos++]=x;
  223.       ifile >> x;
  224.       buf[bufpos++]=x;
  225.       ifile >> x;
  226.       buf[bufpos++]=x;
  227.       ifile >> x;
  228.       buf[bufpos++]=x;
  229.       ifile >> x;
  230.       buf[bufpos++]=x;
  231.       ifile >> x;
  232.       buf[bufpos++]=x;
  233.     }
  234.     else
  235.     if (!stricmp(cmd, "FADEPALI"))
  236.     {
  237.       buf[bufpos++]=1;
  238.       double t;
  239.       ifile >> t;
  240.       *(long*)(buf+bufpos)=t*65536;
  241.       bufpos+=4;
  242.       short x;
  243.       ifile >> x;
  244.       buf[bufpos++]=x;
  245.       ifile >> x;
  246.       *(short*)(buf+bufpos)=x;
  247.       bufpos+=2;
  248.       ifile >> x;
  249.       buf[bufpos++]=x;
  250.       ifile >> x;
  251.       buf[bufpos++]=x;
  252.       ifile >> x;
  253.       buf[bufpos++]=x;
  254.       ifile >> x;
  255.       buf[bufpos++]=x;
  256.       ifile >> x;
  257.       buf[bufpos++]=x;
  258.       ifile >> x;
  259.       buf[bufpos++]=x;
  260.     }
  261.     else
  262.     {
  263.       cerr << "wrong command!";
  264.       exit(1);
  265.     }
  266.   }
  267.   write(ofile, &bufpos, 2);
  268.   write(ofile, buf, bufpos);
  269. }
  270.  
  271. void readobjact()
  272. {
  273.   double lasttime=0;
  274.   unsigned bufpos=0;
  275.   while (1)
  276.   {
  277.     double time;
  278.     ifile >> time;
  279.     if (time<=0)
  280.       time=lasttime-time;
  281.     lasttime=time;
  282.     *(long*)(buf+bufpos)=time*65536;
  283.     bufpos+=4;
  284.     if (time>=10000)
  285.       break;
  286.  
  287.     char cmd[10];
  288.     ifile >> cmd;
  289.     if (!stricmp(cmd, "ENABLE"))
  290.       buf[bufpos++]=1;
  291.     else
  292.     if (!stricmp(cmd, "DISABLE"))
  293.       buf[bufpos++]=0;
  294.     else
  295.     if (!stricmp(cmd, "SETCUT"))
  296.     {
  297.       int x;
  298.       ifile >> x;
  299.       buf[bufpos++]=2;
  300.       buf[bufpos++]=x;
  301.     }
  302.     else
  303.     {
  304.       cerr << "wrong command!";
  305.       exit(1);
  306.     }
  307.   }
  308.   write(ofile, &bufpos, 2);
  309.   write(ofile, buf, bufpos);
  310. }
  311.  
  312. void readxflist()
  313. {
  314.   vector pos[4];
  315.   vector ang[3];
  316.   int plev=0;
  317.   double pt0=0;
  318.   int alev=0;
  319.   double at0=0;
  320.   double lasttime=0;
  321.   unsigned bufpos=0;
  322.   while (1)
  323.   {
  324.     double time;
  325.     ifile >> time;
  326.     if (time<=0)
  327.       time=lasttime-time;
  328.     lasttime=time;
  329.     *(long*)(buf+bufpos)=time*65536;
  330.     bufpos+=4;
  331.     if (time>=10000)
  332.       break;
  333.  
  334.     char cmd[10];
  335.     ifile >> cmd;
  336.     if (!stricmp(cmd, "POS"))
  337.     {
  338.       updatetx(pos, pt0, time, plev);
  339.       plev=1;
  340.       ifile >> pos[0];
  341.       writetx(buf, bufpos, pos, plev);
  342.     }
  343.     else
  344.     if (!stricmp(cmd, "MOVE"))
  345.     {
  346.       updatetx(pos, pt0, time, plev);
  347.       plev=2;
  348.       ifile >> pos[1];
  349.       writetx(buf, bufpos, pos, plev);
  350.     }
  351.     else
  352.     if (!stricmp(cmd, "ACCEL"))
  353.     {
  354.       updatetx(pos, pt0, time, plev);
  355.       plev=3;
  356.       ifile >> pos[2];
  357.       writetx(buf, bufpos, pos, plev);
  358.     }
  359.     else
  360.     if (!stricmp(cmd, "SMOVE"))
  361.     {
  362.       updatetx(pos, pt0, time, plev);
  363.       plev=4;
  364.       double t1;
  365.       vector p1, v1, vp, vs;
  366.       ifile >> t1 >> p1 >> v1;
  367.       vp=(pos[0]-p1)*(6/t1);
  368.       vs=(pos[1]+v1)*2;
  369.       pos[3]=(vp*2+vs*3)*(1/(t1*t1));
  370.       pos[2]=(vp+vs+pos[1]*2)*(-1/t1);
  371.       writetx(buf, bufpos, pos, plev);
  372.     }
  373.     else
  374.     if (!stricmp(cmd, "ANGLE"))
  375.     {
  376.       updatetx(ang, at0, time, alev);
  377.       alev=1;
  378.       ifile >> ang[0];
  379.       writetxa(buf, bufpos, ang, alev);
  380.     }
  381.     else
  382.     if (!stricmp(cmd, "ROT"))
  383.     {
  384.       updatetx(ang, at0, time, alev);
  385.       alev=2;
  386.       ifile >> ang[1];
  387.       writetxa(buf, bufpos, ang, alev);
  388.     }
  389.     else
  390.     if (!stricmp(cmd, "AACCEL"))
  391.     {
  392.       updatetx(ang, at0, time, alev);
  393.       alev=3;
  394.       ifile >> ang[2];
  395.       writetxa(buf, bufpos, ang, alev);
  396.     }
  397.     else
  398.     {
  399.       cerr << "wrong command!";
  400.       exit(1);
  401.     }
  402.   }
  403.   write(ofile, &bufpos, 2);
  404.   write(ofile, buf, bufpos);
  405. }
  406.  
  407. void readobj()
  408. {
  409.   int type;
  410.   ifile >> type;
  411.   write(ofile, &type, 1);
  412.   switch (type)
  413.   {
  414.   case 1:
  415.   {
  416.     char fname[40];
  417.     ifile >> fname;
  418.  
  419.     char path[MAXPATH];
  420.     char drive[MAXDRIVE];
  421.     char dir[MAXDIR];
  422.     char name[MAXFILE];
  423.     char ext[MAXEXT];
  424.  
  425.     fnsplit(fname, drive, dir, name, ext);
  426.     if (stricmp(ext, ".3do"))
  427.     {
  428.       strcpy(path, "makeobj ");
  429.       strcat(path, fname);
  430.       system(path);
  431.     }
  432.     fnmerge(path, drive, dir, name, ".3do");
  433.     int objfile=open(path, O_RDONLY|O_BINARY);
  434.     long len=filelength(objfile);
  435.     for (long c=0; c<len;)
  436.     {
  437.       long r=read(objfile, buf, buflen);
  438.       write(ofile, buf, r);
  439.       c+=r;
  440.     }
  441.     close(objfile);
  442.     readobjact();
  443.     break;
  444.   }
  445.   case 0:
  446.   {
  447.     int num;
  448.     ifile >> num;
  449.     write(ofile, &num, 1);
  450.     for (int i=0; i<num; i++)
  451.       readobj();
  452.     break;
  453.   }
  454.   case 2:
  455.   {
  456.     break;
  457.   }
  458.   default:
  459.     cerr << "wrong object type!";
  460.     exit(1);
  461.   }
  462.  
  463.   readxflist();
  464. }
  465.  
  466. void copytgatexture(char* name)
  467. {
  468.   short fi=open(name, O_BINARY|O_RDONLY);
  469.  
  470.   lseek(fi, 12, SEEK_SET);
  471.   short x,y;
  472.   read(fi, &x, 2);
  473.   read(fi, &y, 2);
  474.   write(ofile, &x, 2);
  475.   write(ofile, &y, 2);
  476.   lseek(fi, 786, SEEK_SET);
  477.   long len=filelength(fi)-786;
  478.   for (long c=0; c<len;)
  479.   {
  480.     long r=read(fi, buf, buflen);
  481.     write(ofile, buf, r);
  482.     c+=r;
  483.   }
  484.   close(fi);
  485. }
  486.  
  487. void readtextures()
  488. {
  489.   short texturenum;
  490.   ifile >> texturenum;
  491.   write(ofile, &texturenum, 2);
  492.   short i;
  493.   for (i=0; i<texturenum; i++)
  494.   {
  495.     short type;
  496.     ifile >> type;
  497.     char filename[40];
  498.     write(ofile, &type, 2);
  499.     short resbit, xabits, yabits, colbits, p;
  500.     long seed;
  501.     short x, y, maxcol, oper, i;
  502.     switch (type)
  503.     {
  504.     case 0:
  505.       ifile >> filename;
  506.       copytgatexture(filename);
  507.       break;
  508.     case 1:
  509.       ifile >> resbit >> xabits >> yabits >> colbits >> p >> seed;
  510.       write(ofile, &resbit, 2);
  511.       write(ofile, &xabits, 2);
  512.       write(ofile, &yabits, 2);
  513.       write(ofile, &colbits, 2);
  514.       write(ofile, &p, 2);
  515.       write(ofile, &seed, 4);
  516.       break;
  517.     case 2:
  518.       ifile >> x >> y >> maxcol >> oper;
  519.       write(ofile, &x, 2);
  520.       write(ofile, &y, 2);
  521.       write(ofile, &maxcol, 1);
  522.       write(ofile, &oper, 1);
  523.       for (i=0; i<oper; i++)
  524.       {
  525.         double pd, fd, ftd, ad, wd;
  526.         ifile >> pd >> fd >> ftd >> ad >> wd;
  527.         long p, f, ft;
  528.         short a, w;
  529.         p=pd*2048.0*65536/360;
  530.         f=fd*2048.0*65536/360;
  531.         ft=ftd*2048.0*65536/360;
  532.         a=ad*2048.0/360;
  533.         w=wd*2048.0/360;
  534.         write(ofile, &p, 4);
  535.         write(ofile, &f, 4);
  536.         write(ofile, &ft, 4);
  537.         write(ofile, &a, 2);
  538.         write(ofile, &w, 2);
  539.       }
  540.       break;
  541.     }
  542.   }
  543. }
  544.  
  545. void readstars()
  546. {
  547.   double lasttime=0;
  548.   unsigned bufpos=0;
  549.   while (1)
  550.   {
  551.     double time;
  552.     ifile >> time;
  553.     if (time<=0)
  554.       time=lasttime-time;
  555.     lasttime=time;
  556.     *(long*)(buf+bufpos)=time*65536;
  557.     bufpos+=4;
  558.     if (time>=10000)
  559.       break;
  560.  
  561.     char cmd[12];
  562.     ifile >> cmd;
  563.     if (!stricmp(cmd, "ENABLE"))
  564.       buf[bufpos++]=1;
  565.     else
  566.     if (!stricmp(cmd, "DISABLE"))
  567.       buf[bufpos++]=0;
  568.     else
  569.     if (!stricmp(cmd, "SETSPEED"))
  570.     {
  571.       double x;
  572.       ifile >> x;
  573.       buf[bufpos++]=2;
  574.       *(long*)(buf+bufpos)=x*65536;
  575.       bufpos+=4;
  576.     }
  577.     else
  578.     if (!stricmp(cmd, "SETMAXCOL"))
  579.     {
  580.       short x;
  581.       ifile >> x;
  582.       buf[bufpos++]=3;
  583.       *(long*)(buf+bufpos)=x*65536;
  584.       bufpos+=4;
  585.     }
  586.     else
  587.     {
  588.       cerr << "wrong command!";
  589.       exit(1);
  590.     }
  591.   }
  592.   write(ofile, &bufpos, 2);
  593.   write(ofile, buf, bufpos);
  594.  
  595.   readxflist();
  596. }
  597.  
  598. void main(int argn, char** argv)
  599. {
  600.   buf=new char[buflen];
  601.   if (!buf)
  602.     return;
  603.  
  604.   if (argn!=2)
  605.     return;
  606.  
  607. // read
  608.  
  609.   ifile.open(argv[1]);
  610.   if (!ifile)
  611.     return;
  612.  
  613.   char path[MAXPATH];
  614.   char drive[MAXDRIVE];
  615.   char dir[MAXDIR];
  616.   char name[MAXFILE];
  617.   char ext[MAXEXT];
  618.  
  619.   fnsplit(argv[1], drive, dir, name, ext);
  620.   fnmerge(path, drive, dir, name, ".3ds");
  621.  
  622.   ofile=open(path, O_BINARY|O_WRONLY|O_TRUNC|O_CREAT, S_IREAD|S_IWRITE);
  623. //  write(ofile, "3ds\x00", 4);
  624.  
  625.   readobj();
  626.  
  627.   readtextures();
  628.  
  629.   readstars();
  630.  
  631.   readpalette();
  632.  
  633.   double endtime;
  634.   ifile >> endtime;
  635.   long et=endtime*65536;
  636.   write(ofile, &et, 4);
  637.  
  638.   close(ofile);
  639.   ifile.close();
  640.  
  641.   cout << argv[1] << " compiled.\n";
  642. }
  643.