00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #ifndef AXIS_3_H_
00026 #define AXIS_3_H_
00027
00028 #include <Core/Primitive/Matrix34.h>
00029 #include <Core/Primitive/Vector3.h>
00030 #include <Core/Primitive/Quaternion.h>
00031
00032 namespace Lamp{
00033
00034
00035
00036
00037
00038 class Axis3{
00039 public:
00040
00041
00042
00043 Axis3() : matrix_(Matrix34::unit), quaternion_(Quaternion::identity),
00044 scale_(Vector3::unitScale), euler_(Vector3::zero),
00045 translation_(Vector3::zero),
00046 validEuler_(true), validQuaternion_(true), isChanged_(true){
00047
00048 }
00049
00050
00051
00052
00053
00054 Axis3(const Axis3& source) : matrix_(source.matrix_),
00055 quaternion_(source.quaternion_), scale_(source.scale_),
00056 euler_(source.euler_), translation_(source.translation_),
00057 validEuler_(source.validEuler_),
00058 validQuaternion_(source.validQuaternion_), isChanged_(true){
00059
00060 }
00061
00062
00063
00064
00065 virtual ~Axis3(){}
00066
00067
00068
00069
00070
00071
00072 virtual void setScale(const Vector3& scale){
00073 if(scale_ == scale){ return; }
00074 scale_ = scale;
00075 isChanged_ = true;
00076 }
00077
00078
00079
00080
00081
00082 virtual const Vector3& getScale() const{ return scale_; }
00083
00084
00085
00086
00087
00088 virtual bool isScaled() const{ return (scale_ != Vector3::unitScale); }
00089
00090
00091
00092
00093
00094
00095 virtual void setRotationXYZ(const Vector3& rotation){
00096 if(validEuler_ && (euler_ == rotation)){ return; }
00097 euler_ = rotation;
00098 validEuler_ = true;
00099 validQuaternion_ = false;
00100 isChanged_ = true;
00101 }
00102
00103
00104
00105
00106
00107 virtual const Vector3& getRotationXYZ(){
00108 if(!validEuler_){
00109 quaternion_.getRotationXYZ(&euler_);
00110 validEuler_ = true;
00111 }
00112 return euler_;
00113 }
00114
00115
00116
00117
00118
00119
00120 virtual void setRotationQuaternion(const Quaternion& rotation){
00121 if(validQuaternion_ && (quaternion_ == rotation)){ return; }
00122 quaternion_ = rotation;
00123 validEuler_ = false;
00124 validQuaternion_ = true;
00125 isChanged_ = true;
00126 }
00127
00128
00129
00130
00131
00132 virtual const Quaternion& getRotationQuaternion(){
00133 if(!validQuaternion_){
00134 quaternion_.setRotationXYZ(euler_);
00135 validQuaternion_ = true;
00136 }
00137 return quaternion_;
00138 }
00139
00140
00141
00142
00143
00144
00145 virtual void setTranslation(const Vector3& translation){
00146 if(translation_ == translation){ return; }
00147 translation_ = translation;
00148 isChanged_ = true;
00149 }
00150
00151
00152
00153
00154
00155 virtual const Vector3& getTranslation() const{ return translation_; }
00156
00157
00158
00159
00160
00161
00162 virtual bool buildMatrix(){
00163 if(isChanged_){
00164 if(validQuaternion_){
00165 matrix_.setTransformationQuaternion(
00166 scale_, quaternion_, translation_);
00167 }else{
00168 Assert(validEuler_);
00169 matrix_.setTransformationXYZ(scale_, euler_, translation_);
00170 }
00171 isChanged_ = false;
00172 return true;
00173 }
00174 return false;
00175 }
00176
00177
00178
00179
00180
00181 virtual const Matrix34& getMatrix() const{
00182 Assert(!isChanged_);
00183 return matrix_;
00184 }
00185
00186
00187
00188
00189
00190
00191 virtual bool isChanged() const{ return isChanged_; }
00192
00193
00194 protected:
00195
00196 Matrix34 matrix_;
00197
00198 Quaternion quaternion_;
00199
00200 Vector3 scale_;
00201
00202 Vector3 euler_;
00203
00204 Vector3 translation_;
00205
00206 bool validEuler_;
00207
00208 bool validQuaternion_;
00209
00210 bool isChanged_;
00211
00212 };
00213
00214
00215 }
00216 #endif // End of AXIS_3_H_
00217