1 /* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     2  *

     3  * Permission is hereby granted, free of charge, to any person obtaining a

     4  * copy of this software and /or associated documentation files

     5  * (the "Materials "), to deal in the Materials without restriction,

     6  * including without limitation the rights to use, copy, modify, merge,

     7  * publish, distribute, sublicense, and/or sell copies of the Materials,

     8  * and to permit persons to whom the Materials are furnished to do so,

     9  * subject to the following conditions:

    10  *

    11  * The above copyright notice and this permission notice shall be included

    12  * in all copies or substantial portions of the Materials.

    13  *

    14  * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

    15  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

    16  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

    17  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,

    18  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR

    19  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR

    20  * THE USE OR OTHER DEALINGS IN THE MATERIALS.

    21  *

    22  * Initial Contributors:

    23  * Nokia Corporation - initial contribution.

    24  *

    25  * Contributors:

    26  *

    27  * Description:

    28  *

    29  */

    30 

    31 #include "glesGet.h"

    32 #include <GLES/glext.h>

    33 #include "GLESContext.h"

    34 #include "GLESDesktopGL.h"

    35 

    36 // UINT_MAX

    37 #include <limits.h>

    38 

    39 bool glesGetParameter(const GLESContext& context, const GLESDesktopGL &dgl, GLenum pname, GLESGetType dstType, void* params)

    40 {

    41     GLESGetType srcType;

    42     GLboolean b[4];

    43     GLint i[16];

    44     GLdouble d[16];

    45     int n = 1;

    46 

    47     switch(pname)

    48     {

    49     case GL_MAX_TEXTURE_UNITS:

    50         i[0] = context.MaxTextureUnits();

    51         srcType = GLES_TYPE_INTEGER;

    52         break;

    53 

    54     case GL_MAX_CLIP_PLANES:

    55         i[0] = context.MaxClipPlanes();

    56         srcType = GLES_TYPE_INTEGER;

    57         break;

    58 

    59     case GL_MAX_LIGHTS:

    60         i[0] = context.MaxLights();

    61         srcType = GLES_TYPE_INTEGER;

    62         break;

    63 

    64     case GL_CLIENT_ACTIVE_TEXTURE:

    65         i[0] = GL_TEXTURE0 + context.ClientActiveTexture();

    66         srcType = GLES_TYPE_ENUM;

    67         break;

    68 

    69     case GL_VERTEX_ARRAY:

    70         i[0] = context.IsArrayEnabled(GLES_VERTEX_ARRAY);

    71         srcType = GLES_TYPE_BOOLEAN;

    72         break;

    73 

    74     case GL_VERTEX_ARRAY_SIZE:

    75         i[0] = context.VertexArray().Size();

    76         srcType = GLES_TYPE_INTEGER;

    77         break;

    78 

    79     case GL_VERTEX_ARRAY_TYPE:

    80         i[0] = context.VertexArray().Type();

    81         srcType = GLES_TYPE_ENUM;

    82         break;

    83 

    84     case GL_VERTEX_ARRAY_STRIDE:

    85         i[0] = context.VertexArray().Stride();

    86         srcType = GLES_TYPE_INTEGER;

    87         break;

    88 

    89     case GL_NORMAL_ARRAY:

    90         i[0] = context.IsArrayEnabled(GLES_NORMAL_ARRAY);

    91         srcType = GLES_TYPE_BOOLEAN;

    92         break;

    93 

    94     case GL_NORMAL_ARRAY_TYPE:

    95         i[0] = context.NormalArray().Type();

    96         srcType = GLES_TYPE_ENUM;

    97         break;

    98 

    99     case GL_NORMAL_ARRAY_STRIDE:

   100         i[0] = context.NormalArray().Stride();

   101         srcType = GLES_TYPE_INTEGER;

   102         break;

   103 

   104     case GL_COLOR_ARRAY:

   105         i[0] = context.IsArrayEnabled(GLES_COLOR_ARRAY);

   106         srcType = GLES_TYPE_BOOLEAN;

   107         break;

   108 

   109     case GL_COLOR_ARRAY_SIZE:

   110         i[0] = context.ColorArray().Size();

   111         srcType = GLES_TYPE_INTEGER;

   112         break;

   113 

   114     case GL_COLOR_ARRAY_TYPE:

   115         i[0] = context.ColorArray().Type();

   116         srcType = GLES_TYPE_ENUM;

   117         break;

   118 

   119     case GL_COLOR_ARRAY_STRIDE:

   120         i[0] = context.ColorArray().Stride();

   121         srcType = GLES_TYPE_INTEGER;

   122         break;

   123 

   124     case GL_POINT_SIZE_ARRAY_OES:

   125         i[0] = context.IsArrayEnabled(GLES_POINT_SIZE_ARRAY);

   126         srcType = GLES_TYPE_BOOLEAN;

   127         break;

   128 

   129     case GL_POINT_SIZE_ARRAY_TYPE_OES:

   130         i[0] = context.PointSizeArray().Type();

   131         srcType = GLES_TYPE_ENUM;

   132         break;

   133 

   134     case GL_POINT_SIZE_ARRAY_STRIDE_OES:

   135         i[0] = context.PointSizeArray().Stride();

   136         srcType = GLES_TYPE_INTEGER;

   137         break;

   138 

   139     case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:

   140         i[0] = context.PointSizeArray().BufferName();

   141         srcType = GLES_TYPE_INTEGER;

   142         break;

   143 

   144     case GL_TEXTURE_COORD_ARRAY:

   145         i[0] = context.IsArrayEnabled(static_cast<GLESArrayFlag>(GLES_TEXTURE_COORD_ARRAY << context.ClientActiveTexture()));

   146         srcType = GLES_TYPE_BOOLEAN;

   147         break;

   148 

   149     case GL_TEXTURE_COORD_ARRAY_SIZE:

   150         i[0] = context.TexCoordArray().Size();

   151         srcType = GLES_TYPE_INTEGER;

   152         break;

   153 

   154     case GL_TEXTURE_COORD_ARRAY_TYPE:

   155         i[0] = context.TexCoordArray().Type();

   156         srcType = GLES_TYPE_ENUM;

   157         break;

   158 

   159     case GL_TEXTURE_COORD_ARRAY_STRIDE:

   160         i[0] = context.TexCoordArray().Stride();

   161         srcType = GLES_TYPE_INTEGER;

   162         break;

   163 

   164     case GL_VERTEX_ARRAY_BUFFER_BINDING:

   165         i[0] = context.VertexArray().BufferName();

   166         srcType = GLES_TYPE_INTEGER;

   167         break;

   168 

   169     case GL_NORMAL_ARRAY_BUFFER_BINDING:

   170         i[0] = context.NormalArray().BufferName();

   171         srcType = GLES_TYPE_INTEGER;

   172         break;

   173 

   174     case GL_COLOR_ARRAY_BUFFER_BINDING:

   175         i[0] = context.ColorArray().BufferName();

   176         srcType = GLES_TYPE_INTEGER;

   177         break;

   178 

   179     case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING:

   180         i[0] = context.TexCoordArray().BufferName();

   181         srcType = GLES_TYPE_INTEGER;

   182         break;

   183 

   184     case GL_ARRAY_BUFFER_BINDING:

   185         i[0] = context.ArrayBufferBinding();

   186         srcType = GLES_TYPE_INTEGER;

   187         break;

   188 

   189     case GL_ELEMENT_ARRAY_BUFFER_BINDING:

   190         i[0] = context.ElementArrayBufferBinding();

   191         srcType = GLES_TYPE_INTEGER;

   192         break;

   193 

   194     case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES:

   195         if(dstType != GLES_TYPE_INTEGER)

   196         {

   197             return false;

   198         }

   199         dgl.glGetDoublev(GL_MODELVIEW_MATRIX, d);

   200         n = 16;

   201         for(int j = 0; j < n; j++)

   202         {

   203             static_cast<GLint*>(params)[j] = *reinterpret_cast<GLint*>(&d[j]);

   204         }

   205         break;

   206 

   207     case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES:

   208         if(dstType != GLES_TYPE_INTEGER)

   209         {

   210             return false;

   211         }

   212         dgl.glGetDoublev(GL_PROJECTION_MATRIX, d);

   213         n = 16;

   214         for(int j = 0; j < n; j++)

   215         {

   216             static_cast<GLint*>(params)[j] = *reinterpret_cast<GLint*>(&d[j]);

   217         }

   218         break;

   219 

   220     case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES:

   221         if(dstType != GLES_TYPE_INTEGER)

   222         {

   223             return false;

   224         }

   225         dgl.glGetDoublev(GL_TEXTURE_MATRIX, d);

   226         n = 16;

   227         for(int j = 0; j < n; j++)

   228         {

   229             static_cast<GLint*>(params)[j] = *reinterpret_cast<GLint*>(&d[j]);

   230         }

   231         break;

   232 

   233     case GL_POINT_SPRITE_OES:

   234         b[0] = dgl.glIsEnabled(GL_POINT_SPRITE);

   235         srcType = GLES_TYPE_BOOLEAN;

   236         break;

   237 

   238     case GL_NUM_COMPRESSED_TEXTURE_FORMATS:

   239         i[0] = 10;

   240         srcType = GLES_TYPE_INTEGER;

   241         break;

   242 

   243     case GL_COMPRESSED_TEXTURE_FORMATS:

   244         i[0] = GL_PALETTE4_RGB8_OES;

   245         i[1] = GL_PALETTE4_RGBA8_OES;

   246         i[2] = GL_PALETTE4_R5_G6_B5_OES;

   247         i[3] = GL_PALETTE4_RGBA4_OES;

   248         i[4] = GL_PALETTE4_RGB5_A1_OES;

   249         i[5] = GL_PALETTE8_RGB8_OES;

   250         i[6] = GL_PALETTE8_RGBA8_OES;

   251         i[7] = GL_PALETTE8_R5_G6_B5_OES;

   252         i[8] = GL_PALETTE8_RGBA4_OES;

   253         i[9] = GL_PALETTE8_RGB5_A1_OES;

   254         srcType = GLES_TYPE_ENUM;

   255         n = 10;

   256         break;

   257 

   258     case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:

   259         i[0] = GL_RGBA;

   260         srcType = GLES_TYPE_ENUM;

   261         break;

   262 

   263     case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:

   264         i[0] = GL_UNSIGNED_BYTE;

   265         srcType = GLES_TYPE_ENUM;

   266         break;

   267 

   268     case GL_ALIASED_POINT_SIZE_RANGE:

   269     case GL_ALIASED_LINE_WIDTH_RANGE:

   270     case GL_DEPTH_RANGE:

   271     case GL_SMOOTH_LINE_WIDTH_RANGE:

   272     case GL_SMOOTH_POINT_SIZE_RANGE:

   273         dgl.glGetDoublev(pname, d);

   274         srcType = GLES_TYPE_DOUBLE;

   275         n = 2;

   276         break;

   277     case GL_ALPHA_TEST_FUNC:

   278     case GL_STENCIL_FAIL:

   279     case GL_STENCIL_FUNC:

   280     case GL_STENCIL_PASS_DEPTH_FAIL:

   281     case GL_STENCIL_PASS_DEPTH_PASS:

   282     case GL_BLEND_DST:

   283     case GL_BLEND_SRC:

   284     case GL_LOGIC_OP_MODE:

   285     case GL_CULL_FACE:

   286     case GL_DEPTH_FUNC:

   287     case GL_FOG_HINT:

   288     case GL_FOG_MODE:

   289     case GL_FRONT_FACE:

   290     case GL_LINE_SMOOTH_HINT:

   291     case GL_MATRIX_MODE:

   292     case GL_PERSPECTIVE_CORRECTION_HINT:

   293     case GL_POINT_SMOOTH_HINT:

   294     case GL_SHADE_MODEL:

   295     case GL_GENERATE_MIPMAP_HINT:

   296     case GL_CULL_FACE_MODE:

   297     case GL_ACTIVE_TEXTURE:

   298         dgl.glGetIntegerv(pname, i);

   299         srcType = GLES_TYPE_ENUM;

   300         break;

   301     case GL_ALPHA_BITS:

   302     case GL_RED_BITS:

   303     case GL_GREEN_BITS:

   304     case GL_BLUE_BITS:

   305     case GL_DEPTH_BITS:

   306     case GL_STENCIL_BITS:

   307     case GL_STENCIL_VALUE_MASK:

   308     case GL_STENCIL_WRITEMASK:

   309     case GL_MODELVIEW_STACK_DEPTH:

   310     case GL_PROJECTION_STACK_DEPTH:

   311     case GL_TEXTURE_STACK_DEPTH:

   312     case GL_PACK_ALIGNMENT:

   313     case GL_UNPACK_ALIGNMENT:

   314     case GL_TEXTURE_BINDING_2D:

   315     case GL_SUBPIXEL_BITS:

   316     case GL_SAMPLE_BUFFERS:

   317     case GL_SAMPLES:

   318     case GL_BUFFER_SIZE:

   319     case GL_STENCIL_CLEAR_VALUE:

   320     case GL_MAX_MODELVIEW_STACK_DEPTH:

   321     case GL_MAX_PROJECTION_STACK_DEPTH:

   322     case GL_MAX_TEXTURE_STACK_DEPTH:

   323     case GL_MAX_TEXTURE_SIZE:

   324         dgl.glGetIntegerv(pname, i);

   325         srcType = GLES_TYPE_INTEGER;

   326         break;

   327     case GL_ALPHA_TEST_REF:

   328     case GL_STENCIL_REF:

   329     case GL_DEPTH_CLEAR_VALUE:

   330     case GL_FOG_DENSITY:

   331     case GL_FOG_START:

   332     case GL_FOG_END:

   333     case GL_LINE_WIDTH:

   334     case GL_POINT_SIZE:

   335     case GL_POINT_SIZE_MIN:

   336     case GL_POINT_SIZE_MAX:

   337     case GL_POLYGON_OFFSET_FACTOR:

   338     case GL_POLYGON_OFFSET_UNITS:

   339     case GL_POINT_FADE_THRESHOLD_SIZE:

   340         dgl.glGetDoublev(pname, d);

   341         srcType = GLES_TYPE_DOUBLE;

   342         break;

   343     case GL_CURRENT_NORMAL:

   344     case GL_POINT_DISTANCE_ATTENUATION:

   345         dgl.glGetDoublev(pname, d);

   346         srcType = GLES_TYPE_DOUBLE;

   347         n = 3;

   348         break;

   349     case GL_COLOR_CLEAR_VALUE:

   350     case GL_CURRENT_TEXTURE_COORDS:

   351     case GL_CURRENT_COLOR:

   352     case GL_FOG_COLOR:

   353     case GL_LIGHT_MODEL_AMBIENT:

   354     case GL_AMBIENT:

   355     case GL_DIFFUSE:

   356     case GL_SPECULAR:

   357     case GL_EMISSION:

   358         dgl.glGetDoublev(pname, d);

   359         srcType = GLES_TYPE_DOUBLE;

   360         n = 4;

   361         break;

   362     case GL_COLOR_WRITEMASK:

   363         dgl.glGetBooleanv(pname, b);

   364         srcType = GLES_TYPE_BOOLEAN;

   365         n = 4;

   366         break;

   367     case GL_DEPTH_WRITEMASK:

   368     case GL_LIGHT_MODEL_TWO_SIDE:

   369         dgl.glGetBooleanv(pname, b);

   370         srcType = GLES_TYPE_BOOLEAN;

   371         break;

   372     case GL_PROJECTION_MATRIX:

   373     case GL_MODELVIEW_MATRIX:

   374     case GL_TEXTURE_MATRIX:

   375         dgl.glGetDoublev(pname, d);

   376         srcType = GLES_TYPE_DOUBLE;

   377         n = 16;

   378         break;

   379     case GL_VIEWPORT:

   380     case GL_SCISSOR_BOX:

   381         dgl.glGetIntegerv(pname, i);

   382         srcType = GLES_TYPE_INTEGER;

   383         n = 4;

   384         break;

   385     case GL_MAX_VIEWPORT_DIMS:

   386         dgl.glGetIntegerv(pname, i);

   387         srcType = GLES_TYPE_INTEGER;

   388         n = 2;

   389         break;

   390 

   391     default:

   392         return false;

   393     }

   394 

   395     // Type conversions

   396 

   397     // Special cases

   398     if(dstType == GLES_TYPE_INTEGER &&

   399        (pname == GL_CURRENT_COLOR || pname == GL_ALPHA_TEST_REF || pname == GL_DEPTH_CLEAR_VALUE))

   400     {

   401         for(int j = 0; j < n; j++)

   402         {

   403             static_cast<GLint*>(params)[j] = static_cast<GLint>((UINT_MAX * d[j] - 1) / 2);

   404         }

   405         return true;

   406     }

   407 

   408     for(int j = 0; j < n; j++)

   409     {

   410         switch(dstType)

   411         {

   412         case GLES_TYPE_BOOLEAN:

   413             switch(srcType)

   414             {

   415             case GLES_TYPE_BOOLEAN:

   416                 static_cast<GLboolean*>(params)[j] = b[j];

   417                 break;

   418             case GLES_TYPE_INTEGER:

   419             case GLES_TYPE_ENUM:

   420                 static_cast<GLboolean*>(params)[j] = i[j] ? GL_TRUE : GL_FALSE;

   421                 break;

   422             case GLES_TYPE_DOUBLE:

   423                 static_cast<GLboolean*>(params)[j] = d[j] ? GL_TRUE : GL_FALSE;

   424                 break;

   425             default:

   426                 GLES_ASSERT(false);

   427             }

   428             break;

   429 

   430         case GLES_TYPE_INTEGER:

   431             switch(srcType)

   432             {

   433             case GLES_TYPE_BOOLEAN:

   434                 static_cast<GLint*>(params)[j] = b[j];

   435                 break;

   436             case GLES_TYPE_INTEGER:

   437             case GLES_TYPE_ENUM:

   438                 static_cast<GLint*>(params)[j] = i[j];

   439                 break;

   440             case GLES_TYPE_DOUBLE:

   441                 static_cast<GLint*>(params)[j] = static_cast<GLint>(d[j]);

   442                 break;

   443             default:

   444                 GLES_ASSERT(false);

   445             }

   446             break;

   447 

   448         case GLES_TYPE_FLOAT:

   449             switch(srcType)

   450             {

   451             case GLES_TYPE_BOOLEAN:

   452                 static_cast<GLfloat*>(params)[j] = b[j];

   453                 break;

   454             case GLES_TYPE_INTEGER:

   455             case GLES_TYPE_ENUM:

   456                 static_cast<GLfloat*>(params)[j] = static_cast<GLfloat>(i[j]);

   457                 break;

   458             case GLES_TYPE_DOUBLE:

   459                 static_cast<GLfloat*>(params)[j] = static_cast<GLfloat>(d[j]);

   460                 break;

   461             default:

   462                 GLES_ASSERT(false);

   463             }

   464             break;

   465 

   466         case GLES_TYPE_FIXED:

   467             switch(srcType)

   468             {

   469             case GLES_TYPE_BOOLEAN:

   470                 static_cast<GLfixed*>(params)[j] = F_TO_X(b[j] ? 1.f : 0.f);

   471                 break;

   472             case GLES_TYPE_INTEGER:

   473                 static_cast<GLfixed*>(params)[j] = I_TO_X(i[j]);

   474                 break;

   475             case GLES_TYPE_ENUM:

   476                 static_cast<GLfixed*>(params)[j] = i[j];

   477                 break;

   478             case GLES_TYPE_DOUBLE:

   479                 static_cast<GLfixed*>(params)[j] = D_TO_X(d[j]);

   480                 break;

   481             default:

   482                 GLES_ASSERT(false);

   483             }

   484             break;

   485 

   486         default:

   487             GLES_ASSERT(false);

   488         }

   489     }

   490 

   491     return true;

   492 }