908 lines
25 KiB
C++
908 lines
25 KiB
C++
/****************************************************************************
|
|
Copyright (c) 2002, Radon Labs GmbH
|
|
Copyright (c) 2011-2013,WebJet Business Division,CYOU
|
|
|
|
http://www.genesis-3d.com.cn
|
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
of this software and associated documentation files (the "Software"), to deal
|
|
in the Software without restriction, including without limitation the rights
|
|
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
copies of the Software, and to permit persons to whom the Software is
|
|
furnished to do so, subject to the following conditions:
|
|
|
|
The above copyright notice and this permission notice shall be included in
|
|
all copies or substantial portions of the Software.
|
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
THE SOFTWARE.
|
|
****************************************************************************/
|
|
#ifndef __actor_H__
|
|
#define __actor_H__
|
|
|
|
#include "app/appframework/app_fwd_decl.h"
|
|
#include "core/refcounted.h"
|
|
#include "core/ptr.h"
|
|
#include "foundation/messaging/message.h"
|
|
#include "messaging/dispatcher.h"
|
|
#include "app/appframework/component.h"
|
|
#include "util/dictionary.h"
|
|
#include "util/guid.h"
|
|
#include "debug/debugtimer.h"
|
|
#include "app/appframework/serialization.h"
|
|
#include "math/matrix44.h"
|
|
#include "math/vector.h"
|
|
#include "math/quaternion.h"
|
|
#include "math/bbox.h"
|
|
#ifndef __SCRIPT_COMMIT__
|
|
#include "foundation/util/scriptbind.h"
|
|
#include "app/scriptfeature/inc/script_message.h"
|
|
#include "app/scriptfeature/inc/script_utility.h"
|
|
#endif
|
|
#include "addons/resource/resourcemanager.h"
|
|
#include "addons/resource/resourcepriority.h"
|
|
#include "addons/resource/templateresloader.h"
|
|
#include "addons/resource/templateressaver.h"
|
|
|
|
//------------------------------------------------------------------------------
|
|
namespace Graphic
|
|
{
|
|
class RenderScene;
|
|
}
|
|
|
|
namespace App
|
|
{
|
|
class Actor;
|
|
class ActorManager;
|
|
class ScriptComponent;
|
|
class RenderComponent;
|
|
class PhysicsEntity;
|
|
class SkinnedMeshRenderComponent;
|
|
class SkeletonComponent;
|
|
class AnimationComponent;
|
|
|
|
enum SysLayerID
|
|
{
|
|
eSL_Defualt = 0,//RenderLayer::eRLDefault
|
|
eSL_Debug = 31,//RenderLayer::eRLDebug
|
|
};
|
|
|
|
|
|
|
|
typedef uint LayerID;
|
|
|
|
typedef uint TagID;
|
|
|
|
class ActorSerializationArgs : public Serialization::SerializationArgs
|
|
{
|
|
public:
|
|
inline ActorSerializationArgs(Actor* parent)
|
|
{
|
|
this->parent = parent;
|
|
}
|
|
Actor* parent;
|
|
};
|
|
|
|
// Modified From Nebula3's Entity(Actor) and Property(Component). MayBe It's Good for Radon Labs.
|
|
// But I think It's too Difficult to Understand Nebula3's Design for Newer. For Example: Property in DB Storage , So Many Thread, So Many Details Hidden in Addon...
|
|
// Actor: Manage RelationShip And Component. TODO: Add TinyActor For Object With No Game Logic.
|
|
// Addons: I Hope There are only Libs Which Can Be Replace By Other Libs Or ReUse By Other Engine. Idealism, But Can Be More Easier.
|
|
// Component: First: Make Addons-Lib's Function Corresponded With Actor-Component Model
|
|
// Second: Corresponded With Other Components With Message.
|
|
class Actor : public Core::RefCounted, App::ISerialization
|
|
{
|
|
__DeclareClass(Actor);
|
|
__ScriptBind
|
|
public:
|
|
/// an Id type, used to identify entities
|
|
typedef unsigned int FastId;
|
|
|
|
const static GPtr<Actor> NullActor;
|
|
|
|
/// destructor. but use Actor::destory
|
|
virtual ~Actor();
|
|
|
|
virtual Graphic::RenderScene* GetRenderScene() const;
|
|
|
|
//--------------------------------basic----------------------------------------
|
|
void SetName(const Util::String& name);
|
|
|
|
const Util::String& GetName(void) const;
|
|
|
|
/// get the Actor's category
|
|
const Util::StringAtom& GetTemplateName() const;
|
|
// store activeState for templatedActors
|
|
void SetTmpActiveState(bool tmpActiveState);
|
|
// get activeState for templatedActors
|
|
bool GetTmpActiveState();
|
|
// set activeState for templatedActors
|
|
void SetActiveStateForTemplate();
|
|
|
|
bool IsLinkTemplate(void) const;
|
|
|
|
void SetLinkTemplate(bool bLink);
|
|
|
|
LayerID GetLayerID(void) const;
|
|
|
|
void SetLayerID(LayerID id);
|
|
|
|
uint GetCullMark() const;
|
|
|
|
TagID GetTagID(void) const;
|
|
|
|
void SetTagID(TagID);
|
|
|
|
/// get unique id of Actor
|
|
FastId GetFastId() const;
|
|
|
|
/// if the actor is active
|
|
bool IsActive() const;//bool checkParent = true
|
|
|
|
/// if the actor is active
|
|
bool IsDestory() const;
|
|
|
|
// active the actor and it's component. add in active actor list in ActorManger
|
|
// if includeChild is true, all child actor will be active too
|
|
void Active(bool forceActiveControlofChild = false);
|
|
|
|
// Deactive the actor and it's component. remove from active actor list in ActorManger
|
|
// if includeChild is true, all child actor will be deactive
|
|
void Deactive(bool forceActiveControlofChild = false);
|
|
|
|
bool GetActiveControl() const;
|
|
|
|
/// actor's it's component and all child actor
|
|
/// obsolete fuction. the same as Deactive(true).
|
|
void Destory(bool forceChild = false);
|
|
|
|
//--------------------------------Parent----------------------------------------
|
|
// return parent. May be Null
|
|
Actor* GetParent(void) const;
|
|
|
|
// set parent. will remove from old parent
|
|
void SetParent( Actor* parent );
|
|
|
|
void SetParent( const GPtr<Actor>& parent );
|
|
|
|
// return child count. May be 0
|
|
SizeT GetChildCount(void) const;
|
|
|
|
// return child by index
|
|
const GPtr<Actor>& GetChild(IndexT i) const;
|
|
|
|
// find actor by FastID
|
|
const GPtr<Actor>& FindChild(FastId id) const;
|
|
|
|
const GPtr<Actor>& FindChildByTag(App::TagID id) const;
|
|
|
|
void FindChildrenByTag(const App::TagID tagID,Util::Array< GPtr<Actor> >& actors) const;
|
|
|
|
const GPtr<Actor>& FindChild(const Util::Guid& guid) const;
|
|
|
|
const GPtr<Actor>& FindChild(const Util::String& name) const;
|
|
|
|
// find child actor index in child list
|
|
IndexT FindChildIndex(FastId id) const;
|
|
|
|
// add child. If childActor Has Parent, Failed, Need Remove Form Other Parent First. Please Use SetParent
|
|
void AddChild(GPtr<Actor>& childActor );
|
|
|
|
// Remove Child By Ptr or Index. if Null or Not Exist, Failed. After Removed, the Index of other Child Actor May Change
|
|
void RemoveChild( const GPtr<Actor>& childActor );
|
|
void RemoveChild( IndexT i );
|
|
|
|
// remove all child
|
|
void RemoveAllChild(void);
|
|
|
|
//----------------------------Transform ----------------------------------------
|
|
|
|
void SetPosition(const Math::vector& pos);
|
|
|
|
void SetRotation(const Math::quaternion& rot);
|
|
|
|
void SetScale(const Math::vector& scale);
|
|
|
|
const Math::vector& GetPosition(void) const;
|
|
|
|
const Math::quaternion& GetRotation(void) const;
|
|
|
|
const Math::vector& GetScale(void) const;
|
|
|
|
|
|
|
|
/** move around z axis(radian).
|
|
*/
|
|
void Roll(Math::scalar angle );
|
|
|
|
/** move around x axis(radian).
|
|
*/
|
|
void Pitch(Math::scalar angle );
|
|
|
|
/** move around y axis(radian).
|
|
*/
|
|
void Yaw(Math::scalar angle );
|
|
|
|
// roll first, then pitch, then yaw.radian.
|
|
void Rotate(Math::scalar roll , Math::scalar pitch , Math::scalar yaw );
|
|
|
|
void SetTransform(const Math::vector& pos, const Math::quaternion& rot, const Math::vector& scale);
|
|
|
|
void SetTransform( const Math::matrix44& m );
|
|
|
|
void SetWorldTransform( const Math::matrix44& m );
|
|
|
|
const Math::matrix44& GetTransform(void) const;
|
|
|
|
const Util::Guid& GetGUID() const;
|
|
|
|
void SetWorldPosition(const Math::vector& pos);
|
|
|
|
void SetWorldRotation(const Math::quaternion& rot);
|
|
|
|
void SetWorldScale(const Math::vector& scale);
|
|
|
|
const Math::quaternion& GetWorldRotation(void) const;
|
|
|
|
const Math::vector& GetWorldPosition(void) const;
|
|
|
|
const Math::vector& GetWorldScale(void) const;
|
|
|
|
const Math::matrix44& GetWorldTransform(void) const;
|
|
|
|
const Math::matrix44 GetWorldTranslateRotation(void) const;
|
|
|
|
// remove the scales of all parent actors
|
|
const Math::matrix44 GetWorldTranslateNoScale(void) const;
|
|
const Math::quaternion GetWorldRotationNoScale(void) const;
|
|
|
|
//-------------------------------boundingbox-----------------------------------------
|
|
|
|
// get world boundingbox. Just The Actor, No child actor
|
|
const Math::bbox& GetWorldBoundingBox(void) const;
|
|
|
|
// get world boundingbox. Include the Actor and it's child actor. Slow !!!!!!!
|
|
Math::bbox GetWorldBoundingBoxWithChild(void) const;
|
|
|
|
// get local boundingbox. default is [-0.5,-0.5,-0.5]~[0.5,0.5,0.5]
|
|
const Math::bbox& GetLocalBoundingBox(void) const;
|
|
|
|
// set Local boundingbox.
|
|
void SetLocalBoundingBox(const Math::bbox& bb);
|
|
|
|
//-------------------------------component-----------------------------------------
|
|
|
|
/// return true if any Component accepts/processes message
|
|
bool AcceptsMessage(const Messaging::Id& msgId) const;
|
|
|
|
/// send a synchronous message to the Actor
|
|
void SendSync(const GPtr<Messaging::Message>& msg);
|
|
|
|
/// throw a message to the script
|
|
template<typename T>
|
|
void ThrowMessageToScript(const Util::String& name,T& pair);
|
|
|
|
/// find Component by RTTI (performs IsA() check), returns invalid pointer if not exists, slow!
|
|
const GPtr<Component>& FindComponent(const Core::Rtti& rtti) const;
|
|
|
|
template<typename T>
|
|
GPtr<T> FindComponent() const;
|
|
|
|
/// find Component by RTTI (perform RTTI's operator == check),returns invalid pointer if not exists,
|
|
/// now only used in script sys to get the exactly component in order to show correct debug imformation.
|
|
const GPtr<Component>& FindComponentExactly(const Core::Rtti& rtti) const;
|
|
|
|
/// find Components by RTTI (performs IsA() check), returns empty size if not exists, slow!
|
|
const Util::Array< GPtr<Component> > FindComponents(const Core::Rtti& rtti) const;
|
|
|
|
/// attach a Component to the Actor
|
|
void AttachComponent(const GPtr<Component>& prop);
|
|
|
|
/// remove a Component from the Actor
|
|
void RemoveComponent(const GPtr<Component>& prop);
|
|
|
|
/// destroy a Component from the Actor
|
|
void DestroyComponent(const GPtr<Component>& prop);
|
|
|
|
const bool IsAllResourcePrepared() const;
|
|
|
|
void SaveTerrainFile(void) const;
|
|
|
|
//----------------------------- callbacks -------------------------------------------
|
|
|
|
/// register a Component callback, called by ComponentSetupCallback() method
|
|
void RegisterComponentCallback(const GPtr<Component>& prop, Component::CallbackType callback);
|
|
|
|
/// called at the beginning of the frame
|
|
void OnBeginFrame();
|
|
|
|
/// called before movement
|
|
void OnMoveBefore();
|
|
|
|
/// called after movement
|
|
void OnMoveAfter();
|
|
|
|
/// called before rendering
|
|
void OnFrame();
|
|
|
|
/// called at the ending of the frame
|
|
void OnEndFrame();
|
|
|
|
/// debug rendering called before rendering
|
|
void OnRenderDebug();
|
|
|
|
//----------------------------------ISerialization--------------------------------------
|
|
|
|
// @ISerialization::GetVersion. when change storage, must add SerializeVersion count
|
|
virtual Version GetVersion() const ;
|
|
|
|
// @ISerialization::Load
|
|
virtual void Load( Version ver, AppReader* pReader, const Serialization::SerializationArgs* args ) ;
|
|
|
|
// @ISerialization::Save
|
|
virtual void Save( AppWriter* pWriter ) const ;
|
|
|
|
// copy from source Actor. after copy, all old components and the child actor in this actor will destroy
|
|
// if includeSelfProperty is false, only the components and child actor will copy
|
|
// if includePrivateProperty is true, the actor's property( like transform, layerID,...) , components and child actor will copy
|
|
// if needRecurVFL is false, the actor's visible,frozen,lock states will affect its children.
|
|
// after copy, the actor is deactive. should manu active if need
|
|
virtual void CopyFrom( const GPtr<Actor>& pSource, bool includePrivateProperty , bool isTemplate = false , bool needRecurVFL = true);
|
|
|
|
//virtual void CopyFromTemplateRes(Resources::ResourceId resID);'
|
|
|
|
//resource loading priority: if -1,use component's setup
|
|
void SetPriority( const Resources::Priority priority );
|
|
|
|
Resources::Priority GetPriority() const;
|
|
|
|
bool PriorityDefinition() const;
|
|
|
|
bool PriorityUndefinition() const;
|
|
//----------------------------------- between components -----------------------------
|
|
#ifndef __SCRIPT_COMMIT__
|
|
void Check_OnRenderPostEffect_Bind();
|
|
void Check_OnRenderPostEffect_Unbind();
|
|
|
|
void Check_OnWillRenderObject_Bind();
|
|
void Check_OnWillRenderObject_Unbind();
|
|
#endif
|
|
static void Check_Skeleton(SkeletonComponent* skeleton);
|
|
static void Check_Animation(AnimationComponent* animation);
|
|
static void Check_Skin(SkinnedMeshRenderComponent* skin);
|
|
|
|
void OpenComponentsCommSign(ComponetsCommSign sign);
|
|
void CloseComponentsCommSign(ComponetsCommSign sign);
|
|
bool IsComponentsCommSignOpen(ComponetsCommSign sign);
|
|
|
|
void _UpdateLocalBBox();
|
|
protected:
|
|
typedef Util::Array<TActorPtr> Children;
|
|
// recompute world transform if need
|
|
void _UpdateWolrdTransform() const;
|
|
void _UpdateLocalTransform() const;
|
|
|
|
|
|
void _CheckActive();
|
|
|
|
void _CheckDeactive();
|
|
|
|
void _Active(bool forceActiveControlofChild = false);
|
|
|
|
void _Deactive(bool forceActiveControlofChild = false);
|
|
|
|
void _OnRenderSceneChanged();
|
|
|
|
void _OnActorParentChanged();
|
|
|
|
/// set Actor category
|
|
void SetTemplateName(const Util::StringAtom& tepName);
|
|
|
|
/// cleanup the Actor Components, called from OnDeactivate()
|
|
void _CleanupAllComponents();
|
|
|
|
/// call OnActivate() on all Components
|
|
void _ActivateAllComponents();
|
|
|
|
/// call OnDeactivate() on all Components
|
|
void _DeactivateAllComponents();
|
|
|
|
void _ActiveComponent( const GPtr<Component>& pComponent );
|
|
|
|
void _DeactiveComponent( const GPtr<Component>& pComponent );
|
|
|
|
void _SetParentImpl(Actor* p);
|
|
|
|
void _DirtyWorldTransform();
|
|
|
|
/// called when attached to world. Just called by ActorManger
|
|
void OnActivate();
|
|
|
|
/// called when removed from world. Just called by ActorManger
|
|
void OnDeactivate();
|
|
|
|
#ifdef __GENESIS_EDITOR__
|
|
public:
|
|
void SetQueryMask(uint mask);
|
|
uint GetQueryMask() const;
|
|
|
|
const Math::vector& GetEulerRotation() const;
|
|
void SetEulerRotation(const Math::vector & rot);
|
|
|
|
void SetFrozen( bool bFrozen , bool needRecursive = true );
|
|
void SetLocked( bool bLocked , bool needRecursive = true );
|
|
bool GetFrozen() { return mFrozen; }
|
|
bool GetLocked() { return mLocked; }
|
|
//only called after copy,pSource is the actor used for copyfrom source
|
|
void SetLockedActorTransformRecursive(const GPtr<App::Actor>& pSource);
|
|
|
|
protected:
|
|
void SetLockedActorLocalTransform( const Actor *parent );
|
|
|
|
Math::vector mEulerAngle;
|
|
uint mQueryMask;
|
|
|
|
bool mFrozen;
|
|
bool mLocked;
|
|
#endif
|
|
public:
|
|
enum EditorFlag
|
|
{
|
|
RenderLightMap = 1,
|
|
};
|
|
void SetEditorFlag(EditorFlag flags);
|
|
EditorFlag GetEditorFlag() const;
|
|
bool CheckEditorFlag (EditorFlag flags);
|
|
|
|
void SetVisible( bool bVisible , bool needRecursive = true);
|
|
bool GetVisible() const;
|
|
|
|
//return true if this actor is a child of one actor that has a animation component
|
|
bool IsChildOfAnimationActor();
|
|
|
|
protected:// date
|
|
uint mEditorFlag;
|
|
|
|
FastId mFastId;
|
|
static FastId s_fastIdCounter;
|
|
|
|
Util::Guid mGuid;
|
|
|
|
Util::String mName;
|
|
bool mActivated;
|
|
//when true, actor will be actived when it is parent is been actived.
|
|
bool mActiveControl;
|
|
|
|
bool mTmpActiveState;
|
|
|
|
Util::StringAtom mTemplateName;
|
|
bool mIsLinkTemplate;
|
|
|
|
LayerID mLayerID;
|
|
TagID mTagID;
|
|
//flag config of components.
|
|
//used for bit flag.see, enum ComponetsCommSign
|
|
TagID mComponentsCommSign;
|
|
|
|
//local transform and bound
|
|
Math::quaternion mLocalRotation;
|
|
Math::vector mLocalPosition;
|
|
Math::vector mLocalScale;
|
|
|
|
Math::bbox mLocalBB;
|
|
|
|
// cache transform and bound
|
|
mutable Math::matrix44 mLocaTrans;
|
|
mutable bool mDirtyLocaTrans;
|
|
|
|
|
|
mutable Math::quaternion mWorldRotation;
|
|
mutable Math::vector mWorldPosition;
|
|
mutable Math::vector mWorldScale;
|
|
mutable Math::matrix44 mWorldTrans;
|
|
mutable bool mDirtyWorldTrans;
|
|
|
|
mutable Math::bbox mWorldBB;
|
|
mutable bool mDirtyWorldBB;
|
|
|
|
GPtr<Messaging::Dispatcher> mDispatcher;
|
|
Util::Array<GPtr<Component> > mComponents;
|
|
Util::FixedArray<Util::Array<GPtr<Component> > > mCallbackComponents;
|
|
|
|
Actor* mParent;
|
|
Children mChildren;
|
|
|
|
bool mVisible;
|
|
Resources::Priority mPriority;
|
|
|
|
//GPtr<Resources::TemplateResInfo> mTemplateResInfo;
|
|
|
|
friend class ActorManager;
|
|
friend class ActorSerialization;
|
|
friend class Scene;
|
|
|
|
#if NEBULA3_ENABLE_PROFILING
|
|
Util::Dictionary<Util::String, GPtr<Debug::DebugTimer> > mComponentActivateDebugTimer;
|
|
Util::Dictionary<Util::String, GPtr<Debug::DebugTimer> > mComponentDeactivateDebugTimer;
|
|
Util::Dictionary<Util::String, GPtr<Debug::DebugTimer> > mComponentOnBeginFrameDebugTimer;
|
|
Util::Dictionary<Util::String, GPtr<Debug::DebugTimer> > mComponentOnMoveBeforeDebugTimer;
|
|
Util::Dictionary<Util::String, GPtr<Debug::DebugTimer> > mComponentOnMoveAfterDebugTimer;
|
|
Util::Dictionary<Util::String, GPtr<Debug::DebugTimer> > mComponentOnRenderDebugTimer;
|
|
|
|
void _AttachComponentTimer( const Core::Rtti* pRtti );
|
|
void _RemoveComponentTimer( const Core::Rtti* pRtti );
|
|
void _ResetComponentTimer();
|
|
#endif
|
|
|
|
/// constructor. but use Actor::Create()
|
|
Actor();
|
|
private:
|
|
|
|
|
|
//internal call.
|
|
/// actor's it's component and all child actor.
|
|
void _Destory(bool forceShutDown = false);
|
|
|
|
};
|
|
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
void
|
|
Actor::SetName(const Util::String& name)
|
|
{
|
|
mName = name;
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
const Util::String&
|
|
Actor::GetName(void) const
|
|
{
|
|
return mName;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Actor::SetTemplateName(const Util::StringAtom& tepName)
|
|
{
|
|
if (tepName.IsValid())
|
|
{
|
|
Util::String str = tepName.AsString();
|
|
str.ToLower();
|
|
if (str == "empty")
|
|
{
|
|
this->mTemplateName = "";
|
|
return;
|
|
}
|
|
}
|
|
|
|
this->mTemplateName = tepName;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline const Util::StringAtom&
|
|
Actor::GetTemplateName() const
|
|
{
|
|
return this->mTemplateName;
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
bool
|
|
Actor::IsLinkTemplate(void) const
|
|
{
|
|
return mIsLinkTemplate;
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
void
|
|
Actor::SetLinkTemplate(bool bLink)
|
|
{
|
|
mIsLinkTemplate = bLink;
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
LayerID
|
|
Actor::GetLayerID(void) const
|
|
{
|
|
return mLayerID;
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
uint
|
|
Actor::GetCullMark(void) const
|
|
{
|
|
return 1 << mLayerID;
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
TagID
|
|
Actor::GetTagID(void) const
|
|
{
|
|
return mTagID;
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
void
|
|
Actor::SetTagID(TagID id)
|
|
{
|
|
mTagID = id;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Actor::IsActive() const//bool checkParent/* = true*/
|
|
{
|
|
return mActivated;
|
|
//if (checkParent)
|
|
//{
|
|
// return mActivated && IsParentActive(true);
|
|
//}
|
|
//else
|
|
//{
|
|
// return mActivated;
|
|
//}
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
inline bool
|
|
Actor::GetActiveControl() const
|
|
{
|
|
return mActiveControl;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
inline void
|
|
Actor::SetTmpActiveState(bool tmpActiveState)
|
|
{
|
|
mTmpActiveState = tmpActiveState;
|
|
}
|
|
|
|
inline bool
|
|
Actor::GetTmpActiveState()
|
|
{
|
|
return mTmpActiveState;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline uint
|
|
Actor::GetFastId() const
|
|
{
|
|
return this->mFastId;
|
|
}
|
|
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
const Math::vector&
|
|
Actor::GetPosition() const
|
|
{
|
|
return this->mLocalPosition;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
const Util::Guid&
|
|
Actor::GetGUID() const
|
|
{
|
|
return this->mGuid;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
const Math::quaternion&
|
|
Actor::GetRotation() const
|
|
{
|
|
return this->mLocalRotation;
|
|
}
|
|
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline
|
|
const Math::vector&
|
|
Actor::GetScale() const
|
|
{
|
|
return this->mLocalScale;
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline bool
|
|
Actor::AcceptsMessage(const Messaging::Id& msgId) const
|
|
{
|
|
return this->mDispatcher->AcceptsMessage(msgId);
|
|
}
|
|
//------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
inline void
|
|
Actor::SendSync(const GPtr<Messaging::Message>& msg)
|
|
{
|
|
this->mDispatcher->HandleMessage(msg);
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
const Math::bbox&
|
|
Actor::GetLocalBoundingBox(void) const
|
|
{
|
|
return mLocalBB;
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
Actor*
|
|
Actor::GetParent(void) const
|
|
{
|
|
return mParent;
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
SizeT
|
|
Actor::GetChildCount(void) const
|
|
{
|
|
return mChildren.Size();
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
void
|
|
Actor::Roll(Math::scalar angle )
|
|
{
|
|
Rotate(angle, 0, 0);
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
void
|
|
Actor::Pitch(Math::scalar angle )
|
|
{
|
|
Rotate(0, angle, 0);
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
void
|
|
Actor::Yaw(Math::scalar angle )
|
|
{
|
|
Rotate(0, 0, angle);
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
void
|
|
Actor::Rotate(Math::scalar roll , Math::scalar pitch , Math::scalar yaw )
|
|
{
|
|
Math::quaternion q = Math::quaternion::rotationyawpitchroll(yaw, pitch, roll);
|
|
SetRotation(q);
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
void
|
|
Actor::OpenComponentsCommSign(ComponetsCommSign sign)
|
|
{
|
|
mComponentsCommSign |= sign;
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
void
|
|
Actor::CloseComponentsCommSign(ComponetsCommSign sign)
|
|
{
|
|
mComponentsCommSign &= (~sign);
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
bool
|
|
Actor::IsComponentsCommSignOpen(ComponetsCommSign sign)
|
|
{
|
|
return (mComponentsCommSign & sign) != 0;
|
|
}
|
|
//------------------------------------------------------------------------
|
|
#ifdef __GENESIS_EDITOR__
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
void
|
|
Actor::SetQueryMask(uint mask)
|
|
{
|
|
if (mask > 31 || mask < 0)
|
|
{
|
|
n_assert(0);
|
|
return;
|
|
}
|
|
mQueryMask = mask;
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
uint
|
|
Actor::GetQueryMask() const
|
|
{
|
|
return mQueryMask;
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
const Math::vector&
|
|
Actor::GetEulerRotation() const
|
|
{
|
|
return mEulerAngle;
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline
|
|
void
|
|
Actor::SetEulerRotation(const Math::vector & rot)
|
|
{
|
|
mEulerAngle = rot;
|
|
}
|
|
//------------------------------------------------------------------------
|
|
#endif
|
|
|
|
inline bool
|
|
Actor::CheckEditorFlag (EditorFlag flags)
|
|
{
|
|
return (mEditorFlag & (uint)flags) != 0;
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline App::Actor::EditorFlag Actor::GetEditorFlag () const
|
|
{
|
|
return (EditorFlag)mEditorFlag;
|
|
}
|
|
//------------------------------------------------------------------------
|
|
inline void Actor::SetEditorFlag (EditorFlag flags)
|
|
{
|
|
mEditorFlag = (uint)flags;
|
|
}
|
|
|
|
inline Resources::Priority Actor::GetPriority() const
|
|
{
|
|
return mPriority;
|
|
}
|
|
|
|
inline bool Actor::PriorityDefinition() const
|
|
{
|
|
return (Resources::ResourcePriority::Undefinition != mPriority);
|
|
}
|
|
|
|
inline bool Actor::PriorityUndefinition() const
|
|
{
|
|
return (Resources::ResourcePriority::Undefinition == mPriority);
|
|
}
|
|
|
|
template<typename T>
|
|
GPtr<T> Actor::FindComponent() const
|
|
{
|
|
const GPtr<Component>& obj = this->FindComponent( T::RTTI );
|
|
if ( obj )
|
|
{
|
|
return obj.downcast<T>();
|
|
}
|
|
else
|
|
{
|
|
return GPtr<T>(0);
|
|
}
|
|
}
|
|
#ifndef __SCRIPT_COMMIT__
|
|
//-------------------------------------------------------------------------
|
|
template<typename T>
|
|
void Actor::ThrowMessageToScript( const Util::String& name,T& pair )
|
|
{
|
|
TScriptMessagePtr msg = ScriptMessageCreator::Instance()->CreateMessage(name,pair);
|
|
SendSync( msg.upcast<Messaging::Message>() );
|
|
}
|
|
#endif
|
|
|
|
} // namespace Game
|
|
//------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
|
|
|
|
#endif // __actor_H__
|
|
|