doxygen: prevent GPL license block from being parsed as doxygen comment.
[blender.git] / source / gameengine / Ketsji / KX_SG_NodeRelationships.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  
31 /** \file KX_SG_NodeRelationships.h
32  *  \ingroup ketsji
33  *  \section KX_SG_NodeRelationships   
34  * This file provides common concrete implementations of 
35  * SG_ParentRelation used by the game engine. These are
36  * KX_SlowParentRelation a slow parent relationship.
37  * KX_NormalParentRelation a normal parent relationship where 
38  * orientation and position are inherited from the parent by
39  * the child.
40  * KX_VertexParentRelation only location information is 
41  * inherited by the child. 
42  */
43
44 #ifndef __KX_SG_NODERELATIONS_H__
45 #define __KX_SG_NODERELATIONS_H__
46
47 #include "SG_Spatial.h"
48 #include "SG_ParentRelation.h"
49
50 class KX_NormalParentRelation : public SG_ParentRelation
51 {
52
53 public :
54         /**
55          * Allocate and construct a new KX_NormalParentRelation
56          * on the heap.
57          */
58
59         static 
60                 KX_NormalParentRelation *
61         New(
62         );              
63
64         /** 
65          * Method inherited from KX_ParentRelation
66          */
67
68                 bool
69         UpdateChildCoordinates(
70                 SG_Spatial * child,
71                 const SG_Spatial * parent,
72                 bool& parentUpdated     
73         );
74
75         /** 
76          * Method inherited from KX_ParentRelation
77          */
78         
79                 SG_ParentRelation *
80         NewCopy(
81         );
82
83         ~KX_NormalParentRelation(
84         );
85
86 private :
87
88         KX_NormalParentRelation(
89         );
90
91
92 #ifdef WITH_CXX_GUARDEDALLOC
93 public:
94         void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:KX_NormalParentRelation"); }
95         void operator delete( void *mem ) { MEM_freeN(mem); }
96 #endif
97 };
98
99
100 class KX_VertexParentRelation : public SG_ParentRelation
101 {
102
103 public :
104
105         /**
106          * Allocate and construct a new KX_VertexParentRelation
107          * on the heap.
108          */
109
110         static 
111                 KX_VertexParentRelation *
112         New(
113         );              
114
115         /** 
116          * Method inherited from KX_ParentRelation
117          */
118
119                 bool
120         UpdateChildCoordinates(
121                 SG_Spatial * child,
122                 const SG_Spatial * parent,
123                 bool& parentUpdated     
124         );
125
126         /** 
127          * Method inherited from KX_ParentRelation
128          */
129         
130                 SG_ParentRelation *
131         NewCopy(
132         );
133
134         ~KX_VertexParentRelation(
135         );
136
137                 bool
138         IsVertexRelation(
139         ) { 
140                 return true;
141         }
142
143 private :
144
145         KX_VertexParentRelation(
146         );
147
148
149 #ifdef WITH_CXX_GUARDEDALLOC
150 public:
151         void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:KX_VertexParentRelation"); }
152         void operator delete( void *mem ) { MEM_freeN(mem); }
153 #endif
154 };
155
156
157 class KX_SlowParentRelation : public SG_ParentRelation
158 {
159
160 public :
161
162         /**
163          * Allocate and construct a new KX_VertexParentRelation
164          * on the heap.
165          */
166
167         static 
168                 KX_SlowParentRelation *
169         New(
170                 MT_Scalar relaxation
171         );              
172
173         /** 
174          * Method inherited from KX_ParentRelation
175          */
176
177                 bool
178         UpdateChildCoordinates(
179                 SG_Spatial * child,
180                 const SG_Spatial * parent,
181                 bool& parentUpdated     
182         );
183
184         /** 
185          * Method inherited from KX_ParentRelation
186          */
187         
188                 SG_ParentRelation *
189         NewCopy(
190         );
191
192                 MT_Scalar
193         GetTimeOffset(
194         ) { return m_relax; }
195         
196                 void
197         SetTimeOffset(
198                 MT_Scalar relaxation
199         ) { m_relax = relaxation; }
200
201         ~KX_SlowParentRelation(
202         );
203         
204                 bool
205         IsSlowRelation(
206         ) { 
207                 return true;
208         }
209
210 private :
211
212         KX_SlowParentRelation(
213                 MT_Scalar relaxation
214         );
215
216         // the relaxation coefficient.
217
218         MT_Scalar m_relax;
219
220         /**
221          * Looks like a hack flag to me.
222          * We need to compute valid world coordinates the first
223          * time we update spatial data of the child. This is done
224          * by just doing a normal parent relation the first time
225          * UpdateChildCoordinates is called and then doing the
226          * slow parent relation 
227          */
228
229         bool m_initialized;
230
231
232 #ifdef WITH_CXX_GUARDEDALLOC
233 public:
234         void *operator new(size_t num_bytes) { return MEM_mallocN(num_bytes, "GE:KX_SlowParentRelation"); }
235         void operator delete( void *mem ) { MEM_freeN(mem); }
236 #endif
237 };
238
239 #endif