3D Graphics Programming with QuickDraw 3D

20 Summary of QuickDraw3D Mathematical Utilities

20 C Summary

20 Constants

Real Zero Definition

#ifdef FLT_EPSILON
# define kQ3RealZero        (FLT_EPSILON)
#else
# define kQ3RealZero        ((float)1.19209290e-07)
#endif

Maximum Floating-Point Value

#ifdef FLT_MAX
# define kQ3MaxFloat        (FLT_MAX)
#else
# define kQ3MaxFloat        ((float)3.40282347e+38)
#endif

Pi

#define kQ3Pi          (3.1415926535898)
#define kQ32Pi          (2.0 * kQ3Pi)

20 Data Types

Bounding Boxes and Spheres

typedef struct TQ3BoundingBox {
 TQ3Point3D          min;
 TQ3Point3D          max;
 TQ3Boolean         isEmpty;
} TQ3BoundingBox;
typedef struct TQ3BoundingSphere {
 TQ3Point3D         origin;
 float         radius;
 TQ3Boolean         isEmpty;
} TQ3BoundingSphere;

20 QuickDraw3D Mathematical Utilities

Setting Points and Vectors

TQ3Point2D *Q3Point2D_Set (TQ3Point2D *point2D, float x, float y);
TQ3Param2D *Q3Param2D_Set (TQ3Param2D *param2D, float u, float v);
TQ3Point3D *Q3Point3D_Set (TQ3Point3D *point3D, 
float x, 
float y, 
float z);
TQ3RationalPoint3D *Q3RationalPoint3D_Set (
TQ3RationalPoint3D *point3D, 
float x, 
float y, 
float w);
TQ3RationalPoint4D *Q3RationalPoint4D_Set (
TQ3RationalPoint4D *point4D, 
float x, 
float y, 
float z, 
float w);
TQ3PolarPoint *Q3PolarPoint_Set (
TQ3PolarPoint *polarPoint, 
float r, 
float theta);
TQ3SphericalPoint *Q3SphericalPoint_Set (
TQ3SphericalPoint *sphericalPoint, 
float rho, 
float theta, 
float phi);
TQ3Vector2D *Q3Vector2D_Set (TQ3Vector2D *vector2D, 
float x, 
float y);
TQ3Vector3D *Q3Vector3D_Set (TQ3Vector3D *vector3D, 
float x, 
float y, 
float z);

Converting Dimensions of Points and Vectors

TQ3Point3D *Q3Point2D_To3D (const TQ3Point2D *point2D, 
TQ3Point3D *result);
TQ3RationalPoint4D *Q3Point3D_To4D (
const TQ3Point3D *point3D, 
TQ3RationalPoint4D *result);
TQ3Point2D *Q3RationalPoint3D_To2D (
const TQ3RationalPoint3D *point3D, 
TQ3Point2D *result);
TQ3Point3D *Q3RationalPoint4D_To3D (
const TQ3RationalPoint4D *point4D, 
TQ3Point3D *result);
TQ3Vector3D *Q3Vector2D_To3D (const TQ3Vector2D *vector2D, 
TQ3Vector3D *result);
TQ3Vector2D *Q3Vector3D_To2D (const TQ3Vector3D *vector3D, 
TQ3Vector2D *result);

Subtracting Points

TQ3Vector2D *Q3Point2D_Subtract (
const TQ3Point2D *p1, 
const TQ3Point2D *p2, 
TQ3Vector2D *result);
TQ3Vector2D *Q3Param2D_Subtract (
const TQ3Param2D *p1, 
const TQ3Param2D *p2, 
TQ3Vector2D *result);
TQ3Vector3D *Q3Point3D_Subtract (
const TQ3Point3D *p1, 
const TQ3Point3D *p2, 
TQ3Vector3D *result);

Calculating Distances Between Points

float Q3Point2D_Distance (const TQ3Point2D *p1, const TQ3Point2D *p2);
float Q3Param2D_Distance (const TQ3Param2D *p1, const TQ3Param2D *p2);
float Q3Point3D_Distance (const TQ3Point3D *p1, const TQ3Point3D *p2);
float Q3RationalPoint3D_Distance (
const TQ3RationalPoint3D *p1, 
const TQ3RationalPoint3D *p2);
float Q3RationalPoint4D_Distance (
const TQ3RationalPoint4D *p1, 
const TQ3RationalPoint4D *p2);
float Q3Point2D_DistanceSquared (const TQ3Point2D *p1, const TQ3Point2D *p2);
float Q3Param2D_DistanceSquared (const TQ3Param2D *p1, const TQ3Param2D *p2);
float Q3Point3D_DistanceSquared (const TQ3Point3D *p1, const TQ3Point3D *p2);
float Q3RationalPoint3D_DistanceSquared (
const TQ3RationalPoint3D *p1, 
const TQ3RationalPoint3D *p2);
float Q3RationalPoint4D_DistanceSquared (
const TQ3RationalPoint4D *p1, 
const TQ3RationalPoint4D *p2);

Determining Point Relative Ratios

TQ3Point2D *Q3Point2D_RRatio (const TQ3Point2D *p1, 
const TQ3Point2D *p2, 
float r1, 
float r2, 
TQ3Point2D *result);
TQ3Param2D *Q3Param2D_RRatio (const TQ3Param2D *p1, 
const TQ3Param2D *p2, 
float r1, 
float r2, 
TQ3Param2D *result);
TQ3Point3D *Q3Point3D_RRatio (const TQ3Point3D *p1, 
const TQ3Point3D *p2, 
float r1, 
float r2, 
TQ3Point3D *result);
TQ3RationalPoint4D *Q3RationalPoint4D_RRatio (
const TQ3RationalPoint4D *p1, 
const TQ3RationalPoint4D *p2, 
float r1, 
float r2, 
TQ3RationalPoint4D *result);

Adding and Subtracting Points and Vectors

TQ3Point2D *Q3Point2D_Vector2D_Add (
const TQ3Point2D *point2D, 
const TQ3Vector2D *vector2D, 
TQ3Point2D *result);
TQ3Param2D *Q3Param2D_Vector2D_Add (
const TQ3Param2D *param2D, 
const TQ3Vector2D *vector2D, 
TQ3Param2D *result);
TQ3Point3D *Q3Point3D_Vector3D_Add (
const TQ3Point3D *point3D, 
const TQ3Vector3D *vector3D, 
TQ3Point3D *result);
TQ3Point2D *Q3Point2D_Vector2D_Subtract (
const TQ3Point2D *point2D, 
const TQ3Vector2D *vector2D, 
TQ3Point2D *result);
TQ3Param2D *Q3Param2D_Vector2D_Subtract (
const TQ3Param2D *param2D, 
const TQ3Vector2D *vector2D, 
TQ3Param2D *result);
TQ3Point3D *Q3Point3D_Vector3D_Subtract (
const TQ3Point3D *point3D, 
const TQ3Vector3D *vector3D, 
TQ3Point3D *result);

Scaling Vectors

TQ3Vector2D *Q3Vector2D_Scale (const TQ3Vector2D *vector2D, 
float scalar, 
TQ3Vector2D *result);
TQ3Vector3D *Q3Vector3D_Scale (const TQ3Vector3D *vector3D, 
float scalar, 
TQ3Vector3D *result);

Determining the Lengths of Vectors

float Q3Vector2D_Length (const TQ3Vector2D *vector2D);
float Q3Vector3D_Length (const TQ3Vector3D *vector3D);

Normalizing Vectors

TQ3Vector2D *Q3Vector2D_Normalize (
const TQ3Vector2D *vector2D, 
TQ3Vector2D *result);
TQ3Vector3D *Q3Vector3D_Normalize (
const TQ3Vector3D *vector3D, 
TQ3Vector3D *result);

Adding and Subtracting Vectors

TQ3Vector2D *Q3Vector2D_Add (const TQ3Vector2D *v1, 
const TQ3Vector2D *v2, 
TQ3Vector2D *result);
TQ3Vector3D *Q3Vector3D_Add (const TQ3Vector3D *v1, 
const TQ3Vector3D *v2, 
TQ3Vector3D *result);
TQ3Vector2D *Q3Vector2D_Subtract (
const TQ3Vector2D *v1, 
const TQ3Vector2D *v2, 
TQ3Vector2D *result);
TQ3Vector3D *Q3Vector3D_Subtract (
const TQ3Vector3D *v1, 
const TQ3Vector3D *v2, 
TQ3Vector3D *result);

Determining Vector Cross Products

float Q3Vector2D_Cross (const TQ3Vector2D *v1, 
const TQ3Vector2D *v2);
TQ3Vector3D *Q3Vector3D_Cross (const TQ3Vector3D *v1, 
const TQ3Vector3D *v2, 
TQ3Vector3D *result);
TQ3Vector3D *Q3Point3D_CrossProductTri (
const TQ3Point3D *point1, 
const TQ3Point3D *point2, 
const TQ3Point3D *point3, 
TQ3Vector3D *crossVector);

Determining Vector Dot Products

float Q3Vector2D_Dot (const TQ3Vector2D *v1, const TQ3Vector2D *v2);
float Q3Vector3D_Dot (const TQ3Vector3D *v1, const TQ3Vector3D *v2);

Transforming Points and Vectors

TQ3Vector2D *Q3Vector2D_Transform (
const TQ3Vector2D *vector2D, 
const TQ3Matrix3x3 *matrix3x3, 
TQ3Vector2D *result);
TQ3Vector3D *Q3Vector3D_Transform (
const TQ3Vector3D *vector3D, 
const TQ3Matrix4x4 *matrix4x4, 
TQ3Vector3D *result);
TQ3Point2D *Q3Point2D_Transform (
const TQ3Point2D *point2D, 
const TQ3Matrix3x3 *matrix3x3, 
TQ3Point2D *result);
TQ3Param2D *Q3Param2D_Transform (
const TQ3Param2D *param2D, 
const TQ3Matrix3x3 *matrix3x3, 
TQ3Param2D *result);
TQ3Point3D *Q3Point3D_Transform (
const TQ3Point3D *point3D, 
const TQ3Matrix4x4 *matrix4x4, 
TQ3Point3D *result);
TQ3RationalPoint4D *Q3RationalPoint4D_Transform (
const TQ3RationalPoint4D *point4D, 
const TQ3Matrix4x4 *matrix4x4, 
TQ3RationalPoint4D *result);
TQ3Status Q3Point3D_To3DTransformArray (
const TQ3Point3D *inVertex, 
const TQ3Matrix4x4 *matrix, 
TQ3Point3D *outVertex, 
long numVertices, 
unsigned long inStructSize, 
unsigned long outStructSize);
TQ3Status Q3Point3D_To4DTransformArray (
const TQ3Point3D *inVertex, 
const TQ3Matrix4x4 *matrix, 
TQ3RationalPoint4D *outVertex, 
long numVertices, 
unsigned long inStructSize, 
unsigned long outStructSize);
TQ3Status Q3RationalPoint4D_To4DTransformArray (
const TQ3RationalPoint4D *inVertex, 
const TQ3Matrix4x4 *matrix, 
TQ3RationalPoint4D *outVertex, 
long numVertices, 
unsigned long inStructSize, 
unsigned long outStructSize);

Negating Vectors

TQ3Vector2D *Q3Vector2D_Negate (const TQ3Vector2D *vector2D, 
TQ3Vector2D *result);
TQ3Vector3D *Q3Vector3D_Negate (const TQ3Vector3D *vector3D, 
TQ3Vector3D *result);

Converting Points from Cartesian to Polar or Spherical Form

TQ3PolarPoint *Q3Point2D_ToPolar (
const TQ3Point2D *point2D, 
TQ3PolarPoint *result);
TQ3Point2D *Q3PolarPoint_ToPoint2D (
const TQ3PolarPoint *polarPoint, 
TQ3Point2D *result);
TQ3SphericalPoint *Q3Point3D_ToSpherical (
const TQ3Point3D *point3D, 
TQ3SphericalPoint *result);
TQ3Point3D *Q3SphericalPoint_ToPoint3D (
const TQ3SphericalPoint *sphericalPoint, 
TQ3Point3D *result);

Determining Point Affine Combinations

TQ3Point2D *Q3Point2D_AffineComb (
const TQ3Point2D *points2D, 
const float *weights, 
unsigned long nPoints, 
TQ3Point2D *result);
TQ3Param2D *Q3Param2D_AffineComb (
const TQ3Param2D *params2D, 
const float *weights, 
unsigned long nPoints, 
TQ3Param2D *result);
TQ3Point3D *Q3Point3D_AffineComb (
const TQ3Point3D *points3D, 
const float *weights, 
unsigned long nPoints, 
TQ3Point3D *result);
TQ3RationalPoint3D *Q3RationalPoint3D_AffineComb (
const TQ3RationalPoint3D *points3D, 
const float *weights, 
unsigned long nPoints, 
TQ3RationalPoint3D *result);
TQ3RationalPoint4D *Q3RationalPoint4D_AffineComb (
const TQ3RationalPoint4D *points4D, 
const float *weights, 
unsigned long nPoints, 
TQ3RationalPoint4D *result);

Managing Matrices

TQ3Matrix3x3 *Q3Matrix3x3_Copy (const TQ3Matrix3x3 *matrix3x3, 
TQ3Matrix3x3 *result);
TQ3Matrix4x4 *Q3Matrix4x4_Copy (const TQ3Matrix4x4 *matrix4x4, 
TQ3Matrix4x4 *result);
TQ3Matrix3x3 *Q3Matrix3x3_SetIdentity (
TQ3Matrix3x3 *matrix3x3);
TQ3Matrix4x4 *Q3Matrix4x4_SetIdentity (
TQ3Matrix4x4 *matrix4x4);
TQ3Matrix3x3 *Q3Matrix3x3_Transpose (
const TQ3Matrix3x3 *matrix3x3, 
TQ3Matrix3x3 *result);
TQ3Matrix4x4 *Q3Matrix4x4_Transpose (
const TQ3Matrix4x4 *matrix4x4, 
TQ3Matrix4x4 *result);
TQ3Matrix3x3 *Q3Matrix3x3_Invert (
const TQ3Matrix3x3 *matrix3x3, 
TQ3Matrix3x3 *result);
TQ3Matrix4x4 *Q3Matrix4x4_Invert (
const TQ3Matrix4x4 *matrix4x4, 
TQ3Matrix4x4 *result);
TQ3Matrix3x3 *Q3Matrix3x3_Adjoint (
const TQ3Matrix3x3 *matrix3x3, 
TQ3Matrix3x3 *result);
TQ3Matrix3x3 *Q3Matrix3x3_Multiply (
const TQ3Matrix3x3 *matrixA, 
const TQ3Matrix3x3 *matrixB, 
TQ3Matrix3x3 *result);
TQ3Matrix4x4 *Q3Matrix4x4_Multiply (
const TQ3Matrix4x4 *matrixA, 
const TQ3Matrix4x4 *matrixB, 
TQ3Matrix4x4 *result);
float Q3Matrix3x3_Determinant (const TQ3Matrix3x3 *matrix3x3);
float Q3Matrix4x4_Determinant (const TQ3Matrix4x4 *matrix4x4);

Setting Up Transformation Matrices

TQ3Matrix3x3 *Q3Matrix3x3_SetTranslate (
TQ3Matrix3x3 *matrix3x3, 
float xTrans, 
float yTrans);
TQ3Matrix3x3 *Q3Matrix3x3_SetScale (
TQ3Matrix3x3 *matrix3x3, 
float xScale, 
float yScale);
TQ3Matrix3x3 *Q3Matrix3x3_SetRotateAboutPoint (
TQ3Matrix3x3 *matrix3x3, 
const TQ3Point2D *origin, 
float angle);
TQ3Matrix4x4 *Q3Matrix4x4_SetTranslate (
TQ3Matrix4x4 *matrix4x4, 
float xTrans, 
float yTrans, 
float zTrans);
TQ3Matrix4x4 *Q3Matrix4x4_SetScale (
TQ3Matrix4x4 *matrix4x4, 
float xScale, 
float yScale, 
float zScale);
TQ3Matrix4x4 *Q3Matrix4x4_SetRotateAboutPoint (
TQ3Matrix4x4 *matrix4x4, 
const TQ3Point3D *origin, 
float xAngle, 
float yAngle, 
float zAngle);
TQ3Matrix4x4 *Q3Matrix4x4_SetRotateAboutAxis (
TQ3Matrix4x4 *matrix4x4, 
const TQ3Point3D *origin, 
const TQ3Vector3D *orientation, 
float angle);
TQ3Matrix4x4 *Q3Matrix4x4_SetRotate_X (
TQ3Matrix4x4 *matrix4x4, float angle);
TQ3Matrix4x4 *Q3Matrix4x4_SetRotate_Y (
TQ3Matrix4x4 *matrix4x4, float angle);
TQ3Matrix4x4 *Q3Matrix4x4_SetRotate_Z (
TQ3Matrix4x4 *matrix4x4, float angle);
TQ3Matrix4x4 *Q3Matrix4x4_SetRotate_XYZ (
TQ3Matrix4x4 *matrix4x4, 
float xAngle, 
float yAngle, 
float zAngle);
TQ3Matrix4x4 *Q3Matrix4x4_SetRotateVectorToVector (
TQ3Matrix4x4 *matrix4x4, 
const TQ3Vector3D *v1, 
const TQ3Vector3D *v2);
TQ3Matrix4x4 *Q3Matrix4x4_SetQuaternion (
TQ3Matrix4x4 *matrix, 
const TQ3Quaternion *quaternion);

Utility Functions

#define Q3Math_DegreesToRadians(x)            ((x) * kQ3Pi / 180.0)
#define Q3Math_RadiansToDegrees(x)            ((x) * 180.0 / kQ3Pi)
#define Q3Math_Min(x,y)            ((x) <= (y) ? (x) : (y))
#define Q3Math_Max(x,y)            ((x) >= (y) ? (x) : (y))

Managing Quaternions

TQ3Quaternion *Q3Quaternion_Set (
TQ3Quaternion *quaternion, 
float w, 
float x, 
float y, 
float z);
TQ3Quaternion *Q3Quaternion_SetIdentity (
TQ3Quaternion *quaternion);
TQ3Quaternion *Q3Quaternion_Copy (
const TQ3Quaternion *quaternion, 
TQ3Quaternion *result);
TQ3Boolean Q3Quaternion_IsIdentity (
const TQ3Quaternion *quaternion);
TQ3Quaternion *Q3Quaternion_Invert (
const TQ3Quaternion *quaternion, 
TQ3Quaternion *result);
TQ3Quaternion *Q3Quaternion_Normalize (
const TQ3Quaternion *quaternion, 
TQ3Quaternion *result);
float Q3Quaternion_Dot (const TQ3Quaternion *q1, 
const TQ3Quaternion *q2);
TQ3Quaternion *Q3Quaternion_Multiply (
const TQ3Quaternion *q1, 
const TQ3Quaternion *q2, 
TQ3Quaternion *result);
TQ3Quaternion *Q3Quaternion_SetRotateAboutAxis (
TQ3Quaternion *quaternion, 
const TQ3Vector3D *axis, 
float angle);
TQ3Quaternion *Q3Quaternion_SetRotateX (
TQ3Quaternion *quaternion, 
float angle);
TQ3Quaternion *Q3Quaternion_SetRotateY (
TQ3Quaternion *quaternion, 
float angle);
TQ3Quaternion *Q3Quaternion_SetRotateZ (
TQ3Quaternion *quaternion, 
float angle);
TQ3Quaternion *Q3Quaternion_SetRotateXYZ (
TQ3Quaternion *quaternion, 
float xAngle, 
float yAngle, 
float zAngle);
TQ3Quaternion *Q3Quaternion_SetMatrix (
TQ3Quaternion *quaternion, 
const TQ3Matrix4x4 *matrix);
TQ3Quaternion *Q3Quaternion_SetRotateVectorToVector (
TQ3Quaternion *quaternion, 
const TQ3Vector3D *v1, 
const TQ3Vector3D *v2);
TQ3Quaternion *Q3Quaternion_MatchReflection (
const TQ3Quaternion *q1, 
const TQ3Quaternion *q2, 
TQ3Quaternion *result);
TQ3Quaternion *Q3Quaternion_InterpolateFast (
const TQ3Quaternion *q1, 
const TQ3Quaternion *q2, 
float t, 
TQ3Quaternion *result);
TQ3Quaternion *Q3Quaternion_InterpolateLinear (
const TQ3Quaternion *q1, 
const TQ3Quaternion *q2, 
float t, 
TQ3Quaternion *result) ;
TQ3Vector3D *Q3Vector3D_TransformQuaternion (
const TQ3Vector3D *vector, 
const TQ3Quaternion *quaternion, 
TQ3Vector3D *result);
TQ3Point3D *Q3Point3D_TransformQuaternion (
const TQ3Point3D *point, 
const TQ3Quaternion *quaternion, 
TQ3Point3D *result);

Managing Bounding Boxes

TQ3BoundingBox *Q3BoundingBox_Copy (
const TQ3BoundingBox *src, 
TQ3BoundingBox *dest);
TQ3BoundingBox *Q3BoundingBox_Union (
const TQ3BoundingBox *v1, 
const TQ3BoundingBox *v2, 
TQ3BoundingBox *result);
TQ3BoundingBox *Q3BoundingBox_Set (
TQ3BoundingBox *bBox, 
const TQ3Point3D *min, 
const TQ3Point3D *max, 
TQ3Boolean isEmpty);
TQ3BoundingBox *Q3BoundingBox_UnionPoint3D (
const TQ3BoundingBox *bBox, 
const TQ3Point3D *pt3D, 
TQ3BoundingBox *result);
TQ3BoundingBox *Q3BoundingBox_UnionRationalPoint4D (
const TQ3BoundingBox *bBox, 
const TQ3RationalPoint4D *pt4D, 
TQ3BoundingBox *result);
TQ3BoundingBox *Q3BoundingBox_SetFromPoints3D (
TQ3BoundingBox *bBox, 
const TQ3Point3D *pts, 
unsigned long nPts, 
unsigned long structSize);
TQ3BoundingBox *Q3BoundingBox_SetFromRationalPoints4D (
TQ3BoundingBox *bBox, 
const TQ3RationalPoint4D *pts, 
unsigned long nPts, 
unsigned long structSize);

Managing Bounding Spheres

TQ3BoundingSphere *Q3BoundingSphere_Copy (
const TQ3BoundingSphere *src, 
TQ3BoundingSphere *dest);
TQ3BoundingSphere *Q3BoundingSphere_Union (
const TQ3BoundingSphere *s1, 
const TQ3BoundingSphere *s2, 
TQ3BoundingSphere *result);
TQ3BoundingSphere *Q3BoundingSphere_Set (
TQ3BoundingSphere *bSphere, 
const TQ3Point3D *origin, 
float radius, 
TQ3Boolean isEmpty);
TQ3BoundingSphere *Q3BoundingSphere_UnionPoint3D (
const TQ3BoundingSphere *bSphere, 
const TQ3Point3D *pt3D, 
TQ3BoundingSphere *result);
TQ3BoundingSphere *Q3BoundingSphere_UnionRationalPoint4D (
const TQ3BoundingSphere *bSphere, 
const TQ3RationalPoint4D *pt4D, 
TQ3BoundingSphere *result);
TQ3BoundingSphere *Q3BoundingSphere_SetFromPoints3D (
TQ3BoundingSphere *bSphere, 
const TQ3Point3D *pts, 
unsigned long nPts, 
unsigned long structSize);
TQ3BoundingSphere *Q3BoundingSphere_SetFromRationalPoints4D (
TQ3BoundingSphere *bSphere, 
const TQ3RationalPoint4D *pts, 
unsigned long nPts, 
unsigned long structSize);

20 - C Summary
20 - Constants
Real Zero Definition
Maximum Floating-Point Value
Pi
20 - Data Types
Bounding Boxes and Spheres
20 - QuickDraw3D Mathematical Utilities
Setting Points and Vectors
Converting Dimensions of Points and Vectors
Subtracting Points
Calculating Distances Between Points
Determining Point Relative Ratios
Adding and Subtracting Points and Vectors
Scaling Vectors
Determining the Lengths of Vectors
Normalizing Vectors
Adding and Subtracting Vectors
Determining Vector Cross Products
Determining Vector Dot Products
Transforming Points and Vectors
Negating Vectors
Converting Points from Cartesian to Polar or Spherical Form
Determining Point Affine Combinations
Managing Matrices
Setting Up Transformation Matrices
Utility Functions
Managing Quaternions
Managing Bounding Boxes
Managing Bounding Spheres

3D Graphics Programming with QuickDraw 3D - 17 OCT 1995

© Apple Computer, Inc.

Let us know what you think of these prototype pages.

Generated with Harlequin WebMaker