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