← Back to branch summary

~ubuntu-branches/ubuntu/maverick/blender/maverick

« back to all changes in this revision

Viewing changes to extern/qdune/core/Bound.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Khashayar Naderehvandi, Khashayar Naderehvandi, Alessio Treglia
  • Date: 2009-01-22 16:53:59 UTC
  • mfrom: (14.1.1 experimental)
  • Revision ID: james.westby@ubuntu.com-20090122165359-v0996tn7fbit64ni
Tags: 2.48a+dfsg-1ubuntu1
https://launchpad.net/bugs/320045
[ Khashayar Naderehvandi ]
* Merge from debian experimental (LP: #320045), Ubuntu remaining changes:
  - Add patch correcting header file locations.
  - Add libvorbis-dev and libgsm1-dev to Build-Depends.
  - Use avcodec_decode_audio2() in source/blender/src/hddaudio.c

[ Alessio Treglia ]
* Add missing previous changelog entries.

Show diffs side-by-side

added added

removed removed

Lines of Context:
extern/qdune/core/Bound.cpp
1
 
#include "Bound.h"
2
 
#include "Transform.h"
3
 
 
4
 
#include "QDRender.h"
5
 
__BEGIN_QDRENDER
6
 
 
7
 
void Bound::transform(const Transform* m)
8
 
{
9
 
        // from Graphic Gems I, by Jim Arvo
10
 
        Point3 amin(minmax[0]), amax(minmax[1]);
11
 
        // matrix4 is row major, so tranpose used here, translate is in m[][3]
12
 
        Point3 bmin((*m)[0][3], (*m)[1][3], (*m)[2][3]);
13
 
        Point3 bmax(bmin);
14
 
        for (int i=0; i<3; ++i)
15
 
                for (int j=0; j<3; ++j) {
16
 
                        float a = (*m)[i][j] * amin[j];
17
 
                        float b = (*m)[i][j] * amax[j];
18
 
                        if (a < b) {
19
 
                                bmin[i] += a;
20
 
                                bmax[i] += b;
21
 
                        }
22
 
                        else {
23
 
                                bmin[i] += b;
24
 
                                bmax[i] += a;
25
 
                        }
26
 
                }
27
 
        minmax[0] = bmin;
28
 
        minmax[1] = bmax;
29
 
}
30
 
 
31
 
void Bound::include(const Point3 &pt)
32
 
{
33
 
        if (pt.x < minmax[0].x) minmax[0].x = pt.x;
34
 
        if (pt.y < minmax[0].y) minmax[0].y = pt.y;
35
 
        if (pt.z < minmax[0].z) minmax[0].z = pt.z;
36
 
        if (pt.x > minmax[1].x) minmax[1].x = pt.x;
37
 
        if (pt.y > minmax[1].y) minmax[1].y = pt.y;
38
 
        if (pt.z > minmax[1].z) minmax[1].z = pt.z;
39
 
}
40
 
 
41
 
void Bound::include(const RtPoint pt)
42
 
{
43
 
        if (pt[0] < minmax[0].x) minmax[0].x = pt[0];
44
 
        if (pt[1] < minmax[0].y) minmax[0].y = pt[1];
45
 
        if (pt[2] < minmax[0].z) minmax[0].z = pt[2];
46
 
        if (pt[0] > minmax[1].x) minmax[1].x = pt[0];
47
 
        if (pt[1] > minmax[1].y) minmax[1].y = pt[1];
48
 
        if (pt[2] > minmax[1].z) minmax[1].z = pt[2];
49
 
}
50
 
 
51
 
void Bound::include(const Bound &b)
52
 
{
53
 
        include(b.minmax[0]);
54
 
        include(b.minmax[1]);
55
 
}
56
 
 
57
 
int Bound::longestAxis()
58
 
{
59
 
        const Vector bdim = minmax[1] - minmax[0];
60
 
        if ((bdim.x > bdim.y) && (bdim.x > bdim.z))
61
 
                return X_AXIS;
62
 
        if (bdim.y > bdim.z)
63
 
                return Y_AXIS;
64
 
        return Z_AXIS;
65
 
}
66
 
 
67
 
bool Bound::isInside(const Point3 &pt) const
68
 
{
69
 
        return ((pt.x>=minmax[0].x) && (pt.y>=minmax[0].y) && (pt.z>=minmax[0].z) &&
70
 
                (pt.x<=minmax[1].x) && (pt.y<=minmax[1].y) && (pt.z<=minmax[1].z));
71
 
}
72
 
 
73
 
 
74
 
#if 0
75
 
bool Bound::intersect(const Ray_t &r, float t0, float t1) const
76
 
{
77
 
        float tmin = (minmax[r.sign[0]].x - r.origin.x) * r.inv_direction.x;
78
 
        float tmax = (minmax[1-r.sign[0]].x - r.origin.x) * r.inv_direction.x;
79
 
        float tymin = (minmax[r.sign[1]].y - r.origin.y) * r.inv_direction.y;
80
 
        float tymax = (minmax[1-r.sign[1]].y - r.origin.y) * r.inv_direction.y;
81
 
        if ((tmin > tymax) || (tymin > tmax)) return false;
82
 
        if (tymin > tmin) tmin = tymin;
83
 
        if (tymax < tmax) tmax = tymax;
84
 
        float tzmin = (minmax[r.sign[2]].z - r.origin.z) * r.inv_direction.z;
85
 
        float tzmax = (minmax[1-r.sign[2]].z - r.origin.z) * r.inv_direction.z;
86
 
        if ((tmin > tzmax) || (tzmin > tmax)) return false;
87
 
        if (tzmin > tmin) tmin = tzmin;
88
 
        if (tzmax < tmax) tmax = tzmax;
89
 
        return ((tmin < t1) && (tmax > t0));
90
 
}
91
 
#endif
92
 
 
93
 
__END_QDRENDER
94