Go to the documentation of this file.00001
00002
00003
00004
00005 #ifndef __I_SCENE_NODE_H_INCLUDED__
00006 #define __I_SCENE_NODE_H_INCLUDED__
00007
00008 #include "IAttributeExchangingObject.h"
00009 #include "ESceneNodeTypes.h"
00010 #include "ECullingTypes.h"
00011 #include "EDebugSceneTypes.h"
00012 #include "ISceneNodeAnimator.h"
00013 #include "ITriangleSelector.h"
00014 #include "SMaterial.h"
00015 #include "irrString.h"
00016 #include "aabbox3d.h"
00017 #include "matrix4.h"
00018 #include "irrList.h"
00019 #include "IAttributes.h"
00020
00021 namespace irr
00022 {
00023 namespace scene
00024 {
00025 class ISceneManager;
00026
00028 typedef core::list<ISceneNode*> ISceneNodeList;
00030 typedef core::list<ISceneNodeAnimator*> ISceneNodeAnimatorList;
00031
00033
00040 class ISceneNode : virtual public io::IAttributeExchangingObject
00041 {
00042 public:
00043
00045 ISceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id=-1,
00046 const core::vector3df& position = core::vector3df(0,0,0),
00047 const core::vector3df& rotation = core::vector3df(0,0,0),
00048 const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f))
00049 : RelativeTranslation(position), RelativeRotation(rotation), RelativeScale(scale),
00050 Parent(0), SceneManager(mgr), TriangleSelector(0), ID(id),
00051 AutomaticCullingState(EAC_BOX), DebugDataVisible(EDS_OFF),
00052 IsVisible(true), IsDebugObject(false)
00053 {
00054 if (parent)
00055 parent->addChild(this);
00056
00057 updateAbsolutePosition();
00058 }
00059
00060
00062 virtual ~ISceneNode()
00063 {
00064
00065 removeAll();
00066
00067
00068 ISceneNodeAnimatorList::Iterator ait = Animators.begin();
00069 for (; ait != Animators.end(); ++ait)
00070 (*ait)->drop();
00071
00072 if (TriangleSelector)
00073 TriangleSelector->drop();
00074 }
00075
00076
00078
00091 virtual void OnRegisterSceneNode()
00092 {
00093 if (IsVisible)
00094 {
00095 ISceneNodeList::Iterator it = Children.begin();
00096 for (; it != Children.end(); ++it)
00097 (*it)->OnRegisterSceneNode();
00098 }
00099 }
00100
00101
00103
00108 virtual void OnAnimate(u32 timeMs)
00109 {
00110 if (IsVisible)
00111 {
00112
00113
00114 ISceneNodeAnimatorList::Iterator ait = Animators.begin();
00115 while (ait != Animators.end())
00116 {
00117
00118
00119
00120 ISceneNodeAnimator* anim = *ait;
00121 ++ait;
00122 anim->animateNode(this, timeMs);
00123 }
00124
00125
00126 updateAbsolutePosition();
00127
00128
00129
00130 ISceneNodeList::Iterator it = Children.begin();
00131 for (; it != Children.end(); ++it)
00132 (*it)->OnAnimate(timeMs);
00133 }
00134 }
00135
00136
00138 virtual void render() = 0;
00139
00140
00142
00143 virtual const c8* getName() const
00144 {
00145 return Name.c_str();
00146 }
00147
00148
00150
00151 virtual void setName(const c8* name)
00152 {
00153 Name = name;
00154 }
00155
00156
00158
00159 virtual void setName(const core::stringc& name)
00160 {
00161 Name = name;
00162 }
00163
00164
00166
00173 virtual const core::aabbox3d<f32>& getBoundingBox() const = 0;
00174
00175
00177
00178 virtual const core::aabbox3d<f32> getTransformedBoundingBox() const
00179 {
00180 core::aabbox3d<f32> box = getBoundingBox();
00181 AbsoluteTransformation.transformBoxEx(box);
00182 return box;
00183 }
00184
00185
00187
00193 virtual const core::matrix4& getAbsoluteTransformation() const
00194 {
00195 return AbsoluteTransformation;
00196 }
00197
00198
00200
00204 virtual core::matrix4 getRelativeTransformation() const
00205 {
00206 core::matrix4 mat;
00207 mat.setRotationDegrees(RelativeRotation);
00208 mat.setTranslation(RelativeTranslation);
00209
00210 if (RelativeScale != core::vector3df(1.f,1.f,1.f))
00211 {
00212 core::matrix4 smat;
00213 smat.setScale(RelativeScale);
00214 mat *= smat;
00215 }
00216
00217 return mat;
00218 }
00219
00220
00222
00226 virtual bool isVisible() const
00227 {
00228 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00229 return IsVisible;
00230 }
00231
00233
00235 virtual bool isTrulyVisible() const
00236 {
00237 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00238 if(!IsVisible)
00239 return false;
00240
00241 if(!Parent)
00242 return true;
00243
00244 return Parent->isTrulyVisible();
00245 }
00246
00248
00252 virtual void setVisible(bool isVisible)
00253 {
00254 IsVisible = isVisible;
00255 }
00256
00257
00259
00261 virtual s32 getID() const
00262 {
00263 return ID;
00264 }
00265
00266
00268
00270 virtual void setID(s32 id)
00271 {
00272 ID = id;
00273 }
00274
00275
00277
00280 virtual void addChild(ISceneNode* child)
00281 {
00282 if (child && (child != this))
00283 {
00284
00285 if (SceneManager != child->SceneManager)
00286 child->setSceneManager(SceneManager);
00287
00288 child->grab();
00289 child->remove();
00290 Children.push_back(child);
00291 child->Parent = this;
00292 }
00293 }
00294
00295
00297
00302 virtual bool removeChild(ISceneNode* child)
00303 {
00304 ISceneNodeList::Iterator it = Children.begin();
00305 for (; it != Children.end(); ++it)
00306 if ((*it) == child)
00307 {
00308 (*it)->Parent = 0;
00309 (*it)->drop();
00310 Children.erase(it);
00311 return true;
00312 }
00313
00314 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00315 return false;
00316 }
00317
00318
00320
00323 virtual void removeAll()
00324 {
00325 ISceneNodeList::Iterator it = Children.begin();
00326 for (; it != Children.end(); ++it)
00327 {
00328 (*it)->Parent = 0;
00329 (*it)->drop();
00330 }
00331
00332 Children.clear();
00333 }
00334
00335
00337
00339 virtual void remove()
00340 {
00341 if (Parent)
00342 Parent->removeChild(this);
00343 }
00344
00345
00347
00348 virtual void addAnimator(ISceneNodeAnimator* animator)
00349 {
00350 if (animator)
00351 {
00352 Animators.push_back(animator);
00353 animator->grab();
00354 }
00355 }
00356
00357
00359
00360 const core::list<ISceneNodeAnimator*>& getAnimators() const
00361 {
00362 return Animators;
00363 }
00364
00365
00367
00370 virtual void removeAnimator(ISceneNodeAnimator* animator)
00371 {
00372 ISceneNodeAnimatorList::Iterator it = Animators.begin();
00373 for (; it != Animators.end(); ++it)
00374 {
00375 if ((*it) == animator)
00376 {
00377 (*it)->drop();
00378 Animators.erase(it);
00379 return;
00380 }
00381 }
00382 }
00383
00384
00386
00388 virtual void removeAnimators()
00389 {
00390 ISceneNodeAnimatorList::Iterator it = Animators.begin();
00391 for (; it != Animators.end(); ++it)
00392 (*it)->drop();
00393
00394 Animators.clear();
00395 }
00396
00397
00399
00406 virtual video::SMaterial& getMaterial(u32 num)
00407 {
00408 return video::IdentityMaterial;
00409 }
00410
00411
00413
00414 virtual u32 getMaterialCount() const
00415 {
00416 return 0;
00417 }
00418
00419
00421
00425 void setMaterialFlag(video::E_MATERIAL_FLAG flag, bool newvalue)
00426 {
00427 for (u32 i=0; i<getMaterialCount(); ++i)
00428 getMaterial(i).setFlag(flag, newvalue);
00429 }
00430
00431
00433
00436 void setMaterialTexture(u32 textureLayer, video::ITexture* texture)
00437 {
00438 if (textureLayer >= video::MATERIAL_MAX_TEXTURES)
00439 return;
00440
00441 for (u32 i=0; i<getMaterialCount(); ++i)
00442 getMaterial(i).setTexture(textureLayer, texture);
00443 }
00444
00445
00447
00448 void setMaterialType(video::E_MATERIAL_TYPE newType)
00449 {
00450 for (u32 i=0; i<getMaterialCount(); ++i)
00451 getMaterial(i).MaterialType = newType;
00452 }
00453
00454
00456
00460 virtual const core::vector3df& getScale() const
00461 {
00462 return RelativeScale;
00463 }
00464
00465
00467
00468 virtual void setScale(const core::vector3df& scale)
00469 {
00470 RelativeScale = scale;
00471 }
00472
00473
00475
00479 virtual const core::vector3df& getRotation() const
00480 {
00481 return RelativeRotation;
00482 }
00483
00484
00486
00488 virtual void setRotation(const core::vector3df& rotation)
00489 {
00490 RelativeRotation = rotation;
00491 }
00492
00493
00495
00498 virtual const core::vector3df& getPosition() const
00499 {
00500 return RelativeTranslation;
00501 }
00502
00503
00505
00507 virtual void setPosition(const core::vector3df& newpos)
00508 {
00509 RelativeTranslation = newpos;
00510 }
00511
00512
00514
00522 virtual core::vector3df getAbsolutePosition() const
00523 {
00524 return AbsoluteTransformation.getTranslation();
00525 }
00526
00527
00529
00534 void setAutomaticCulling( u32 state)
00535 {
00536 AutomaticCullingState = state;
00537 }
00538
00539
00541
00542 u32 getAutomaticCulling() const
00543 {
00544 return AutomaticCullingState;
00545 }
00546
00547
00549
00552 virtual void setDebugDataVisible(u32 state)
00553 {
00554 DebugDataVisible = state;
00555 }
00556
00558
00560 u32 isDebugDataVisible() const
00561 {
00562 return DebugDataVisible;
00563 }
00564
00565
00567
00569 void setIsDebugObject(bool debugObject)
00570 {
00571 IsDebugObject = debugObject;
00572 }
00573
00574
00576
00579 bool isDebugObject() const
00580 {
00581 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00582 return IsDebugObject;
00583 }
00584
00585
00587
00588 const core::list<ISceneNode*>& getChildren() const
00589 {
00590 return Children;
00591 }
00592
00593
00595
00596 virtual void setParent(ISceneNode* newParent)
00597 {
00598 grab();
00599 remove();
00600
00601 Parent = newParent;
00602
00603 if (Parent)
00604 Parent->addChild(this);
00605
00606 drop();
00607 }
00608
00609
00611
00620 virtual ITriangleSelector* getTriangleSelector() const
00621 {
00622 return TriangleSelector;
00623 }
00624
00625
00627
00635 virtual void setTriangleSelector(ITriangleSelector* selector)
00636 {
00637 if (TriangleSelector != selector)
00638 {
00639 if (TriangleSelector)
00640 TriangleSelector->drop();
00641
00642 TriangleSelector = selector;
00643 if (TriangleSelector)
00644 TriangleSelector->grab();
00645 }
00646 }
00647
00648
00650
00652 virtual void updateAbsolutePosition()
00653 {
00654 if (Parent)
00655 {
00656 AbsoluteTransformation =
00657 Parent->getAbsoluteTransformation() * getRelativeTransformation();
00658 }
00659 else
00660 AbsoluteTransformation = getRelativeTransformation();
00661 }
00662
00663
00665
00666 scene::ISceneNode* getParent() const
00667 {
00668 return Parent;
00669 }
00670
00671
00673
00674 virtual ESCENE_NODE_TYPE getType() const
00675 {
00676 return ESNT_UNKNOWN;
00677 }
00678
00679
00681
00687 virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const
00688 {
00689 if (!out)
00690 return;
00691 out->addString ("Name", Name.c_str());
00692 out->addInt ("Id", ID );
00693
00694 out->addVector3d("Position", getPosition() );
00695 out->addVector3d("Rotation", getRotation() );
00696 out->addVector3d("Scale", getScale() );
00697
00698 out->addBool ("Visible", IsVisible );
00699 out->addInt ("AutomaticCulling", AutomaticCullingState);
00700 out->addInt ("DebugDataVisible", DebugDataVisible );
00701 out->addBool ("IsDebugObject", IsDebugObject );
00702 }
00703
00704
00706
00712 virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0)
00713 {
00714 if (!in)
00715 return;
00716 Name = in->getAttributeAsString("Name");
00717 ID = in->getAttributeAsInt("Id");
00718
00719 setPosition(in->getAttributeAsVector3d("Position"));
00720 setRotation(in->getAttributeAsVector3d("Rotation"));
00721 setScale(in->getAttributeAsVector3d("Scale"));
00722
00723 IsVisible = in->getAttributeAsBool("Visible");
00724 s32 tmpState = in->getAttributeAsEnumeration("AutomaticCulling",
00725 scene::AutomaticCullingNames);
00726 if (tmpState != -1)
00727 AutomaticCullingState = (u32)tmpState;
00728 else
00729 AutomaticCullingState = in->getAttributeAsInt("AutomaticCulling");
00730
00731 DebugDataVisible = in->getAttributeAsInt("DebugDataVisible");
00732 IsDebugObject = in->getAttributeAsBool("IsDebugObject");
00733
00734 updateAbsolutePosition();
00735 }
00736
00738
00741 virtual ISceneNode* clone(ISceneNode* newParent=0, ISceneManager* newManager=0)
00742 {
00743 return 0;
00744 }
00745
00747
00748 virtual ISceneManager* getSceneManager(void) const { return SceneManager; }
00749
00750 protected:
00751
00753
00757 void cloneMembers(ISceneNode* toCopyFrom, ISceneManager* newManager)
00758 {
00759 Name = toCopyFrom->Name;
00760 AbsoluteTransformation = toCopyFrom->AbsoluteTransformation;
00761 RelativeTranslation = toCopyFrom->RelativeTranslation;
00762 RelativeRotation = toCopyFrom->RelativeRotation;
00763 RelativeScale = toCopyFrom->RelativeScale;
00764 ID = toCopyFrom->ID;
00765 setTriangleSelector(toCopyFrom->TriangleSelector);
00766 AutomaticCullingState = toCopyFrom->AutomaticCullingState;
00767 DebugDataVisible = toCopyFrom->DebugDataVisible;
00768 IsVisible = toCopyFrom->IsVisible;
00769 IsDebugObject = toCopyFrom->IsDebugObject;
00770
00771 if (newManager)
00772 SceneManager = newManager;
00773 else
00774 SceneManager = toCopyFrom->SceneManager;
00775
00776
00777
00778 ISceneNodeList::Iterator it = toCopyFrom->Children.begin();
00779 for (; it != toCopyFrom->Children.end(); ++it)
00780 (*it)->clone(this, newManager);
00781
00782
00783
00784 ISceneNodeAnimatorList::Iterator ait = toCopyFrom->Animators.begin();
00785 for (; ait != toCopyFrom->Animators.end(); ++ait)
00786 {
00787 ISceneNodeAnimator* anim = (*ait)->createClone(this, SceneManager);
00788 if (anim)
00789 {
00790 addAnimator(anim);
00791 anim->drop();
00792 }
00793 }
00794 }
00795
00798 void setSceneManager(ISceneManager* newManager)
00799 {
00800 SceneManager = newManager;
00801
00802 ISceneNodeList::Iterator it = Children.begin();
00803 for (; it != Children.end(); ++it)
00804 (*it)->setSceneManager(newManager);
00805 }
00806
00808 core::stringc Name;
00809
00811 core::matrix4 AbsoluteTransformation;
00812
00814 core::vector3df RelativeTranslation;
00815
00817 core::vector3df RelativeRotation;
00818
00820 core::vector3df RelativeScale;
00821
00823 ISceneNode* Parent;
00824
00826 core::list<ISceneNode*> Children;
00827
00829 core::list<ISceneNodeAnimator*> Animators;
00830
00832 ISceneManager* SceneManager;
00833
00835 ITriangleSelector* TriangleSelector;
00836
00838 s32 ID;
00839
00841 u32 AutomaticCullingState;
00842
00844 u32 DebugDataVisible;
00845
00847 bool IsVisible;
00848
00850 bool IsDebugObject;
00851 };
00852
00853
00854 }
00855 }
00856
00857 #endif
00858