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 1.3 by greg, Fri Dec 22 09:24:07 1989 UTC vs.
Revision 2.3 by greg, Sat Feb 22 02:07:22 2003 UTC

# Line 1 | Line 1
1 – /* Copyright (c) 1986 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.
6 + */
7 +
8 + /* ====================================================================
9 + * The Radiance Software License, Version 1.0
10   *
11 < *     10/19/85
11 > * Copyright (c) 1990 - 2002 The Regents of the University of California,
12 > * through Lawrence Berkeley National Laboratory.   All rights reserved.
13 > *
14 > * Redistribution and use in source and binary forms, with or without
15 > * modification, are permitted provided that the following conditions
16 > * are met:
17 > *
18 > * 1. Redistributions of source code must retain the above copyright
19 > *         notice, this list of conditions and the following disclaimer.
20 > *
21 > * 2. Redistributions in binary form must reproduce the above copyright
22 > *       notice, this list of conditions and the following disclaimer in
23 > *       the documentation and/or other materials provided with the
24 > *       distribution.
25 > *
26 > * 3. The end-user documentation included with the redistribution,
27 > *           if any, must include the following acknowledgment:
28 > *             "This product includes Radiance software
29 > *                 (http://radsite.lbl.gov/)
30 > *                 developed by the Lawrence Berkeley National Laboratory
31 > *               (http://www.lbl.gov/)."
32 > *       Alternately, this acknowledgment may appear in the software itself,
33 > *       if and wherever such third-party acknowledgments normally appear.
34 > *
35 > * 4. The names "Radiance," "Lawrence Berkeley National Laboratory"
36 > *       and "The Regents of the University of California" must
37 > *       not be used to endorse or promote products derived from this
38 > *       software without prior written permission. For written
39 > *       permission, please contact [email protected].
40 > *
41 > * 5. Products derived from this software may not be called "Radiance",
42 > *       nor may "Radiance" appear in their name, without prior written
43 > *       permission of Lawrence Berkeley National Laboratory.
44 > *
45 > * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
46 > * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
47 > * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
48 > * DISCLAIMED.   IN NO EVENT SHALL Lawrence Berkeley National Laboratory OR
49 > * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
50 > * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
51 > * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
52 > * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
53 > * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
54 > * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
55 > * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56 > * SUCH DAMAGE.
57 > * ====================================================================
58 > *
59 > * This software consists of voluntary contributions made by many
60 > * individuals on behalf of Lawrence Berkeley National Laboratory.   For more
61 > * information on Lawrence Berkeley National Laboratory, please see
62 > * <http://www.lbl.gov/>.
63   */
64  
65 + #include  "mat4.h"
66  
67 < static double  m4tmp[4][4];             /* for efficiency */
67 > MAT4  m4ident = MAT4IDENT;
68  
69 < #define  copymat4(m4a,m4b)      bcopy((char *)m4b,(char *)m4a,sizeof(m4tmp))
69 > static MAT4  m4tmp;             /* for efficiency */
70  
71  
72 < setident4(m4)
20 < double  m4[4][4];
21 < {
22 <        static double  ident[4][4] = {
23 <                1.,0.,0.,0.,
24 <                0.,1.,0.,0.,
25 <                0.,0.,1.,0.,
26 <                0.,0.,0.,1.,
27 <        };
28 <        copymat4(m4, ident);
29 < }
30 <
31 <
72 > void
73   multmat4(m4a, m4b, m4c)         /* multiply m4b X m4c and put into m4a */
74 < double  m4a[4][4];
75 < register double  m4b[4][4], m4c[4][4];
74 > MAT4  m4a;
75 > register MAT4  m4b, m4c;
76   {
77          register int  i, j;
78          
# Line 46 | Line 87 | register double  m4b[4][4], m4c[4][4];
87   }
88  
89  
90 + void
91   multv3(v3a, v3b, m4)    /* transform vector v3b by m4 and put into v3a */
92 < double  v3a[3];
93 < register double  v3b[3];
94 < register double  m4[4][4];
92 > FVECT  v3a;
93 > register FVECT  v3b;
94 > register MAT4  m4;
95   {
96          m4tmp[0][0] = v3b[0]*m4[0][0] + v3b[1]*m4[1][0] + v3b[2]*m4[2][0];
97          m4tmp[0][1] = v3b[0]*m4[0][1] + v3b[1]*m4[1][1] + v3b[2]*m4[2][1];
# Line 61 | Line 103 | register double  m4[4][4];
103   }
104  
105  
106 + void
107   multp3(p3a, p3b, m4)            /* transform p3b by m4 and put into p3a */
108 < register double  p3a[3];
109 < double  p3b[3];
110 < register double  m4[4][4];
108 > register FVECT  p3a;
109 > FVECT  p3b;
110 > register MAT4  m4;
111   {
112          multv3(p3a, p3b, m4);   /* transform as vector */
113          p3a[0] += m4[3][0];     /* translate */
114          p3a[1] += m4[3][1];
115          p3a[2] += m4[3][2];
116   }
74 –
75 –
76 – #ifdef  INVMAT
77 – /*
78 – * invmat - computes the inverse of mat into inverse.  Returns 1
79 – * if there exists an inverse, 0 otherwise.  It uses Gaussian Elimination
80 – * method with partial pivoting.
81 – */
82 –
83 – invmat(inverse,mat)
84 – double mat[4][4],inverse[4][4];
85 – {
86 – #define SWAP(a,b,t) (t=a,a=b,b=t)
87 – #define ABS(x) (x>=0?x:-(x))
88 –
89 –        register int i,j,k;
90 –        register double temp;
91 –
92 –        copymat4(m4tmp, mat);
93 –        setident(inverse);
94 –
95 –        for(i = 0; i < 4; i++) {
96 –                /* Look for row with largest pivot and swap rows */
97 –                temp = 0; j = -1;
98 –                for(k = i; k < 4; k++)
99 –                        if(ABS(m4tmp[k][i]) > temp) {
100 –                                temp = ABS(m4tmp[k][i]);
101 –                                j = k;
102 –                                }
103 –                if(j == -1)     /* No replacing row -> no inverse */
104 –                        return(0);
105 –                if (j != i)
106 –                        for(k = 0; k < 4; k++) {
107 –                                SWAP(m4tmp[i][k],m4tmp[j][k],temp);
108 –                                SWAP(inverse[i][k],inverse[j][k],temp);
109 –                                }
110 –
111 –                temp = m4tmp[i][i];
112 –                for(k = 0; k < 4; k++) {
113 –                        m4tmp[i][k] /= temp;
114 –                        inverse[i][k] /= temp;
115 –                        }
116 –                for(j = 0; j < 4; j++) {
117 –                        if(j != i) {
118 –                                temp = m4tmp[j][i];
119 –                                for(k = 0; k < 4; k++) {
120 –                                        m4tmp[j][k] -= m4tmp[i][k]*temp;
121 –                                        inverse[j][k] -= inverse[i][k]*temp;
122 –                                        }
123 –                                }
124 –                        }
125 –                }
126 –        return(1);
127 –
128 – #undef ABS
129 – #undef SWAP
130 – }
131 – #endif

Diff Legend

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