Panda3D

nodePathLerps.h

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 
 All Classes Functions Variables Enumerations