nel/src/3d/track.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "std3d.h"
  18
  19 #include "nel/3d/track.h"
  20
  21 #include "nel/misc/rgba.h"
  22 #include "nel/misc/hierarchical_timer.h"
  23
  24 using namespace NLMISC;
  25
  26 #ifdef DEBUG_NEW
  27 #define new DEBUG_NEW
  28 #endif
  29
  30 namespace NL3D
  31 {
  32
  33 H_AUTO_DECL( NL3D_UTrack_interpolate )
  34
  35 #define NL3D_HAUTO_UTRACK_INTERPOLATE                   H_AUTO_USE( NL3D_UTrack_interpolate )
  36
  37
  38 // ***************************************************************************
  39
  40 /*
  41 // Some compilation check: force Visual to compile to template
  42 CTrackDefaultFloat ttoto10;
  43 CTrackDefaultVector ttoto11;
  44 CTrackDefaultQuat ttoto12;
  45 CTrackDefaultInt ttoto13;
  46 CTrackDefaultRGBA ttoto16;
  47 CTrackDefaultString ttoto14;
  48 CTrackDefaultBool ttoto15;
  49 */
  50
  51 // ***************************************************************************
  52 static CAnimatedValueBlock              AnimatedValueBlock;
  53
  54 // ***************************************************************************
  55
  56 bool ITrack::interpolate (TAnimationTime time, float& res)
  57 {
  58         NL3D_HAUTO_UTRACK_INTERPOLATE;
  59
  60         // Evaluate it
  61         const CAnimatedValueFloat *value;
  62         value= dynamic_cast<const CAnimatedValueFloat*>(&eval (time, AnimatedValueBlock));
  63
  64         // Type is good ?
  65         if (value)
  66         {
  67                 // Ok, return the value
  68                 res=value->Value;
  69                 return true;
  70         }
  71         else
  72                 // No, return false
  73                 return false;
  74 }
  75
  76 // ***************************************************************************
  77
  78 bool ITrack::interpolate (TAnimationTime time, sint32& res)
  79 {
  80         NL3D_HAUTO_UTRACK_INTERPOLATE;
  81
  82         // Evaluate it
  83         const CAnimatedValueInt *value;
  84         value= dynamic_cast<const CAnimatedValueInt*>(&eval (time, AnimatedValueBlock));
  85
  86         // Type is good ?
  87         if (value)
  88         {
  89                 // Ok, return the value
  90                 res=value->Value;
  91                 return true;
  92         }
  93         else
  94                 // No, return false
  95                 return false;
  96 }
  97
  98 // ***************************************************************************
  99
 100 bool ITrack::interpolate (TAnimationTime time, CRGBA& res)
 101 {
 102         NL3D_HAUTO_UTRACK_INTERPOLATE;
 103
 104         // Evaluate it
 105         const CAnimatedValueRGBA *value;
 106         value= dynamic_cast<const CAnimatedValueRGBA*>(&eval (time, AnimatedValueBlock));
 107
 108         // Type is good ?
 109         if (value)
 110         {
 111                 // Ok, return the value
 112                 res=value->Value;
 113                 return true;
 114         }
 115         else
 116                 // No, return false
 117                 return false;
 118 }
 119
 120 // ***************************************************************************
 121
 122 bool ITrack::interpolate (TAnimationTime time, CVector& res)
 123 {
 124         NL3D_HAUTO_UTRACK_INTERPOLATE;
 125
 126         // Evaluate it
 127         const CAnimatedValueVector *value;
 128         value= dynamic_cast<const CAnimatedValueVector*>(&eval (time, AnimatedValueBlock));
 129
 130         // Type is good ?
 131         if (value)
 132         {
 133                 // Ok, return the value
 134                 res=value->Value;
 135                 return true;
 136         }
 137         else
 138                 // No, return false
 139                 return false;
 140 }
 141
 142 // ***************************************************************************
 143
 144 bool ITrack::interpolate (TAnimationTime time, CQuat& res)
 145 {
 146         NL3D_HAUTO_UTRACK_INTERPOLATE;
 147
 148         // Evaluate it
 149         const CAnimatedValueQuat *value;
 150         value= dynamic_cast<const CAnimatedValueQuat*>(&eval (time, AnimatedValueBlock));
 151
 152         // Type is good ?
 153         if (value)
 154         {
 155                 // Ok, return the value
 156                 res=value->Value;
 157                 return true;
 158         }
 159         else
 160                 // No, return false
 161                 return false;
 162 }
 163
 164 // ***************************************************************************
 165
 166 bool ITrack::interpolate (TAnimationTime time, std::string& res)
 167 {
 168         NL3D_HAUTO_UTRACK_INTERPOLATE;
 169
 170         // Evaluate it
 171         const CAnimatedValueString *value;
 172         value= dynamic_cast<const CAnimatedValueString*>(&eval (time, AnimatedValueBlock));
 173
 174         // Type is good ?
 175         if (value)
 176         {
 177                 // Ok, return the value
 178                 res=value->Value;
 179                 return true;
 180         }
 181         else
 182                 // No, return false
 183                 return false;
 184 }
 185
 186 // ***************************************************************************
 187
 188 bool ITrack::interpolate (TAnimationTime time, bool& res)
 189 {
 190         NL3D_HAUTO_UTRACK_INTERPOLATE;
 191
 192         // Evaluate it
 193         const CAnimatedValueBool *value;
 194         value= dynamic_cast<const CAnimatedValueBool*>(&eval (time, AnimatedValueBlock));
 195
 196         // Type is good ?
 197         if (value)
 198         {
 199                 // Ok, return the value
 200                 res=value->Value;
 201                 return true;
 202         }
 203         else
 204                 // No, return false
 205                 return false;
 206 }
 207
 208 // ***************************************************************************
 209
 210 } // NL3D