1 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
2 /**
3  *	Contains code for 3D vectors.
4  *	\file		IcePoint.h
5  *	\author		Pierre Terdiman
6  *	\date		April, 4, 2000
7  */
8 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
9 
10 ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
11 // Include Guard
12 #ifndef __ICEPOINT_H__
13 #define __ICEPOINT_H__
14 
15 	// Forward declarations
16 	class HPoint;
17 	class Plane;
18 	class Matrix3x3;
19 	class Matrix4x4;
20 
21 	#define CROSS2D(a, b)	(a.x*b.y - b.x*a.y)
22 
23 	const float EPSILON2 = 1.0e-20f;
24 
25 	class ICEMATHS_API Point
26 	{
27 		public:
28 
29 		//! Empty constructor
Point()30 		inline_					Point()														{}
31 		//! Constructor from a single float
32 //		inline_					Point(float val) : x(val), y(val), z(val)					{}
33 // Removed since it introduced the nasty "Point T = *Matrix4x4.GetTrans();" bug.......
34 		//! Constructor from floats
Point(float xx,float yy,float zz)35 		inline_					Point(float xx, float yy, float zz) : x(xx), y(yy), z(zz)	{}
36 		//! Constructor from array
Point(const float f[3])37 		inline_					Point(const float f[3]) : x(f[X]), y(f[Y]), z(f[Z])		{}
38 		//! Copy constructor
Point(const Point & p)39 		inline_					Point(const Point& p) : x(p.x), y(p.y), z(p.z)				{}
40 		//! Destructor
~Point()41 		inline_					~Point()													{}
42 
43 		//! Clears the vector
Zero()44 		inline_	Point&			Zero()									{ x =			y =			z = 0.0f;			return *this;	}
45 
46 		//! + infinity
SetPlusInfinity()47 		inline_	Point&			SetPlusInfinity()						{ x =			y =			z = MAX_FLOAT;		return *this;	}
48 		//! - infinity
SetMinusInfinity()49 		inline_	Point&			SetMinusInfinity()						{ x =			y =			z = MIN_FLOAT;		return *this;	}
50 
51 		//! Sets positive unit random vector
52 				Point&			PositiveUnitRandomVector();
53 		//! Sets unit random vector
54 				Point&			UnitRandomVector();
55 
56 		//! Assignment from values
Set(float xx,float yy,float zz)57 		inline_	Point&			Set(float xx, float yy, float zz)		{ x  = xx;		y  = yy;	z  = zz;			return *this;	}
58 		//! Assignment from array
Set(const float f[3])59 		inline_	Point&			Set(const float f[3])					{ x  = f[X];	y  = f[Y];	z  = f[Z];			return *this;	}
60 		//! Assignment from another point
Set(const Point & src)61 		inline_	Point&			Set(const Point& src)					{ x  = src.x;	y  = src.y;	z  = src.z;			return *this;	}
62 
63 		//! Adds a vector
Add(const Point & p)64 		inline_	Point&			Add(const Point& p)						{ x += p.x;		y += p.y;	z += p.z;			return *this;	}
65 		//! Adds a vector
Add(float xx,float yy,float zz)66 		inline_	Point&			Add(float xx, float yy, float zz)		{ x += xx;		y += yy;	z += zz;			return *this;	}
67 		//! Adds a vector
Add(const float f[3])68 		inline_	Point&			Add(const float f[3])					{ x += f[X];	y += f[Y];	z += f[Z];			return *this;	}
69 		//! Adds vectors
Add(const Point & p,const Point & q)70 		inline_	Point&			Add(const Point& p, const Point& q)		{ x = p.x+q.x;	y = p.y+q.y;	z = p.z+q.z;	return *this;	}
71 
72 		//! Subtracts a vector
Sub(const Point & p)73 		inline_	Point&			Sub(const Point& p)						{ x -= p.x;		y -= p.y;	z -= p.z;			return *this;	}
74 		//! Subtracts a vector
Sub(float xx,float yy,float zz)75 		inline_	Point&			Sub(float xx, float yy, float zz)		{ x -= xx;		y -= yy;	z -= zz;			return *this;	}
76 		//! Subtracts a vector
Sub(const float f[3])77 		inline_	Point&			Sub(const float f[3])					{ x -= f[X];	y -= f[Y];	z -= f[Z];			return *this;	}
78 		//! Subtracts vectors
Sub(const Point & p,const Point & q)79 		inline_	Point&			Sub(const Point& p, const Point& q)		{ x = p.x-q.x;	y = p.y-q.y;	z = p.z-q.z;	return *this;	}
80 
81 		//! this = -this
Neg()82 		inline_	Point&			Neg()									{ x = -x;		y = -y;			z = -z;			return *this;	}
83 		//! this = -a
Neg(const Point & a)84 		inline_	Point&			Neg(const Point& a)						{ x = -a.x;		y = -a.y;		z = -a.z;		return *this;	}
85 
86 		//! Multiplies by a scalar
Mult(float s)87 		inline_	Point&			Mult(float s)							{ x *= s;		y *= s;		z *= s;				return *this;	}
88 
89 		//! this = a * scalar
Mult(const Point & a,float scalar)90 		inline_	Point&			Mult(const Point& a, float scalar)
91 								{
92 									x = a.x * scalar;
93 									y = a.y * scalar;
94 									z = a.z * scalar;
95 									return *this;
96 								}
97 
98 		//! this = a + b * scalar
Mac(const Point & a,const Point & b,float scalar)99 		inline_	Point&			Mac(const Point& a, const Point& b, float scalar)
100 								{
101 									x = a.x + b.x * scalar;
102 									y = a.y + b.y * scalar;
103 									z = a.z + b.z * scalar;
104 									return *this;
105 								}
106 
107 		//! this = this + a * scalar
Mac(const Point & a,float scalar)108 		inline_	Point&			Mac(const Point& a, float scalar)
109 								{
110 									x += a.x * scalar;
111 									y += a.y * scalar;
112 									z += a.z * scalar;
113 									return *this;
114 								}
115 
116 		//! this = a - b * scalar
Msc(const Point & a,const Point & b,float scalar)117 		inline_	Point&			Msc(const Point& a, const Point& b, float scalar)
118 								{
119 									x = a.x - b.x * scalar;
120 									y = a.y - b.y * scalar;
121 									z = a.z - b.z * scalar;
122 									return *this;
123 								}
124 
125 		//! this = this - a * scalar
Msc(const Point & a,float scalar)126 		inline_	Point&			Msc(const Point& a, float scalar)
127 								{
128 									x -= a.x * scalar;
129 									y -= a.y * scalar;
130 									z -= a.z * scalar;
131 									return *this;
132 								}
133 
134 		//! this = a + b * scalarb + c * scalarc
Mac2(const Point & a,const Point & b,float scalarb,const Point & c,float scalarc)135 		inline_	Point&			Mac2(const Point& a, const Point& b, float scalarb, const Point& c, float scalarc)
136 								{
137 									x = a.x + b.x * scalarb + c.x * scalarc;
138 									y = a.y + b.y * scalarb + c.y * scalarc;
139 									z = a.z + b.z * scalarb + c.z * scalarc;
140 									return *this;
141 								}
142 
143 		//! this = a - b * scalarb - c * scalarc
Msc2(const Point & a,const Point & b,float scalarb,const Point & c,float scalarc)144 		inline_	Point&			Msc2(const Point& a, const Point& b, float scalarb, const Point& c, float scalarc)
145 								{
146 									x = a.x - b.x * scalarb - c.x * scalarc;
147 									y = a.y - b.y * scalarb - c.y * scalarc;
148 									z = a.z - b.z * scalarb - c.z * scalarc;
149 									return *this;
150 								}
151 
152 		//! this = mat * a
153 		inline_	Point&			Mult(const Matrix3x3& mat, const Point& a);
154 
155 		//! this = mat1 * a1 + mat2 * a2
156 		inline_	Point&			Mult2(const Matrix3x3& mat1, const Point& a1, const Matrix3x3& mat2, const Point& a2);
157 
158 		//! this = this + mat * a
159 		inline_	Point&			Mac(const Matrix3x3& mat, const Point& a);
160 
161 		//! this = transpose(mat) * a
162 		inline_	Point&			TransMult(const Matrix3x3& mat, const Point& a);
163 
164 		//! Linear interpolate between two vectors: this = a + t * (b - a)
Lerp(const Point & a,const Point & b,float t)165 		inline_	Point&			Lerp(const Point& a, const Point& b, float t)
166 								{
167 									x = a.x + t * (b.x - a.x);
168 									y = a.y + t * (b.y - a.y);
169 									z = a.z + t * (b.z - a.z);
170 									return *this;
171 								}
172 
173 		//! Hermite interpolate between p1 and p2. p0 and p3 are used for finding gradient at p1 and p2.
174 		//! this =	p0 * (2t^2 - t^3 - t)/2
175 		//!			+ p1 * (3t^3 - 5t^2 + 2)/2
176 		//!			+ p2 * (4t^2 - 3t^3 + t)/2
177 		//!			+ p3 * (t^3 - t^2)/2
Herp(const Point & p0,const Point & p1,const Point & p2,const Point & p3,float t)178 		inline_	Point&			Herp(const Point& p0, const Point& p1, const Point& p2, const Point& p3, float t)
179 								{
180 									float t2 = t * t;
181 									float t3 = t2 * t;
182 									float kp0 = (2.0f * t2 - t3 - t) * 0.5f;
183 									float kp1 = (3.0f * t3 - 5.0f * t2 + 2.0f) * 0.5f;
184 									float kp2 = (4.0f * t2 - 3.0f * t3 + t) * 0.5f;
185 									float kp3 = (t3 - t2) * 0.5f;
186 									x = p0.x * kp0 + p1.x * kp1 + p2.x * kp2 + p3.x * kp3;
187 									y = p0.y * kp0 + p1.y * kp1 + p2.y * kp2 + p3.y * kp3;
188 									z = p0.z * kp0 + p1.z * kp1 + p2.z * kp2 + p3.z * kp3;
189 									return *this;
190 								}
191 
192 		//! this = rotpos * r + linpos
193 		inline_	Point&			Transform(const Point& r, const Matrix3x3& rotpos, const Point& linpos);
194 
195 		//! this = trans(rotpos) * (r - linpos)
196 		inline_	Point&			InvTransform(const Point& r, const Matrix3x3& rotpos, const Point& linpos);
197 
198 		//! Returns MIN(x, y, z);
Min()199 		inline_	float			Min()				const		{ return MIN(x, MIN(y, z));												}
200 		//! Returns MAX(x, y, z);
Max()201 		inline_	float			Max()				const		{ return MAX(x, MAX(y, z));												}
202 		//! Sets each element to be componentwise minimum
Min(const Point & p)203 		inline_	Point&			Min(const Point& p)				{ x = MIN(x, p.x); y = MIN(y, p.y); z = MIN(z, p.z);	return *this;	}
204 		//! Sets each element to be componentwise maximum
Max(const Point & p)205 		inline_	Point&			Max(const Point& p)				{ x = MAX(x, p.x); y = MAX(y, p.y); z = MAX(z, p.z);	return *this;	}
206 
207 		//! Clamps each element
Clamp(float min,float max)208 		inline_	Point&			Clamp(float min, float max)
209 								{
210 									if(x<min)	x=min;	if(x>max)	x=max;
211 									if(y<min)	y=min;	if(y>max)	y=max;
212 									if(z<min)	z=min;	if(z>max)	z=max;
213 									return *this;
214 								}
215 
216 		//! Computes square magnitude
SquareMagnitude()217 		inline_	float			SquareMagnitude()	const		{ return x*x + y*y + z*z;												}
218 		//! Computes magnitude
Magnitude()219 		inline_	float			Magnitude()			const		{ return sqrtf(x*x + y*y + z*z);										}
220 		//! Computes volume
Volume()221 		inline_	float			Volume()			const		{ return x * y * z;														}
222 
223 		//! Checks the point is near zero
ApproxZero()224 		inline_	bool			ApproxZero()		const		{ return SquareMagnitude() < EPSILON2;									}
225 
226 		//! Tests for exact zero vector
IsZero()227 		inline_	BOOL			IsZero()			const
228 								{
229 									if(IR(x) || IR(y) || IR(z))	return FALSE;
230 									return TRUE;
231 								}
232 
233 		//! Checks point validity
IsValid()234 		inline_	BOOL			IsValid()			const
235 								{
236 									if(!IsValidFloat(x))	return FALSE;
237 									if(!IsValidFloat(y))	return FALSE;
238 									if(!IsValidFloat(z))	return FALSE;
239 									return TRUE;
240 								}
241 
242 		//! Slighty moves the point
Tweak(udword coord_mask,udword tweak_mask)243 				void			Tweak(udword coord_mask, udword tweak_mask)
244 								{
245 									if(coord_mask&1)	{ udword Dummy = IR(x);	Dummy^=tweak_mask;	x = FR(Dummy); }
246 									if(coord_mask&2)	{ udword Dummy = IR(y);	Dummy^=tweak_mask;	y = FR(Dummy); }
247 									if(coord_mask&4)	{ udword Dummy = IR(z);	Dummy^=tweak_mask;	z = FR(Dummy); }
248 								}
249 
250 		#define TWEAKMASK		0x3fffff
251 		#define TWEAKNOTMASK	~TWEAKMASK
252 		//! Slighty moves the point out
TweakBigger()253 		inline_	void			TweakBigger()
254 								{
255 									udword	Dummy = (IR(x)&TWEAKNOTMASK);	if(!IS_NEGATIVE_FLOAT(x))	Dummy+=TWEAKMASK+1;	x = FR(Dummy);
256 											Dummy = (IR(y)&TWEAKNOTMASK);	if(!IS_NEGATIVE_FLOAT(y))	Dummy+=TWEAKMASK+1;	y = FR(Dummy);
257 											Dummy = (IR(z)&TWEAKNOTMASK);	if(!IS_NEGATIVE_FLOAT(z))	Dummy+=TWEAKMASK+1;	z = FR(Dummy);
258 								}
259 
260 		//! Slighty moves the point in
TweakSmaller()261 		inline_	void			TweakSmaller()
262 								{
263 									udword	Dummy = (IR(x)&TWEAKNOTMASK);	if(IS_NEGATIVE_FLOAT(x))	Dummy+=TWEAKMASK+1;	x = FR(Dummy);
264 											Dummy = (IR(y)&TWEAKNOTMASK);	if(IS_NEGATIVE_FLOAT(y))	Dummy+=TWEAKMASK+1;	y = FR(Dummy);
265 											Dummy = (IR(z)&TWEAKNOTMASK);	if(IS_NEGATIVE_FLOAT(z))	Dummy+=TWEAKMASK+1;	z = FR(Dummy);
266 								}
267 
268 		//! Normalizes the vector
Normalize()269 		inline_	Point&			Normalize()
270 								{
271 									float M = x*x + y*y + z*z;
272 									if(M)
273 									{
274 										M = 1.0f / sqrtf(M);
275 										x *= M;
276 										y *= M;
277 										z *= M;
278 									}
279 									return *this;
280 								}
281 
282 		//! Sets vector length
SetLength(float length)283 		inline_	Point&			SetLength(float length)
284 								{
285 									float NewLength = length / Magnitude();
286 									x *= NewLength;
287 									y *= NewLength;
288 									z *= NewLength;
289 									return *this;
290 								}
291 
292 		//! Clamps vector length
ClampLength(float limit_length)293 		inline_	Point&			ClampLength(float limit_length)
294 								{
295 									if(limit_length>=0.0f)	// Magnitude must be positive
296 									{
297 										float CurrentSquareLength = SquareMagnitude();
298 
299 										if(CurrentSquareLength > limit_length * limit_length)
300 										{
301 											float Coeff = limit_length / sqrtf(CurrentSquareLength);
302 											x *= Coeff;
303 											y *= Coeff;
304 											z *= Coeff;
305 										}
306 									}
307 									return *this;
308 								}
309 
310 		//! Computes distance to another point
Distance(const Point & b)311 		inline_	float			Distance(const Point& b)			const
312 								{
313 									return sqrtf((x - b.x)*(x - b.x) + (y - b.y)*(y - b.y) + (z - b.z)*(z - b.z));
314 								}
315 
316 		//! Computes square distance to another point
SquareDistance(const Point & b)317 		inline_	float			SquareDistance(const Point& b)		const
318 								{
319 									return ((x - b.x)*(x - b.x) + (y - b.y)*(y - b.y) + (z - b.z)*(z - b.z));
320 								}
321 
322 		//! Dot product dp = this|a
Dot(const Point & p)323 		inline_	float			Dot(const Point& p)					const		{	return p.x * x + p.y * y + p.z * z;				}
324 
325 		//! Cross product this = a x b
Cross(const Point & a,const Point & b)326 		inline_	Point&			Cross(const Point& a, const Point& b)
327 								{
328 									x = a.y * b.z - a.z * b.y;
329 									y = a.z * b.x - a.x * b.z;
330 									z = a.x * b.y - a.y * b.x;
331 									return *this;
332 								}
333 
334 		//! Vector code ( bitmask = sign(z) | sign(y) | sign(x) )
VectorCode()335 		inline_	udword			VectorCode()						const
336 								{
337 									return (IR(x)>>31) | ((IR(y)&SIGN_BITMASK)>>30) | ((IR(z)&SIGN_BITMASK)>>29);
338 								}
339 
340 		//! Returns largest axis
LargestAxis()341 		inline_	PointComponent	LargestAxis()						const
342 								{
343 									const float* Vals = &x;
344 									PointComponent m = X;
345 									if(Vals[Y] > Vals[m]) m = Y;
346 									if(Vals[Z] > Vals[m]) m = Z;
347 									return m;
348 								}
349 
350 		//! Returns closest axis
ClosestAxis()351 		inline_	PointComponent	ClosestAxis()						const
352 								{
353 									const float* Vals = &x;
354 									PointComponent m = X;
355 									if(AIR(Vals[Y]) > AIR(Vals[m])) m = Y;
356 									if(AIR(Vals[Z]) > AIR(Vals[m])) m = Z;
357 									return m;
358 								}
359 
360 		//! Returns smallest axis
SmallestAxis()361 		inline_	PointComponent	SmallestAxis()						const
362 								{
363 									const float* Vals = &x;
364 									PointComponent m = X;
365 									if(Vals[Y] < Vals[m]) m = Y;
366 									if(Vals[Z] < Vals[m]) m = Z;
367 									return m;
368 								}
369 
370 		//! Refracts the point
371 				Point&			Refract(const Point& eye, const Point& n, float refractindex, Point& refracted);
372 
373 		//! Projects the point onto a plane
374 				Point&			ProjectToPlane(const Plane& p);
375 
376 		//! Projects the point onto the screen
377 				void			ProjectToScreen(float halfrenderwidth, float halfrenderheight, const Matrix4x4& mat, HPoint& projected) const;
378 
379 		//! Unfolds the point onto a plane according to edge(a,b)
380 				Point&			Unfold(Plane& p, Point& a, Point& b);
381 
382 		//! Hash function from Ville Miettinen
GetHashValue()383 		inline_	udword			GetHashValue()						const
384 								{
385 									const udword* h = (const udword*)(this);
386 									udword f = (h[0]+h[1]*11-(h[2]*17)) & 0x7fffffff;	// avoid problems with +-0
387 									return (f>>22)^(f>>12)^(f);
388 								}
389 
390 		//! Stuff magic values in the point, marking it as explicitely not used.
391 				void			SetNotUsed();
392 		//! Checks the point is marked as not used
393 				BOOL			IsNotUsed()							const;
394 
395 		// Arithmetic operators
396 
397 		//! Unary operator for Point Negate = - Point
398 		inline_	Point			operator-()							const		{ return Point(-x, -y, -z);							}
399 
400 		//! Operator for Point Plus = Point + Point.
401 		inline_	Point			operator+(const Point& p)			const		{ return Point(x + p.x, y + p.y, z + p.z);			}
402 		//! Operator for Point Minus = Point - Point.
403 		inline_	Point			operator-(const Point& p)			const		{ return Point(x - p.x, y - p.y, z - p.z);			}
404 
405 		//! Operator for Point Mul   = Point * Point.
406 		inline_	Point			operator*(const Point& p)			const		{ return Point(x * p.x, y * p.y, z * p.z);			}
407 		//! Operator for Point Scale = Point * float.
408 		inline_	Point			operator*(float s)					const		{ return Point(x * s,   y * s,   z * s );			}
409 		//! Operator for Point Scale = float * Point.
410 		inline_ friend	Point	operator*(float s, const Point& p)				{ return Point(s * p.x, s * p.y, s * p.z);			}
411 
412 		//! Operator for Point Div   = Point / Point.
413 		inline_	Point			operator/(const Point& p)			const		{ return Point(x / p.x, y / p.y, z / p.z);			}
414 		//! Operator for Point Scale = Point / float.
415 		inline_	Point			operator/(float s)					const		{ s = 1.0f / s; return Point(x * s, y * s, z * s);	}
416 		//! Operator for Point Scale = float / Point.
417 		inline_	friend	Point	operator/(float s, const Point& p)				{ return Point(s / p.x, s / p.y, s / p.z);			}
418 
419 		//! Operator for float DotProd = Point | Point.
420 		inline_	float			operator|(const Point& p)			const		{ return x*p.x + y*p.y + z*p.z;						}
421 		//! Operator for Point VecProd = Point ^ Point.
422 		inline_	Point			operator^(const Point& p)			const
423 								{
424 									return Point(
425 									y * p.z - z * p.y,
426 									z * p.x - x * p.z,
427 									x * p.y - y * p.x );
428 								}
429 
430 		//! Operator for Point += Point.
431 		inline_	Point&			operator+=(const Point& p)						{ x += p.x; y += p.y; z += p.z;	return *this;		}
432 		//! Operator for Point += float.
433 		inline_	Point&			operator+=(float s)								{ x += s;   y += s;   z += s;	return *this;		}
434 
435 		//! Operator for Point -= Point.
436 		inline_	Point&			operator-=(const Point& p)						{ x -= p.x; y -= p.y; z -= p.z;	return *this;		}
437 		//! Operator for Point -= float.
438 		inline_	Point&			operator-=(float s)								{ x -= s;   y -= s;   z -= s;	return *this;		}
439 
440 		//! Operator for Point *= Point.
441 		inline_	Point&			operator*=(const Point& p)						{ x *= p.x; y *= p.y; z *= p.z;	return *this;		}
442 		//! Operator for Point *= float.
443 		inline_	Point&			operator*=(float s)								{ x *= s; y *= s; z *= s;		return *this;		}
444 
445 		//! Operator for Point /= Point.
446 		inline_	Point&			operator/=(const Point& p)						{ x /= p.x; y /= p.y; z /= p.z;	return *this;		}
447 		//! Operator for Point /= float.
448 		inline_	Point&			operator/=(float s)								{ s = 1.0f/s; x *= s; y *= s; z *= s; return *this; }
449 
450 		// Logical operators
451 
452 		//! Operator for "if(Point==Point)"
453 		inline_	bool			operator==(const Point& p)			const		{ return ( (IR(x)==IR(p.x))&&(IR(y)==IR(p.y))&&(IR(z)==IR(p.z)));	}
454 		//! Operator for "if(Point!=Point)"
455 		inline_	bool			operator!=(const Point& p)			const		{ return ( (IR(x)!=IR(p.x))||(IR(y)!=IR(p.y))||(IR(z)!=IR(p.z)));	}
456 
457 		// Arithmetic operators
458 
459 		//! Operator for Point Mul = Point * Matrix3x3.
460 		inline_	Point			operator*(const Matrix3x3& mat)		const
461 								{
462 									class ShadowMatrix3x3{ public: float m[3][3]; };	// To allow inlining
463 									const ShadowMatrix3x3* Mat = (const ShadowMatrix3x3*)&mat;
464 
465 									return Point(
466 									x * Mat->m[0][0] + y * Mat->m[1][0] + z * Mat->m[2][0],
467 									x * Mat->m[0][1] + y * Mat->m[1][1] + z * Mat->m[2][1],
468 									x * Mat->m[0][2] + y * Mat->m[1][2] + z * Mat->m[2][2] );
469 								}
470 
471 		//! Operator for Point Mul = Point * Matrix4x4.
472 		inline_	Point			operator*(const Matrix4x4& mat)		const
473 								{
474 									class ShadowMatrix4x4{ public: float m[4][4]; };	// To allow inlining
475 									const ShadowMatrix4x4* Mat = (const ShadowMatrix4x4*)&mat;
476 
477 									return Point(
478 									x * Mat->m[0][0] + y * Mat->m[1][0] + z * Mat->m[2][0] + Mat->m[3][0],
479 									x * Mat->m[0][1] + y * Mat->m[1][1] + z * Mat->m[2][1] + Mat->m[3][1],
480 									x * Mat->m[0][2] + y * Mat->m[1][2] + z * Mat->m[2][2] + Mat->m[3][2]);
481 								}
482 
483 		//! Operator for Point *= Matrix3x3.
484 		inline_	Point&			operator*=(const Matrix3x3& mat)
485 								{
486 									class ShadowMatrix3x3{ public: float m[3][3]; };	// To allow inlining
487 									const ShadowMatrix3x3* Mat = (const ShadowMatrix3x3*)&mat;
488 
489 									float xp = x * Mat->m[0][0] + y * Mat->m[1][0] + z * Mat->m[2][0];
490 									float yp = x * Mat->m[0][1] + y * Mat->m[1][1] + z * Mat->m[2][1];
491 									float zp = x * Mat->m[0][2] + y * Mat->m[1][2] + z * Mat->m[2][2];
492 
493 									x = xp;	y = yp;	z = zp;
494 
495 									return *this;
496 								}
497 
498 		//! Operator for Point *= Matrix4x4.
499 		inline_	Point&			operator*=(const Matrix4x4& mat)
500 								{
501 									class ShadowMatrix4x4{ public: float m[4][4]; };	// To allow inlining
502 									const ShadowMatrix4x4* Mat = (const ShadowMatrix4x4*)&mat;
503 
504 									float xp = x * Mat->m[0][0] + y * Mat->m[1][0] + z * Mat->m[2][0] + Mat->m[3][0];
505 									float yp = x * Mat->m[0][1] + y * Mat->m[1][1] + z * Mat->m[2][1] + Mat->m[3][1];
506 									float zp = x * Mat->m[0][2] + y * Mat->m[1][2] + z * Mat->m[2][2] + Mat->m[3][2];
507 
508 									x = xp;	y = yp;	z = zp;
509 
510 									return *this;
511 								}
512 
513 		// Cast operators
514 
515 		//! Cast a Point to a HPoint. w is set to zero.
516 								operator	HPoint()				const;
517 
518 		inline_					operator	const	float*() const	{ return &x; }
519 		inline_					operator			float*()		{ return &x; }
520 
521 		public:
522 				float			x, y, z;
523 	};
524 
525 	FUNCTION ICEMATHS_API void Normalize1(Point& a);
526 	FUNCTION ICEMATHS_API void Normalize2(Point& a);
527 
528 #endif //__ICEPOINT_H__
529