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