Imported Upstream version 1.4~svn915

1 files changed, 48 insertions, 22 deletions

diff --git a/include/SFML/Graphics/Matrix3.inl b/include/SFML/Graphics/Matrix3.inl
index 610c745..658157c 100755..100644
--- a/include/SFML/Graphics/Matrix3.inl
+++ b/include/SFML/Graphics/Matrix3.inl
@@ -44,8 +44,8 @@ inline Matrix3::Matrix3(float a00, float a01, float a02,
 {

     myData[0] = a00; myData[4] = a01; myData[8]  = 0.f; myData[12] = a02;

     myData[1] = a10; myData[5] = a11; myData[9]  = 0.f; myData[13] = a12;

-    myData[2] = a20; myData[6] = a21; myData[10] = 1.f; myData[14] = a22;

-    myData[3] = 0.f; myData[7] = 0.f; myData[11] = 0.f; myData[15] = 1.f;

+    myData[2] = 0.f; myData[6] = 0.f; myData[10] = 1.f; myData[14] = 0.f;

+    myData[3] = a20; myData[7] = a21; myData[11] = 0.f; myData[15] = a22;

 }

 

 

@@ -87,21 +87,21 @@ inline Vector2f Matrix3::Transform(const Vector2f& Point) const
 inline Matrix3 Matrix3::GetInverse() const

 {

     // Compute the determinant

-    float Det = myData[0] * (myData[14] * myData[5] - myData[6] * myData[13]) -

-                myData[1] * (myData[14] * myData[4] - myData[6] * myData[12]) +

-                myData[2] * (myData[13] * myData[4] - myData[5] * myData[12]);

+    float Det = myData[0] * (myData[15] * myData[5] - myData[7] * myData[13]) -

+                myData[1] * (myData[15] * myData[4] - myData[7] * myData[12]) +

+                myData[3] * (myData[13] * myData[4] - myData[5] * myData[12]);

 

     // Compute the inverse if determinant is not zero

     if ((Det < -1E-7f) || (Det > 1E-7f))

     {

-        return Matrix3( (myData[14] * myData[5] - myData[6] * myData[13]) / Det,

-                       -(myData[14] * myData[4] - myData[6] * myData[12]) / Det,

+        return Matrix3( (myData[15] * myData[5] - myData[7] * myData[13]) / Det,

+                       -(myData[15] * myData[4] - myData[7] * myData[12]) / Det,

                         (myData[13] * myData[4] - myData[5] * myData[12]) / Det,

-                       -(myData[14] * myData[1] - myData[2] * myData[13]) / Det,

-                        (myData[14] * myData[0] - myData[2] * myData[12]) / Det,

+                       -(myData[15] * myData[1] - myData[3] * myData[13]) / Det,

+                        (myData[15] * myData[0] - myData[3] * myData[12]) / Det,

                        -(myData[13] * myData[0] - myData[1] * myData[12]) / Det,

-                        (myData[6]  * myData[1] - myData[2] * myData[5])  / Det,

-                       -(myData[6]  * myData[0] - myData[2] * myData[4])  / Det,

+                        (myData[7]  * myData[1] - myData[3] * myData[5])  / Det,

+                       -(myData[7]  * myData[0] - myData[3] * myData[4])  / Det,

                         (myData[5]  * myData[0] - myData[1] * myData[4])  / Det);

     }

     else

@@ -126,11 +126,37 @@ inline const float* Matrix3::Get4x4Elements() const
 ////////////////////////////////////////////////////////////

 inline float Matrix3::operator ()(unsigned int Row, unsigned int Col) const

 {

-    return myData[Row + (Col + Col / 2) * 4];

+    switch (Row + Col * 3)

+    {

+        case 0 : return myData[0];

+        case 1 : return myData[1];

+        case 2 : return myData[3];

+        case 3 : return myData[4];

+        case 4 : return myData[5];

+        case 5 : return myData[7];

+        case 6 : return myData[12];

+        case 7 : return myData[13];

+        case 8 : return myData[15];

+

+        default : return myData[0];

+    }

 }

 inline float& Matrix3::operator ()(unsigned int Row, unsigned int Col)

 {

-    return myData[Row + (Col + Col / 2) * 4];

+    switch (Row + Col * 3)

+    {

+        case 0 : return myData[0];

+        case 1 : return myData[1];

+        case 2 : return myData[3];

+        case 3 : return myData[4];

+        case 4 : return myData[5];

+        case 5 : return myData[7];

+        case 6 : return myData[12];

+        case 7 : return myData[13];

+        case 8 : return myData[15];

+

+        default : return myData[0];

+    }

 }

 

 

@@ -139,15 +165,15 @@ inline float& Matrix3::operator ()(unsigned int Row, unsigned int Col)
 ////////////////////////////////////////////////////////////

 inline Matrix3 Matrix3::operator *(const Matrix3& Mat) const

 {

-    return Matrix3(myData[0] * Mat.myData[0]  + myData[4] * Mat.myData[1]  + myData[12] * Mat.myData[2],

-                   myData[0] * Mat.myData[4]  + myData[4] * Mat.myData[5]  + myData[12] * Mat.myData[3],

-                   myData[0] * Mat.myData[12] + myData[4] * Mat.myData[13] + myData[12] * Mat.myData[14],

-                   myData[1] * Mat.myData[0]  + myData[5] * Mat.myData[1]  + myData[13] * Mat.myData[2],

-                   myData[1] * Mat.myData[4]  + myData[5] * Mat.myData[5]  + myData[13] * Mat.myData[3],

-                   myData[1] * Mat.myData[12] + myData[5] * Mat.myData[13] + myData[13] * Mat.myData[14],

-                   myData[2] * Mat.myData[0]  + myData[6] * Mat.myData[1]  + myData[14] * Mat.myData[2],

-                   myData[2] * Mat.myData[4]  + myData[6] * Mat.myData[5]  + myData[14] * Mat.myData[3],

-                   myData[2] * Mat.myData[12] + myData[6] * Mat.myData[13] + myData[14] * Mat.myData[14]);

+    return Matrix3(myData[0] * Mat.myData[0]  + myData[4] * Mat.myData[1]  + myData[12] * Mat.myData[3],

+                   myData[0] * Mat.myData[4]  + myData[4] * Mat.myData[5]  + myData[12] * Mat.myData[7],

+                   myData[0] * Mat.myData[12] + myData[4] * Mat.myData[13] + myData[12] * Mat.myData[15],

+                   myData[1] * Mat.myData[0]  + myData[5] * Mat.myData[1]  + myData[13] * Mat.myData[3],

+                   myData[1] * Mat.myData[4]  + myData[5] * Mat.myData[5]  + myData[13] * Mat.myData[7],

+                   myData[1] * Mat.myData[12] + myData[5] * Mat.myData[13] + myData[13] * Mat.myData[15],

+                   myData[3] * Mat.myData[0]  + myData[7] * Mat.myData[1]  + myData[15] * Mat.myData[3],

+                   myData[3] * Mat.myData[4]  + myData[7] * Mat.myData[5]  + myData[15] * Mat.myData[7],

+                   myData[3] * Mat.myData[12] + myData[7] * Mat.myData[13] + myData[15] * Mat.myData[15]);

 }