BaseObject.h

#pragma once
#include "IAttributeFields.h"
#include "IViewClippingObject.h"
#include "IRefObject.h"
#include "IHeadOn3D.h"
#include "IObjectScriptingInterface.h"
#include <list>
#include <vector>
#include "unordered_ref_array.h"
#include "EffectFileHandles.h"
#include "ObjectEvent.h"

namespace ParaEngine
{
class IParaDebugDraw;

enum OBJECT_ATTRIBUTE
{
    OBJ_VOLUMN_SENSOR = 1,
    OBJ_VOLUMN_CONTAINER = 0x1<<1,
    OBJ_VOLUMN_FREESPACE = 0x1<<2,
    OBJ_VOLUMN_ISOLATED = 0x1<<3,
    OBJ_VOLUMN_TILE_VISITOR = 0x1<<4,
    OBJ_VOLUMN_VIP = 0x1<<5,
    OBJ_VOLUMN_INVISIBLE = 0x1<<6,
    VOLUMN_MASK = 0x7f,
    MESH_USE_LIGHT = 0x1<<7,
    MESH_BILLBOARDED= 0x1<<8,
    MESH_SHADOW_RECEIVER= 0x1<<9,
    MESH_SHADOW_NOT_CASTER= 0x1<<10,
    MESH_VEGETATION= 0x1<<11,
    OBJ_SHOW_BOUNDINGBOX = 0x1<<12,
    OBJ_BIG_STATIC_OBJECT = 0x1<<13,
    OBJ_SKIP_RENDER = 0x1<<14,
    OBJ_SKIP_PICKING = 0x1<<15,
    OBJ_SKIP_TERRAIN_NORMAL = 0x1<<16,
    /* whether the object will be rendered with a custom renderer. The default draw function will do nothing. */
    OBJ_CUSTOM_RENDERER = 0x1 << 17,
};

enum PHYSICS_METHOD{
    PHYSICS_LAZY_LOAD = 1,
    PHYSICS_ALWAYS_LOAD = 0x1 << 1,
    PHYSICS_FORCE_NO_PHYSICS = 0x1 << 2,
    PHYSICS_LOAD_FROM_ASSET = 0x1 << 3
};

enum ObjectType
{
    _undefined = 0,
    _Floor = 2,
    _Sky = 3,
    _MeshTerrain = 4,
    _Scene = 5,
    _LocalLight = 6,

    _PC_Zone=7,
    _PC_Portal=8,
    _PC_AntiPortal=9,

    _Tile = 20,         

    _Sensor = 22,
    _House = 23,
    _SolidHouse = 24, 
    _SolidLightedHouse = 25,
    _SolidMesh = 26,
    _DummyMesh = 27,
    _MiniSceneGraph = 28,
    // voxel mesh from a 3d grid.
    _VoxelMesh = 29,

    _Biped = 40,            
    _DummyAnimMesh=41,  
    _SolidAnimMesh=42,      
    _NPC=50,                
    
    _GlobalBiped = 60,      
    _OPC,               
    _Team,
    _Creature,
    _Player,
    _RPG, // typical RPG object
    _UnknownGlobal,
    
    _CameraFollowPerson=100,
    _CameraThirdPerson=101,
    _CameraFirstPerson=102,
};

enum RenderSelectionStyle
{
    RenderSelectionStyle_unlit = 0,
    RenderSelectionStyle_border = 1,
    RenderSelectionStyle_flash = 2,
};


struct AssetEntity;
class CBaseObject : public IViewClippingObject, public IHeadOn3D, public IObjectScriptingInterface
{
public:
    typedef ParaEngine::weak_ptr<IObject, CBaseObject> WeakPtr_type;

    // typedef std::list<CBaseObject*> CChildObjectList_Type;
    typedef unordered_ref_array<CBaseObject*> CChildObjectList_Type;
    typedef std::list<ObjectEvent> ObjectEventList_Type;
    
    enum _SceneObjectType
    {
        BaseObject = 0,
        ContainerObject = 0x1,
        MeshObject = 0x1<<1,
        SkyMesh = 0x1<<2,
        BipedObject = 0x1<<3,
        SpriteObject = 0x1<<4,
        SceneRoot = 0x1<<5,
        OPCBiped = 0x1<<6,
        RPGBiped = 0x1<<7,
        MDXObject = 0x1<<8,
        MeshPhysicsObject = 0x1<<9,
        DynamicObject  = 0x1<<10,
        ViewCullingObject  = 0x1<<11,
        MissileObject  = 0x1<<12,
        GameObject  = 0x1<<13,
        LightObject = 0x1<<14,
        MiniSceneGraph  = 0x1<<15,
        VoxelMesh  = 0x1<<16,
        ManagedLoader  = 0x1<<17,
        ZoneNode  = 0x1<<18,
        PortalNode  = 0x1<<19,
        AntiPortalNode  = 0x1<<20,
        CadObject = 0x1<<21,
    };
    virtual CBaseObject::_SceneObjectType GetType(){return CBaseObject::BaseObject;};

    enum CallBackType{
        Type_EnterSentientArea=0,
        Type_LeaveSentientArea,
        Type_Click,
        Type_Event,
        Type_Perception,
        Type_FrameMove,
        Type_Net_Send,
        Type_Net_Receive,
        Type_OnLoadScript, 
        Type_OnAssetLoaded, 
        Type_Paint,
        Type_Unknown,
    };

    enum NPL_STRING{
        NPL_CREATE = 0, 
        NPL_CREATE_IN_LOADER = 0x1<<1, 
        NPL_UPDATE = 0x1<<2, 
        NPL_DELETE = 0x1<<3,    
        NPL_DONOT_OUTPUT_ASSET = 0x1<<4,      
    };
    CBaseObject(void);
    virtual ~CBaseObject(void);

    virtual void Clone(CBaseObject* obj);

    virtual CBaseObject* Clone();


    virtual std::string ToString(DWORD nMethod);

    int GetID();

    static CBaseObject* GetObjectByID(int nID);

    // implementation of IAttributeFields

    virtual int GetAttributeClassID(){return ATTRIBUTE_CLASSID_CBaseObject;}
    virtual const char* GetAttributeClassName(){static const char name[] = "CBaseObject"; return name;}
    virtual const char* GetAttributeClassDescription(){static const char desc[] = ""; return desc;}
    virtual int InstallFields(CAttributeClass* pClass, bool bOverride);
    
    virtual bool AddChildAttributeObject(IAttributeFields* pChild, int nRowIndex = -1, int nColumnIndex = 0);

    virtual void* QueryObjectByName(const std::string& sObjectType);

    virtual void* QueryObject(int nObjectType);

    ATTRIBUTE_METHOD1(CBaseObject, GetID_s, int*)   { *p1 = cls->GetID(); return S_OK; }

    ATTRIBUTE_METHOD1(CBaseObject, IsGlobal_s, bool*)       {*p1 = cls->IsGlobal(); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetFacing_s, float*) {*p1 = cls->GetFacing(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetFacing_s, float)  {cls->SetFacing(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetYaw_s, float*)    { *p1 = cls->GetYaw(); return S_OK; }
    ATTRIBUTE_METHOD1(CBaseObject, SetYaw_s, float) { cls->SetYaw(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CBaseObject, GetPitch_s, float*)  { *p1 = cls->GetPitch(); return S_OK; }
    ATTRIBUTE_METHOD1(CBaseObject, SetPitch_s, float)   { cls->SetPitch(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CBaseObject, GetRoll_s, float*)   { *p1 = cls->GetRoll(); return S_OK; }
    ATTRIBUTE_METHOD1(CBaseObject, SetRoll_s, float)    { cls->SetRoll(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CBaseObject, GetHeight_s, float*) {*p1 = cls->GetHeight(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetHeight_s, float)  {cls->SetHeight(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetWidth_s, float*)  {*p1 = cls->GetWidth(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetWidth_s, float)   {cls->SetWidth(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetDepth_s, float*)  {*p1 = cls->GetDepth(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetDepth_s, float)   {cls->SetDepth(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetRadius_s, float*) {*p1 = cls->GetRadius(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetRadius_s, float)  {cls->SetRadius(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetPosition_s, DVector3*)    { *p1 = cls->GetPosition(); return S_OK; }
    ATTRIBUTE_METHOD1(CBaseObject, SetPosition_s, DVector3) { cls->SetPosition(p1); return S_OK; }
    
    ATTRIBUTE_METHOD1(CBaseObject, GetAssetFileName_s, const char**)    { *p1 = cls->GetAssetFileName().c_str(); return S_OK; }
    ATTRIBUTE_METHOD1(CBaseObject, SetAssetFileName_s, const char*) { cls->SetAssetFileName(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CBaseObject, GetTechHandle_s, int*)   {*p1 = cls->GetPrimaryTechniqueHandle(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetTechHandle_s, int)    {cls->SetPrimaryTechniqueHandle(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetCtorPercentage_s, float*) {*p1 = cls->GetCtorPercentage(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetCtorPercentage_s, float)  {cls->SetCtorPercentage(p1); return S_OK;}
    
    ATTRIBUTE_METHOD1(CBaseObject, GetHomeZone_s, const char**) {*p1 = cls->GetHomeZoneName(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetHomeZone_s, const char*)  {cls->SetHomeZoneName(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetShowBoundingBox_s, bool*) {*p1 = cls->IsShowBoundingBox(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetShowBoundingBox_s, bool)  {cls->ShowBoundingBox(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetPhysicsGroup_s, int*) {*p1 = cls->GetPhysicsGroup(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetPhysicsGroup_s, int)  {cls->SetPhysicsGroup(p1); return S_OK;}
    
    ATTRIBUTE_METHOD1(CBaseObject, GetPhysicsGroupMask_s, DWORD*)   {*p1 = cls->GetPhysicsGroupMask(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetPhysicsGroupMask_s, DWORD)    {cls->SetPhysicsGroupMask(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetSelectGroupIndex_s, int*) {*p1 = cls->GetSelectGroupIndex(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetSelectGroupIndex_s, int)  {cls->SetSelectGroupIndex(p1); return S_OK;}
    
    ATTRIBUTE_METHOD(CBaseObject, Reset_s)  {cls->Reset(); return S_OK;}

    DEFINE_SCRIPT_EVENT_GET(CBaseObject, OnAssetLoaded);
    ATTRIBUTE_METHOD1(CBaseObject, SetOnAssetLoaded_s, const char*) {cls->SetOnAssetLoaded(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetRenderOrder_s, float*)            { *p1 = cls->GetRenderOrder(); return S_OK; }
    ATTRIBUTE_METHOD1(CBaseObject, SetRenderOrder_s, float)     { cls->SetRenderOrder(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CBaseObject, GetRenderImportance_s, int*)         { *p1 = cls->GetRenderImportance(); return S_OK; }
    ATTRIBUTE_METHOD1(CBaseObject, SetRenderImportance_s, int)      { cls->SetRenderImportance(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CBaseObject, GetRenderDistance_s, float*)         {*p1 = cls->GetRenderDistance(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetRenderDistance_s, float)      {cls->SetRenderDistance(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetAnimation_s, int*)        {*p1 = cls->GetAnimation(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetAnimation_s, int)     {cls->SetAnimation(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetAnimFrame_s, int*)        {*p1 = cls->GetAnimFrame(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetAnimFrame_s, int)     {cls->SetAnimFrame(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, IsAnimEnabled_s, bool*)      { *p1 = cls->IsAnimEnabled(); return S_OK; }
    ATTRIBUTE_METHOD1(CBaseObject, EnableAnim_s, bool)      { cls->EnableAnim(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CBaseObject, IsUseGlobalTime_s, bool*)        {*p1 = cls->IsUseGlobalTime(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetUseGlobalTime_s, bool)        {cls->SetUseGlobalTime(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetChildCount_s, int*)       {*p1 = (int)(cls->GetChildren().size()); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetNormal_s, Vector3*)       {*p1 = cls->GetNormal(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetNormal_s, Vector3)        {cls->SetNormal(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, IsTransparent_s, bool*)  {*p1 = cls->IsTransparent(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetTransparent_s, bool)  {cls->SetTransparent(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, IsVisible_s, bool*)  {*p1 = cls->IsVisible(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetVisibility_s, bool)   {cls->SetVisibility(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, IsShadowCaster_s, bool*) {*p1 = cls->IsShadowCaster(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetShadowCaster_s, bool) {cls->SetShadowCaster(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, IsShadowReceiver_s, bool*)   {*p1 = cls->IsShadowReceiver(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetShadowReceiver_s, bool)   {cls->SetShadowReceiver(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, IsBillboarded_s, bool*)  {*p1 = cls->IsBillboarded(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetBillboarded_s, bool)  {cls->SetBillboarded(p1); return S_OK;}
    
    ATTRIBUTE_METHOD1(CBaseObject, IsSkipRender_s, bool*)   {*p1 = cls->IsSkipRender(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetSkipRender_s, bool)   {cls->SetSkipRender(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, IsSkipPicking_s, bool*)  {*p1 = cls->IsSkipPicking(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetSkipPicking_s, bool)  {cls->SetSkipPicking(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, IsSkipTerrainNormal_s, bool*)    {*p1 = cls->IsSkipTerrainNormal(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetSkipTerrainNormal_s, bool)    {cls->SetSkipTerrainNormal(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetSelectionEffect_s, int*)      {*p1 = cls->GetSelectionEffect(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetSelectionEffect_s, int)       {cls->SetSelectionEffect(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, IsHeadOnZEnabled_s, bool*)   {*p1 = cls->IsHeadOnZEnabled(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetHeadOnZEnabled_s, bool)   {cls->SetHeadOnZEnabled(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, IsHeadOn3DScalingEnabled_s, bool*)   {*p1 = cls->IsHeadOn3DScalingEnabled(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetHeadOn3DScalingEnabled_s, bool)   {cls->SetHeadOn3DScalingEnabled(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, IsHeadOnUseGlobal3DScaling_s, bool*) {*p1 = cls->IsHeadOnUseGlobal3DScaling(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetHeadOnUseGlobal3DScaling_s, bool) {cls->SetHeadOnUseGlobal3DScaling(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetHeadOnNearZoomDist_s, float*) {*p1 = cls->GetHeadOnNearZoomDist(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetHeadOnNearZoomDist_s, float)  {cls->SetHeadOnNearZoomDist(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetHeadOnFarZoomDist_s, float*)  {*p1 = cls->GetHeadOnFarZoomDist(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetHeadOnFarZoomDist_s, float)   {cls->SetHeadOnFarZoomDist(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetHeadOnMinUIScaling_s, float*) {*p1 = cls->GetHeadOnMinUIScaling(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetHeadOnMinUIScaling_s, float)  {cls->SetHeadOnMinUIScaling(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetHeadOnMaxUIScaling_s, float*) {*p1 = cls->GetHeadOnMaxUIScaling(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetHeadOnMaxUIScaling_s, float)  {cls->SetHeadOnMaxUIScaling(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetHeadOnAlphaFadePercentage_s, float*)  {*p1 = cls->GetHeadOnAlphaFadePercentage(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetHeadOnAlphaFadePercentage_s, float)   {cls->SetHeadOnAlphaFadePercentage(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, GetHeadOn3DFacing_s, float*) {*p1 = cls->GetHeadOn3DFacing(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetHeadOn3DFacing_s, float)  {cls->SetHeadOn3DFacing(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, IsPersistent_s, bool*)       {*p1 = cls->IsPersistent(); return S_OK;}
    ATTRIBUTE_METHOD1(CBaseObject, SetPersistent_s, bool)       {cls->SetPersistent(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CBaseObject, IsDead_s, bool*)     { *p1 = cls->IsDead(); return S_OK; }
    ATTRIBUTE_METHOD1(CBaseObject, SetDead_s, bool)     { cls->SetDead(); return S_OK; }
    
    ATTRIBUTE_METHOD1(CBaseObject, IsTileObject_s, bool*)       { *p1 = cls->IsTileObject(); return S_OK; }
    ATTRIBUTE_METHOD1(CBaseObject, SetTileObject_s, bool)       { cls->SetTileObject(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CBaseObject, GetFrameNumber_s, int*)          { *p1 = cls->GetFrameNumber(); return S_OK; }
    ATTRIBUTE_METHOD1(CBaseObject, SetFrameNumber_s, int)       { cls->SetFrameNumber(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CBaseObject, GetOpacity_s, float*)        { *p1 = cls->GetOpacity(); return S_OK; }
    ATTRIBUTE_METHOD1(CBaseObject, SetOpacity_s, float)     { cls->SetOpacity(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CBaseObject, IsLastFrameRendered_s, bool*)        { *p1 = cls->IsLastFrameRendered(); return S_OK; }
    ATTRIBUTE_METHOD(CBaseObject, DestroyChildren_s)        { cls->DestroyChildren(); return S_OK; }

    ATTRIBUTE_METHOD1(CBaseObject, GetRenderMatrix_s, Matrix4*)     { cls->GetRenderMatrix(*p1); return S_OK; }

    ATTRIBUTE_METHOD1(CBaseObject, SetLocalTransform_s, const Matrix4&)     { cls->SetLocalTransform(p1); return S_OK; }
    ATTRIBUTE_METHOD1(CBaseObject, GetLocalTransform_s, Matrix4*)       { cls->GetLocalTransform(p1); return S_OK; }
    
    ATTRIBUTE_METHOD1(CBaseObject, IsPhysicsEnabled_s, bool*)   { *p1 = cls->IsPhysicsEnabled(); return S_OK; }
    ATTRIBUTE_METHOD1(CBaseObject, EnablePhysics_s, bool)   { cls->EnablePhysics(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CBaseObject, IsLODEnabled_s, bool*) { *p1 = cls->IsLODEnabled(); return S_OK; }
    ATTRIBUTE_METHOD1(CBaseObject, EnableLOD_s, bool) { cls->EnableLOD(p1); return S_OK; }

    virtual IAttributeFields* GetChildAttributeObject(const std::string& sName);
    virtual int GetChildAttributeObjectCount(int nColumnIndex = 0);
    virtual int GetChildAttributeColumnCount();
    virtual IAttributeFields* GetChildAttributeObject(int nRowIndex, int nColumnIndex = 0);
public:
    
    virtual bool IsGlobal();
    inline bool IsBiped(){return m_objType>=_Biped;};

    virtual IGameObject* QueryIGameObject();
    virtual IAttributeFields* GetAttributeObject();

    inline bool CheckVolumnField(DWORD volType){ return CheckAttribute(volType);};
    
    virtual TextureEntity* GetTexture();

    inline bool CheckAttribute(DWORD attribute){
        return (m_dwAttribute & attribute)>0;
    }
    inline void SetAttribute(DWORD dwAtt, bool bTurnOn = true){
        if(bTurnOn)
            m_dwAttribute |= dwAtt;
        else
            m_dwAttribute &= (~dwAtt);
    }

    inline void SetBillboarded(bool bBillboarded){
        SetAttribute(MESH_BILLBOARDED, bBillboarded);
    }
    inline bool IsBillboarded(){
        return CheckAttribute(MESH_BILLBOARDED);
    }

    inline void SetShadowReceiver(bool bEnable){
        SetAttribute(MESH_SHADOW_RECEIVER, bEnable);
    }

    inline bool IsShadowReceiver(){
        return CheckAttribute(MESH_SHADOW_RECEIVER);
    }

    inline void SetShadowCaster(bool bEnable){
        SetAttribute(MESH_SHADOW_NOT_CASTER, !bEnable);
    }

    inline bool IsShadowCaster(){
        return !CheckAttribute(MESH_SHADOW_NOT_CASTER);
    }

    inline void SetVegetation(bool bIsVegetation)
    {
        SetAttribute(MESH_VEGETATION, bIsVegetation);
    }

    inline bool IsVegetation(){
        return CheckAttribute(MESH_VEGETATION);
    }
    
    inline void ShowBoundingBox(bool bShowBoundingBox){
        SetAttribute(OBJ_SHOW_BOUNDINGBOX, bShowBoundingBox);
    }
    inline bool IsShowBoundingBox(){
        return CheckAttribute(OBJ_SHOW_BOUNDINGBOX);
    }

    CZoneNode* GetHomeZone();

    void SetHomeZone(CZoneNode* pZone);

    bool IsVisible();
    void SetVisibility(bool bVisible);

    inline bool IsRenderable() 
    {
        return ! CheckAttribute(OBJ_SKIP_RENDER | OBJ_VOLUMN_INVISIBLE);
    }
    
    inline void SetSkipRender(bool bSkipRender){
        SetAttribute(OBJ_SKIP_RENDER, bSkipRender);
    }

    inline bool IsSkipRender(){
        return CheckAttribute(OBJ_SKIP_RENDER);
    }

    inline void SetSkipPicking(bool bSkipPicking){
        SetAttribute(OBJ_SKIP_PICKING, bSkipPicking);
    }

    inline bool IsSkipPicking(){
        return CheckAttribute(OBJ_SKIP_PICKING);
    }

    void SetSkipTerrainNormal(bool bSkip);

    bool IsSkipTerrainNormal();

    bool CanPick();

    virtual bool CanHasPhysics();
    virtual void LoadPhysics();

    virtual void UnloadPhysics();

    virtual void EnablePhysics(bool bEnable);

    virtual void SetAlwaysLoadPhysics(bool bEnable);

    virtual bool IsPhysicsEnabled();

    virtual bool ViewTouch();

    inline void SetRenderImportance(int nRenderImportance) {m_nRenderImportance = nRenderImportance;}
    inline int GetRenderImportance() {return m_nRenderImportance;}

    float GetRenderOrder() const { return m_fRenderOrder; }
    void SetRenderOrder(float val);

    CChildObjectList_Type&      GetChildren(){ return m_children;};

    CBaseObject* GetChildByName(const string& name, bool bRecursive = false);

    virtual void                    DestroyChildren();

    int DestroyChildByName(const string& name, bool bRecursive = false);

    int RemoveChildByName(const string& name, bool bRecursive = false);

    int RemoveChild(const CBaseObject* pObj, bool bRecursive = false);

    virtual void SetOnAssetLoaded(const char* sCallbackScript);


    bool ActivateScript(int func_type, const string& precode, const string& postcode);
    bool ActivateScript(int func_type, const string& precode);
    bool ActivateScript(int func_type);

    virtual void SetBoundingBox(float fOBB_X, float fOBB_Y, float fOBB_Z, float fFacing);

    virtual void GetBoundingBox(float* fOBB_X, float* fOBB_Y, float* fOBB_Z, float* fFacing);
    
    virtual void SetBoundRect(float fWidth ,float fHeight, float fFacing);
    virtual void GetBoundRect(float* fWidth ,float* fHeight, float* fFacing);

    virtual void SetRadius(float fRadius);
    
    virtual float GetRadius();

    virtual int GetSelectionEffect();

    virtual void SetSelectionEffect(int nStyle);

    virtual bool IsPersistent();
    virtual void SetPersistent(bool bPersistent);

    virtual void SetOpacity(float fOpacity);
    virtual float GetOpacity();
    
    virtual HRESULT InitDeviceObjects();    // device independent
    virtual HRESULT RestoreDeviceObjects(); // device dependent
    virtual HRESULT InvalidateDeviceObjects();
    virtual HRESULT DeleteDeviceObjects();
    virtual HRESULT RendererRecreated();
public:
    virtual float GetRenderDistance();
    virtual void SetRenderDistance(float fDist);

    virtual int GetPrimaryTechniqueHandle();

    virtual void SetPrimaryTechniqueHandle(int nHandle);

    virtual CParameterBlock* GetEffectParamBlock(bool bCreateIfNotExist = false);

    virtual bool IsTransparent(){return false;};

    virtual void SetTransparent(bool bIsTransparent){};

    virtual int GetNumReplaceableTextures();

    virtual TextureEntity* GetDefaultReplaceableTexture(int ReplaceableTextureID); 

    virtual TextureEntity* GetReplaceableTexture(int ReplaceableTextureID);

    virtual bool  SetReplaceableTexture(int ReplaceableTextureID, TextureEntity* pTextureEntity);

    virtual void OnSelect(int nGroupID);
    virtual void OnDeSelect();

    virtual void AddChild(CBaseObject * pObject);
    virtual void SetParent(CBaseObject* pParent) {};
    virtual CBaseObject* GetParent() { return NULL; };

    virtual bool IsDead();
    virtual void SetDead();

    virtual void AddToDeadObjectPool();

    virtual void Cleanup(){};
    virtual void Animate( double dTimeDelta, int nRenderNumber=0 );
    virtual HRESULT Draw( SceneState * sceneState);
    virtual int PrepareRender(CBaseCamera* pCamera, SceneState * sceneState);

    virtual Matrix4* GetAttachmentMatrix(Matrix4& pOut, int nAttachmentID=0, int nRenderNumber=0);
    
    virtual bool HasAttachmentPoint( int nAttachmentID=0);

    virtual Vector3* GetAttachmentPosition(Vector3& pOut, int nAttachmentID=0, int nRenderNumber=0);
    
    virtual CBipedStateManager*  GetBipedStateManager(bool bCreateOnDemand = true) {return NULL;};

    virtual void SetPhysicsGroup(int nGroup){};

    virtual int GetPhysicsGroup(){return 0;};

    virtual void SetAnimation(int nAnimID){};

    virtual void SetPhysicsGroupMask(DWORD dwValue); 

    virtual DWORD GetPhysicsGroupMask(); 

    virtual int GetAnimation(){return 0;};

    virtual void SetAnimFrame(int nFrame){};

    virtual int GetAnimFrame(){return 0;};

    virtual void EnableAnim(bool bAnimated) {};
    virtual bool IsAnimEnabled()  { return true; };

    virtual void SetUseGlobalTime(bool bUseGlobalTime){};

    virtual bool IsUseGlobalTime(){return false;};

    virtual float GetPhysicsRadius();

    virtual void Reset(){};
    
    virtual DVector3 GetPosition();
    
    virtual void SetPosition(const DVector3 & v);
        
    virtual float GetHeight();
    virtual void SetHeight(float fHeight);

    virtual float GetWidth();
    virtual void SetWidth(float fWidth);

    virtual float GetDepth();
    virtual void SetDepth(float fDepth);
    
    /* return the normal at the terrain position where the object is situated at its x,z plane.*/
    virtual Vector3 GetNormal();
    virtual void SetNormal(const Vector3 & pNorm){};

    virtual void PushParam();

    virtual void PopParam();

    /*virtual void SetScaling(float x, float y, float z){};
    virtual void GetScaling(float& x, float& y, float& z){x=1.f;y=1.f;z=1.f;};*/
    
    virtual AssetEntity* GetPrimaryAsset(){return NULL;};

    virtual const std::string& GetAssetFileName();

    virtual void SetAssetFileName(const std::string& sFilename);

    virtual bool IsStanding(){return true;};

    virtual float GetCtorPercentage(){return 1.0f;}
    virtual void SetCtorPercentage(float fPercentage){}
    
    virtual void AutoSelectTechnique();

    virtual void Report( vector < string > & v_sReport );
    virtual HRESULT ResetTime();

    virtual bool HasAlphaBlendedObjects();

    enum CompressOption{
        ReleaseDevices = 1,
        ReleasePhysics = 2,
        ReleaseEvents = 4
    };
    virtual void CompressObject(CompressOption option = (CompressOption)0xffff);
    
    virtual IViewClippingObject* GetViewClippingObject();

    virtual void UpdateFrameNumber(int nFrameNumber);
    void SetFrameNumber(int nFrameNumber);
    
    int GetFrameNumber();

    bool CheckFrameNumber(int nFrameNumber);

    bool IsLastFrameRendered();

    void SetMyType(ObjectType t);
    ObjectType GetMyType();

    void SnapToTerrainSurface(bool bUseNorm = true);

    virtual ObjectShape GetObjectShape();

    virtual void SetObjectShape(ObjectShape shape);

    CTerrainTile* GetTileContainer();
    virtual void SetTileContainer(CTerrainTile* val);
    virtual void UpdateTileContainer();

    void SetHomeZoneName(const char* sName);
    const char* GetHomeZoneName();

    void SetSelectGroupIndex(int nGroupIndex = -1);

    int GetSelectGroupIndex();

    virtual bool IsTileObject();
    virtual void SetTileObject(bool bIsTileObject);


    inline bool IsGeometryDirty() const { return m_bGeometryDirty; }
    void SetGeometryDirty(bool bDirty = true);

    bool IsLODEnabled() const;
    void EnableLOD(bool val);

    virtual void UpdateGeometry();

    virtual void SetLocalTransform(const Matrix4& mXForm);
    virtual void GetLocalTransform(Matrix4* localTransform);

    virtual int GetMeshTriangleList(std::vector<Vector3>& output, int nOption = 0);

protected:
    int m_nID;

    DWORD                   m_dwAttribute;

    CChildObjectList_Type       m_children;
    
    ObjectType              m_objType;


    // the quad-tree terrain tile that this game object is currently visiting. This may be NULL, if object has not been attached.
    CTerrainTile* m_tileContainer;
    
    int32 m_nTechniqueHandle;
    
    int32 m_nFrameNumber;
    
    int32 m_nSelectGroupIndex;

    int32 m_nRenderImportance;

    float m_fRenderOrder;

    float m_fRenderDistance;

    CParameterBlock* m_pEffectParamBlock;

    bool m_bGeometryDirty : 1;
    bool m_bEnableLOD : 1;
    static int g_nObjectSelectionEffect;
};
}