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

Comparing ray/src/common/tmesh.c (file contents):
Revision 2.2 by greg, Tue Mar 11 17:08:55 2003 UTC vs.
Revision 2.6 by greg, Thu Apr 15 23:51:04 2021 UTC

# Line 6 | Line 6 | static const char RCSid[] = "$Id$";
6   */
7  
8   #include <stdio.h>
9 –
9   #include "fvect.h"
11 –
10   #include "tmesh.h"
11  
14 – #define ABS(x)          ((x) >= 0 ? (x) : -(x))
12  
16 –
13   int
14 < flat_tri(v1, v2, v3, n1, n2, n3)        /* determine if triangle is flat */
15 < FVECT   v1, v2, v3, n1, n2, n3;
14 > flat_tri(                       /* determine if triangle is flat */
15 >        FVECT   v1,
16 >        FVECT   v2,
17 >        FVECT   v3,
18 >        FVECT   n1,
19 >        FVECT   n2,
20 >        FVECT   n3
21 > )
22   {
23          double  d1, d2, d3;
24          FVECT   vt1, vt2, vn;
# Line 40 | Line 42 | FVECT  v1, v2, v3, n1, n2, n3;
42  
43  
44   int
45 < comp_baryc(bcm, v1, v2, v3)             /* compute barycentric vectors */
46 < register BARYCCM        *bcm;
47 < FLOAT                   *v1, *v2, *v3;
45 > comp_baryc(                     /* compute barycentric vectors */
46 >        BARYCCM *bcm,
47 >        RREAL   *v1,
48 >        RREAL   *v2,
49 >        RREAL   *v3
50 > )
51   {
52 <        FLOAT   *vt;
52 >        RREAL   *vt;
53          FVECT   va, vab, vcb;
54          double  d;
55          int     ax0, ax1;
56 <        register int    i;
56 >        int     i;
57                                          /* compute major axis */
58          VSUB(vab, v1, v2);
59          VSUB(vcb, v3, v2);
60          VCROSS(va, vab, vcb);
61 <        bcm->ax = ABS(va[0]) > ABS(va[1]) ? 0 : 1;
62 <        bcm->ax = ABS(va[bcm->ax]) > ABS(va[2]) ? bcm->ax : 2;
63 <        ax0 = (bcm->ax + 1) % 3;
64 <        ax1 = (bcm->ax + 2) % 3;
61 >        bcm->ax = (va[1]*va[1] > va[0]*va[0]);
62 >        if (va[2]*va[2] > va[bcm->ax]*va[bcm->ax]) bcm->ax = 2;
63 >        ax0 = (bcm->ax + 1)%3;
64 >        ax1 = (bcm->ax + 2)%3;
65          for (i = 0; i < 2; i++) {
66                  vab[0] = v1[ax0] - v2[ax0];
67                  vcb[0] = v3[ax0] - v2[ax0];
# Line 65 | Line 70 | FLOAT                  *v1, *v2, *v3;
70                  d = vcb[0]*vcb[0] + vcb[1]*vcb[1];
71                  if (d <= FTINY*FTINY)
72                          return(-1);
73 <                d = (vcb[0]*vab[0]+vcb[1]*vab[1])/d;
73 >                d = (vcb[0]*vab[0] + vcb[1]*vab[1])/d;
74                  va[0] = vab[0] - vcb[0]*d;
75                  va[1] = vab[1] - vcb[1]*d;
76                  d = va[0]*va[0] + va[1]*va[1];
# Line 74 | Line 79 | FLOAT                  *v1, *v2, *v3;
79                  d = 1.0/d;
80                  bcm->tm[i][0] = va[0] *= d;
81                  bcm->tm[i][1] = va[1] *= d;
82 <                bcm->tm[i][2] = -(v2[ax0]*va[0]+v2[ax1]*va[1]);
82 >                bcm->tm[i][2] = -(v2[ax0]*va[0] + v2[ax1]*va[1]);
83                                          /* rotate vertices */
84                  vt = v1;
85                  v1 = v2;
# Line 86 | Line 91 | FLOAT                  *v1, *v2, *v3;
91  
92  
93   void
94 < eval_baryc(wt, p, bcm)          /* evaluate barycentric weights at p */
95 < FLOAT   wt[3];
96 < FVECT   p;
97 < register BARYCCM        *bcm;
94 > eval_baryc(                     /* evaluate barycentric weights at p */
95 >        RREAL   wt[3],
96 >        FVECT   p,
97 >        BARYCCM *bcm
98 > )
99   {
100          double  u, v;
101 +        int     i;
102          
103 <        u = p[(bcm->ax + 1) % 3];
104 <        v = p[(bcm->ax + 2) % 3];
103 >        if ((i = bcm->ax + 1) >= 3) i -= 3;
104 >        u = p[i];
105 >        if (++i >= 3) i -= 3;
106 >        v = p[i];
107          wt[0] = u*bcm->tm[0][0] + v*bcm->tm[0][1] + bcm->tm[0][2];
108          wt[1] = u*bcm->tm[1][0] + v*bcm->tm[1][1] + bcm->tm[1][2];
109          wt[2] = 1. - wt[1] - wt[0];
# Line 102 | Line 111 | register BARYCCM       *bcm;
111  
112  
113   int
114 < get_baryc(wt, p, v1, v2, v3)    /* compute barycentric weights at p */
115 < FLOAT   wt[3];
116 < FVECT   p;
117 < FVECT   v1, v2, v3;
114 > get_baryc(              /* compute barycentric weights at p */
115 >        RREAL   wt[3],
116 >        FVECT   p,
117 >        FVECT   v1,
118 >        FVECT   v2,
119 >        FVECT   v3
120 > )
121   {
122          BARYCCM bcm;
123          
# Line 119 | Line 131 | FVECT  v1, v2, v3;
131   #if 0
132   int
133   get_baryc(wt, p, v1, v2, v3)    /* compute barycentric weights at p */
134 < FLOAT   wt[3];
134 > RREAL   wt[3];
135   FVECT   p;
136   FVECT   v1, v2, v3;
137   {
# Line 145 | Line 157 | FVECT  v1, v2, v3;
157  
158  
159   void
160 < put_baryc(bcm, com, n)          /* put barycentric coord. vectors */
161 < register BARYCCM        *bcm;
162 < register FLOAT          com[][3];
163 < int                     n;
160 > fput_baryc(                     /* put barycentric coord. vectors */
161 >        BARYCCM *bcm,
162 >        RREAL   com[][3],
163 >        int     n,
164 >        FILE    *fp
165 > )
166   {
167          double  a, b;
168 <        register int    i, j;
168 >        int     i;
169  
170 <        printf("%d\t%d\n", 1+3*n, bcm->ax);
170 >        fprintf(fp, "%d\t%d\n", 1+3*n, bcm->ax);
171          for (i = 0; i < n; i++) {
172                  a = com[i][0] - com[i][2];
173                  b = com[i][1] - com[i][2];
174 <                printf("%14.8f %14.8f %14.8f\n",
174 >                fprintf(fp, "%14.8f %14.8f %14.8f\n",
175                          bcm->tm[0][0]*a + bcm->tm[1][0]*b,
176                          bcm->tm[0][1]*a + bcm->tm[1][1]*b,
177                          bcm->tm[0][2]*a + bcm->tm[1][2]*b + com[i][2]);

Diff Legend

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