/* 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 <GLES/gl.h>

#include <GLES/glplatform.h>

#include <iostream>

#include "GLESDesktopGL.h"

#include "glesInternal.h"

#include "EGLInterface.h"

#include "GLESContext.h"

#include "GLESArray.h"

#include "GLESTexture.h"

#include "glesGet.h"

// exit()

#include <stdlib.h>

// memcpy

#include <string.h>

#ifdef __cplusplus

extern "C" {

#endif

/* Available only in Common profile */

GL_API void GL_APIENTRY glAlphaFunc (GLenum func, GLclampf ref)

{

    GLES_ENTER();

    ctx->DGL().glAlphaFunc (func, ref);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glClearColor (GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)

{

    GLES_ENTER();

    ctx->DGL().glClearColor (red, green, blue, alpha);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glClearDepthf (GLclampf depth)

{

    GLES_ENTER();

    ctx->DGL().glClearDepth (depth);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glClipPlanef (GLenum plane, const GLfloat *equation)

{

    GLES_ENTER();

    GLES_ERROR_IF(plane < GL_CLIP_PLANE0 || plane >= GL_CLIP_PLANE0 + ctx->MaxClipPlanes(), GL_INVALID_ENUM);

    GLdouble dequation[4];

    for(int i = 0; i < 4; i++)

    {

        dequation[i] = static_cast<GLdouble>(equation[i]);

    }

    ctx->DGL().glClipPlane (plane, dequation);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glColor4f (GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)

{

    GLES_ENTER();

    ctx->DGL().glColor4f (red, green, blue, alpha);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glDepthRangef (GLclampf zNear, GLclampf zFar)

{

    GLES_ENTER();

    ctx->DGL().glDepthRange(zNear, zFar);

    GLES_LEAVE();

}

bool isValidSingleValuedFogParamEnum(GLenum pname)

{

    switch(pname)

    {

    case GL_FOG_MODE:

    case GL_FOG_DENSITY:

    case GL_FOG_START:

    case GL_FOG_END:

        return true;

    default:

        return false;

    }

}

bool isValidFogParamEnum(GLenum pname)

{

    return isValidSingleValuedFogParamEnum(pname) || pname == GL_FOG_COLOR;

}

GL_API void GL_APIENTRY glFogf (GLenum pname, GLfloat param)

{

    GLES_ENTER();

    GLES_ERROR_IF(!isValidFogParamEnum(pname), GL_INVALID_ENUM);

    ctx->DGL().glFogf (pname, param);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glFogfv (GLenum pname, const GLfloat *params)

{

    GLES_ENTER();

    GLES_ERROR_IF(!isValidFogParamEnum(pname), GL_INVALID_ENUM);

    ctx->DGL().glFogfv (pname, params);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glFrustumf (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)

{

    GLES_ENTER();

    ctx->DGL().glFrustum (left, right, bottom, top, zNear, zFar);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glGetClipPlanef (GLenum pname, GLfloat eqn[4])

{

    GLES_ENTER();

    GLdouble deqn[4];

    ctx->DGL().glGetClipPlane (pname, deqn);

    for(int i = 0; i < 4; i++)

    {

        eqn[i] = static_cast<GLfloat>(deqn[i]);

    }

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glGetFloatv (GLenum pname, GLfloat *params)

{

    GLES_ENTER();

    if(!glesGetParameter(*ctx, ctx->DGL(), pname, GLES_TYPE_FLOAT, params))

    {

        GLES_ERROR(GL_INVALID_ENUM);

    }

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glGetLightfv (GLenum light, GLenum pname, GLfloat *params)

{

    GLES_ENTER();

    ctx->DGL().glGetLightfv (light, pname, params);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glGetMaterialfv (GLenum face, GLenum pname, GLfloat *params)

{

    GLES_ENTER();

    ctx->DGL().glGetMaterialfv (face, pname, params);

    GLES_LEAVE();

}

bool isValidTexEnvTargetEnum(GLenum target)

{

    switch(target)

    {

    case GL_POINT_SPRITE_OES:

    case GL_TEXTURE_ENV:

        return true;

    default:

        return false;

    }

}

bool isValidSingleValuedTexEnvParamEnum(GLenum pname)

{

    switch(pname)

    {

    case GL_TEXTURE_ENV_MODE:

    case GL_COORD_REPLACE_OES:

    case GL_COMBINE_RGB:

    case GL_COMBINE_ALPHA:

    case GL_SRC0_RGB:

    case GL_SRC1_RGB:

    case GL_SRC2_RGB:

    case GL_SRC0_ALPHA:

    case GL_SRC1_ALPHA:

    case GL_SRC2_ALPHA:

    case GL_OPERAND0_RGB:

    case GL_OPERAND1_RGB:

    case GL_OPERAND2_RGB:

    case GL_OPERAND0_ALPHA:

    case GL_OPERAND1_ALPHA:

    case GL_OPERAND2_ALPHA:

    case GL_RGB_SCALE:

    case GL_ALPHA_SCALE:

        return true;

    default:

        return false;

    }

}

bool isValidTexEnvParamEnum(GLenum pname)

{

    return isValidSingleValuedTexEnvParamEnum(pname) || pname == GL_TEXTURE_ENV_COLOR;

}

GL_API void GL_APIENTRY glGetTexEnvfv (GLenum env, GLenum pname, GLfloat *params)

{

    GLES_ENTER();

    GLES_ERROR_IF(!isValidTexEnvTargetEnum(env), GL_INVALID_ENUM);

    GLES_ERROR_IF(!isValidTexEnvParamEnum(pname), GL_INVALID_ENUM);

    env = env == GL_POINT_SPRITE_OES ? GL_POINT_SPRITE : env;

    pname = pname == GL_COORD_REPLACE_OES ? GL_COORD_REPLACE : pname;

    ctx->DGL().glGetTexEnvfv (env, pname, params);

    GLES_LEAVE();

}

bool isValidTexParamEnum(GLenum pname)

{

    switch(pname)

    {

    case GL_TEXTURE_MIN_FILTER:

    case GL_TEXTURE_MAG_FILTER:

    case GL_TEXTURE_WRAP_S:

    case GL_TEXTURE_WRAP_T:

    case GL_GENERATE_MIPMAP:

        return true;

    default:

        return false;

    }

}

GL_API void GL_APIENTRY glGetTexParameterfv (GLenum target, GLenum pname, GLfloat *params)

{

    GLES_ENTER();

    GLES_ERROR_IF(!isValidTexParamEnum(pname), GL_INVALID_ENUM);

    ctx->DGL().glGetTexParameterfv (target, pname, params);

    GLES_LEAVE();

}

bool isValidLightModelParamEnum(GLenum pname)

{

    switch(pname)

    {

    case GL_LIGHT_MODEL_AMBIENT:

    case GL_LIGHT_MODEL_TWO_SIDE:

        return true;

    default:

        return false;

    }

}

GL_API void GL_APIENTRY glLightModelf (GLenum pname, GLfloat param)

{

    GLES_ENTER();

    GLES_ERROR_IF(!isValidLightModelParamEnum(pname), GL_INVALID_ENUM);

    ctx->DGL().glLightModelf (pname, param);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glLightModelfv (GLenum pname, const GLfloat *params)

{

    GLES_ENTER();

    GLES_ERROR_IF(!isValidLightModelParamEnum(pname), GL_INVALID_ENUM);

    ctx->DGL().glLightModelfv (pname, params);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glLightf (GLenum light, GLenum pname, GLfloat param)

{

    GLES_ENTER();

    ctx->DGL().glLightf (light, pname, param);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glLightfv (GLenum light, GLenum pname, const GLfloat *params)

{

    GLES_ENTER();

    ctx->DGL().glLightfv (light, pname, params);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glLineWidth (GLfloat width)

{

    GLES_ENTER();

    ctx->DGL().glLineWidth (width);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glLoadMatrixf (const GLfloat *m)

{

    GLES_ENTER();

    ctx->DGL().glLoadMatrixf (m);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glMaterialf (GLenum face, GLenum pname, GLfloat param)

{

    GLES_ENTER();

    ctx->DGL().glMaterialf (face, pname, param);

    GLES_LEAVE();

}

bool isValidSingleValuedMaterialParamEnum(GLenum pname)

{

    return pname == GL_SHININESS;

}

bool isValidMaterialParamEnum(GLenum pname)

{

    if(isValidSingleValuedMaterialParamEnum(pname))

    {

        return true;

    }

    else

    {

        switch(pname)

        {

        case GL_AMBIENT:

        case GL_DIFFUSE:

        case GL_AMBIENT_AND_DIFFUSE:

        case GL_SPECULAR:

        case GL_EMISSION:

        case GL_SHININESS:

            return true;

        default:

            return false;

        }

    }

}

GL_API void GL_APIENTRY glMaterialfv (GLenum face, GLenum pname, const GLfloat *params)

{

    GLES_ENTER();

    GLES_ERROR_IF(!isValidMaterialParamEnum(pname), GL_INVALID_ENUM);

    ctx->DGL().glMaterialfv (face, pname, params);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glMultMatrixf (const GLfloat *m)

{

    GLES_ENTER();

    ctx->DGL().glMultMatrixf(m);

    GLES_LEAVE();

}

bool isValidTextureTargetEnum(GLenum target, unsigned int maxTextureUnits)

{

    return target >= GL_TEXTURE0 && target < GL_TEXTURE0 + maxTextureUnits;

}

GL_API void GL_APIENTRY glMultiTexCoord4f (GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)

{

    GLES_ENTER();

    GLES_ERROR_IF(!isValidTextureTargetEnum(target, ctx->MaxTextureUnits()), GL_INVALID_ENUM);

    ctx->DGL().glMultiTexCoord4f(target, s, t, r, q);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glNormal3f (GLfloat nx, GLfloat ny, GLfloat nz)

{

    GLES_ENTER();

    ctx->DGL().glNormal3f(nx, ny, nz);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glOrthof (GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar)

{

    GLES_ENTER();

    ctx->DGL().glOrtho(left, right, bottom, top, zNear, zFar);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glPointParameterf (GLenum pname, GLfloat param)

{

    GLES_ENTER();

    ctx->DGL().glPointParameterf (pname, param);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glPointParameterfv (GLenum pname, const GLfloat *params)

{

    GLES_ENTER();

    ctx->DGL().glPointParameterfv (pname, params);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glPointSize (GLfloat size)

{

    GLES_ENTER();

    ctx->DGL().glPointSize (size);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glPolygonOffset (GLfloat factor, GLfloat units)

{

    GLES_ENTER();

    ctx->DGL().glPolygonOffset (factor, units);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glRotatef (GLfloat angle, GLfloat x, GLfloat y, GLfloat z)

{

    GLES_ENTER();

    ctx->DGL().glRotatef (angle, x, y, z);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glScalef (GLfloat x, GLfloat y, GLfloat z)

{

    GLES_ENTER();

    ctx->DGL().glScalef (x, y, z);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glTexEnvf (GLenum target, GLenum pname, GLfloat param)

{

    GLES_ENTER();

    GLES_ERROR_IF(!isValidTexEnvTargetEnum(target), GL_INVALID_ENUM);

    GLES_ERROR_IF(!isValidTexEnvParamEnum(pname), GL_INVALID_ENUM);

    target = target == GL_POINT_SPRITE_OES ? GL_POINT_SPRITE : target;

    pname = pname == GL_COORD_REPLACE_OES ? GL_COORD_REPLACE : pname;

    ctx->DGL().glTexEnvf (target, pname, param);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glTexEnvfv (GLenum target, GLenum pname, const GLfloat *params)

{

    GLES_ENTER();

    GLES_ERROR_IF(!isValidTexEnvTargetEnum(target), GL_INVALID_ENUM);

    GLES_ERROR_IF(!isValidTexEnvParamEnum(pname), GL_INVALID_ENUM);

    target = target == GL_POINT_SPRITE_OES ? GL_POINT_SPRITE : target;

    pname = pname == GL_COORD_REPLACE_OES ? GL_COORD_REPLACE : pname;

    ctx->DGL().glTexEnvfv (target, pname, params);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glTexParameterf (GLenum target, GLenum pname, GLfloat param)

{

    GLES_ENTER();

    GLES_ERROR_IF(target != GL_TEXTURE_2D, GL_INVALID_ENUM);

    GLES_ERROR_IF(!isValidTexParamEnum(pname), GL_INVALID_ENUM);

    pname = pname == GL_COORD_REPLACE_OES ? GL_COORD_REPLACE : pname;

    ctx->DGL().glTexParameterf (target, pname, param);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glTexParameterfv (GLenum target, GLenum pname, const GLfloat *params)

{

    GLES_ENTER();

    GLES_ERROR_IF(target != GL_TEXTURE_2D, GL_INVALID_ENUM);

    GLES_ERROR_IF(!isValidTexParamEnum(pname), GL_INVALID_ENUM);

    target = target == GL_POINT_SPRITE_OES ? GL_POINT_SPRITE : target;

    pname = pname == GL_COORD_REPLACE_OES ? GL_COORD_REPLACE : pname;

    ctx->DGL().glTexParameterfv (target, pname, params);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glTranslatef (GLfloat x, GLfloat y, GLfloat z)

{

    GLES_ENTER();

    ctx->DGL().glTranslatef (x, y, z);

    GLES_LEAVE();

}

/* Available in both Common and Common-Lite profiles */

GL_API void GL_APIENTRY glActiveTexture (GLenum texture)

{

    GLES_ENTER();

    GLES_ERROR_IF(!isValidTextureTargetEnum(texture, ctx->MaxTextureUnits()), GL_INVALID_ENUM);

    ctx->DGL().glActiveTexture (texture);

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glAlphaFuncx (GLenum func, GLclampx ref)

{

    GLES_ENTER();

    ctx->DGL().glAlphaFunc(func, X_TO_F(ref));

    GLES_LEAVE();

}

bool isValidBufferTarget(GLenum target)

{

    switch(target)

    {

    case GL_ARRAY_BUFFER:

    case GL_ELEMENT_ARRAY_BUFFER:

        return true;

    default:

        return false;

    }

}

GL_API void GL_APIENTRY glBindBuffer (GLenum target, GLuint buffer)

{

    GLES_ENTER();

    GLES_ERROR_IF(!isValidBufferTarget(target), GL_INVALID_ENUM);

    switch(target)

    {

    case GL_ARRAY_BUFFER:

        if(!ctx->BindArrayBuffer(buffer))

        {

            GLES_ERROR(GL_OUT_OF_MEMORY);

        }

        break;

    case GL_ELEMENT_ARRAY_BUFFER:

        if(!ctx->BindElementArrayBuffer(buffer))

        {

            GLES_ERROR(GL_OUT_OF_MEMORY);

        }

        break;

    default:

        GLES_ERROR(GL_INVALID_ENUM);

    }

    GLES_LEAVE();

}

GL_API void GL_APIENTRY glBindTexture (GLenum target, GLuint texture)

{

    GLES_ENTER();

    GLES_ERROR_IF(target != GL_TEXTURE_2D, GL_INVALID_ENUM);

    ctx->GetHostError();

    ctx->DGL().glBindTexture (target, texture);

    if(ctx->GetHostError() == GL_NO_ERROR)

    {

        ctx->BindTexture(texture);

    }

    GLES_LEAVE();

}

bool isValidSrcBlendFuncEnum(GLenum func)