source/gameengine/Ketsji/KX_SG_NodeRelationships.h

   1 /**
   2  * @mainpage KX_SG_NodeRelationships
   3
   4  * @section
   5  *
   6  * This file provides common concrete implementations of
   7  * SG_ParentRelation used by the game engine. These are
   8  * KX_SlowParentRelation a slow parent relationship.
   9  * KX_NormalParentRelation a normal parent relationship where
  10  * orientation and position are inherited from the parent by
  11  * the child.
  12  * KX_VertexParentRelation only location information is
  13  * inherited by the child.
  14  *
  15  * interface
  16  *
  17  * $Id$
  18  *
  19  * ***** BEGIN GPL LICENSE BLOCK *****
  20  *
  21  * This program is free software; you can redistribute it and/or
  22  * modify it under the terms of the GNU General Public License
  23  * as published by the Free Software Foundation; either version 2
  24  * of the License, or (at your option) any later version.
  25  *
  26  * This program is distributed in the hope that it will be useful,
  27  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  28  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  29  * GNU General Public License for more details.
  30  *
  31  * You should have received a copy of the GNU General Public License
  32  * along with this program; if not, write to the Free Software Foundation,
  33  * Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  34  *
  35  * The Original Code is Copyright (C) 2001-2002 by NaN Holding BV.
  36  * All rights reserved.
  37  *
  38  * The Original Code is: all of this file.
  39  *
  40  * Contributor(s): none yet.
  41  *
  42  * ***** END GPL LICENSE BLOCK *****
  43  *
  44  */
  45
  46 #ifndef __KX_SG_NODERELATIONS_H__
  47 #define __KX_SG_NODERELATIONS_H__
  48
  49 #include "SG_Spatial.h"
  50 #include "SG_ParentRelation.h"
  51
  52 class KX_NormalParentRelation : public SG_ParentRelation
  53 {
  54
  55 public :
  56
  57         /**
  58          * Allocate and construct a new KX_NormalParentRelation
  59          * on the heap.
  60          */
  61
  62         static
  63                 KX_NormalParentRelation *
  64         New(
  65         );
  66
  67         /**
  68          * Method inherited from KX_ParentRelation
  69          */
  70
  71                 bool
  72         UpdateChildCoordinates(
  73                 SG_Spatial * child,
  74                 const SG_Spatial * parent
  75         );
  76
  77         /**
  78          * Method inherited from KX_ParentRelation
  79          */
  80
  81                 SG_ParentRelation *
  82         NewCopy(
  83         );
  84
  85         ~KX_NormalParentRelation(
  86         );
  87
  88 private :
  89
  90         KX_NormalParentRelation(
  91         );
  92
  93 };
  94
  95
  96 class KX_VertexParentRelation : public SG_ParentRelation
  97 {
  98
  99 public :
 100
 101         /**
 102          * Allocate and construct a new KX_VertexParentRelation
 103          * on the heap.
 104          */
 105
 106         static
 107                 KX_VertexParentRelation *
 108         New(
 109         );
 110
 111         /**
 112          * Method inherited from KX_ParentRelation
 113          */
 114
 115                 bool
 116         UpdateChildCoordinates(
 117                 SG_Spatial * child,
 118                 const SG_Spatial * parent
 119         );
 120
 121         /**
 122          * Method inherited from KX_ParentRelation
 123          */
 124
 125                 SG_ParentRelation *
 126         NewCopy(
 127         );
 128
 129         ~KX_VertexParentRelation(
 130         );
 131
 132                 bool
 133         IsVertexRelation(
 134         ) {
 135                 return true;
 136         }
 137
 138 private :
 139
 140         KX_VertexParentRelation(
 141         );
 142
 143 };
 144
 145
 146 class KX_SlowParentRelation : public SG_ParentRelation
 147 {
 148
 149 public :
 150
 151         /**
 152          * Allocate and construct a new KX_VertexParentRelation
 153          * on the heap.
 154          */
 155
 156         static
 157                 KX_SlowParentRelation *
 158         New(
 159                 MT_Scalar relaxation
 160         );
 161
 162         /**
 163          * Method inherited from KX_ParentRelation
 164          */
 165
 166                 bool
 167         UpdateChildCoordinates(
 168                 SG_Spatial * child,
 169                 const SG_Spatial * parent
 170         );
 171
 172         /**
 173          * Method inherited from KX_ParentRelation
 174          */
 175
 176                 SG_ParentRelation *
 177         NewCopy(
 178         );
 179
 180                 MT_Scalar
 181         GetTimeOffset(
 182         ) { return m_relax; }
 183
 184                 void
 185         SetTimeOffset(
 186                 MT_Scalar relaxation
 187         ) { m_relax = relaxation; }
 188
 189         ~KX_SlowParentRelation(
 190         );
 191
 192                 bool
 193         IsSlowRelation(
 194         ) {
 195                 return true;
 196         }
 197
 198 private :
 199
 200         KX_SlowParentRelation(
 201                 MT_Scalar relaxation
 202         );
 203
 204         // the relaxation coefficient.
 205
 206         MT_Scalar m_relax;
 207
 208         /**
 209          * Looks like a hack flag to me.
 210          * We need to compute valid world coordinates the first
 211          * time we update spatial data of the child. This is done
 212          * by just doing a normal parent relation the first time
 213          * UpdateChildCoordinates is called and then doing the
 214          * slow parent relation
 215          */
 216
 217         bool m_initialized;
 218
 219 };
 220
 221 #endif