source/gameengine/SceneGraph/SG_Spatial.h

   1 /*
   2  * $Id$
   3  *
   4  * ***** BEGIN GPL LICENSE BLOCK *****
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU General Public License
   8  * as published by the Free Software Foundation; either version 2
   9  * of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program; if not, write to the Free Software Foundation,
  18  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  19  *
  20  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  21  * All rights reserved.
  22  *
  23  * The Original Code is: all of this file.
  24  *
  25  * Contributor(s): none yet.
  26  *
  27  * ***** END GPL LICENSE BLOCK *****
  28  */
  29
  30 /** \file SG_Spatial.h
  31  *  \ingroup bgesg
  32  */
  33
  34 #ifndef __SG_SPATIAL_H
  35 #define __SG_SPATIAL_H
  36
  37 #include <MT_Vector3.h>
  38 #include <MT_Point3.h>
  39 #include <MT_Matrix3x3.h> // or Quaternion later ?
  40 #include "SG_IObject.h"
  41 #include "SG_BBox.h"
  42 #include "SG_ParentRelation.h"
  43
  44
  45 class SG_Node;
  46 class SG_ParentRelation;
  47
  48 /**
  49  * SG_Spatial contains spatial information (local & world position, rotation
  50  * and scaling) for a Scene graph node.
  51  * It also contains a link to the node's parent.
  52  */
  53 class SG_Spatial : public SG_IObject
  54 {
  55
  56 protected:
  57         MT_Point3               m_localPosition;
  58         MT_Matrix3x3            m_localRotation;
  59         MT_Vector3              m_localScaling;
  60
  61         MT_Point3               m_worldPosition;
  62         MT_Matrix3x3            m_worldRotation;
  63         MT_Vector3              m_worldScaling;
  64
  65         SG_ParentRelation *     m_parent_relation;
  66
  67         SG_BBox                 m_bbox;
  68         MT_Scalar               m_radius;
  69         bool                    m_modified;
  70         bool                    m_ogldirty;             // true if the openGL matrix for this object must be recomputed
  71
  72 public:
  73         inline void ClearModified()
  74         {
  75                 m_modified = false;
  76                 m_ogldirty = true;
  77         }
  78         inline void SetModified()
  79         {
  80                 m_modified = true;
  81                 ActivateScheduleUpdateCallback();
  82         }
  83         inline void ClearDirty()
  84         {
  85                 m_ogldirty = false;
  86         }
  87         /**
  88          * Define the realtionship this node has with it's parent
  89          * node. You should pass an unshared instance of an SG_ParentRelation
  90          * allocated on the heap to this method. Ownership of this
  91          * instance is assumed by this class.
  92          * You may call this function several times in the lifetime
  93          * of a node to change the relationship dynamically.
  94          * You must call this method before the first call to UpdateSpatialData().
  95          * An assertion willl be fired at run-time in debug if this is not
  96          * the case.
  97          * The relation is activated only if no controllers of this object
  98          * updated the coordinates of the child.
  99          */
 100
 101                 void
 102         SetParentRelation(
 103                 SG_ParentRelation *relation
 104         );
 105
 106         SG_ParentRelation * GetParentRelation()
 107         {
 108                 return m_parent_relation;
 109         }
 110
 111
 112
 113
 114         /**
 115          * Apply a translation relative to the current position.
 116          * if local then the translation is assumed to be in the
 117          * local coordinates of this object. If not then the translation
 118          * is assumed to be in global coordinates. In this case
 119          * you must provide a pointer to the parent of this object if it
 120          * exists otherwise if there is no parent set it to NULL
 121          */
 122
 123                 void
 124         RelativeTranslate(
 125                 const MT_Vector3& trans,
 126                 const SG_Spatial *parent,
 127                 bool local
 128         );
 129
 130         void SetLocalPosition(const MT_Point3& trans)
 131         {
 132                 m_localPosition = trans;
 133                 SetModified();
 134         }
 135
 136         void SetWorldPosition(const MT_Point3& trans)
 137         {
 138                 m_worldPosition = trans;
 139         }
 140
 141
 142                 void
 143         RelativeRotate(
 144                 const MT_Matrix3x3& rot,
 145                 bool local
 146         );
 147
 148         void SetLocalOrientation(const MT_Matrix3x3& rot)
 149         {
 150                 m_localRotation = rot;
 151                 SetModified();
 152         }
 153
 154         // rot is arrange like openGL matrix
 155         void SetLocalOrientation(const float* rot)
 156         {
 157                 m_localRotation.setValue(rot);
 158                 SetModified();
 159         }
 160
 161         void SetWorldOrientation(const MT_Matrix3x3& rot)
 162         {
 163                 m_worldRotation = rot;
 164         }
 165
 166         void RelativeScale(const MT_Vector3& scale)
 167         {
 168                 m_localScaling = m_localScaling * scale;
 169                 SetModified();
 170         }
 171
 172         void SetLocalScale(const MT_Vector3& scale)
 173         {
 174                 m_localScaling = scale;
 175                 SetModified();
 176         }
 177
 178         void SetWorldScale(const MT_Vector3& scale)
 179         {
 180                 m_worldScaling = scale;
 181         }
 182
 183         const MT_Point3& GetLocalPosition() const
 184         {
 185                 return m_localPosition;
 186         }
 187
 188         const MT_Matrix3x3& GetLocalOrientation() const
 189         {
 190                 return m_localRotation;
 191         }
 192
 193         const MT_Vector3& GetLocalScale() const
 194         {
 195                 return m_localScaling;
 196         }
 197
 198         const MT_Point3& GetWorldPosition() const
 199         {
 200                 return m_worldPosition;
 201         }
 202
 203         const MT_Matrix3x3&     GetWorldOrientation() const
 204         {
 205                 return m_worldRotation;
 206         }
 207
 208         const MT_Vector3& GetWorldScaling() const
 209         {
 210                 return m_worldScaling;
 211         }
 212
 213         void SetWorldFromLocalTransform()
 214         {
 215                 m_worldPosition= m_localPosition;
 216                 m_worldScaling= m_localScaling;
 217                 m_worldRotation= m_localRotation;
 218         }
 219
 220
 221
 222         MT_Transform GetWorldTransform() const;
 223
 224         bool    ComputeWorldTransforms(const SG_Spatial *parent, bool& parentUpdated)
 225         {
 226                 return m_parent_relation->UpdateChildCoordinates(this,parent,parentUpdated);
 227         }
 228
 229
 230         /**
 231          * Bounding box functions.
 232          */
 233         SG_BBox& BBox()
 234         {
 235                 return m_bbox;
 236         }
 237
 238         void SetBBox(SG_BBox& bbox)
 239         {
 240                 m_bbox = bbox;
 241         }
 242
 243
 244         bool inside(const MT_Point3 &point) const;
 245         void getBBox(MT_Point3 *box) const;
 246         void getAABBox(MT_Point3 *box) const;
 247
 248         MT_Scalar Radius() const { return m_radius; }
 249         void SetRadius(MT_Scalar radius) { m_radius = radius; }
 250         bool IsModified() { return m_modified; }
 251         bool IsDirty() { return m_ogldirty; }
 252
 253 protected:
 254         friend class SG_Controller;
 255         friend class KX_BoneParentRelation;
 256         friend class KX_VertexParentRelation;
 257         friend class KX_SlowParentRelation;
 258         friend class KX_NormalParentRelation;
 259
 260         /**
 261          * Protected constructor this class is not
 262          * designed for direct instantiation
 263          */
 264
 265         SG_Spatial(
 266                 void* clientobj,
 267                 void* clientinfo,
 268                 SG_Callbacks& callbacks
 269         );
 270
 271         SG_Spatial(
 272                 const SG_Spatial& other
 273         );
 274
 275
 276         virtual ~SG_Spatial();
 277
 278         /**
 279          * Update the world coordinates of this spatial node. This also informs
 280          * any controllers to update this object.
 281          */
 282
 283                 bool
 284         UpdateSpatialData(
 285                 const SG_Spatial *parent,
 286                 double time,
 287                 bool& parentUpdated
 288         );
 289
 290
 291 #ifdef WITH_CXX_GUARDEDALLOC
 292 public:
 293         void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:SG_Spatial"); }
 294         void operator delete( void *mem ) { MEM_freeN(mem); }
 295 #endif
 296 };
 297
 298 #endif //__SG_SPATIAL_H
 299