SlimDXc_Jun2010(VC++2008)/source/math/Vector2.cpp

   1 #include "stdafx.h"\r
   2 /*\r
   3 * Copyright (c) 2007-2010 SlimDX Group\r
   4 * \r
   5 * Permission is hereby granted, free of charge, to any person obtaining a copy\r
   6 * of this software and associated documentation files (the "Software"), to deal\r
   7 * in the Software without restriction, including without limitation the rights\r
   8 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r
   9 * copies of the Software, and to permit persons to whom the Software is\r
  10 * furnished to do so, subject to the following conditions:\r
  11 * \r
  12 * The above copyright notice and this permission notice shall be included in\r
  13 * all copies or substantial portions of the Software.\r
  14 * \r
  15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
  17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r
  18 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r
  19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
  20 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r
  21 * THE SOFTWARE.\r
  22 */\r
  23 \r
  24 #include <d3dx9.h>\r
  25 \r
  26 #include "Matrix.h"\r
  27 #include "Quaternion.h"\r
  28 #include "Vector2.h"\r
  29 \r
  30 using namespace System;\r
  31 using namespace System::Globalization;\r
  32 \r
  33 namespace SlimDX\r
  34 {\r
  35         Vector2::Vector2( float value )\r
  36         {\r
  37                 X = value;\r
  38                 Y = value;\r
  39         }\r
  40         \r
  41         Vector2::Vector2( float x, float y )\r
  42         {\r
  43                 X = x;\r
  44                 Y = y;\r
  45         }\r
  46         \r
  47         float Vector2::default::get( int index )\r
  48         {\r
  49                 switch( index )\r
  50                 {\r
  51                 case 0:\r
  52                         return X;\r
  53 \r
  54                 case 1:\r
  55                         return Y;\r
  56 \r
  57                 default:\r
  58                         throw gcnew ArgumentOutOfRangeException( "index", "Indices for Vector2 run from 0 to 1, inclusive." );\r
  59                 }\r
  60         }\r
  61         \r
  62         void Vector2::default::set( int index, float value )\r
  63         {\r
  64                 switch( index )\r
  65                 {\r
  66                 case 0:\r
  67                         X = value;\r
  68                         break;\r
  69 \r
  70                 case 1:\r
  71                         Y = value;\r
  72                         break;\r
  73 \r
  74                 default:\r
  75                         throw gcnew ArgumentOutOfRangeException( "index", "Indices for Vector2 run from 0 to 1, inclusive." );\r
  76                 }\r
  77         }\r
  78         \r
  79         float Vector2::Length()\r
  80         {\r
  81                 return static_cast<float>( Math::Sqrt( (X * X) + (Y * Y) ) );\r
  82         }\r
  83         \r
  84         float Vector2::LengthSquared()\r
  85         {\r
  86                 return (X * X) + (Y * Y);\r
  87         }\r
  88         \r
  89         void Vector2::Normalize()\r
  90         {\r
  91                 float length = Length();\r
  92                 if( length == 0 )\r
  93                         return;\r
  94                 float num = 1 / length;\r
  95                 X *= num;\r
  96                 Y *= num;\r
  97         }\r
  98 \r
  99         Vector2 Vector2::Add( Vector2 left, Vector2 right )\r
 100         {\r
 101                 return Vector2( left.X + right.X, left.Y + right.Y );\r
 102         }\r
 103         \r
 104         void Vector2::Add( Vector2% left, Vector2% right, [Out] Vector2% result )\r
 105         {\r
 106                 result = Vector2( left.X + right.X, left.Y + right.Y );\r
 107         }\r
 108         \r
 109         Vector2 Vector2::Subtract( Vector2 left, Vector2 right )\r
 110         {\r
 111                 return Vector2( left.X - right.X, left.Y - right.Y );\r
 112         }\r
 113         \r
 114         void Vector2::Subtract( Vector2% left, Vector2% right, [Out] Vector2% result )\r
 115         {\r
 116                 result = Vector2( left.X - right.X, left.Y - right.Y );\r
 117         }\r
 118         \r
 119         Vector2 Vector2::Modulate( Vector2 left, Vector2 right )\r
 120         {\r
 121                 return Vector2( left.X * right.X, left.Y * right.Y );\r
 122         }\r
 123         \r
 124         void Vector2::Modulate( Vector2% left, Vector2% right, [Out] Vector2% result )\r
 125         {\r
 126                 result = Vector2( left.X * right.X, left.Y * right.Y );\r
 127         }\r
 128         \r
 129         Vector2 Vector2::Multiply( Vector2 value, float scale )\r
 130         {\r
 131                 return Vector2( value.X * scale, value.Y * scale );\r
 132         }\r
 133         \r
 134         void Vector2::Multiply( Vector2% value, float scale, [Out] Vector2% result )\r
 135         {\r
 136                 result = Vector2( value.X * scale, value.Y * scale );\r
 137         }\r
 138         \r
 139         Vector2 Vector2::Divide( Vector2 value, float scale )\r
 140         {\r
 141                 return Vector2( value.X / scale, value.Y / scale );\r
 142         }\r
 143 \r
 144         void Vector2::Divide( Vector2% value, float scale, [Out] Vector2% result )\r
 145         {\r
 146                 result = Vector2( value.X / scale, value.Y / scale );\r
 147         }\r
 148 \r
 149         Vector2 Vector2::Negate( Vector2 value )\r
 150         {\r
 151                 return Vector2( -value.X, -value.Y );\r
 152         }\r
 153         \r
 154         void Vector2::Negate( Vector2% value, [Out] Vector2% result )\r
 155         {\r
 156                 result = Vector2( -value.X, -value.Y );\r
 157         }\r
 158         \r
 159         Vector2 Vector2::Barycentric( Vector2 value1, Vector2 value2, Vector2 value3, float amount1, float amount2 )\r
 160         {\r
 161                 Vector2 vector;\r
 162                 vector.X = (value1.X + (amount1 * (value2.X - value1.X))) + (amount2 * (value3.X - value1.X));\r
 163                 vector.Y = (value1.Y + (amount1 * (value2.Y - value1.Y))) + (amount2 * (value3.Y - value1.Y));\r
 164                 return vector;\r
 165         }\r
 166         \r
 167         void Vector2::Barycentric( Vector2% value1, Vector2% value2, Vector2% value3, float amount1, float amount2, [Out] Vector2% result )\r
 168         {\r
 169                 result = Vector2((value1.X + (amount1 * (value2.X - value1.X))) + (amount2 * (value3.X - value1.X)),\r
 170                         (value1.Y + (amount1 * (value2.Y - value1.Y))) + (amount2 * (value3.Y - value1.Y)) );\r
 171         }\r
 172         \r
 173         Vector2 Vector2::CatmullRom( Vector2 value1, Vector2 value2, Vector2 value3, Vector2 value4, float amount )\r
 174         {\r
 175                 Vector2 vector;\r
 176                 float squared = amount * amount;\r
 177                 float cubed = amount * squared;\r
 178 \r
 179                 vector.X = 0.5f * ((((2.0f * value2.X) + ((-value1.X + value3.X) * amount)) + \r
 180                         (((((2.0f * value1.X) - (5.0f * value2.X)) + (4.0f * value3.X)) - value4.X) * squared)) + \r
 181                         ((((-value1.X + (3.0f * value2.X)) - (3.0f * value3.X)) + value4.X) * cubed));\r
 182 \r
 183                 vector.Y = 0.5f * ((((2.0f * value2.Y) + ((-value1.Y + value3.Y) * amount)) + \r
 184                         (((((2.0f * value1.Y) - (5.0f * value2.Y)) + (4.0f * value3.Y)) - value4.Y) * squared)) + \r
 185                         ((((-value1.Y + (3.0f * value2.Y)) - (3.0f * value3.Y)) + value4.Y) * cubed));\r
 186 \r
 187                 return vector;\r
 188         }\r
 189         \r
 190         void Vector2::CatmullRom( Vector2% value1, Vector2% value2, Vector2% value3, Vector2% value4, float amount, [Out] Vector2% result )\r
 191         {\r
 192                 float squared = amount * amount;\r
 193                 float cubed = amount * squared;\r
 194                 Vector2 r;\r
 195 \r
 196                 r.X = 0.5f * ((((2.0f * value2.X) + ((-value1.X + value3.X) * amount)) + \r
 197                         (((((2.0f * value1.X) - (5.0f * value2.X)) + (4.0f * value3.X)) - value4.X) * squared)) + \r
 198                         ((((-value1.X + (3.0f * value2.X)) - (3.0f * value3.X)) + value4.X) * cubed));\r
 199 \r
 200                 r.Y = 0.5f * ((((2.0f * value2.Y) + ((-value1.Y + value3.Y) * amount)) + \r
 201                         (((((2.0f * value1.Y) - (5.0f * value2.Y)) + (4.0f * value3.Y)) - value4.Y) * squared)) + \r
 202                         ((((-value1.Y + (3.0f * value2.Y)) - (3.0f * value3.Y)) + value4.Y) * cubed));\r
 203 \r
 204                 result = r;\r
 205         }\r
 206         \r
 207         Vector2 Vector2::Clamp( Vector2 value, Vector2 min, Vector2 max )\r
 208         {\r
 209                 float x = value.X;\r
 210                 x = (x > max.X) ? max.X : x;\r
 211                 x = (x < min.X) ? min.X : x;\r
 212 \r
 213                 float y = value.Y;\r
 214                 y = (y > max.Y) ? max.Y : y;\r
 215                 y = (y < min.Y) ? min.Y : y;\r
 216 \r
 217                 return Vector2( x, y );\r
 218         }\r
 219         \r
 220         void Vector2::Clamp( Vector2% value, Vector2% min, Vector2% max, [Out] Vector2% result )\r
 221         {\r
 222                 float x = value.X;\r
 223                 x = (x > max.X) ? max.X : x;\r
 224                 x = (x < min.X) ? min.X : x;\r
 225 \r
 226                 float y = value.Y;\r
 227                 y = (y > max.Y) ? max.Y : y;\r
 228                 y = (y < min.Y) ? min.Y : y;\r
 229 \r
 230                 result = Vector2( x, y );\r
 231         }\r
 232         \r
 233         Vector2 Vector2::Hermite( Vector2 value1, Vector2 tangent1, Vector2 value2, Vector2 tangent2, float amount )\r
 234         {\r
 235                 Vector2 vector;\r
 236                 float squared = amount * amount;\r
 237                 float cubed = amount * squared;\r
 238                 float part1 = ((2.0f * cubed) - (3.0f * squared)) + 1.0f;\r
 239                 float part2 = (-2.0f * cubed) + (3.0f * squared);\r
 240                 float part3 = (cubed - (2.0f * squared)) + amount;\r
 241                 float part4 = cubed - squared;\r
 242 \r
 243                 vector.X = (((value1.X * part1) + (value2.X * part2)) + (tangent1.X * part3)) + (tangent2.X * part4);\r
 244                 vector.Y = (((value1.Y * part1) + (value2.Y * part2)) + (tangent1.Y * part3)) + (tangent2.Y * part4);\r
 245 \r
 246                 return vector;\r
 247         }       \r
 248         \r
 249         void Vector2::Hermite( Vector2% value1, Vector2% tangent1, Vector2% value2, Vector2% tangent2, float amount, [Out] Vector2% result )\r
 250         {\r
 251                 float squared = amount * amount;\r
 252                 float cubed = amount * squared;\r
 253                 float part1 = ((2.0f * cubed) - (3.0f * squared)) + 1.0f;\r
 254                 float part2 = (-2.0f * cubed) + (3.0f * squared);\r
 255                 float part3 = (cubed - (2.0f * squared)) + amount;\r
 256                 float part4 = cubed - squared;\r
 257 \r
 258                 Vector2 r;\r
 259                 r.X = (((value1.X * part1) + (value2.X * part2)) + (tangent1.X * part3)) + (tangent2.X * part4);\r
 260                 r.Y = (((value1.Y * part1) + (value2.Y * part2)) + (tangent1.Y * part3)) + (tangent2.Y * part4);\r
 261 \r
 262                 result = r;\r
 263         }\r
 264         \r
 265         Vector2 Vector2::Lerp( Vector2 start, Vector2 end, float factor )\r
 266         {\r
 267                 Vector2 vector;\r
 268 \r
 269                 vector.X = start.X + ((end.X - start.X) * factor);\r
 270                 vector.Y = start.Y + ((end.Y - start.Y) * factor);\r
 271 \r
 272                 return vector;\r
 273         }\r
 274         \r
 275         void Vector2::Lerp( Vector2% start, Vector2% end, float factor, [Out] Vector2% result )\r
 276         {\r
 277                 Vector2 r;\r
 278                 r.X = start.X + ((end.X - start.X) * factor);\r
 279                 r.Y = start.Y + ((end.Y - start.Y) * factor);\r
 280 \r
 281                 result = r;\r
 282         }\r
 283         \r
 284         Vector2 Vector2::SmoothStep( Vector2 start, Vector2 end, float amount )\r
 285         {\r
 286                 Vector2 vector;\r
 287 \r
 288                 amount = (amount > 1.0f) ? 1.0f : ((amount < 0.0f) ? 0.0f : amount);\r
 289                 amount = (amount * amount) * (3.0f - (2.0f * amount));\r
 290 \r
 291                 vector.X = start.X + ((end.X - start.X) * amount);\r
 292                 vector.Y = start.Y + ((end.Y - start.Y) * amount);\r
 293 \r
 294                 return vector;\r
 295         }\r
 296         \r
 297         void Vector2::SmoothStep( Vector2% start, Vector2% end, float amount, [Out] Vector2% result )\r
 298         {\r
 299                 amount = (amount > 1.0f) ? 1.0f : ((amount < 0.0f) ? 0.0f : amount);\r
 300                 amount = (amount * amount) * (3.0f - (2.0f * amount));\r
 301 \r
 302                 Vector2 r;\r
 303                 r.X = start.X + ((end.X - start.X) * amount);\r
 304                 r.Y = start.Y + ((end.Y - start.Y) * amount);\r
 305 \r
 306                 result = r;\r
 307         }\r
 308         \r
 309         float Vector2::Distance( Vector2 value1, Vector2 value2 )\r
 310         {\r
 311                 float x = value1.X - value2.X;\r
 312                 float y = value1.Y - value2.Y;\r
 313 \r
 314                 return static_cast<float>( Math::Sqrt( (x * x) + (y * y) ) );\r
 315         }\r
 316 \r
 317         float Vector2::DistanceSquared( Vector2 value1, Vector2 value2 )\r
 318         {\r
 319                 float x = value1.X - value2.X;\r
 320                 float y = value1.Y - value2.Y;\r
 321 \r
 322                 return (x * x) + (y * y);\r
 323         }\r
 324         \r
 325         float Vector2::Dot( Vector2 left, Vector2 right )\r
 326         {\r
 327                 return (left.X * right.X + left.Y * right.Y);\r
 328         }\r
 329         \r
 330         Vector2 Vector2::Normalize( Vector2 vector )\r
 331         {\r
 332                 vector.Normalize();\r
 333                 return vector;\r
 334         }\r
 335         \r
 336         void Vector2::Normalize( Vector2% vector, [Out] Vector2% result )\r
 337         {\r
 338                 result = Vector2::Normalize(vector);\r
 339         }\r
 340         \r
 341         Vector4 Vector2::Transform( Vector2 vector, Matrix transform )\r
 342         {\r
 343                 Vector4 result;\r
 344 \r
 345                 result.X = (vector.X * transform.M11) + (vector.Y * transform.M21) + transform.M41;\r
 346                 result.Y = (vector.X * transform.M12) + (vector.Y * transform.M22) + transform.M42;\r
 347                 result.Z = (vector.X * transform.M13) + (vector.Y * transform.M23) + transform.M43;\r
 348                 result.W = (vector.X * transform.M14) + (vector.Y * transform.M24) + transform.M44;\r
 349 \r
 350                 return result;\r
 351         }\r
 352         \r
 353         void Vector2::Transform( Vector2% vector, Matrix% transform, [Out] Vector4% result )\r
 354         {\r
 355                 Vector4 r;\r
 356                 r.X = (vector.X * transform.M11) + (vector.Y * transform.M21) + transform.M41;\r
 357                 r.Y = (vector.X * transform.M12) + (vector.Y * transform.M22) + transform.M42;\r
 358                 r.Z = (vector.X * transform.M13) + (vector.Y * transform.M23) + transform.M43;\r
 359                 r.W = (vector.X * transform.M14) + (vector.Y * transform.M24) + transform.M44;\r
 360 \r
 361                 result = r;\r
 362         }\r
 363         \r
 364         array<Vector4>^ Vector2::Transform( array<Vector2>^ vectors, Matrix% transform )\r
 365         {\r
 366                 if( vectors == nullptr )\r
 367                         throw gcnew ArgumentNullException( "vectors" );\r
 368 \r
 369                 int count = vectors->Length;\r
 370                 array<Vector4>^ results = gcnew array<Vector4>( count );\r
 371 \r
 372                 for( int i = 0; i < count; i++ )\r
 373                 {\r
 374                         Vector4 r;\r
 375                         r.X = (vectors[i].X * transform.M11) + (vectors[i].Y * transform.M21) + transform.M41;\r
 376                         r.Y = (vectors[i].X * transform.M12) + (vectors[i].Y * transform.M22) + transform.M42;\r
 377                         r.Z = (vectors[i].X * transform.M13) + (vectors[i].Y * transform.M23) + transform.M43;\r
 378                         r.W = (vectors[i].X * transform.M14) + (vectors[i].Y * transform.M24) + transform.M44;\r
 379 \r
 380                         results[i] = r;\r
 381                 }\r
 382 \r
 383                 return results;\r
 384         }\r
 385         \r
 386         Vector4 Vector2::Transform( Vector2 value, Quaternion rotation )\r
 387         {\r
 388                 Vector4 vector;\r
 389                 float x = rotation.X + rotation.X;\r
 390                 float y = rotation.Y + rotation.Y;\r
 391                 float z = rotation.Z + rotation.Z;\r
 392                 float wx = rotation.W * x;\r
 393                 float wy = rotation.W * y;\r
 394                 float wz = rotation.W * z;\r
 395                 float xx = rotation.X * x;\r
 396                 float xy = rotation.X * y;\r
 397                 float xz = rotation.X * z;\r
 398                 float yy = rotation.Y * y;\r
 399                 float yz = rotation.Y * z;\r
 400                 float zz = rotation.Z * z;\r
 401 \r
 402                 vector.X = ((value.X * ((1.0f - yy) - zz)) + (value.Y * (xy - wz)));\r
 403                 vector.Y = ((value.X * (xy + wz)) + (value.Y * ((1.0f - xx) - zz)));\r
 404                 vector.Z = ((value.X * (xz - wy)) + (value.Y * (yz + wx)));\r
 405                 vector.W = 1.0f;\r
 406 \r
 407                 return vector;\r
 408         }\r
 409         \r
 410         void Vector2::Transform( Vector2% value, Quaternion% rotation, [Out] Vector4% result )\r
 411         {\r
 412                 float x = rotation.X + rotation.X;\r
 413                 float y = rotation.Y + rotation.Y;\r
 414                 float z = rotation.Z + rotation.Z;\r
 415                 float wx = rotation.W * x;\r
 416                 float wy = rotation.W * y;\r
 417                 float wz = rotation.W * z;\r
 418                 float xx = rotation.X * x;\r
 419                 float xy = rotation.X * y;\r
 420                 float xz = rotation.X * z;\r
 421                 float yy = rotation.Y * y;\r
 422                 float yz = rotation.Y * z;\r
 423                 float zz = rotation.Z * z;\r
 424 \r
 425                 Vector4 r;\r
 426                 r.X = ((value.X * ((1.0f - yy) - zz)) + (value.Y * (xy - wz)));\r
 427                 r.Y = ((value.X * (xy + wz)) + (value.Y * ((1.0f - xx) - zz)));\r
 428                 r.Z = ((value.X * (xz - wy)) + (value.Y * (yz + wx)));\r
 429                 r.W = 1.0f;\r
 430 \r
 431                 result = r;\r
 432         }\r
 433 \r
 434         array<Vector4>^ Vector2::Transform( array<Vector2>^ vectors, Quaternion% rotation )\r
 435         {\r
 436                 if( vectors == nullptr )\r
 437                         throw gcnew ArgumentNullException( "vectors" );\r
 438 \r
 439                 int count = vectors->Length;\r
 440                 array<Vector4>^ results = gcnew array<Vector4>( count );\r
 441 \r
 442                 float x = rotation.X + rotation.X;\r
 443                 float y = rotation.Y + rotation.Y;\r
 444                 float z = rotation.Z + rotation.Z;\r
 445                 float wx = rotation.W * x;\r
 446                 float wy = rotation.W * y;\r
 447                 float wz = rotation.W * z;\r
 448                 float xx = rotation.X * x;\r
 449                 float xy = rotation.X * y;\r
 450                 float xz = rotation.X * z;\r
 451                 float yy = rotation.Y * y;\r
 452                 float yz = rotation.Y * z;\r
 453                 float zz = rotation.Z * z;\r
 454 \r
 455                 for( int i = 0; i < count; i++ )\r
 456                 {\r
 457                         Vector4 r;\r
 458                         r.X = ((vectors[i].X * ((1.0f - yy) - zz)) + (vectors[i].Y * (xy - wz)));\r
 459                         r.Y = ((vectors[i].X * (xy + wz)) + (vectors[i].Y * ((1.0f - xx) - zz)));\r
 460                         r.Z = ((vectors[i].X * (xz - wy)) + (vectors[i].Y * (yz + wx)));\r
 461                         r.W = 1.0f;\r
 462 \r
 463                         results[i] = r;\r
 464                 }\r
 465 \r
 466                 return results;\r
 467         }\r
 468         \r
 469         Vector2 Vector2::TransformCoordinate( Vector2 coord, Matrix transform )\r
 470         {\r
 471                 Vector4 vector;\r
 472 \r
 473                 vector.X = (coord.X * transform.M11) + (coord.Y * transform.M21) + transform.M41;\r
 474                 vector.Y = (coord.X * transform.M12) + (coord.Y * transform.M22) + transform.M42;\r
 475                 vector.Z = (coord.X * transform.M13) + (coord.Y * transform.M23) + transform.M43;\r
 476                 vector.W = 1 / ((coord.X * transform.M14) + (coord.Y * transform.M24) + transform.M44);\r
 477 \r
 478                 return Vector2( vector.X * vector.W, vector.Y * vector.W );\r
 479         }\r
 480         \r
 481         void Vector2::TransformCoordinate( Vector2% coord, Matrix% transform, [Out] Vector2% result )\r
 482         {\r
 483                 Vector4 vector;\r
 484 \r
 485                 vector.X = (coord.X * transform.M11) + (coord.Y * transform.M21) + transform.M41;\r
 486                 vector.Y = (coord.X * transform.M12) + (coord.Y * transform.M22) + transform.M42;\r
 487                 vector.Z = (coord.X * transform.M13) + (coord.Y * transform.M23) + transform.M43;\r
 488                 vector.W = 1 / ((coord.X * transform.M14) + (coord.Y * transform.M24) + transform.M44);\r
 489 \r
 490                 result = Vector2( vector.X * vector.W, vector.Y * vector.W );\r
 491         }\r
 492         \r
 493         array<Vector2>^ Vector2::TransformCoordinate( array<Vector2>^ coords, Matrix% transform )\r
 494         {\r
 495                 if( coords == nullptr )\r
 496                         throw gcnew ArgumentNullException( "coordinates" );\r
 497 \r
 498                 Vector4 vector;\r
 499                 int count = coords->Length;\r
 500                 array<Vector2>^ results = gcnew array<Vector2>( count );\r
 501 \r
 502                 for( int i = 0; i < count; i++ )\r
 503                 {\r
 504                         vector.X = (coords[i].X * transform.M11) + (coords[i].Y * transform.M21) + transform.M41;\r
 505                         vector.Y = (coords[i].X * transform.M12) + (coords[i].Y * transform.M22) + transform.M42;\r
 506                         vector.Z = (coords[i].X * transform.M13) + (coords[i].Y * transform.M23) + transform.M43;\r
 507                         vector.W = 1 / ((coords[i].X * transform.M14) + (coords[i].Y * transform.M24) + transform.M44);\r
 508                         results[i] = Vector2( vector.X * vector.W, vector.Y * vector.W );\r
 509                 }\r
 510 \r
 511                 return results;\r
 512         }\r
 513 \r
 514         Vector2 Vector2::TransformNormal( Vector2 normal, Matrix transform )\r
 515         {\r
 516                 Vector2 vector;\r
 517 \r
 518                 vector.X = (normal.X * transform.M11) + (normal.Y * transform.M21);\r
 519                 vector.Y = (normal.X * transform.M12) + (normal.Y * transform.M22);\r
 520 \r
 521                 return vector;\r
 522         }\r
 523         \r
 524         void Vector2::TransformNormal( Vector2% normal, Matrix% transform, [Out] Vector2% result )\r
 525         {\r
 526                 Vector2 r;\r
 527                 r.X = (normal.X * transform.M11) + (normal.Y * transform.M21);\r
 528                 r.Y = (normal.X * transform.M12) + (normal.Y * transform.M22);\r
 529 \r
 530                 result = r;\r
 531         }\r
 532         \r
 533         array<Vector2>^ Vector2::TransformNormal( array<Vector2>^ normals, Matrix% transform )\r
 534         {\r
 535                 if( normals == nullptr )\r
 536                         throw gcnew ArgumentNullException( "normals" );\r
 537 \r
 538                 int count = normals->Length;\r
 539                 array<Vector2>^ results = gcnew array<Vector2>( count );\r
 540 \r
 541                 for( int i = 0; i < count; i++ )\r
 542                 {\r
 543                         Vector2 r;\r
 544                         r.X = (normals[i].X * transform.M11) + (normals[i].Y * transform.M21);\r
 545                         r.Y = (normals[i].X * transform.M12) + (normals[i].Y * transform.M22);\r
 546 \r
 547                         results[i] = r;\r
 548                 }\r
 549 \r
 550                 return results;\r
 551         }\r
 552         \r
 553         Vector2 Vector2::Minimize( Vector2 left, Vector2 right )\r
 554         {\r
 555                 Vector2 vector;\r
 556                 vector.X = (left.X < right.X) ? left.X : right.X;\r
 557                 vector.Y = (left.Y < right.Y) ? left.Y : right.Y;\r
 558                 return vector;\r
 559         }\r
 560         \r
 561         void Vector2::Minimize( Vector2% left, Vector2% right, [Out] Vector2% result )\r
 562         {\r
 563                 Vector2 r;\r
 564                 r.X = (left.X < right.X) ? left.X : right.X;\r
 565                 r.Y = (left.Y < right.Y) ? left.Y : right.Y;\r
 566 \r
 567                 result = r;\r
 568         }\r
 569         \r
 570         Vector2 Vector2::Maximize( Vector2 left, Vector2 right )\r
 571         {\r
 572                 Vector2 vector;\r
 573                 vector.X = (left.X > right.X) ? left.X : right.X;\r
 574                 vector.Y = (left.Y > right.Y) ? left.Y : right.Y;\r
 575                 return vector;\r
 576         }\r
 577 \r
 578         void Vector2::Maximize( Vector2% left, Vector2% right, [Out] Vector2% result )\r
 579         {\r
 580                 Vector2 r;\r
 581                 r.X = (left.X > right.X) ? left.X : right.X;\r
 582                 r.Y = (left.Y > right.Y) ? left.Y : right.Y;\r
 583 \r
 584                 result = r;\r
 585         }\r
 586         \r
 587         Vector2 Vector2::operator + ( Vector2 left, Vector2 right )\r
 588         {\r
 589                 return Vector2( left.X + right.X, left.Y + right.Y );\r
 590         }\r
 591 \r
 592         Vector2 Vector2::operator - ( Vector2 left, Vector2 right )\r
 593         {\r
 594                 return Vector2( left.X - right.X, left.Y - right.Y );\r
 595         }\r
 596         \r
 597         Vector2 Vector2::operator - ( Vector2 value )\r
 598         {\r
 599                 return Vector2( -value.X, -value.Y );\r
 600         }\r
 601         \r
 602         Vector2 Vector2::operator * ( Vector2 value, float scale )\r
 603         {\r
 604                 return Vector2( value.X * scale, value.Y * scale );\r
 605         }\r
 606         \r
 607         Vector2 Vector2::operator * ( float scale, Vector2 vec )\r
 608         {\r
 609                 return vec * scale;\r
 610         }\r
 611         \r
 612         Vector2 Vector2::operator / ( Vector2 value, float scale )\r
 613         {\r
 614                 return Vector2( value.X / scale, value.Y / scale );\r
 615         }\r
 616         \r
 617         bool Vector2::operator == ( Vector2 left, Vector2 right )\r
 618         {\r
 619                 return Vector2::Equals( left, right );\r
 620         }\r
 621         \r
 622         bool Vector2::operator != ( Vector2 left, Vector2 right )\r
 623         {\r
 624                 return !Vector2::Equals( left, right );\r
 625         }\r
 626         \r
 627         String^ Vector2::ToString()\r
 628         {\r
 629                 return String::Format( CultureInfo::CurrentCulture, "X:{0} Y:{1}", X.ToString(CultureInfo::CurrentCulture), Y.ToString(CultureInfo::CurrentCulture) );\r
 630         }\r
 631 \r
 632         int Vector2::GetHashCode()\r
 633         {\r
 634                 return X.GetHashCode() + Y.GetHashCode();\r
 635         }\r
 636 \r
 637         bool Vector2::Equals( Object^ value )\r
 638         {\r
 639                 if( value == nullptr )\r
 640                         return false;\r
 641 \r
 642                 if( value->GetType() != GetType() )\r
 643                         return false;\r
 644 \r
 645                 return Equals( safe_cast<Vector2>( value ) );\r
 646         }\r
 647 \r
 648         bool Vector2::Equals( Vector2 value )\r
 649         {\r
 650                 return ( X == value.X && Y == value.Y );\r
 651         }\r
 652 \r
 653         bool Vector2::Equals( Vector2% value1, Vector2% value2 )\r
 654         {\r
 655                 return ( value1.X == value2.X && value1.Y == value2.Y );\r
 656         }\r
 657 }