OpenGL

开发平台：
Visual C++

CVector.h：源码内容
							/*
   Class Name:
      CVector3.
   Created by:
      Allen Sherrod (Programming Ace of www.UltimateGameProgramming.com).
   Description:
      This class represents a 3D point for a vertex's x, y, z.
*/
#ifndef _CVECTOR_H_
#define _CVECTOR_H_
#include <math.h>
#include <stdlib.h>
#ifndef RAND01
#define RAND01
inline float rand01() { return ( (float)rand() ) / 32767; }
#endif
/*******************************************************************************
* VECTOR
*******************************************************************************/
class CVector
{
   public:
      CVector();                                        // Constructor.
      CVector(float Q);										             // Overloaded constructor.
      CVector(float X, float Y, float Z);               // Overloaded constructor.
      CVector(const CVector &v);                       // Another overloaded constructor.
      void operator=(CVector v);                        // Overloaded = sign.
      void operator=(float f);                           // Overloaded = sign.
      CVector operator-(CVector v);                    // Overloaded - sign.
      CVector operator+(CVector v);                    // Overloaded + sign.
      CVector operator*(CVector v);                    // Overloaded * sign.
      CVector operator/(CVector v);                    // Overloaded / sign.
      CVector operator+(float f);                       // Overloaded + sign.
      CVector operator-(float f);                       // Overloaded - sign.
      CVector operator*(float f);                       // Overloaded * sign.
      CVector operator/(float f);                       // Overloaded / sign.
      void operator +=(CVector v);                      // Overloaded += sign.
      void operator -=(CVector v);                      // Overloaded -= sign.
      void operator *=(CVector v);                      // Overloaded *= sign.
      void operator /=(CVector v);                      // Overloaded /= sign.
      void operator +=(float f);                         // Overloaded += sign.
      void operator -=(float f);                         // Overloaded -= sign.
      void operator *=(float f);                         // Overloaded *= sign.
      void operator /=(float f);                         // Overloaded /= sign.
      bool operator >(CVector v);                      // Overloaded > sign.
      bool operator <(CVector v);                      // Overloaded < sign.
      bool operator >(float f);                      // Overloaded > sign.
      bool operator <(float f);                      // Overloaded < sign.
      bool operator ==(CVector v);                      // Overloaded == sign.
      bool operator !=(CVector v);                      // Overloaded != sign.
      void CrossProduct(CVector v1, CVector v2);       // Stores cross product of v1, v2.
      void CrossProduct3(CVector v1, CVector v2,
                         CVector v3);                   // Stores cross product of v1, v2, v3.
      float DotProduct3(CVector v1);                    // Dot 3 on v1 and this.
      float GetLength();                                 // Return this objects length.
      float GetLength2();                                 // Return this objects length, but not sqrt-ed.
      void Normal();                                     // Normalize this vector.
      CVector Normalized();                          // Returns this vector normalized.
      void Normalize(CVector Triangle[]);               // Find the normal of a triangle.
      void Randomize();
      /*
      void CalculateTangentVector(CVector Point1,
                                  CVector Point2,
                                  CVector Point3,
                                  CVector NormalOfA,
                                  CTexCoord P1Tex,
                                  CTexCoord P2Tex,
                                  CTexCoord P3Tex);      // Cacluate a tagent vector & store here.
      */
      void ExtendVertexPos(CVector lightPos,            // Extend point based on light position
                           float Extend);                // and currend point, saves here.
      void ExtendVertexPos(CVector currentVertex,       // Takes current point and source and
                           CVector lightPos,            // extend and saves here.
                           float Extend);
      CVector GetRotatedX(double angle);                // Rotate along x.
      CVector GetRotatedY(double angle);                // Rotate alone y.
      CVector GetRotatedZ(double angle);                // Rotate along z.
      CVector GetRotatedAxis(double angle, CVector axis);// Rotate along an axis.
      void CalculateBinormalVector(CVector tangent,
                                   CVector normal);     // Calcluate a binormal.
      void ClampTo01();                                  // Clamp this vector between 0 and 1.
      void Set(CVector v)
      {	x = v.x; y = v.y; z = v.z; }
      void Set(float X, float Y, float Z)
			{ x=X; y=Y; z=Z; }
      void Set(float X, float Y, float Z, float W)
			{ x=X; y=Y; z=Z; w=W; }
			void NoiseAngle()
			{
				x += ((float)(rand()%50)-25)/50;
				y += ((float)(rand()%50)-25)/50;
				z += ((float)(rand()%50)-25)/50;
			}
      float x, y, z;                                  // vertex's x, y, and z info.
			float w;	// just so it work with some physic functions, etc.. and for matrix which must be array of 16..
	float& operator[] (int i)
	{
		return (&x)[i];
	}	
	const float& operator[] (int i) const
	{
		return (&x)[i];
	}
	static CVector RandomizeAngle( CVector v, float f );
  /*******************************************************/
 /* this was copied from vector3f class by Kevin Harris */
/* (some part of it was deleted)                       */
//-----------------------------------------------------------------------------
//           Name: vector3f.cpp
//         Author: Kevin Harris
//  Last Modified: 09/09/02
//    Description: Source file for OpenGL compatible utility class for a 3  
//                 component vector of floats.
//
//  NOTE: This class has been left unoptimized for readability.
//-----------------------------------------------------------------------------
static float dotProduct( const CVector &v1,  const CVector &v2 )
{
	return( v1.x * v2.x + v1.y * v2.y + v1.z * v2.z  );
}
/*
CVector operator + ( const CVector &other )
{
    CVector vResult(0.0f, 0.0f, 0.0f);
    vResult.x = x + other.x;
    vResult.y = y + other.y;
    vResult.z = z + other.z;
    return vResult;
}
CVector operator + ( void ) const
{
    return *this;
}
CVector operator - ( const CVector &other )
{
    CVector vResult(0.0f, 0.0f, 0.0f);
    vResult.x = x - other.x;
    vResult.y = y - other.y;
    vResult.z = z - other.z;
    return vResult;
}
CVector operator - ( void ) const
{
    CVector vResult(-x, -y, -z);
    return vResult;
}
CVector operator * ( const CVector &other )
{
    CVector vResult(0.0f, 0.0f, 0.0f);
    vResult.x = x * other.x;
    vResult.y = y * other.y;
    vResult.z = z * other.z;
    return vResult;
}
CVector operator * ( const float scalar )
{
    CVector vResult(0.0f, 0.0f, 0.0f);
    vResult.x = x * scalar;
    vResult.y = y * scalar;
    vResult.z = z * scalar;
    return vResult;
}
CVector operator * ( const float scalar, const CVector &other )
{
    CVector vResult(0.0f, 0.0f, 0.0f);
    vResult.x = other.x * scalar;
    vResult.y = other.y * scalar;
    vResult.z = other.z * scalar;
    return vResult;
}
CVector operator / ( const CVector &other )
{
    CVector vResult(0.0f, 0.0f, 0.0f);
    vResult.x = x / other.x;
    vResult.y = y / other.y;
    vResult.z = z / other.z;
    return vResult;
}
CVector& operator = ( const CVector &other )
{
	x = other.x;
	y = other.y;
	z = other.z;
    return *this;
}
CVector& operator += ( const CVector &other )
{
    x += other.x;
    y += other.y;
    z += other.z;
    return *this;
}
CVector& operator -= ( const CVector &other )
{
    x -= other.x;
    y -= other.y;
    z -= other.z;
    return *this;
}
//
// Static utility methods...
//
static float distance( const CVector &v1,  const CVector &v2  )
{
	float dx = v1.x - v2.x;
	float dy = v1.y - v2.y;
	float dz = v1.z - v2.z;
	return (float)sqrt( dx * dx + dy * dy + dz * dz );
}
static CVector crossProduct( const CVector &v1,  const CVector &v2 )
{
	CVector vCrossProduct;
    vCrossProduct.x = v1.y * v2.z - v1.z * v2.y;
    vCrossProduct.y = v1.z * v2.x - v1.x * v2.z;
    vCrossProduct.z = v1.x * v2.y - v1.y * v2.x;
	return vCrossProduct;
}
*/
/*****************************************/
};
class CMatrix
{
	public:
	CMatrix()
	{
		Reset();
	}
	void Reset()
	{
		m_front.Set(1, 0, 0, 0);
		m_up.Set	 (0, 1, 0, 0);
		m_right.Set(0, 0, 1, 0);
		m_posit.Set(0, 0, 0, 1);
	}
	void ResetRotation()
	{
		m_front.Set(1, 0, 0, 0);
		m_up.Set	 (0, 1, 0, 0);
		m_right.Set(0, 0, 1, 0);
	}
	void Randomize()
	{
		m_front.Randomize();
		m_up.Randomize();
		m_right.Randomize();
		m_posit.Randomize();
	}
	void ResetW()
	{
		m_front[3] = 0;
		m_up[3] = 0;
		m_right[3] = 0;
		m_posit[3] = 1;
	}
	CVector m_front;
	CVector m_up;
	CVector m_right;
	CVector m_posit;
	CVector& operator[] (int i)
	{
		return (&m_front)[i];
	}
	const CVector& operator[] (int i) const
	{
		return (&m_front)[i];
	}
};
#endif
// Copyright September 2003
// All Rights Reserved!
// Allen Sherrod
// ProgrammingAce@UltimateGameProgramming.com
// www.UltimateGameProgramming.com

						