doc/html/_i_scene_node_8h_source.html

00001 // Copyright (C) 2002-2012 Nikolaus Gebhardt
-00002 // This file is part of the "Irrlicht Engine".
-00003 // For conditions of distribution and use, see copyright notice in irrlicht.h
-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             // delete all children
-00065             removeAll();
-00066
-00067             // delete all animators
-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                 // animate this node with all animators
-00113
-00114                 ISceneNodeAnimatorList::Iterator ait = Animators.begin();
-00115                 while (ait != Animators.end())
-00116                     {
-00117                     // continue to the next node before calling animateNode()
-00118                     // so that the animator may remove itself from the scene
-00119                     // node without the iterator becoming invalid
-00120                     ISceneNodeAnimator* anim = *ait;
-00121                     ++ait;
-00122                     anim->animateNode(this, timeMs);
-00123                 }
-00124
-00125                 // update absolute position
-00126                 updateAbsolutePosition();
-00127
-00128                 // perform the post render process on all children
-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                 // Change scene manager?
-00285                 if (SceneManager != child->SceneManager)
-00286                     child->setSceneManager(SceneManager);
-00287
-00288                 child->grab();
-00289                 child->remove(); // remove from old parent
-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; // to be implemented by derived classes
-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             // clone children
-00777
-00778             ISceneNodeList::Iterator it = toCopyFrom->Children.begin();
-00779             for (; it != toCopyFrom->Children.end(); ++it)
-00780                 (*it)->clone(this, newManager);
-00781
-00782             // clone animators
-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 } // end namespace scene
-00855 } // end namespace irr
-00856
-00857 #endif
-00858
-