Branch data Line data Source code
1 : : #ifndef GFXMATH_VEC3_INCLUDED // -*- C++ -*-
2 : : #define GFXMATH_VEC3_INCLUDED
3 : :
4 : : /************************************************************************
5 : :
6 : : 3D Vector class.
7 : :
8 : : $Id: Vec3.h,v 1.6 1997/03/17 22:52:26 garland Exp $
9 : :
10 : : ************************************************************************/
11 : :
12 : : class Vec3 {
13 : : private:
14 : : double elt[3];
15 : :
16 : : protected:
17 : : inline void copy(const Vec3& v);
18 : :
19 : : public:
20 : : //
21 : : // Standard constructors
22 : : //
23 : 2901634 : Vec3(double x=0, double y=0, double z=0) { elt[0]=x; elt[1]=y; elt[2]=z; }
24 : : #ifdef GFXMATH_VEC2_INCLUDED
25 : : Vec3(const Vec2& v, double z) { elt[0]=v[0]; elt[1]=v[1]; elt[2]=z; }
26 : : #endif
27 : 1088 : Vec3(const Vec3& v) { copy(v); }
28 : : Vec3(const double *v) { elt[0]=v[0]; elt[1]=v[1]; elt[2]=v[2]; }
29 : :
30 : : //
31 : : // Access methods
32 : : //
33 : : #ifdef SAFETY
34 : : double& operator()(int i) { assert(i>=0 && i<3); return elt[i]; }
35 : : double operator()(int i) const { assert(i>=0 && i<3); return elt[i]; }
36 : : #else
37 : : double& operator()(int i) { return elt[i]; }
38 : : double operator()(int i) const { return elt[i]; }
39 : : #endif
40 : 7499076 : double& operator[](int i) { return elt[i]; }
41 : 860580 : double operator[](int i) const { return elt[i]; }
42 : :
43 : : double *raw() { return elt; }
44 : : const double *raw() const { return elt; }
45 : :
46 : : //
47 : : // Comparison operators
48 : : //
49 : : inline bool operator==(const Vec3& v) const;
50 : : inline bool operator!=(const Vec3& v) const;
51 : :
52 : : //
53 : : // Assignment and in-place arithmetic methods
54 : : //
55 : : inline void set(double x, double y, double z) { elt[0]=x; elt[1]=y; elt[2]=z; }
56 : : inline Vec3& operator=(const Vec3& v);
57 : : inline Vec3& operator+=(const Vec3& v);
58 : : inline Vec3& operator-=(const Vec3& v);
59 : : inline Vec3& operator*=(double s);
60 : : inline Vec3& operator/=(double s);
61 : :
62 : : //
63 : : // Binary arithmetic methods
64 : : //
65 : : inline Vec3 operator+(const Vec3& v) const;
66 : : inline Vec3 operator-(const Vec3& v) const;
67 : : inline Vec3 operator-() const;
68 : :
69 : : inline Vec3 operator*(double s) const;
70 : : inline Vec3 operator/(double s) const;
71 : : inline double operator*(const Vec3& v) const;
72 : : inline Vec3 operator^(const Vec3& v) const;
73 : : };
74 : :
75 : :
76 : :
77 : : ////////////////////////////////////////////////////////////////////////
78 : : //
79 : : // Method definitions
80 : : //
81 : :
82 : 1680820 : inline void Vec3::copy(const Vec3& v)
83 : : {
84 : 1680820 : elt[0]=v.elt[0]; elt[1]=v.elt[1]; elt[2]=v.elt[2];
85 : 1680820 : }
86 : :
87 : : inline bool Vec3::operator==(const Vec3& v) const
88 : : {
89 : : double dx=elt[X]-v[X], dy=elt[Y]-v[Y], dz=elt[Z]-v[Z];
90 : : return (dx*dx + dy*dy + dz*dz) < FEQ_EPS2;
91 : : }
92 : :
93 : : inline bool Vec3::operator!=(const Vec3& v) const
94 : : {
95 : : double dx=elt[X]-v[X], dy=elt[Y]-v[Y], dz=elt[Z]-v[Z];
96 : : return (dx*dx + dy*dy + dz*dz) > FEQ_EPS2;
97 : : }
98 : :
99 : 1680276 : inline Vec3& Vec3::operator=(const Vec3& v)
100 : : {
101 : 1680276 : copy(v);
102 : 1680276 : return *this;
103 : : }
104 : :
105 : 0 : inline Vec3& Vec3::operator+=(const Vec3& v)
106 : : {
107 : 0 : elt[0] += v[0]; elt[1] += v[1]; elt[2] += v[2];
108 : 0 : return *this;
109 : : }
110 : :
111 : : inline Vec3& Vec3::operator-=(const Vec3& v)
112 : : {
113 : : elt[0] -= v[0]; elt[1] -= v[1]; elt[2] -= v[2];
114 : : return *this;
115 : : }
116 : :
117 : : inline Vec3& Vec3::operator*=(double s)
118 : : {
119 : : elt[0] *= s; elt[1] *= s; elt[2] *= s;
120 : : return *this;
121 : : }
122 : :
123 : 10400 : inline Vec3& Vec3::operator/=(double s)
124 : : {
125 : 10400 : elt[0] /= s; elt[1] /= s; elt[2] /= s;
126 : 10400 : return *this;
127 : : }
128 : :
129 : :
130 : 2 : inline Vec3 Vec3::operator+(const Vec3& v) const
131 : : {
132 : 2 : return Vec3(elt[0]+v[0], elt[1]+v[1], elt[2]+v[2]);
133 : : }
134 : :
135 : 20402 : inline Vec3 Vec3::operator-(const Vec3& v) const
136 : : {
137 : 20402 : return Vec3(elt[0]-v[0], elt[1]-v[1], elt[2]-v[2]);
138 : : }
139 : :
140 : 10400 : inline Vec3 Vec3::operator-() const
141 : : {
142 : 10400 : return Vec3(-elt[0], -elt[1], -elt[2]);
143 : : }
144 : :
145 : 4 : inline Vec3 Vec3::operator*(double s) const
146 : : {
147 : 4 : return Vec3(elt[0]*s, elt[1]*s, elt[2]*s);
148 : : }
149 : :
150 : 0 : inline Vec3 Vec3::operator/(double s) const
151 : : {
152 : 0 : return Vec3(elt[0]/s, elt[1]/s, elt[2]/s);
153 : : }
154 : :
155 : 10406 : inline double Vec3::operator*(const Vec3& v) const
156 : : {
157 : 10406 : return elt[0]*v[0] + elt[1]*v[1] + elt[2]*v[2];
158 : : }
159 : :
160 : 10400 : inline Vec3 Vec3::operator^(const Vec3& v) const
161 : : {
162 : 10400 : Vec3 w( elt[1]*v[2] - v[1]*elt[2],
163 : 10400 : -elt[0]*v[2] + v[0]*elt[2],
164 : 20800 : elt[0]*v[1] - v[0]*elt[1] );
165 : 10400 : return w;
166 : : }
167 : :
168 : : // Make scalar multiplication commutative
169 : 8 : inline Vec3 operator*(double s, const Vec3& v) { return v*s; }
170 : :
171 : :
172 : :
173 : : ////////////////////////////////////////////////////////////////////////
174 : : //
175 : : // Primitive function definitions
176 : : //
177 : :
178 : 0 : inline double norm(const Vec3& v)
179 : : {
180 : 0 : return sqrt(v[0]*v[0] + v[1]*v[1] + v[2]*v[2]);
181 : : }
182 : :
183 : 10400 : inline double norm2(const Vec3& v)
184 : : {
185 : 10400 : return v[0]*v[0] + v[1]*v[1] + v[2]*v[2];
186 : : }
187 : :
188 : 0 : inline double length(const Vec3& v) { return norm(v); }
189 : :
190 : :
191 : 10400 : inline double unitize(Vec3& v)
192 : : {
193 : 10400 : double l=norm2(v);
194 [ + - ][ + - ]: 10400 : if( l!=1.0 && l!=0.0 )
195 : : {
196 : 10400 : l = sqrt(l);
197 : 10400 : v /= l;
198 : : }
199 : 10400 : return l;
200 : : }
201 : :
202 : :
203 : :
204 : : ////////////////////////////////////////////////////////////////////////
205 : : //
206 : : // Misc. function definitions
207 : : //
208 : :
209 : : inline std::ostream& operator<<(std::ostream& out, const Vec3& v)
210 : : {
211 : : return out << "[" << v[0] << " " << v[1] << " " << v[2] << "]";
212 : : }
213 : :
214 : : #ifdef GFXGL_INCLUDED
215 : : inline void glV(const Vec3& v) { glVertex(v[X], v[Y], v[Z]); }
216 : : inline void glN(const Vec3& v) { glNormal(v[X], v[Y], v[Z]); }
217 : : inline void glC(const Vec3& v) { glColor(v[X], v[Y], v[Z]); }
218 : : #endif
219 : :
220 : :
221 : : // GFXMATH_VEC3_INCLUDED
222 : : #endif
|
