1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
|
/* -*-c++-*- OpenSceneGraph - Copyright (C) 1998-2006 Robert Osfield
*
* This library is open source and may be redistributed and/or modified under
* the terms of the OpenSceneGraph Public License (OSGPL) version 0.0 or
* (at your option) any later version. The full license is in LICENSE file
* included with this distribution, and on the openscenegraph.org website.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* OpenSceneGraph Public License for more details.
*/
#ifndef OSG_VEC2F
#define OSG_VEC2F 1
#include <osg/Math>
namespace osg {
/** General purpose float pair. Uses include representation of
* texture coordinates.
* No support yet added for float * Vec2f - is it necessary?
* Need to define a non-member non-friend operator* etc.
* BTW: Vec2f * float is okay
*/
class Vec2f
{
public:
/** Type of Vec class.*/
typedef float value_type;
/** Number of vector components. */
enum { num_components = 2 };
/** Vec member varaible. */
value_type _v[2];
Vec2f() {_v[0]=0.0; _v[1]=0.0;}
Vec2f(value_type x,value_type y) { _v[0]=x; _v[1]=y; }
inline bool operator == (const Vec2f& v) const { return _v[0]==v._v[0] && _v[1]==v._v[1]; }
inline bool operator != (const Vec2f& v) const { return _v[0]!=v._v[0] || _v[1]!=v._v[1]; }
inline bool operator < (const Vec2f& v) const
{
if (_v[0]<v._v[0]) return true;
else if (_v[0]>v._v[0]) return false;
else return (_v[1]<v._v[1]);
}
inline value_type * ptr() { return _v; }
inline const value_type * ptr() const { return _v; }
inline void set( value_type x, value_type y ) { _v[0]=x; _v[1]=y; }
inline value_type & operator [] (int i) { return _v[i]; }
inline value_type operator [] (int i) const { return _v[i]; }
inline value_type & x() { return _v[0]; }
inline value_type & y() { return _v[1]; }
inline value_type x() const { return _v[0]; }
inline value_type y() const { return _v[1]; }
inline bool valid() const { return !isNaN(); }
inline bool isNaN() const { return osg::isNaN(_v[0]) || osg::isNaN(_v[1]); }
/** Dot product. */
inline value_type operator * (const Vec2f& rhs) const
{
return _v[0]*rhs._v[0]+_v[1]*rhs._v[1];
}
/** Multiply by scalar. */
inline const Vec2f operator * (value_type rhs) const
{
return Vec2f(_v[0]*rhs, _v[1]*rhs);
}
/** Unary multiply by scalar. */
inline Vec2f& operator *= (value_type rhs)
{
_v[0]*=rhs;
_v[1]*=rhs;
return *this;
}
/** Divide by scalar. */
inline const Vec2f operator / (value_type rhs) const
{
return Vec2f(_v[0]/rhs, _v[1]/rhs);
}
/** Unary divide by scalar. */
inline Vec2f& operator /= (value_type rhs)
{
_v[0]/=rhs;
_v[1]/=rhs;
return *this;
}
/** Binary vector add. */
inline const Vec2f operator + (const Vec2f& rhs) const
{
return Vec2f(_v[0]+rhs._v[0], _v[1]+rhs._v[1]);
}
/** Unary vector add. Slightly more efficient because no temporary
* intermediate object.
*/
inline Vec2f& operator += (const Vec2f& rhs)
{
_v[0] += rhs._v[0];
_v[1] += rhs._v[1];
return *this;
}
/** Binary vector subtract. */
inline const Vec2f operator - (const Vec2f& rhs) const
{
return Vec2f(_v[0]-rhs._v[0], _v[1]-rhs._v[1]);
}
/** Unary vector subtract. */
inline Vec2f& operator -= (const Vec2f& rhs)
{
_v[0]-=rhs._v[0];
_v[1]-=rhs._v[1];
return *this;
}
/** Negation operator. Returns the negative of the Vec2f. */
inline const Vec2f operator - () const
{
return Vec2f (-_v[0], -_v[1]);
}
/** Length of the vector = sqrt( vec . vec ) */
inline value_type length() const
{
return sqrtf( _v[0]*_v[0] + _v[1]*_v[1] );
}
/** Length squared of the vector = vec . vec */
inline value_type length2( void ) const
{
return _v[0]*_v[0] + _v[1]*_v[1];
}
/** Normalize the vector so that it has length unity.
* Returns the previous length of the vector.
*/
inline value_type normalize()
{
value_type norm = Vec2f::length();
if (norm>0.0)
{
value_type inv = 1.0f/norm;
_v[0] *= inv;
_v[1] *= inv;
}
return( norm );
}
}; // end of class Vec2f
} // end of namespace osg
#endif
|
