← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/blender/gutsy-security

« back to all changes in this revision

Viewing changes to source/blender/blenlib/intern/arithb.c

  • Committer: Bazaar Package Importer
  • Author(s): Florian Ernst
  • Date: 2007-05-17 11:47:59 UTC
  • mfrom: (1.2.6 upstream)
  • Revision ID: james.westby@ubuntu.com-20070517114759-yp4ybrnhp2u7pk66
Tags: 2.44-1
* New upstream release.
* Drop debian/patches/01_64bits_stupidity, not needed anymore: as of this
  version blender is 64 bits safe again. Adjust README.Debian accordingly.

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/blender/blenlib/intern/arithb.c
7
7
 * Functions here get counterparts with MTC prefixes. Basically, we phase
8
8
 * out the calls here in favour of fully prototyped versions.
9
9
 *
10
 
 * $Id: arithb.c,v 1.53 2007/02/09 21:46:08 blendix Exp $
 
10
 * $Id: arithb.c,v 1.54 2007/04/04 13:18:28 campbellbarton Exp $
11
11
 *
12
12
 * ***** BEGIN GPL/BL DUAL LICENSE BLOCK *****
13
13
 *
95
95
        return (float)sqrt(fac);
96
96
}
97
97
 
98
 
float Normalise(float *n)
 
98
float Normalize(float *n)
99
99
{
100
100
        float d;
101
101
        
102
102
        d= n[0]*n[0]+n[1]*n[1]+n[2]*n[2];
103
 
        /* A larger value causes normalise errors in a scaled down models with camera xtreme close */
 
103
        /* A larger value causes normalize errors in a scaled down models with camera xtreme close */
104
104
        if(d>1.0e-35F) {
105
105
                d= (float)sqrt(d);
106
106
 
1220
1220
        nor[0] = mat[2][1];             /* cross product with (0,0,1) */
1221
1221
        nor[1] =  -mat[2][0];
1222
1222
        nor[2] = 0.0;
1223
 
        Normalise(nor);
 
1223
        Normalize(nor);
1224
1224
        
1225
1225
        co= mat[2][2];
1226
1226
        angle= 0.5f*saacos(co);
1341
1341
        }
1342
1342
        co/= len1;
1343
1343
 
1344
 
        Normalise(nor);
 
1344
        Normalize(nor);
1345
1345
        
1346
1346
        angle= 0.5f*saacos(co);
1347
1347
        si= (float)sin(angle);
1414
1414
        mat[coz][0]= vec[0];
1415
1415
        mat[coz][1]= vec[1];
1416
1416
        mat[coz][2]= vec[2];
1417
 
        Normalise((float *)mat[coz]);
 
1417
        Normalize((float *)mat[coz]);
1418
1418
        
1419
1419
        inp= mat[coz][0]*up[0] + mat[coz][1]*up[1] + mat[coz][2]*up[2];
1420
1420
        mat[coy][0]= up[0] - inp*mat[coz][0];
1421
1421
        mat[coy][1]= up[1] - inp*mat[coz][1];
1422
1422
        mat[coy][2]= up[2] - inp*mat[coz][2];
1423
1423
 
1424
 
        Normalise((float *)mat[coy]);
 
1424
        Normalize((float *)mat[coy]);
1425
1425
        
1426
1426
        Crossf(mat[cox], mat[coy], mat[coz]);
1427
1427
        
1460
1460
        mat[coz][0]= vec[0];
1461
1461
        mat[coz][1]= vec[1];
1462
1462
        mat[coz][2]= vec[2];
1463
 
        Normalise((float *)mat[coz]);
 
1463
        Normalize((float *)mat[coz]);
1464
1464
        
1465
1465
        inp= mat[coz][2];
1466
1466
        mat[coy][0]= - inp*mat[coz][0];
1467
1467
        mat[coy][1]= - inp*mat[coz][1];
1468
1468
        mat[coy][2]= 1.0f - inp*mat[coz][2];
1469
1469
 
1470
 
        Normalise((float *)mat[coy]);
 
1470
        Normalize((float *)mat[coy]);
1471
1471
        
1472
1472
        Crossf(mat[cox], mat[coy], mat[coz]);
1473
1473
        
1751
1751
 
1752
1752
void Mat3Ortho(float mat[][3])
1753
1753
{       
1754
 
        Normalise(mat[0]);
1755
 
        Normalise(mat[1]);
1756
 
        Normalise(mat[2]);
 
1754
        Normalize(mat[0]);
 
1755
        Normalize(mat[1]);
 
1756
        Normalize(mat[2]);
1757
1757
}
1758
1758
 
1759
1759
void Mat4Ortho(float mat[][4])
1760
1760
{
1761
1761
        float len;
1762
1762
        
1763
 
        len= Normalise(mat[0]);
 
1763
        len= Normalize(mat[0]);
1764
1764
        if(len!=0.0) mat[0][3]/= len;
1765
 
        len= Normalise(mat[1]);
 
1765
        len= Normalize(mat[1]);
1766
1766
        if(len!=0.0) mat[1][3]/= len;
1767
 
        len= Normalise(mat[2]);
 
1767
        len= Normalize(mat[2]);
1768
1768
        if(len!=0.0) mat[2][3]/= len;
1769
1769
}
1770
1770
 
1876
1876
        n[0]= n1[1]*n2[2]-n1[2]*n2[1];
1877
1877
        n[1]= n1[2]*n2[0]-n1[0]*n2[2];
1878
1878
        n[2]= n1[0]*n2[1]-n1[1]*n2[0];
1879
 
        Normalise(n);
 
1879
        Normalize(n);
1880
1880
}
1881
1881
 
1882
1882
void CalcNormLong( int* v1, int*v2, int*v3, float *n)
1892
1892
        n[0]= n1[1]*n2[2]-n1[2]*n2[1];
1893
1893
        n[1]= n1[2]*n2[0]-n1[0]*n2[2];
1894
1894
        n[2]= n1[0]*n2[1]-n1[1]*n2[0];
1895
 
        Normalise(n);
 
1895
        Normalize(n);
1896
1896
}
1897
1897
 
1898
1898
float CalcNormFloat( float *v1, float *v2, float *v3, float *n)
1908
1908
        n[0]= n1[1]*n2[2]-n1[2]*n2[1];
1909
1909
        n[1]= n1[2]*n2[0]-n1[0]*n2[2];
1910
1910
        n[2]= n1[0]*n2[1]-n1[1]*n2[0];
1911
 
        return Normalise(n);
 
1911
        return Normalize(n);
1912
1912
}
1913
1913
 
1914
1914
float CalcNormFloat4( float *v1, float *v2, float *v3, float *v4, float *n)
1928
1928
        n[1]= n1[2]*n2[0]-n1[0]*n2[2];
1929
1929
        n[2]= n1[0]*n2[1]-n1[1]*n2[0];
1930
1930
 
1931
 
        return Normalise(n);
 
1931
        return Normalize(n);
1932
1932
}
1933
1933
 
1934
1934
 
2022
2022
        VecSubf(vec1, v2, v1);
2023
2023
        VecSubf(vec2, v4, v1);
2024
2024
        Crossf(n, vec1, vec2);
2025
 
        len= Normalise(n);
 
2025
        len= Normalize(n);
2026
2026
 
2027
2027
        VecSubf(vec1, v4, v3);
2028
2028
        VecSubf(vec2, v2, v3);
2029
2029
        Crossf(n, vec1, vec2);
2030
 
        len+= Normalise(n);
 
2030
        len+= Normalize(n);
2031
2031
 
2032
2032
        return (len/2.0f);
2033
2033
}
2039
2039
        VecSubf(vec1, v3, v2);
2040
2040
        VecSubf(vec2, v1, v2);
2041
2041
        Crossf(n, vec1, vec2);
2042
 
        len= Normalise(n);
 
2042
        len= Normalize(n);
2043
2043
 
2044
2044
        return (len/2.0f);
2045
2045
}
2403
2403
        quat[2]= vec[1];
2404
2404
        quat[3]= vec[2];
2405
2405
                                                                                                           
2406
 
        if( Normalise(quat+1) == 0.0) {
 
2406
        if( Normalize(quat+1) == 0.0) {
2407
2407
                QuatOne(quat);
2408
2408
        }
2409
2409
        else {
2424
2424
 
2425
2425
        VecSubf(vec1, v2, v1);
2426
2426
        VecSubf(vec2, v2, v3);
2427
 
        Normalise(vec1);
2428
 
        Normalise(vec2);
 
2427
        Normalize(vec1);
 
2428
        Normalize(vec2);
2429
2429
 
2430
2430
        return NormalizedVecAngle2(vec1, vec2) * 180.0/M_PI;
2431
2431
}
2437
2437
 
2438
2438
        VecCopyf(vec1, v1);
2439
2439
        VecCopyf(vec2, v2);
2440
 
        Normalise(vec1);
2441
 
        Normalise(vec2);
 
2440
        Normalize(vec1);
 
2441
        Normalize(vec2);
2442
2442
 
2443
2443
        return NormalizedVecAngle2(vec1, vec2)* 180.0/M_PI;
2444
2444
}
2585
2585
        float vec[3];
2586
2586
 
2587
2587
        VecCopyf(vec, mat[0]);
2588
 
        size[0]= Normalise(vec);
 
2588
        size[0]= Normalize(vec);
2589
2589
        VecCopyf(vec, mat[1]);
2590
 
        size[1]= Normalise(vec);
 
2590
        size[1]= Normalize(vec);
2591
2591
        VecCopyf(vec, mat[2]);
2592
 
        size[2]= Normalise(vec);
 
2592
        size[2]= Normalize(vec);
2593
2593
 
2594
2594
}
2595
2595
 
2599
2599
        
2600
2600
 
2601
2601
        VecCopyf(vec, mat[0]);
2602
 
        size[0]= Normalise(vec);
 
2602
        size[0]= Normalize(vec);
2603
2603
        VecCopyf(vec, mat[1]);
2604
 
        size[1]= Normalise(vec);
 
2604
        size[1]= Normalize(vec);
2605
2605
        VecCopyf(vec, mat[2]);
2606
 
        size[2]= Normalise(vec);
 
2606
        size[2]= Normalize(vec);
2607
2607
}
2608
2608
 
2609
2609
/* ************* SPECIALS ******************* */
2619
2619
        n[0]= vec[1];
2620
2620
        n[1]= -vec[0];
2621
2621
        n[2]= 0.0;
2622
 
        Normalise(n);
 
2622
        Normalize(n);
2623
2623
        
2624
2624
        if(n[0]==0.0 && n[1]==0.0) n[0]= 1.0;
2625
2625
        
2639
2639
 
2640
2640
        /* what angle has this line with x-axis? */
2641
2641
        vec[2]= 0.0;
2642
 
        Normalise(vec);
 
2642
        Normalize(vec);
2643
2643
 
2644
2644
        angle= (float)(0.5*atan2(vec[1], vec[0]));
2645
2645
        co= (float)cos(angle);
2700
2700
        return v1[0]*v2[0]+v1[1]*v2[1];
2701
2701
}
2702
2702
 
2703
 
float Normalise2(float *n)
 
2703
float Normalize2(float *n)
2704
2704
{
2705
2705
        float d;
2706
2706