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

 *

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

 * copy of this software and /or associated documentation files

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

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

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

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

 * subject to the following conditions:

 *

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

 * in all copies or substantial portions of the Materials.

 *

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

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

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.

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

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

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

 * THE USE OR OTHER DEALINGS IN THE MATERIALS.

 *

 * Initial Contributors:

 * Nokia Corporation - initial contribution.

 *

 * Contributors:

 *

 * Description:

 *

 */

#include "glesGet.h"

#include <GLES/glext.h>

#include "GLESContext.h"

#include "GLESDesktopGL.h"

// UINT_MAX

#include <limits.h>

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

{

    GLESGetType srcType;

    GLboolean b[4];

    GLint i[16];

    GLdouble d[16];

    int n = 1;

    switch(pname)

    {

    case GL_MAX_TEXTURE_UNITS:

        i[0] = context.MaxTextureUnits();

        srcType = GLES_TYPE_INTEGER;

        break;

    case GL_MAX_CLIP_PLANES:

        i[0] = context.MaxClipPlanes();

        srcType = GLES_TYPE_INTEGER;

        break;

    case GL_MAX_LIGHTS:

        i[0] = context.MaxLights();

        srcType = GLES_TYPE_INTEGER;

        break;

    case GL_CLIENT_ACTIVE_TEXTURE:

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

        srcType = GLES_TYPE_ENUM;

        break;

    case GL_VERTEX_ARRAY:

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

        srcType = GLES_TYPE_BOOLEAN;

        break;

    case GL_VERTEX_ARRAY_SIZE:

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

        srcType = GLES_TYPE_INTEGER;

        break;

    case GL_VERTEX_ARRAY_TYPE:

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

        srcType = GLES_TYPE_ENUM;

        break;

    case GL_VERTEX_ARRAY_STRIDE:

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

        srcType = GLES_TYPE_INTEGER;

        break;

    case GL_NORMAL_ARRAY:

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

        srcType = GLES_TYPE_BOOLEAN;

        break;

    case GL_NORMAL_ARRAY_TYPE:

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

        srcType = GLES_TYPE_ENUM;

        break;

    case GL_NORMAL_ARRAY_STRIDE:

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

        srcType = GLES_TYPE_INTEGER;

        break;

    case GL_COLOR_ARRAY:

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

        srcType = GLES_TYPE_BOOLEAN;

        break;

    case GL_COLOR_ARRAY_SIZE:

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

        srcType = GLES_TYPE_INTEGER;

        break;

    case GL_COLOR_ARRAY_TYPE:

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

        srcType = GLES_TYPE_ENUM;

        break;

    case GL_COLOR_ARRAY_STRIDE:

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

        srcType = GLES_TYPE_INTEGER;

        break;

    case GL_POINT_SIZE_ARRAY_OES:

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

        srcType = GLES_TYPE_BOOLEAN;

        break;

    case GL_POINT_SIZE_ARRAY_TYPE_OES:

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

        srcType = GLES_TYPE_ENUM;

        break;

    case GL_POINT_SIZE_ARRAY_STRIDE_OES:

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

        srcType = GLES_TYPE_INTEGER;

        break;

    case GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES:

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

        srcType = GLES_TYPE_INTEGER;

        break;

    case GL_TEXTURE_COORD_ARRAY:

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

        srcType = GLES_TYPE_BOOLEAN;

        break;

    case GL_TEXTURE_COORD_ARRAY_SIZE:

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

        srcType = GLES_TYPE_INTEGER;

        break;

    case GL_TEXTURE_COORD_ARRAY_TYPE:

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

        srcType = GLES_TYPE_ENUM;

        break;

    case GL_TEXTURE_COORD_ARRAY_STRIDE:

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

        srcType = GLES_TYPE_INTEGER;

        break;

    case GL_VERTEX_ARRAY_BUFFER_BINDING:

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

        srcType = GLES_TYPE_INTEGER;

        break;

    case GL_NORMAL_ARRAY_BUFFER_BINDING:

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

        srcType = GLES_TYPE_INTEGER;

        break;

    case GL_COLOR_ARRAY_BUFFER_BINDING:

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

        srcType = GLES_TYPE_INTEGER;

        break;

    case GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING:

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

        srcType = GLES_TYPE_INTEGER;

        break;

    case GL_ARRAY_BUFFER_BINDING:

        i[0] = context.ArrayBufferBinding();

        srcType = GLES_TYPE_INTEGER;

        break;

    case GL_ELEMENT_ARRAY_BUFFER_BINDING:

        i[0] = context.ElementArrayBufferBinding();

        srcType = GLES_TYPE_INTEGER;

        break;

    case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES:

        if(dstType != GLES_TYPE_INTEGER)

        {

            return false;

        }

        dgl.glGetDoublev(GL_MODELVIEW_MATRIX, d);

        n = 16;

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

        {

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

        }

        break;

    case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES:

        if(dstType != GLES_TYPE_INTEGER)

        {

            return false;

        }

        dgl.glGetDoublev(GL_PROJECTION_MATRIX, d);

        n = 16;

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

        {

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

        }

        break;

    case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES:

        if(dstType != GLES_TYPE_INTEGER)

        {

            return false;

        }

        dgl.glGetDoublev(GL_TEXTURE_MATRIX, d);

        n = 16;

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

        {

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

        }

        break;

    case GL_POINT_SPRITE_OES:

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

        srcType = GLES_TYPE_BOOLEAN;

        break;

    case GL_NUM_COMPRESSED_TEXTURE_FORMATS:

        i[0] = 10;

        srcType = GLES_TYPE_INTEGER;

        break;

    case GL_COMPRESSED_TEXTURE_FORMATS:

        i[0] = GL_PALETTE4_RGB8_OES;

        i[1] = GL_PALETTE4_RGBA8_OES;

        i[2] = GL_PALETTE4_R5_G6_B5_OES;

        i[3] = GL_PALETTE4_RGBA4_OES;

        i[4] = GL_PALETTE4_RGB5_A1_OES;

        i[5] = GL_PALETTE8_RGB8_OES;

        i[6] = GL_PALETTE8_RGBA8_OES;

        i[7] = GL_PALETTE8_R5_G6_B5_OES;

        i[8] = GL_PALETTE8_RGBA4_OES;

        i[9] = GL_PALETTE8_RGB5_A1_OES;

        srcType = GLES_TYPE_ENUM;

        n = 10;

        break;

    case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:

        i[0] = GL_RGBA;

        srcType = GLES_TYPE_ENUM;

        break;

    case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:

        i[0] = GL_UNSIGNED_BYTE;

        srcType = GLES_TYPE_ENUM;

        break;

    case GL_ALIASED_POINT_SIZE_RANGE:

    case GL_ALIASED_LINE_WIDTH_RANGE:

    case GL_DEPTH_RANGE:

    case GL_SMOOTH_LINE_WIDTH_RANGE:

    case GL_SMOOTH_POINT_SIZE_RANGE:

        dgl.glGetDoublev(pname, d);

        srcType = GLES_TYPE_DOUBLE;

        n = 2;

        break;

    case GL_ALPHA_TEST_FUNC:

    case GL_STENCIL_FAIL:

    case GL_STENCIL_FUNC:

    case GL_STENCIL_PASS_DEPTH_FAIL:

    case GL_STENCIL_PASS_DEPTH_PASS:

    case GL_BLEND_DST:

    case GL_BLEND_SRC:

    case GL_LOGIC_OP_MODE:

    case GL_CULL_FACE:

    case GL_DEPTH_FUNC:

    case GL_FOG_HINT:

    case GL_FOG_MODE:

    case GL_FRONT_FACE:

    case GL_LINE_SMOOTH_HINT:

    case GL_MATRIX_MODE:

    case GL_PERSPECTIVE_CORRECTION_HINT:

    case GL_POINT_SMOOTH_HINT:

    case GL_SHADE_MODEL:

    case GL_GENERATE_MIPMAP_HINT:

    case GL_CULL_FACE_MODE:

    case GL_ACTIVE_TEXTURE:

        dgl.glGetIntegerv(pname, i);

        srcType = GLES_TYPE_ENUM;

        break;

    case GL_ALPHA_BITS:

    case GL_RED_BITS:

    case GL_GREEN_BITS:

    case GL_BLUE_BITS:

    case GL_DEPTH_BITS:

    case GL_STENCIL_BITS:

    case GL_STENCIL_VALUE_MASK:

    case GL_STENCIL_WRITEMASK:

    case GL_MODELVIEW_STACK_DEPTH:

    case GL_PROJECTION_STACK_DEPTH:

    case GL_TEXTURE_STACK_DEPTH:

    case GL_PACK_ALIGNMENT:

    case GL_UNPACK_ALIGNMENT:

    case GL_TEXTURE_BINDING_2D:

    case GL_SUBPIXEL_BITS:

    case GL_SAMPLE_BUFFERS:

    case GL_SAMPLES:

    case GL_BUFFER_SIZE:

    case GL_STENCIL_CLEAR_VALUE:

    case GL_MAX_MODELVIEW_STACK_DEPTH:

    case GL_MAX_PROJECTION_STACK_DEPTH:

    case GL_MAX_TEXTURE_STACK_DEPTH:

    case GL_MAX_TEXTURE_SIZE:

        dgl.glGetIntegerv(pname, i);

        srcType = GLES_TYPE_INTEGER;

        break;

    case GL_ALPHA_TEST_REF:

    case GL_STENCIL_REF:

    case GL_DEPTH_CLEAR_VALUE:

    case GL_FOG_DENSITY:

    case GL_FOG_START:

    case GL_FOG_END:

    case GL_LINE_WIDTH:

    case GL_POINT_SIZE:

    case GL_POINT_SIZE_MIN:

    case GL_POINT_SIZE_MAX:

    case GL_POLYGON_OFFSET_FACTOR:

    case GL_POLYGON_OFFSET_UNITS:

    case GL_POINT_FADE_THRESHOLD_SIZE:

        dgl.glGetDoublev(pname, d);

        srcType = GLES_TYPE_DOUBLE;

        break;

    case GL_CURRENT_NORMAL:

    case GL_POINT_DISTANCE_ATTENUATION:

        dgl.glGetDoublev(pname, d);

        srcType = GLES_TYPE_DOUBLE;

        n = 3;

        break;

    case GL_COLOR_CLEAR_VALUE:

    case GL_CURRENT_TEXTURE_COORDS:

    case GL_CURRENT_COLOR:

    case GL_FOG_COLOR:

    case GL_LIGHT_MODEL_AMBIENT:

    case GL_AMBIENT:

    case GL_DIFFUSE:

    case GL_SPECULAR:

    case GL_EMISSION:

        dgl.glGetDoublev(pname, d);

        srcType = GLES_TYPE_DOUBLE;

        n = 4;

        break;

    case GL_COLOR_WRITEMASK:

        dgl.glGetBooleanv(pname, b);

        srcType = GLES_TYPE_BOOLEAN;

        n = 4;

        break;

    case GL_DEPTH_WRITEMASK:

    case GL_LIGHT_MODEL_TWO_SIDE:

        dgl.glGetBooleanv(pname, b);

        srcType = GLES_TYPE_BOOLEAN;

        break;

    case GL_PROJECTION_MATRIX:

    case GL_MODELVIEW_MATRIX:

    case GL_TEXTURE_MATRIX:

        dgl.glGetDoublev(pname, d);

        srcType = GLES_TYPE_DOUBLE;

        n = 16;

        break;

    case GL_VIEWPORT:

    case GL_SCISSOR_BOX:

        dgl.glGetIntegerv(pname, i);

        srcType = GLES_TYPE_INTEGER;

        n = 4;

        break;

    case GL_MAX_VIEWPORT_DIMS:

        dgl.glGetIntegerv(pname, i);

        srcType = GLES_TYPE_INTEGER;

        n = 2;

        break;

    default:

        return false;

    }

    // Type conversions

    // Special cases

    if(dstType == GLES_TYPE_INTEGER &&

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

    {

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

        {

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

        }

        return true;

    }

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

    {

        switch(dstType)

        {

        case GLES_TYPE_BOOLEAN:

            switch(srcType)

            {

            case GLES_TYPE_BOOLEAN:

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

                break;

            case GLES_TYPE_INTEGER:

            case GLES_TYPE_ENUM:

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

                break;

            case GLES_TYPE_DOUBLE:

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

                break;

            default:

                GLES_ASSERT(false);

            }

            break;

        case GLES_TYPE_INTEGER:

            switch(srcType)

            {

            case GLES_TYPE_BOOLEAN:

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

                break;

            case GLES_TYPE_INTEGER:

            case GLES_TYPE_ENUM:

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

                break;

            case GLES_TYPE_DOUBLE:

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

                break;

            default:

                GLES_ASSERT(false);

            }

            break;

        case GLES_TYPE_FLOAT:

            switch(srcType)

            {

            case GLES_TYPE_BOOLEAN:

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

                break;

            case GLES_TYPE_INTEGER:

            case GLES_TYPE_ENUM:

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

                break;

            case GLES_TYPE_DOUBLE:

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

                break;

            default:

                GLES_ASSERT(false);

            }

            break;

        case GLES_TYPE_FIXED:

            switch(srcType)

            {

            case GLES_TYPE_BOOLEAN:

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

                break;

            case GLES_TYPE_INTEGER:

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

                break;

            case GLES_TYPE_ENUM:

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

                break;

            case GLES_TYPE_DOUBLE:

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

                break;

            default:

                GLES_ASSERT(false);

            }

            break;

        default:

            GLES_ASSERT(false);

        }

    }

    return true;

}