/*==LICENSE==* CyanWorlds.com Engine - MMOG client, server and tools Copyright (C) 2011 Cyan Worlds, Inc. This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see . You can contact Cyan Worlds, Inc. by email legal@cyan.com or by snail mail at: Cyan Worlds, Inc. 14617 N Newport Hwy Mead, WA 99021 *==LICENSE==*/ #ifndef HS_EULER_inc #define HS_EULER_inc #include "hsGeometry3.h" // ////////////////////////////////////////////////////////////////////////// // EULER STUFF // See Gems IV, Ken Shoemake ////////////////////////////////////////////////////////////////////////// // /*** Order type constants, constructors, extractors ***/ /* There are 24 possible conventions, designated by: */ /* o EulAxI = axis used initially */ /* o EulPar = parity of axis permutation */ /* o EulRep = repetition of initial axis as last */ /* o EulFrm = frame from which axes are taken */ /* Axes I,J,K will be a permutation of X,Y,Z. */ /* Axis H will be either I or K, depending on EulRep. */ /* Frame S takes axes from initial static frame. */ /* If ord = (AxI=X, Par=Even, Rep=No, Frm=S), then */ /* {a,b,c,ord} means Rz(c)Ry(b)Rx(a), where Rz(c)v */ /* rotates v around Z by c radians. */ #define EulFrmS 0 #define EulFrmR 1 #define EulFrm(ord) ((unsigned)(ord)&1) #define EulRepNo 0 #define EulRepYes 1 #define EulRep(ord) (((unsigned)(ord)>>1)&1) #define EulParEven 0 #define EulParOdd 1 #define EulPar(ord) (((unsigned)(ord)>>2)&1) #define EulSafe "\000\001\002\000" #define EulNext "\001\002\000\001" #define EulAxI(ord) ((int)(EulSafe[(((unsigned)(ord)>>3)&3)])) #define EulAxJ(ord) ((int)(EulNext[EulAxI(ord)+(EulPar(ord)==EulParOdd)])) #define EulAxK(ord) ((int)(EulNext[EulAxI(ord)+(EulPar(ord)!=EulParOdd)])) #define EulAxH(ord) ((EulRep(ord)==EulRepNo)?EulAxK(ord):EulAxI(ord)) /* EulGetOrd unpacks all useful information about order simultaneously. */ #define EulGetOrd(ord,i,j,k,h,n,s,f) {unsigned o=ord;f=o&1;o>>=1;s=o&1;o>>=1;\ n=o&1;o>>=1;i=EulSafe[o&3];j=EulNext[i+n];k=EulNext[i+1-n];h=s?k:i;} /* EulOrd creates an order value between 0 and 23 from 4-tuple choices. */ #define EulOrd(i,p,r,f) (((((((i)<<1)+(p))<<1)+(r))<<1)+(f)) /* Static axes */ #define EulOrdXYZs EulOrd(X,EulParEven,EulRepNo,EulFrmS) #define EulOrdXYXs EulOrd(X,EulParEven,EulRepYes,EulFrmS) #define EulOrdXZYs EulOrd(X,EulParOdd,EulRepNo,EulFrmS) #define EulOrdXZXs EulOrd(X,EulParOdd,EulRepYes,EulFrmS) #define EulOrdYZXs EulOrd(Y,EulParEven,EulRepNo,EulFrmS) #define EulOrdYZYs EulOrd(Y,EulParEven,EulRepYes,EulFrmS) #define EulOrdYXZs EulOrd(Y,EulParOdd,EulRepNo,EulFrmS) #define EulOrdYXYs EulOrd(Y,EulParOdd,EulRepYes,EulFrmS) #define EulOrdZXYs EulOrd(Z,EulParEven,EulRepNo,EulFrmS) #define EulOrdZXZs EulOrd(Z,EulParEven,EulRepYes,EulFrmS) #define EulOrdZYXs EulOrd(Z,EulParOdd,EulRepNo,EulFrmS) #define EulOrdZYZs EulOrd(Z,EulParOdd,EulRepYes,EulFrmS) /* Rotating axes */ #define EulOrdZYXr EulOrd(X,EulParEven,EulRepNo,EulFrmR) #define EulOrdXYXr EulOrd(X,EulParEven,EulRepYes,EulFrmR) #define EulOrdYZXr EulOrd(X,EulParOdd,EulRepNo,EulFrmR) #define EulOrdXZXr EulOrd(X,EulParOdd,EulRepYes,EulFrmR) #define EulOrdXZYr EulOrd(Y,EulParEven,EulRepNo,EulFrmR) #define EulOrdYZYr EulOrd(Y,EulParEven,EulRepYes,EulFrmR) #define EulOrdZXYr EulOrd(Y,EulParOdd,EulRepNo,EulFrmR) #define EulOrdYXYr EulOrd(Y,EulParOdd,EulRepYes,EulFrmR) #define EulOrdYXZr EulOrd(Z,EulParEven,EulRepNo,EulFrmR) #define EulOrdZXZr EulOrd(Z,EulParEven,EulRepYes,EulFrmR) #define EulOrdXYZr EulOrd(Z,EulParOdd,EulRepNo,EulFrmR) #define EulOrdZYZr EulOrd(Z,EulParOdd,EulRepYes,EulFrmR) struct hsMatrix44; class hsQuat; class hsEuler { public: hsScalar fX,fY,fZ; UInt32 fOrder; hsEuler(hsScalar ai, hsScalar aj, hsScalar ah, UInt32 order) : fX(ai),fY(aj),fZ(ah),fOrder(order) {} // getters, converters void GetQuat(hsQuat* res ); void GetMatrix44(hsMatrix44* M); // setters, converters void SetFromMatrix44(const hsMatrix44* M, UInt32 order); void SetFromQuat(const hsQuat* q, UInt32 order); }; #endif // HS_EULER_inc