自己写的一个数学库

因为要做光线跟踪，所以要有一个自己的图形库嘛，所以要封装自己的数学库，所以我就模仿者书上写了一个图形库

按它的那个库中的函数写的，名字大多都一样，有些我认为可以优化的优化了一下

BkDefs.h  定义一些数据姐都的

#ifndef BKDEFS_H_INCLUDED#define BKDEFS_H_INCLUDED/*包含定义的常量及数据类型*/typedef unsigned char Byte  ;typedef unsigned int  Word  ;typedef unsigned long DWord ;//typedef enum { false , true  } Boolen ;typedef char Name[80] ;typedef struct {    Byte Red ;    Byte Grn ;    Byte Blu ;} RGB ;typedef RGB Palette_Register[256] ;typedef float TDA[3]  ;                     //实数三维向量typedef float FDA[4]  ;                     //实数四维向量typedef int   TDIA[3] ;                     //整数三维向量typedef float Matx4x4[4][4] ;               //实数的4x4矩阵#define MaxCol      7#define MaxInten    35#define Ln10        2.30258509299405E+000#define OneOverLn10 0.43429448190325E+000#define Pi          3.1415927#define PiOver180   1.74532925199433E-002#define PiUnder180  5.72957795130823E+001#endif // BKDEFS_H_INCLUDED

BkMath.h声明函数

#ifndef BKMATH_H_INCLUDED#define BKMATH_H_INCLUDED/*包含数学模块各例程使用的函数原型,这些原型指明指明数学*//*模块中所有函数的名字和参数，以及需要向函数传入的参数*/#include "BkDefs.h"/*基本数学函数*//*Round( x ) : 返回与x最接近的整数*/extern int   Round( double x ) ;/*Frac(x) : 返回x的小数部分，如果x < 0 ,Frac( x ) = x-Trunc( x )*/extern float Frac ( double x ) ;/*Trunc( x ) : 返回x的整数部分，舍去小数部分*/extern int   Trunc( double x ) ;/*SqrFP( x ) : 返回浮点数x的平方*/extern float SqrFp( float  x ) ;/*Sqr( x ) : 返回整数x的平方*/extern int   Sqr  ( int    x ) ;/*Radians( Angle ) ：返回以弧度表示的Angle*/extern float Radians( float Angle ) ;/*Degrees( Angle ) ：返回以角度表示的Angle*/extern float Degrees( float Angle ) ;/*描述数学函数的cos函数,接收角度Angle*/extern float CosD( float Angle ) ;/*描述数学函数的sin函数,接收角度Angle*/extern float SinD( float Angle ) ;/*求Base的Exponent次幂*/extern float Power( float Base , int Exponent ) ;/*求一个数以10为底的对数*/extern float Log   ( float x ) ;/*计算以10为底的实数次幂*/extern float Exp10 ( float x ) ;/*获取浮点数的符号*/extern float Sign  ( float x ) ;/*获取传入参数的符号，传入参数为整数*/extern int   IntSign ( int x ) ;/*计算一个整数x的平方根，并返回与结果最接近的整数*/extern int   IntSqrt ( int x ) ;/*IntPower使用递归计算整数的整数次幂,Base的Exponent次幂*/extern int   IntPower( int x ) ;/*返回两个浮点数里的最小数*/extern float MIN( float a , float b ) ;/*返回两个浮点数里的最大数*/extern float MAX( float a , float b ) ;/*返回三个浮点数里的最小数*/extern float MIN3( float a , float b , float c ) ;/*返回三个浮点数里的最大数*/extern float MAX3( float a , float b , float c ) ;/*返回四个浮点数里的最小数*/extern float MIN4( float a , float b , float c , float d ) ;/*返回四个浮点数里的最大数*/extern float MAX4( float a , float b , float c , float d ) ;/*向量和矩阵函数*//*创建浮点数三维向量TDA*/extern void  Vec ( float r , float s , float t , TDA   A ) ;/*创建整数数三维向量TDIA*/extern void  VecInt( int r , int s , int t , TDIA A ) ;/*提取存储在TDA里的三个浮点值*/extern void  UnVec( TDA A , float *r , float *s , float *t) ;/*提取存储在TDIA里的三个浮点值*/extern void  UnVecInt( TDIA A , int *r , int *s , int *t ) ;/*计算向量A与向量B的点积*/extern float VecDot( TDA A , TDA B ) ;/*计算向量A与向量B的叉积*/extern void  VecCross( TDA A , TDA B , TDA C ) ;/*计算向量的模长*/extern float VecLen( TDA A ) ;/*规格化向量A,即使A的模长为1*/extern void  VecNormalize( TDA A ) ;/*将一个实数四维向量A与一个变换矩阵Matrix相乘,存入实数四维向量B*/extern void  VecMatxMult( FDA A , Matx4x4 Matrix , FDA B ) ;/*对实数三维向量A-B求值,结果存入实数三维向量C*/extern void  VecSub( TDA A , TDA B , TDA C ) ;/*对整数向量A-B求值,结果存入实数向量C*/extern void  VecSubInt( TDIA A , TDIA B , TDA C ) ;/*对实数三维向量A+B求值,结果存入实数向量C*/extern void  VecAdd( TDA A , TDA B , TDA C ) ;/*对整数向量A+B求值,结果存入实数向量C*/extern void  VecAdd3( TDA A , TDA B , TDA C , TDA D ) ;/*对实数向量A+B求值,结果存入实数向量C*/extern void  VecCopy( TDA A , TDA B ) ;/*将向量三维实数A复制到三维实数B*/extern void  VecCopyInt( TDIA A , TDIA B ) ;/*将三维整数向量A复制到三维整数向量B*/extern void  VecLinComb( float r , TDA A , float s , TDA B , TDA C ) ;/*计算向量A与向量B的线性组合：C = rA + sB 结果存入三维实数向量C*/extern void  VecScalMult ( float r , TDA  A , TDA B ) ;/*缩放运算，将传入三维实数向量A与给定实数r相乘 ， 结果存入三维实数向量B*/extern void  VecScalMultI( float r , TDIA A , TDA B ) ;/*缩放运算，将传入三维整数向量A与给定实数r相乘 ， 结果存入三维实数向量B*/extern void  VecScalMultInt( float r , TDA A , TDIA B ) ;/*将传入的三维实数向量A与实数r相乘，执行缩放操作, 再与三维实数向量B相加，结果存入三维实数向量C*/extern void  VecAddScalMult( float r , TDA A , TDA B , TDA C ) ;/*将所有三维实数向量A内各元素置为0*/extern void  VecNull( TDA A ) ;/*将所有三维整数向量A内各元素置为0*/extern void  VecNullInt( TDIA A ) ;/*三维实数向量A乘B再与实数r相乘，最后保存在三维实数向量C内*/extern void  VecElemMult( float r , TDA A , TDA B , TDA C ) ;/*查找向量的最小分量*/extern void  VecMin( TDA a , TDA b , TDA c ) ;/*查找向量的最大分量*/extern void  VecMax( TDA a , TDA b , TDA c ) ;/*通过改变元素符号，使向量反向*/extern void  VecNegate( TDA A ) ;/*仿射变换函数*//*将4x4向量所有元素置0*/extern void  ZeroMatrix( Matx4x4 A ) ;/*平移矩阵，沿向量( tx , ty , tz )反向平移  , 将该平移矩阵存入A */extern void  Translate3D( float tx , float ty , float tz , Matx4x4 A ) ;/*缩放矩阵, 在 x 和 y 和 z 方向 ，分别缩放sx , sy , sz 倍 , 将该缩放矩阵存入A*/extern void  Scale3D( float sx , float sy , float sz , Matx4x4 A ) ;/*旋转矩阵,沿任意坐标轴旋转Theta角度 ， m = 1 : x轴， m = 2 : y轴， m = 3 : z轴, 将该旋转矩阵存入A**/extern void  Rotate3D( int m , float Theta , Matx4x4 A ) ;/*两个实数4x4矩阵乘法, 将该乘法矩阵存入A*/extern void  Multiply3DMatricies( Matx4x4 A , Matx4x4 B , Matx4x4 C ) ;/*将给定的矩阵a复制给矩阵b*/extern void  MatCopy( Matx4x4 a , Matx4x4 b ) ;/*按缩放，旋转，平移方式相乘各矩阵， 得到复合矩阵存入XForm*/extern void  PrepareMatrix( float Tx , float Ty , float Tz ,                            float Sx , float Sy , float Sz ,                            float Rx , float Ry , float Rz ,                            Matx4x4 XForm ) ;/*本函数是用来还原函数PrepareMatrix(),本函数的参数里，*//*平移和旋转参数是函数PrepareMatrix里参数的相反数，而缩放参数，则是PrepareMatrix里的倒数*/extern void  PrepareInvMatrix( float Tx , float Ty , float Tz ,                               float Sx , float Sy , float Sz ,                               float Rx , float Ry , float Rz ,                               Matx4x4 XForm ) ;/*将一个实数三维向量A与一个实数4*4矩阵M相乘，结果存入B*/extern void  Transform( TDA A , Matx4x4 M , TDA B ) ;/*伪随机数生成*//*使用一个实数初始化随机数生成器，OldSeed置为传入*//*的种子值,使用Rand和RandInt函数时，都必须调用InitRand函数*/extern void  InitRand( float Seed ) ;/*返回一个正整型随机数，范围由两字节参数Range指定*//*或者是从0到(Range-1)*/extern int   RandInt ( Word Range ) ;/*返回一个0.0到1.0之间的正实数随机数,OldRand*//*是常量sigma与OldRand之间的小数部分*//*使用Rand函数之前，必须调用InitRand函数*/extern float Rand() ;#endif // BKMATH_H_INCLUDED

BkMath.cpp 定义这些函数

/*函数Sign返回值是否改为int*/#include <cstdio>#include <cstdlib>#include <cmath>#include "BkMath.h"/*********************//*   基本数学函数    *//*********************//*Round( x ) : 返回与x最接近的整数*/int  Round( double x ){    return ( ( int ) ( x + 0.5 ) ) ;}/*Trunc( x ) : 返回x的整数部分，舍去小数部分*/int  Trunc( double x ){    return ( ( int ) ( x ) ) ;}/*Frac(x) : 返回x的小数部分，如果x < 0 ,Frac( x ) = x-Trunc( x )*/float Frac( double x ){    int y ;    y = ( ( int ) ( x ) ) ;    return ( x - ( float ) y ) ;}/*SqrFP( x ) : 返回浮点数x的平方*/float SqrFP( float x ){    return ( x * x ) ;}/*Sqr( x ) : 返回整数x的平方*/int Sqr( int x ){    return ( x * x ) ;}/*Radians( Angle ) ：返回以弧度表示的Angle*/float Radians( float Angle ){    return ( Angle * PiOver180 ) ;}/*Degrees( Angle ) ：返回以角度表示的Angle*/float Degrees( float Angle ){    return ( Angle * PiUnder180 ) ;}/*描述数学函数的cos函数,接收角度Angle*/float CosD( float Angle ){    return ( cos( Radians( Angle ) ) ) ;}/*描述数学函数的sin函数,接收角度Angle*/float SinD( float Angle ){    return ( sin( Radians( Angle ) ) ) ;}/*求Base的Exponent次幂*/float Power( float Base , float Exponent ){    float BPower ;    if( Exponent == 0 ) return 1 ;    else {        BPower = 1.0 ;        for( int i = 1 ; i <= Exponent ; i ++ )            BPower *= Base ;        return BPower ;    }}/*求一个数以10为底的对数*/float Log( float x ){    return ( log(x) * OneOverLn10 ) ;}/*计算以10为底的实数次幂*/float Exp10( float x ){    return( exp( x * Ln10 ) ) ;}/*获取浮点数的符号*/float Sign( float x ){    if( x < 0 ) return -1 ;    else if( x > 0 ) return 1 ;    else return 0 ;}/*获取传入参数的符号，传入参数为整数*/int  IntSign( int x ){    if( x < 0 ) return -1 ;    else if( x > 0 ) return 1 ;    else return 0 ;}/*计算一个整数x的平方根，并返回与结果最接近的整数*/int  IntSqrt( int x ){    int  OddInt = 1 , OldArg = x , FirstSqrt ;    while( x >= 0 ) {        x -= OddInt ;        OddInt += 2 ;    }    FirstSqrt = OddInt >> 1 ;    if( Sqr( FirstSqrt ) - FirstSqrt + 1 > OldArg )        return ( FirstSqrt - 1 ) ;    else return FirstSqrt ;}/*IntPower使用递归计算整数的整数次幂,Base的Exponent次幂*/int  IntPower( int Base , int Exponent ){    int BPower ;    if( Exponent == 0 ) return 1 ;    else {        BPower = 1 ;        for( int i = 1 ; i <= Exponent ; i ++ )            BPower *= Base ;        return BPower ;    }}/*返回两个浮点数里的最小数*/float MIN( float a , float b ){    if( a < b ) return a ;    else return b ;}/*返回两个浮点数里的最大数*/float MAX( float a , float b ){    if( a < b ) return b ;    else return a ;}/*返回三个浮点数里的最小数*/float MIN3( float a , float b , float c ){    float t = MIN( a , b ) ;    return MIN( t , c ) ;}/*返回三个浮点数里的最大数*/float MAX3( float a , float b , float c ){    float t = MAX( a , b ) ;    return MAX( t , c ) ;}/*返回四个浮点数里的最小数*/float MIN4( float a , float b , float c , float d ){    float t = MIN3( a , b , c ) ;    return MIN( t , d ) ;}/*返回四个浮点数里的最大数*/float MAX4( float a , float b , float c , float d ){    float t = MAX3( a , b , c ) ;    return MAX( t , c ) ;}/****************************//*      向量和矩阵函数      *//****************************//*创建浮点数三维向量TDA*/void  Vec( float r , float s , float t , TDA A ){    A[0] = r ; A[1] = s ; A[2] = t ;}/*创建整数数三维向量TDIA*/void  VecInt( int r , int s , int t , TDIA A ){    A[0] = r ; A[1] = s ; A[2] = t ;}/*提取存储在TDA里的三个浮点值*/void  UnVec( TDA A , float *r , float *s , float *t ){    *r = A[0] ; *s = A[1] ; *t = A[2] ;}/*提取存储在TDIA里的三个浮点值*/void  UnVecInt( TDIA A , int *r , int *s , int *t ){    *r = A[0] ; *s = A[1] ; *t = A[2] ;}/*计算向量A与向量B的点积*/float VecDot( TDA A , TDA B ){    return ( A[0] * B[0] + A[1] * B[1] + A[2] * B[2] ) ;}/*计算向量A与向量B的叉积*/void  VecCross( TDA A , TDA B , TDA C ){    C[0] = A[1] * B[2] - A[2] * B[1] ;    C[1] = A[2] * B[0] - A[0] * B[2] ;    C[2] = A[0] * B[1] - A[1] * B[0] ;}/*计算向量的模长*/float  VecLen( TDA A ){    return ( sqrt( SqrFP( A[0] ) ) + SqrFP( A[1] ) + SqrFP( A[2] ) ) ;}/*规格化向量A,即使A的模长为1*/void  VecNormalize( TDA A ){    float  dist , invdist ;    dist = VecLen( A ) ;    if( !( dist == 0.0 ) )    {        invdist = 1.0 / dist ;        A[0] *= invdist ;        A[1] *= invdist ;        A[2] *= invdist ;    }    else    {        puts( "Zero-Length Vectors cannot be Normalize" ) ;        exit( 1 ) ;    }}/*将一个实数四维向量A与一个变换矩阵Matrix相乘,存入实数四维向量B*/void  VecMatxMult( FDA A , Matx4x4 Matrix , FDA B ){    for( int i = 0 ; i < 4 ; i ++ )    {        B[i] = 0 ;        for( int j = 0 ; j < 4 ; j ++ )            B[i] += A[j] * Matrix[j][i] ;    }}/*对实数三维向量A-B求值,结果存入实数三维向量C*/void  VecSub( TDA A , TDA B , TDA C ){    C[0] = A[0] - B[0] ;    C[1] = A[1] - B[1] ;    C[2] = A[2] - B[2] ;}/*对整数向量A-B求值,结果存入实数向量C*/void  VecSubInt( TDIA A , TDIA B , TDA C ){    C[0] = float ( A[0] - B[0] ) ;    C[1] = float ( A[1] - B[1] ) ;    C[2] = float ( A[2] - B[2] ) ;}/*对实数三维向量A+B求值,结果存入实数向量C*/void  VecAdd( TDA A , TDA B , TDA C ){    C[0] = A[0] + B[0] ;    C[1] = A[1] + B[1] ;    C[2] = A[2] + B[2] ;}/*对整数向量A+B求值,结果存入实数向量C*/void  VecAddInt( TDIA A , TDIA B , TDA C ){    C[0] = float ( A[0] + B[0] ) ;    C[1] = float ( A[1] + B[1] ) ;    C[2] = float ( A[2] + B[2] ) ;}/*对实数向量A+B求值,结果存入实数向量C*/void  VecAdd3( TDA A , TDA B , TDA C , TDA D){    D[0] =  A[0] + B[0] +C[0] ;    D[1] =  A[1] + B[1] +C[1] ;    D[2] =  A[2] + B[2] +C[2] ;}/*将向量三维实数A复制到三维实数B*/void  VecCopy( TDA A , TDA B ){    B[0] = 0.0 + A[0] ;    B[1] = 0.0 + A[1] ;    B[2] = 0.0 + A[2] ;}/*将三维整数向量A复制到三维整数向量B*/void  VecCopyInt( TDIA A , TDIA B ){    B[0] = A[0] ; B[1] = A[1] ; B[2] = A[2] ;}/*计算向量A与向量B的线性组合：C = rA + sB 结果存入三维实数向量C*/void  VecLinComb( float r , TDA A , float s , TDA B , TDA C ){    C[0] = r * A[0] + s * B[0] ;    C[1] = r * A[1] + s * B[1] ;    C[2] = r * A[2] + s * B[2] ;}/*缩放运算，将传入三维实数向量A与给定实数r相乘 ， 结果存入三维实数向量B*/void  VecScalMult( float r , TDA A , TDA B ){    B[0] = r * A[0] ;    B[1] = r * A[1] ;    B[2] = r * A[2] ;}/*缩放运算，将传入三维整数向量A与给定实数r相乘 ， 结果存入三维实数向量B*/void  VecScalMultI( float r , TDIA A , TDA B ){    B[0] = r * ( float ( A[0] ) ) ;    B[1] = r * ( float ( A[1] ) ) ;    B[2] = r * ( float ( A[2] ) ) ;}/*缩放运算，将传入三维实数向量A与给定实数r相乘 ， 结果存入三维整数向量B*/void  VecScalMultInt( float r , TDA A , TDIA B ){    B[0] = Round( r * A[0] ) ;    B[1] = Round( r * A[1] ) ;    B[2] = Round( r * A[2] ) ;}/*将传入的三维实数向量A与实数r相乘，执行缩放操作, 再与三维实数向量B相加，结果存入三维实数向量C*/void  VecAddScalMult( float r , TDA A , TDA B , TDA C ){    C[0] = r * A[0] + B[0] ;    C[1] = r * A[1] + B[1] ;    C[2] = r * A[2] + B[2] ;}/*将所有三维实数向量A内各元素置为0*/void  VecNull( TDA A ){    A[0] = 0.0 ; A[1] = 0.0 ; A[2] = 0.0 ;}/*将所有三维整数向量A内各元素置为0*/void  VecNullInt( TDIA A ){    A[0] = 0 ; A[1] = 0 ; A[2] = 0 ;}/*三维实数向量A乘B再与实数r相乘，最后保存在三维实数向量C内*/void  VecElemMult( float r , TDA A , TDA B , TDA C ){    C[0] = r * A[0] * B[0] ;    C[1] = r * A[1] * B[1] ;    C[2] = r * A[2] * B[2] ;}/*查找向量的最小分量*/void  VecMin( TDA a , TDA b , TDA c ){    if( a[0] < b[0] ) c[0] = a[0] ;    else c[0] = b[0] ;    if( a[1] < b[1] ) c[1] = a[1] ;    else c[1] = b[1] ;    if( a[2] < b[2] ) c[2] = a[2] ;    else c[2] = b[2] ;}/*查找向量的最大分量*/void  VecMax( TDA a , TDA b , TDA c ){    if( a[0] > b[0] ) c[0] = a[0] ;    else c[0] = b[0] ;    if( a[1] > b[1] ) c[1] = a[1] ;    else c[1] = b[1] ;    if( a[2] > b[2] ) c[2] = a[2] ;    else c[2] = b[2] ;}/*通过改变元素符号，使向量反向*/void  VecNegate( TDA A ){    A[0] = -A[0] ;    A[1] = -A[1] ;    A[2] = -A[2] ;}/********************//*   仿射变换函数   *//********************//*将4x4向量所有元素置0*/void  ZeroMatrix( Matx4x4 A ){    for( int i = 0 ; i < 4 ; i ++ )    {        for( int j = 0 ; j < 4 ; j ++ )            A[i][j] = 0 ;    }}/*平移矩阵，沿向量( tx , ty , tz )反向平移  , 将该平移矩阵存入A */void  Translate3D( float tx , float ty , float tz , Matx4x4 A ){    ZeroMatrix( A ) ;    for( int i = 0 ; i < 4 ; i ++ )        A[i][i] = 1.0 ;    A[0][3] = -tx ;    A[1][3] = -ty ;    A[2][3] = -tz ;}/*缩放矩阵, 在 x 和 y 和 z 方向 ，分别缩放sx , sy , sz 倍 , 将该缩放矩阵存入A*/void  Scale3D( float sx , float sy , float sz , Matx4x4 A ){    ZeroMatrix( A ) ;    A[0][0] = sx  ;    A[1][1] = sy  ;    A[2][2] = sz  ;    A[3][3] = 1.0 ;}/*旋转矩阵,沿任意坐标轴旋转Theta角度 ， m = 1 : x轴， m = 2 : y轴， m = 3 : z轴, 将该旋转矩阵存入A**/void  Rotate3D( int m , float Theta , Matx4x4 A ){    int  m1 , m2 ;    float c , s ;    ZeroMatrix( A ) ;    A[m-1][m-1] = 1.0 ;    A[3][3] = 1.0 ;    m1 = ( m % 3 ) + 1 ;    m2 = ( m1 % 3 ) ;    m1 -= 1 ;    c = CosD( Theta ) ;    s = SinD( Theta ) ;    A[m1][m1] = c  ;    A[m1][m2] = s  ;    A[m2][m2] = c  ;    A[m2][m1] = -s ;}/*两个实数4x4矩阵乘法, 将该乘法矩阵存入A*/void  Multiply3DMatricies( Matx4x4 A , Matx4x4 B , Matx4x4 C ){    Byte i , j , k ;    float ab ;    for( i = 0 ; i < 4 ; i ++ )    {        for( j = 0 ; j < 4 ; j ++ )        {            ab = 0 ;            for( k = 0 ; k < 4 ; k ++ )                ab += A[i][k] + B[k][j] ;            C[i][j] = ab ;        }    }}/*将给定的矩阵a复制给矩阵b*/void  MatCopy( Matx4x4 a , Matx4x4 b ){    Byte i , j ;    for( i = 0 ; i < 4 ; i ++ )        for( j = 0 ; j < 4 ; j ++ )            b[i][j] = a[i][j] ;}/*按缩放，旋转，平移方式相乘各矩阵， 得到复合矩阵存入XForm*/void  PrepareMatrix( float Tx , float Ty , float Tz , float Sx , float Sy , float Sz ,                     float Rx , float Ry , float Rz , Matx4x4 XForm ){    Matx4x4 M1 , M2 , M3 , M4 , M5 , M6 , M7 , M8 , M9 ;    Scale3D( Sx , Sy , Sz , M1 ) ;    Rotate3D( 1 , Rx , M2 ) ;    Rotate3D( 2 , Ry , M3 ) ;    Rotate3D( 3 , Rz , M4 ) ;    Translate3D( Tx , Ty , Tz , M5 ) ;    Multiply3DMatricies( M2 , M1 , M6 ) ;    Multiply3DMatricies( M3 , M6 , M7 ) ;    Multiply3DMatricies( M4 , M7 , M8 ) ;    Multiply3DMatricies( M5 , M8 , M9 ) ;    MatCopy( M9 , XForm ) ;}/*本函数是用来还原函数PrepareMatrix(),本函数的参数里，*//*平移和旋转参数是函数PrepareMatrix里参数的相反数，而缩放参数，则是PrepareMatrix里的倒数*/void  PrepareInvMatrix( float Tx , float Ty , float Tz , float Sx , float Sy , float Sz ,                     float Rx , float Ry , float Rz , Matx4x4 XForm ){    Matx4x4 M1 , M2 , M3 , M4 , M5 , M6 , M7 , M8 , M9 ;    Scale3D( Sx , Sy , Sz , M1 ) ;    Rotate3D( 1 , Rx , M2 ) ;    Rotate3D( 2 , Ry , M3 ) ;    Rotate3D( 3 , Rz , M4 ) ;    Translate3D( Tx , Ty , Tz , M5 ) ;    Multiply3DMatricies( M4 , M5 , M6 ) ;    Multiply3DMatricies( M3 , M6 , M7 ) ;    Multiply3DMatricies( M2 , M7 , M8 ) ;    Multiply3DMatricies( M1 , M8 , M9 ) ;    MatCopy( M9 , XForm ) ;}/*将一个实数三维向量A与一个实数4*4矩阵M相乘，结果存入B*/void  Transform( TDA A , Matx4x4 M , TDA B ){    B[0] = M[0][0] * A[0] + M[0][1] * A[1] + M[0][2] * A[2] + M[0][3] ;    B[1] = M[1][0] * A[0] + M[1][1] * A[1] + M[1][2] * A[2] + M[1][3] ;    B[2] = M[2][0] * A[0] + M[2][1] * A[1] + M[2][2] * A[2] + M[2][3] ;}/********************//*   伪随机数生成   *//********************//*种子*/double OldRand ;/*伪随机数生成*//*使用一个实数初始化随机数生成器，OldRand置为传入*//*的种子值,使用Rand和RandInt函数时，都必须调用InitRand函数*/void  InitRand( float Seed ){    OldRand = Seed ;}/*返回一个正整型随机数，范围由两字节参数Range指定*//*或者是从0到(Range-1)*/int   RandInt( Word Range ){    float sigma = 423.1966 ;    OldRand = Frac( sigma * OldRand ) ;    return ( Trunc( OldRand * ( float ) Range ) ) ;}/*返回一个0.0到1.0之间的正实数随机数,OldRand*//*是常量sigma与OldRand之间的小数部分*//*使用Rand函数之前，必须调用InitRand函数*/float Rand(){    float sigma = 423.1966 ;    OldRand = Frac( sigma * OldRand ) ;    return OldRand ;}

我居然写完了之后让WD来测试，然后他具体些注释，我太邪恶了

 

以后还会把图形库一起封装的。。。