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
00035 class ISceneNode : virtual public io::IAttributeExchangingObject
00036 {
00037 public:
00038
00040 ISceneNode(ISceneNode* parent, ISceneManager* mgr, s32 id=-1,
00041 const core::vector3df& position = core::vector3df(0,0,0),
00042 const core::vector3df& rotation = core::vector3df(0,0,0),
00043 const core::vector3df& scale = core::vector3df(1.0f, 1.0f, 1.0f))
00044 : RelativeTranslation(position), RelativeRotation(rotation), RelativeScale(scale),
00045 Parent(0), SceneManager(mgr), TriangleSelector(0), ID(id),
00046 AutomaticCullingState(EAC_BOX), DebugDataVisible(EDS_OFF),
00047 IsVisible(true), IsDebugObject(false)
00048 {
00049 if (parent)
00050 parent->addChild(this);
00051
00052 updateAbsolutePosition();
00053 }
00054
00055
00057 virtual ~ISceneNode()
00058 {
00059
00060 removeAll();
00061
00062
00063 core::list<ISceneNodeAnimator*>::Iterator ait = Animators.begin();
00064 for (; ait != Animators.end(); ++ait)
00065 (*ait)->drop();
00066
00067 if (TriangleSelector)
00068 TriangleSelector->drop();
00069 }
00070
00071
00073
00086 virtual void OnRegisterSceneNode()
00087 {
00088 if (IsVisible)
00089 {
00090 core::list<ISceneNode*>::Iterator it = Children.begin();
00091 for (; it != Children.end(); ++it)
00092 (*it)->OnRegisterSceneNode();
00093 }
00094 }
00095
00096
00098
00103 virtual void OnAnimate(u32 timeMs)
00104 {
00105 if (IsVisible)
00106 {
00107
00108
00109 core::list<ISceneNodeAnimator*>::Iterator ait = Animators.begin();
00110 while (ait != Animators.end())
00111 {
00112
00113
00114
00115 ISceneNodeAnimator* anim = *ait;
00116 ++ait;
00117 anim->animateNode(this, timeMs);
00118 }
00119
00120
00121 updateAbsolutePosition();
00122
00123
00124
00125 core::list<ISceneNode*>::Iterator it = Children.begin();
00126 for (; it != Children.end(); ++it)
00127 (*it)->OnAnimate(timeMs);
00128 }
00129 }
00130
00131
00133 virtual void render() = 0;
00134
00135
00137
00138 virtual const c8* getName() const
00139 {
00140 return Name.c_str();
00141 }
00142
00143
00145
00146 virtual void setName(const c8* name)
00147 {
00148 Name = name;
00149 }
00150
00151
00153
00154 virtual void setName(const core::stringc& name)
00155 {
00156 Name = name;
00157 }
00158
00159
00161
00168 virtual const core::aabbox3d<f32>& getBoundingBox() const = 0;
00169
00170
00172
00173 virtual const core::aabbox3d<f32> getTransformedBoundingBox() const
00174 {
00175 core::aabbox3d<f32> box = getBoundingBox();
00176 AbsoluteTransformation.transformBoxEx(box);
00177 return box;
00178 }
00179
00180
00183 virtual const core::matrix4& getAbsoluteTransformation() const
00184 {
00185 return AbsoluteTransformation;
00186 }
00187
00188
00190
00194 virtual core::matrix4 getRelativeTransformation() const
00195 {
00196 core::matrix4 mat;
00197 mat.setRotationDegrees(RelativeRotation);
00198 mat.setTranslation(RelativeTranslation);
00199
00200 if (RelativeScale != core::vector3df(1.f,1.f,1.f))
00201 {
00202 core::matrix4 smat;
00203 smat.setScale(RelativeScale);
00204 mat *= smat;
00205 }
00206
00207 return mat;
00208 }
00209
00210
00212
00216 virtual bool isVisible() const
00217 {
00218 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00219 return IsVisible;
00220 }
00221
00223
00225 virtual bool isTrulyVisible() const
00226 {
00227 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00228 if(!IsVisible)
00229 return false;
00230
00231 if(!Parent)
00232 return true;
00233
00234 return Parent->isTrulyVisible();
00235 }
00236
00238
00242 virtual void setVisible(bool isVisible)
00243 {
00244 IsVisible = isVisible;
00245 }
00246
00247
00249
00251 virtual s32 getID() const
00252 {
00253 return ID;
00254 }
00255
00256
00258
00260 virtual void setID(s32 id)
00261 {
00262 ID = id;
00263 }
00264
00265
00267
00270 virtual void addChild(ISceneNode* child)
00271 {
00272 if (child && (child != this))
00273 {
00274
00275 if (SceneManager != child->SceneManager)
00276 child->setSceneManager(SceneManager);
00277
00278 child->grab();
00279 child->remove();
00280 Children.push_back(child);
00281 child->Parent = this;
00282 }
00283 }
00284
00285
00287
00292 virtual bool removeChild(ISceneNode* child)
00293 {
00294 core::list<ISceneNode*>::Iterator it = Children.begin();
00295 for (; it != Children.end(); ++it)
00296 if ((*it) == child)
00297 {
00298 (*it)->Parent = 0;
00299 (*it)->drop();
00300 Children.erase(it);
00301 return true;
00302 }
00303
00304 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00305 return false;
00306 }
00307
00308
00310
00313 virtual void removeAll()
00314 {
00315 core::list<ISceneNode*>::Iterator it = Children.begin();
00316 for (; it != Children.end(); ++it)
00317 {
00318 (*it)->Parent = 0;
00319 (*it)->drop();
00320 }
00321
00322 Children.clear();
00323 }
00324
00325
00327
00329 virtual void remove()
00330 {
00331 if (Parent)
00332 Parent->removeChild(this);
00333 }
00334
00335
00337
00338 virtual void addAnimator(ISceneNodeAnimator* animator)
00339 {
00340 if (animator)
00341 {
00342 Animators.push_back(animator);
00343 animator->grab();
00344 }
00345 }
00346
00347
00349
00350 const core::list<ISceneNodeAnimator*>& getAnimators() const
00351 {
00352 return Animators;
00353 }
00354
00355
00357
00360 virtual void removeAnimator(ISceneNodeAnimator* animator)
00361 {
00362 core::list<ISceneNodeAnimator*>::Iterator it = Animators.begin();
00363 for (; it != Animators.end(); ++it)
00364 {
00365 if ((*it) == animator)
00366 {
00367 (*it)->drop();
00368 Animators.erase(it);
00369 return;
00370 }
00371 }
00372 }
00373
00374
00376
00378 virtual void removeAnimators()
00379 {
00380 core::list<ISceneNodeAnimator*>::Iterator it = Animators.begin();
00381 for (; it != Animators.end(); ++it)
00382 (*it)->drop();
00383
00384 Animators.clear();
00385 }
00386
00387
00389
00396 virtual video::SMaterial& getMaterial(u32 num)
00397 {
00398 return video::IdentityMaterial;
00399 }
00400
00401
00403
00404 virtual u32 getMaterialCount() const
00405 {
00406 return 0;
00407 }
00408
00409
00411
00415 void setMaterialFlag(video::E_MATERIAL_FLAG flag, bool newvalue)
00416 {
00417 for (u32 i=0; i<getMaterialCount(); ++i)
00418 getMaterial(i).setFlag(flag, newvalue);
00419 }
00420
00421
00423
00426 void setMaterialTexture(u32 textureLayer, video::ITexture* texture)
00427 {
00428 if (textureLayer >= video::MATERIAL_MAX_TEXTURES)
00429 return;
00430
00431 for (u32 i=0; i<getMaterialCount(); ++i)
00432 getMaterial(i).setTexture(textureLayer, texture);
00433 }
00434
00435
00437
00438 void setMaterialType(video::E_MATERIAL_TYPE newType)
00439 {
00440 for (u32 i=0; i<getMaterialCount(); ++i)
00441 getMaterial(i).MaterialType = newType;
00442 }
00443
00444
00446
00450 virtual const core::vector3df& getScale() const
00451 {
00452 return RelativeScale;
00453 }
00454
00455
00457
00458 virtual void setScale(const core::vector3df& scale)
00459 {
00460 RelativeScale = scale;
00461 }
00462
00463
00465
00469 virtual const core::vector3df& getRotation() const
00470 {
00471 return RelativeRotation;
00472 }
00473
00474
00476
00478 virtual void setRotation(const core::vector3df& rotation)
00479 {
00480 RelativeRotation = rotation;
00481 }
00482
00483
00485
00488 virtual const core::vector3df& getPosition() const
00489 {
00490 return RelativeTranslation;
00491 }
00492
00493
00495
00497 virtual void setPosition(const core::vector3df& newpos)
00498 {
00499 RelativeTranslation = newpos;
00500 }
00501
00502
00504
00507 virtual core::vector3df getAbsolutePosition() const
00508 {
00509 return AbsoluteTransformation.getTranslation();
00510 }
00511
00512
00514
00519 void setAutomaticCulling( E_CULLING_TYPE state)
00520 {
00521 AutomaticCullingState = state;
00522 }
00523
00524
00526
00527 E_CULLING_TYPE getAutomaticCulling() const
00528 {
00529 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00530 return AutomaticCullingState;
00531 }
00532
00533
00535
00538 virtual void setDebugDataVisible(s32 state)
00539 {
00540 DebugDataVisible = state;
00541 }
00542
00544
00546 s32 isDebugDataVisible() const
00547 {
00548 return DebugDataVisible;
00549 }
00550
00551
00553
00555 void setIsDebugObject(bool debugObject)
00556 {
00557 IsDebugObject = debugObject;
00558 }
00559
00560
00562
00565 bool isDebugObject() const
00566 {
00567 _IRR_IMPLEMENT_MANAGED_MARSHALLING_BUGFIX;
00568 return IsDebugObject;
00569 }
00570
00571
00573
00574 const core::list<ISceneNode*>& getChildren() const
00575 {
00576 return Children;
00577 }
00578
00579
00581
00582 virtual void setParent(ISceneNode* newParent)
00583 {
00584 grab();
00585 remove();
00586
00587 Parent = newParent;
00588
00589 if (Parent)
00590 Parent->addChild(this);
00591
00592 drop();
00593 }
00594
00595
00597
00606 virtual ITriangleSelector* getTriangleSelector() const
00607 {
00608 return TriangleSelector;
00609 }
00610
00611
00613
00621 virtual void setTriangleSelector(ITriangleSelector* selector)
00622 {
00623 if (TriangleSelector != selector)
00624 {
00625 if (TriangleSelector)
00626 TriangleSelector->drop();
00627
00628 TriangleSelector = selector;
00629 if (TriangleSelector)
00630 TriangleSelector->grab();
00631 }
00632 }
00633
00634
00636
00638 virtual void updateAbsolutePosition()
00639 {
00640 if (Parent)
00641 {
00642 AbsoluteTransformation =
00643 Parent->getAbsoluteTransformation() * getRelativeTransformation();
00644 }
00645 else
00646 AbsoluteTransformation = getRelativeTransformation();
00647 }
00648
00649
00651
00652 scene::ISceneNode* getParent() const
00653 {
00654 return Parent;
00655 }
00656
00657
00659
00660 virtual ESCENE_NODE_TYPE getType() const
00661 {
00662 return ESNT_UNKNOWN;
00663 }
00664
00665
00667
00673 virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options=0) const
00674 {
00675 if (!out)
00676 return;
00677 out->addString ("Name", Name.c_str());
00678 out->addInt ("Id", ID );
00679
00680 out->addVector3d("Position", getPosition() );
00681 out->addVector3d("Rotation", getRotation() );
00682 out->addVector3d("Scale", getScale() );
00683
00684 out->addBool ("Visible", IsVisible );
00685 out->addEnum ("AutomaticCulling", AutomaticCullingState, AutomaticCullingNames);
00686 out->addInt ("DebugDataVisible", DebugDataVisible );
00687 out->addBool ("IsDebugObject", IsDebugObject );
00688 }
00689
00690
00692
00698 virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options=0)
00699 {
00700 if (!in)
00701 return;
00702 Name = in->getAttributeAsString("Name");
00703 ID = in->getAttributeAsInt("Id");
00704
00705 setPosition(in->getAttributeAsVector3d("Position"));
00706 setRotation(in->getAttributeAsVector3d("Rotation"));
00707 setScale(in->getAttributeAsVector3d("Scale"));
00708
00709 IsVisible = in->getAttributeAsBool("Visible");
00710 AutomaticCullingState = (scene::E_CULLING_TYPE) in->getAttributeAsEnumeration("AutomaticCulling",
00711 scene::AutomaticCullingNames);
00712
00713 DebugDataVisible = in->getAttributeAsInt("DebugDataVisible");
00714 IsDebugObject = in->getAttributeAsBool("IsDebugObject");
00715
00716 updateAbsolutePosition();
00717 }
00718
00720
00723 virtual ISceneNode* clone(ISceneNode* newParent=0, ISceneManager* newManager=0)
00724 {
00725 return 0;
00726 }
00727
00729
00730 virtual ISceneManager* getSceneManager(void) const { return SceneManager; }
00731
00732 protected:
00733
00735
00739 void cloneMembers(ISceneNode* toCopyFrom, ISceneManager* newManager)
00740 {
00741 Name = toCopyFrom->Name;
00742 AbsoluteTransformation = toCopyFrom->AbsoluteTransformation;
00743 RelativeTranslation = toCopyFrom->RelativeTranslation;
00744 RelativeRotation = toCopyFrom->RelativeRotation;
00745 RelativeScale = toCopyFrom->RelativeScale;
00746 ID = toCopyFrom->ID;
00747 setTriangleSelector(toCopyFrom->TriangleSelector);
00748 AutomaticCullingState = toCopyFrom->AutomaticCullingState;
00749 DebugDataVisible = toCopyFrom->DebugDataVisible;
00750 IsVisible = toCopyFrom->IsVisible;
00751 IsDebugObject = toCopyFrom->IsDebugObject;
00752
00753 if (newManager)
00754 SceneManager = newManager;
00755 else
00756 SceneManager = toCopyFrom->SceneManager;
00757
00758
00759
00760 core::list<ISceneNode*>::Iterator it = toCopyFrom->Children.begin();
00761 for (; it != toCopyFrom->Children.end(); ++it)
00762 (*it)->clone(this, newManager);
00763
00764
00765
00766 core::list<ISceneNodeAnimator*>::Iterator ait = toCopyFrom->Animators.begin();
00767 for (; ait != toCopyFrom->Animators.end(); ++ait)
00768 {
00769 ISceneNodeAnimator* anim = (*ait)->createClone(this, SceneManager);
00770 if (anim)
00771 {
00772 addAnimator(anim);
00773 anim->drop();
00774 }
00775 }
00776 }
00777
00780 void setSceneManager(ISceneManager* newManager)
00781 {
00782 SceneManager = newManager;
00783
00784 core::list<ISceneNode*>::Iterator it = Children.begin();
00785 for (; it != Children.end(); ++it)
00786 (*it)->setSceneManager(newManager);
00787 }
00788
00790 core::stringc Name;
00791
00793 core::matrix4 AbsoluteTransformation;
00794
00796 core::vector3df RelativeTranslation;
00797
00799 core::vector3df RelativeRotation;
00800
00802 core::vector3df RelativeScale;
00803
00805 ISceneNode* Parent;
00806
00808 core::list<ISceneNode*> Children;
00809
00811 core::list<ISceneNodeAnimator*> Animators;
00812
00814 ISceneManager* SceneManager;
00815
00817 ITriangleSelector* TriangleSelector;
00818
00820 s32 ID;
00821
00823 E_CULLING_TYPE AutomaticCullingState;
00824
00826 s32 DebugDataVisible;
00827
00829 bool IsVisible;
00830
00832 bool IsDebugObject;
00833 };
00834
00835 }
00836 }
00837
00838 #endif
00839