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

Comparing ray/src/hd/sm_geom.c (file contents):
Revision 3.8 by gwlarson, Wed Nov 11 12:05:38 1998 UTC vs.
Revision 3.9 by gwlarson, Mon Dec 28 18:07:35 1998 UTC

# Line 57 | Line 57 | FVECT v0,v1,v2;
57  
58   /* calculates the normal of a face contour using Newell's formula. e
59  
60 <               a =  SUMi (yi - yi+1)(zi + zi+1)smMesh->samples->max_samp+4);
60 >               a =  SUMi (yi - yi+1)(zi + zi+1);
61                 b =  SUMi (zi - zi+1)(xi + xi+1)
62                 c =  SUMi (xi - xi+1)(yi + yi+1)
63   */
# Line 74 | Line 74 | int norm;
74    
75    n[1] = (v0[2] - v1[2]) * (v0[0] + v1[0]) +
76             (v1[2] - v2[2]) * (v1[0] + v2[0]) +
77 <           (v2[2] - v0[2]) * (v2[0] + v0[0]);
77 >            (v2[2] - v0[2]) * (v2[0] + v0[0]);
78    
79    n[2] = (v0[1] + v1[1]) * (v0[0] - v1[0]) +
80           (v1[1] + v2[1]) * (v1[0] - v2[0]) +
# Line 119 | Line 119 | FVECT p0,p1;
119   }
120  
121  
122 <
122 > double
123   point_on_sphere(ps,p,c)
124   FVECT ps,p,c;
125   {
126 +  double d;
127      VSUB(ps,p,c);    
128 <    normalize(ps);
128 >    d= normalize(ps);
129 >    return(d);
130   }
131  
132  
# Line 247 | Line 249 | intersect_ray_oplane(orig,dir,n,pd,r)
249    return(hit);
250   }
251  
252 + /* Assumption: know crosses plane:dont need to check for 'on' case */
253 + intersect_edge_coord_plane(v0,v1,w,r)
254 + FVECT v0,v1;
255 + int w;
256 + FVECT r;
257 + {
258 +  FVECT dv;
259 +  int wnext;
260 +  double t;
261  
262 +  VSUB(dv,v1,v0);
263 +  t = -v0[w]/dv[w];
264 +  r[w] = 0.0;
265 +  wnext = (w+1)%3;
266 +  r[wnext] = v0[wnext] + dv[wnext]*t;
267 +  wnext = (w+2)%3;
268 +  r[wnext] = v0[wnext] + dv[wnext]*t;
269 + }
270 +
271   int
272   intersect_edge_plane(e0,e1,peq,pd,r)
273     FVECT e0,e1;
# Line 319 | Line 339 | FVECT p0,p1,p2;
339      VSUB(p2,p2,p0);
340      VSUB(np,np,p0);
341      
342 <    p1[0] = VLEN(p1);
342 >    p1[0] = DOT(p1,x_axis);
343      p1[1] = 0;
344  
345      d1 = DOT(p2,x_axis);
# Line 647 | Line 667 | FVECT a1,a2,a3,b1,b2,b3;
667    int which,test,n_set[2];
668    int sides[2][3][3],i,j,inext,jnext;
669    int tests[2][3];
670 <  FVECT n[2][3],p,avg[2];
670 >  FVECT n[2][3],p,avg[2],t1,t2,t3;
671  
672 + #ifdef DEBUG
673 +    tri_normal(b1,b2,b3,p,FALSE);
674 +    if(DOT(p,b1) > 0)
675 +      {
676 +       VCOPY(t3,b1);
677 +       VCOPY(t2,b2);
678 +       VCOPY(t1,b3);
679 +      }
680 +    else
681 + #endif
682 +      {
683 +       VCOPY(t1,b1);
684 +       VCOPY(t2,b2);
685 +       VCOPY(t3,b3);
686 +      }
687 +
688    /* Test the vertices of triangle a against the pyramid formed by triangle
689       b and the origin. If any vertex of a is interior to triangle b, or
690       if all 3 vertices of a are ON the edges of b,return TRUE. Remember
691       the results of the edge normal and sidedness tests for later.
692     */
693 < if(vertices_in_stri(a1,a2,a3,b1,b2,b3,&(n_set[0]),n[0],avg[0],sides[1]))
693 > if(vertices_in_stri(a1,a2,a3,t1,t2,t3,&(n_set[0]),n[0],avg[0],sides[1]))
694       return(TRUE);
695    
696 < if(vertices_in_stri(b1,b2,b3,a1,a2,a3,&(n_set[1]),n[1],avg[1],sides[0]))
696 > if(vertices_in_stri(t1,t2,t3,a1,a2,a3,&(n_set[1]),n[1],avg[1],sides[0]))
697       return(TRUE);
698  
699  
700 <  set_sidedness_tests(b1,b2,b3,a1,a2,a3,tests[0],sides[0],n_set[1],n[1]);
700 >  set_sidedness_tests(t1,t2,t3,a1,a2,a3,tests[0],sides[0],n_set[1],n[1]);
701    if(tests[0][0]&tests[0][1]&tests[0][2])
702      return(FALSE);
703  
704 <  set_sidedness_tests(a1,a2,a3,b1,b2,b3,tests[1],sides[1],n_set[0],n[0]);
704 >  set_sidedness_tests(a1,a2,a3,t1,t2,t3,tests[1],sides[1],n_set[0],n[0]);
705    if(tests[1][0]&tests[1][1]&tests[1][2])
706      return(FALSE);
707  
# Line 871 | Line 907 | FVECT a0,a1,b0,b1;
907   }
908  
909  
874 –
910   /* Find the normalized barycentric coordinates of p relative to
911   * triangle v0,v1,v2. Return result in coord
912   */
# Line 889 | Line 924 | double coord[3];
924  
925   }
926  
892 – bary_ith_child(coord,i)
893 – double coord[3];
894 – int i;
895 – {
896 –
897 –  switch(i){
898 –  case 0:
899 –      /* update bary for child */
900 –      coord[0] = 2.0*coord[0]- 1.0;
901 –      coord[1] *= 2.0;
902 –      coord[2] *= 2.0;
903 –      break;
904 –  case 1:
905 –    coord[0] *= 2.0;
906 –    coord[1] = 2.0*coord[1]- 1.0;
907 –    coord[2] *= 2.0;
908 –    break;
909 –  case 2:
910 –    coord[0] *= 2.0;
911 –    coord[1] *= 2.0;
912 –    coord[2] = 2.0*coord[2]- 1.0;
913 –    break;
914 –  case 3:
915 –    coord[0] = 1.0 - 2.0*coord[0];
916 –    coord[1] = 1.0 - 2.0*coord[1];
917 –    coord[2] = 1.0 - 2.0*coord[2];
918 –    break;
919 – #ifdef DEBUG
920 –  default:
921 –    eputs("bary_ith_child():Invalid child\n");
922 –    break;
923 – #endif
924 –  }
925 – }
927  
928  
928 – int
929 – bary_child(coord)
930 – double coord[3];
931 – {
932 –  int i;
929  
934 –  if(coord[0] > 0.5)
935 –  {
936 –      /* update bary for child */
937 –      coord[0] = 2.0*coord[0]- 1.0;
938 –      coord[1] *= 2.0;
939 –      coord[2] *= 2.0;
940 –      return(0);
941 –  }
942 –  else
943 –    if(coord[1] > 0.5)
944 –    {
945 –      coord[0] *= 2.0;
946 –      coord[1] = 2.0*coord[1]- 1.0;
947 –      coord[2] *= 2.0;
948 –      return(1);
949 –    }
950 –    else
951 –      if(coord[2] > 0.5)
952 –      {
953 –        coord[0] *= 2.0;
954 –        coord[1] *= 2.0;
955 –        coord[2] = 2.0*coord[2]- 1.0;
956 –        return(2);
957 –      }
958 –      else
959 –         {
960 –           coord[0] = 1.0 - 2.0*coord[0];
961 –           coord[1] = 1.0 - 2.0*coord[1];
962 –           coord[2] = 1.0 - 2.0*coord[2];
963 –           return(3);
964 –         }
965 – }
966 –
967 – /* Coord was the ith child of the parent: set the coordinate
968 –   relative to the parent
969 – */
930   bary_parent(coord,i)
971 – double coord[3];
972 – int i;
973 – {
974 –
975 –  switch(i) {
976 –  case 0:
977 –    /* update bary for child */
978 –    coord[0] = coord[0]*0.5 + 0.5;
979 –    coord[1] *= 0.5;
980 –    coord[2] *= 0.5;
981 –    break;
982 –  case 1:
983 –    coord[0] *= 0.5;
984 –    coord[1]  = coord[1]*0.5 + 0.5;
985 –    coord[2] *= 0.5;
986 –    break;
987 –    
988 –  case 2:
989 –    coord[0] *= 0.5;
990 –    coord[1] *= 0.5;
991 –    coord[2] = coord[2]*0.5 + 0.5;
992 –    break;
993 –    
994 –  case 3:
995 –    coord[0] = 0.5 - 0.5*coord[0];
996 –    coord[1] = 0.5 - 0.5*coord[1];
997 –    coord[2] = 0.5 - 0.5*coord[2];
998 –    break;
999 – #ifdef DEBUG
1000 –  default:
1001 –    eputs("bary_parent():Invalid child\n");
1002 –    break;
1003 – #endif
1004 –  }
1005 – }
1006 –
1007 – bary_from_child(coord,child,next)
1008 – double coord[3];
1009 – int child,next;
1010 – {
1011 – #ifdef DEBUG
1012 –  if(child <0 || child > 3)
1013 –  {
1014 –    eputs("bary_from_child():Invalid child\n");
1015 –    return;
1016 –  }
1017 –  if(next <0 || next > 3)
1018 –  {
1019 –    eputs("bary_from_child():Invalid next\n");
1020 –    return;
1021 –  }
1022 – #endif
1023 –  if(next == child)
1024 –    return;
1025 –
1026 –  switch(child){
1027 –  case 0:
1028 –    switch(next){
1029 –    case 1:
1030 –      coord[0] += 1.0;
1031 –      coord[1] -= 1.0;
1032 –      break;
1033 –    case 2:
1034 –      coord[0] += 1.0;
1035 –      coord[2] -= 1.0;
1036 –      break;
1037 –    case 3:
1038 –      coord[0] *= -1.0;
1039 –      coord[1] = 1 - coord[1];
1040 –      coord[2] = 1 - coord[2];
1041 –      break;
1042 –
1043 –    }
1044 –    break;
1045 –  case 1:
1046 –    switch(next){
1047 –    case 0:
1048 –      coord[0] -= 1.0;
1049 –      coord[1] += 1.0;
1050 –      break;
1051 –    case 2:
1052 –      coord[1] += 1.0;
1053 –      coord[2] -= 1.0;
1054 –      break;
1055 –    case 3:
1056 –      coord[0] = 1 - coord[0];
1057 –      coord[1] *= -1.0;
1058 –      coord[2] = 1 - coord[2];
1059 –      break;
1060 –    }
1061 –    break;
1062 –  case 2:
1063 –    switch(next){
1064 –    case 0:
1065 –      coord[0] -= 1.0;
1066 –      coord[2] += 1.0;
1067 –      break;
1068 –    case 1:
1069 –      coord[1] -= 1.0;
1070 –      coord[2] += 1.0;
1071 –      break;
1072 –    case 3:
1073 –      coord[0] = 1 - coord[0];
1074 –      coord[1] = 1 - coord[1];
1075 –      coord[2] *= -1.0;
1076 –      break;
1077 –    }
1078 –    break;
1079 –  case 3:
1080 –    switch(next){
1081 –    case 0:
1082 –      coord[0] *= -1.0;
1083 –      coord[1] = 1 - coord[1];
1084 –      coord[2] = 1 - coord[2];
1085 –      break;
1086 –    case 1:
1087 –      coord[0] = 1 - coord[0];
1088 –      coord[1] *= -1.0;
1089 –      coord[2] = 1 - coord[2];
1090 –      break;
1091 –    case 2:
1092 –      coord[0] = 1 - coord[0];
1093 –      coord[1] = 1 - coord[1];
1094 –      coord[2] *= -1.0;
1095 –      break;
1096 –    }
1097 –    break;
1098 –  }
1099 – }
1100 –
1101 –
1102 – baryi_parent(coord,i)
931   BCOORD coord[3];
932   int i;
933   {
1106 –
934    switch(i) {
935    case 0:
936      /* update bary for child */
937 <    coord[0] = (coord[0] >> 1) + MAXBCOORD2;
937 >    coord[0] = (coord[0] >> 1) + MAXBCOORD4;
938      coord[1] >>= 1;
939      coord[2] >>= 1;
940      break;
941    case 1:
942      coord[0] >>= 1;
943 <    coord[1]  = (coord[1] >> 1) + MAXBCOORD2;
943 >    coord[1]  = (coord[1] >> 1) + MAXBCOORD4;
944      coord[2] >>= 1;
945      break;
946      
947    case 2:
948      coord[0] >>= 1;
949      coord[1] >>= 1;
950 <    coord[2] = (coord[2] >> 1) + MAXBCOORD2;
950 >    coord[2] = (coord[2] >> 1) + MAXBCOORD4;
951      break;
952      
953    case 3:
954 <    coord[0] = MAXBCOORD2 - (coord[0] >> 1);
955 <    coord[1] = MAXBCOORD2 - (coord[1] >> 1);
956 <    coord[2] = MAXBCOORD2 - (coord[2] >> 1);
954 >    coord[0] = MAXBCOORD4 - (coord[0] >> 1);
955 >    coord[1] = MAXBCOORD4 - (coord[1] >> 1);
956 >    coord[2] = MAXBCOORD4 - (coord[2] >> 1);
957      break;
958   #ifdef DEBUG
959    default:
960 <    eputs("baryi_parent():Invalid child\n");
960 >    eputs("bary_parent():Invalid child\n");
961      break;
962   #endif
963    }
964   }
965  
966 < baryi_from_child(coord,child,next)
966 > bary_from_child(coord,child,next)
967   BCOORD coord[3];
968   int child,next;
969   {
970   #ifdef DEBUG
971    if(child <0 || child > 3)
972    {
973 <    eputs("baryi_from_child():Invalid child\n");
973 >    eputs("bary_from_child():Invalid child\n");
974      return;
975    }
976    if(next <0 || next > 3)
977    {
978 <    eputs("baryi_from_child():Invalid next\n");
978 >    eputs("bary_from_child():Invalid next\n");
979      return;
980    }
981   #endif
# Line 1158 | Line 985 | int child,next;
985    switch(child){
986    case 0:
987        coord[0] = 0;
988 <      coord[1] = MAXBCOORD - coord[1];
989 <      coord[2] = MAXBCOORD - coord[2];
988 >      coord[1] = MAXBCOORD2 - coord[1];
989 >      coord[2] = MAXBCOORD2 - coord[2];
990        break;
991    case 1:
992 <      coord[0] = MAXBCOORD - coord[0];
992 >      coord[0] = MAXBCOORD2 - coord[0];
993        coord[1] = 0;
994 <      coord[2] = MAXBCOORD - coord[2];
994 >      coord[2] = MAXBCOORD2 - coord[2];
995        break;
996    case 2:
997 <      coord[0] = MAXBCOORD - coord[0];
998 <      coord[1] = MAXBCOORD - coord[1];
997 >      coord[0] = MAXBCOORD2 - coord[0];
998 >      coord[1] = MAXBCOORD2 - coord[1];
999        coord[2] = 0;
1000      break;
1001    case 3:
1002      switch(next){
1003      case 0:
1004        coord[0] = 0;
1005 <      coord[1] = MAXBCOORD - coord[1];
1006 <      coord[2] = MAXBCOORD - coord[2];
1005 >      coord[1] = MAXBCOORD2 - coord[1];
1006 >      coord[2] = MAXBCOORD2 - coord[2];
1007        break;
1008      case 1:
1009 <      coord[0] = MAXBCOORD - coord[0];
1009 >      coord[0] = MAXBCOORD2 - coord[0];
1010        coord[1] = 0;
1011 <      coord[2] = MAXBCOORD - coord[2];
1011 >      coord[2] = MAXBCOORD2 - coord[2];
1012        break;
1013      case 2:
1014 <      coord[0] = MAXBCOORD - coord[0];
1015 <      coord[1] = MAXBCOORD - coord[1];
1014 >      coord[0] = MAXBCOORD2 - coord[0];
1015 >      coord[1] = MAXBCOORD2 - coord[1];
1016        coord[2] = 0;
1017        break;
1018      }
# Line 1194 | Line 1021 | int child,next;
1021   }
1022  
1023   int
1024 < baryi_child(coord)
1024 > bary_child(coord)
1025   BCOORD coord[3];
1026   {
1027    int i;
1028  
1029 <  if(coord[0] > MAXBCOORD2)
1029 >  if(coord[0] > MAXBCOORD4)
1030    {
1031        /* update bary for child */
1032 <      coord[0] = (coord[0]<< 1) - MAXBCOORD;
1032 >      coord[0] = (coord[0]<< 1) - MAXBCOORD2;
1033        coord[1] <<= 1;
1034        coord[2] <<= 1;
1035        return(0);
1036    }
1037    else
1038 <    if(coord[1] > MAXBCOORD2)
1038 >    if(coord[1] > MAXBCOORD4)
1039      {
1040        coord[0] <<= 1;
1041 <      coord[1] = (coord[1] << 1) - MAXBCOORD;
1041 >      coord[1] = (coord[1] << 1) - MAXBCOORD2;
1042        coord[2] <<= 1;
1043        return(1);
1044      }
1045      else
1046 <      if(coord[2] > MAXBCOORD2)
1046 >      if(coord[2] > MAXBCOORD4)
1047        {
1048          coord[0] <<= 1;
1049          coord[1] <<= 1;
1050 <        coord[2] = (coord[2] << 1) - MAXBCOORD;
1050 >        coord[2] = (coord[2] << 1) - MAXBCOORD2;
1051          return(2);
1052        }
1053        else
1054           {
1055 <           coord[0] = MAXBCOORD - (coord[0] << 1);
1056 <           coord[1] = MAXBCOORD - (coord[1] << 1);
1057 <           coord[2] = MAXBCOORD - (coord[2] << 1);
1055 >           coord[0] = MAXBCOORD2 - (coord[0] << 1);
1056 >           coord[1] = MAXBCOORD2 - (coord[1] << 1);
1057 >           coord[2] = MAXBCOORD2 - (coord[2] << 1);
1058             return(3);
1059           }
1060   }
1061  
1062   int
1063 < baryi_nth_child(coord,i)
1063 > bary_nth_child(coord,i)
1064   BCOORD coord[3];
1065   int i;
1066   {
# Line 1241 | Line 1068 | int i;
1068    switch(i){
1069    case 0:
1070      /* update bary for child */
1071 <    coord[0] = (coord[0]<< 1) - MAXBCOORD;
1071 >    coord[0] = (coord[0]<< 1) - MAXBCOORD2;
1072      coord[1] <<= 1;
1073      coord[2] <<= 1;
1074      break;
1075    case 1:
1076      coord[0] <<= 1;
1077 <    coord[1] = (coord[1] << 1) - MAXBCOORD;
1077 >    coord[1] = (coord[1] << 1) - MAXBCOORD2;
1078      coord[2] <<= 1;
1079      break;
1080    case 2:
1081      coord[0] <<= 1;
1082      coord[1] <<= 1;
1083 <    coord[2] = (coord[2] << 1) - MAXBCOORD;
1083 >    coord[2] = (coord[2] << 1) - MAXBCOORD2;
1084      break;
1085    case 3:
1086 <    coord[0] = MAXBCOORD - (coord[0] << 1);
1087 <    coord[1] = MAXBCOORD - (coord[1] << 1);
1088 <    coord[2] = MAXBCOORD - (coord[2] << 1);
1086 >    coord[0] = MAXBCOORD2 - (coord[0] << 1);
1087 >    coord[1] = MAXBCOORD2 - (coord[1] << 1);
1088 >    coord[2] = MAXBCOORD2 - (coord[2] << 1);
1089      break;
1090    }
1091   }
1265 –
1266 –
1267 – baryi_children(coord,i,in_tri,rcoord,rin_tri)
1268 – BCOORD coord[3][3];
1269 – int i;
1270 – int in_tri[3];
1271 – BCOORD rcoord[3][3];
1272 – int rin_tri[3];
1273 – {
1274 –  int j;
1275 –
1276 –  for(j=0; j< 3; j++)
1277 –  {
1278 –    if(!in_tri[j])
1279 –    {
1280 –      rin_tri[j]=0;
1281 –      continue;
1282 –    }
1283 –    
1284 –    if(i != 3)
1285 –    {
1286 –      if(coord[j][i] < MAXBCOORD2)
1287 –        {
1288 –          rin_tri[j] = 0;
1289 –          continue;
1290 –        }
1291 –    }
1292 –    else
1293 –      if( !(coord[j][0] <= MAXBCOORD2 && coord[j][1] <= MAXBCOORD2 &&
1294 –            coord[j][2] <= MAXBCOORD2))
1295 –        {
1296 –          rin_tri[j] = 0;
1297 –          continue;
1298 –        }
1299 –      
1300 –    rin_tri[j]=1;
1301 –    VCOPY(rcoord[j],coord[j]);
1302 –    baryi_nth_child(rcoord[j],i);
1303 –  }
1304 –
1305 – }
1306 –
1307 – convert_dtol(b,bi)
1308 – double b[3];
1309 – BCOORD bi[3];
1310 – {
1311 –  int i;
1312 –
1313 –  for(i=0; i < 2;i++)
1314 –  {
1315 –
1316 –    if(b[i] <= 0.0)
1317 –    {
1318 –      bi[i]= 0;
1319 –    }
1320 –    else
1321 –      if(b[i] >= 1.0)
1322 –      {
1323 –        bi[i]= MAXBCOORD;
1324 –      }
1325 –      else
1326 –        bi[i] = (BCOORD)(b[i]*MAXBCOORD);
1327 –  }
1328 –  bi[2] = bi[0] +  bi[1];
1329 –  if(bi[2] > MAXBCOORD)
1330 –  {
1331 –      bi[2] = 0;
1332 –      bi[1] = MAXBCOORD - bi[0];
1333 –  }
1334 –  else
1335 –    bi[2] = MAXBCOORD - bi[2];
1336 –
1337 – }
1338 –
1339 – /* convert barycentric coordinate b in [-eps,1+eps] to [0,MAXLONG],
1340 –   dir unbounded to [-MAXLONG,MAXLONG]
1341 – */
1342 – bary_dtol(b,db,bi,dbi,t,w)
1343 – double b[3],db[3][3];
1344 – BCOORD bi[3];
1345 – BDIR dbi[3][3];
1346 – TINT t[3];
1347 – int w;
1348 – {
1349 –  int i,id,j,k;
1350 –  double d;
1351 –
1352 –  convert_dtol(b,bi);
1353 –
1354 –  for(j=w; j< 3; j++)
1355 –  {
1356 –    if(t[j] == HUGET)
1357 –    {
1358 –      max_index(db[j],&d);
1359 –      for(i=0; i< 3; i++)
1360 –        dbi[j][i] = (BDIR)(db[j][i]/d*MAXBDIR);
1361 –      break;
1362 –    }
1363 –    else
1364 –    {
1365 –      for(i=0; i< 3; i++)
1366 –          dbi[j][i] = (BDIR)(db[j][i]*MAXBDIR);
1367 –    }
1368 –  }
1369 – }
1370 –
1371 –
1372 – /* convert barycentric coordinate b in [-eps,1+eps] to [0,MAXLONG],
1373 –   dir unbounded to [-MAXLONG,MAXLONG]
1374 – */
1375 – bary_dtol_new(b,db,bi,boi,dbi,t)
1376 – double b[4][3],db[3][3];
1377 – BCOORD bi[3],boi[3][3];
1378 – BDIR dbi[3][3];
1379 – int t[3];
1380 – {
1381 –  int i,id,j,k;
1382 –  double d;
1383 –
1384 –  convert_dtol(b[3],bi);
1385 –
1386 –  for(j=0; j<3;j++)
1387 –  {
1388 –    if(t[j] != 1)
1389 –      continue;
1390 –    convert_dtol(b[j],boi[j]);
1391 –  }
1392 –  for(j=0; j< 3; j++)
1393 –  {
1394 –    k = (j+1)%3;
1395 –    if(t[k]==0)
1396 –      continue;
1397 –    if(t[k] == -1)
1398 –      {
1399 –        max_index(db[j],&d);
1400 –        for(i=0; i< 3; i++)
1401 –          dbi[j][i] = (BDIR)(db[j][i]/d*MAXBDIR);
1402 –        t[k] = 0;
1403 –      }
1404 –    else
1405 –      if(t[j] != 1)
1406 –        for(i=0; i< 3; i++)
1407 –          dbi[j][i] = (BDIR)(db[j][i]*MAXBDIR);
1408 –    else
1409 –      for(i=0; i< 3; i++)
1410 –        dbi[j][i] = boi[k][i] - boi[j][i];
1411 –    
1412 –  }
1413 – }
1414 –
1415 –
1416 – bary_dtolb(b,bi,in_tri)
1417 – double b[3][3];
1418 – BCOORD bi[3][3];
1419 – int in_tri[3];
1420 – {
1421 –  int i,j;
1422 –
1423 –  for(j=0; j<3;j++)
1424 –  {
1425 –    if(!in_tri[j])
1426 –      continue;
1427 –    for(i=0; i < 2;i++)
1428 –    {
1429 –    if(b[j][i] <= 0.0)
1430 –    {
1431 –      bi[j][i]= 0;
1432 –    }
1433 –    else
1434 –      if(b[j][i] >= 1.0)
1435 –      {
1436 –        bi[j][i]= MAXBCOORD;
1437 –      }
1438 –      else
1439 –        bi[j][i] = (BCOORD)(b[j][i]*MAXBCOORD);
1440 –    }
1441 –    bi[j][2] = MAXBCOORD - bi[j][0] - bi[j][1];
1442 –    if(bi[j][2] < 0)
1443 –      {
1444 –        bi[j][2] = 0;
1445 –        bi[j][1] = MAXBCOORD - bi[j][0];
1446 –      }
1447 –  }
1448 – }
1449 –
1450 –
1451 –
1452 –
1453 –
1454 –
1455 –
1456 –
1092  
1093  
1094  

Diff Legend

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