back  Return to list

GL_ARB_transpose_matrix
homeprevnext Name
  
    ARB_transpose_matrix  
  
homeprevnext Name Strings
  
    GL_ARB_transpose_matrix  
  
homeprevnext Contact
  
    David Blythe (blythe 'at' sgi.com)  
  
homeprevnext Status
  
    Complete. Approved by ARB on 12/8/1999  
  
homeprevnext Version
  
    Last Modified Date: January 3, 2000  
    Author Revision: 1.3  
  
homeprevnext Number
  
    ARB Extension #3  
  
homeprevnext Dependencies
  
    This extensions is written against the OpenGL 1.2 Specification.  
    May be implemented in any version of OpenGL.  
  
homeprevnext Overview
  
    New functions and tokens are added allowing application matrices  
    stored in row major order rather than column major order to be  
    transferred to the OpenGL implementation.  This allows an application  
    to use standard C-language 2-dimensional arrays (m[row][col]) and  
    have the array indices match the expected matrix row and column indexes.  
    These arrays are referred to as transpose matrices since they are  
    the transpose of the standard matrices passed to OpenGL.  
  
    This extension adds an interface for transfering data to and from the  
    OpenGL pipeline, it does not change any OpenGL processing or imply any  
    changes in state representation.  
  
homeprevnext IP Status
  
    No IP is believed to be involved.  
  
homeprevnext Issues
  
    * Why do this?  
  
        It's very useful for layered libraries that desire to use two  
        dimensional C arrays as matrices.  It avoids having the layered  
        library perform the transpose itself before calling OpenGL since  
        most OpenGL implementations can efficiently perform the transpose  
        while reading the matrix from client memory.  
  
    * Why not add a mode?  
  
        It's substantially more confusing and complicated to add a mode.  
        Simply adding two new entry points saves considerable confusion  
        and avoids having layered libraries need to query the current mode  
        in order to send a matrix with the correct memory layout.  
  
    * Why not a utility routine in GLU  
  
        It costs some performance.  It is believed that most OpenGL  
        implementations can perform the transpose in place with negligble  
        performance penalty.  
  
    * Why use the name transpose?  
  
        It's sure a lot less confusing than trying to ascribe unambiguous  
        meaning to terms like row and column.  It could be matrix_transpose  
        rather than transpose_matrix though.  
  
    * Short Transpose to Trans?  
  
  
homeprevnext New Procedures and Functions
  
    void LoadTransposeMatrix{fd}ARB(T m[16]);  
    void MultTransposeMatrix{fd}ARB(T m[16]);  
  
homeprevnext New Tokens
  
    Accepted by the <pname> parameter of GetBooleanv, GetIntegerv, GetFloatv,  
    and GetDoublev  
  
        TRANSPOSE_MODELVIEW_MATRIX_ARB    0x84E3  
        TRANSPOSE_PROJECTION_MATRIX_ARB   0x84E4  
        TRANSPOSE_TEXTURE_MATRIX_ARB      0x84E5  
        TRANSPOSE_COLOR_MATRIX_ARB        0x84E6  
  
  
homeprevnext Additions to Chapter 2 of the 1.2 OpenGL Specification (OpenGL Operation)
  
    Add to Section 2.10.2 Matrices  <before LoadIdentity>  
  
    LoadTransposeMatrixARB takes a 4x4 matrix stored in row-major order as  
  
    Let transpose(m,n) be defined as  
  
        n[0] = m[0];  
        n[1] = m[4];  
        n[2] = m[8];  
        n[3] = m[12];  
        n[4] = m[1];  
        n[5] = m[5];  
        n[6] = m[9];  
        n[7] = m[13];  
        n[8] = m[2];  
        n[9] = m[6];  
        n[10] = m[10];  
        n[11] = m[14];  
        n[12] = m[3];  
        n[13] = m[7];  
        n[14] = m[11];  
        n[15] = m[15];  
  
    The effect of LoadTransposeMatrixARB(m) is then the same as the effect of  
    the command sequence  
  
        float n[16];  
        transpose(m,n)  
        LoadMatrix(n);  
  
    The effect of MultTransposeMatrixARB(m) is then the same as the effect of  
    the command sequence  
  
        float n[16];  
        transpose(m,n);  
        MultMatrix(n);  
  
  
homeprevnext Additions to Chapter 3 of the 1.2 OpenGL Specification (Rasterization)
  
    None  
  
homeprevnext Additions to Chapter 4 of the 1.2 OpenGL Specification (Per-Fragment Operations and the Framebuffer)
  
    None  
  
homeprevnext Additions to Chapter 5 of the 1.2 OpenGL Specification (Special Functions)
  
    None  
  
homeprevnext Additions to Chapter 6 of the 1.2 OpenGL Specification (State and State Requests)
  
    Matrices are queried and returned in their transposed form by calling  
    GetBooleanv, GetIntegerv, GetFloatv, and GetDoublev with <pname> set to  
    TRANSPOSE_MODELVIEW_MATRIX_ARB, TRANSPOSE_PROJECTION_MATRIX_ARB,  
    TRANSPOSE_TEXTURE_MATRIX_ARB, or TRANSPOSE_COLOR_MATRIX_ARB.  
    The effect of GetFloatv(TRANSPOSE_MODELVIEW_MATRIX_ARB,m) is then the same  
    as the effect of the command sequence  
  
        float n[16];  
        GetFloatv(MODELVIEW_MATRIX_ARB,n);  
        transpose(n,m);  
  
    Similar results occur for TRANSPOSE_PROJECTION_MATRIX_ARB,  
    TRANSPOSE_TEXTURE_MATRIX_ARB, and TRANSPOSE_COLOR_MATRIX_ARB.  
  
  
homeprevnext Additions to Appendix A of the OpenGL 1.2.1 Specification (Invariance)
  
    None  
  
homeprevnext Additions to the GLX Specification
  
    None  
  
homeprevnext GLX Protocol
  
    LoadTransposeMatrix and MultTransposeMatrix are layered  
    on top of LoadMatrix and MultMatrix protocol  
    performing client-side translation.  The Get commands  
    are passed over the wire as part of the generic Get  
    protocol with no translation required.  
  
homeprevnext Errors
  
    No new errors, but error behavoir is inherited by the commands  
    that the transpose commands are implemented on top of  
    (LoadMatrix, MultMatrix, and Get*).  
  
homeprevnext New State
  
    None  
  
    TRANSPOSE_*_MATRIX_ARB refer to the same state as their non-transposed  
    counterparts.  
  
homeprevnext New Implementation Dependent State
  
    None  
  
homeprevnext Revision History
  
    * Revision 1.1 - initial draft (18 Mar 1999)  
    * Revision 1.2 - changed to use layered specification and ARB affix  
                     (23 Nov 1999)  
    * Revision 1.3 - Minor tweaks to GLX protocol and Errors. (7 Dec 1999)  
  
Conformance Testing  
  
    Load and Multiply the modelview matrix (initialized to identity  
    each time) using LoadTransposeMatrixfARB and MultTransposeMatrixfARB  
    with the matrix:  
  
        ( 1  2  3  4 )  
        ( 5  6  7  8 )  
        ( 9 10 11 12 )  
        (13 14 15 16 )  
  
    and get the modelview matrix using TRANSPOSE_MODELVIEW_MATRIX_ARB and  
    validate that the matrix is correct.  Get the matrix using  
    MODELVIEW_MATRIX and verify that it is the transpose of the above  
    matrix.  Load and Multiply the modelview matrix using LoadMatrixf  
    and MultMatrixf with the above matrix and verify that the correct  
    matrix is on the modelview stack using gets of MODELVIEW_MATRIX  
    and TRANSPOSE_MODELVIEW_MATRIX_ARB.  
  
  
Valid XHTML 1.1! Valid CSS! Last update: November 14, 2006.
Cette page doit être lue avec un navigateur récent respectant le standard XHTML 1.1.