Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/core3/src/orxonox/objects/WorldEntity.h @ 1592

Last change on this file since 1592 was 1592, checked in by landauf, 16 years ago
  • Some small changes in XMLPortParam: It's now possible to add functions of another class. an example is setPosition and getPosition that are directly referred to Ogre::Node. Use XMLPortParamExtern if you need this. It takes the object to call the functions on as an additional argument (in our example: this→node_).
  • Removed loadParams functions and reduced the usage of XMLPortParamLoadOnly in several classes
  • Property svn:eol-style set to native
File size: 9.0 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Fabian 'x3n' Landau
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29#ifndef _WorldEntity_H__
30#define _WorldEntity_H__
31
32#include "OrxonoxPrereqs.h"
33
34#include <OgreSceneManager.h>
35#include <OgreSceneNode.h>
36
37#include "util/Math.h"
38#include "util/XMLIncludes.h"
39#include "network/Synchronisable.h"
40#include "core/BaseObject.h"
41#include "Tickable.h"
42#include "../tools/Mesh.h"
43
44namespace orxonox
45{
46    class _OrxonoxExport WorldEntity : public BaseObject, public Tickable, public network::Synchronisable
47    {
48        public:
49            WorldEntity();
50            virtual ~WorldEntity();
51
52            virtual void tick(float dt);
53            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode);
54            virtual inline bool create(){ return Synchronisable::create(); }
55
56            void attachWorldEntity(WorldEntity* entity);
57            const WorldEntity* getAttachedWorldEntity(unsigned int index) const;
58
59            inline Ogre::SceneNode* getNode()
60                { return this->node_; }
61
62            inline void setNode(Ogre::SceneNode* node)
63                { this->node_ = node; }
64
65            inline void setPosition(const Vector3& pos)
66                { this->node_->setPosition(pos); }
67            inline void setPosition(Real x, Real y, Real z)
68                { this->node_->setPosition(x, y, z); }
69            inline const Vector3& getPosition() const
70                { return this->node_->getPosition(); }
71
72            inline void translate(const Vector3 &d, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_PARENT)
73                { this->node_->translate(d, relativeTo); }
74            inline void translate(Real x, Real y, Real z, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_PARENT)
75                { this->node_->translate(x, y, z, relativeTo); }
76            inline void translate(const Matrix3 &axes, const Vector3 &move, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_PARENT)
77                { this->node_->translate(axes, move, relativeTo); }
78            inline void translate(const Matrix3 &axes, Real x, Real y, Real z, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_PARENT)
79                { this->node_->translate(axes, x, y, z, relativeTo); }
80
81            inline void yaw(const Radian &angle, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_LOCAL)
82                { this->node_->yaw(angle, relativeTo); }
83            inline void pitch(const Radian &angle, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_LOCAL)
84                { this->node_->pitch(angle, relativeTo); }
85            inline void roll(const Radian &angle, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_LOCAL)
86                { this->node_->roll(angle, relativeTo); }
87            void setYawPitchRoll(const Degree& yaw, const Degree& pitch, const Degree& roll);
88
89            inline void setYaw(const Degree &angle)
90                { this->node_->yaw(angle, Ogre::Node::TS_LOCAL); }
91            inline void setPitch(const Degree &angle)
92                { this->node_->pitch(angle, Ogre::Node::TS_LOCAL); }
93            inline void setRoll(const Degree &angle)
94                { this->node_->roll(angle, Ogre::Node::TS_LOCAL); }
95
96            inline const Ogre::Quaternion& getOrientation()
97              { return this->node_->getOrientation(); }
98            inline void setOrientation(const Ogre::Quaternion& quat)
99              { this->node_->setOrientation(quat); }
100            inline void rotate(const Vector3 &axis, const Radian &angle, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_LOCAL)
101              { this->node_->rotate(axis, angle, relativeTo); }
102            inline void setDirectionSimple(Real x, Real y, Real z)
103              { this->setDirection(x, y, z); }
104            inline void setDirection(Real x, Real y, Real z, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_LOCAL, const Vector3 &localDirectionVector=Vector3::NEGATIVE_UNIT_Z)
105              { this->node_->setDirection(x, y, z, relativeTo, localDirectionVector); }
106            inline void setDirection(const Vector3 &vec, Ogre::Node::TransformSpace relativeTo=Ogre::Node::TS_LOCAL, const Vector3 &localDirectionVector=Vector3::NEGATIVE_UNIT_Z)
107              { this->node_->setDirection(vec, relativeTo, localDirectionVector); }
108            inline void lookAt(const Vector3 &targetPoint, Ogre::Node::TransformSpace relativeTo, const Vector3 &localDirectionVector=Vector3::NEGATIVE_UNIT_Z)
109              { this->node_->lookAt(targetPoint, relativeTo, localDirectionVector); }
110
111            inline void setScale3D(const Vector3 &scale)
112              { this->node_->setScale(scale); }
113            inline void setScale3D(Real x, Real y, Real z)
114              { this->node_->setScale(x, y, z); }
115            inline const Vector3& getScale3D(void) const
116              { return this->node_->getScale(); }
117            inline void setScale(float scale)
118              { this->node_->setScale(scale, scale, scale); }
119            inline float getScale() const
120              { Vector3 scale = this->getScale3D(); return (scale.x == scale.y && scale.x == scale.z) ? scale.x : 1; }
121            inline void scale3D(const Vector3 &scale)
122              { this->node_->scale(scale); }
123            inline void scale3D(Real x, Real y, Real z)
124              { this->node_->scale(x, y, z); }
125            inline void scale(Real scale)
126              { this->node_->scale(scale, scale, scale); }
127
128            inline void attachObject(Ogre::MovableObject *obj)
129              { this->node_->attachObject(obj); }
130            inline void attachObject(Mesh &mesh)
131              { this->node_->attachObject(mesh.getEntity()); }
132            inline void detachObject(Ogre::MovableObject *obj)
133              { this->node_->detachObject(obj); }
134            inline void detachAllObjects()
135              { this->node_->detachAllObjects(); }
136
137            inline void setVelocity(const Vector3& velocity)
138                { this->velocity_ = velocity; }
139            inline void setVelocity(Real x, Real y, Real z)
140                { this->velocity_.x = x; this->velocity_.y = y; this->velocity_.z = z; }
141            inline const Vector3& getVelocity() const
142                { return this->velocity_; }
143
144            inline void setAcceleration(const Vector3& acceleration)
145                { this->acceleration_ = acceleration; }
146            inline void setAcceleration(Real x, Real y, Real z)
147                { this->acceleration_.x = x; this->acceleration_.y = y; this->acceleration_.z = z; }
148            inline const Vector3& getAcceleration() const
149                { return this->acceleration_; }
150
151            inline void setRotationAxis(const Vector3& axis)
152                { this->rotationAxis_ = axis; this->rotationAxis_.normalise(); }
153            inline void setRotationAxis(Real x, Real y, Real z)
154                { this->rotationAxis_.x = x; this->rotationAxis_.y = y; this->rotationAxis_.z = z; rotationAxis_.normalise(); }
155            inline const Vector3& getRotationAxis() const
156                { return this->rotationAxis_; }
157
158//            inline void setRotationRate(const Radian& angle)
159//                { this->rotationRate_ = angle; }
160            inline void setRotationRate(const Degree& angle)
161                { this->rotationRate_ = angle; this->setStatic(angle == Degree(0)); }
162            inline const Radian& getRotationRate() const
163                { return this->rotationRate_; }
164
165            inline void setMomentum(const Radian& angle)
166                { this->momentum_ = angle; }
167            inline void setMomentum(const Degree& angle)
168                { this->momentum_ = angle; }
169            inline const Radian& getMomentum() const
170                { return this->momentum_; }
171
172            inline void setStatic(bool bStatic)
173                { this->bStatic_ = bStatic; }
174            inline bool isStatic()
175                { return this->bStatic_; }
176
177        protected:
178            void registerAllVariables();
179
180            Vector3 velocity_;
181            Vector3 acceleration_;
182            Vector3 rotationAxis_;
183            Radian rotationRate_;
184            Radian momentum_;
185
186        private:
187            static unsigned int worldEntityCounter_s;
188            Ogre::SceneNode* node_;
189            bool bStatic_;
190            std::vector<WorldEntity*> attachedWorldEntities_;
191    };
192}
193
194#endif /* _WorldEntity_H__ */
Note: See TracBrowser for help on using the repository browser.