home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1999 July: Mac OS SDK / Dev.CD Jul 99 SDK1.toast / Development Kits / Mac OS / OpenGL 1.0 SDK / Source / Libraries / tk / tkxform.c < prev   
Encoding:
C/C++ Source or Header  |  1999-05-18  |  2.2 KB  |  153 lines  |  [TEXT/CWIE]
  1. #include <math.h>
  2. #include <stdio.h>
  3. #include "gl.h"
  4. #include "3d.h"
  5.  
  6. #define STACKDEPTH 10
  7.  
  8. typedef struct {
  9.     GLdouble    mat[4][4];
  10.     GLdouble    norm[3][3];
  11. } mat_t;
  12.  
  13. static mat_t matstack[STACKDEPTH] = {
  14.     {{{1.0, 0.0, 0.0, 0.0},
  15.     {0.0, 1.0, 0.0, 0.0},
  16.     {0.0, 0.0, 1.0, 0.0},
  17.     {0.0, 0.0, 0.0, 1.0}},
  18.     {{1.0, 0.0, 0.0},
  19.     {0.0, 1.0, 0.0},
  20.     {0.0, 0.0, 1.0}}}
  21. };
  22.  
  23. static int identitymat = 1;
  24. static int mattop = 0;
  25.  
  26. void m_xformpt(GLdouble pin[3], GLdouble pout[3], 
  27.     GLdouble nin[3], GLdouble nout[3])
  28. {
  29.     int    i;
  30.     GLdouble    ptemp[3], ntemp[3];
  31.     mat_t    *m = &matstack[mattop];
  32.  
  33.     if(identitymat)
  34.     {
  35.         for(i = 0; i < 3; i++)
  36.         {
  37.             pout[i] = pin[i];
  38.             nout[i] = nin[i];
  39.         }
  40.         
  41.         return;
  42.     }
  43.     
  44.     for(i = 0; i < 3; i++)
  45.     {
  46.         ptemp[i] = pin[0]*m->mat[0][i] +
  47.                        pin[1]*m->mat[1][i] +
  48.                        pin[2]*m->mat[2][i] +
  49.                        m->mat[3][i];
  50.                        
  51.         ntemp[i] = nin[0]*m->norm[0][i] +
  52.                        nin[1]*m->norm[1][i] +
  53.                        nin[2]*m->norm[2][i];
  54.     }
  55.     
  56.     for(i = 0; i < 3; i++)
  57.     {
  58.         pout[i] = ptemp[i];
  59.         nout[i] = ntemp[i];
  60.     }
  61.     
  62.     normalize(nout);
  63. }
  64.  
  65. void m_xformptonly(GLdouble pin[3], GLdouble pout[3])
  66. {
  67.     int    i;
  68.     GLdouble    ptemp[3];
  69.     mat_t    *m = &matstack[mattop];
  70.  
  71.     if(identitymat)
  72.     {
  73.         for(i = 0; i < 3; i++)
  74.         {
  75.             pout[i] = pin[i];
  76.         }
  77.         
  78.         return;
  79.     }
  80.     
  81.     for(i = 0; i < 3; i++)
  82.     {
  83.         ptemp[i] = pin[0]*m->mat[0][i] +
  84.                      pin[1]*m->mat[1][i] +
  85.                      pin[2]*m->mat[2][i] +
  86.                      m->mat[3][i];
  87.     }
  88.     
  89.     for (i = 0; i < 3; i++)
  90.     {
  91.         pout[i] = ptemp[i];
  92.     }
  93. }
  94.  
  95. void m_pushmatrix(void)
  96. {
  97.     if(mattop < STACKDEPTH-1)
  98.     {
  99.         matstack[mattop+1] = matstack[mattop];
  100.         mattop++;
  101.     }
  102.     else
  103.     {
  104.         error("m_pushmatrix: stack overflow\n");
  105.     }
  106. }
  107.  
  108. void m_popmatrix(void)
  109. {
  110.     if(mattop > 0)
  111.         mattop--;
  112.     else
  113.         error("m_popmatrix: stack underflow\n");
  114. }
  115.  
  116. void m_translate(GLdouble x, GLdouble y, GLdouble z)
  117. {
  118.     int    i;
  119.     mat_t    *m = &matstack[mattop];
  120.  
  121.     identitymat = 0;
  122.     
  123.     for (i = 0; i < 4; i++)
  124.     {
  125.         m->mat[3][i] = x*m->mat[0][i] +
  126.                              y*m->mat[1][i] +
  127.                              z*m->mat[2][i] +
  128.                              m->mat[3][i];
  129.     }
  130. }
  131.  
  132. void m_scale(GLdouble x, GLdouble y, GLdouble z)
  133. {
  134.     int    i;
  135.     mat_t    *m = &matstack[mattop];
  136.  
  137.     identitymat = 0;
  138.     
  139.     for (i = 0; i < 3; i++)
  140.     {
  141.         m->mat[0][i] *= x;
  142.         m->mat[1][i] *= y;
  143.         m->mat[2][i] *= z;
  144.     }
  145.     
  146.     for (i = 0; i < 3; i++)
  147.     {
  148.         m->norm[0][i] /= x;
  149.         m->norm[1][i] /= y;
  150.         m->norm[2][i] /= z;
  151.     }
  152. }
  153.