HBhvUtility.h
Go to the documentation of this file.
1 // Copyright (c) Tech Soft 3D, Inc.
2 //
3 // The information contained herein is confidential and proprietary to Tech Soft 3D, Inc.,
4 // and considered a trade secret as defined under civil and criminal statutes.
5 // Tech Soft 3D, Inc. shall pursue its civil and criminal remedies in the event of
6 // unauthorized use or misappropriation of its trade secrets. Use of this information
7 // by anyone other than authorized employees of Tech Soft 3D, Inc. is granted only under
8 // a written non-disclosure agreement, expressly prescribing the scope and manner of such use.
9 
10 //"Parts of HQuat Copyright (C) Jason Shankel, 2000"
11 //
12 //
13 
18 #ifndef _H_HBhvUtility_H
19 #define _H_HBhvUtility_H
20 
21 #ifdef H_PACK_8
22 #pragma pack(push)
23 #pragma pack(8)
24 #endif
25 
26 #include "HTools.h"
27 
28 #ifndef SWIG
29 #include "BStream.h"
30 #endif
31 
32 class HUtilityXMLTag;
33 class HUtilityTextParser;
34 class HBhvTimeline;
35 class HBaseModel;
36 class HStreamFileToolkit;
37 class HBaseView;
38 class HBaseModel;
39 class HBhvAnimation;
40 
41 #define BHV_MAX_NAME_LENGTH 256
42 #define BHV_MAX_VERSION_LENGTH 256
43 #define BHV_MAX_VENDOR_LENGTH 4096
44 #define BHV_MAX_TYPE_LENGTH 4096
45 
46 
53 };
54 
55 
63 };
64 
65 
72 };
73 
74 
75 
76 
78 
83 class MVO_API HQuat
84 {
85 public:
86  float x;
87  float y;
88  float z;
89  float w;
90  const HQuat &Normalize();
92  HQuat() { x=0.0f;y=0.0f;z=0.0f; w=0;};
94  HQuat(float X,float Y,float Z, float W) { x=X;y=Y;z=Z; w=W;};
96  HQuat(HQuat const *p) { x=p->x;y=p->y;z=p->z; w=p->w;};
98  HQuat(const HQuat &p) { x=p.x;y=p.y;z=p.z; w=p.w;};
99 
101  void Set(float X,float Y,float Z, float W) { x=X;y=Y;z=Z; w=W; };
102 
108  HQuat operator *(const HQuat &q2) const
109  {
110 
111  return HQuat(y*q2.z - z*q2.y + w*q2.x + x*q2.w,
112  z*q2.x - x*q2.z + w*q2.y + y*q2.w,
113  x*q2.y - y*q2.x + w*q2.z + z*q2.w,
114  w*q2.w - x*q2.x - y*q2.y - z*q2.z);
115  }
116 
122  HQuat operator *(float v) const
123  {
124  return HQuat(x*v, y*v, z*v, w*v);
125  }
126 
133  friend HQuat operator* (float v, const HQuat& q)
134  {
135  return HQuat(v*q.x,v*q.y,v*q.z, v*q.w);
136  }
137 
143  HQuat operator /(float v) const
144  {
145  return HQuat(x/v, y/v, z/v, w/v);
146  }
147  HQuat operator -(const HQuat &q2) const
153  {
154  return HQuat(x-q2.x, y-q2.y, z-q2.z, w-q2.w);
155  }
156 
162  HQuat operator +(const HQuat &q2) const
163  {
164  return HQuat(x+q2.x, y+q2.y, z+q2.z, w+q2.w);
165  }
166 
173  static HQuat Qlog(const HQuat &q);
174 
179  void ToMatrix(float matrix[16]);
180 
181 
187  static HQuat Qexp(const HQuat &q);
195  static HQuat Qlerp(const HQuat &q1,const HQuat &q2,float fraction);
203  static HQuat Qslerp(const HQuat &q1,const HQuat &q2,float fraction);
212  static HQuat QslerpNoInvert(const HQuat &q1,const HQuat &q2,float fraction);
221  static HQuat QslerpNoInvertExtraSpins(const HQuat &q1,const HQuat &q2,float fraction, int ExtraSpins);
231  static HQuat Qsquad(const HQuat &q1,const HQuat &q2,const HQuat &a,const HQuat &b,float fraction);
239  static HQuat Qspline(const HQuat &qnm1,const HQuat &qn,const HQuat &qnp1);
244  static HQuat MatrixToQuaternion(float matrix[]);
245 
246 };
247 
248 
249 
251 
257 class MVO_API HKeyframe
258 {
259 public:
264  {
265  m_bConstant = false;
266  m_bEaseInOut = false;
267  }
268  virtual ~HKeyframe() {};
269 
275  virtual HKeyframe *Clone() {
276  HKeyframe *p = new HKeyframe;
277  *p = *this;
278  return p;
279  }
280 
284  virtual void Serialize(HUtilityXMLTag *xmlgen) {
285  UNREFERENCED(xmlgen);
286  }
287 
293  virtual void SetConstant(bool constant) { m_bConstant = constant; }
299  virtual void SetEaseInOut(bool easeinout) { m_bEaseInOut = easeinout; }
301  virtual void SetRelative(bool relative) { m_bRelative = relative; }
302 
304  bool m_bConstant;
305  bool m_bRelative;
307 };
308 
309 
311 
314 class MVO_API HKeyframeChannel : public HKeyframe
315 {
316 public:
317 
322  {
323  m_cp.Set(0.0f,0.0f,0.0f);
324  m_type = HANIChannel;
325  }
326  virtual ~HKeyframeChannel() {};
327 
333  virtual HKeyframe *Clone ()
334  {
336  *p = *this;
337  return p;
338  }
339 
348  virtual void Interpolate(HKeyframeChannel **posarray, int keyframe, float fraction, int length, HPoint &res) {
349  UNREFERENCED(posarray);
350  UNREFERENCED(keyframe);
351  UNREFERENCED(fraction);
352  UNREFERENCED(length);
353  UNREFERENCED(res);
354  }
355 
358 };
359 
360 
361 
362 
365 {
366 public:
367 
371  HKeyframeChannelLinear(float x=0, float y=0, float z=0) : HKeyframeChannel()
372  {
373  m_channeltype = HANILinear;
374  m_cp.Set(x,y,z);
375  }
376  virtual ~HKeyframeChannelLinear() {};
377 
383  virtual HKeyframe *Clone ()
384  {
386  *p = *this;
387  return p;
388  }
389 
398  virtual void Interpolate(HKeyframeChannel **posarray, int keyframe, float fraction, int length, HPoint &res);
399 
403  virtual void Serialize(HUtilityXMLTag *xmlgen);
404 
405 };
406 
408 
412 {
413 public:
414 
418  HKeyframeChannelDiscrete(float x=0, float y=0, float z = 0) : HKeyframeChannel()
419  {
420  m_channeltype = HANIDiscrete;
421  m_cp.Set(x,y,z);
422 
423  }
424  virtual ~HKeyframeChannelDiscrete() {};
425 
431  virtual HKeyframe *Clone ()
432  {
434  *p = *this;
435  return p;
436  }
437 
448  virtual void Interpolate(HKeyframeChannel **posarray, int keyframe, float fraction, int length, HPoint &res);
449 
453  virtual void Serialize(HUtilityXMLTag *xmlgen);
454 
455 };
456 
457 
458 
460 
463 {
464 public:
465 
469  HKeyframeChannelCurve(float x = 0, float y = 0, float z = 0) : HKeyframeChannel()
470  {
471  m_channeltype = HANIHermiteSpline;
472  m_cp.Set(x,y,z);
473 
474  }
475  virtual ~HKeyframeChannelCurve() {};
476 
482  virtual HKeyframe *Clone ()
483  {
485  *p = *this;
486  return p;
487  }
488 
495  void CalculateCurveFactor(HBhvTimeline *timeline, int keyframe);
496 
505  void CalculateHermiteTangents(HPoint p0, HPoint p2, HPoint p3, float a = 0.5f);
506 
514  HPoint InterpolateHermiteSpline(float fraction, HPoint p1, HPoint p2);
515 
516 // HPoint InterpolateBezierSpline(float fraction, HPoint p2);
517 
518 
523  void CalculateCurveLength(HPoint p2);
524 
530  void DrawTangents(HPoint p2);
531 
540  virtual void Interpolate(HKeyframeChannel **posarray, int keyframe, float fraction, int length, HPoint &res);
541 
545  virtual void Serialize(HUtilityXMLTag *xmlgen);
546 
549  float m_factor1;
550  float m_factor2;
552  float ItemType;
553  float c;
554  float b;
557 };
558 
560 
565 {
566 
567 public:
568 
573  {
574  m_channeltype = HANIFollowPath;
575  m_bLinear = false;
576  }
577  virtual ~HKeyframeChannelFollowPath() {};
578 
584  virtual HKeyframe *Clone ()
585  {
587  *p = *this;
588  return p;
589  }
590 
599  virtual void Interpolate(HKeyframeChannel **posarray, int keyframe, float fraction, int length, HPoint &res);
600  virtual void Serialize(HUtilityXMLTag *xmlgen);
601 
602 // virtual void Serialize(HUtilityXMLTag *xmlgen);
603  float tmatrix[16];
604  float tmatrix2[16];
605  bool m_bLinear;
606  bool m_bNoRotate;
607 };
608 
609 
610 
611 
613 class MVO_API HKeyframeRotation : public HKeyframe
614 {
615 public:
616 
621  {
622  m_type = HANIRotation;
623  m_bLinear = false;
624  }
625  virtual ~HKeyframeRotation() {};
626 
632  virtual HKeyframe *Clone ()
633  {
635  *p = *this;
636  return p;
637  }
638 
640  bool m_bLinear;
642 };
643 
644 
645 
648 {
649 public:
650 
651 
656  HKeyframeAxisRotation(float angle = 0)
657  {
658  m_rotationtype = HANIAxisRotation;
659  m_angle = angle;
660 
661  }
662  virtual ~HKeyframeAxisRotation() {};
663 
669  virtual HKeyframe *Clone ()
670  {
672  *p = *this;
673  return p;
674 
675  }
676 
680  virtual void Serialize(HUtilityXMLTag *xmlgen);
681 
682  float m_angle;
683 };
684 
685 
687 class MVO_API HKeyframeQuatSlerp : public HKeyframeRotation
688 {
689 public:
690 
694  HKeyframeQuatSlerp(float x = 0, float y = 0, float z = 0, float w = 0)
695  {
696  m_rotationtype = HANIQuatSlerpRotation;
697  m_quat.Set(x,y,z,w);
698  }
699 
700  virtual ~HKeyframeQuatSlerp() {};
701 
707  virtual HKeyframe *Clone ()
708  {
710  *p = *this;
711  return p;
712  }
713 
715 };
716 
717 
718 
719 
721 class MVO_API HKeyframeQuatSquad : public HKeyframeRotation
722 {
723 public:
724 
725 
729  HKeyframeQuatSquad(float x = 0, float y = 0, float z = 0, float w = 0)
730  {
731  m_rotationtype = HANIQuatSquadRotation;
732  m_quat.Set(x,y,z,w);
733  m_ExtraSpins = 0;
734 
735  }
736  virtual ~HKeyframeQuatSquad() {};
737 
743  virtual HKeyframe *Clone ()
744  {
746  *p = *this;
747  return p;
748  }
749 
753  virtual void Serialize(HUtilityXMLTag *xmlgen);
754 
756  int m_ExtraSpins;
757 
758 };
759 
760 
762 class MVO_API HKeyframeMatrix : public HKeyframeRotation
763 {
764 public:
765 
766 
770  HKeyframeMatrix(float matrix[] = 0)
771  {
772  m_rotationtype = HANIQuatSquadRotation;
773 
774  if (matrix)
775  {
776  for (int i=0;i<16;i++)
777  m_matrix[i] = matrix[i];
778  }
779 
780  }
781  virtual ~HKeyframeMatrix() {};
782 
788  virtual HKeyframe *Clone ()
789  {
791  *p = *this;
792  return p;
793  }
794 
798  virtual void Serialize(HUtilityXMLTag *xmlgen);
799 
800  float m_matrix[16];
801  int m_ExtraSpins;
802 
803 };
804 
805 
806 
807 
808 
810 
814 class MVO_API HKeyframeString : public HKeyframe
815 {
816 public:
817 
821  HKeyframeString();
822  virtual ~HKeyframeString() {};
823 
829  virtual HKeyframe *Clone ()
830  {
832  *p = *this;
833  return p;
834  }
835 
839  virtual void Serialize(HUtilityXMLTag *xmlgen);
840 
841 
846  void SetTarget(const char *target);
847 
850  char * GetTarget() { return m_target; }
851 
852  char m_target[MVO_BUFFER_SIZE];
853  bool m_bDiscrete;
854 
855 };
856 
857 
859 
863 class MVO_API HKeyframe3String : public HKeyframe
864 {
865 public:
866 
871  virtual ~HKeyframe3String() {};
872 
878  virtual HKeyframe *Clone ()
879  {
881  *p = *this;
882  return p;
883  }
884 
888  virtual void Serialize(HUtilityXMLTag *xmlgen);
889 
890 
895  void SetTarget(const char *t1, const char *t2, const char *t3);
896 
899  char * GetTarget1() { return m_t1; }
900  char * GetTarget2() { return m_t2; }
901  char * GetTarget3() { return m_t3; }
902 
903  char m_t1[255];
904  char m_t2[255];
905  char m_t3[255];
907 };
908 
909 
910 
911 
912 
914 
918 class MVO_API ShellMorphInfo {
919 public:
920 
924  ShellMorphInfo();
925  struct vlist_s* arrays_list;
926  HC_KEY original_key;
927  HC_KEY temp_key;
929 };
930 
931 
932 
933 #ifndef SWIG
934 class MVO_API TK_Bhv_XML : public TK_XML
936 {
937 
938 
939 public:
940 
945  TK_Bhv_XML(HBaseModel * model) : TK_XML()
946  {
947  m_pModel = model;
948  }
949 
951  TK_Status Interpret(BStreamFileToolkit &tk, ID_Key key, int variant);
953  TK_Status Execute (BStreamFileToolkit & tk);
954 
955 private:
956  HBaseModel * m_pModel;
957 };
958 #endif
959 
960 
961 
963 class MVO_API HBhvUtility
964 {
965 public:
966 
972  static void GetQuatPoint(HUtilityTextParser *tp, HQuat &quat);
973  static void GetMatrix(HUtilityTextParser *tp, float matrix[]);
974 
975 
981  static void GetQuatPoint(const char *text, HQuat &quat);
982 
983  static void GetMatrix(const char *text, float matrix[]);
984 
985 
991  static void ConvertHSFtoMorph(const char *filename, HBaseModel *model);
992 
998  static void ConvertHSFtoSegSwitch(const char *filename, HBaseModel *model);
999 
1005  static void SetupAnimationReadFromHSF(HStreamFileToolkit *mytool, HBaseModel *model);
1006 
1012  static void SetupAnimationWriteFromHSF(HStreamFileToolkit *mytool, HBaseModel *model);
1013 
1018  static void ShowModellingMatrix(float *segment_modelling_matrix);
1019 
1020  static void MakeCameraKeyframe(HBaseView *view, float timediff, bool targetmode = false);
1021 
1022  static HBhvAnimation* AddAnimation(HBaseModel *model, char *name, char *targetpath, HPoint *pivot);
1023  static void AddPosKeyframe(HBaseModel *model, char *animname, int tick, HPoint pos, bool linear);
1024  static void AddRotKeyframe(HBaseModel *model, char *animname, int tick, HQuat pos, bool linear);
1025  static void AddPosRotKeyframe(HBaseModel *model, const char *animname, int tick, HPoint pivot, float matrix[]);
1026  static void AddMatrixKeyframe(HBaseModel *model, HBhvAnimation *ani, int tick, float matrix[]);
1027 
1028  static void AddPosRotKeyframe(HBaseModel *model, char *animname, int tick, HPoint pos, bool linear, HQuat quat, bool linear2);
1029  static void AddInstanceCreateKeyframe(HBaseModel *model, char *animname, int tick, char *path, char *include_path, char *color);
1030  static void AddSegmentMoveKeyframe(HBaseModel *model, HBhvAnimation *anim, int tick, char *path);
1031 
1032 
1033 
1034 
1035 
1036 private:
1037  static void Move_Segments_To_Segment(HC_KEY target, HC_KEY destination);
1038  static void AddShellToMorphList(HC_KEY key, struct vlist_s *morph_data_list);
1039  static bool KeyExists(HC_KEY key, struct vlist_s *morp_data_list);
1040  static void ResetMorphData(struct vlist_s *morp_data_list);
1041  static void CollectShellMorphData(HC_KEY key, struct vlist_s *morp_data_list);
1042  static void ClearAllAttributes(HC_KEY key);
1043  static int searchcounter;
1044 };
1045 
1046 typedef struct
1047 {
1048  HC_KEY segkey;
1049  float *matrix;
1050  HBhvAnimation *anim;
1051  HBhvAnimation *anim2;
1052  int tick;
1053  int tick2;
1054  char *path;
1056 
1057 
1058 class MVO_API HBhvSegmentTracker
1059 {
1060 public:
1062  void MakeTreeSnapshotRecursive(HC_KEY segkey, HC_KEY newsegkey, MVO_POINTER_SIZED_INT &uid);
1063  void MakeTreeSnapshot();
1064 
1065  HC_KEY m_TrackerKey;
1066  HBaseModel *m_pModel;
1067  struct vhash_s * m_NewIncludesHash;
1068 };
1069 
1071 {
1072 public:
1074 
1075  void NewFrame();
1076  void StartFrames();
1077 
1078  bool CompareMatrices(float *m1, float *m2);
1079 
1080 private:
1081  HBaseModel *m_pModel;
1082  struct vlist_s * m_Anims;
1083  struct vhash_s * m_Segments;
1084  int m_AnimCounter;
1085  int m_Tick;
1086  bool m_bFirstFrame;
1087  HBhvSegmentTracker *m_pSegmentTracker;
1088 };
1089 
1090 
1091 
1092 
1093 
1094 #ifdef H_PACK_8
1095 #pragma pack(pop)
1096 #endif
1097 
1098 #endif
1099 
1100 
1101 
HKeyframeChannel()
Definition: HBhvUtility.h:321
The HBhvTimeline class encpasulates an animation timeline.
Definition: HBhvTimeline.h:38
The HKeyframe class is the base class for all keyframe types.
Definition: HBhvUtility.h:257
The HKeyframeAxisRotation class is used for rotations around an arbitrary axis.
Definition: HBhvUtility.h:647
bool m_bConstant
Definition: HBhvUtility.h:304
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:431
The HKeyframeQuatSquad class is used for non-linear quaternion based rotation.
Definition: HBhvUtility.h:721
void Set(float X, float Y, float Z, float W)
Definition: HBhvUtility.h:101
char * GetTarget()
Definition: HBhvUtility.h:850
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:275
The HQuat class defines the data type of a Quaternion.
Definition: HBhvUtility.h:83
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:632
float w
Definition: HBhvUtility.h:89
float c
Definition: HBhvUtility.h:553
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:743
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:829
Definition: HBhvUtility.h:1058
String keyframe type.
Definition: HBhvUtility.h:51
Definition: HBhvUtility.h:1070
HQuat m_quat
Definition: HBhvUtility.h:755
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:383
HKeyframeRotation()
Definition: HBhvUtility.h:620
The HKeyframeRotation class is the base class for all rotation related keyframes. ...
Definition: HBhvUtility.h:613
HANIRotationType
Definition: HBhvUtility.h:67
float m_angle
Definition: HBhvUtility.h:682
HQuat()
Definition: HBhvUtility.h:92
char * GetTarget1()
Definition: HBhvUtility.h:899
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:669
The HKeyframeQuatSlerp class is used for linear quaternion based rotation.
Definition: HBhvUtility.h:687
HANIKeyframeType
Definition: HBhvUtility.h:48
HPoint m_tangent2
Definition: HBhvUtility.h:548
virtual void SetEaseInOut(bool easeinout)
Definition: HBhvUtility.h:299
bool m_bRelative
Definition: HBhvUtility.h:305
HKeyframeQuatSlerp(float x=0, float y=0, float z=0, float w=0)
Definition: HBhvUtility.h:694
float y
Definition: HBhvUtility.h:87
HQuat(HQuat const *p)
Definition: HBhvUtility.h:96
HQuat m_quat
Definition: HBhvUtility.h:714
Definition: HBhvUtility.h:1046
HKeyframe()
Definition: HBhvUtility.h:263
HPoint m_cp
Definition: HBhvUtility.h:356
HKeyframeChannelCurve(float x=0, float y=0, float z=0)
Definition: HBhvUtility.h:469
HKeyframeAxisRotation(float angle=0)
Definition: HBhvUtility.h:656
HANIRotationType m_rotationtype
Definition: HBhvUtility.h:639
float x
Definition: HBhvUtility.h:86
HANIKeyframeType m_type
Definition: HBhvUtility.h:303
HPoint m_tangent1
Definition: HBhvUtility.h:547
The HKeyframeChannelDiscrete class is used for discrete interpolation of positional values...
Definition: HBhvUtility.h:411
virtual void Serialize(HUtilityXMLTag *xmlgen)
Definition: HBhvUtility.h:284
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:788
The HKeyframeString class is used for any string related keyframes.
Definition: HBhvUtility.h:863
struct vlist_s * arrays_list
Definition: HBhvUtility.h:925
virtual void Interpolate(HKeyframeChannel **posarray, int keyframe, float fraction, int length, HPoint &res)
float ItemType
Definition: HBhvUtility.h:552
HKeyframeChannelDiscrete(float x=0, float y=0, float z=0)
Definition: HBhvUtility.h:418
The HKeyframeChannelCurve class is used for spline based interpolation of positional values...
Definition: HBhvUtility.h:462
Linear quaternion rotational type.
Definition: HBhvUtility.h:69
The HBaseModel class is used to store and manage model information.
Definition: HBaseModel.h:47
float m_factor2
Definition: HBhvUtility.h:550
The HBhvUtility class contains a set of utility functions and data structures used in the behaviour c...
Definition: HBhvUtility.h:963
Rotational keyframe type.
Definition: HBhvUtility.h:50
HANIChannelType
Definition: HBhvUtility.h:57
The HPoint class is the data type of a three-dimensional point.
Definition: HGlobals.h:121
The HBaseView class defines and manages a view of model information.
Definition: HBaseView.h:332
The HKeyframeChannelLinear class is used for linear interpolation of positional values.
Definition: HBhvUtility.h:364
The ShellMorphInfo class contains vertex attribute information.
Definition: HBhvUtility.h:918
HKeyframeMatrix(float matrix[]=0)
Definition: HBhvUtility.h:770
float z
Definition: HBhvUtility.h:88
Channel keyframe type.
Definition: HBhvUtility.h:49
virtual void SetConstant(bool constant)
Definition: HBhvUtility.h:293
HQuat(float X, float Y, float Z, float W)
Definition: HBhvUtility.h:94
Axis rotation type.
Definition: HBhvUtility.h:68
HKeyframeChannelFollowPath()
Definition: HBhvUtility.h:572
HC_KEY original_key
Definition: HBhvUtility.h:926
The HBhvAnimation class defines an animation.
Definition: HBhvAnimation.h:43
Euler rotation type.
Definition: HBhvUtility.h:71
bool m_bLinear
Definition: HBhvUtility.h:640
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:482
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:878
HANIChannelType m_channeltype
Definition: HBhvUtility.h:357
float b
Definition: HBhvUtility.h:554
virtual void Serialize(HUtilityXMLTag *xmlgen)
HKeyframeQuatSquad(float x=0, float y=0, float z=0, float w=0)
Definition: HBhvUtility.h:729
The HKeyframeChannelFollowPath class is used for interpolators that change orientation in relation to...
Definition: HBhvUtility.h:564
Bezier spline channel type.
Definition: HBhvUtility.h:60
HPoint * control_polygon
Definition: HBhvUtility.h:551
virtual void SetRelative(bool relative)
Definition: HBhvUtility.h:301
Follow path channel type.
Definition: HBhvUtility.h:61
virtual void Interpolate(HKeyframeChannel **posarray, int keyframe, float fraction, int length, HPoint &res)
Definition: HBhvUtility.h:348
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:707
The HKeyframeString class is used for any string related keyframes.
Definition: HBhvUtility.h:814
HC_KEY temp_key
Definition: HBhvUtility.h:927
Non-linear quaternion rotational type.
Definition: HBhvUtility.h:70
bool m_bEaseInOut
Definition: HBhvUtility.h:306
float m_curvelength
Definition: HBhvUtility.h:555
TK_Bhv_XML(HBaseModel *model)
Definition: HBhvUtility.h:945
HQuat(const HQuat &p)
Definition: HBhvUtility.h:98
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:584
The HKeyframeQuatSquad class is used for non-linear quaternion based rotation.
Definition: HBhvUtility.h:762
Linear channel type.
Definition: HBhvUtility.h:58
HKeyframeChannelLinear(float x=0, float y=0, float z=0)
Definition: HBhvUtility.h:371
String keyframe type.
Definition: HBhvUtility.h:52
virtual HKeyframe * Clone()
Definition: HBhvUtility.h:333
Hermite spline channel type.
Definition: HBhvUtility.h:59
The HKeyframeChannel class is the base class for all channel related keyframe types.
Definition: HBhvUtility.h:314
float m_factor1
Definition: HBhvUtility.h:549
Discrete channel type.
Definition: HBhvUtility.h:62
The TK_Bhv_XML subclasses writes and reads behavior related to XML data.
Definition: HBhvUtility.h:935