fbase.h

flash文件的解码程序

class FlashFixed16
{
//private
public:
    SBYTE upperval;
    UBYTE lowerval;
public: 
    FlashFixed16(void); 
    FlashFixed16(SBYTE u, UBYTE l); 
    FlashFixed16(double f); 
    
    UWORD ConvertToRaw() const
    {
        UWORD r = ((SWORD)upperval)<<8;
        r |= lowerval;
        return r;
    }
    void GetFromRaw(SWORD raw)
    {
        upperval = raw >> 8;
        lowerval = (raw & 0xff);
    }
    double ConvertToDouble()
    {
        return upperval + double(lowerval) / 0x100;
    }
    void GetFromDouble(double x)
    {
        upperval = (UBYTE)floor(x);
        lowerval = (UBYTE)((x-floor(x))*0x100);
    }
    
    friend std::ostream &operator<< (std::ostream &out, const FlashFixed16 &data);
    friend std::istream &operator>> (std::istream &in,  FlashFixed16 &data);    
};

class FlashMatrix
{
public:
    FlashMatrix() : scale(false), scalex(0), scaley(0),
                  rotate(false), rotatex(0), rotatey(0),
                  translatex(0), translatey(0)
    {
    }
    FlashMatrix(bool _scale, FlashFixed _scalex, FlashFixed _scaley,
                bool _rotate, FlashFixed _rotatex, FlashFixed _rotatey,
                SWORD _translatex, SWORD _translatey)
                : scale(_scale), scalex(_scalex), scaley(_scaley),
                  rotate(_rotate), rotatex(_rotatex), rotatey(_rotatey),
                  translatex(_translatex), translatey(_translatey)
    {
    }
    
    void SetScale(FlashFixed _scalex, FlashFixed _scaley) { scalex=_scalex; scaley=_scaley; scale=true;}
    void SetRotate(FlashFixed _rotatex, FlashFixed _rotatey) { rotatex=_rotatex; rotatey=_rotatey; rotate = true;}
    void SetTranslate(SWORD _translatex, SWORD _translatey) { translatex=_translatex; translatey=_translatey;}

    bool HasScale() const { return scale; }
    bool HasRotate() const { return rotate; }

    FlashFixed GetRotateX() const { return rotatex; }
    FlashFixed GetRotateY() const { return rotatey; }

    FlashFixed GetScaleX() const { return scalex; }
    FlashFixed GetScaleY() const { return scaley; }

	// EH: changed return types
    SWORD GetTranslateX() const { return translatex; }
    SWORD GetTranslateY() const { return translatey; }

private:
    bool scale;
    FlashFixed scalex;
    FlashFixed scaley;
    bool rotate;
    FlashFixed rotatex;
    FlashFixed rotatey;
    SWORD translatex;
    SWORD translatey;

    friend std::ostream &operator<< (std::ostream &out, const FlashMatrix &data);
    friend std::istream &operator>> (std::istream &in,  FlashMatrix &data);
};

class FlashMatrixScale : public FlashMatrix
{
    FlashMatrixScale(FlashFixed _scalex, FlashFixed _scaley) : 
        FlashMatrix(true, _scalex, _scaley, false, 0, 0, 0, 0)
    {
        
    }       
};

class FlashMatrixRotate : public FlashMatrix
{
    FlashMatrixRotate(FlashFixed _rotatex, FlashFixed _rotatey) : 
        FlashMatrix(false, 0, 0, true, _rotatex, _rotatey, 0, 0)
    {
        
    }       
};

class FlashMatrixTranslate : public FlashMatrix
{
    FlashMatrixTranslate(SWORD x, SWORD y) : 
        FlashMatrix(false, 0, 0, false, 0, 0, x, y)
    {
        
    }       
};

class FlashRGB
{
public: 
    FlashRGB() : r(0), g(0), b(0), a(0xff), alpha(false) { }
    FlashRGB(SWORD _r, SWORD _g, SWORD _b) : r(_r), g(_g), b(_b), a(0xff), alpha(false){ }
    FlashRGB(SWORD _r, SWORD _g, SWORD _b, SWORD _a) : r(_r), g(_g), b(_b), a(_a), alpha(true){ }

    void Write(BitBuffer &out, int num=-1);
    
    void Read(BitStreamIn &in, int num=-1);

    bool GetAlphaWriteMode(void)   { return (alpha); }
    void SetAlphaWriteMode(bool a) { alpha=a; }

    int GetNumBits() 
    { 
        if(alpha) return fbase_max(fbase_max(GetBitSizeSigned(a),GetBitSizeSigned(b)),fbase_max(GetBitSizeSigned(r),GetBitSizeSigned(g)));
        return fbase_max(GetBitSizeSigned(b),fbase_max(GetBitSizeSigned(r),GetBitSizeSigned(g)));
    }
    
    SWORD GetR() { return r; }
    SWORD GetG() { return g; }
    SWORD GetB() { return b; }
    SWORD GetA() { return a; }
    void SetR(SWORD _r) {r = _r; }
    void SetG(SWORD _g) {g = _g; }
    void SetB(SWORD _b) {b = _b; }
    void SetA(SWORD _a) {a = _a; }
    void SetRGBA(SWORD _r, SWORD _g, SWORD _b, SWORD _a)
    {
        r = _r;
        g = _g;
        b = _b;
        a = _a;
    }
    void SetRGB(SWORD _r, SWORD _g, SWORD _b)
    {
        r = _r;
        g = _g;
        b = _b;
    }

private:    
    SWORD r;
    SWORD g;
    SWORD b;
    SWORD a;
    bool alpha;
    friend std::ostream &operator<< (std::ostream &out, const FlashRGB &data);
    friend std::istream &operator>> (std::istream &in,  FlashRGB &data);
};

class FlashColorTransform : public FlashVersionEnabled
{
public:
	FlashColorTransform() : add(false), mult(false){}
	
	FlashColorTransform(bool _add, FlashRGB& _addFlashRGB, bool _mult, FlashRGB& _multFlashRGB)
		: add(_add), mult(_mult), addFlashRGB(_addFlashRGB), multFlashRGB(_multFlashRGB){}
	    
    friend std::ostream& operator<<(std::ostream& out, FlashColorTransform &data);
    friend std::istream& operator>>(std::istream& in, FlashColorTransform &data);

    bool HasAdd() const { return add; }
    bool HasMult() const { return mult; }
    
    FlashRGB GetAddRGB() const { return addFlashRGB; }
    FlashRGB GetMultRGB() const { return multFlashRGB; }

	void SetAddRGB(FlashRGB _addFlashRGB) 
	{
		addFlashRGB = _addFlashRGB;
		add = true;
	}
	void SetMultRGB(FlashRGB _multFlashRGB) 
	{
		multFlashRGB = _multFlashRGB;
		mult = true;
	}

	void SetAdd(short _addFlashR, short _addFlashG, short _addFlashB) 
	{
		addFlashRGB = FlashRGB(_addFlashR, _addFlashG, _addFlashB);
		add = true;
	}
	void SetMult(FlashFixed16 _multFlashR, FlashFixed16 _multFlashG, FlashFixed16 _multFlashB) 
	{
		multFlashRGB = FlashRGB(_multFlashR.ConvertToRaw(), _multFlashG.ConvertToRaw(), _multFlashB.ConvertToRaw());
		mult = true;
	}

private:
    bool add;
    bool mult;
    FlashRGB addFlashRGB;
    FlashRGB multFlashRGB;
};

class FlashRect
{
public:
    FlashRect(int _x1, int _y1, int _x2, int _y2) : 
      x1(_x1), y1(_y1), x2(_x2), y2(_y2), defined(true) {}
    
    FlashRect() : x1(0), y1(0), x2(0), y2(0), defined(false) {}
    
    ~FlashRect() {}

    bool IsDefined() { return(defined); }
    
    void SetRect(int _x1, int _y1, int _x2, int _y2)
    {
      x1 = _x1;
      y1 = _y1;
      x2 = _x2;
      y2 = _y2;
    }
    
    SWORD GetX1() const { return x1; }
    SWORD GetX2() const { return x2; }
    SWORD GetY1() const { return y1; }
    SWORD GetY2() const { return y2; }

    void BoundWith(const FlashRect &r) { x1 = fbase_min(x1,r.x1); x2 = fbase_max(x2, r.x2); y1 = fbase_min(y1,r.y1); y2 = fbase_max(y2, r.y2); };
private:
    int x1; 
    int y1;
    int x2;
    int y2;
    bool defined;

    friend std::ostream &operator<< (std::ostream &out, const FlashRect &data);
    friend std::istream &operator>> (std::istream &in,  FlashRect &data);
};


class FlashHeader
{
public:
    FlashHeader(UBYTE _version, UDWORD _filesize, int width, int height, UWORD _framerate, UWORD _framecount);
    FlashHeader(UBYTE _version, UDWORD _filesize, int width, int height, double _framerate, UWORD _framecount);
    FlashHeader() {}
    ~FlashHeader() {}

    UBYTE  GetVersion(void) { return version; }
    UDWORD GetFilesize(void) { return filesize; }
    FlashRect GetScreenSize(void) { return size; }
    FlashFixed16 GetFrameRate(void) { return frameRate; }
    UWORD GetFrameCount(void) { return frameCount; }

private:
    
    friend std::ostream &operator << (std::ostream &out, const FlashHeader &data);
    friend std::istream &operator >> (std::istream &in,  FlashHeader &data);

    UBYTE  version;
    UDWORD filesize;
    FlashRect size;
    FlashFixed16 frameRate;
    UWORD frameCount;
};

class FlashTagHeader
{
DEFINE_RW_INTERFACE
public:
    FlashTagHeader() {}
    FlashTagHeader(UWORD _tagID, UDWORD _length) : tagID(_tagID), length(_length) {}
    virtual ~FlashTagHeader() {}

    UWORD GetTagID(void) { return tagID; }
    UDWORD GetTagLength(void) { return length; }

private:
    UWORD  tagID;
    UDWORD length;

    friend std::ostream &operator << (std::ostream &out, const FlashTagHeader &data);
    friend std::istream &operator >> (std::istream &in,  FlashTagHeader &data);

};


class FlashTag
{
public:
    FlashTag() {}
    virtual ~FlashTag() {}
	virtual bool isFrame() { return false; }

    void SetImportSize(UDWORD i) { importsize = i; }	
protected:
    UDWORD importsize;
private:        
};

class FlashSpriteEnabled : public FlashTag
{
public:
    FlashSpriteEnabled() {}
    virtual ~FlashSpriteEnabled() {}	

	virtual void Write(std::ostream &out) = 0;

};

class FlashIDFactory
{
public: 
    FlashIDFactory() {};

    UWORD GetCharacterID() 
    { 
        UWORD _IDCharacter = IDCharacter; 
        IDCharacter++; 
        return (_IDCharacter); 
    }
    static void ResetCount()
    {
        IDCharacter=1;
    }
private:    
    static UWORD IDCharacter;
};

class FlashIDEnabled
{
public:
    FlashIDEnabled(bool count=true) { charID = idFactory.GetCharacterID(); }
    
    void SetID(UWORD i) { charID=i; }
    UWORD GetID(void) const { return (charID); }
private:
    FlashIDFactory idFactory;
    UWORD charID;
};

class FlashTagRawData : public FlashTag
{
DEFINE_RW_INTERFACE
public:
	char *ptrData;
	int  lenData;

	friend std::ostream &operator << (std::ostream &out, const FlashTagRawData &data);
    friend std::istream &operator >> (std::istream &in,  FlashTagRawData &data);
};

#define DEFINE_SIMPLE_TAG(x, n) \
std::ostream &operator << (std::ostream &out, const x &data) \
{ \
    return (out << FlashTagHeader(n,0)); \
} \
std::istream &operator >> (std::istream &in,  x &data) \
{ \
    return in; \
}

#define DECLARE_SIMPLE_TAG(x) \
class x : public FlashTag \
{                               \
	DEFINE_RW_INTERFACE			\
public:                         \
    x() {} \
    ~x() {} \
    friend std::ostream &operator << (std::ostream &out, const x &data); \
    friend std::istream &operator >> (std::istream &in,  x &data); \
};

#define DECLARE_SIMPLE_TAG2(x) \
class x : public FlashSpriteEnabled \
{                               \
	DEFINE_RW_INTERFACE			\
public:                         \
    x() {} \
    ~x() {} \
    friend std::ostream &operator << (std::ostream &out, const x &data); \
    friend std::istream &operator >> (std::istream &in,  x &data); \
};

#define DECLARE_SIMPLE_TAG3(x) \
class x : public FlashSpriteEnabled \
{                               \
	DEFINE_RW_INTERFACE			\
public:                         \
    x() {} \
    ~x() {} \
	virtual bool isFrame() { return true; }\
    friend std::ostream &operator << (std::ostream &out, const x &data); \
    friend std::istream &operator >> (std::istream &in,  x &data); \
};

template<class T> class gc_vector: public std::vector<T>
{
public:	
	gc_vector() {}
	gc_vector(const gc_vector &c) {}
	~gc_vector() { for(std::vector<T>::iterator i = begin(); i != end(); i++) { delete *i; }}
};

FlashMatrix CreateMatrix(FlashRect bounds,float scaleX,float scaleY,float rotation,float translateX,float translateY,bool bScale, bool bRotate);

template <class T> class FlashCopyEnabled
{
public:
	FlashCopyEnabled() { }
	virtual T * Copy() const = 0;

};

#define DEFINE_FLASHCOPY_INTERFACE(T, P)	\
	virtual P * Copy() const { return new T( *this ); }

#endif