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
00026 #ifndef GRINLIZ_GEOMETRY_INCLUDED
00027 #define GRINLIZ_GEOMETRY_INCLUDED
00028
00029 #include "glvector.h"
00030 #include "glrectangle.h"
00031 #include "glmatrix.h"
00032 #include "glmemorypool.h"
00033
00034 #include <vector>
00035
00036 namespace grinliz {
00037
00039 template< class T>
00040 inline void CrossProduct( const Vector2<T>& u, const Vector2<T>& v, Vector3<T>* w )
00041 {
00042 w->x = 0.0f;
00043 w->y = 0.0f;
00044 w->z = u.x * v.y - u.y * v.x;
00045 }
00046
00047
00049 template< class T>
00050 inline T DotProduct( const Vector2<T>& v0, const Vector2<T>& v1 )
00051 {
00052 return v0.x*v1.x + v0.y*v1.y;
00053 }
00054
00055
00057 template< class T>
00058 inline void CrossProduct( const Vector3<T>& u, const Vector3<T>& v, Vector3<T>* w )
00059 {
00060 GLASSERT( &u != w && &v != w );
00061
00062 w->x = u.y * v.z - u.z * v.y;
00063 w->y = u.z * v.x - u.x * v.z;
00064 w->z = u.x * v.y - u.y * v.x;
00065 }
00066
00067
00069 template< class T>
00070 inline Vector3<T> CrossProduct( const Vector3<T>& u, const Vector3<T>& v )
00071 {
00072 Vector3<T> w;
00073
00074 w.x = u.y * v.z - u.z * v.y;
00075 w.y = u.z * v.x - u.x * v.z;
00076 w.z = u.x * v.y - u.y * v.x;
00077 return w;
00078 }
00079
00080
00082 template< class T>
00083 inline T DotProduct( const Vector3<T>& v0, const Vector3<T>& v1 )
00084 {
00085 return v0.x*v1.x + v0.y*v1.y + v0.z*v1.z;
00086 }
00087
00088
00089 struct BoundingSphere
00090 {
00091 Vector3F point;
00092 float rad;
00093
00094 };
00095
00096
00099 struct Ray
00100 {
00101 Vector3F origin;
00102 Vector3F direction;
00103 float length;
00104 };
00105
00110 struct Plane
00111 {
00113 static void CreatePlane( const Vector3F* vertices, Plane* plane );
00114
00115 Vector3F n;
00116 float d;
00117
00118 float Z( float x, float y ) const { return -( d + (n.x * x) + (n.y * y) ) / ( n.z ); }
00119
00120 void Normalize()
00121 {
00122 float div = 1.0f / sqrtf( ( n.x * n.x ) + ( n.y * n.y ) + ( n.z * n.z ) );
00123 n.x *= div;
00124 n.y *= div;
00125 n.z *= div;
00126 d *= div;
00127 }
00128
00129
00130
00131
00132
00133
00134
00135
00136
00138 void ProjectToPlane( const Vector3F& vector, Vector3F* projected ) const;
00139 };
00140
00141 float CalcSphereTexture( float x, float y, bool roundHigh );
00142
00143 enum TessellateSphereMode
00144 {
00145 TESS_SPHERE_NORMAL,
00146 TESS_SPHERE_TOPHALF,
00147 TESS_SPHERE_MIRROR,
00148 };
00149
00163 void TessellateSphere( int iterations, float radius, bool innerNormals,
00164 std::vector< Vector3F >* _vertex,
00165 std::vector< U32 >* _index,
00166 std::vector< Vector3F >* _normal = 0,
00167 std::vector< Vector2F >* _texture = 0,
00168 TessellateSphereMode mode = TESS_SPHERE_NORMAL );
00169
00170
00173 struct LineNode
00174 {
00175 grinliz::Vector2F point;
00176 LineNode* prev;
00177 LineNode* next;
00178 float value;
00179
00180 LineNode( const grinliz::Vector2F& p ) : point( p ), prev( 0 ), next( 0 ), value( 0.0f ) {}
00181 LineNode( float x, float y ) : prev( 0 ), next( 0 ), value( 0.0f ) { point.Set( x, y ); }
00182 LineNode( float x, float y, float val ) : prev( 0 ), next( 0 ), value( val ) { point.Set( x, y ); }
00183 ~LineNode() {}
00184
00185 void* operator new( size_t size ) {
00186 GLASSERT( sizeof( LineNode ) == size );
00187 return pool.Alloc();
00188 }
00189
00190 void operator delete( void* mem ) { pool.Free( mem ); }
00191
00192 static MemoryPool pool;
00193 };
00194
00195
00201 class LineLoop
00202 {
00203 public:
00205 LineLoop() : first( 0 ) {}
00206 ~LineLoop() { Clear(); }
00207
00209 void Clear();
00211 void Delete( LineNode* del );
00222 void AddAtEnd( LineNode* node );
00224 void AddAfter( LineNode* me, LineNode* add );
00226 LineNode* First() { return first; }
00228 const LineNode* First() const { return first; }
00233 void SortToTop();
00235 void Bounds( grinliz::Rectangle2F* bounds );
00236
00241 void Render( float* surface, int width, int height, bool fill=false );
00242
00243 #ifdef DEBUG
00244 void Dump();
00245 #endif
00246
00247 private:
00248 LineNode* first;
00249 };
00250
00251
00257 template< int X0, int X1, int XC >
00258 struct Quad3F
00259 {
00260 enum { NUM_VERTEX = 4 };
00261 Vector3F vertex[NUM_VERTEX];
00262
00263 Quad3F( float x0, float y0, float x1, float y1, float c )
00264 {
00265 vertex[0].X(X0) = x0; vertex[0].X(X1) = y0; vertex[0].X(XC) = c;
00266 vertex[1].X(X0) = x1; vertex[1].X(X1) = y0; vertex[1].X(XC) = c;
00267 vertex[2].X(X0) = x1; vertex[2].X(X1) = y1; vertex[2].X(XC) = c;
00268 vertex[3].X(X0) = x0; vertex[3].X(X1) = y1; vertex[3].X(XC) = c;
00269 }
00270 };
00271
00272 typedef Quad3F< 0, 1, 2 > Quad3Fz;
00273
00274
00280 template< int X0, int X1 >
00281 struct Quad2F
00282 {
00283 enum { NUM_VERTEX = 4 };
00284 Vector2F vertex[NUM_VERTEX];
00285
00286 Quad2F( float x0, float y0, float x1, float y1 )
00287 {
00288 vertex[0].X(X0) = x0; vertex[0].X(X1) = y0;
00289 vertex[1].X(X0) = x1; vertex[1].X(X1) = y0;
00290 vertex[2].X(X0) = x1; vertex[2].X(X1) = y1;
00291 vertex[3].X(X0) = x0; vertex[3].X(X1) = y1;
00292 }
00293 };
00294
00295 typedef Quad2F< 0, 1 > Quad2Fz;
00296
00297
00298
00303 class Quaternion
00304 {
00305 public:
00306 Quaternion() : x( 0.0f ), y( 0.0f ), z( 0.0f ), w( 1.0f ) {}
00307
00308 void Normalize();
00309
00310 const void ToAxisAngle( Vector3F* axis, float* angleOut );
00311 const void ToMatrix( Matrix4* matrix );
00312 void FromRotationMatrix( const Matrix4& matrix );
00313 void FromAxisAngle( const Vector3F& axis, float angle );
00314
00315 static void SLERP( const Quaternion& start, const Quaternion& end, float t, Quaternion* result );
00316 static void Multiply( const Quaternion& a, const Quaternion& b, Quaternion* result );
00317
00318 float x, y, z, w;
00319 };
00320
00321
00322 enum
00323 {
00324 REJECT = 0,
00325 INTERSECT,
00326 POSITIVE,
00327 NEGATIVE,
00328 INSIDE,
00329 };
00330
00331 enum
00332 {
00333
00334 YZ_PLANE,
00335 XZ_PLANE,
00336 XY_PLANE
00337 };
00338
00339
00361 int ComparePlaneAABB( const Plane&, const Rectangle3F& aabb );
00362
00366 int ComparePlanePoint( const Plane&, const Vector3F& p );
00367
00371 inline int IntersectPlaneAABB( const Plane& p, const Rectangle3F& aabb )
00372 {
00373 return ( ComparePlaneAABB( p, aabb ) == INTERSECT ) ? INTERSECT : REJECT;
00374 }
00375
00376
00381 int IntersectRayTri( const Vector3F& point, const Vector3F& dir,
00382 const Vector3F& vert0, const Vector3F& vert1, const Vector3F& vert2,
00383 Vector3F* intersect );
00384
00389 int IntersectRayAAPlane( const Vector3F& point, const Vector3F& dir,
00390 int planeType, float planeLoc,
00391 Vector3F* intersect,
00392 float* t );
00393
00398 int IntersectRayAABB( const Vector3F& origin, const Vector3F& dir,
00399 const Rectangle3F& aabb,
00400 Vector3F* intersect,
00401 float* t );
00402
00408 int IntersectionRayAABB( const Ray& ray,
00409 const Rectangle3F& aabb,
00410 Rectangle3F* result );
00411
00415 int IntersectRayZPlane( const Vector3F& origin, const Vector3F& dir,
00416 float z,
00417 Vector3F* intersect );
00418
00423 int IntersectLinePlane( const Vector3F& a0, const Vector3F& a1,
00424 const Plane& plane,
00425 Vector3F* out,
00426 float* t );
00427
00433 int IntersectLineLine( const Vector3F& a0, const Vector3F& a1,
00434 const Vector3F& b0, const Vector3F& b1,
00435 Vector3F* out0,
00436 Vector3F* out1 );
00437
00443 int IntersectLineLine( const Vector2F& a0, const Vector2F& a1,
00444 const Vector2F& b0, const Vector2F& b1,
00445 Vector2F* out,
00446 float* t0,
00447 float* t1 );
00448
00449
00453 int PointInPolygon( const Vector2F& p, const Vector2F* vertex, int numVertex );
00454
00458 float PointBetweenPoints( const Vector3F& p0, const Vector3F& p1, const Vector3F& pi );
00459
00464 int Intersect3Planes( const Plane& p0, const Plane& p1, const Plane& p2, Vector3F* intersection );
00465
00466 };
00467 #endif
00468