Home | History | Annotate | Download | only in main 
      1 /**************************************************************************
      2  *
      3  * Copyright 2008 VMware, Inc.
      4  * All Rights Reserved.
      5  *
      6  **************************************************************************/
      7 
      8 
      9 /**
     10  * Code to implement GL_OES_query_matrix.  See the spec at:
     11  * http://www.khronos.org/registry/gles/extensions/OES/OES_query_matrix.txt
     12  */
     13 
     14 
     15 #include <stdlib.h>
     16 #include "c99_math.h"
     17 #include "glheader.h"
     18 #include "querymatrix.h"
     19 #include "main/get.h"
     20 
     21 
     22 /**
     23  * This is from the GL_OES_query_matrix extension specification:
     24  *
     25  *  GLbitfield glQueryMatrixxOES( GLfixed mantissa[16],
     26  *                                GLint   exponent[16] )
     27  *  mantissa[16] contains the contents of the current matrix in GLfixed
     28  *  format.  exponent[16] contains the unbiased exponents applied to the
     29  *  matrix components, so that the internal representation of component i
     30  *  is close to mantissa[i] * 2^exponent[i].  The function returns a status
     31  *  word which is zero if all the components are valid. If
     32  *  status & (1<<i) != 0, the component i is invalid (e.g., NaN, Inf).
     33  *  The implementations are not required to keep track of overflows.  In
     34  *  that case, the invalid bits are never set.
     35  */
     36 
     37 #define INT_TO_FIXED(x) ((GLfixed) ((x) << 16))
     38 #define FLOAT_TO_FIXED(x) ((GLfixed) ((x) * 65536.0))
     39 
     40 
     41 GLbitfield GLAPIENTRY
     42 _mesa_QueryMatrixxOES(GLfixed mantissa[16], GLint exponent[16])
     43 {
     44    GLfloat matrix[16];
     45    GLint tmp;
     46    GLenum currentMode = GL_FALSE;
     47    GLenum desiredMatrix = GL_FALSE;
     48    /* The bitfield returns 1 for each component that is invalid (i.e.
     49     * NaN or Inf).  In case of error, everything is invalid.
     50     */
     51    GLbitfield rv;
     52    unsigned i, bit;
     53 
     54    /* This data structure defines the mapping between the current matrix
     55     * mode and the desired matrix identifier.
     56     */
     57    static const struct {
     58       GLenum currentMode;
     59       GLenum desiredMatrix;
     60    } modes[] = {
     61       {GL_MODELVIEW, GL_MODELVIEW_MATRIX},
     62       {GL_PROJECTION, GL_PROJECTION_MATRIX},
     63       {GL_TEXTURE, GL_TEXTURE_MATRIX},
     64    };
     65 
     66    /* Call Mesa to get the current matrix in floating-point form.  First,
     67     * we have to figure out what the current matrix mode is.
     68     */
     69    _mesa_GetIntegerv(GL_MATRIX_MODE, &tmp);
     70    currentMode = (GLenum) tmp;
     71 
     72    /* The mode is either GL_FALSE, if for some reason we failed to query
     73     * the mode, or a given mode from the above table.  Search for the
     74     * returned mode to get the desired matrix; if we don't find it,
     75     * we can return immediately, as _mesa_GetInteger() will have
     76     * logged the necessary error already.
     77     */
     78    for (i = 0; i < ARRAY_SIZE(modes); i++) {
     79       if (modes[i].currentMode == currentMode) {
     80          desiredMatrix = modes[i].desiredMatrix;
     81          break;
     82       }
     83    }
     84    if (desiredMatrix == GL_FALSE) {
     85       /* Early error means all values are invalid. */
     86       return 0xffff;
     87    }
     88 
     89    /* Now pull the matrix itself. */
     90    _mesa_GetFloatv(desiredMatrix, matrix);
     91 
     92    rv = 0;
     93    for (i = 0, bit = 1; i < 16; i++, bit<<=1) {
     94       float normalizedFraction;
     95       int exp;
     96 
     97       switch (fpclassify(matrix[i])) {
     98       case FP_SUBNORMAL:
     99       case FP_NORMAL:
    100       case FP_ZERO:
    101          /* A "subnormal" or denormalized number is too small to be
    102           * represented in normal format; but despite that it's a
    103           * valid floating point number.  FP_ZERO and FP_NORMAL
    104           * are both valid as well.  We should be fine treating
    105           * these three cases as legitimate floating-point numbers.
    106           */
    107          normalizedFraction = (GLfloat)frexp(matrix[i], &exp);
    108          mantissa[i] = FLOAT_TO_FIXED(normalizedFraction);
    109          exponent[i] = (GLint) exp;
    110          break;
    111 
    112       case FP_NAN:
    113          /* If the entry is not-a-number or an infinity, then the
    114           * matrix component is invalid.  The invalid flag for
    115           * the component is already set; might as well set the
    116           * other return values to known values.  We'll set
    117           * distinct values so that a savvy end user could determine
    118           * whether the matrix component was a NaN or an infinity,
    119           * but this is more useful for debugging than anything else
    120           * since the standard doesn't specify any such magic
    121           * values to return.
    122           */
    123          mantissa[i] = INT_TO_FIXED(0);
    124          exponent[i] = (GLint) 0;
    125          rv |= bit;
    126          break;
    127 
    128       case FP_INFINITE:
    129          /* Return +/- 1 based on whether it's a positive or
    130           * negative infinity.
    131           */
    132          if (matrix[i] > 0) {
    133             mantissa[i] = INT_TO_FIXED(1);
    134          }
    135          else {
    136             mantissa[i] = -INT_TO_FIXED(1);
    137          }
    138          exponent[i] = (GLint) 0;
    139          rv |= bit;
    140          break;
    141 
    142       default:
    143          /* We should never get here; but here's a catching case
    144           * in case fpclassify() is returnings something unexpected.
    145           */
    146          mantissa[i] = INT_TO_FIXED(2);
    147          exponent[i] = (GLint) 0;
    148          rv |= bit;
    149          break;
    150       }
    151 
    152    } /* for each component */
    153 
    154    /* All done */
    155    return rv;
    156 }
    157