开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 图形图像 > OpenGL > 查看源码
glMath.c
资源名称：gloop.zip　[点击查看]
上传用户：shxiangxiu
上传日期：2007-01-03
资源大小：1101k
文件大小：11k
源码类别：

OpenGL

开发平台：

Visual C++

glMath.c：源码内容
  1. /////////////////////////////////////////////////////////////////////////////
  2. // glMath.c : global glMath function implementation file
  3. //
  4. // glOOP (OpenGL Object Oriented Programming library)
  5. // Copyright (c) Craig Fahrnbach 1997, 1998
  6. //
  7. // OpenGL is a registered trademark of Silicon Graphics
  8. //
  9. //
  10. // This program is provided for educational and personal use only and
  11. // is provided without guarantee or warrantee expressed or implied.
  12. //
  13. // Commercial use is strickly prohibited without written permission
  14. // from ImageWare Development.
  15. //
  16. // This program is -not- in the public domain.
  17. //
  18. /////////////////////////////////////////////////////////////////////////////
  20. #include <windows.h>
  21. #include <glgl.h>
  22. #include <glglu.h>
  23. #include <glglaux.h>
  25. #include <math.h>
  26. #include "glMath.h"
  29. /*****************************************************************************
  30.  *
  31.  *  Misc. Math Routines
  32.  *
  33.  *****************************************************************************
  34.  */
  36. GLfloat Radiansf(GLfloat Angle)
  37. {
  38. double r = (double)Angle*PiOver180; 
  39. return(GLfloat)r;
  40. }
  42. GLfloat Degreesf(GLfloat Angle)
  43. {
  44. double d = (double)Angle*PiUnder180;
  45. return(GLfloat)d;
  46. }
  48. GLfloat Cosf(GLfloat Angle)
  49. {
  50. return((GLfloat)cos(Radiansf(Angle)));
  51. }
  53. GLfloat Sinf(GLfloat Angle)
  54. {
  55. return((GLfloat)sin(Radiansf(Angle)));
  56. }
  58. GLfloat Powerf(GLfloat Base, int Exponent)
  59. {
  60. GLfloat BPower;
  61. int   t;
  63. if(Exponent==0)
  64. return(1.0f);
  65. else
  66. {
  67. BPower=1.0f;
  68. for(t=1; t<=Exponent; t++)
  69. {
  70. BPower*=Base;
  71. }
  72. return(BPower);
  73. }
  74. }
  76. GLfloat Sqrf(GLfloat x)
  77. {
  78. return(x*x);
  79. }
  81. int Roundf(GLfloat x)
  82. {
  83. if(x<0)
  84. return((int)(x-0.5));
  85. else
  86. return((int)(x+0.5));
  87. }
  89. GLdouble Radiansd(GLdouble Angle)
  90. {
  91. double r = Angle*PiOver180; 
  92. return r;
  93. }
  95. GLdouble Degreesd(GLdouble Angle)
  96. {
  97. double d = Angle*PiUnder180;
  98. return d;
  99. }
  101. GLdouble Cosd(GLdouble Angle)
  102. {
  103. return((GLdouble)cos(Radiansd(Angle)));
  104. }
  106. GLdouble Sind(GLdouble Angle)
  107. {
  108. return((GLdouble)sin(Radiansd(Angle)));
  109. }
  112. /*****************************************************************************
  113.  *
  114.  *  Vector Functions:
  115.  *
  116.  *****************************************************************************
  117.  */
  119. void Vec3f(GLfloat r, GLfloat s, GLfloat t, VECTORF A)
  120. {
  121. A[0]=r;
  122. A[1]=s;
  123. A[2]=t;
  124. }
  126. void UnVec3f(VECTORF A, GLfloat *r, GLfloat *s, GLfloat *t)
  127. {
  128. *r=A[0];
  129. *s=A[1];
  130. *t=A[2];
  131. }
  133. void Vec4f(GLfloat r, GLfloat s, GLfloat t, GLfloat u, VECTORF A)
  134. {
  135. A[0]=r;
  136. A[1]=s;
  137. A[2]=t;
  138. A[3]=u;
  139. }
  141. void UnVec4f(VECTORF A, GLfloat *r, GLfloat *s, GLfloat *t, GLfloat *u)
  142. {
  143. *r=A[0];
  144. *s=A[1];
  145. *t=A[2];
  146. *u=A[3];
  147. }
  149. void VecClear3f(VECTORF A)
  150. {
  151. A[X] = 0.0f;
  152. A[Y] = 0.0f;
  153. A[Z] = 0.0f;
  154. }
  156. void VecClear4f(VECTORF A)
  157. {
  158. A[X] = 0.0f;
  159. A[Y] = 0.0f;
  160. A[Z] = 0.0f;
  161. A[W] = 0.0f;
  162. }
  164. void VecCopy3f(VECTORF A, VECTORF B)
  165. {
  166. B[X]=A[X];
  167. B[Y]=A[Y];
  168. B[Z]=A[Z];
  169. }
  171. void VecCopy4f(VECTORF A, VECTORF B)
  172. {
  173. B[X]=A[X];
  174. B[Y]=A[Y];
  175. B[Z]=A[Z];
  176. B[W]=A[W];
  177. }
  179. void VecSubf(VECTORF A, VECTORF B, VECTORF C)
  180. {
  181. C[0]=A[0]-B[0];
  182. C[1]=A[1]-B[1];
  183. C[2]=A[2]-B[2];
  184. }
  186. void VecAddf(VECTORF A, VECTORF B, VECTORF C)
  187. {
  188. C[0]=A[0]+B[0];
  189. C[1]=A[1]+B[1];
  190. C[2]=A[2]+B[2];
  191. }
  193. void VecAdd3f(VECTORF A, VECTORF B, VECTORF C, VECTORF D)
  194. {
  195. D[0]=A[0]+B[0]+C[0];
  196. D[1]=A[1]+B[1]+C[1];
  197. D[2]=A[2]+B[2]+C[2];
  198. }
  200. GLfloat VecDiFFf(VECTORF A, VECTORF B)
  201. {
  202. GLfloat fDiff;
  204. fDiff  = A[X]-B[X];
  205. fDiff += A[Y]-B[Y];
  206. fDiff += A[Z]-B[Z];
  208. return fDiff;
  209. }
  211. GLfloat VecDotf(VECTORF A, VECTORF B)
  212. {
  213. return(A[0]*B[0] + A[1]*B[1] + A[2]*B[2]);
  214. }
  216. void VecCrossf(VECTORF A, VECTORF B, VECTORF C)
  217. {
  218. C[0]=A[1]*B[2] - A[2]*B[1];
  219. C[1]=A[2]*B[0] - A[0]*B[2];
  220. C[2]=A[0]*B[1] - A[1]*B[0];
  221. }
  223. GLfloat VecLenf(VECTORF A)
  224. {
  225. return(GLfloat)(sqrt(Sqrf(A[0])+Sqrf(A[1])+Sqrf(A[2])));
  226. }
  228. void VecNormalizef(VECTORF A)
  229. {
  230. GLfloat dist,invdist;
  232. dist=VecLenf(A);
  233. if(dist==0.0)
  234. return;
  235. else {
  236. invdist=1.0f/dist;
  237. A[0]*=invdist;
  238. A[1]*=invdist;
  239. A[2]*=invdist;
  240. }
  241. }
  243. void CalNormalf(VECTORF A, VECTORF B, VECTORF C, VECTORF N)
  244. {
  245. // Calculate the surface normals of a plane, given points A, B and C
  246. // which reside on the surface of the plane.
  247. /*
  248.                      ^ Vn (Normal)
  249.                      |
  250.                      | 
  251.                      |
  252.                      | 
  253.                  Va  *------------------* Vb  (Vu)
  254.                     /                 /
  255.                   /                 / 
  256.                 /                 /
  257.               /                 /
  258.          Vc *------------------
  259.        (Vv)
  261. */
  262. VECTORF u, v;
  264. VecSubf(B, A, u);
  265. VecSubf(C, A, v);
  266. VecCrossf(v, u, N);
  267. VecNormalizef(N);
  268. }
  271. /*****************************************************************************
  272.  *
  273.  *  Affine Matrix Transformation Routines
  274.  *
  275.  *****************************************************************************
  277.   We define a 4x4 matrix array, referenced as Row,Column as:
  279. | 0,0  0,1  0,2  0,3 |
  280. |                    |
  281. | 1,0  1,1  1,2  1,3 |
  282. |                    |
  283. | 2,0  2,1  2,2  2,3 |
  284. |                    |
  285. | 3,0  3,1  3,2  3,3 |
  286. */
  288. void ZeroMatrix(Matx4x4 A)
  289. {
  290. // Initialize the matrix to the following values:
  291. // 0.0 0.0 0.0 0.0
  292. // 0.0 0.0 0.0 0.0
  293. // 0.0 0.0 0.0 0.0
  294. // 0.0 0.0 0.0 0.0
  295. //
  296. int i, j;
  298. for (i=0; i<4; i++) {
  299. for (j=0; j<4; j++)
  300. A[i][j]=0.0;
  301. }
  302. }
  304. void Translate3D(float tx, float ty, float tz, Matx4x4 A)
  305. {
  306. // Translation matrix identified as:
  307. //  ----------------
  308. // | 1   0   0   Tx |
  309. // | 0   1   0   Ty |
  310. // | 0   0   1   Tz |
  311. // | 0   0   0   1  |
  312. //  ----------------
  313. int i;
  315. ZeroMatrix(A);
  316. for (i=0; i<4; i++)
  317. A[i][i]=1.0;
  319. A[0][3]=tx;
  320. A[1][3]=ty;
  321. A[2][3]=tz;
  322. }
  324. void Scale3D(float sx, float sy, float sz, Matx4x4 A)
  325. {
  326. // Scaling matrix identified as:
  327. //  ----------------
  328. // | Sx  0   0   0 |
  329. // | 0   Sy  0   0 |
  330. // | 0   0   Sz  0 |
  331. // | 0   0   0   1 |
  332. //  ----------------
  334. ZeroMatrix(A);
  335. A[0][0]=sx;
  336. A[1][1]=sy;
  337. A[2][2]=sz;
  338. A[3][3]=1.0;
  339. }
  341. void Rotate3D(int m, float Theta, Matx4x4 A)
  342. {
  343. float c, s;
  345. ZeroMatrix(A);
  346. c=Cosf(Theta);
  347. s=Sinf(Theta);
  349. // Compensate for rounding errors
  350. if(fabs(c)<SMALL_NUMBER)
  351. c=0.0f;
  352. if(fabs(s)<SMALL_NUMBER)
  353. s=0.0f;
  355. switch(m)
  356. {
  357. case X:
  358. // Rotation about the X-Axis matrix identified as:
  359. //  -----------------------
  360. // | 1     0      0      0 |
  361. // | 0     cosX   -sinX  0 |
  362. // | 0     sinX   cosX   0 |
  363. // | 0     0      0      1 |
  364. //  -----------------------
  366. A[0][0]= 1.0;
  367. A[1][1]= c;
  368. A[1][2]=-s;
  369. A[2][1]= s;
  370. A[2][2]= c;
  371. A[3][3]= 1.0;
  372. break;
  374. case Y:
  375. // Rotation about the Y-Axis matrix identified as:
  376. //  -----------------------
  377. // | cosY  0      sinY   0 |
  378. // | 0     1      0      0 |
  379. // | -sinY 0      cosY   0 |
  380. // | 0     0      0      1 |
  381. //  -----------------------
  383. A[0][0]= c;
  384. A[0][2]= s;
  385. A[1][1]= 1.0;
  386. A[2][0]=-s;
  387. A[2][2]= c;
  388. A[3][3]= 1.0;
  389. break;
  391. case Z:
  392. // Rotation about the Z-Axis matrix identified as:
  393. //  -----------------------
  394. // | cosZ  -sinZ  0      0 |
  395. // | sinZ  cosZ   0      0 |
  396. // | 0     0      0      0 |
  397. // | 0     0      0      1 |
  398. //  -----------------------
  400. A[0][0]= c;
  401. A[0][1]=-s;
  402. A[1][0]= s;
  403. A[1][1]= c;
  404. A[2][2]= 1.0;
  405. A[3][3]= 1.0;
  406. break;
  407. }
  408. }
  410. void MultiplyMatricies(Matx4x4 A, Matx4x4 B, Matx4x4 C)
  411. {
  412. int   i, j, k;
  414. for(i=0; i<4; i++) {
  415. for(j=0; j<4; j++) {
  416. for(k=0, C[i][j]=0; k<4; k++)
  417. C[i][j] += A[i][k] * B[k][j];
  418. }
  419. }
  420. }
  422. void MatrixCopy(Matx4x4 A, Matx4x4 B)
  423. {
  424. int  i, j;
  426. for(i=0; i<4; i++)
  427. {
  428. for(j=0; j<4; j++)
  429. B[i][j]=A[i][j];
  430. }
  431. }
  433. void TransposeMatrix(Matx4x4 A)
  434. {
  435. Matx4x4 M;
  436. int  i, j;
  438. for(i=0; i<4; i++) {
  439. for(j=0; j<4; j++)
  440. M[j][i]=A[i][j];
  441. }
  442. MatrixCopy(M, A);
  443. }
  445. void PrepareMatrix(float Ox, float Oy, float Oz,
  446.    float Sx, float Sy, float Sz,
  447.    float Rx, float Ry, float Rz,
  448.    float Tx, float Ty, float Tz,
  449.    Matx4x4 XForm)
  450. {
  451. Matx4x4 M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11;
  453. Translate3D(Tx, Ty, Tz, M1);
  454. Scale3D(Sx, Sy, Sz, M2);
  455. Rotate3D(Z, Rz, M3);
  456. Rotate3D(Y, Ry, M4);
  457. Rotate3D(X, Rx, M5);
  458. Translate3D(Ox, Oy, Oz, M6);
  460. MultiplyMatricies(M2, M1, M7);
  461. MultiplyMatricies(M3, M7, M8);
  462. MultiplyMatricies(M4, M8, M9);
  463. MultiplyMatricies(M5, M9, M10);
  464. MultiplyMatricies(M6, M10, M11);
  465. MatrixCopy(M11, XForm);
  466. }
  468. void PrepareInvMatrix(float Ox, float Oy, float Oz,
  469.   float Sx, float Sy, float Sz,
  470.   float Rx, float Ry, float Rz,
  471.   float Tx, float Ty, float Tz,
  472.   Matx4x4 XForm)
  473. {
  474. Matx4x4 M1, M2, M3, M4, M5, M6, M7, M8, M9, M10, M11;
  476. Translate3D(-Ox, -Oy, -Oz, M1);
  477. Rotate3D(X, -Rx, M2);
  478. Rotate3D(Y, -Ry, M3);
  479. Rotate3D(Z, -Rz, M4);
  480. Scale3D(1/Sx, 1/Sy, 1/Sz, M5);
  481. Translate3D(-Tx, -Ty, -Tz, M6);
  483. MultiplyMatricies(M2, M1, M7);
  484. MultiplyMatricies(M3, M7, M8);
  485. MultiplyMatricies(M4, M8, M9);
  486. MultiplyMatricies(M5, M9, M10);
  487. MultiplyMatricies(M6, M10, M11);
  488. MatrixCopy(M11, XForm);
  489. }
  491. void VecTransformf(VECTORF S, VECTORF D, Matx4x4 M)
  492. {
  493. GLdouble x, y, z;
  495. // Transform the Source vector 'S' by the matrix 'M'
  496. x = M[0][0]*S[0] + M[0][1]*S[1] + M[0][2]*S[2] + M[0][3];
  497. y = M[1][0]*S[0] + M[1][1]*S[1] + M[1][2]*S[2] + M[1][3];
  498. z = M[2][0]*S[0] + M[2][1]*S[1] + M[2][2]*S[2] + M[2][3];
  500. // Compensate for rounding errors
  501. if(fabs(x) < SMALL_NUMBER)
  502. x = 0.0f;
  503. if(fabs(y) < SMALL_NUMBER)
  504. y = 0.0f;
  505. if(fabs(z) < SMALL_NUMBER)
  506. z = 0.0f;
  508. // Store the transformed values in the Destination
  509. // vector 'D'
  510. D[0] = (GLfloat)x;
  511. D[1] = (GLfloat)y;
  512. D[2] = (GLfloat)z;
  513. }
  515. /*****************************************************************************
  516.  *
  517.  *  Misc OpenGL Related Functions:
  518.  *
  519.  *****************************************************************************
  520.   We define a 4x4 matrix array, OpenGL linear matrix format:
  521.   referenced as Row,Column as:
  523. | 0,0  0,1  0,2  0,3 | |a0  a4  a8   a12|
  524. |                    | |                |
  525. | 1,0  1,1  1,2  1,3 | |a1  a5  a9   a13|
  526. |                    | |                |
  527. | 2,0  2,1  2,2  2,3 | |a2  a6  a10  a14|
  528. |                    | |                |
  529. | 3,0  3,1  3,2  3,3 | |a3  a7  a11  a15|
  531.  */
  533. void glMatrixTo4x4(GLdouble M[16], Matx4x4 A)
  534. {
  535. int i, j;
  537. for(i=0; i<4; i++) {
  538. for(j=0; j<4; j++)
  539. A[i][j]=(float)M[(i*4)+j];
  540. }
  541. }
  543. void Matx4x4ToglMatrix(Matx4x4 A, GLdouble M[16])
  544. {
  545. int i, j;
  547. for(i=0; i<4; i++) {
  548. for(j=0; j<4; j++)
  549. M[(i*4)+j]=(GLdouble)A[i][j];
  550. }
  551. }
  553. void Transformf(VECTORF S, VECTORF D, GLdouble M[16])
  554. {
  555. GLdouble x, y, z;
  557. // Transform the Source vector 'S' by the matrix 'M'
  558. x = M[0]*S[0] + M[1]*S[1] + M[2] *S[2]; // + M[3];
  559. y = M[4]*S[0] + M[5]*S[1] + M[6] *S[2]; // + M[7];
  560. z = M[8]*S[0] + M[9]*S[1] + M[10]*S[2]; // + M[11];
  562. // Compensate for rounding errors
  563. if(fabs(x) < SMALL_NUMBER)
  564. x = 0.0f;
  565. if(fabs(y) < SMALL_NUMBER)
  566. y = 0.0f;
  567. if(fabs(z) < SMALL_NUMBER)
  568. z = 0.0f;
  570. // Store the transformed values in the Destination
  571. // vector 'D'
  572. D[0] = (GLfloat)x;
  573. D[1] = (GLfloat)y;
  574. D[2] = (GLfloat)z;
  575. }