home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / flash078.zip / flashsource-r0_7_8.zip / FBase.cpp < prev    next >
C/C++ Source or Header  |  2001-07-30  |  12KB  |  479 lines
  1. #include "FBase.h"
  2. #include <math.h>
  3. #include <iostream>
  4. #include <sstream>
  5.  
  6. FlashFixed::FlashFixed(void) : upperval(0), lowerval(0) 
  7. {
  8. }
  9.  
  10. FlashFixed::FlashFixed(SWORD u, UWORD l) : upperval(u), lowerval(l) 
  11. {
  12. }
  13.  
  14. FlashFixed::FlashFixed(double f) : upperval((UWORD)floor(f)), lowerval(UWORD((f-floor(f))*0x10000)) 
  15. {
  16. }
  17.  
  18. std::ostream &operator<< (std::ostream &out, const FlashFixed &data)
  19. {
  20.     WRITE_UWORD(data.upperval)
  21.     WRITE_UWORD(data.lowerval)
  22.     return out;
  23. }
  24.  
  25. std::istream &operator>> (std::istream &in,  FlashFixed &data)
  26. {
  27.     READ_UWORD(data.upperval)
  28.     READ_UWORD(data.lowerval)
  29.     return in;
  30. }
  31.  
  32. FlashFixed16::FlashFixed16(void) : upperval(0), lowerval(0) 
  33. {
  34. }
  35.  
  36. FlashFixed16::FlashFixed16(SBYTE u, UBYTE l) : upperval(u), lowerval(l) 
  37. {
  38. }
  39.  
  40. FlashFixed16::FlashFixed16(double f) : upperval((UBYTE)floor(f)), lowerval(UBYTE((f-floor(f))*0x100))
  41. {
  42. }
  43.  
  44. std::ostream &operator<< (std::ostream &out, const FlashFixed16 &data)
  45. {
  46.     WRITE_UBYTE(data.upperval)
  47.     WRITE_UBYTE(data.lowerval)
  48.     return out;
  49. }
  50.  
  51. std::istream &operator>> (std::istream &in,  FlashFixed16 &data)
  52. {
  53.     READ_UBYTE(data.upperval)
  54.     READ_UBYTE(data.lowerval)
  55.     return in;
  56. }
  57.  
  58.  
  59.  
  60. std::ostream &operator<< (std::ostream &out, const FlashMatrix &data)
  61. {
  62.     BitBuffer b;
  63.     b.Write(data.scale,1);
  64.     if(data.scale)
  65.     {
  66.         int bits = max(GetBitSizeSigned(data.scalex.ConvertToRaw()),
  67.                        GetBitSizeSigned(data.scaley.ConvertToRaw()));
  68.         b.Write(bits,5);    
  69.         b.Write(PackBitsSigned(data.scalex.ConvertToRaw()),bits);
  70.         b.Write(PackBitsSigned(data.scaley.ConvertToRaw()),bits);
  71.         
  72.     }
  73.     b.Write(data.rotate,1);
  74.     if(data.rotate)
  75.     {
  76.         int bits = max(GetBitSizeSigned(data.rotatex.ConvertToRaw()),
  77.                        GetBitSizeSigned(data.rotatey.ConvertToRaw()));
  78.         b.Write(bits,5);
  79.         b.Write(PackBitsSigned(data.rotatex.ConvertToRaw()),bits);
  80.         b.Write(PackBitsSigned(data.rotatey.ConvertToRaw()),bits);
  81.         
  82.     }
  83.     
  84.     int bits = max(GetBitSizeSigned(data.translatex),
  85.                    GetBitSizeSigned(data.translatey));
  86.     b.Write(bits,5);
  87.     b.Write(PackBitsSigned(data.translatex),bits);
  88.     b.Write(PackBitsSigned(data.translatey),bits);
  89.  
  90.     out << b;
  91.     return out;
  92. }
  93.  
  94. std::istream &operator>> (std::istream &in,  FlashMatrix &data)
  95. {
  96.     
  97.     BitStreamIn i(&in);
  98.     unsigned char ct;
  99.     i.Read(ct,1);
  100.     data.scale = (ct==1);
  101.     unsigned int bits;
  102.     if(data.scale)
  103.     {
  104.         i.Read(bits,5); 
  105.         SDWORD x;
  106.         SDWORD y;
  107.         i.Read(x,bits);
  108.         data.scalex.GetFromRaw(UnPackBitsSigned(x,bits));
  109.         i.Read(y,bits);
  110.         data.scaley.GetFromRaw(UnPackBitsSigned(y,bits));
  111.         
  112.     }
  113.     i.Read(ct,1);
  114.     data.rotate = (ct==1);
  115.     if(data.rotate)
  116.     {
  117.         i.Read(bits,5); 
  118.         SDWORD x;
  119.         SDWORD y;
  120.         i.Read(x,bits);
  121.         data.rotatex.GetFromRaw(UnPackBitsSigned(x,bits));
  122.         i.Read(y,bits);
  123.         data.rotatey.GetFromRaw(UnPackBitsSigned(y,bits));
  124.  
  125.     
  126.     }
  127.     
  128.     i.Read(bits,5);
  129.     
  130.     SDWORD transx;
  131.     SDWORD transy;
  132.  
  133.     if(bits > 0)
  134.     {
  135.         i.Read(transx,bits);
  136.         i.Read(transy,bits);
  137.  
  138.         data.translatex = UnPackBitsSigned(transx,bits);
  139.         data.translatey = UnPackBitsSigned(transy,bits);
  140.     } 
  141.     else
  142.     {
  143.         data.translatex = 0;
  144.         data.translatey = 0;
  145.  
  146.     }
  147.     return in;
  148. }
  149.  
  150. std::ostream& operator<<(std::ostream& out, FlashColorTransform &data)
  151. {
  152.     data.addFlashRGB.SetAlphaWriteMode(data.GetTagVersion() > 1);
  153.     data.multFlashRGB.SetAlphaWriteMode(data.GetTagVersion() > 1);
  154.  
  155.     BitBuffer b;
  156.     b.Write(data.add,1);
  157.     b.Write(data.mult,1);
  158.  
  159.     int num=max(data.multFlashRGB.GetNumBits(),data.addFlashRGB.GetNumBits());
  160.     b.Write(num,4);
  161.     
  162.     if(data.mult)
  163.     {
  164.         data.multFlashRGB.Write(b,num);
  165.     }
  166.     if(data.add)
  167.     {
  168.         data.addFlashRGB.Write(b,num);
  169.     }
  170.     
  171.     out << b;
  172.     return out;
  173. }
  174. std::istream& operator>>(std::istream& in, FlashColorTransform &data)
  175. {
  176.     data.addFlashRGB.SetAlphaWriteMode(data.GetTagVersion() > 1);
  177.     data.multFlashRGB.SetAlphaWriteMode(data.GetTagVersion() > 1);
  178.  
  179.     BitStreamIn b(&in);
  180.     unsigned char ct;
  181.     b.Read(ct,1);
  182.     data.add = (ct != 0);
  183.     b.Read(ct,1);
  184.     data.mult = (ct != 0);
  185.     
  186.     int num;
  187.     b.Read(num,4);
  188.     
  189.     if(data.mult)
  190.     {
  191.         data.multFlashRGB.SetAlphaWriteMode(true);
  192.         data.multFlashRGB.Read(b,num);
  193.     }
  194.     if(data.add)
  195.     {
  196.         data.addFlashRGB.SetAlphaWriteMode(true);
  197.         data.addFlashRGB.Read(b,num);
  198.     }
  199.     return in;
  200. }
  201.  
  202. void FlashRGB::Write(BitBuffer &out, int num)
  203. {
  204.     if(num != -1)
  205.     {       
  206.         out.Write(PackBitsSigned(r),num);
  207.         out.Write(PackBitsSigned(g),num);
  208.         out.Write(PackBitsSigned(b),num);
  209.         if(alpha) out.Write(PackBitsSigned(a),num);
  210.     }
  211.     else
  212.     {
  213.         out.Write(r,8);
  214.         out.Write(g,8);
  215.         out.Write(b,8);
  216.         if(alpha) out.Write(a,8);
  217.     }
  218. }
  219.  
  220. void FlashRGB::Read(BitStreamIn &in, int num)
  221. {
  222.     if(num != -1)
  223.     {       
  224.         in.Read(r,num);
  225.         in.Read(g,num);
  226.         in.Read(b,num);
  227.         if(alpha) in.Read(a,num);
  228.  
  229.         r=UnPackBitsSigned(r,num);
  230.         g=UnPackBitsSigned(g,num);
  231.         b=UnPackBitsSigned(b,num);
  232.         if(alpha) a=UnPackBitsSigned(a,num);
  233.     }
  234.     else
  235.     {
  236.         in.Read(r,8);
  237.         in.Read(g,8);
  238.         in.Read(b,8);
  239.         if(alpha) in.Read(a,8);
  240.     }
  241.  
  242. }
  243. std::ostream &operator<< (std::ostream &out, const FlashRGB &data)
  244. {
  245.     out.put((data.r < 0xff) ? ((char)data.r) : (char)0xff);
  246.     out.put((data.g < 0xff) ? ((char)data.g) : (char)0xff);
  247.     out.put((data.b < 0xff) ? ((char)data.b) : (char)0xff);
  248.     if(data.alpha) out.put((data.a < 0xff) ? ((char)data.a) : (char)0xff);
  249.     return out;
  250. }
  251. std::istream &operator>> (std::istream &in,  FlashRGB &data)
  252. {
  253.     data.r = in.get();
  254.     data.g = in.get();
  255.     data.b = in.get();
  256.     if(data.alpha) data.a = in.get();
  257.     return in;
  258. }
  259.  
  260.  
  261. BitStreamOut &operator<< (BitStreamOut &out, BitBuffer &data)
  262. {
  263.     int displacement=0;
  264.     for(std::vector<char>::iterator i = data.v.begin(); i != data.v.end(); i++)
  265.     {
  266.         displacement+=8;
  267.         if(data.displace-displacement > 8)
  268.         {
  269.             out.Write((char)*i,8);
  270.         }
  271.         else out.Write((char)*i,data.displace-displacement);
  272.     }
  273.     return out;
  274. }
  275.  
  276. std::ostream &operator<< (std::ostream &out, BitBuffer &data)
  277. {
  278.     for(std::vector<char>::iterator i = data.v.begin(); i != data.v.end(); i++)
  279.     {
  280.         out.put((char)*i);
  281.     }
  282.     return out;
  283. }
  284.  
  285. std::istream &operator>> (std::istream &in,  BitBuffer &data)
  286. {
  287.     return in;
  288. }
  289.  
  290. std::ostream &operator<< (std::ostream &out, const FlashRect &data)
  291. {
  292.     int minbits = max(max(GetBitSize(data.x1), GetBitSize(data.y1)), 
  293.                     max(GetBitSize(data.x2), GetBitSize(data.y2)))+1;
  294.  
  295.     BitBuffer b;
  296.     b.Write(minbits,5);
  297.     b.Write(data.x1,minbits);
  298.     b.Write(data.x2,minbits);
  299.     b.Write(data.y1,minbits);
  300.     b.Write(data.y2,minbits);
  301.     out << b;
  302.     return out;
  303. }
  304.  
  305. FlashHeader::FlashHeader(UBYTE _version, UDWORD _filesize, int width, int height, UWORD _framerate, UWORD _framecount)
  306. {
  307.     version=_version;
  308.     filesize=_filesize;
  309.     size=FlashRect(0,0,width, height);
  310.     frameRate=FlashFixed16(_framerate >> 8, _framerate & 0xff);
  311.     frameCount=_framecount;
  312. }
  313.  
  314. FlashHeader::FlashHeader(UBYTE _version, UDWORD _filesize, int width, int height, double _framerate, UWORD _framecount)
  315. {
  316.     version=_version;
  317.     filesize=_filesize;
  318.     size=FlashRect(0,0,width, height);
  319.     frameRate=FlashFixed16(_framerate);
  320.     frameCount=_framecount;
  321. }
  322.  
  323. std::istream &operator>> (std::istream &in,  FlashRect &data)
  324. {
  325.     // TODO: DOES NOT FUNCTION
  326.     char c = in.get();
  327.     char bit_size = c >> 3;
  328.     in.putback(c);
  329.     BitStreamIn b(&in,5);
  330.     SWORD tmp;
  331.     
  332.     
  333.     b.Read(tmp, bit_size);
  334.     data.x1=UnPackBitsSigned(tmp,bit_size);
  335.     b.Read(tmp, bit_size);
  336.     data.x2=UnPackBitsSigned(tmp,bit_size);
  337.     b.Read(tmp, bit_size);
  338.     data.y1=UnPackBitsSigned(tmp,bit_size);
  339.     b.Read(tmp, bit_size);
  340.     data.y2=UnPackBitsSigned(tmp,bit_size);
  341.     
  342.     
  343.     
  344.     return in;
  345. }
  346. std::ostream &operator << (std::ostream &out, const FlashHeader &data)
  347. {
  348.     int minbits = (int)ceil(((max(GetBitSize(data.size.GetX2()), GetBitSize(data.size.GetY2())+1)) * 4 + 5) / 8.0);
  349.         
  350.     UDWORD size_adjust = 12+minbits;
  351.     out << "FWS";
  352.     out.put(data.version);
  353.     WRITE_UDWORD(data.filesize+size_adjust)
  354.     out << data.size;
  355.  
  356.     WRITE_UWORD(data.frameRate.ConvertToRaw())    
  357.     WRITE_UWORD(data.frameCount)
  358.     
  359.     return out;
  360. }
  361. std::istream &operator >> (std::istream &in,  FlashHeader &data)
  362. {
  363.     char tmp[3];
  364.     SWORD tmp1;
  365.     in.read(tmp,3); // TODO: SHOULD BE "FWS", add error handling
  366.     data.version = in.get();
  367.     READ_UDWORD(data.filesize)
  368.     in >> data.size;
  369.     READ_UWORD(tmp1)
  370.     data.frameRate.GetFromRaw(tmp1);
  371.     READ_UWORD(data.frameCount)
  372.     return in;
  373. }
  374.  
  375. std::ostream &operator << (std::ostream &out, const FlashTagHeader &data)
  376. {
  377.     if (data.length < 63) 
  378.     {
  379.         UWORD write = ((data.tagID << 6) | data.length);
  380.         out.put(write & 0xff);
  381.         out.put(write >> 8);
  382.     }
  383.     else
  384.     {
  385.         UWORD write = ((data.tagID << 6) | 0x3f);
  386.         out.put(write & 0xff);
  387.         out.put(write >> 8);
  388.         WRITE_UDWORD(data.length);
  389.     }
  390.     return out;
  391. }
  392. std::istream &operator >> (std::istream &in,  FlashTagHeader &data)
  393. {
  394.     UWORD c  = in.get(); 
  395.     UWORD c2 = in.get(); 
  396.  
  397.     UWORD read = (c2 << 8) | c;
  398.     
  399.     data.tagID = read >> 6;
  400.     
  401.     if((read & 0x3f) != 0x3f)
  402.     {
  403.         data.length = read & 0x3f;
  404.     }
  405.     else
  406.     {
  407.         READ_UDWORD(data.length);
  408.     }
  409.  
  410.     
  411.     return in;
  412.     
  413.  
  414. }
  415.  
  416. std::ostream &operator << (std::ostream &out, const FlashTag &data) { return out;}
  417. std::istream &operator >> (std::istream &in,  FlashTag &data) { return in;}
  418.  
  419. UWORD FlashIDFactory::IDCharacter=0;
  420.  
  421.  
  422. FlashMatrix CreateMatrix(FlashRect bounds,float scaleX,float scaleY,float rotation,float translateX,float translateY,bool bScale, bool bRotate)
  423. {
  424.     const double DegToRad = 3.14159265358979323 / 180.0;    // pi/2
  425.  
  426.     int centerX = int( (bounds.GetX1()+bounds.GetX2())/2.0 );
  427.     int centerY = int( (bounds.GetY1()+bounds.GetY2())/2.0 );
  428.     float sX = scaleX ;
  429.     float sY =  scaleY ;
  430.     float rot = rotation;
  431.  
  432. //     float skewX = 1.0;
  433. //     float skewY = 1.0;
  434.  
  435.     // We want to rotate the matrix about its own center, not the origin. So it is necessary
  436.     // to move the object to the origin, rotate it, and move it back.
  437. /*
  438.     float deltaX = centerX * cos( DegToRad * rot ) - centerY * sin(DegToRad*rot) - centerX; 
  439.     float deltaY = centerX * sin( DegToRad * rot ) + centerY * cos(DegToRad*rot) - centerY;
  440. */
  441.     // This is the code from David Michie to make a swf matrix (no skew)
  442.  
  443.     //   Assign(cos(rx)*sx,  sin(rx)*sx,  0.0,
  444.     //          cos(ry)*sy,  sin(ry)*sy,  0.0,
  445.     //          x,           y,           1.0);
  446.  
  447.     // lee: using the Folef and Van Damme gives a slightly different
  448.     // matrix (a matrix rotated from Flash's, actually). So converting the
  449.     // above given that cos(x+90) = -sin(x) & sin(x+90) = cos x,
  450.     // gives the matrix below.
  451.  
  452.     // make the matrix:
  453.     //    | a b tx|
  454.     //    | c d ty|
  455.     //
  456.  
  457.     double a =  cos( DegToRad*rot ) * sX; //ScaleX
  458.     double b =  sin( DegToRad*rot ) * sX; //RotateSkew0
  459.     double c = -sin( DegToRad*rot ) * sY; //RotateSkew1
  460.     double d =  cos( DegToRad*rot ) * sY; //ScaleY
  461.  
  462.     // By Yiyi
  463.     double deltaX = centerX * cos( DegToRad * rot ) - centerY * sin(DegToRad*rot); 
  464.     double deltaY = centerX * sin( DegToRad * rot ) + centerY * cos(DegToRad*rot);
  465.     
  466.     return FlashMatrix(bScale, FlashFixed( a ), FlashFixed( d ),
  467.                         bRotate,FlashFixed( b ), FlashFixed( c ),
  468.  
  469.  
  470. //                        translateX - int( deltaX * sX ), 
  471. //                        translateY - int( deltaY * sY ) 
  472.  
  473.                         // By Yiyi
  474.                         (int)(translateX + centerX - int( deltaX * sX )), 
  475.                         (int)(translateY + centerY - int( deltaY * sY )) 
  476.                       );
  477. }
  478.  
  479.