Panda3D
|
00001 // Filename: nodePathLerps.h 00002 // Created by: frang (01Jun00) 00003 // 00004 //////////////////////////////////////////////////////////////////// 00005 // 00006 // PANDA 3D SOFTWARE 00007 // Copyright (c) Carnegie Mellon University. All rights reserved. 00008 // 00009 // All use of this software is subject to the terms of the revised BSD 00010 // license. You should have received a copy of this license along 00011 // with this source code in a file named "LICENSE." 00012 // 00013 //////////////////////////////////////////////////////////////////// 00014 00015 #ifndef NODEPATHLERPS_H 00016 #define NODEPATHLERPS_H 00017 00018 #include "pandabase.h" 00019 00020 #include "lerpfunctor.h" 00021 #include "nodePath.h" 00022 00023 //////////////////////////////////////////////////////////////////// 00024 // Class : PosLerpFunctor 00025 // Description : Class for Lerping between positions in space 00026 //////////////////////////////////////////////////////////////////// 00027 class EXPCL_PANDA_PGRAPH PosLerpFunctor : public LPoint3fLerpFunctor { 00028 private: 00029 NodePath _node_path; 00030 bool _is_wrt; 00031 NodePath _wrt_path; 00032 00033 PUBLISHED: 00034 PosLerpFunctor(NodePath np, LPoint3f start, LPoint3f end) 00035 : LPoint3fLerpFunctor(start, end), _node_path(np), _is_wrt(false) {} 00036 PosLerpFunctor(NodePath np, float sx, float sy, float sz, float ex, float ey, 00037 float ez) : LPoint3fLerpFunctor(LPoint3f(sx, sy, sz), 00038 LPoint3f(ex, ey, ez)), 00039 _node_path(np), _is_wrt(false) {} 00040 PosLerpFunctor(NodePath np, LPoint3f start, LPoint3f end, NodePath wrt) 00041 : LPoint3fLerpFunctor(start, end), _node_path(np), _is_wrt(true), 00042 _wrt_path(wrt) {} 00043 PosLerpFunctor(NodePath np, float sx, float sy, float sz, float ex, float ey, 00044 float ez, NodePath wrt) 00045 : LPoint3fLerpFunctor(LPoint3f(sx, sy, sz), LPoint3f(ex, ey, ez)), 00046 _node_path(np), _is_wrt(true), _wrt_path(wrt) {} 00047 00048 public: 00049 PosLerpFunctor(const PosLerpFunctor&); 00050 virtual ~PosLerpFunctor(); 00051 PosLerpFunctor& operator=(const PosLerpFunctor&); 00052 virtual void operator()(float); 00053 00054 public: 00055 // now for typehandle stuff 00056 static TypeHandle get_class_type() { 00057 return _type_handle; 00058 } 00059 static void init_type() { 00060 LPoint3fLerpFunctor::init_type(); 00061 register_type(_type_handle, "PosLerpFunctor", 00062 LPoint3fLerpFunctor::get_class_type()); 00063 } 00064 virtual TypeHandle get_type() const { 00065 return get_class_type(); 00066 } 00067 virtual TypeHandle force_init_type() { 00068 init_type(); 00069 return get_class_type(); 00070 } 00071 private: 00072 static TypeHandle _type_handle; 00073 }; 00074 00075 00076 // evil bad bad evil HPR 00077 //////////////////////////////////////////////////////////////////// 00078 // Class : HprLerpFunctor 00079 // Description : Class for Lerping between orientations in space 00080 //////////////////////////////////////////////////////////////////// 00081 class EXPCL_PANDA_PGRAPH HprLerpFunctor : public LVecBase3fLerpFunctor { 00082 private: 00083 NodePath _node_path; 00084 bool _is_wrt; 00085 NodePath _wrt_path; 00086 00087 PUBLISHED: 00088 HprLerpFunctor(NodePath np, LVecBase3f start, LVecBase3f end) 00089 : LVecBase3fLerpFunctor(start, end), _node_path(np), _is_wrt(false) {} 00090 HprLerpFunctor(NodePath np, float sx, float sy, float sz, float ex, float ey, 00091 float ez) : LVecBase3fLerpFunctor(LVecBase3f(sx, sy, sz), 00092 LVecBase3f(ex, ey, ez)), 00093 _node_path(np), _is_wrt(false) {} 00094 HprLerpFunctor(NodePath np, LVecBase3f start, LVecBase3f end, NodePath wrt) 00095 : LVecBase3fLerpFunctor(start, end), _node_path(np), _is_wrt(true), 00096 _wrt_path(wrt) {} 00097 HprLerpFunctor(NodePath np, float sx, float sy, float sz, float ex, float ey, 00098 float ez, NodePath wrt) 00099 : LVecBase3fLerpFunctor(LVecBase3f(sx, sy, sz), LVecBase3f(ex, ey, ez)), 00100 _node_path(np), _is_wrt(true), _wrt_path(wrt) {} 00101 void take_shortest(); 00102 void take_longest(); 00103 00104 public: 00105 HprLerpFunctor(const HprLerpFunctor&); 00106 virtual ~HprLerpFunctor(); 00107 HprLerpFunctor& operator=(const HprLerpFunctor&); 00108 virtual void operator()(float); 00109 00110 public: 00111 // now for typehandle stuff 00112 static TypeHandle get_class_type() { 00113 return _type_handle; 00114 } 00115 static void init_type() { 00116 LVecBase3fLerpFunctor::init_type(); 00117 register_type(_type_handle, "HprLerpFunctor", 00118 LVecBase3fLerpFunctor::get_class_type()); 00119 } 00120 virtual TypeHandle get_type() const { 00121 return get_class_type(); 00122 } 00123 virtual TypeHandle force_init_type() { 00124 init_type(); 00125 return get_class_type(); 00126 } 00127 private: 00128 static TypeHandle _type_handle; 00129 }; 00130 00131 //////////////////////////////////////////////////////////////////// 00132 // Class : ScaleLerpFunctor 00133 // Description : Class for Lerping between scales 00134 //////////////////////////////////////////////////////////////////// 00135 class EXPCL_PANDA_PGRAPH ScaleLerpFunctor : public LVecBase3fLerpFunctor { 00136 private: 00137 NodePath _node_path; 00138 bool _is_wrt; 00139 NodePath _wrt_path; 00140 00141 PUBLISHED: 00142 ScaleLerpFunctor(NodePath np, LVecBase3f start, LVecBase3f end) 00143 : LVecBase3fLerpFunctor(start, end), _node_path(np), _is_wrt(false) {} 00144 ScaleLerpFunctor(NodePath np, float sx, float sy, float sz, float ex, 00145 float ey, float ez) 00146 : LVecBase3fLerpFunctor(LVecBase3f(sx, sy, sz), LVecBase3f(ex, ey, ez)), 00147 _node_path(np), _is_wrt(false) {} 00148 ScaleLerpFunctor(NodePath np, LVecBase3f start, LVecBase3f end, NodePath wrt) 00149 : LVecBase3fLerpFunctor(start, end), _node_path(np), _is_wrt(true), 00150 _wrt_path(wrt) {} 00151 ScaleLerpFunctor(NodePath np, float sx, float sy, float sz, float ex, 00152 float ey, float ez, NodePath wrt) 00153 : LVecBase3fLerpFunctor(LVecBase3f(sx, sy, sz), LVecBase3f(ex, ey, ez)), 00154 _node_path(np), _is_wrt(true), _wrt_path(wrt) {} 00155 00156 public: 00157 ScaleLerpFunctor(const ScaleLerpFunctor&); 00158 virtual ~ScaleLerpFunctor(); 00159 ScaleLerpFunctor& operator=(const ScaleLerpFunctor&); 00160 virtual void operator()(float); 00161 00162 public: 00163 // now for typehandle stuff 00164 static TypeHandle get_class_type() { 00165 return _type_handle; 00166 } 00167 static void init_type() { 00168 LVecBase3fLerpFunctor::init_type(); 00169 register_type(_type_handle, "ScaleLerpFunctor", 00170 LVecBase3fLerpFunctor::get_class_type()); 00171 } 00172 virtual TypeHandle get_type() const { 00173 return get_class_type(); 00174 } 00175 virtual TypeHandle force_init_type() { 00176 init_type(); 00177 return get_class_type(); 00178 } 00179 private: 00180 static TypeHandle _type_handle; 00181 }; 00182 00183 //////////////////////////////////////////////////////////////////// 00184 // Class : ColorLerpFunctor 00185 // Description : Class for Lerping between colors 00186 //////////////////////////////////////////////////////////////////// 00187 class EXPCL_PANDA_PGRAPH ColorLerpFunctor : public LVecBase4fLerpFunctor { 00188 private: 00189 NodePath _node_path; 00190 bool _is_wrt; 00191 NodePath _wrt_path; 00192 00193 PUBLISHED: 00194 ColorLerpFunctor(NodePath np, LVecBase4f start, LVecBase4f end) 00195 : LVecBase4fLerpFunctor(start, end), _node_path(np), _is_wrt(false) {} 00196 ColorLerpFunctor(NodePath np, float sr, float sg, float sb, float sa, 00197 float er, float eg, float eb, float ea) : LVecBase4fLerpFunctor(LVecBase4f(sr, sg, sb, sa), 00198 LVecBase4f(er, eg, eb, ea)), _node_path(np), _is_wrt(false) {} 00199 ColorLerpFunctor(NodePath np, LVecBase4f start, LVecBase4f end, NodePath wrt) 00200 : LVecBase4fLerpFunctor(start, end), _node_path(np), _is_wrt(true), 00201 _wrt_path(wrt) {} 00202 ColorLerpFunctor(NodePath np, float sr, float sg, float sb, float sa, float er, float eg, 00203 float eb, float ea, NodePath wrt) 00204 : LVecBase4fLerpFunctor(LVecBase4f(sr, sg, sb, sa), LVecBase4f(er, eg, eb, ea)), 00205 _node_path(np), _is_wrt(true), _wrt_path(wrt) {} 00206 00207 public: 00208 ColorLerpFunctor(const ColorLerpFunctor&); 00209 virtual ~ColorLerpFunctor(); 00210 ColorLerpFunctor& operator=(const ColorLerpFunctor&); 00211 virtual void operator()(float); 00212 00213 public: 00214 // now for typehandle stuff 00215 static TypeHandle get_class_type() { 00216 return _type_handle; 00217 } 00218 static void init_type() { 00219 LVecBase4fLerpFunctor::init_type(); 00220 register_type(_type_handle, "ColorLerpFunctor", 00221 LVecBase4fLerpFunctor::get_class_type()); 00222 } 00223 virtual TypeHandle get_type() const { 00224 return get_class_type(); 00225 } 00226 virtual TypeHandle force_init_type() { 00227 init_type(); 00228 return get_class_type(); 00229 } 00230 private: 00231 static TypeHandle _type_handle; 00232 }; 00233 00234 //////////////////////////////////////////////////////////////////// 00235 // Class : PosHprLerpFunctor 00236 // Description : Class for Lerping between positions and orientations 00237 // in space 00238 //////////////////////////////////////////////////////////////////// 00239 class EXPCL_PANDA_PGRAPH PosHprLerpFunctor : public LerpFunctor { 00240 private: 00241 NodePath _node_path; 00242 LPoint3f _pstart; 00243 LPoint3f _pend; 00244 LPoint3f _pdiff_cache; 00245 LVecBase3f _hstart; 00246 LVecBase3f _hend; 00247 LVecBase3f _hdiff_cache; 00248 bool _is_wrt; 00249 NodePath _wrt_path; 00250 00251 PUBLISHED: 00252 PosHprLerpFunctor(NodePath np, LPoint3f pstart, LPoint3f pend, 00253 LVecBase3f hstart, LVecBase3f hend) 00254 : LerpFunctor(), _node_path(np), _pstart(pstart), _pend(pend), 00255 _pdiff_cache(pend-pstart), _hstart(hstart), _hend(hend), 00256 _hdiff_cache(hend-hstart), _is_wrt(false) {} 00257 PosHprLerpFunctor(NodePath np, float psx, float psy, float psz, float pex, 00258 float pey, float pez, float hsx, float hsy, float hsz, 00259 float hex, float hey, float hez) 00260 : LerpFunctor(), _node_path(np), _pstart(psx, psy, psz), 00261 _pend(pex, pey, pez), _pdiff_cache(_pend-_pstart), 00262 _hstart(hsx, hsy, hsz), _hend(hex, hey, hez), 00263 _hdiff_cache(_hend - _hstart), _is_wrt(false) {} 00264 PosHprLerpFunctor(NodePath np, LPoint3f pstart, LPoint3f pend, 00265 LVecBase3f hstart, LVecBase3f hend, NodePath wrt) 00266 : LerpFunctor(), _node_path(np), _pstart(pstart), _pend(pend), 00267 _pdiff_cache(pend-pstart), _hstart(hstart), _hend(hend), 00268 _hdiff_cache(hend-hstart), _is_wrt(true), _wrt_path(wrt) {} 00269 PosHprLerpFunctor(NodePath np, float psx, float psy, float psz, float pex, 00270 float pey, float pez, float hsx, float hsy, float hsz, 00271 float hex, float hey, float hez, NodePath wrt) 00272 : LerpFunctor(), _node_path(np), _pstart(psx, psy, psz), 00273 _pend(pex, pey, pez), _pdiff_cache(_pend-_pstart), 00274 _hstart(hsx, hsy, hsz), _hend(hex, hey, hez), 00275 _hdiff_cache(_hend - _hstart), _is_wrt(true), _wrt_path(wrt) {} 00276 void take_shortest(); 00277 void take_longest(); 00278 00279 public: 00280 PosHprLerpFunctor(const PosHprLerpFunctor&); 00281 virtual ~PosHprLerpFunctor(); 00282 PosHprLerpFunctor& operator=(const PosHprLerpFunctor&); 00283 virtual void operator()(float); 00284 00285 public: 00286 // now for typehandle stuff 00287 static TypeHandle get_class_type() { 00288 return _type_handle; 00289 } 00290 static void init_type() { 00291 LerpFunctor::init_type(); 00292 register_type(_type_handle, "PosHprLerpFunctor", 00293 LerpFunctor::get_class_type()); 00294 } 00295 virtual TypeHandle get_type() const { 00296 return get_class_type(); 00297 } 00298 virtual TypeHandle force_init_type() { 00299 init_type(); 00300 return get_class_type(); 00301 } 00302 private: 00303 static TypeHandle _type_handle; 00304 }; 00305 00306 //////////////////////////////////////////////////////////////////// 00307 // Class : HprScaleLerpFunctor 00308 // Description : Class for Lerping between orientation 00309 // and scale 00310 //////////////////////////////////////////////////////////////////// 00311 class EXPCL_PANDA_PGRAPH HprScaleLerpFunctor : public LerpFunctor { 00312 private: 00313 NodePath _node_path; 00314 LVecBase3f _hstart; 00315 LVecBase3f _hend; 00316 LVecBase3f _hdiff_cache; 00317 LVecBase3f _sstart; 00318 LVecBase3f _send; 00319 LVecBase3f _sdiff_cache; 00320 bool _is_wrt; 00321 NodePath _wrt_path; 00322 00323 PUBLISHED: 00324 HprScaleLerpFunctor(NodePath np, 00325 LVecBase3f hstart, LVecBase3f hend, LVecBase3f sstart, 00326 LVecBase3f send) 00327 : LerpFunctor(), _node_path(np), 00328 _hstart(hstart), _hend(hend), 00329 _hdiff_cache(hend-hstart), _sstart(sstart), _send(send), 00330 _sdiff_cache(send-sstart), _is_wrt(false) {} 00331 HprScaleLerpFunctor(NodePath np, float hsx, float hsy, 00332 float hsz, float hex, float hey, float hez, float ssx, 00333 float ssy, float ssz, float sex, float sey, float sez) 00334 : LerpFunctor(), _node_path(np), 00335 _hstart(hsx, hsy, hsz), _hend(hex, hey, hez), 00336 _hdiff_cache(_hend-_hstart), _sstart(ssx, ssy, ssz), 00337 _send(sex, sey, sez), _sdiff_cache(_send-_sstart), _is_wrt(false) {} 00338 HprScaleLerpFunctor(NodePath np, 00339 LVecBase3f hstart, LVecBase3f hend, LVecBase3f sstart, 00340 LVecBase3f send, NodePath wrt) 00341 : LerpFunctor(), _node_path(np), _hstart(hstart), _hend(hend), 00342 _hdiff_cache(hend-hstart), _sstart(sstart), _send(send), 00343 _sdiff_cache(send-sstart), _is_wrt(true), _wrt_path(wrt) {} 00344 HprScaleLerpFunctor(NodePath np, float hsx, float hsy, 00345 float hsz, float hex, float hey, float hez, float ssx, 00346 float ssy, float ssz, float sex, float sey, float sez, 00347 NodePath wrt) 00348 : LerpFunctor(), _node_path(np), 00349 _hstart(hsx, hsy, hsz), _hend(hex, hey, hez), 00350 _hdiff_cache(_hend-_hstart), _sstart(ssx, ssy, ssz), 00351 _send(sex, sey, sez), _sdiff_cache(_send-_sstart), _is_wrt(true), 00352 _wrt_path(wrt) {} 00353 void take_shortest(); 00354 void take_longest(); 00355 00356 public: 00357 HprScaleLerpFunctor(const HprScaleLerpFunctor&); 00358 virtual ~HprScaleLerpFunctor(); 00359 HprScaleLerpFunctor& operator=(const HprScaleLerpFunctor&); 00360 virtual void operator()(float); 00361 00362 public: 00363 // now for typehandle stuff 00364 static TypeHandle get_class_type() { 00365 return _type_handle; 00366 } 00367 static void init_type() { 00368 LerpFunctor::init_type(); 00369 register_type(_type_handle, "HprScaleLerpFunctor", 00370 LerpFunctor::get_class_type()); 00371 } 00372 virtual TypeHandle get_type() const { 00373 return get_class_type(); 00374 } 00375 virtual TypeHandle force_init_type() { 00376 init_type(); 00377 return get_class_type(); 00378 } 00379 private: 00380 static TypeHandle _type_handle; 00381 }; 00382 00383 //////////////////////////////////////////////////////////////////// 00384 // Class : PosHprScaleLerpFunctor 00385 // Description : Class for Lerping between position, orientation, 00386 // and scale 00387 //////////////////////////////////////////////////////////////////// 00388 class EXPCL_PANDA_PGRAPH PosHprScaleLerpFunctor : public LerpFunctor { 00389 private: 00390 NodePath _node_path; 00391 LPoint3f _pstart; 00392 LPoint3f _pend; 00393 LPoint3f _pdiff_cache; 00394 LVecBase3f _hstart; 00395 LVecBase3f _hend; 00396 LVecBase3f _hdiff_cache; 00397 LVecBase3f _sstart; 00398 LVecBase3f _send; 00399 LVecBase3f _sdiff_cache; 00400 bool _is_wrt; 00401 NodePath _wrt_path; 00402 00403 PUBLISHED: 00404 PosHprScaleLerpFunctor(NodePath np, LPoint3f pstart, LPoint3f pend, 00405 LVecBase3f hstart, LVecBase3f hend, LVecBase3f sstart, 00406 LVecBase3f send) 00407 : LerpFunctor(), _node_path(np), _pstart(pstart), _pend(pend), 00408 _pdiff_cache(pend-pstart), _hstart(hstart), _hend(hend), 00409 _hdiff_cache(hend-hstart), _sstart(sstart), _send(send), 00410 _sdiff_cache(send-sstart), _is_wrt(false) {} 00411 PosHprScaleLerpFunctor(NodePath np, float psx, float psy, float psz, 00412 float pex, float pey, float pez, float hsx, float hsy, 00413 float hsz, float hex, float hey, float hez, float ssx, 00414 float ssy, float ssz, float sex, float sey, float sez) 00415 : LerpFunctor(), _node_path(np), _pstart(psx, psy, psz), 00416 _pend(pex, pey, pez), _pdiff_cache(_pend-_pstart), 00417 _hstart(hsx, hsy, hsz), _hend(hex, hey, hez), 00418 _hdiff_cache(_hend-_hstart), _sstart(ssx, ssy, ssz), 00419 _send(sex, sey, sez), _sdiff_cache(_send-_sstart), _is_wrt(false) {} 00420 PosHprScaleLerpFunctor(NodePath np, LPoint3f pstart, LPoint3f pend, 00421 LVecBase3f hstart, LVecBase3f hend, LVecBase3f sstart, 00422 LVecBase3f send, NodePath wrt) 00423 : LerpFunctor(), _node_path(np), _pstart(pstart), _pend(pend), 00424 _pdiff_cache(pend-pstart), _hstart(hstart), _hend(hend), 00425 _hdiff_cache(hend-hstart), _sstart(sstart), _send(send), 00426 _sdiff_cache(send-sstart), _is_wrt(true), _wrt_path(wrt) {} 00427 PosHprScaleLerpFunctor(NodePath np, float psx, float psy, float psz, 00428 float pex, float pey, float pez, float hsx, float hsy, 00429 float hsz, float hex, float hey, float hez, float ssx, 00430 float ssy, float ssz, float sex, float sey, float sez, 00431 NodePath wrt) 00432 : LerpFunctor(), _node_path(np), _pstart(psx, psy, psz), 00433 _pend(pex, pey, pez), _pdiff_cache(_pend-_pstart), 00434 _hstart(hsx, hsy, hsz), _hend(hex, hey, hez), 00435 _hdiff_cache(_hend-_hstart), _sstart(ssx, ssy, ssz), 00436 _send(sex, sey, sez), _sdiff_cache(_send-_sstart), _is_wrt(true), 00437 _wrt_path(wrt) {} 00438 void take_shortest(); 00439 void take_longest(); 00440 00441 public: 00442 PosHprScaleLerpFunctor(const PosHprScaleLerpFunctor&); 00443 virtual ~PosHprScaleLerpFunctor(); 00444 PosHprScaleLerpFunctor& operator=(const PosHprScaleLerpFunctor&); 00445 virtual void operator()(float); 00446 00447 public: 00448 // now for typehandle stuff 00449 static TypeHandle get_class_type() { 00450 return _type_handle; 00451 } 00452 static void init_type() { 00453 LerpFunctor::init_type(); 00454 register_type(_type_handle, "PosHprScaleLerpFunctor", 00455 LerpFunctor::get_class_type()); 00456 } 00457 virtual TypeHandle get_type() const { 00458 return get_class_type(); 00459 } 00460 virtual TypeHandle force_init_type() { 00461 init_type(); 00462 return get_class_type(); 00463 } 00464 private: 00465 static TypeHandle _type_handle; 00466 }; 00467 00468 //////////////////////////////////////////////////////////////////// 00469 // Class : ColorScaleLerpFunctor 00470 // Description : Class for Lerping between color scales 00471 //////////////////////////////////////////////////////////////////// 00472 class EXPCL_PANDA_PGRAPH ColorScaleLerpFunctor : public LVecBase4fLerpFunctor { 00473 private: 00474 NodePath _node_path; 00475 bool _is_wrt; 00476 NodePath _wrt_path; 00477 00478 PUBLISHED: 00479 ColorScaleLerpFunctor(NodePath np, LVecBase4f start, LVecBase4f end) 00480 : LVecBase4fLerpFunctor(start, end), _node_path(np), _is_wrt(false) {} 00481 ColorScaleLerpFunctor(NodePath np, float sr, float sg, float sb, float sa, 00482 float er, float eg, float eb, float ea) : LVecBase4fLerpFunctor(LVecBase4f(sr, sg, sb, sa), 00483 LVecBase4f(er, eg, eb, ea)), _node_path(np), _is_wrt(false) {} 00484 ColorScaleLerpFunctor(NodePath np, LVecBase4f start, LVecBase4f end, NodePath wrt) 00485 : LVecBase4fLerpFunctor(start, end), _node_path(np), _is_wrt(true), 00486 _wrt_path(wrt) {} 00487 ColorScaleLerpFunctor(NodePath np, float sr, float sg, float sb, float sa, float er, float eg, 00488 float eb, float ea, NodePath wrt) 00489 : LVecBase4fLerpFunctor(LVecBase4f(sr, sg, sb, sa), LVecBase4f(er, eg, eb, ea)), 00490 _node_path(np), _is_wrt(true), _wrt_path(wrt) {} 00491 00492 public: 00493 ColorScaleLerpFunctor(const ColorScaleLerpFunctor&); 00494 virtual ~ColorScaleLerpFunctor(); 00495 ColorScaleLerpFunctor& operator=(const ColorScaleLerpFunctor&); 00496 virtual void operator()(float); 00497 00498 public: 00499 // now for typehandle stuff 00500 static TypeHandle get_class_type() { 00501 return _type_handle; 00502 } 00503 static void init_type() { 00504 LVecBase4fLerpFunctor::init_type(); 00505 register_type(_type_handle, "ColorScaleLerpFunctor", 00506 LVecBase4fLerpFunctor::get_class_type()); 00507 } 00508 virtual TypeHandle get_type() const { 00509 return get_class_type(); 00510 } 00511 virtual TypeHandle force_init_type() { 00512 init_type(); 00513 return get_class_type(); 00514 } 00515 private: 00516 static TypeHandle _type_handle; 00517 }; 00518 00519 #endif /* NODEPATHLERPS_H */ 00520 00521 00522 00523 00524