geometry.h

MONA是为数不多的C++语言编写的一个很小的操作系统

	Quaternion		operator* (Matrix &src);
	Quaternion&		operator*=(Matrix &src);

// 係尦悢偺媡悢
	Quaternion		operator~();
// 幚悢偲偺忔彍嶼
	Quaternion		operator* (float src);
	Quaternion&		operator*=(float src);
	Quaternion		operator/ (float src);
	Quaternion&		operator/=(float src);
// 幚悢偲偺壛嶼偼丄幚悢晹偱偁傞 a 偵壛嶼偡傞偩偗側偺偱徣棯乮偟偐傕巊傢側偄乯

// *this 偺 b,c,d 傪儀僋僩儖偲偟偰丄偦偺夞傝傪 r 偩偗夞揮偡傞係尦悢傪嶌傞丅
// 夞揮偼丄嵍庤嵗昗宯偺偲偒丄儀僋僩儖偵懳偟偰嵍夞傝乮斀帪寁夞傝乯偱偁傞丅
// 傑偨丄SetRotate()傪屇傫偱傕儀僋僩儖岦偒偼曄傢傜側偄偑丄摿掕忦審壓偱屇傫偩応崌
// (b=c=d=0偺帪摍) 惓忢摦嶌偟側偄偨傔婎杮揑偵偼枅夞儀僋僩儖抣傪擖傟側偍偡丅
//	Quaternion&		SetRotate(float r);
// 儀僋僩儖抣傕摨帪偵僙僢僩偡傞丅
	Quaternion&		SetRotate(float inb,float inc,float ind,float r);
	Quaternion&		SetRotate(Vector &v,float r);
	Quaternion&		SetRotate(Quaternion &q,float r);
// SetRotate() 屻偵屇傇偲丄src 傪夞揮偝偣偨儀僋僩儖係尦悢傪曉偡丅
	Quaternion		CalcRotate(Quaternion &src);

// Matrix偲屳姺丅徻偟偔偼Matrix::SetOrientation()嶲徠
	void			SetOrientation(float x,float y,float z,float ix,float iy,float iz);
	void			SetOrientation(Vector &vz,Vector &vy);

protected:
	Quaternion&		SetRotate(float r);
	Quaternion&		operator= (Vector &src);
};

class Vector
{
public:
					Vector();
					Vector(float inx,float iny,float inz);
	virtual			~Vector();

	float			x,y,z;

	Vector&			set(float inx=0,float iny=0,float inz=0);
// 僨僶僢僌梡
	void			put();

// 朄慄偵偡傞丅 x*x + y*y + z*z == 1 偵側傞丅
	Vector&			Normal();
// 愨懳抣傪媮傔傞丅sqrt(x*x + y*y + z*z)傪曉偡
	float			Absolute();
// 2揰娫偺嫍棧傪媮傔傞
	float			Distance(Vector &src);

// 撪愊(俀儀僋僩儖偺惉偡妏搙)傪曉偡
	float			InnerProduct(Vector &src);
	float			operator*(Vector &src);
// 撪愊(佢(v1)(this)(v2)偺惉偡妏搙)傪曉偡
	float			InnerProduct(Vector &src1,Vector &src2);
// this, v1, v2 偺弴偱奜愊傪媮傔丄this偵奿擺偡傞丅
	Vector&			OuterProduct(Vector &v1,Vector &v2);
// this, v1, v2 偺弴偱奜愊傪媮傔丄寢壥偺Vector傪曉偡丅
	Vector			CalcOuterProduct(Vector &v1,Vector &v2);

	Vector&			operator= (Vector src);
// 儀僋僩儖摨巑偺壛尭嶼
	Vector			operator+ (Vector &src);
	Vector&			operator+=(Vector &src);
	Vector			operator-(Vector &src);
	Vector&			operator-=(Vector &src);
// 儀僋僩儖偲幚悢偺忔彍嶼
	Vector			operator* (float d);
	Vector&			operator*=(float d);
	Vector			operator/ (float d);
	Vector&			operator/=(float d);

// 嵗昗曄姺丅扨弮偵峴楍墘嶼傪峴偆偩偗
	Vector&			operator*=(Matrix &src);
	Vector			operator* (Matrix &src);
// 堏摦儀僋僩儖傪僐僺乕
	Vector&			operator= (Matrix &src);

// 儀僋僩儖偺僐僺乕丅幚悢晹偼愗傝幪偰
	Vector&			operator= (Quaternion &src);

// 嵗昗曄姺丅係尦悢偺妡嶼偲偼慡偔偺暿暔丅幚嵺偼 q * v * ~q 傪峴偭偰偄傞丅
// 仏仏仏梫拲堄
	Vector			operator* (Quaternion &src);
	Vector&			operator*=(Quaternion &src);

#ifdef _D3DTYPES_H_
	Vector&			operator= (D3DVECTOR src){x=src.x; y=src.y; z=src.z; return *this;};
	operator D3DVECTOR*() {return (D3DVECTOR*)this;};
#endif
};


// 峴楍丄係尦悢崿嵼偺奒憌僋儔僗偺僥僗僩儌僨儖
// 幚嵺偼係尦悢偐傜峴楍傊偺曄姺偼崅懍偵峴偊丄
// 峴楍偱弌偒傞偙偲偼偨偄偰偄係尦悢偱弌棃丄
// 峏偵4尦悢摨巑偺忔嶼偼崅懍側偨傔
// 撪晹幚憰偼偡傋偰 Quaternion + Vector 偵偟偰丄
// 戝検偺捀揰偺嵗昗墘嶼傪峴偆応崌偩偗峴楍偲捀揰偺忔嶼傪峴偆傛偆偵偟偨曽偑椙偄丅

class HierarchyQ;
class HierarchyM;
class Hierarchy
{
public:
friend class HierarchyQ;
friend class HierarchyM;
						Hierarchy(int inID=0);
	virtual				~Hierarchy();

	int					ID;

	Vector				v;		// 帺恎偺儀僋僩儖
	Vector				sv;		// 恊偐傜偺慡偰傪壛偊偨嵗昗

	int					vnum;	// 捀揰悢
	Vector				*vlist;	// 捀揰偺攝楍

	virtual void		Calc();

	virtual Hierarchy	*Search(int searchID);

// 巕嫙傪捛壛
	virtual HierarchyQ	*AddChildQ();
	virtual HierarchyM	*AddChildM();


// 婎杮揑偵堦師尦儕僗僩偱偁傞丅
// 帺暘偼巕嫙傪抦傜側偄丅偦偺偐傢傝恊傪抦偭偰偄傞偺偱嵗昗曄姺偑峴偊傞丅
// 傑偨丄恊偼儕僗僩偺拞偱帺暘傛傝慜偵偄側偗傟偽側傜側偄丅
// 偮傑傝丄憡屳偵恊偲偟偰巜偟偰偄傞峔憿偼僄儔乕偱偁傞丅
	Hierarchy			*parent,*prev,*next;

protected:
	virtual void		DoCalc(){};
	virtual void		DoCalcChild(HierarchyQ *child){};
	virtual void		DoCalcChild(HierarchyM *child){};
};

class HierarchyQ : public Hierarchy
{
public:
						HierarchyQ(int inID=0);
						~HierarchyQ();
	Quaternion			q;		// 帺恎偺曄姺
	Quaternion			sq;		// 恊偐傜偺慡偰偺曄姺傪偟偨係尦悢
protected:
	void				DoCalc();
	void				DoCalcChild(HierarchyQ *child);
	void				DoCalcChild(HierarchyM *child);
};

class HierarchyM : public Hierarchy
{
public:
						HierarchyM(int inID=0);
						~HierarchyM();
	Matrix				m;		// 帺恎偺曄姺
	Matrix				sm;		// 恊偐傜偺慡偰偺曄姺傪偟偨峴楍
protected:
	void				DoCalc();
	void				DoCalcChild(HierarchyM *child);
	void				DoCalcChild(HierarchyQ *child);
};


//撈棫娭悢
Vector CrossProduct(Vector &v1,Vector &v2);

#endif

/*
// Geometry 僒儞僾儖
int main()
{
// 係尦悢僒儞僾儖
	Quaternion q;		// 幉
	Vector v;			// 夞揮偝偣傞嵗昗揰

// (1,1,0)偺儀僋僩儖偵懳偟偰丄儀僋僩儖 v 傪嵍夞傝偵90搙夞揮偝偣傞丅
	q.set(1,1,0);		// 幉偵偡傞儀僋僩儖傪愝掕
	q.SetRotate(PI2);	// 夞揮偡傞妏搙傪愝掕
	v.set(1,0,0);		// 夞揮偝偣傞儀僋僩儖傪愝掕
	v*=q;				// 儀僋僩儖傪夞揮偝偣傞
	v.put();			// 寢壥昞帵

// 摨偠偔丄(1,1,0)偺儀僋僩儖偵懳偟偰丄儀僋僩儖 v 傪嵍夞傝偵180搙夞揮偝偣傞丅
	q.set(1,1,0);
	q.SetRotate(PI);	// 夞揮偡傞妏搙傪嵞愝掕
	v.set(1,0,0);
	v*=q;
	v.put();


// 峴楍墘嶼僒儞僾儖
	Matrix m,m2;

	m.SetYrotate(PI2);	// (z,x)暯柺偵懳偟偰丄PI2偩偗夞揮偡傞峴楍
	v.set(1,0,0);
	v*=m;				// 峴楍偲儀僋僩儖乮峀偄堄枴偱偙傟傕峴楍乯偺忔嶼
	v.put();

	m2.SetXrotate(PI2);	// (y,z)暯柺偵懳偟偰丄PI2偩偗夞揮偡傞峴楍
	m*=m2;				// 峴楍偺忔嶼
	v.set(1,0,0);
	v*=m;
	v.put();

// 峴楍 佁 係尦悢 僒儞僾儖

	m=q;				// q偲姰慡偵摨偠曄姺傪峴偆m傪惗惉丅
	v.set(1,1,1);
	v*=q;
	v.put();			// 乧嘆
	v.set(1,1,1);
	v*=m;
	v.put();			// 嘆偲摨偠寢壥偑摼傜傟傞丅

	m.SetOrientation(1,2,3, 1,1.5,1.2);
	q=m;				// m偲姰慡偵摨偠曄姺傪峴偆q傪惗惉丅
	v.set(1,1,1);
	v*=q;
	v.put();			// 乧嘇
	v.set(1,1,1);
	v*=m;
	v.put();			// 嘇偲摨偠寢壥偑摼傜傟傞丅


	return 0;
}
*/