diff options
Diffstat (limited to 'libraries/ModifiedBulletX/MonoXnaCompactMaths/Vector3.cs')
-rw-r--r-- | libraries/ModifiedBulletX/MonoXnaCompactMaths/Vector3.cs | 1240 |
1 files changed, 620 insertions, 620 deletions
diff --git a/libraries/ModifiedBulletX/MonoXnaCompactMaths/Vector3.cs b/libraries/ModifiedBulletX/MonoXnaCompactMaths/Vector3.cs index fd4bcd2..f246415 100644 --- a/libraries/ModifiedBulletX/MonoXnaCompactMaths/Vector3.cs +++ b/libraries/ModifiedBulletX/MonoXnaCompactMaths/Vector3.cs | |||
@@ -1,620 +1,620 @@ | |||
1 | #region License | 1 | #region License |
2 | /* | 2 | /* |
3 | MIT License | 3 | MIT License |
4 | Copyright © 2006 The Mono.Xna Team | 4 | Copyright © 2006 The Mono.Xna Team |
5 | 5 | ||
6 | All rights reserved. | 6 | All rights reserved. |
7 | 7 | ||
8 | Authors: | 8 | Authors: |
9 | * Alan McGovern | 9 | * Alan McGovern |
10 | 10 | ||
11 | Permission is hereby granted, free of charge, to any person obtaining a copy | 11 | Permission is hereby granted, free of charge, to any person obtaining a copy |
12 | of this software and associated documentation files (the "Software"), to deal | 12 | of this software and associated documentation files (the "Software"), to deal |
13 | in the Software without restriction, including without limitation the rights | 13 | in the Software without restriction, including without limitation the rights |
14 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | 14 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell |
15 | copies of the Software, and to permit persons to whom the Software is | 15 | copies of the Software, and to permit persons to whom the Software is |
16 | furnished to do so, subject to the following conditions: | 16 | furnished to do so, subject to the following conditions: |
17 | 17 | ||
18 | The above copyright notice and this permission notice shall be included in all | 18 | The above copyright notice and this permission notice shall be included in all |
19 | copies or substantial portions of the Software. | 19 | copies or substantial portions of the Software. |
20 | 20 | ||
21 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | 21 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
22 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | 22 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
23 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | 23 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
24 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | 24 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
25 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | 25 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, |
26 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | 26 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE |
27 | SOFTWARE. | 27 | SOFTWARE. |
28 | */ | 28 | */ |
29 | #endregion License | 29 | #endregion License |
30 | 30 | ||
31 | using System; | 31 | using System; |
32 | using System.ComponentModel; | 32 | using System.ComponentModel; |
33 | using System.Text; | 33 | using System.Text; |
34 | using System.Runtime.InteropServices; | 34 | using System.Runtime.InteropServices; |
35 | 35 | ||
36 | namespace MonoXnaCompactMaths | 36 | namespace MonoXnaCompactMaths |
37 | { | 37 | { |
38 | [Serializable] | 38 | [Serializable] |
39 | [StructLayout(LayoutKind.Sequential)] | 39 | [StructLayout(LayoutKind.Sequential)] |
40 | //[TypeConverter(typeof(Vector3Converter))] | 40 | //[TypeConverter(typeof(Vector3Converter))] |
41 | public struct Vector3 : IEquatable<Vector3> | 41 | public struct Vector3 : IEquatable<Vector3> |
42 | { | 42 | { |
43 | #region Private Fields | 43 | #region Private Fields |
44 | 44 | ||
45 | private static Vector3 zero = new Vector3(0f, 0f, 0f); | 45 | private static Vector3 zero = new Vector3(0f, 0f, 0f); |
46 | private static Vector3 one = new Vector3(1f, 1f, 1f); | 46 | private static Vector3 one = new Vector3(1f, 1f, 1f); |
47 | private static Vector3 unitX = new Vector3(1f, 0f, 0f); | 47 | private static Vector3 unitX = new Vector3(1f, 0f, 0f); |
48 | private static Vector3 unitY = new Vector3(0f, 1f, 0f); | 48 | private static Vector3 unitY = new Vector3(0f, 1f, 0f); |
49 | private static Vector3 unitZ = new Vector3(0f, 0f, 1f); | 49 | private static Vector3 unitZ = new Vector3(0f, 0f, 1f); |
50 | private static Vector3 up = new Vector3(0f, 1f, 0f); | 50 | private static Vector3 up = new Vector3(0f, 1f, 0f); |
51 | private static Vector3 down = new Vector3(0f, -1f, 0f); | 51 | private static Vector3 down = new Vector3(0f, -1f, 0f); |
52 | private static Vector3 right = new Vector3(1f, 0f, 0f); | 52 | private static Vector3 right = new Vector3(1f, 0f, 0f); |
53 | private static Vector3 left = new Vector3(-1f, 0f, 0f); | 53 | private static Vector3 left = new Vector3(-1f, 0f, 0f); |
54 | private static Vector3 forward = new Vector3(0f, 0f, -1f); | 54 | private static Vector3 forward = new Vector3(0f, 0f, -1f); |
55 | private static Vector3 backward = new Vector3(0f, 0f, 1f); | 55 | private static Vector3 backward = new Vector3(0f, 0f, 1f); |
56 | 56 | ||
57 | #endregion Private Fields | 57 | #endregion Private Fields |
58 | 58 | ||
59 | 59 | ||
60 | #region Public Fields | 60 | #region Public Fields |
61 | 61 | ||
62 | public float X; | 62 | public float X; |
63 | public float Y; | 63 | public float Y; |
64 | public float Z; | 64 | public float Z; |
65 | 65 | ||
66 | #endregion Public Fields | 66 | #endregion Public Fields |
67 | 67 | ||
68 | 68 | ||
69 | #region Properties | 69 | #region Properties |
70 | 70 | ||
71 | public static Vector3 Zero | 71 | public static Vector3 Zero |
72 | { | 72 | { |
73 | get { return zero; } | 73 | get { return zero; } |
74 | } | 74 | } |
75 | 75 | ||
76 | public static Vector3 One | 76 | public static Vector3 One |
77 | { | 77 | { |
78 | get { return one; } | 78 | get { return one; } |
79 | } | 79 | } |
80 | 80 | ||
81 | public static Vector3 UnitX | 81 | public static Vector3 UnitX |
82 | { | 82 | { |
83 | get { return unitX; } | 83 | get { return unitX; } |
84 | } | 84 | } |
85 | 85 | ||
86 | public static Vector3 UnitY | 86 | public static Vector3 UnitY |
87 | { | 87 | { |
88 | get { return unitY; } | 88 | get { return unitY; } |
89 | } | 89 | } |
90 | 90 | ||
91 | public static Vector3 UnitZ | 91 | public static Vector3 UnitZ |
92 | { | 92 | { |
93 | get { return unitZ; } | 93 | get { return unitZ; } |
94 | } | 94 | } |
95 | 95 | ||
96 | public static Vector3 Up | 96 | public static Vector3 Up |
97 | { | 97 | { |
98 | get { return up; } | 98 | get { return up; } |
99 | } | 99 | } |
100 | 100 | ||
101 | public static Vector3 Down | 101 | public static Vector3 Down |
102 | { | 102 | { |
103 | get { return down; } | 103 | get { return down; } |
104 | } | 104 | } |
105 | 105 | ||
106 | public static Vector3 Right | 106 | public static Vector3 Right |
107 | { | 107 | { |
108 | get { return right; } | 108 | get { return right; } |
109 | } | 109 | } |
110 | 110 | ||
111 | public static Vector3 Left | 111 | public static Vector3 Left |
112 | { | 112 | { |
113 | get { return left; } | 113 | get { return left; } |
114 | } | 114 | } |
115 | 115 | ||
116 | public static Vector3 Forward | 116 | public static Vector3 Forward |
117 | { | 117 | { |
118 | get { return forward; } | 118 | get { return forward; } |
119 | } | 119 | } |
120 | 120 | ||
121 | public static Vector3 Backward | 121 | public static Vector3 Backward |
122 | { | 122 | { |
123 | get { return backward; } | 123 | get { return backward; } |
124 | } | 124 | } |
125 | 125 | ||
126 | #endregion Properties | 126 | #endregion Properties |
127 | 127 | ||
128 | 128 | ||
129 | #region Constructors | 129 | #region Constructors |
130 | 130 | ||
131 | public Vector3(float x, float y, float z) | 131 | public Vector3(float x, float y, float z) |
132 | { | 132 | { |
133 | this.X = x; | 133 | this.X = x; |
134 | this.Y = y; | 134 | this.Y = y; |
135 | this.Z = z; | 135 | this.Z = z; |
136 | } | 136 | } |
137 | 137 | ||
138 | 138 | ||
139 | public Vector3(float value) | 139 | public Vector3(float value) |
140 | { | 140 | { |
141 | this.X = value; | 141 | this.X = value; |
142 | this.Y = value; | 142 | this.Y = value; |
143 | this.Z = value; | 143 | this.Z = value; |
144 | } | 144 | } |
145 | 145 | ||
146 | 146 | ||
147 | /*public Vector3(Vector2 value, float z) | 147 | /*public Vector3(Vector2 value, float z) |
148 | { | 148 | { |
149 | this.X = value.X; | 149 | this.X = value.X; |
150 | this.Y = value.Y; | 150 | this.Y = value.Y; |
151 | this.Z = z; | 151 | this.Z = z; |
152 | }*/ | 152 | }*/ |
153 | 153 | ||
154 | 154 | ||
155 | #endregion Constructors | 155 | #endregion Constructors |
156 | 156 | ||
157 | 157 | ||
158 | #region Public Methods | 158 | #region Public Methods |
159 | 159 | ||
160 | public static Vector3 Add(Vector3 value1, Vector3 value2) | 160 | public static Vector3 Add(Vector3 value1, Vector3 value2) |
161 | { | 161 | { |
162 | value1.X += value2.X; | 162 | value1.X += value2.X; |
163 | value1.Y += value2.Y; | 163 | value1.Y += value2.Y; |
164 | value1.Z += value2.Z; | 164 | value1.Z += value2.Z; |
165 | return value1; | 165 | return value1; |
166 | } | 166 | } |
167 | 167 | ||
168 | public static void Add(ref Vector3 value1, ref Vector3 value2, out Vector3 result) | 168 | public static void Add(ref Vector3 value1, ref Vector3 value2, out Vector3 result) |
169 | { | 169 | { |
170 | result.X = value1.X + value2.X; | 170 | result.X = value1.X + value2.X; |
171 | result.Y = value1.Y + value2.Y; | 171 | result.Y = value1.Y + value2.Y; |
172 | result.Z = value1.Z + value2.Z; | 172 | result.Z = value1.Z + value2.Z; |
173 | } | 173 | } |
174 | 174 | ||
175 | /*public static Vector3 Barycentric(Vector3 value1, Vector3 value2, Vector3 value3, float amount1, float amount2) | 175 | /*public static Vector3 Barycentric(Vector3 value1, Vector3 value2, Vector3 value3, float amount1, float amount2) |
176 | { | 176 | { |
177 | return new Vector3( | 177 | return new Vector3( |
178 | MathHelper.Barycentric(value1.X, value2.X, value3.X, amount1, amount2), | 178 | MathHelper.Barycentric(value1.X, value2.X, value3.X, amount1, amount2), |
179 | MathHelper.Barycentric(value1.Y, value2.Y, value3.Y, amount1, amount2), | 179 | MathHelper.Barycentric(value1.Y, value2.Y, value3.Y, amount1, amount2), |
180 | MathHelper.Barycentric(value1.Z, value2.Z, value3.Z, amount1, amount2)); | 180 | MathHelper.Barycentric(value1.Z, value2.Z, value3.Z, amount1, amount2)); |
181 | }*/ | 181 | }*/ |
182 | 182 | ||
183 | /*public static void Barycentric(ref Vector3 value1, ref Vector3 value2, ref Vector3 value3, float amount1, float amount2, out Vector3 result) | 183 | /*public static void Barycentric(ref Vector3 value1, ref Vector3 value2, ref Vector3 value3, float amount1, float amount2, out Vector3 result) |
184 | { | 184 | { |
185 | result = new Vector3( | 185 | result = new Vector3( |
186 | MathHelper.Barycentric(value1.X, value2.X, value3.X, amount1, amount2), | 186 | MathHelper.Barycentric(value1.X, value2.X, value3.X, amount1, amount2), |
187 | MathHelper.Barycentric(value1.Y, value2.Y, value3.Y, amount1, amount2), | 187 | MathHelper.Barycentric(value1.Y, value2.Y, value3.Y, amount1, amount2), |
188 | MathHelper.Barycentric(value1.Z, value2.Z, value3.Z, amount1, amount2)); | 188 | MathHelper.Barycentric(value1.Z, value2.Z, value3.Z, amount1, amount2)); |
189 | }*/ | 189 | }*/ |
190 | 190 | ||
191 | /*public static Vector3 CatmullRom(Vector3 value1, Vector3 value2, Vector3 value3, Vector3 value4, float amount) | 191 | /*public static Vector3 CatmullRom(Vector3 value1, Vector3 value2, Vector3 value3, Vector3 value4, float amount) |
192 | { | 192 | { |
193 | return new Vector3( | 193 | return new Vector3( |
194 | MathHelper.CatmullRom(value1.X, value2.X, value3.X, value4.X, amount), | 194 | MathHelper.CatmullRom(value1.X, value2.X, value3.X, value4.X, amount), |
195 | MathHelper.CatmullRom(value1.Y, value2.Y, value3.Y, value4.Y, amount), | 195 | MathHelper.CatmullRom(value1.Y, value2.Y, value3.Y, value4.Y, amount), |
196 | MathHelper.CatmullRom(value1.Z, value2.Z, value3.Z, value4.Z, amount)); | 196 | MathHelper.CatmullRom(value1.Z, value2.Z, value3.Z, value4.Z, amount)); |
197 | }*/ | 197 | }*/ |
198 | 198 | ||
199 | /*public static void CatmullRom(ref Vector3 value1, ref Vector3 value2, ref Vector3 value3, ref Vector3 value4, float amount, out Vector3 result) | 199 | /*public static void CatmullRom(ref Vector3 value1, ref Vector3 value2, ref Vector3 value3, ref Vector3 value4, float amount, out Vector3 result) |
200 | { | 200 | { |
201 | result = new Vector3( | 201 | result = new Vector3( |
202 | MathHelper.CatmullRom(value1.X, value2.X, value3.X, value4.X, amount), | 202 | MathHelper.CatmullRom(value1.X, value2.X, value3.X, value4.X, amount), |
203 | MathHelper.CatmullRom(value1.Y, value2.Y, value3.Y, value4.Y, amount), | 203 | MathHelper.CatmullRom(value1.Y, value2.Y, value3.Y, value4.Y, amount), |
204 | MathHelper.CatmullRom(value1.Z, value2.Z, value3.Z, value4.Z, amount)); | 204 | MathHelper.CatmullRom(value1.Z, value2.Z, value3.Z, value4.Z, amount)); |
205 | }*/ | 205 | }*/ |
206 | 206 | ||
207 | /*public static Vector3 Clamp(Vector3 value1, Vector3 min, Vector3 max) | 207 | /*public static Vector3 Clamp(Vector3 value1, Vector3 min, Vector3 max) |
208 | { | 208 | { |
209 | return new Vector3( | 209 | return new Vector3( |
210 | MathHelper.Clamp(value1.X, min.X, max.X), | 210 | MathHelper.Clamp(value1.X, min.X, max.X), |
211 | MathHelper.Clamp(value1.Y, min.Y, max.Y), | 211 | MathHelper.Clamp(value1.Y, min.Y, max.Y), |
212 | MathHelper.Clamp(value1.Z, min.Z, max.Z)); | 212 | MathHelper.Clamp(value1.Z, min.Z, max.Z)); |
213 | }*/ | 213 | }*/ |
214 | 214 | ||
215 | /*public static void Clamp(ref Vector3 value1, ref Vector3 min, ref Vector3 max, out Vector3 result) | 215 | /*public static void Clamp(ref Vector3 value1, ref Vector3 min, ref Vector3 max, out Vector3 result) |
216 | { | 216 | { |
217 | result = new Vector3( | 217 | result = new Vector3( |
218 | MathHelper.Clamp(value1.X, min.X, max.X), | 218 | MathHelper.Clamp(value1.X, min.X, max.X), |
219 | MathHelper.Clamp(value1.Y, min.Y, max.Y), | 219 | MathHelper.Clamp(value1.Y, min.Y, max.Y), |
220 | MathHelper.Clamp(value1.Z, min.Z, max.Z)); | 220 | MathHelper.Clamp(value1.Z, min.Z, max.Z)); |
221 | }*/ | 221 | }*/ |
222 | 222 | ||
223 | public static Vector3 Cross(Vector3 vector1, Vector3 vector2) | 223 | public static Vector3 Cross(Vector3 vector1, Vector3 vector2) |
224 | { | 224 | { |
225 | Cross(ref vector1, ref vector2, out vector1); | 225 | Cross(ref vector1, ref vector2, out vector1); |
226 | return vector1; | 226 | return vector1; |
227 | } | 227 | } |
228 | 228 | ||
229 | public static void Cross(ref Vector3 vector1, ref Vector3 vector2, out Vector3 result) | 229 | public static void Cross(ref Vector3 vector1, ref Vector3 vector2, out Vector3 result) |
230 | { | 230 | { |
231 | result = new Vector3(vector1.Y * vector2.Z - vector2.Y * vector1.Z, | 231 | result = new Vector3(vector1.Y * vector2.Z - vector2.Y * vector1.Z, |
232 | -(vector1.X * vector2.Z - vector2.X * vector1.Z), | 232 | -(vector1.X * vector2.Z - vector2.X * vector1.Z), |
233 | vector1.X * vector2.Y - vector2.X * vector1.Y); | 233 | vector1.X * vector2.Y - vector2.X * vector1.Y); |
234 | } | 234 | } |
235 | 235 | ||
236 | public static float Distance(Vector3 vector1, Vector3 vector2) | 236 | public static float Distance(Vector3 vector1, Vector3 vector2) |
237 | { | 237 | { |
238 | float result; | 238 | float result; |
239 | DistanceSquared(ref vector1, ref vector2, out result); | 239 | DistanceSquared(ref vector1, ref vector2, out result); |
240 | return (float)Math.Sqrt(result); | 240 | return (float)Math.Sqrt(result); |
241 | } | 241 | } |
242 | 242 | ||
243 | public static void Distance(ref Vector3 value1, ref Vector3 value2, out float result) | 243 | public static void Distance(ref Vector3 value1, ref Vector3 value2, out float result) |
244 | { | 244 | { |
245 | DistanceSquared(ref value1, ref value2, out result); | 245 | DistanceSquared(ref value1, ref value2, out result); |
246 | result = (float)Math.Sqrt(result); | 246 | result = (float)Math.Sqrt(result); |
247 | } | 247 | } |
248 | 248 | ||
249 | public static float DistanceSquared(Vector3 value1, Vector3 value2) | 249 | public static float DistanceSquared(Vector3 value1, Vector3 value2) |
250 | { | 250 | { |
251 | float result; | 251 | float result; |
252 | DistanceSquared(ref value1, ref value2, out result); | 252 | DistanceSquared(ref value1, ref value2, out result); |
253 | return result; | 253 | return result; |
254 | } | 254 | } |
255 | 255 | ||
256 | public static void DistanceSquared(ref Vector3 value1, ref Vector3 value2, out float result) | 256 | public static void DistanceSquared(ref Vector3 value1, ref Vector3 value2, out float result) |
257 | { | 257 | { |
258 | result = (value1.X - value2.X) * (value1.X - value2.X) + | 258 | result = (value1.X - value2.X) * (value1.X - value2.X) + |
259 | (value1.Y - value2.Y) * (value1.Y - value2.Y) + | 259 | (value1.Y - value2.Y) * (value1.Y - value2.Y) + |
260 | (value1.Z - value2.Z) * (value1.Z - value2.Z); | 260 | (value1.Z - value2.Z) * (value1.Z - value2.Z); |
261 | } | 261 | } |
262 | 262 | ||
263 | public static Vector3 Divide(Vector3 value1, Vector3 value2) | 263 | public static Vector3 Divide(Vector3 value1, Vector3 value2) |
264 | { | 264 | { |
265 | value1.X /= value2.X; | 265 | value1.X /= value2.X; |
266 | value1.Y /= value2.Y; | 266 | value1.Y /= value2.Y; |
267 | value1.Z /= value2.Z; | 267 | value1.Z /= value2.Z; |
268 | return value1; | 268 | return value1; |
269 | } | 269 | } |
270 | 270 | ||
271 | public static Vector3 Divide(Vector3 value1, float value2) | 271 | public static Vector3 Divide(Vector3 value1, float value2) |
272 | { | 272 | { |
273 | float factor = 1 / value2; | 273 | float factor = 1 / value2; |
274 | value1.X *= factor; | 274 | value1.X *= factor; |
275 | value1.Y *= factor; | 275 | value1.Y *= factor; |
276 | value1.Z *= factor; | 276 | value1.Z *= factor; |
277 | return value1; | 277 | return value1; |
278 | } | 278 | } |
279 | 279 | ||
280 | public static void Divide(ref Vector3 value1, float divisor, out Vector3 result) | 280 | public static void Divide(ref Vector3 value1, float divisor, out Vector3 result) |
281 | { | 281 | { |
282 | float factor = 1 / divisor; | 282 | float factor = 1 / divisor; |
283 | result.X = value1.X * factor; | 283 | result.X = value1.X * factor; |
284 | result.Y = value1.Y * factor; | 284 | result.Y = value1.Y * factor; |
285 | result.Z = value1.Z * factor; | 285 | result.Z = value1.Z * factor; |
286 | } | 286 | } |
287 | 287 | ||
288 | public static void Divide(ref Vector3 value1, ref Vector3 value2, out Vector3 result) | 288 | public static void Divide(ref Vector3 value1, ref Vector3 value2, out Vector3 result) |
289 | { | 289 | { |
290 | result.X = value1.X / value2.X; | 290 | result.X = value1.X / value2.X; |
291 | result.Y = value1.Y / value2.Y; | 291 | result.Y = value1.Y / value2.Y; |
292 | result.Z = value1.Z / value2.Z; | 292 | result.Z = value1.Z / value2.Z; |
293 | } | 293 | } |
294 | 294 | ||
295 | public static float Dot(Vector3 vector1, Vector3 vector2) | 295 | public static float Dot(Vector3 vector1, Vector3 vector2) |
296 | { | 296 | { |
297 | return vector1.X * vector2.X + vector1.Y * vector2.Y + vector1.Z * vector2.Z; | 297 | return vector1.X * vector2.X + vector1.Y * vector2.Y + vector1.Z * vector2.Z; |
298 | } | 298 | } |
299 | 299 | ||
300 | public static void Dot(ref Vector3 vector1, ref Vector3 vector2, out float result) | 300 | public static void Dot(ref Vector3 vector1, ref Vector3 vector2, out float result) |
301 | { | 301 | { |
302 | result = vector1.X * vector2.X + vector1.Y * vector2.Y + vector1.Z * vector2.Z; | 302 | result = vector1.X * vector2.X + vector1.Y * vector2.Y + vector1.Z * vector2.Z; |
303 | } | 303 | } |
304 | 304 | ||
305 | public override bool Equals(object obj) | 305 | public override bool Equals(object obj) |
306 | { | 306 | { |
307 | return (obj is Vector3) ? this == (Vector3)obj : false; | 307 | return (obj is Vector3) ? this == (Vector3)obj : false; |
308 | } | 308 | } |
309 | 309 | ||
310 | public bool Equals(Vector3 other) | 310 | public bool Equals(Vector3 other) |
311 | { | 311 | { |
312 | return this == other; | 312 | return this == other; |
313 | } | 313 | } |
314 | 314 | ||
315 | public override int GetHashCode() | 315 | public override int GetHashCode() |
316 | { | 316 | { |
317 | return (int)(this.X + this.Y + this.Z); | 317 | return (int)(this.X + this.Y + this.Z); |
318 | } | 318 | } |
319 | 319 | ||
320 | /*public static Vector3 Hermite(Vector3 value1, Vector3 tangent1, Vector3 value2, Vector3 tangent2, float amount) | 320 | /*public static Vector3 Hermite(Vector3 value1, Vector3 tangent1, Vector3 value2, Vector3 tangent2, float amount) |
321 | { | 321 | { |
322 | Vector3 result = new Vector3(); | 322 | Vector3 result = new Vector3(); |
323 | Hermite(ref value1, ref tangent1, ref value2, ref tangent2, amount, out result); | 323 | Hermite(ref value1, ref tangent1, ref value2, ref tangent2, amount, out result); |
324 | return result; | 324 | return result; |
325 | }*/ | 325 | }*/ |
326 | 326 | ||
327 | /*public static void Hermite(ref Vector3 value1, ref Vector3 tangent1, ref Vector3 value2, ref Vector3 tangent2, float amount, out Vector3 result) | 327 | /*public static void Hermite(ref Vector3 value1, ref Vector3 tangent1, ref Vector3 value2, ref Vector3 tangent2, float amount, out Vector3 result) |
328 | { | 328 | { |
329 | result.X = MathHelper.Hermite(value1.X, tangent1.X, value2.X, tangent2.X, amount); | 329 | result.X = MathHelper.Hermite(value1.X, tangent1.X, value2.X, tangent2.X, amount); |
330 | result.Y = MathHelper.Hermite(value1.Y, tangent1.Y, value2.Y, tangent2.Y, amount); | 330 | result.Y = MathHelper.Hermite(value1.Y, tangent1.Y, value2.Y, tangent2.Y, amount); |
331 | result.Z = MathHelper.Hermite(value1.Z, tangent1.Z, value2.Z, tangent2.Z, amount); | 331 | result.Z = MathHelper.Hermite(value1.Z, tangent1.Z, value2.Z, tangent2.Z, amount); |
332 | }*/ | 332 | }*/ |
333 | 333 | ||
334 | public float Length() | 334 | public float Length() |
335 | { | 335 | { |
336 | float result; | 336 | float result; |
337 | DistanceSquared(ref this, ref zero, out result); | 337 | DistanceSquared(ref this, ref zero, out result); |
338 | return (float)Math.Sqrt(result); | 338 | return (float)Math.Sqrt(result); |
339 | } | 339 | } |
340 | 340 | ||
341 | public float LengthSquared() | 341 | public float LengthSquared() |
342 | { | 342 | { |
343 | float result; | 343 | float result; |
344 | DistanceSquared(ref this, ref zero, out result); | 344 | DistanceSquared(ref this, ref zero, out result); |
345 | return result; | 345 | return result; |
346 | } | 346 | } |
347 | 347 | ||
348 | /*public static Vector3 Lerp(Vector3 value1, Vector3 value2, float amount) | 348 | /*public static Vector3 Lerp(Vector3 value1, Vector3 value2, float amount) |
349 | { | 349 | { |
350 | return new Vector3( | 350 | return new Vector3( |
351 | MathHelper.Lerp(value1.X, value2.X, amount), | 351 | MathHelper.Lerp(value1.X, value2.X, amount), |
352 | MathHelper.Lerp(value1.Y, value2.Y, amount), | 352 | MathHelper.Lerp(value1.Y, value2.Y, amount), |
353 | MathHelper.Lerp(value1.Z, value2.Z, amount)); | 353 | MathHelper.Lerp(value1.Z, value2.Z, amount)); |
354 | }*/ | 354 | }*/ |
355 | 355 | ||
356 | /*public static void Lerp(ref Vector3 value1, ref Vector3 value2, float amount, out Vector3 result) | 356 | /*public static void Lerp(ref Vector3 value1, ref Vector3 value2, float amount, out Vector3 result) |
357 | { | 357 | { |
358 | result = new Vector3( | 358 | result = new Vector3( |
359 | MathHelper.Lerp(value1.X, value2.X, amount), | 359 | MathHelper.Lerp(value1.X, value2.X, amount), |
360 | MathHelper.Lerp(value1.Y, value2.Y, amount), | 360 | MathHelper.Lerp(value1.Y, value2.Y, amount), |
361 | MathHelper.Lerp(value1.Z, value2.Z, amount)); | 361 | MathHelper.Lerp(value1.Z, value2.Z, amount)); |
362 | }*/ | 362 | }*/ |
363 | 363 | ||
364 | /*public static Vector3 Max(Vector3 value1, Vector3 value2) | 364 | /*public static Vector3 Max(Vector3 value1, Vector3 value2) |
365 | { | 365 | { |
366 | return new Vector3( | 366 | return new Vector3( |
367 | MathHelper.Max(value1.X, value2.X), | 367 | MathHelper.Max(value1.X, value2.X), |
368 | MathHelper.Max(value1.Y, value2.Y), | 368 | MathHelper.Max(value1.Y, value2.Y), |
369 | MathHelper.Max(value1.Z, value2.Z)); | 369 | MathHelper.Max(value1.Z, value2.Z)); |
370 | }*/ | 370 | }*/ |
371 | 371 | ||
372 | /*public static void Max(ref Vector3 value1, ref Vector3 value2, out Vector3 result) | 372 | /*public static void Max(ref Vector3 value1, ref Vector3 value2, out Vector3 result) |
373 | { | 373 | { |
374 | result = new Vector3( | 374 | result = new Vector3( |
375 | MathHelper.Max(value1.X, value2.X), | 375 | MathHelper.Max(value1.X, value2.X), |
376 | MathHelper.Max(value1.Y, value2.Y), | 376 | MathHelper.Max(value1.Y, value2.Y), |
377 | MathHelper.Max(value1.Z, value2.Z)); | 377 | MathHelper.Max(value1.Z, value2.Z)); |
378 | }*/ | 378 | }*/ |
379 | 379 | ||
380 | /*public static Vector3 Min(Vector3 value1, Vector3 value2) | 380 | /*public static Vector3 Min(Vector3 value1, Vector3 value2) |
381 | { | 381 | { |
382 | return new Vector3( | 382 | return new Vector3( |
383 | MathHelper.Min(value1.X, value2.X), | 383 | MathHelper.Min(value1.X, value2.X), |
384 | MathHelper.Min(value1.Y, value2.Y), | 384 | MathHelper.Min(value1.Y, value2.Y), |
385 | MathHelper.Min(value1.Z, value2.Z)); | 385 | MathHelper.Min(value1.Z, value2.Z)); |
386 | }*/ | 386 | }*/ |
387 | 387 | ||
388 | /*public static void Min(ref Vector3 value1, ref Vector3 value2, out Vector3 result) | 388 | /*public static void Min(ref Vector3 value1, ref Vector3 value2, out Vector3 result) |
389 | { | 389 | { |
390 | result = new Vector3( | 390 | result = new Vector3( |
391 | MathHelper.Min(value1.X, value2.X), | 391 | MathHelper.Min(value1.X, value2.X), |
392 | MathHelper.Min(value1.Y, value2.Y), | 392 | MathHelper.Min(value1.Y, value2.Y), |
393 | MathHelper.Min(value1.Z, value2.Z)); | 393 | MathHelper.Min(value1.Z, value2.Z)); |
394 | }*/ | 394 | }*/ |
395 | 395 | ||
396 | public static Vector3 Multiply(Vector3 value1, Vector3 value2) | 396 | public static Vector3 Multiply(Vector3 value1, Vector3 value2) |
397 | { | 397 | { |
398 | value1.X *= value2.X; | 398 | value1.X *= value2.X; |
399 | value1.Y *= value2.Y; | 399 | value1.Y *= value2.Y; |
400 | value1.Z *= value2.Z; | 400 | value1.Z *= value2.Z; |
401 | return value1; | 401 | return value1; |
402 | } | 402 | } |
403 | 403 | ||
404 | public static Vector3 Multiply(Vector3 value1, float scaleFactor) | 404 | public static Vector3 Multiply(Vector3 value1, float scaleFactor) |
405 | { | 405 | { |
406 | value1.X *= scaleFactor; | 406 | value1.X *= scaleFactor; |
407 | value1.Y *= scaleFactor; | 407 | value1.Y *= scaleFactor; |
408 | value1.Z *= scaleFactor; | 408 | value1.Z *= scaleFactor; |
409 | return value1; | 409 | return value1; |
410 | } | 410 | } |
411 | 411 | ||
412 | public static void Multiply(ref Vector3 value1, float scaleFactor, out Vector3 result) | 412 | public static void Multiply(ref Vector3 value1, float scaleFactor, out Vector3 result) |
413 | { | 413 | { |
414 | result.X = value1.X * scaleFactor; | 414 | result.X = value1.X * scaleFactor; |
415 | result.Y = value1.Y * scaleFactor; | 415 | result.Y = value1.Y * scaleFactor; |
416 | result.Z = value1.Z * scaleFactor; | 416 | result.Z = value1.Z * scaleFactor; |
417 | } | 417 | } |
418 | 418 | ||
419 | public static void Multiply(ref Vector3 value1, ref Vector3 value2, out Vector3 result) | 419 | public static void Multiply(ref Vector3 value1, ref Vector3 value2, out Vector3 result) |
420 | { | 420 | { |
421 | result.X = value1.X * value2.X; | 421 | result.X = value1.X * value2.X; |
422 | result.Y = value1.Y * value2.Y; | 422 | result.Y = value1.Y * value2.Y; |
423 | result.Z = value1.Z * value2.Z; | 423 | result.Z = value1.Z * value2.Z; |
424 | } | 424 | } |
425 | 425 | ||
426 | public static Vector3 Negate(Vector3 value) | 426 | public static Vector3 Negate(Vector3 value) |
427 | { | 427 | { |
428 | value = new Vector3(-value.X, -value.Y, -value.Z); | 428 | value = new Vector3(-value.X, -value.Y, -value.Z); |
429 | return value; | 429 | return value; |
430 | } | 430 | } |
431 | 431 | ||
432 | public static void Negate(ref Vector3 value, out Vector3 result) | 432 | public static void Negate(ref Vector3 value, out Vector3 result) |
433 | { | 433 | { |
434 | result = new Vector3(-value.X, -value.Y, -value.Z); | 434 | result = new Vector3(-value.X, -value.Y, -value.Z); |
435 | } | 435 | } |
436 | 436 | ||
437 | public void Normalize() | 437 | public void Normalize() |
438 | { | 438 | { |
439 | Normalize(ref this, out this); | 439 | Normalize(ref this, out this); |
440 | } | 440 | } |
441 | 441 | ||
442 | public static Vector3 Normalize(Vector3 vector) | 442 | public static Vector3 Normalize(Vector3 vector) |
443 | { | 443 | { |
444 | Normalize(ref vector, out vector); | 444 | Normalize(ref vector, out vector); |
445 | return vector; | 445 | return vector; |
446 | } | 446 | } |
447 | 447 | ||
448 | public static void Normalize(ref Vector3 value, out Vector3 result) | 448 | public static void Normalize(ref Vector3 value, out Vector3 result) |
449 | { | 449 | { |
450 | float factor; | 450 | float factor; |
451 | Distance(ref value, ref zero, out factor); | 451 | Distance(ref value, ref zero, out factor); |
452 | factor = 1f / factor; | 452 | factor = 1f / factor; |
453 | result.X = value.X * factor; | 453 | result.X = value.X * factor; |
454 | result.Y = value.Y * factor; | 454 | result.Y = value.Y * factor; |
455 | result.Z = value.Z * factor; | 455 | result.Z = value.Z * factor; |
456 | } | 456 | } |
457 | 457 | ||
458 | public static Vector3 Reflect(Vector3 vector, Vector3 normal) | 458 | public static Vector3 Reflect(Vector3 vector, Vector3 normal) |
459 | { | 459 | { |
460 | throw new NotImplementedException(); | 460 | throw new NotImplementedException(); |
461 | } | 461 | } |
462 | 462 | ||
463 | public static void Reflect(ref Vector3 vector, ref Vector3 normal, out Vector3 result) | 463 | public static void Reflect(ref Vector3 vector, ref Vector3 normal, out Vector3 result) |
464 | { | 464 | { |
465 | throw new NotImplementedException(); | 465 | throw new NotImplementedException(); |
466 | } | 466 | } |
467 | 467 | ||
468 | /*public static Vector3 SmoothStep(Vector3 value1, Vector3 value2, float amount) | 468 | /*public static Vector3 SmoothStep(Vector3 value1, Vector3 value2, float amount) |
469 | { | 469 | { |
470 | return new Vector3( | 470 | return new Vector3( |
471 | MathHelper.SmoothStep(value1.X, value2.X, amount), | 471 | MathHelper.SmoothStep(value1.X, value2.X, amount), |
472 | MathHelper.SmoothStep(value1.Y, value2.Y, amount), | 472 | MathHelper.SmoothStep(value1.Y, value2.Y, amount), |
473 | MathHelper.SmoothStep(value1.Z, value2.Z, amount)); | 473 | MathHelper.SmoothStep(value1.Z, value2.Z, amount)); |
474 | }*/ | 474 | }*/ |
475 | 475 | ||
476 | /*public static void SmoothStep(ref Vector3 value1, ref Vector3 value2, float amount, out Vector3 result) | 476 | /*public static void SmoothStep(ref Vector3 value1, ref Vector3 value2, float amount, out Vector3 result) |
477 | { | 477 | { |
478 | result = new Vector3( | 478 | result = new Vector3( |
479 | MathHelper.SmoothStep(value1.X, value2.X, amount), | 479 | MathHelper.SmoothStep(value1.X, value2.X, amount), |
480 | MathHelper.SmoothStep(value1.Y, value2.Y, amount), | 480 | MathHelper.SmoothStep(value1.Y, value2.Y, amount), |
481 | MathHelper.SmoothStep(value1.Z, value2.Z, amount)); | 481 | MathHelper.SmoothStep(value1.Z, value2.Z, amount)); |
482 | }*/ | 482 | }*/ |
483 | 483 | ||
484 | public static Vector3 Subtract(Vector3 value1, Vector3 value2) | 484 | public static Vector3 Subtract(Vector3 value1, Vector3 value2) |
485 | { | 485 | { |
486 | value1.X -= value2.X; | 486 | value1.X -= value2.X; |
487 | value1.Y -= value2.Y; | 487 | value1.Y -= value2.Y; |
488 | value1.Z -= value2.Z; | 488 | value1.Z -= value2.Z; |
489 | return value1; | 489 | return value1; |
490 | } | 490 | } |
491 | 491 | ||
492 | public static void Subtract(ref Vector3 value1, ref Vector3 value2, out Vector3 result) | 492 | public static void Subtract(ref Vector3 value1, ref Vector3 value2, out Vector3 result) |
493 | { | 493 | { |
494 | result.X = value1.X - value2.X; | 494 | result.X = value1.X - value2.X; |
495 | result.Y = value1.Y - value2.Y; | 495 | result.Y = value1.Y - value2.Y; |
496 | result.Z = value1.Z - value2.Z; | 496 | result.Z = value1.Z - value2.Z; |
497 | } | 497 | } |
498 | 498 | ||
499 | public override string ToString() | 499 | public override string ToString() |
500 | { | 500 | { |
501 | StringBuilder sb = new StringBuilder(32); | 501 | StringBuilder sb = new StringBuilder(32); |
502 | sb.Append("{X:"); | 502 | sb.Append("{X:"); |
503 | sb.Append(this.X); | 503 | sb.Append(this.X); |
504 | sb.Append(" Y:"); | 504 | sb.Append(" Y:"); |
505 | sb.Append(this.Y); | 505 | sb.Append(this.Y); |
506 | sb.Append(" Z:"); | 506 | sb.Append(" Z:"); |
507 | sb.Append(this.Z); | 507 | sb.Append(this.Z); |
508 | sb.Append("}"); | 508 | sb.Append("}"); |
509 | return sb.ToString(); | 509 | return sb.ToString(); |
510 | } | 510 | } |
511 | 511 | ||
512 | public static Vector3 Transform(Vector3 position, Matrix matrix) | 512 | public static Vector3 Transform(Vector3 position, Matrix matrix) |
513 | { | 513 | { |
514 | Transform(ref position, ref matrix, out position); | 514 | Transform(ref position, ref matrix, out position); |
515 | return position; | 515 | return position; |
516 | } | 516 | } |
517 | 517 | ||
518 | public static void Transform(ref Vector3 position, ref Matrix matrix, out Vector3 result) | 518 | public static void Transform(ref Vector3 position, ref Matrix matrix, out Vector3 result) |
519 | { | 519 | { |
520 | result = new Vector3((position.X * matrix.M11) + (position.Y * matrix.M21) + (position.Z * matrix.M31) + matrix.M41, | 520 | result = new Vector3((position.X * matrix.M11) + (position.Y * matrix.M21) + (position.Z * matrix.M31) + matrix.M41, |
521 | (position.X * matrix.M12) + (position.Y * matrix.M22) + (position.Z * matrix.M32) + matrix.M42, | 521 | (position.X * matrix.M12) + (position.Y * matrix.M22) + (position.Z * matrix.M32) + matrix.M42, |
522 | (position.X * matrix.M13) + (position.Y * matrix.M23) + (position.Z * matrix.M33) + matrix.M43); | 522 | (position.X * matrix.M13) + (position.Y * matrix.M23) + (position.Z * matrix.M33) + matrix.M43); |
523 | } | 523 | } |
524 | 524 | ||
525 | public static Vector3 TransformNormal(Vector3 normal, Matrix matrix) | 525 | public static Vector3 TransformNormal(Vector3 normal, Matrix matrix) |
526 | { | 526 | { |
527 | TransformNormal(ref normal, ref matrix, out normal); | 527 | TransformNormal(ref normal, ref matrix, out normal); |
528 | return normal; | 528 | return normal; |
529 | } | 529 | } |
530 | 530 | ||
531 | public static void TransformNormal(ref Vector3 normal, ref Matrix matrix, out Vector3 result) | 531 | public static void TransformNormal(ref Vector3 normal, ref Matrix matrix, out Vector3 result) |
532 | { | 532 | { |
533 | result = new Vector3((normal.X * matrix.M11) + (normal.Y * matrix.M21) + (normal.Z * matrix.M31), | 533 | result = new Vector3((normal.X * matrix.M11) + (normal.Y * matrix.M21) + (normal.Z * matrix.M31), |
534 | (normal.X * matrix.M12) + (normal.Y * matrix.M22) + (normal.Z * matrix.M32), | 534 | (normal.X * matrix.M12) + (normal.Y * matrix.M22) + (normal.Z * matrix.M32), |
535 | (normal.X * matrix.M13) + (normal.Y * matrix.M23) + (normal.Z * matrix.M33)); | 535 | (normal.X * matrix.M13) + (normal.Y * matrix.M23) + (normal.Z * matrix.M33)); |
536 | } | 536 | } |
537 | 537 | ||
538 | #endregion Public methods | 538 | #endregion Public methods |
539 | 539 | ||
540 | 540 | ||
541 | #region Operators | 541 | #region Operators |
542 | 542 | ||
543 | public static bool operator ==(Vector3 value1, Vector3 value2) | 543 | public static bool operator ==(Vector3 value1, Vector3 value2) |
544 | { | 544 | { |
545 | return value1.X == value2.X | 545 | return value1.X == value2.X |
546 | && value1.Y == value2.Y | 546 | && value1.Y == value2.Y |
547 | && value1.Z == value2.Z; | 547 | && value1.Z == value2.Z; |
548 | } | 548 | } |
549 | 549 | ||
550 | public static bool operator !=(Vector3 value1, Vector3 value2) | 550 | public static bool operator !=(Vector3 value1, Vector3 value2) |
551 | { | 551 | { |
552 | return !(value1 == value2); | 552 | return !(value1 == value2); |
553 | } | 553 | } |
554 | 554 | ||
555 | public static Vector3 operator +(Vector3 value1, Vector3 value2) | 555 | public static Vector3 operator +(Vector3 value1, Vector3 value2) |
556 | { | 556 | { |
557 | value1.X += value2.X; | 557 | value1.X += value2.X; |
558 | value1.Y += value2.Y; | 558 | value1.Y += value2.Y; |
559 | value1.Z += value2.Z; | 559 | value1.Z += value2.Z; |
560 | return value1; | 560 | return value1; |
561 | } | 561 | } |
562 | 562 | ||
563 | public static Vector3 operator -(Vector3 value) | 563 | public static Vector3 operator -(Vector3 value) |
564 | { | 564 | { |
565 | value = new Vector3(-value.X, -value.Y, -value.Z); | 565 | value = new Vector3(-value.X, -value.Y, -value.Z); |
566 | return value; | 566 | return value; |
567 | } | 567 | } |
568 | 568 | ||
569 | public static Vector3 operator -(Vector3 value1, Vector3 value2) | 569 | public static Vector3 operator -(Vector3 value1, Vector3 value2) |
570 | { | 570 | { |
571 | value1.X -= value2.X; | 571 | value1.X -= value2.X; |
572 | value1.Y -= value2.Y; | 572 | value1.Y -= value2.Y; |
573 | value1.Z -= value2.Z; | 573 | value1.Z -= value2.Z; |
574 | return value1; | 574 | return value1; |
575 | } | 575 | } |
576 | 576 | ||
577 | public static Vector3 operator *(Vector3 value1, Vector3 value2) | 577 | public static Vector3 operator *(Vector3 value1, Vector3 value2) |
578 | { | 578 | { |
579 | value1.X *= value2.X; | 579 | value1.X *= value2.X; |
580 | value1.Y *= value2.Y; | 580 | value1.Y *= value2.Y; |
581 | value1.Z *= value2.Z; | 581 | value1.Z *= value2.Z; |
582 | return value1; | 582 | return value1; |
583 | } | 583 | } |
584 | 584 | ||
585 | public static Vector3 operator *(Vector3 value, float scaleFactor) | 585 | public static Vector3 operator *(Vector3 value, float scaleFactor) |
586 | { | 586 | { |
587 | value.X *= scaleFactor; | 587 | value.X *= scaleFactor; |
588 | value.Y *= scaleFactor; | 588 | value.Y *= scaleFactor; |
589 | value.Z *= scaleFactor; | 589 | value.Z *= scaleFactor; |
590 | return value; | 590 | return value; |
591 | } | 591 | } |
592 | 592 | ||
593 | public static Vector3 operator *(float scaleFactor, Vector3 value) | 593 | public static Vector3 operator *(float scaleFactor, Vector3 value) |
594 | { | 594 | { |
595 | value.X *= scaleFactor; | 595 | value.X *= scaleFactor; |
596 | value.Y *= scaleFactor; | 596 | value.Y *= scaleFactor; |
597 | value.Z *= scaleFactor; | 597 | value.Z *= scaleFactor; |
598 | return value; | 598 | return value; |
599 | } | 599 | } |
600 | 600 | ||
601 | public static Vector3 operator /(Vector3 value1, Vector3 value2) | 601 | public static Vector3 operator /(Vector3 value1, Vector3 value2) |
602 | { | 602 | { |
603 | value1.X /= value2.X; | 603 | value1.X /= value2.X; |
604 | value1.Y /= value2.Y; | 604 | value1.Y /= value2.Y; |
605 | value1.Z /= value2.Z; | 605 | value1.Z /= value2.Z; |
606 | return value1; | 606 | return value1; |
607 | } | 607 | } |
608 | 608 | ||
609 | public static Vector3 operator /(Vector3 value, float divider) | 609 | public static Vector3 operator /(Vector3 value, float divider) |
610 | { | 610 | { |
611 | float factor = 1 / divider; | 611 | float factor = 1 / divider; |
612 | value.X *= factor; | 612 | value.X *= factor; |
613 | value.Y *= factor; | 613 | value.Y *= factor; |
614 | value.Z *= factor; | 614 | value.Z *= factor; |
615 | return value; | 615 | return value; |
616 | } | 616 | } |
617 | 617 | ||
618 | #endregion | 618 | #endregion |
619 | } | 619 | } |
620 | } | 620 | } |