Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/orxonox/Scene.h @ 11906

Last change on this file since 11906 was 11176, checked in by fvultier, 9 years ago

Added a debug console command that allows visualization of the weaponSlots.

  • Property svn:eol-style set to native
File size: 7.8 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 *      Reto Grieder (physics)
25 *   Co-authors:
26 *      ...
27 *
28 */
29
30/**
31@file Scene.h
32@brief Definition of Scene Class
33*/
34
35#ifndef _Scene_H__
36#define _Scene_H__
37
38#include "OrxonoxPrereqs.h"
39
40#include <list>
41#include <set>
42#include <string>
43
44#include "util/Math.h"
45#include "util/OgreForwardRefs.h"
46#include "core/BaseObject.h"
47#include "core/object/Context.h"
48#include "network/synchronisable/Synchronisable.h"
49#include "tools/interfaces/Tickable.h"
50#include "core/command/ConsoleCommandIncludes.h"
51
52namespace orxonox
53{
54    class _OrxonoxExport Scene : public BaseObject, public Synchronisable, public Tickable, public Context
55    {
56        public:
57            /**
58            @brief
59                This class holds a Scene which is a collection of all kinds of objects to be rendered in the same space,
60                with the same physics and the same light properties. Objects can be anything from a light source, over non physical objects
61                like Billboards to just plain Models with an attached Mesh
62            */
63            Scene(Context* context);
64            virtual ~Scene();
65
66            virtual void XMLPort(Element& xmlelement, XMLPort::Mode mode) override;
67            void registerVariables();
68
69            inline Ogre::SceneManager* getSceneManager() const
70                { return this->sceneManager_; }
71            inline Ogre::SceneNode* getRootSceneNode() const
72                { return this->rootSceneNode_; }
73            inline RenderQueueListener* getRenderQueueListener() const
74                { return this->renderQueueListener_; }
75
76            void setSkybox(const std::string& skybox);
77            inline const std::string& getSkybox() const
78                { return this->skybox_; }
79
80            void setAmbientLight(const ColourValue& colour);
81            inline const ColourValue& getAmbientLight() const
82                { return this->ambientLight_; }
83
84            void setShadow(bool bShadow);
85            inline bool getShadow() const
86                { return this->bShadows_; }
87
88            inline void setSoundReferenceDistance(float distance)
89                { this->soundReferenceDistance_ = distance; }
90            inline float getSoundReferenceDistance() const
91                { return this->soundReferenceDistance_; }
92
93            inline Radar* getRadar()
94                { return this->radar_; }
95
96            virtual inline uint32_t getSceneID() const override { return this->getObjectID(); }
97
98            virtual void tick(float dt) override;
99
100        private:
101            void addObject(BaseObject* object);
102            BaseObject* getObject(unsigned int index) const;
103
104            void networkcallback_applySkybox()
105                { this->setSkybox(this->skybox_); }
106            void networkcallback_applyAmbientLight()
107                { this->setAmbientLight(this->ambientLight_); }
108            void networkcallback_applyShadows()
109                { this->setShadow(this->bShadows_); }
110
111            Ogre::SceneManager*      sceneManager_; //!< This is a pointer to the Ogre SceneManager we're using to render the Scene
112            Ogre::SceneNode*         rootSceneNode_; //!< This is a pointer to the root node of the Scene tree
113            RenderQueueListener*     renderQueueListener_; //!< this is a pointer to the RenderQueueListener we're using for this Scene
114
115            std::string              skybox_; //!< This string holds information about the skybox we're using
116            ColourValue              ambientLight_; //!< This variable holds the color value for the ambient light in our scene, usually black in space
117            std::list<BaseObject*>   objects_; //!< This list holds all the objects created in our scene
118            bool                     bShadows_; //!< Do we want shadows in our scene?
119            float                    soundReferenceDistance_; //!< This holds a reference distance, which represents the distance between our scene and the listener
120            Radar*                   radar_; //!< This is a pointer to a Radar object assigned with this scene
121            WeakPtr<GlobalShader>    glowShader_;
122
123
124        /////////////
125        // Physics //
126        /////////////
127
128        public:
129            inline bool hasPhysics() const
130                { return this->physicalWorld_ != nullptr; }
131            void setPhysicalWorld(bool wantsPhysics);
132
133            void setNegativeWorldRange(const Vector3& range);
134            inline const Vector3& getNegativeWorldRange() const
135                { return this->negativeWorldRange_; }
136
137            void setPositiveWorldRange(const Vector3& range);
138            inline const Vector3& getPositiveWorldRange() const
139                { return this->positiveWorldRange_; }
140
141            void setGravity(const Vector3& gravity);
142            inline const Vector3& getGravity() const
143                { return this->gravity_; }
144
145            void addPhysicalObject(WorldEntity* object);
146            void removePhysicalObject(WorldEntity* object);
147
148            inline bool isUpdatingPhysics() const
149                { return this->bIsUpdatingPhysics_; }
150
151            void setDebugDrawPhysics(bool bDraw, bool bFill, float fillAlpha);
152
153            static void consoleCommand_debugDrawPhysics(bool bDraw, bool bFill, float fillAlpha);
154
155        private:
156            inline void networkcallback_hasPhysics()
157                { this->setPhysicalWorld(this->bHasPhysics_); }
158            inline void networkcallback_negativeWorldRange()
159                { this->setNegativeWorldRange(this->negativeWorldRange_); }
160            inline void networkcallback_positiveWorldRange()
161                { this->setPositiveWorldRange(this->positiveWorldRange_); }
162            inline void networkcallback_gravity()
163                { this->setGravity(this->gravity_); }
164
165            // collision callback from bullet
166            static bool collisionCallback(btManifoldPoint& cp, const btCollisionObject* colObj0, int partId0,
167                                          int index0, const btCollisionObject* colObj1, int partId1, int index1);
168
169            // Bullet objects
170            btDiscreteDynamicsWorld*             physicalWorld_;
171            bt32BitAxisSweep3*                   broadphase_;
172            btDefaultCollisionConfiguration*     collisionConfig_;
173            btCollisionDispatcher*               dispatcher_;
174            btSequentialImpulseConstraintSolver* solver_;
175
176            std::set<WorldEntity*>               physicalObjectQueue_;
177            std::set<WorldEntity*>               physicalObjects_;
178            bool                                 bHasPhysics_;
179            Vector3                              negativeWorldRange_;
180            Vector3                              positiveWorldRange_;
181            Vector3                              gravity_;
182
183            BulletDebugDrawer*                   debugDrawer_;
184            bool                                 bDebugDrawPhysics_;
185            bool                                 bIsUpdatingPhysics_;
186    };
187}
188
189#endif /* _Scene_H__ */
Note: See TracBrowser for help on using the repository browser.