ViewVC Help
View File | Revision Log | Show Annotations | Download File | Root Listing
root/radiance/ray/src/common/mat4.c
(Generate patch)

Comparing ray/src/common/mat4.c (file contents):
Revision 2.1 by greg, Tue Nov 12 16:54:53 1991 UTC vs.
Revision 2.4 by greg, Tue Feb 25 02:47:21 2003 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1990 Regents of the University of California */
2 –
1   #ifndef lint
2 < static char SCCSid[] = "$SunId$ LBL";
2 > static const char       RCSid[] = "$Id$";
3   #endif
6 –
4   /*
5   *  mat4.c - routines dealing with 4 X 4 homogeneous transformation matrices.
9 – *
10 – *     10/19/85
6   */
7  
8 + #include "copyright.h"
9 +
10   #include  "mat4.h"
11  
12   MAT4  m4ident = MAT4IDENT;
# Line 17 | Line 14 | MAT4  m4ident = MAT4IDENT;
14   static MAT4  m4tmp;             /* for efficiency */
15  
16  
17 + void
18   multmat4(m4a, m4b, m4c)         /* multiply m4b X m4c and put into m4a */
19   MAT4  m4a;
20   register MAT4  m4b, m4c;
# Line 34 | Line 32 | register MAT4  m4b, m4c;
32   }
33  
34  
35 + void
36   multv3(v3a, v3b, m4)    /* transform vector v3b by m4 and put into v3a */
37   FVECT  v3a;
38   register FVECT  v3b;
# Line 49 | Line 48 | register MAT4  m4;
48   }
49  
50  
51 + void
52   multp3(p3a, p3b, m4)            /* transform p3b by m4 and put into p3a */
53   register FVECT  p3a;
54   FVECT  p3b;
# Line 58 | Line 58 | register MAT4  m4;
58          p3a[0] += m4[3][0];     /* translate */
59          p3a[1] += m4[3][1];
60          p3a[2] += m4[3][2];
61 – }
62 –
63 –
64 – /*
65 – * invmat - computes the inverse of mat into inverse.  Returns 1
66 – * if there exists an inverse, 0 otherwise.  It uses Gaussian Elimination
67 – * method with partial pivoting.
68 – */
69 –
70 – invmat(inverse,mat)
71 – MAT4  mat, inverse;
72 – {
73 – #define SWAP(a,b,t) (t=a,a=b,b=t)
74 – #define ABS(x) (x>=0?x:-(x))
75 –
76 –        register int i,j,k;
77 –        register double temp;
78 –
79 –        copymat4(m4tmp, mat);
80 –        setident4(inverse);
81 –
82 –        for(i = 0; i < 4; i++) {
83 –                /* Look for row with largest pivot and swap rows */
84 –                temp = 0; j = -1;
85 –                for(k = i; k < 4; k++)
86 –                        if(ABS(m4tmp[k][i]) > temp) {
87 –                                temp = ABS(m4tmp[k][i]);
88 –                                j = k;
89 –                                }
90 –                if(j == -1)     /* No replacing row -> no inverse */
91 –                        return(0);
92 –                if (j != i)
93 –                        for(k = 0; k < 4; k++) {
94 –                                SWAP(m4tmp[i][k],m4tmp[j][k],temp);
95 –                                SWAP(inverse[i][k],inverse[j][k],temp);
96 –                                }
97 –
98 –                temp = m4tmp[i][i];
99 –                for(k = 0; k < 4; k++) {
100 –                        m4tmp[i][k] /= temp;
101 –                        inverse[i][k] /= temp;
102 –                        }
103 –                for(j = 0; j < 4; j++) {
104 –                        if(j != i) {
105 –                                temp = m4tmp[j][i];
106 –                                for(k = 0; k < 4; k++) {
107 –                                        m4tmp[j][k] -= m4tmp[i][k]*temp;
108 –                                        inverse[j][k] -= inverse[i][k]*temp;
109 –                                        }
110 –                                }
111 –                        }
112 –                }
113 –        return(1);
114 –
115 – #undef ABS
116 – #undef SWAP
61   }

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines