Alphabetical Class Index  Class Hierarchy   File Members   Compound Members   File List  

HBhvUtility.h
Go to the documentation of this file.
1 //
2 // Copyright (c) 2000 by Tech Soft 3D, LLC.
3 // The information contained herein is confidential and proprietary to
4 // Tech Soft 3D, LLC., and considered a trade secret as defined under
5 // civil and criminal statutes. Tech Soft 3D shall pursue its civil
6 // and criminal remedies in the event of unauthorized use or misappropriation
7 // of its trade secrets. Use of this information by anyone other than
8 // authorized employees of Tech Soft 3D, LLC. is granted only under a
9 // written non-disclosure agreement, expressly prescribing the scope and
10 // manner of such use.
11 //
12 //"Parts of HQuat Copyright (C) Jason Shankel, 2000"
13 //
14 // $Id: 8a555c15d24af72688e1fed9bd2e526d504938f6 $
15 //
16 
21 #ifndef _H_HBhvUtility_H
22 #define _H_HBhvUtility_H
23 
24 #ifdef H_PACK_8
25 #pragma pack(push)
26 #pragma pack(8)
27 #endif
28 
29 #include "HTools.h"
30 
31 #ifndef SWIG
32 #include "BStream.h"
33 #endif
34 
35 class HUtilityXMLTag;
36 class HUtilityTextParser;
37 class HBhvTimeline;
38 class HBaseModel;
39 class HStreamFileToolkit;
40 class HBaseView;
41 class HBaseModel;
42 class HBhvAnimation;
43 
44 #define BHV_MAX_NAME_LENGTH 256
45 #define BHV_MAX_VERSION_LENGTH 256
46 #define BHV_MAX_VENDOR_LENGTH 4096
47 #define BHV_MAX_TYPE_LENGTH 4096
48 
49 
56 };
57 
58 
66 };
67 
68 
75 };
76 
77 
78 
79 
81 
86 class MVO_API HQuat
87 {
88 public:
89  float x;
90  float y;
91  float z;
92  float w;
93  const HQuat &Normalize();
95  HQuat() { x=0.0f;y=0.0f;z=0.0f; w=0;};
97  HQuat(float X,float Y,float Z, float W) { x=X;y=Y;z=Z; w=W;};
99  HQuat(HQuat const *p) { x=p->x;y=p->y;z=p->z; w=p->w;};
101  HQuat(const HQuat &p) { x=p.x;y=p.y;z=p.z; w=p.w;};
102 
104  void Set(float X,float Y,float Z, float W) { x=X;y=Y;z=Z; w=W; };
105 
111  HQuat operator *(const HQuat &q2) const
112  {
113 
114  return HQuat(y*q2.z - z*q2.y + w*q2.x + x*q2.w,
115  z*q2.x - x*q2.z + w*q2.y + y*q2.w,
116  x*q2.y - y*q2.x + w*q2.z + z*q2.w,
117  w*q2.w - x*q2.x - y*q2.y - z*q2.z);
118  }
119 
125  HQuat operator *(float v) const
126  {
127  return HQuat(x*v, y*v, z*v, w*v);
128  }
129 
136  friend HQuat operator* (float v, const HQuat& q)
137  {
138  return HQuat(v*q.x,v*q.y,v*q.z, v*q.w);
139  }
140 
146  HQuat operator /(float v) const
147  {
148  return HQuat(x/v, y/v, z/v, w/v);
149  }
150  HQuat operator -(const HQuat &q2) const
156  {
157  return HQuat(x-q2.x, y-q2.y, z-q2.z, w-q2.w);
158  }
159 
165  HQuat operator +(const HQuat &q2) const
166  {
167  return HQuat(x+q2.x, y+q2.y, z+q2.z, w+q2.w);
168  }
169 
176  static HQuat Qlog(const HQuat &q);
177 
182  void ToMatrix(float matrix[16]);
183 
184 
190  static HQuat Qexp(const HQuat &q);
198  static HQuat Qlerp(const HQuat &q1,const HQuat &q2,float fraction);
206  static HQuat Qslerp(const HQuat &q1,const HQuat &q2,float fraction);
215  static HQuat QslerpNoInvert(const HQuat &q1,const HQuat &q2,float fraction);
224  static HQuat QslerpNoInvertExtraSpins(const HQuat &q1,const HQuat &q2,float fraction, int ExtraSpins);
234  static HQuat Qsquad(const HQuat &q1,const HQuat &q2,const HQuat &a,const HQuat &b,float fraction);
242  static HQuat Qspline(const HQuat &qnm1,const HQuat &qn,const HQuat &qnp1);
247  static HQuat MatrixToQuaternion(float *matrix);
248 
249 };
250 
251 
252 
254 
260 class MVO_API HKeyframe
261 {
262 public:
267  {
268  m_bConstant = false;
269  m_bEaseInOut = false;
270  }
271  virtual ~HKeyframe() {};
272 
278  virtual HKeyframe *Clone() {
279  HKeyframe *p = new HKeyframe;
280  *p = *this;
281  return p;
282  }
283 
287  virtual void Serialize(HUtilityXMLTag *xmlgen) { }
288 
294  virtual void SetConstant(bool constant) { m_bConstant = constant; }
300  virtual void SetEaseInOut(bool easeinout) { m_bEaseInOut = easeinout; }
302  virtual void SetRelative(bool relative) { m_bRelative = relative; }
303 
305  bool m_bConstant;
306  bool m_bRelative;
308 };
309 
310 
312 
315 class MVO_API HKeyframeChannel : public HKeyframe
316 {
317 public:
318 
323  {
324  m_cp.Set(0.0f,0.0f,0.0f);
325  m_type = HANIChannel;
326  }
327  virtual ~HKeyframeChannel() {};
328 
334  virtual HKeyframe *Clone ()
335  {
337  *p = *this;
338  return p;
339  }
340 
349  virtual void Interpolate(HKeyframeChannel **posarray, int keyframe, float fraction, int length, HPoint &res) { }
350 
353 };
354 
355 
356 
357 
360 {
361 public:
362 
366  HKeyframeChannelLinear(float x=0, float y=0, float z=0) : HKeyframeChannel()
367  {
368  m_channeltype = HANILinear;
369  m_cp.Set(x,y,z);
370  }
371  virtual ~HKeyframeChannelLinear() {};
372 
378  virtual HKeyframe *Clone ()
379  {
381  *p = *this;
382  return p;
383  }
384 
393  virtual void Interpolate(HKeyframeChannel **posarray, int keyframe, float fraction, int length, HPoint &res);
394 
398  virtual void Serialize(HUtilityXMLTag *xmlgen);
399 
400 };
401 
403 
407 {
408 public:
409 
413  HKeyframeChannelDiscrete(float x=0, float y=0, float z = 0) : HKeyframeChannel()
414  {
415  m_channeltype = HANIDiscrete;
416  m_cp.Set(x,y,z);
417 
418  }
419  virtual ~HKeyframeChannelDiscrete() {};
420 
426  virtual HKeyframe *Clone ()
427  {
429  *p = *this;
430  return p;
431  }
432 
443  virtual void Interpolate(HKeyframeChannel **posarray, int keyframe, float fraction, int length, HPoint &res);
444 
448  virtual void Serialize(HUtilityXMLTag *xmlgen);
449 
450 };
451 
452 
453 
455 
458 {
459 public:
460 
464  HKeyframeChannelCurve(float x = 0, float y = 0, float z = 0) : HKeyframeChannel()
465  {
466  m_channeltype = HANIHermiteSpline;
467  m_cp.Set(x,y,z);
468 
469  }
470  virtual ~HKeyframeChannelCurve() {};
471 
477  virtual HKeyframe *Clone ()
478  {
480  *p = *this;
481  return p;
482  }
483 
490  void CalculateCurveFactor(HBhvTimeline *timeline, int keyframe);
491 
500  void CalculateHermiteTangents(HPoint p0, HPoint p2, HPoint p3, float a = 0.5f);
501 
509  HPoint InterpolateHermiteSpline(float fraction, HPoint p1, HPoint p2);
510 
511 // HPoint InterpolateBezierSpline(float fraction, HPoint p2);
512 
513 
518  void CalculateCurveLength(HPoint p2);
519 
525  void DrawTangents(HPoint p2);
526 
535  virtual void Interpolate(HKeyframeChannel **posarray, int keyframe, float fraction, int length, HPoint &res);
536 
540  virtual void Serialize(HUtilityXMLTag *xmlgen);
541 
544  float m_factor1;
545  float m_factor2;
547  float ItemType;
548  float c;
549  float b;
552 };
553 
555 
560 {
561 
562 public:
563 
568  {
569  m_channeltype = HANIFollowPath;
570  m_bLinear = false;
571  }
572  virtual ~HKeyframeChannelFollowPath() {};
573 
579  virtual HKeyframe *Clone ()
580  {
582  *p = *this;
583  return p;
584  }
585 
594  virtual void Interpolate(HKeyframeChannel **posarray, int keyframe, float fraction, int length, HPoint &res);
595  virtual void Serialize(HUtilityXMLTag *xmlgen);
596 
597 // virtual void Serialize(HUtilityXMLTag *xmlgen);
598  float tmatrix[16];
599  float tmatrix2[16];
600  bool m_bLinear;
601  bool m_bNoRotate;
602 };
603 
604 
605 
606 
608 class MVO_API HKeyframeRotation : public HKeyframe
609 {
610 public:
611 
616  {
617  m_type = HANIRotation;
618  m_bLinear = false;
619  }
620  virtual ~HKeyframeRotation() {};
621 
627  virtual HKeyframe *Clone ()
628  {
630  *p = *this;
631  return p;
632  }
633 
635  bool m_bLinear;
637 };
638 
639 
640 
643 {
644 public:
645 
646 
651  HKeyframeAxisRotation(float angle = 0)
652  {
653  m_rotationtype = HANIAxisRotation;
654  m_angle = angle;
655 
656  }
657  virtual ~HKeyframeAxisRotation() {};
658 
664  virtual HKeyframe *Clone ()
665  {
667  *p = *this;
668  return p;
669 
670  }
671 
675  virtual void Serialize(HUtilityXMLTag *xmlgen);
676 
677  float m_angle;
678 };
679 
680 
682 class MVO_API HKeyframeQuatSlerp : public HKeyframeRotation
683 {
684 public:
685 
689  HKeyframeQuatSlerp(float x = 0, float y = 0, float z = 0, float w = 0)
690  {
691  m_rotationtype = HANIQuatSlerpRotation;
692  m_quat.Set(x,y,z,w);
693  }
694 
695  virtual ~HKeyframeQuatSlerp() {};
696 
702  virtual HKeyframe *Clone ()
703  {
705  *p = *this;
706  return p;
707  }
708 
710 };
711 
712 
713 
714 
716 class MVO_API HKeyframeQuatSquad : public HKeyframeRotation
717 {
718 public:
719 
720 
724  HKeyframeQuatSquad(float x = 0, float y = 0, float z = 0, float w = 0)
725  {
726  m_rotationtype = HANIQuatSquadRotation;
727  m_quat.Set(x,y,z,w);
728  m_ExtraSpins = 0;
729 
730  }
731  virtual ~HKeyframeQuatSquad() {};
732 
738  virtual HKeyframe *Clone ()
739  {
741  *p = *this;
742  return p;
743  }
744 
748  virtual void Serialize(HUtilityXMLTag *xmlgen);
749 
751  int m_ExtraSpins;
752 
753 };
754 
755 
757 class MVO_API HKeyframeMatrix : public HKeyframeRotation
758 {
759 public:
760 
761 
765  HKeyframeMatrix(float * matrix = 0)
766  {
767  m_rotationtype = HANIQuatSquadRotation;
768 
769  if (matrix)
770  {
771  for (int i=0;i<16;i++)
772  m_matrix[i] = matrix[i];
773  }
774 
775  }
776  virtual ~HKeyframeMatrix() {};
777 
783  virtual HKeyframe *Clone ()
784  {
786  *p = *this;
787  return p;
788  }
789 
793  virtual void Serialize(HUtilityXMLTag *xmlgen);
794 
795  float m_matrix[16];
796  int m_ExtraSpins;
797 
798 };
799 
800 
801 
802 
803 
805 
809 class MVO_API HKeyframeString : public HKeyframe
810 {
811 public:
812 
816  HKeyframeString();
817  virtual ~HKeyframeString() {};
818 
824  virtual HKeyframe *Clone ()
825  {
827  *p = *this;
828  return p;
829  }
830 
834  virtual void Serialize(HUtilityXMLTag *xmlgen);
835 
836 
841  void SetTarget(const char *target);
842 
845  char * GetTarget() { return m_target; }
846 
847  char m_target[MVO_BUFFER_SIZE];
848  bool m_bDiscrete;
849 
850 };
851 
852 
854 
858 class MVO_API HKeyframe3String : public HKeyframe
859 {
860 public:
861 
866  virtual ~HKeyframe3String() {};
867 
873  virtual HKeyframe *Clone ()
874  {
876  *p = *this;
877  return p;
878  }
879 
883  virtual void Serialize(HUtilityXMLTag *xmlgen);
884 
885 
890  void SetTarget(const char *t1, const char *t2, const char *t3);
891 
894  char * GetTarget1() { return m_t1; }
895  char * GetTarget2() { return m_t2; }
896  char * GetTarget3() { return m_t3; }
897 
898  char m_t1[255];
899  char m_t2[255];
900  char m_t3[255];
902 };
903 
904 
905 
906 
907 
909 
913 class MVO_API ShellMorphInfo {
914 public:
915 
919  ShellMorphInfo();
920  struct vlist_s* arrays_list;
924 };
925 
926 
927 
928 #ifndef SWIG
929 class MVO_API TK_Bhv_XML : public TK_XML
931 {
932 
933 
934 public:
935 
940  TK_Bhv_XML(HBaseModel * model) : TK_XML()
941  {
942  m_pModel = model;
943  }
944 
946  TK_Status Interpret(BStreamFileToolkit &tk, ID_Key key, int variant) alter;
948  TK_Status Execute (BStreamFileToolkit & tk) alter;
949 
950 private:
951  HBaseModel * m_pModel;
952 };
953 #endif
954 
955 
956 
958 class MVO_API HBhvUtility
959 {
960 public:
961 
967  static void GetQuatPoint(HUtilityTextParser *tp, HQuat &quat);
968  static void GetMatrix(HUtilityTextParser *tp, float *matrix);
969 
970 
976  static void GetQuatPoint(const char *text, HQuat &quat);
977 
978  static void GetMatrix(const char *text, float *matrix);
979 
980 
986  static void ConvertHSFtoMorph(const char *filename, HBaseModel *model);
987 
993  static void ConvertHSFtoSegSwitch(const char *filename, HBaseModel *model);
994 
1000  static void SetupAnimationReadFromHSF(HStreamFileToolkit *mytool, HBaseModel *model);
1001 
1007  static void SetupAnimationWriteFromHSF(HStreamFileToolkit *mytool, HBaseModel *model);
1008 
1013  static void ShowModellingMatrix(float *segment_modelling_matrix);
1014 
1015  static void MakeCameraKeyframe(HBaseView *view, float timediff, bool targetmode = false);
1016 
1017  static HBhvAnimation* AddAnimation(HBaseModel *model, char *name, char *targetpath, HPoint *pivot);
1018  static void AddPosKeyframe(HBaseModel *model, char *animname, int tick, HPoint pos, bool linear);
1019  static void AddRotKeyframe(HBaseModel *model, char *animname, int tick, HQuat pos, bool linear);
1020  static void AddPosRotKeyframe(HBaseModel *model, const char *animname, int tick, HPoint pivot, float *matrix);
1021  static void AddMatrixKeyframe(HBaseModel *model, HBhvAnimation *ani, int tick, float *matrix);
1022 
1023  static void AddPosRotKeyframe(HBaseModel *model, char *animname, int tick, HPoint pos, bool linear, HQuat quat, bool linear2);
1024  static void AddInstanceCreateKeyframe(HBaseModel *model, char *animname, int tick, char *path, char *include_path, char *color);
1025  static void AddSegmentMoveKeyframe(HBaseModel *model, HBhvAnimation *anim, int tick, char *path);
1026 
1027 
1028 
1029 
1030 
1031 private:
1032  static void Move_Segments_To_Segment(HC_KEY target, HC_KEY destination);
1033  static void AddShellToMorphList(HC_KEY key, struct vlist_s *morph_data_list);
1034  static bool KeyExists(HC_KEY key, struct vlist_s *morp_data_list);
1035  static void ResetMorphData(struct vlist_s *morp_data_list);
1036  static void CollectShellMorphData(HC_KEY key, struct vlist_s *morp_data_list);
1037  static void ClearAllAttributes(HC_KEY key);
1038  static int searchcounter;
1039 };
1040 
1041 typedef struct
1042 {
1043  HC_KEY segkey;
1044  float *matrix;
1045  HBhvAnimation *anim;
1046  HBhvAnimation *anim2;
1047  int tick;
1048  int tick2;
1049  char *path;
1051 
1052 
1053 class MVO_API HBhvSegmentTracker
1054 {
1055 public:
1057  void MakeTreeSnapshotRecursive(HC_KEY segkey, HC_KEY newsegkey, MVO_POINTER_SIZED_INT &uid);
1058  void MakeTreeSnapshot();
1059 
1060  HC_KEY m_TrackerKey;
1061  HBaseModel *m_pModel;
1062  struct vhash_s * m_NewIncludesHash;
1063 };
1064 
1066 {
1067 public:
1069 
1070  void NewFrame();
1071  void StartFrames();
1072 
1073  bool CompareMatrices(float *m1, float *m2);
1074 
1075 private:
1076  HBaseModel *m_pModel;
1077  struct vlist_s * m_Anims;
1078  struct vhash_s * m_Segments;
1079  int m_AnimCounter;
1080  int m_Tick;
1081  bool m_bFirstFrame;
1082  HBhvSegmentTracker *m_pSegmentTracker;
1083 };
1084 
1085 
1086 
1087 
1088 
1089 #ifdef H_PACK_8
1090 #pragma pack(pop)
1091 #endif
1092 
1093 #endif
1094 
1095 
1096 
HKeyframeChannel()
Definition: HBhvUtility.h:322
The HBhvTimeline class encpasulates an animation timeline.
Definition: HBhvTimeline.h:42
The HKeyframe class is the base class for all keyframe types.
Definition: HBhvUtility.h:260
The HKeyframeAxisRotation class is used for rotations around an arbitrary axis.
Definition: HBhvUtility.h:642
bool m_bConstant
Definition: HBhvUtility.h:305
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:426
The HKeyframeQuatSquad class is used for non-linear quaternion based rotation.
Definition: HBhvUtility.h:716
void Set(float X, float Y, float Z, float W)
Definition: HBhvUtility.h:104
char * GetTarget()
Definition: HBhvUtility.h:845
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:278
The HQuat class defines the data type of a Quaternion.
Definition: HBhvUtility.h:86
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:627
float w
Definition: HBhvUtility.h:92
float c
Definition: HBhvUtility.h:548
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:738
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:824
Definition: HBhvUtility.h:1053
String keyframe type.
Definition: HBhvUtility.h:54
Definition: HBhvUtility.h:1065
HQuat m_quat
Definition: HBhvUtility.h:750
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:378
HKeyframeRotation()
Definition: HBhvUtility.h:615
The HKeyframeRotation class is the base class for all rotation related keyframes. ...
Definition: HBhvUtility.h:608
#define HC_KEY
HANIRotationType
Definition: HBhvUtility.h:70
float m_angle
Definition: HBhvUtility.h:677
HQuat()
Definition: HBhvUtility.h:95
char * GetTarget1()
Definition: HBhvUtility.h:894
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:664
The HKeyframeQuatSlerp class is used for linear quaternion based rotation.
Definition: HBhvUtility.h:682
HANIKeyframeType
Definition: HBhvUtility.h:51
HPoint m_tangent2
Definition: HBhvUtility.h:543
virtual void SetEaseInOut(bool easeinout)
Definition: HBhvUtility.h:300
bool m_bRelative
Definition: HBhvUtility.h:306
HKeyframeQuatSlerp(float x=0, float y=0, float z=0, float w=0)
Definition: HBhvUtility.h:689
float y
Definition: HBhvUtility.h:90
HQuat(HQuat const *p)
Definition: HBhvUtility.h:99
HQuat m_quat
Definition: HBhvUtility.h:709
Definition: HBhvUtility.h:1041
HKeyframe()
Definition: HBhvUtility.h:266
HPoint m_cp
Definition: HBhvUtility.h:351
HKeyframeChannelCurve(float x=0, float y=0, float z=0)
Definition: HBhvUtility.h:464
HKeyframeAxisRotation(float angle=0)
Definition: HBhvUtility.h:651
HANIRotationType m_rotationtype
Definition: HBhvUtility.h:634
float x
Definition: HBhvUtility.h:89
HANIKeyframeType m_type
Definition: HBhvUtility.h:304
HPoint m_tangent1
Definition: HBhvUtility.h:542
The HKeyframeChannelDiscrete class is used for discrete interpolation of positional values...
Definition: HBhvUtility.h:406
virtual void Serialize(HUtilityXMLTag *xmlgen)
Definition: HBhvUtility.h:287
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:783
The HKeyframeString class is used for any string related keyframes.
Definition: HBhvUtility.h:858
struct vlist_s * arrays_list
Definition: HBhvUtility.h:920
virtual void Interpolate(HKeyframeChannel **posarray, int keyframe, float fraction, int length, HPoint &res)
float ItemType
Definition: HBhvUtility.h:547
HKeyframeChannelDiscrete(float x=0, float y=0, float z=0)
Definition: HBhvUtility.h:413
The HKeyframeChannelCurve class is used for spline based interpolation of positional values...
Definition: HBhvUtility.h:457
Linear quaternion rotational type.
Definition: HBhvUtility.h:72
The HBaseModel class is used to store and manage model information.
Definition: HBaseModel.h:52
float m_factor2
Definition: HBhvUtility.h:545
The HBhvUtility class contains a set of utility functions and data structures used in the behaviour c...
Definition: HBhvUtility.h:958
Rotational keyframe type.
Definition: HBhvUtility.h:53
HANIChannelType
Definition: HBhvUtility.h:60
The HPoint class is the data type of a three-dimensional point.
Definition: HGlobals.h:126
The HBaseView class defines and manages a view of model information.
Definition: HBaseView.h:337
The HKeyframeChannelLinear class is used for linear interpolation of positional values.
Definition: HBhvUtility.h:359
The ShellMorphInfo class contains vertex attribute information.
Definition: HBhvUtility.h:913
float z
Definition: HBhvUtility.h:91
Channel keyframe type.
Definition: HBhvUtility.h:52
virtual void SetConstant(bool constant)
Definition: HBhvUtility.h:294
HQuat(float X, float Y, float Z, float W)
Definition: HBhvUtility.h:97
Axis rotation type.
Definition: HBhvUtility.h:71
HKeyframeChannelFollowPath()
Definition: HBhvUtility.h:567
HC_KEY original_key
Definition: HBhvUtility.h:921
The HBhvAnimation class defines an animation.
Definition: HBhvAnimation.h:47
Euler rotation type.
Definition: HBhvUtility.h:74
bool m_bLinear
Definition: HBhvUtility.h:635
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:477
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:873
HANIChannelType m_channeltype
Definition: HBhvUtility.h:352
float b
Definition: HBhvUtility.h:549
virtual void Serialize(HUtilityXMLTag *xmlgen)
HKeyframeQuatSquad(float x=0, float y=0, float z=0, float w=0)
Definition: HBhvUtility.h:724
The HKeyframeChannelFollowPath class is used for interpolators that change orientation in relation to...
Definition: HBhvUtility.h:559
Bezier spline channel type.
Definition: HBhvUtility.h:63
HPoint * control_polygon
Definition: HBhvUtility.h:546
virtual void SetRelative(bool relative)
Definition: HBhvUtility.h:302
Follow path channel type.
Definition: HBhvUtility.h:64
virtual void Interpolate(HKeyframeChannel **posarray, int keyframe, float fraction, int length, HPoint &res)
Definition: HBhvUtility.h:349
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:702
The HKeyframeString class is used for any string related keyframes.
Definition: HBhvUtility.h:809
HC_KEY temp_key
Definition: HBhvUtility.h:922
Non-linear quaternion rotational type.
Definition: HBhvUtility.h:73
bool m_bEaseInOut
Definition: HBhvUtility.h:307
float m_curvelength
Definition: HBhvUtility.h:550
TK_Bhv_XML(HBaseModel *model)
Definition: HBhvUtility.h:940
HQuat(const HQuat &p)
Definition: HBhvUtility.h:101
HKeyframeMatrix(float *matrix=0)
Definition: HBhvUtility.h:765
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:579
The HKeyframeQuatSquad class is used for non-linear quaternion based rotation.
Definition: HBhvUtility.h:757
Linear channel type.
Definition: HBhvUtility.h:61
HKeyframeChannelLinear(float x=0, float y=0, float z=0)
Definition: HBhvUtility.h:366
String keyframe type.
Definition: HBhvUtility.h:55
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:334
Hermite spline channel type.
Definition: HBhvUtility.h:62
The HKeyframeChannel class is the base class for all channel related keyframe types.
Definition: HBhvUtility.h:315
float m_factor1
Definition: HBhvUtility.h:544
Discrete channel type.
Definition: HBhvUtility.h:65
The TK_Bhv_XML subclasses writes and reads behavior related to XML data.
Definition: HBhvUtility.h:930