FlashTextureManager.h

#pragma once
#include <vector>
#include <string>
#include "FileManager.h"

#include "util/mutex.h"
#include <boost/thread.hpp>
#include <boost/shared_ptr.hpp>

namespace ParaEngine
{
    using namespace std;
    struct SWFRect
    {
        int m_bitSize;
        int m_minX;
        int m_minY;
        int m_maxX;
        int m_maxY;
    public:
        int getMinX();
        int getMinY();
        int getMaxX();
        int getMaxY();

        void setMinX( int minX );
        void setMinY( int minY );
        void setMaxX( int maxX );
        void setMaxY( int maxY );

        
        SWFRect( int minX, int minY, int maxX, int maxY );
        SWFRect();

        void Init( CParaFile& in, bool bUnsigned=false);
    };
    struct SWFHeader
    {
        byte Signature[3]; // 'F', 'W', 'S' or 'C', 'W', 'S'(compressed)
        byte Version;
        DWORD fileLength;

        // rect
        SWFRect frameSize;
        short frameRate;
        short frameCount;

    public:
        SWFHeader();
        SWFHeader(CParaFile& in);
    };

    class CFlashPlayer
    {
    public:
        CFlashPlayer(int nFlashPlayerIndex);
        ~CFlashPlayer();

        typedef boost::shared_ptr<boost::thread> Boost_Thread_ptr_type;

    public:
        bool IsFree(){return m_bFree;}

        void LoadMovie(const char* filename);

        void PutFlashVars(const char* args);

        const char* CallFlashFunction(const char* sFunc);

        void SetFlashReturnValue(const char* sResult);

        const char* GetFlashReturnValue();

        void UnloadMovie();
        
        void InvalidateDeviceObjects();

        void RenderFrameMove(float fCurTime);

        bool GetTextureInfo(int* width, int* height);

        LRESULT SendMessage( UINT Msg,WPARAM wParam,LPARAM lParam);
        LRESULT PostMessage( UINT Msg,WPARAM wParam,LPARAM lParam);

        const char* GetFileName();

        int GetIndex() {return m_nFlashPlayerIndex;}


        bool IsWindowMode() { return m_bWindowMode;};

        void SetWindowMode(bool bIsWindowMode);

        void MoveWindow(int x, int y, int width, int height, bool bRepaint=true);


        void OnSizeChange();

        void SetWindowVisible(bool bVisible);

        void Repaint();

        void SetFocus();

        HWND GetWindowHandle();

        void UpdatePixelsBuffer();
    private:
        HRESULT CreateTexture(LPDIRECT3DTEXTURE9 *ppTexture);

        HRESULT UpdateTexture(LPDIRECT3DTEXTURE9 pTexture);

    public:
        HRESULT StartWindowThread();
        void DefaultWinThreadProc();

        bool MsgProcCustom(UINT message,WPARAM wParam,LPARAM lParam);

        bool PostWinThreadMessage(UINT message,WPARAM wParam,LPARAM lParam);
        
        bool SetParentWindow(HWND hWnd);

        bool HasFocus();
    public:
        LPDIRECT3DTEXTURE9 GetTexture();
        
        string m_filename;
        float m_fTimeOut;
        float m_fLastUsedTime;
        int m_nFlashPlayerIndex;
        
        LPDIRECT3DTEXTURE9 m_pTexture;
        D3DFORMAT m_TextureFormat;
        bool m_bUseDynamicTextures;

        bool m_bTextureUpdatedThisFrame;
        bool m_bFree;
        bool m_bTransparent;
        HWND m_hwndFlashPlayerControl;
        
        int m_nX;
        int m_nY;
        int m_nWidth;
        int m_nHeight;
        int m_nBufWidth;// thread unsafe
        int m_nBufHeight;// thread unsafe
        int m_nTextureWidth;
        int m_nTextureHeight;
        int m_nWindowX;
        int m_nWindowY;
        int m_nWindowWidth;
        int m_nWindowHeight;

        DWORD* m_lpPixels; // thread unsafe
        LinearColor m_backgroundColor;

        bool m_bNeedFlashUpdate;
        bool m_bFlipVertical;

        bool m_bWindowMode;

        // the most recent flash return value. 
        string m_sFlashReturnValue;

        //  the default window thread ptr. 
        Boost_Thread_ptr_type m_win_thread;
        ParaEngine::mutex     m_win_thread_mutex;
        bool m_bWindowCreated;
        bool m_bWinThreadMovieLoaded;
        // the window thread id
        DWORD m_dwWinThreadID;

        string m_sCurrentFlashFunc;
        string m_sCurrentFlashFuncResponse;
        bool m_bInFlashFunc;

        bool m_bHasFocus;
    };

    class CFlashTextureManager : public ISearchPathManager
    {
    public:
        CFlashTextureManager(void);
        virtual ~CFlashTextureManager(void);

    public:
        HRESULT InitDeviceObjects();// device independent
        HRESULT RestoreDeviceObjects(); // device dependent
        HRESULT InvalidateDeviceObjects();
        HRESULT DeleteDeviceObjects();
        void Cleanup();
        void LoadAsset();
        void UnloadAsset();
        void GarbageCollectAll();

        void OnSizeChange();

        void SetMaxFlashPlayerNum(int nNum);
        int GetMaxFlashPlayerNum();

        CFlashPlayer* GetFlashPlayer(const char* sFileName);
        
        CFlashPlayer* GetFlashPlayer(int nIndex);
        
        int GetFlashPlayerIndex(const char* sFileName);

        LPDIRECT3DTEXTURE9 GetTexture(const char* sFileName);
        bool GetTextureInfo(const char* sFileName, int* width, int* height);

        bool UnloadTexture(const char* sFileName);
        
        void RenderFrameMove(float fElapsedTime);

        string FindFile(const string& filename, bool bFindInSearchPaths);

        void RepaintAll();

        void RenderFlashWindows(SceneState& sceneState);
    
        bool SetParentWindow(HWND hWnd);
        
        static bool HasFocus();
    public:
        vector <CFlashPlayer*> m_FlashPlayers;

        static bool m_bHasFocus;
    };
}