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 associated documentation files (the "Software"),

     5  * to deal in the Software without restriction, including without limitation

     6  * the rights to use, copy, modify, merge, publish, distribute, sublicense,

     7  * and/or sell copies of the Software, and to permit persons to whom the

     8  * Software is furnished to do so, subject to the following conditions:

     9  *

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

    11  * in all copies or substantial portions of the Software.

    12  *

    13  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

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

    15  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

    16  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN

    17  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

    18  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

    19  *

    20  * Initial Contributors:

    21  * Nokia Corporation - initial contribution.

    22  *

    23  * Contributors:

    24  *

    25  * Description:

    26  *

    27  */

    28 

    29 #include "common.h"

    30 #include "hgl.h"

    31 #include "context.h"

    32 #include "get.h"

    33 

    34 static GLboolean dglGet(const DGLContext* ctx, GLenum pname, DGLType dstType, void* params)

    35 {

    36 	int j;

    37 	DGLType srcType;

    38 	GLboolean b[1];

    39 	GLint i[11];

    40 

    41 	int n = 1;

    42 

    43 	switch(pname)

    44 	{

    45 		case GL_SHADER_COMPILER:

    46 			srcType = DGLES2_TYPE_BOOL;

    47 			b[0] = GL_TRUE;

    48 			break;

    49 

    50 		case GL_NUM_SHADER_BINARY_FORMATS:

    51 			srcType = DGLES2_TYPE_INT;

    52 			i[0] = 0;

    53 			break;

    54 

    55 		case GL_SHADER_BINARY_FORMATS:

    56 			// None.

    57 			return GL_TRUE;

    58 

    59 		case GL_NUM_COMPRESSED_TEXTURE_FORMATS:

    60 			srcType = DGLES2_TYPE_INT;

    61 			i[0] = 11;

    62 			break;

    63 

    64 		case GL_COMPRESSED_TEXTURE_FORMATS:

    65 			srcType = DGLES2_TYPE_ENUM;

    66 			i[0] = GL_PALETTE4_RGB8_OES;

    67 			i[1] = GL_PALETTE4_RGBA8_OES;

    68 			i[2] = GL_PALETTE4_R5_G6_B5_OES;

    69 			i[3] = GL_PALETTE4_RGBA4_OES;

    70 			i[4] = GL_PALETTE4_RGB5_A1_OES;

    71 			i[5] = GL_PALETTE8_RGB8_OES;

    72 			i[6] = GL_PALETTE8_RGBA8_OES;

    73 			i[7] = GL_PALETTE8_R5_G6_B5_OES;

    74 			i[8] = GL_PALETTE8_RGBA4_OES;

    75 			i[9] = GL_PALETTE8_RGB5_A1_OES;

    76 			i[10] = GL_ETC1_RGB8_OES;

    77 			n = 11;

    78 			break;

    79 

    80 		case GL_IMPLEMENTATION_COLOR_READ_FORMAT:

    81 			i[0] = GL_RGBA;

    82 			srcType = DGLES2_TYPE_ENUM;

    83 			break;

    84 

    85 		case GL_IMPLEMENTATION_COLOR_READ_TYPE:

    86 			i[0] = GL_UNSIGNED_BYTE;

    87 			srcType = DGLES2_TYPE_ENUM;

    88 			break;

    89 

    90 		case GL_MAX_FRAGMENT_UNIFORM_VECTORS:

    91 			ctx->hgl.GetIntegerv(GL_MAX_FRAGMENT_UNIFORM_COMPONENTS, i);

    92 			i[0] /= 4;

    93 			srcType = DGLES2_TYPE_INT;

    94 			break;

    95 

    96 		case GL_MAX_VERTEX_UNIFORM_VECTORS:

    97 			ctx->hgl.GetIntegerv(GL_MAX_VERTEX_UNIFORM_COMPONENTS, i);

    98 			i[0] /= 4;

    99 			srcType = DGLES2_TYPE_INT;

   100 			break;

   101 

   102 		case GL_MAX_VARYING_VECTORS:

   103 			ctx->hgl.GetIntegerv(GL_MAX_VARYING_FLOATS, i);

   104 			i[0] /= 4;

   105 			srcType = DGLES2_TYPE_INT;

   106 			break;

   107 

   108 		default:

   109 			// Let the host GL handle this case.

   110 			return GL_FALSE;

   111 	}

   112 

   113 	// Type conversions.

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

   115 	{

   116 		switch(dstType)

   117 		{

   118 			case DGLES2_TYPE_FLOAT:

   119 				switch(srcType)

   120 				{

   121 					case DGLES2_TYPE_BOOL:

   122 						((GLfloat*)params)[j] = b[j] ? 1.f : 0.f;

   123 						break;

   124 

   125 					case DGLES2_TYPE_INT:

   126 					case DGLES2_TYPE_ENUM:

   127 						((GLfloat*)params)[j] = (GLfloat)i[j];

   128 						break;

   129 

   130 					default:

   131 						DGLES2_ASSERT(GL_FALSE);

   132 				}

   133 				break;

   134 

   135 			case DGLES2_TYPE_BOOL:

   136 				switch(srcType)

   137 				{

   138 					case DGLES2_TYPE_BOOL:

   139 						((GLboolean*)params)[j] = b[j];

   140 						break;

   141 

   142 					case DGLES2_TYPE_INT:

   143 					case DGLES2_TYPE_ENUM:

   144 						((GLboolean*)params)[j] = i[j] ? GL_TRUE : GL_FALSE;

   145 						break;

   146 

   147 					default:

   148 						DGLES2_ASSERT(GL_FALSE);

   149 				}

   150 				break;

   151 

   152 			case DGLES2_TYPE_INT:

   153 				switch(srcType)

   154 				{

   155 					case DGLES2_TYPE_BOOL:

   156 						((GLint*)params)[j] = b[j] ? 1 : 0;

   157 						break;

   158 

   159 					case DGLES2_TYPE_INT:

   160 					case DGLES2_TYPE_ENUM:

   161 						((GLint*)params)[j] = i[j];

   162 						break;

   163 

   164 					default:

   165 						DGLES2_ASSERT(GL_FALSE);

   166 				}

   167 				break;

   168 

   169 			default:

   170 				DGLES2_ASSERT(GL_FALSE);

   171 		}

   172 	}

   173 

   174 	return GL_TRUE;

   175 }

   176 

   177 GL_APICALL_BUILD void GL_APIENTRY glGetBooleanv(GLenum pname, GLboolean* params)

   178 {

   179 	DGLES2_ENTER();

   180 	if(!dglGet(ctx, pname, DGLES2_TYPE_BOOL, params))

   181 	{

   182 		ctx->hgl.GetBooleanv(pname, params);

   183 	}

   184 	DGLES2_LEAVE();

   185 }

   186 

   187 GL_APICALL_BUILD GLenum GL_APIENTRY glGetError(void)

   188 {

   189 	DGLES2_ENTER_RET(GL_NO_ERROR);

   190 	{

   191 		GLenum host_error = ctx->hgl.GetError();

   192 		GLenum wrapper_error = ctx->error;

   193 		ctx->error = GL_NO_ERROR;

   194 		DGLES2_LEAVE_RET(host_error != GL_NO_ERROR ? host_error : wrapper_error);

   195 	}

   196 }

   197 

   198 GL_APICALL_BUILD void GL_APIENTRY glGetFloatv(GLenum pname, GLfloat* params)

   199 {

   200 	DGLES2_ENTER();

   201 	if(!dglGet(ctx, pname, DGLES2_TYPE_FLOAT, params))

   202 	{

   203 		ctx->hgl.GetFloatv(pname, params);

   204 	}

   205 	DGLES2_LEAVE();

   206 }

   207 

   208 GL_APICALL_BUILD void GL_APIENTRY glGetIntegerv(GLenum pname, GLint* params)

   209 {

   210 	DGLES2_ENTER();

   211 	if(!dglGet(ctx, pname, DGLES2_TYPE_INT, params))

   212 	{

   213 		ctx->hgl.GetIntegerv(pname, params);

   214 	}

   215 	DGLES2_LEAVE();

   216 }

   217 

   218 GL_APICALL_BUILD const GLubyte* GL_APIENTRY glGetString(GLenum name)

   219 {

   220 	DGLES2_ENTER_RET(NULL);

   221 	{

   222 		static const GLubyte vendor[] = "Nokia";

   223 		static const GLubyte renderer[] = "OpenGL ES 2.0";

   224 		static const GLubyte version[] = "OpenGL ES 2.0";

   225 		static const GLubyte slversion[] = "OpenGL ES GLSL ES 1.0";

   226 		static const GLubyte extensions[] = "GL_OES_depth24 GL_OES_depth32 GL_OES_rgb8_rgba8 "

   227 											"GL_OES_vertex_half_float GL_OES_texture_half_float "

   228 											"GL_OES_texture_half_float_linear GL_OES_texture_npot "

   229 											"GL_OES_compressed_paletted_texture "

   230 											"GL_OES_compressed_ETC1_RGB8_texture "

   231 											"GL_OES_EGL_image";

   232 		const GLubyte* str = NULL;

   233 		switch(name)

   234 		{

   235 		case GL_VENDOR:

   236 			str = vendor;

   237 			break;

   238 		case GL_RENDERER:

   239 			str = renderer;

   240 			break;

   241 		case GL_VERSION:

   242 			str = version;

   243 			break;

   244 		case GL_SHADING_LANGUAGE_VERSION:

   245 			str = slversion;

   246 			break;

   247 		case GL_EXTENSIONS:

   248 			str = extensions;

   249 			break;

   250 		default:

   251 			DGLES2_ERROR_RET(GL_INVALID_ENUM, NULL);

   252 			break;

   253 		}

   254 		DGLES2_LEAVE_RET(str);

   255 	}

   256 }

   257