CAVSceneNode.h

Go to the documentation of this file.

#ifndef __C_AV_SCENE_NODE_H__
#define __C_AV_SCENE_NODE_H__

#include <irrlicht.h>

#ifdef ARSA_FRAMEWORK
#include "ArsaCompileConfig.h"
#include "ESceneNodeTypes2.h"
#endif

typedef struct av_t av_t;

namespace irr
{

#ifndef ARSA_FRAMEWORK
namespace scene
{
        const int ESNT_AV       = MAKE_IRR_ID('f','f','a','v');
}
#endif
        
namespace arsa
{

class CSceneManager2;
struct SPsd;

const char* const sBuiltInPlayBackNames[] = {
        "play",
        "playonce",
        "pause",
        "stop",
        "playall",
        "pauseall",
        "stopall",
        "show",
        "hide",
        "isplaying",
        "!isplaying",
        "isend",
        "!isend",
        "clear",
        "load",
        "playat",
        "playatresize",
        "loop",
        "once",
        "resize",
        "volume",
        "seek",
        "isready",
        "isreadyfirst",
        "fit",
        "getfit",
        "getframe",
        "getframecount",
        "cache",
        "clearplayat",
        "getfilename",
        "clearcache",
        "getcachecount",
        "getcount",
        "fps",
        "getfps",
        "getdurationend",
        "getduration",
        0
};

enum E_PLAY_BACK
{
        EPB_PLAY = 0,
        EPB_PLAY_ONCE,
        EPB_PAUSE,
        EPB_STOP,
        EPB_PLAY_ALL,
        EPB_PAUSE_ALL,
        EPB_STOP_ALL,
        EPB_SHOW,
        EPB_HIDE,
        EPB_ISPLAYING,
        EPB_NOT_ISPLAYING,
        EPB_IS_END,
        EPB_NOT_IS_END,
        EPB_CLEAR,
        EPB_LOAD,
        EPB_PLAY_AT,
        EPB_PLAY_AT_RESIZE,
        EPB_LOOP,
        EPB_ONCE,
        EPB_RESIZE,
        EPB_VOLUME,
        EPB_SEEK,
        EPB_IS_READY,
        EPB_IS_READY_FIRST,
        EPB_FIT,
        EPB_GET_FIT,
        EPB_GET_FRAME,
        EPB_GET_FRAME_COUNT,
        EPB_CACHE,
        EPB_CLEAR_PLAY_AT,
        EPB_GET_FILENAME,
        EPB_CLEAR_CACHE,
        EPB_GET_CACHE_COUNT,
        EPB_GET_COUNT,
        EPB_FPS,
        EPB_GET_FPS,
        EPB_GET_DURATION_END,
        EPB_GET_DURATION,
        EPB_COUNT
};

class CAVSceneNode : public scene::ISceneNode
{
public:
        CAVSceneNode(irr::IrrlichtDevice* device, scene::ISceneNode* parent, scene::ISceneManager* smgr, arsa::CSceneManager2* smgr2, s32 id = -1);
        virtual ~CAVSceneNode( );

        static void AV_INIT(irr::ILogger* log = 0);
        static bool AV_DEINIT( );
        static void internal_volume(irr::f32 vol = 1.0f);

        virtual bool open(irr::io::IReadFile* fp, const irr::core::dimension2di& size = irr::core::dimension2di(0, 0));
        virtual bool openFromFile( const irr::core::stringc& filename, bool stream = true, const irr::core::dimension2di& size = irr::core::dimension2di(0,0)); 
        virtual void avUpdate();
        virtual void close( );
        virtual bool isPlaying( ) const;
        virtual bool isEnd( ) const;
        virtual void play( bool play = true );
        virtual void loop( bool loop );
        virtual void stop( );
        virtual void volume( irr::f32 vol = 1.0f );
        virtual bool seek( u32 hh, u32 mm, u32 ss );
        virtual bool seek_sec( irr::s32 sec );
        virtual bool seek_percent( irr::s32 percent );
        virtual bool resize( const irr::core::dimension2di& size );
        virtual irr::core::dimension2di getTextureSize();
        virtual void show( bool show = true ) { m_show = show; }
        //virtual void setAutoClose( bool close = false ) { m_auto_close = close; }
        virtual bool isForground() const { return m_forground; }
        virtual bool isShow() const { return m_show; }
        //virtual bool isAutoClose() const { return m_auto_close; }
        virtual bool draw( bool is_forground = true );
        virtual void useAsTexture( bool active = true );
        virtual void useAsForground(bool active = true) { m_forground = active; }
        static E_PLAY_BACK getPlayback( const core::stringc& str );
        virtual void playback( E_PLAY_BACK pb );
        virtual void setPlayTime( f32 sec );
        virtual video::ITexture* getTexture();
        virtual void setDrawOrder(u32 order) { m_draworder = order; }
        virtual u32 getDrawOrder() const { return m_draworder; }
        virtual irr::u64 getVideoEndDuration() const; // return millisec, 0 is error
        virtual irr::u64 getAudioEndDuration() const; // return millisec, 0 is error
        virtual irr::u64 getVideoCurrentDuration() const; // return millisec, 0 is error
        virtual irr::u64 getAudioCurrentDuration() const; // return millisec, 0 is error
        virtual bool hasVideo() const { return m_has_video; }
        virtual bool hasAudio() const { return m_has_audio; }

        virtual CAVSceneNode* clone(scene::ISceneNode* newParent = 0, scene::ISceneManager* newSceneManager = 0);

        virtual void OnRegisterSceneNode();

        virtual void OnAnimate(u32 timeMs);

        virtual void render();

        virtual const core::aabbox3d<f32>& getBoundingBox() const;

        virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const;

        virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0);

        virtual scene::ESCENE_NODE_TYPE getType() const { return (scene::ESCENE_NODE_TYPE)scene::ESNT_AV; }

        virtual void setVisible(bool isVisible);

        virtual video::SMaterial& getMaterial(u32 i);

        virtual u32 getMaterialCount() const;   

private:

        irr::IrrlichtDevice* Device;
        CSceneManager2* SceneManager2;
        core::aabbox3d<f32> Box;
        av_t*   m_av;
        irr::io::path m_filename;
        video::SMaterial Material;
        bool m_play;
        bool m_loop;
        bool m_stream;
        bool m_show;
        bool m_use_as_uv;
        bool m_screen_align;
        bool m_forground;
        //bool m_auto_close;
        bool m_has_audio;
        bool m_has_video;
        bool m_alpha;
        f32      m_vol;
        core::vector2df m_pos;
        core::position2di m_size;
        int     m_align;
        f32 m_play_time;
        u32 LastTimeMs;
        irr::video::ITexture* m_tex;
        irr::video::IImage* m_image; // ref only from av
        irr::scene::SMeshBuffer m_mb_fullscreen;
        SPsd* m_psd;
        u32 m_draworder;

};

} // end namespace arsa
} // end namespace irr

#endif // __C_AV_SCENE_NODE_H__