CARSAPsd.h

Go to the documentation of this file.

#ifndef __C_ARSA_PSD_SCENE_NODE_H__
#define __C_ARSA_PSD_SCENE_NODE_H__

#include <irrlicht.h>

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

namespace irr
{

class IARSAInput;

#ifndef ARSA_FRAMEWORK
namespace scene
{
        const int ESNT_ARSA_PSD = MAKE_IRR_ID('a','p','s','d');
}
#endif

namespace arsa
{

class CConstant;
struct SPsd;
struct SPsdList;

enum E_DRAW_FLAGS
{
        EDF_NONE = 0,
        EDF_CENTER = 1,
        EDF_TOP = 2,
        EDF_BOTTOM = 4,
        EDF_LEFT = 8,
        EDF_RIGHT = 16,
        EDF_HFLIP = 32,
        EDF_VFLIP = 64,
        EDF_DEFAULT = EDF_TOP|EDF_LEFT
};

enum E_DRAW_TYPE
{
        EDT_SPRITE = 0,
        EDT_HUD,
        EDT_ANIMATE,
        EDT_REF,
        EDT_GROUP,
        EDT_FUNCTION,
        EDT_WIDGET,
        //EDT_POLYGON,
        //EDT_LAYER,
        //EDT_STAR,
        EDT_COUNT
};

enum E_LOOP_FLAG
{
        ELF_ONCE = 2,
        ELF_LOOP = 4,
        ELF_PINGPONG = 8,
        ELF_DEFAULT = ELF_LOOP
};

class CARSAPsd : public scene::ISceneNode
{
public:
        CARSAPsd(scene::ISceneNode* parent, scene::ISceneManager* smgr, s32 id = -1);
        virtual ~CARSAPsd( );

        virtual CARSAPsd* 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_ARSA_PSD; }       

        // class operation
        virtual bool load( const io::path& filename, bool cls = true, bool cache = true );      
        virtual bool cache(const io::path& filename, bool cache = true);
        virtual bool merge( CARSAPsd* src );
        virtual void clear( bool removeTex = true ); // all clean-up
        virtual s32 addPsdLayer(const irr::core::stringc& name, irr::video::ITexture* tex, bool force_add = false);
        virtual bool isOk() const;
        virtual bool isPsdFile(const io::path& filename) const;
        virtual bool isPsdQuit() const;
        virtual void setPsdQuit(bool quit = true);
        virtual s32 getPsdId(const core::stringc& name) const;
        virtual s32 getPsdId(const SPsd& psd) const;
        virtual s32 getPsdIdByPrefix(const core::stringc& prefix) const;
        virtual u32 getPsdIdByPrefixs(const core::stringc& prefix, core::array<s32>& out_ids) const;
        virtual u32 getPsdNameByPrefixs(const core::stringc& prefix, core::array<core::stringc>& out_names) const;
        virtual void setOffset(const core::vector3df& offset);
        virtual void setOffsetX(irr::f32 value );
        virtual void setOffsetY(irr::f32 value);
        virtual const core::vector3df& getOffset() const;
        virtual void setMaxOffset(const core::aabbox3df& offset);
        virtual const core::aabbox3df& getMaxOffset() const;
        virtual void setScreenSize(const core::dimension2du& size);
        virtual const core::dimension2du& getScreenSize() const;
        virtual u32 getPsdCount() const;        
        virtual const core::dimension2du& getHitExtend() const;
        virtual void setHitExtend(const core::dimension2du& ext);
        virtual u32 getTriggerFromFunction(const core::stringc& func_name, core::array<core::stringc>& out_trigs );
        virtual u32 getVariableFromFunction(const core::stringc& func_name, core::array<core::stringc>& out_varnames );
        virtual bool existFunction(const core::stringc& func_name) const;
        virtual void setFilename( const io::path& filename);
        virtual io::path getFilename() const;
        virtual arsa::CConstant* getConst() const;
        virtual io::path getAbsoluteFilename() const;
        virtual io::path getAbsolutePath() const;

        virtual void updatePsdNow( s32 id );
        virtual void updatePsdNowAll();
        virtual bool isIdOk(irr::s32 id) const;
        virtual bool isPsdOutOfScreen(irr::s32 id) const;
        virtual void play(irr::s32 id, bool playing = true, irr::s32 customframe = 0 );
        virtual void pause(irr::s32 id);
        virtual bool removePsd(irr::s32 id);
        virtual s32 clonePsd(irr::s32 src_id, const core::stringc& new_name, bool force_add = false);
        virtual core::stringc getPsdName(irr::s32 id) const;
        virtual const SPsd& getPsd(irr::s32 id) const;
        virtual void setPsdVisible(irr::s32 id, bool visible);
        virtual void setPsdVisiblePrefix(const core::stringc& prefix, bool visible);
        virtual bool isPsdVisible(irr::s32 id) const;
        virtual void setPsdPos(irr::s32 id, f32 x, f32 y);
        virtual void getPsdPos(irr::s32 id, f32& x, f32& y) const;
        virtual irr::core::vector3df getPsdPos(irr::s32 id) const;
        virtual irr::core::vector3df getPsdPosOriginal(irr::s32 id) const;
        virtual irr::core::vector3df getPsdPosOutScreen(irr::s32 id, irr::u32 flags) const;
        virtual void setPsdScale(irr::s32 id, const irr::core::vector3df& scale );
        virtual void getPsdScale(irr::s32 id, irr::core::vector3df& out_scale ) const;
        virtual core::dimension2du getPsdSize(irr::s32 id) const;
        virtual void setPsdDrawType(irr::s32 id, E_DRAW_TYPE flags);
        virtual E_DRAW_TYPE getPsdDrawType(irr::s32 id) const;
        virtual void setPsdDrawFlags(irr::s32 id, u32 type);
        virtual s32 getPsdDrawFlags(irr::s32 id) const;
        virtual void setPsdRotFlags(irr::s32 id, u32 type);     
        virtual s32 getPsdRotFlags(irr::s32 id) const;
        virtual void setPsdScaleFlags(irr::s32 id, u32 type);
        virtual s32 getPsdScaleFlags(irr::s32 id) const;
        virtual void setPsdVisFlags(irr::s32 id, u32 type);
        virtual s32 getPsdVisFlags(irr::s32 id) const;
        virtual void setPsdRot(irr::s32 id, const core::vector3df& rot);
        virtual const core::vector3df& getPsdRot(irr::s32 id) const;
        virtual void setPsdRotSpeed(irr::s32 id, f32 speed);
        virtual f32 getPsdRotSpeed(irr::s32 id) const;
        virtual void setPsdColor(irr::s32 id, const video::SColor& color);
        virtual const irr::video::SColor& getPsdColor(irr::s32 id) const;
        virtual const irr::video::SColor& getPsdColorTopLeft(irr::s32 id) const; // get original color layer at 0, 0 pixel
        virtual f32 getDeltaTime() const;
        virtual bool isPlaying(irr::s32 id) const;
        virtual void updateBBox(irr::s32 id);
        virtual video::ITexture* getPsdTexture(irr::s32 id) const;
        virtual void setPsdTexture(irr::s32 id, irr::video::ITexture* tex );
        virtual void setPsdTextureLayer(irr::s32 id, irr::u32 num, irr::video::ITexture* tex);
        virtual void setPsdDrawOrder(irr::s32 id, irr::u32 order);      
        virtual u32  getPsdDrawOrder(irr::s32 id) const;
        virtual void setDrawOrder(u32 order);   
        virtual core::aabbox3df getPsdBBox(irr::s32 id) const;
        virtual void setPsdClampPos(irr::s32 id, bool clamp );
        virtual bool getPsdClampPos(irr::s32 id) const;
        virtual void setPsdFrame(irr::s32 id, u32 frame);
        virtual s32 getPsdFrame(irr::s32 id) const;
        virtual u32 getPsdFrameCount(irr::s32 id) const;
        virtual void setPsdLoopFlags(irr::s32 id, u32 flags);
        virtual u32 getPsdLoopFlags(irr::s32 id) const;
        virtual void setPsdFPS(irr::s32 id, s32 fps);
        virtual void setPsdFPS(irr::s32 id, u32 frame, s32 fps);
        virtual s32 getPsdFPS(irr::s32 id, u32 frame) const;
        virtual bool isFrameOk(irr::s32 id, u32 frame) const;
        virtual bool setPsdRef(irr::s32 id, s32 ref_id) const;
        virtual void setPsdClipRect(irr::s32 id, const irr::core::rectf& cliprect );
        virtual irr::core::rectf getPsdClipRect(irr::s32 id) const;
        virtual void setPsdLayerOffset(irr::s32 id, irr::f32 offsetx, irr::f32 offsety );
        virtual void setPsdMaterialType(irr::s32 id, irr::s32 type);
        virtual const irr::s32 getPsdMaterialType(irr::s32 id ) const;
        virtual void setPsdUserData(irr::s32 id, const irr::core::stringc& key, const irr::core::stringc& value );
        virtual irr::core::stringc getPsdUserData(irr::s32 id, const irr::core::stringc& key) const;
        virtual void removePsdUserData(irr::s32 id, const irr::core::stringc& key);
        virtual void clearPsdUserData(irr::s32 id ); // internal used only!!!
        virtual void setPsdTexClamp(irr::s32 id, irr::video::E_TEXTURE_CLAMP value);
        virtual irr::video::E_TEXTURE_CLAMP getPsdTexClamp(irr::s32 id ) const;
        virtual void setPsdGPUConstant(irr::s32 id, const irr::video::IVideoDriver::SShaderConstant& value );
        virtual const irr::video::IVideoDriver::SShaderConstant* getPsdGPUConstant(irr::s32 id, const irr::core::stringc& key) const;
        virtual const irr::video::IVideoDriver::SShaderConstant* getPsdGPUConstant(irr::s32 id, irr::u32 num) const;
        virtual size_t getPsdGPUConstantSize(irr::s32 id) const;
        virtual void clearPsdGPUConstant(irr::s32 id);  
        virtual irr::u32 addPsdFrame(irr::s32 id, irr::u32 framecount);
        virtual void clearPsdFrame(irr::s32 id);
        virtual void setPsdTextureFrame(irr::s32 id, irr::u32 numframe, irr::video::ITexture* tex);

        virtual int getPsdType(irr::s32 id) const;

        virtual void setPsdVisiblePercent(irr::s32 id, int perx, int pery );
        virtual irr::core::vector2di getPsdVisiblePercent(irr::s32 id) const;

        virtual void draw(irr::s32 id, const video::ITexture* tex, u32 drawflags = EDF_DEFAULT );
        virtual void draw(irr::s32 id, f32 x, f32 y );

        virtual void drawOnce(irr::s32 id, const irr::video::ITexture* tex, u32 drawflags = EDF_DEFAULT);
        virtual void drawOnce(irr::s32 id, irr::f32 x, irr::f32 y);

        virtual void draw2DImage(const video::ITexture* texture, const core::position2d<s32>& destPos,
                const core::rect<s32>& sourceRect, const core::rect<s32>* clipRect =0,
                video::SColor color=video::SColor(255,255,255,255), bool useAlphaChannelOfTexture=false);
        virtual void draw2DImageBatch(const video::ITexture* texture,
                        const core::array<core::position2d<s32> >& positions,
                        const core::array<core::rect<s32> >& sourceRects,
                        const core::rect<s32>* clipRect=0,
                        video::SColor color=video::SColor(255,255,255,255),
                        bool useAlphaChannelOfTexture=false);

        //========================================
        // hit
        //========================================
        virtual void PickupClear();
        //virtual irr::s32 getPickupState(irr::s32 id);
        //virtual irr::s32 getPickupLayerId() const;
        irr::s32 getPickupState(const core::stringc& prefix);
        const irr::core::stringc& getPickupLayerName() const;

        virtual core::stringc hitTouch(irr::u32 touch_flag, bool hit_invisible = false, int touchid = 0) const;
        virtual bool hitTouchLayer(const core::stringc& name, irr::u32 touch_flag, bool hit_invisible = false, int touchid = 0) const;
        virtual s32 hitTouchPrefix(const core::stringc& prefix, irr::u32 touch_flag, bool hit_invisible = false, int touchid = 0) const;
        virtual u32 hitTouchPrefixs(const core::stringc& prefix, irr::u32 touch_flag, core::array<s32>& out_ids, bool hit_invisible = false, int touchid = 0);

        virtual core::stringc hitLayer(const core::stringc& name, bool hit_invisible = false) const;
        virtual bool hitLayer(const core::stringc& name, const core::stringc& name2, bool hit_invisible = false) const;
        virtual core::stringc hitLayerPrefix(const core::stringc& prefix, bool hit_invisible = false) const;
        virtual bool hitLayerPrefix(const core::stringc& name, const core::stringc& prefix, bool hit_invisible = false) const;
        virtual u32  hitLayerPrefixs(const core::stringc& name, const core::stringc& prefix, core::array<s32>& out_ids, bool hit_invisible = false);
        virtual bool hitLayerPrefixWithPrefix(const core::stringc& prefix, const core::stringc& prefix2, bool hit_invisible = false) const;
        virtual u32  hitLayerPrefixWithPrefixs(const core::stringc& prefix, const core::stringc& prefix2, core::array<s32>& out_ids, bool hit_invisible = false);

        virtual s32 hitId(irr::s32 id, bool hit_invisible = false) const;
        virtual u32 hitId(irr::s32 id, core::array<s32>& out_ids, bool hit_invisible = false);
        virtual s32 hitIdPrefix(irr::s32 id, const core::stringc& prefix, bool hit_invisible = false) const;
        virtual u32 hitIdPrefixs(irr::s32 id, const core::stringc& prefix, core::array<s32>& out_ids, bool hit_invisible = false);

        virtual bool hitXYId(int x, int y, s32 id, bool hit_invisible = false) const;
        virtual bool hitXYLayer(int x, int y, const core::stringc& name, bool hit_invisible = false) const;
        virtual int  hitXY(int x, int y, bool hit_invisible = false) const;
        virtual u32  hitXYs(int x, int y, core::array<s32>& out_ids, bool hit_invisible = false);
        virtual s32  hitXYPrefix(int x, int y, const core::stringc& prefix, bool hit_invisible = false) const;
        virtual u32  hitXYPrefixs(int x, int y, const core::stringc& prefix, core::array<s32>& out_ids, bool hit_invisible = false);

        virtual bool hitLine(const core::line3df& line, s32 id, bool hit_invisible = false) const;
        virtual int  hitLine(const core::line3df& line, bool hit_invisible = false) const;
        virtual u32  hitLine(const core::line3df& line, core::array<s32>& out_ids, bool hit_invisible = false);

        virtual bool hitBox(const core::aabbox3df& box, s32 id, bool hit_invisible = false) const;

        static bool hitPsd(const SPsd& a, const SPsd& b, bool hit_invisible = false);
        static bool hitXY(const SPsd& a, int x, int y, const core::dimension2du& screensize, const core::dimension2du& hitext, bool hit_invisible = false);
        static bool hitLine(const SPsd& a, const core::line3df& line, const core::dimension2du& screensize, bool hit_invisible = false);
        static bool hitBox(const SPsd& a, const core::aabbox3df& box, const core::dimension2du& screensize, bool hit_invisible = false);

        //========================================
        // deprecate hit
        //========================================
        static bool hit( const SPsd& a, const SPsd& b, bool hit_invisible = false );
        static bool hit( const SPsd& a, int x, int y, const core::dimension2du& screensize, const core::dimension2du& hitext, bool hit_invisible = false );
        static bool hit( const SPsd& a, const core::line3df& line, const core::dimension2du& screensize, bool hit_invisible = false );
        static bool hit( const SPsd& a, const core::aabbox3df& box, const core::dimension2du& screensize, bool hit_invisible = false );

        virtual bool hit(int x, int y, s32 id, bool hit_invisible = false) const;
        virtual bool hit( int x, int y, const core::stringc& name, bool hit_invisible = false ) const;  
        virtual int  hit( int x, int y, bool hit_invisible = false ) const;
        virtual u32  hit( int x, int y, core::array<s32>& out_ids, bool hit_invisible = false );

        virtual int hit(irr::s32 id, bool hit_invisible = false) const;
        virtual int hit( const SPsd& a, bool hit_invisible = false ) const;
        virtual u32 hit( const SPsd& a, core::array<s32>& out_ids, bool hit_invisible = false );        

        virtual bool hit(const core::line3df& line, s32 id, bool hit_invisible = false) const;
        virtual int hit( const core::line3df& line, bool hit_invisible = false ) const;
        virtual u32 hit( const core::line3df& line, core::array<s32>& out_ids, bool hit_invisible = false );

        virtual bool hit(const core::aabbox3df& box, s32 id, bool hit_invisible = false) const;

        virtual s32 addGroup( const core::stringc& group_name );
        virtual s32 getGroupId(const core::stringc& group_name);
        virtual s32 getGroupIdByPrefix(const core::stringc& prefix) const;
        virtual u32 getGroupIdByPrefixs(const core::stringc& prefix, core::array<s32>& out_group_ids) const;
        virtual u32 getGroupCount();
        virtual irr::core::stringc getGroupNameById(irr::s32 group_id);
        virtual u32 addElement(irr::s32 group_id, s32 psd_id);
        virtual void removeElement(irr::s32 group_id, s32 psd_id);
        virtual s32 getElementId(irr::s32 group_id, s32 psd_id) const;
        virtual s32 getElementPsdIdById(irr::s32 group_id, s32 num) const;
        virtual u32 getElementCount(irr::s32 group_id) const;   
        virtual void setGroupPos(irr::s32 group_id, f32 x, f32 y);
        virtual void setGroupScale(irr::s32 group_id, const irr::core::vector3df& scale);
        virtual void setGroupVisible(irr::s32 group_id, bool visible = true);
        virtual void setGroupVisibleOnlyOne(irr::s32 group_id, s32 psd_id, bool only_one_visible = true );
        virtual void setGroupPlay(irr::s32 group_id, bool playing = true);
        virtual void setGroupPlayOnlyOne(irr::s32 group_id, s32 psd_id, bool only_one_playing = true);
        virtual void setGroupDrawFlags(irr::s32 group_id, u32 flags);
        virtual void setGroupRotFlags(irr::s32 group_id, u32 flags);
        virtual void setGroupScaleFlags(irr::s32 group_id, u32 flags);
        virtual void setGroupVisFlags(irr::s32 group_id, u32 flags);
        virtual void setGroupColor(irr::s32 group_id, const video::SColor& color);
        virtual void setGroupRot(irr::s32 group_id, const core::vector3df& rot);
        virtual void setGroupRotSpeed(irr::s32 group_id, f32 speed);
        virtual void setGroupClampPos(irr::s32 group_id, bool clamp);
        virtual void setGroupDrawOrder(irr::s32 group_id, u32 order);
        virtual void setGroupClipRect(irr::s32 group_id, const irr::core::rectf& cliprect);
        virtual bool isGroupExistId(irr::s32 group_id, s32 psd_id) const;
        virtual bool isGroupIdOk(irr::s32 group_id) const;
        virtual bool isGroupPlay(irr::s32 group_id) const;      

        virtual void animClearAll();
        virtual void animClear(irr::s32 id);
        virtual void animResetAll();
        virtual void animReset(irr::s32 id);
        virtual u32 animGetCount(irr::s32 id) const;
        virtual void animAddFade(irr::s32 id, irr::u32 start = 0, irr::u32 end = 255, irr::u32 vel = 300, bool wait = true, bool reset = true);
        virtual void animAddScale(irr::s32 id, const irr::core::vector3df& start = irr::core::vector3df(1), const irr::core::vector3df& end = irr::core::vector3df(1), const irr::core::vector3df& vel = irr::core::vector3df(3), bool wait = true, bool reset = true);
        virtual void animAddRot(irr::s32 id, const irr::core::vector3df& start = irr::core::vector3df(1), const irr::core::vector3df& end = irr::core::vector3df(1), const irr::core::vector3df& vel = irr::core::vector3df(300), bool wait = true, bool reset = true);
        virtual void animAddMove(irr::s32 id, const irr::core::vector3df& start = irr::core::vector3df(0), const irr::core::vector3df& end = irr::core::vector3df(100), const irr::core::vector3df& vel = irr::core::vector3df(300), bool wait = true, bool reset = true);
        virtual void animAddVisible(irr::s32 id, const irr::core::vector3df& start = irr::core::vector3df(100), const irr::core::vector3df& end = irr::core::vector3df(100), const irr::core::vector3df& vel = irr::core::vector3df(3), bool wait = true, bool reset = true);
        virtual void animAddDelay(irr::s32 id, irr::f32 delay_sec, bool wait = true);
        virtual void animAddAV(irr::s32 id, const irr::io::path& filename, bool wait = true);
        virtual void animAddOffset(irr::s32 id, const irr::core::vector3df& start = irr::core::vector3df(0), const irr::core::vector3df& end = irr::core::vector3df(100), const irr::core::vector3df& vel = irr::core::vector3df(300), bool wait = true, bool reset = true);
        virtual void animSetLoop(irr::s32 id, irr::u32 start = 0, irr::u32 end = 0, irr::s32 count = 0);
        // 2023_10_19 added by oil
        virtual bool animIsEndAll(irr::s32 id);

        virtual void batAdd(irr::f32 sec, const irr::core::stringc& psd_func);
        virtual void batPlay(bool play = true);
        virtual void batStop(); 
        virtual void batClear();
        virtual void batReset();
        virtual u32  batGetCount() const;
        virtual bool batRemove( u32 id );
        virtual bool batIsOk() const;

        virtual s32 getMaterialType() const;

        virtual bool loadTrigger(const io::path& filename, bool clear = true);
        virtual bool loadTrigger(io::IReadFile* fp, bool clear = true);
        virtual bool loadTrigger(const core::array<core::stringc>& streams, bool clear = true, const irr::io::path& filename = irr::io::path("built-in"));
        virtual bool callTriggerFunction(const core::stringc& func);
        virtual bool callTrigger(const core::stringc& script_str );
        virtual void clearTrigger();
        virtual io::path getTriggerFilename() const;
        virtual bool getTriggerError() const;

        virtual SPsd* allocatePsd();
        virtual void freePsd(SPsd** dead);

        virtual bool getPsdFromTexture( SPsd& out, irr::video::ITexture* tex, f32 x = 0, f32 y = 0, irr::core::vector3df rot = irr::core::vector3df(), irr::core::vector3df scale = irr::core::vector3df(1), irr::u32 draworder = 0 );
        virtual irr::scene::IMeshBuffer* getMeshBuffer(const SPsd& psd) const;

        virtual irr::core::stringc addPointer(void* pointer);
        virtual bool removePointer(const irr::core::stringc& guid);
        void clearPointer();
        virtual irr::u32 getPointerCount() const;
        virtual void* getPointer(const irr::core::stringc& guid) const;
        virtual void  setPointer(const irr::core::stringc& guid, void* pointer);
        virtual SPsdList* getPsdList() const { return PsdList; }
        virtual irr::u32 getLayerCount() const;
        virtual irr::u32 getLayerNum() const;

        // internal use only
        virtual void gpuUpload();
        s32 addPsd(const SPsd& psd, bool force_add = false, irr::s32 start = -1 ); // internal call only
        //bool getArefPsd(const void *psd_layer, const irr::core::stringc& layer_name, irr::arsa::SPsd& out_psd);

        // util for external used
        void HitLayerClear();
        irr::s32 HitLayerIsAdded(const irr::core::stringc& name1, const irr::core::stringc& name2);
        bool HitLayerRemove(const irr::core::stringc& name1, const irr::core::stringc& name2);
        bool HitLayerAdd(const irr::core::stringc& name1, const irr::core::stringc& name2);

private:
        SPsdList* PsdList;
                
        void updatePsd(SPsd& psd);
        void drawPsd( const SPsd& psd);

        void addQueueRendering(irr::s32 id);

};

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

#endif // __C_ARSA_PSD_SCENE_NODE_H__