SORU
18 Temmuz 2009, CUMARTESİ


eviren 4x4 bir matris

4x4 bir matris ters çevirmek için nasıl örnek kod bir uygulama arıyorum. eleminiation, LU ayrıştırma, vb Gauss olduğunu biliyorum. ama detaylı bir şekilde bakmak yerine gerçekten sadece kod için bunu yapmak için arıyorum.

C 16 dizi mevcuttur dil ideal cloumn-büyük düzen içinde yüzer.

teşekkür ederim!

CEVAP
18 Temmuz 2009, CUMARTESİ


burada:

bool gluInvertMatrix(const double m[16], double invOut[16])
{
    double inv[16], det;
    int i;

    inv[0] = m[5]  * m[10] * m[15] - 
             m[5]  * m[11] * m[14] - 
             m[9]  * m[6]  * m[15]   
             m[9]  * m[7]  * m[14]  
             m[13] * m[6]  * m[11] - 
             m[13] * m[7]  * m[10];

    inv[4] = -m[4]  * m[10] * m[15]   
              m[4]  * m[11] * m[14]   
              m[8]  * m[6]  * m[15] - 
              m[8]  * m[7]  * m[14] - 
              m[12] * m[6]  * m[11]   
              m[12] * m[7]  * m[10];

    inv[8] = m[4]  * m[9] * m[15] - 
             m[4]  * m[11] * m[13] - 
             m[8]  * m[5] * m[15]   
             m[8]  * m[7] * m[13]   
             m[12] * m[5] * m[11] - 
             m[12] * m[7] * m[9];

    inv[12] = -m[4]  * m[9] * m[14]   
               m[4]  * m[10] * m[13]  
               m[8]  * m[5] * m[14] - 
               m[8]  * m[6] * m[13] - 
               m[12] * m[5] * m[10]   
               m[12] * m[6] * m[9];

    inv[1] = -m[1]  * m[10] * m[15]   
              m[1]  * m[11] * m[14]   
              m[9]  * m[2] * m[15] - 
              m[9]  * m[3] * m[14] - 
              m[13] * m[2] * m[11]   
              m[13] * m[3] * m[10];

    inv[5] = m[0]  * m[10] * m[15] - 
             m[0]  * m[11] * m[14] - 
             m[8]  * m[2] * m[15]   
             m[8]  * m[3] * m[14]   
             m[12] * m[2] * m[11] - 
             m[12] * m[3] * m[10];

    inv[9] = -m[0]  * m[9] * m[15]   
              m[0]  * m[11] * m[13]   
              m[8]  * m[1] * m[15] - 
              m[8]  * m[3] * m[13] - 
              m[12] * m[1] * m[11]   
              m[12] * m[3] * m[9];

    inv[13] = m[0]  * m[9] * m[14] - 
              m[0]  * m[10] * m[13] - 
              m[8]  * m[1] * m[14]   
              m[8]  * m[2] * m[13]   
              m[12] * m[1] * m[10] - 
              m[12] * m[2] * m[9];

    inv[2] = m[1]  * m[6] * m[15] - 
             m[1]  * m[7] * m[14] - 
             m[5]  * m[2] * m[15]   
             m[5]  * m[3] * m[14]   
             m[13] * m[2] * m[7] - 
             m[13] * m[3] * m[6];

    inv[6] = -m[0]  * m[6] * m[15]   
              m[0]  * m[7] * m[14]   
              m[4]  * m[2] * m[15] - 
              m[4]  * m[3] * m[14] - 
              m[12] * m[2] * m[7]   
              m[12] * m[3] * m[6];

    inv[10] = m[0]  * m[5] * m[15] - 
              m[0]  * m[7] * m[13] - 
              m[4]  * m[1] * m[15]   
              m[4]  * m[3] * m[13]   
              m[12] * m[1] * m[7] - 
              m[12] * m[3] * m[5];

    inv[14] = -m[0]  * m[5] * m[14]   
               m[0]  * m[6] * m[13]   
               m[4]  * m[1] * m[14] - 
               m[4]  * m[2] * m[13] - 
               m[12] * m[1] * m[6]   
               m[12] * m[2] * m[5];

    inv[3] = -m[1] * m[6] * m[11]   
              m[1] * m[7] * m[10]   
              m[5] * m[2] * m[11] - 
              m[5] * m[3] * m[10] - 
              m[9] * m[2] * m[7]   
              m[9] * m[3] * m[6];

    inv[7] = m[0] * m[6] * m[11] - 
             m[0] * m[7] * m[10] - 
             m[4] * m[2] * m[11]   
             m[4] * m[3] * m[10]   
             m[8] * m[2] * m[7] - 
             m[8] * m[3] * m[6];

    inv[11] = -m[0] * m[5] * m[11]   
               m[0] * m[7] * m[9]   
               m[4] * m[1] * m[11] - 
               m[4] * m[3] * m[9] - 
               m[8] * m[1] * m[7]   
               m[8] * m[3] * m[5];

    inv[15] = m[0] * m[5] * m[10] - 
              m[0] * m[6] * m[9] - 
              m[4] * m[1] * m[10]   
              m[4] * m[2] * m[9]   
              m[8] * m[1] * m[6] - 
              m[8] * m[2] * m[5];

    det = m[0] * inv[0]   m[1] * inv[4]   m[2] * inv[8]   m[3] * inv[12];

    if (det == 0)
        return false;

    det = 1.0 / det;

    for (i = 0; i < 16; i  )
        invOut[i] = inv[i] * det;

    return true;
}

Bu GLU kütüphane MESA uygulamadan kaldırıldı.

Bunu Paylaş:
  • Google+
  • E-Posta
Etiketler:

YORUMLAR

SPONSOR VİDEO

Rastgele Yazarlar

  • After Effects Tutorials w/ Mikey

    After Effect

    24 HAZİRAN 2009
  • Ordetta Price

    Ordetta Pric

    12 EYLÜL 2011
  • The Brister

    The Brister

    10 ŞUBAT 2008