SuperTuxKart
track_object.hpp
1 //
2 // SuperTuxKart - a fun racing game with go-kart
3 // Copyright (C) 2009-2015 Joerg Henrichs
4 //
5 // This program is free software; you can redistribute it and/or
6 // modify it under the terms of the GNU General Public License
7 // as published by the Free Software Foundation; either version 3
8 // of the License, or (at your option) any later version.
9 //
10 // This program is distributed in the hope that it will be useful,
11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 // GNU General Public License for more details.
14 //
15 // You should have received a copy of the GNU General Public License
16 // along with this program; if not, write to the Free Software
17 // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 
19 #ifndef HEADER_TRACK_OBJECT_HPP
20 #define HEADER_TRACK_OBJECT_HPP
21 
22 #include <vector3d.h>
23 
24 #include "physics/physical_object.hpp"
25 #include "scriptengine/scriptvec3.hpp"
26 #include "tracks/track_object_presentation.hpp"
27 #include "utils/cpp2011.hpp"
28 #include "utils/vec3.hpp"
29 #include <string>
30 #include "animations/three_d_animation.hpp"
31 
32 #include <memory>
33 
35 class RenderInfo;
36 class ThreeDAnimation;
37 class XMLNode;
38 
46 {
47 //public:
48  // The different type of track objects: physical objects, graphical
49  // objects (without a physical representation) - the latter might be
50  // eye candy (to reduce work for physics), ...
51  //enum TrackObjectType {TO_PHYSICAL, TO_GRAPHICAL};
52 
53 private:
55  bool m_enabled;
56 
57  TrackObjectPresentation* m_presentation;
58 
59  std::string m_name;
60 
61  std::string m_id;
62 
63  std::shared_ptr<RenderInfo> m_render_info;
64 
65 protected:
66 
68  core::vector3df m_init_xyz;
69 
71  core::vector3df m_init_hpr;
72 
74  core::vector3df m_init_scale;
75 
77  std::string m_lod_group;
78 
79  std::string m_interaction;
80 
81  std::string m_type;
82 
83  bool m_soccer_ball;
84 
87 
88  std::shared_ptr<PhysicalObject> m_physical_object;
89 
90  ThreeDAnimation* m_animator;
91 
92  TrackObject* m_parent_library;
93 
94  std::vector<TrackObject*> m_movable_children;
95  std::vector<TrackObject*> m_children;
96 
97  bool m_initially_visible;
98 
99  std::string m_visibility_condition;
100 
101  void init(const XMLNode &xml_node, scene::ISceneNode* parent,
102  ModelDefinitionLoader& model_def_loader,
103  TrackObject* parent_library);
104 
105 public:
106  TrackObject(const XMLNode &xml_node,
107  scene::ISceneNode* parent,
108  ModelDefinitionLoader& model_def_loader,
109  TrackObject* parent_library);
110 
111  TrackObject(const core::vector3df& xyz,
112  const core::vector3df& hpr,
113  const core::vector3df& scale,
114  const char* interaction,
115  TrackObjectPresentation* presentation,
116  bool is_dynamic,
117  const PhysicalObject::Settings* physicsSettings);
118  virtual ~TrackObject();
119  virtual void update(float dt);
120  virtual void updateGraphics(float dt);
121  virtual void resetAfterRewind();
122  void move(const core::vector3df& xyz, const core::vector3df& hpr,
123  const core::vector3df& scale, bool updateRigidBody,
124  bool isAbsoluteCoord);
125 
126  virtual void reset();
127  const core::vector3df& getPosition() const;
128  const core::vector3df getAbsolutePosition() const;
129  const core::vector3df getAbsoluteCenterPosition() const;
130  const core::vector3df& getRotation() const;
131  const core::vector3df& getScale() const;
132  bool castRay(const btVector3 &from,
133  const btVector3 &to, btVector3 *hit_point,
134  const Material **material, btVector3 *normal,
135  bool interpolate_normal) const;
136 
137  TrackObject* getParentLibrary()
138  {
139  return m_parent_library;
140  }
141 
142  // ------------------------------------------------------------------------
145  virtual void onWorldReady();
146  // ------------------------------------------------------------------------
149  virtual void handleExplosion(const Vec3& pos, bool directHit) {};
150  void setID(std::string obj_id) { m_id = obj_id; }
151 
152  // ------------------------------------------------------------------------
153  const std::string& getLodGroup() const { return m_lod_group; }
154  // ------------------------------------------------------------------------
155  const std::string& getType() const { return m_type; }
156  // ------------------------------------------------------------------------
157  const std::string getName() const { return m_name; }
158  // ------------------------------------------------------------------------
159  const std::string getID() const { return m_id; }
160  // ------------------------------------------------------------------------
161  const std::string getInteraction() const { return m_interaction; }
162  // ------------------------------------------------------------------------
163  bool isEnabled() const { return m_enabled; }
164  // ------------------------------------------------------------------------
165  bool isSoccerBall() const { return m_soccer_ball; }
166  // ------------------------------------------------------------------------
167  const PhysicalObject* getPhysicalObject() const
168  { return m_physical_object.get(); }
169  // ------------------------------------------------------------------------
170  PhysicalObject* getPhysicalObject() { return m_physical_object.get(); }
171  // ------------------------------------------------------------------------
172  const core::vector3df getInitXYZ() const { return m_init_xyz; }
173  // ------------------------------------------------------------------------
174  const core::vector3df getInitRotation() const { return m_init_hpr; }
175  // ------------------------------------------------------------------------
176  const core::vector3df getInitScale() const { return m_init_scale; }
177  // ------------------------------------------------------------------------
178  template<typename T>
179  T* getPresentation() { return dynamic_cast<T*>(m_presentation); }
180  // ------------------------------------------------------------------------
181  template<typename T>
182  const T* getPresentation() const { return dynamic_cast<T*>(m_presentation); }
183  // ------------------------------------------------------------------------
184  // Methods usable by scripts
196  scene::IAnimatedMeshSceneNode* getMesh();
200  TrackObjectPresentationParticles* getParticleEmitter() { return getPresentation<TrackObjectPresentationParticles>(); }
204  TrackObjectPresentationSound* getSoundEmitter(){ return getPresentation<TrackObjectPresentationSound>(); }
208  TrackObjectPresentationLight* getLight() { return getPresentation<TrackObjectPresentationLight>(); }
209  // For angelscript. Needs to be named something different than getAnimator since it's overloaded.
213  ThreeDAnimation* getIPOAnimator() { return m_animator; }
214  // For angelscript. Needs to be named something different than getPhysicalObject since it's overloaded.
218  PhysicalObject* getPhysics() { return m_physical_object.get(); }
220  void setEnabled(bool mode);
221 
222  void moveTo(const Scripting::SimpleVec3* pos, bool isAbsoluteCoord);
223  /* @} */
224  /* @} */
225  /* @} */
226 
227  void resetEnabled();
228  // ------------------------------------------------------------------------
229  ThreeDAnimation* getAnimator() { return m_animator; }
230  // ------------------------------------------------------------------------
231  const ThreeDAnimation* getAnimator() const { return m_animator; }
232  // ------------------------------------------------------------------------
233  /* Return true if it has animator or its parent library has */
234  bool hasAnimatorRecursively() const
235  {
236  if (m_animator)
237  return true;
238  if (!m_parent_library)
239  return false;
240  return m_parent_library->hasAnimatorRecursively();
241  }
242  // ------------------------------------------------------------------------
243  void setPaused(bool mode){ m_animator->setPaused(mode); }
244  // ------------------------------------------------------------------------
245  void setInitiallyVisible(bool val) { m_initially_visible = val; }
246  // ------------------------------------------------------------------------
248  bool isDriveable() const { return m_is_driveable; }
249  // ------------------------------------------------------------------------
253  void addMovableChild(TrackObject* child);
254  // ------------------------------------------------------------------------
255  void addChild(TrackObject* child);
256  // ------------------------------------------------------------------------
257  std::vector<TrackObject*>& getMovableChildren() { return m_movable_children; }
258  // ------------------------------------------------------------------------
259  std::vector<TrackObject*>& getChildren() { return m_children; }
260  // ------------------------------------------------------------------------
261  void movePhysicalBodyToGraphicalNode(const core::vector3df& xyz, const core::vector3df& hpr);
262  // ------------------------------------------------------------------------
263  bool joinToMainTrack();
264  // ------------------------------------------------------------------------
265  TrackObject* cloneToChild();
266  LEAK_CHECK()
267 }; // TrackObject
268 
269 #endif
bool isDriveable() const
Returns if a kart can drive on this object.
Definition: track_object.hpp:248
void addMovableChild(TrackObject *child)
Used along the "extract movable nodes out of library objects" hack, used to still preserve the parent...
Definition: track_object.cpp:690
void init(const XMLNode &xml_node, scene::ISceneNode *parent, ModelDefinitionLoader &model_def_loader, TrackObject *parent_library)
Initialises the track object based on the specified XML data.
Definition: track_object.cpp:103
virtual void updateGraphics(float dt)
This updates all only graphical elements.
Definition: track_object.cpp:540
virtual ~TrackObject()
Destructor.
Definition: track_object.cpp:464
A wrapper around bullets btVector3 to include conventient conversion functions (e.g.
Definition: vec3.hpp:34
bool castRay(const btVector3 &from, const btVector3 &to, btVector3 *hit_point, const Material **material, btVector3 *normal, bool interpolate_normal) const
Does a raycast against the track object.
Definition: track_object.cpp:587
ThreeDAnimation * getIPOAnimator()
Should only be used on TrackObjects that use curve-based animation.
Definition: track_object.hpp:213
scene::IAnimatedMeshSceneNode * getMesh()
Should only be used on mesh track objects.
Definition: track_object.cpp:719
virtual void reset()
Initialises an object before a race starts.
Definition: track_object.cpp:473
virtual void onWorldReady()
To finish object constructions.
Definition: track_object.cpp:398
TrackObjectPresentationLight * getLight()
Should only be used on sound emitter track objects.
Definition: track_object.hpp:208
bool m_enabled
True if the object is currently being displayed.
Definition: track_object.hpp:55
A track object representation that consists of a sound emitter.
Definition: track_object_presentation.hpp:276
Definition: script_track.cpp:250
TrackObjectPresentationSound * getSoundEmitter()
Should only be used on sound emitter track objects.
Definition: track_object.hpp:204
bool m_is_driveable
True if a kart can drive on this object.
Definition: track_object.hpp:86
std::string m_lod_group
LOD group this object is part of, if it is LOD.
Definition: track_object.hpp:77
Base class for all track object presentation classes.
Definition: track_object_presentation.hpp:57
virtual void update(float dt)
This updates once per physics time step.
Definition: track_object.cpp:551
TrackObject(const XMLNode &xml_node, scene::ISceneNode *parent, ModelDefinitionLoader &model_def_loader, TrackObject *parent_library)
A track object: any additional object on the track.
Definition: track_object.cpp:54
Definition: physical_object.hpp:38
A track object representation that consists of a particle emitter.
Definition: track_object_presentation.hpp:336
A track object representation that consists of a light emitter.
Definition: track_object_presentation.hpp:364
virtual void handleExplosion(const Vec3 &pos, bool directHit)
Called when an explosion happens.
Definition: track_object.hpp:149
Definition: physical_object.hpp:48
core::vector3df m_init_hpr
The initial hpr of the object.
Definition: track_object.hpp:71
Definition: material.hpp:47
virtual void resetAfterRewind()
This reset all physical object moved by 3d animation back to current ticks.
Definition: track_object.cpp:562
Definition: scriptvec3.hpp:28
utility class used to parse XML files
Definition: xml_node.hpp:47
core::vector3df m_init_scale
The initial scale of the object.
Definition: track_object.hpp:74
Definition: render_info.hpp:27
core::vector3df m_init_xyz
The initial XYZ position of the object.
Definition: track_object.hpp:68
A virtual base class for all animations.
Definition: three_d_animation.hpp:44
void setEnabled(bool mode)
Hide or show the object.
Definition: track_object.cpp:485
TrackObjectPresentationParticles * getParticleEmitter()
Should only be used on particle emitter track objects.
Definition: track_object.hpp:200
Utility class to load level-of-detail nodes and library nodes.
Definition: model_definition_loader.hpp:81
PhysicalObject * getPhysics()
Get the physics representation of an object.
Definition: track_object.hpp:218