summaryrefslogtreecommitdiff
path: root/GLESv1_CM/yagl_gles1_calls.c
diff options
context:
space:
mode:
Diffstat (limited to 'GLESv1_CM/yagl_gles1_calls.c')
-rw-r--r--GLESv1_CM/yagl_gles1_calls.c1684
1 files changed, 1319 insertions, 365 deletions
diff --git a/GLESv1_CM/yagl_gles1_calls.c b/GLESv1_CM/yagl_gles1_calls.c
index e2eee55..f044939 100644
--- a/GLESv1_CM/yagl_gles1_calls.c
+++ b/GLESv1_CM/yagl_gles1_calls.c
@@ -1,343 +1,751 @@
-#include "yagl_state.h"
-#include "yagl_host_gles1_calls.h"
+#include "GLES/gl.h"
+#include "GLES/glext.h"
+#include "yagl_gles_calls.h"
+#include "yagl_host_gles_calls.h"
+#include "yagl_gles1_validate.h"
+#include "yagl_gles1_context.h"
+#include "yagl_gles_array.h"
+#include "yagl_gles_buffer.h"
#include "yagl_impl.h"
-#include "yagl_gles_context.h"
#include "yagl_malloc.h"
-#include "GLES/glext.h"
+#include "yagl_transport.h"
+#include "yagl_utils.h"
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
-#include "yagl_gles_utils.h"
+#include <assert.h>
+
+#define YAGL_SET_ERR(err) \
+ yagl_gles_context_set_error(&ctx->base, err); \
+ YAGL_LOG_ERROR("error = 0x%X", err)
+
+#define YAGL_GET_CTX_IMPL(ret_expr) \
+ struct yagl_gles1_context *ctx = \
+ (struct yagl_gles1_context*)yagl_get_client_context(); \
+ if (!ctx || (ctx->base.base.client_api != yagl_client_api_gles1)) { \
+ YAGL_LOG_WARN("no current context"); \
+ YAGL_LOG_FUNC_EXIT(NULL); \
+ ret_expr; \
+ }
-/*
- * GLES1 has arrays of vertices, normals, colors, texture coordinates and
- * point sizes. Every texture unit has its own texture coordinates array
- */
-typedef enum {
- YAGL_GLES1_ARRAY_VERTEX = 0,
- YAGL_GLES1_ARRAY_COLOR,
- YAGL_GLES1_ARRAY_NORMAL,
- YAGL_GLES1_ARRAY_POINTSIZE,
- YAGL_GLES1_ARRAY_TEX_COORD,
-} YaglGles1ArrayType;
+#define YAGL_GET_CTX_RET(ret) YAGL_GET_CTX_IMPL(return ret)
-static inline int yagl_get_active_tex_index(void)
-{
- return YAGL_GLES1_ARRAY_TEX_COORD +
- yagl_get_integer(GL_CLIENT_ACTIVE_TEXTURE) - GL_TEXTURE0;
-}
+#define YAGL_GET_CTX() YAGL_GET_CTX_IMPL(return)
-static unsigned yagl_gles1_array_idx_get(struct yagl_gles_context *ctx,
- GLenum array)
+static __inline int yagl_gles1_array_idx_get(struct yagl_gles1_context *ctx,
+ GLenum array,
+ unsigned *arr_idx_p)
{
- unsigned ret;
-
switch (array) {
case GL_VERTEX_ARRAY:
- ret = YAGL_GLES1_ARRAY_VERTEX;
+ *arr_idx_p = yagl_gles1_array_vertex;
break;
case GL_COLOR_ARRAY:
- ret = YAGL_GLES1_ARRAY_COLOR;
+ *arr_idx_p = yagl_gles1_array_color;
break;
case GL_NORMAL_ARRAY:
- ret = YAGL_GLES1_ARRAY_NORMAL;
+ *arr_idx_p = yagl_gles1_array_normal;
break;
case GL_TEXTURE_COORD_ARRAY:
- ret = yagl_get_active_tex_index();
+ *arr_idx_p = yagl_gles1_array_texcoord + ctx->client_active_texture;
break;
case GL_POINT_SIZE_ARRAY_OES:
- ret = YAGL_GLES1_ARRAY_POINTSIZE;
+ *arr_idx_p = yagl_gles1_array_pointsize;
break;
default:
- ret = -1;
- break;
+ return 0;
}
- if (ret >= ctx->num_arrays) {
- fprintf(stderr, "Error! Array with index %d doesn't exist at %s:%d\n",
- ret, __func__, __LINE__);
+ return 1;
+}
+
+/*
+ * TODO: Passthrough for now.
+ * @{
+ */
+
+YAGL_IMPLEMENT_API_NORET2(glAlphaFunc, GLenum, GLclampf, func, ref)
+YAGL_IMPLEMENT_API_NORET3(glTexEnvf, GLenum, GLenum, GLfloat, target, pname, param)
+YAGL_IMPLEMENT_API_NORET1(glMatrixMode, GLenum, mode)
+YAGL_IMPLEMENT_API_NORET0(glLoadIdentity)
+YAGL_IMPLEMENT_API_NORET0(glPopMatrix)
+YAGL_IMPLEMENT_API_NORET0(glPushMatrix)
+YAGL_IMPLEMENT_API_NORET4(glRotatef, GLfloat, GLfloat, GLfloat, GLfloat, angle, x, y, z)
+YAGL_IMPLEMENT_API_NORET3(glTranslatef, GLfloat, GLfloat, GLfloat, x, y, z)
+YAGL_IMPLEMENT_API_NORET3(glScalef, GLfloat, GLfloat, GLfloat, x, y, z)
+YAGL_IMPLEMENT_API_NORET4(glColor4f, GLfloat, GLfloat, GLfloat, GLfloat, red, green, blue, alpha)
+YAGL_IMPLEMENT_API_NORET4(glColor4ub, GLubyte, GLubyte, GLubyte, GLubyte, red, green, blue, alpha)
+YAGL_IMPLEMENT_API_NORET3(glNormal3f, GLfloat, GLfloat, GLfloat, nx, ny, nz)
+YAGL_IMPLEMENT_API_NORET1(glShadeModel, GLenum, mode)
+YAGL_IMPLEMENT_API_NORET1(glLogicOp, GLenum, opcode)
+
+/*
+ * @}
+ */
+
+YAGL_API void glAlphaFuncx(GLenum func, GLclampx ref)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT2(glAlphaFuncx, GLenum, GLclampx, func, ref);
+
+ YAGL_GET_CTX();
+
+ yagl_host_glAlphaFunc(func, yagl_fixed_to_float(ref));
+
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
+
+YAGL_API void glTexEnvi(GLenum target, GLenum pname, GLint param)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT3(glTexEnvi, GLenum, GLenum, GLint, target, pname, param);
+
+ YAGL_GET_CTX();
+
+ if ((target != GL_TEXTURE_ENV) && (target != GL_POINT_SPRITE_OES)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
}
- return ret;
+ yagl_host_glTexEnvi(target, pname, param);
+
+out:
+ YAGL_LOG_FUNC_EXIT(NULL);
}
-static void yagl_query_gles1_array(struct yagl_gles_array *arr,
- YaglGles1ArrayType arr_type)
+YAGL_API void glTexEnvx(GLenum target, GLenum pname, GLfixed param)
{
- GLenum name, buff_bind, stride, pointer;
+ GLfloat paramf;
- switch (arr_type) {
- case YAGL_GLES1_ARRAY_VERTEX:
- name = GL_VERTEX_ARRAY;
- buff_bind = GL_VERTEX_ARRAY_BUFFER_BINDING;
- stride = GL_VERTEX_ARRAY_STRIDE;
- pointer = GL_VERTEX_ARRAY_POINTER;
- break;
- case YAGL_GLES1_ARRAY_COLOR:
- name = GL_COLOR_ARRAY;
- buff_bind = GL_COLOR_ARRAY_BUFFER_BINDING;
- stride = GL_COLOR_ARRAY_STRIDE;
- pointer = GL_COLOR_ARRAY_POINTER;
- break;
- case YAGL_GLES1_ARRAY_NORMAL:
- name = GL_NORMAL_ARRAY;
- buff_bind = GL_NORMAL_ARRAY_BUFFER_BINDING;
- stride = GL_NORMAL_ARRAY_STRIDE;
- pointer = GL_NORMAL_ARRAY_POINTER;
- break;
- case YAGL_GLES1_ARRAY_POINTSIZE:
- name = GL_POINT_SIZE_ARRAY_OES;
- buff_bind = GL_POINT_SIZE_ARRAY_BUFFER_BINDING_OES;
- stride = GL_POINT_SIZE_ARRAY_STRIDE_OES;
- pointer = GL_POINT_SIZE_ARRAY_POINTER_OES;
- break;
- case YAGL_GLES1_ARRAY_TEX_COORD:
- name = GL_TEXTURE_COORD_ARRAY;
- buff_bind = GL_TEXTURE_COORD_ARRAY_BUFFER_BINDING;
- stride = GL_TEXTURE_COORD_ARRAY_STRIDE;
- pointer = GL_TEXTURE_COORD_ARRAY_POINTER;
- break;
- default:
- fprintf(stderr, "Programming error! Unknown array %d type at %s:%d\n",
- arr_type, __func__, __LINE__);
- exit(1);
+ YAGL_LOG_FUNC_ENTER_SPLIT3(glTexEnvx, GLenum, GLenum, GLfixed, target, pname, param);
+
+ YAGL_GET_CTX();
+
+ if ((target != GL_TEXTURE_ENV) && (target != GL_POINT_SPRITE_OES)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
}
- arr->enabled = yagl_get_integer(name);
- arr->vbo = yagl_get_integer(buff_bind);
- arr->stride = yagl_get_integer(stride);
+ if ((pname == GL_RGB_SCALE) || (pname == GL_ALPHA_SCALE)) {
+ paramf = yagl_fixed_to_float(param);
+ } else {
+ paramf = (GLfloat)param;
+ }
+
+ yagl_host_glTexEnvf(target, pname, paramf);
+
+out:
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
+
+YAGL_API void glRotatex(GLfixed angle,
+ GLfixed x,
+ GLfixed y,
+ GLfixed z)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT4(glRotatex, GLfixed, GLfixed, GLfixed, GLfixed, angle, x, y, z);
+
+ YAGL_GET_CTX();
+
+ yagl_host_glRotatef(yagl_fixed_to_float(angle),
+ yagl_fixed_to_float(x),
+ yagl_fixed_to_float(y),
+ yagl_fixed_to_float(z));
+
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
- if (!arr->vbo) {
- yagl_host_glGetPointerv(pointer, &arr->ptr);
+YAGL_API void glTranslatex(GLfixed x,
+ GLfixed y,
+ GLfixed z)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT3(glTranslatex, GLfixed, GLfixed, GLfixed, x, y, z);
+
+ YAGL_GET_CTX();
+
+ yagl_host_glTranslatef(yagl_fixed_to_float(x),
+ yagl_fixed_to_float(y),
+ yagl_fixed_to_float(z));
+
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
+
+YAGL_API void glScalex(GLfixed x,
+ GLfixed y,
+ GLfixed z)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT3(glScalex, GLfixed, GLfixed, GLfixed, x, y, z);
+
+ YAGL_GET_CTX();
+
+ yagl_host_glScalef(yagl_fixed_to_float(x),
+ yagl_fixed_to_float(y),
+ yagl_fixed_to_float(z));
+
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
+
+YAGL_API void glOrthof(GLfloat left,
+ GLfloat right,
+ GLfloat bottom,
+ GLfloat top,
+ GLfloat zNear,
+ GLfloat zFar)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT6(glOrthof, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, left, right, bottom, top, zNear, zFar);
+
+ YAGL_GET_CTX();
+
+ if ((left == right) || (bottom == top) || (zNear == zFar)) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ } else {
+ yagl_host_glOrthof(left, right, bottom, top, zNear, zFar);
}
+
+ YAGL_LOG_FUNC_EXIT(NULL);
}
-static inline void yagl_set_client_active_texture(GLenum tex)
+YAGL_API void glOrthox(GLfixed left,
+ GLfixed right,
+ GLfixed bottom,
+ GLfixed top,
+ GLfixed zNear,
+ GLfixed zFar)
{
- yagl_host_glClientActiveTexture(tex);
+ YAGL_LOG_FUNC_ENTER_SPLIT6(glOrthox, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, left, right, bottom, top, zNear, zFar);
+
+ YAGL_GET_CTX();
+
+ if ((left == right) || (bottom == top) || (zNear == zFar)) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ } else {
+ yagl_host_glOrthof(yagl_fixed_to_float(left),
+ yagl_fixed_to_float(right),
+ yagl_fixed_to_float(bottom),
+ yagl_fixed_to_float(top),
+ yagl_fixed_to_float(zNear),
+ yagl_fixed_to_float(zFar));
+ }
+
+ YAGL_LOG_FUNC_EXIT(NULL);
}
-static void yagl_query_texture_arrays(struct yagl_gles_array *arrays,
- int num_texture_units)
+YAGL_API void glPointSize(GLfloat size)
{
- GLint cur_text;
- int i;
+ YAGL_LOG_FUNC_ENTER_SPLIT1(glPointSize, GLfloat, size);
- cur_text = yagl_get_integer(GL_CLIENT_ACTIVE_TEXTURE);
+ YAGL_GET_CTX();
- for (i = 0; i < num_texture_units; ++i) {
- yagl_set_client_active_texture(GL_TEXTURE0 + i);
- yagl_query_gles1_array(&arrays[i], YAGL_GLES1_ARRAY_TEX_COORD);
+ if (size <= 0) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ } else {
+ yagl_host_glPointSize(size);
}
- yagl_set_client_active_texture(cur_text);
+ YAGL_LOG_FUNC_EXIT(NULL);
}
-void yagl_update_arrays(void)
+YAGL_API void glPointSizex(GLfixed size)
{
- struct yagl_gles_context *ctx = yagl_gles_context_get();
- int i;
- int num_texture_units;
+ GLfloat sizef;
+
+ YAGL_LOG_FUNC_ENTER_SPLIT1(glPointSizex, GLfixed, size);
+
+ YAGL_GET_CTX();
- if (!ctx || ctx->arrays) {
- return;
+ sizef = yagl_fixed_to_float(size);
+
+ if (sizef <= 0) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ } else {
+ yagl_host_glPointSize(sizef);
}
- num_texture_units = yagl_get_integer(GL_MAX_TEXTURE_UNITS);
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
- ctx->num_arrays = YAGL_GLES1_ARRAY_TEX_COORD + num_texture_units;
+YAGL_API void glLineWidthx(GLfixed width)
+{
+ GLfloat widthf;
- ctx->arrays = yagl_malloc0(sizeof(*ctx->arrays) * ctx->num_arrays);
+ YAGL_LOG_FUNC_ENTER_SPLIT1(glLineWidthx, GLfixed, width);
- for (i = YAGL_GLES1_ARRAY_VERTEX; i < YAGL_GLES1_ARRAY_TEX_COORD; ++i) {
- yagl_query_gles1_array(&ctx->arrays[i], i);
+ YAGL_GET_CTX();
+
+ widthf = yagl_fixed_to_float(width);
+
+ if (widthf <= 0) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ goto out;
}
- yagl_query_texture_arrays(&ctx->arrays[YAGL_GLES1_ARRAY_TEX_COORD],
- num_texture_units);
+ yagl_gles_context_line_width(&ctx->base, widthf);
+
+out:
+ YAGL_LOG_FUNC_EXIT(NULL);
}
-static void yagl_set_array_pointer(GLenum array_type,
- GLint size,
- GLenum type,
- GLsizei stride,
- const GLvoid* pointer)
+YAGL_API void glTexParameterx(GLenum target,
+ GLenum pname,
+ GLfixed param)
{
- struct yagl_gles_context *ctx = yagl_gles_context_get();
- int el_size = 0;
- unsigned arr_idx;
+ YAGL_LOG_FUNC_ENTER_SPLIT3(glTexParameterx, GLenum, GLenum, GLfixed, target, pname, param);
+
+ YAGL_GET_CTX();
+
+ if (target != GL_TEXTURE_2D) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
+ yagl_gles_context_tex_parameterf(&ctx->base, target, pname, (GLfloat)param);
+
+out:
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
+
+YAGL_API void glColor4x(GLfixed red,
+ GLfixed green,
+ GLfixed blue,
+ GLfixed alpha)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT4(glColor4x, GLfixed, GLfixed, GLfixed, GLfixed, red, green, blue, alpha);
+
+ YAGL_GET_CTX();
+
+ yagl_host_glColor4f(yagl_fixed_to_float(red),
+ yagl_fixed_to_float(green),
+ yagl_fixed_to_float(blue),
+ yagl_fixed_to_float(alpha));
- if (ctx && ctx->arrays && yagl_get_el_size(type, &el_size)) {
- arr_idx = yagl_gles1_array_idx_get(ctx, array_type);
- yagl_update_vbo();
- ctx->arrays[arr_idx].vbo = 0;
- ctx->arrays[arr_idx].stride = 0;
- ctx->arrays[arr_idx].ptr = NULL;
- if (ctx->vbo) {
- ctx->arrays[arr_idx].vbo = ctx->vbo;
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
+
+YAGL_API void glNormal3x(GLfixed nx,
+ GLfixed ny,
+ GLfixed nz)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT3(glNormal3x, GLfixed, GLfixed, GLfixed, nx, ny, nz);
+
+ YAGL_GET_CTX();
+
+ yagl_host_glNormal3f(yagl_fixed_to_float(nx),
+ yagl_fixed_to_float(ny),
+ yagl_fixed_to_float(nz));
+
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
+
+YAGL_API void glClearColorx(GLclampx red,
+ GLclampx green,
+ GLclampx blue,
+ GLclampx alpha)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT4(glClearColorx, GLclampx, GLclampx, GLclampx, GLclampx, red, green, blue, alpha);
+
+ YAGL_GET_CTX();
+
+ yagl_gles_context_clear_color(&ctx->base,
+ yagl_fixed_to_float(red),
+ yagl_fixed_to_float(green),
+ yagl_fixed_to_float(blue),
+ yagl_fixed_to_float(alpha));
+
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
+
+YAGL_API void glClearDepthx(GLclampx depth)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT1(glClearDepthx, GLclampx, depth);
+
+ YAGL_GET_CTX();
+
+ yagl_gles_context_clear_depthf(&ctx->base, yagl_fixed_to_float(depth));
+
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
+
+YAGL_API void glMultiTexCoord4f(GLenum target,
+ GLfloat s,
+ GLfloat t,
+ GLfloat r,
+ GLfloat q)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT5(glMultiTexCoord4f, GLenum, GLfloat, GLfloat, GLfloat, GLfloat, target, s, t, r, q);
+
+ YAGL_GET_CTX();
+
+ if (target >= GL_TEXTURE0 &&
+ target < (GL_TEXTURE0 + ctx->base.num_texture_units)) {
+ yagl_host_glMultiTexCoord4f(target, s, t, r, q);
+ }
+
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
+
+YAGL_API void glMultiTexCoord4x(GLenum target,
+ GLfixed s,
+ GLfixed t,
+ GLfixed r,
+ GLfixed q)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT5(glMultiTexCoord4x, GLenum, GLfixed, GLfixed, GLfixed, GLfixed, target, s, t, r, q);
+
+ YAGL_GET_CTX();
+
+ if (target >= GL_TEXTURE0 &&
+ target < (GL_TEXTURE0 + ctx->base.num_texture_units)) {
+ yagl_host_glMultiTexCoord4f(target,
+ yagl_fixed_to_float(s),
+ yagl_fixed_to_float(t),
+ yagl_fixed_to_float(r),
+ yagl_fixed_to_float(q));
+ }
+
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
+
+YAGL_API void glPointParameterf(GLenum pname,
+ GLfloat param)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT2(glPointParameterf, GLenum, GLfloat, pname, param);
+
+ YAGL_GET_CTX();
+
+ if (pname != GL_POINT_SIZE_MIN && pname != GL_POINT_SIZE_MIN &&
+ pname != GL_POINT_SIZE_MAX && pname != GL_POINT_FADE_THRESHOLD_SIZE) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ } else {
+ yagl_host_glPointParameterf(pname, param);
+ }
+
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
+
+YAGL_API void glPointParameterx(GLenum pname,
+ GLfixed param)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT2(glPointParameterx, GLenum, GLfixed, pname, param);
+
+ YAGL_GET_CTX();
+
+ if (pname != GL_POINT_SIZE_MIN && pname != GL_POINT_SIZE_MIN &&
+ pname != GL_POINT_SIZE_MAX && pname != GL_POINT_FADE_THRESHOLD_SIZE) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ } else {
+ yagl_host_glPointParameterf(pname, yagl_fixed_to_float(param));
+ }
+
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
+
+YAGL_API void glFogf(GLenum pname, GLfloat param)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT2(glFogf, GLenum, GLfloat, pname, param);
+
+ YAGL_GET_CTX();
+
+ if (pname != GL_FOG_MODE && pname != GL_FOG_DENSITY &&
+ pname != GL_FOG_START && pname != GL_FOG_END) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ } else {
+ yagl_host_glFogf(pname, param);
+ }
+
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
+
+YAGL_API void glFogx(GLenum pname, GLfixed param)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT2(glFogx, GLenum, GLfixed, pname, param);
+
+ YAGL_GET_CTX();
+
+ if (pname != GL_FOG_MODE && pname != GL_FOG_DENSITY &&
+ pname != GL_FOG_START && pname != GL_FOG_END) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ } else {
+ if (pname == GL_FOG_MODE) {
+ yagl_host_glFogf(pname, (GLfloat)param);
} else {
- if (stride) {
- ctx->arrays[arr_idx].stride = stride;
- } else {
- ctx->arrays[arr_idx].stride = size * el_size;
- }
- ctx->arrays[arr_idx].ptr = (GLvoid *)pointer;
+ yagl_host_glFogf(pname, yagl_fixed_to_float(param));
}
}
+
+ YAGL_LOG_FUNC_EXIT(NULL);
}
-static inline unsigned yagl_get_light_param_len(GLenum pname)
+YAGL_API void glFrustumf(GLfloat left,
+ GLfloat right,
+ GLfloat bottom,
+ GLfloat top,
+ GLfloat zNear,
+ GLfloat zFar)
{
- switch (pname) {
- case GL_AMBIENT:
- case GL_DIFFUSE:
- case GL_SPECULAR:
- case GL_POSITION:
- return 4;
- case GL_SPOT_DIRECTION:
- return 3;
- case GL_SPOT_EXPONENT:
- case GL_SPOT_CUTOFF:
- case GL_CONSTANT_ATTENUATION:
- case GL_LINEAR_ATTENUATION:
- case GL_QUADRATIC_ATTENUATION:
- return 1;
- default:
- return 0;
+ YAGL_LOG_FUNC_ENTER_SPLIT6(glFrustumf, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, left, right, bottom, top, zNear, zFar);
+
+ YAGL_GET_CTX();
+
+ if (zNear <= 0 || zFar <= 0 || left == right ||
+ bottom == top || zNear == zFar) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ } else {
+ yagl_host_glFrustumf(left, right, bottom, top, zNear, zFar);
}
+
+ YAGL_LOG_FUNC_EXIT(NULL);
}
-static inline unsigned yagl_get_material_param_len(GLenum pname)
+YAGL_API void glFrustumx(GLfixed left,
+ GLfixed right,
+ GLfixed bottom,
+ GLfixed top,
+ GLfixed zNear,
+ GLfixed zFar)
{
- switch (pname) {
- case GL_AMBIENT:
- case GL_DIFFUSE:
- case GL_SPECULAR:
- case GL_EMISSION:
- case GL_AMBIENT_AND_DIFFUSE:
- return 4;
- case GL_SHININESS:
- return 1;
- default:
- return 0;
+ YAGL_LOG_FUNC_ENTER_SPLIT6(glFrustumx, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, left, right, bottom, top, zNear, zFar);
+
+ YAGL_GET_CTX();
+
+ if (zNear <= 0 || zFar <= 0 ||left == right ||
+ bottom == top || zNear == zFar) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ } else {
+ yagl_host_glFrustumf(yagl_fixed_to_float(left),
+ yagl_fixed_to_float(right),
+ yagl_fixed_to_float(bottom),
+ yagl_fixed_to_float(top),
+ yagl_fixed_to_float(zNear),
+ yagl_fixed_to_float(zFar));
}
+
+ YAGL_LOG_FUNC_EXIT(NULL);
}
-static inline unsigned yagl_get_texenv_param_len(GLenum pname)
+YAGL_API void glLightf(GLenum light,
+ GLenum pname,
+ GLfloat param)
{
- if (pname == GL_TEXTURE_ENV_COLOR) {
- return 4;
+ YAGL_LOG_FUNC_ENTER_SPLIT3(glLightf, GLenum, GLenum, GLfloat, light, pname, param);
+
+ YAGL_GET_CTX();
+
+ if (light < GL_LIGHT0 || light >= (GL_LIGHT0 + ctx->max_lights)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ } else {
+ yagl_host_glLightf(light, pname, param);
}
- return 1;
+ YAGL_LOG_FUNC_EXIT(NULL);
}
-static inline unsigned yagl_get_point_param_len(GLenum pname)
+YAGL_API void glLightx(GLenum light,
+ GLenum pname,
+ GLfixed param)
{
- if (pname == GL_POINT_DISTANCE_ATTENUATION) {
- return 3;
+ YAGL_LOG_FUNC_ENTER_SPLIT3(glLightx, GLenum, GLenum, GLfixed, light, pname, param);
+
+ YAGL_GET_CTX();
+
+ if (light < GL_LIGHT0 || light >= (GL_LIGHT0 + ctx->max_lights)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ } else {
+ yagl_host_glLightf(light, pname, yagl_fixed_to_float(param));
}
- return 1;
+ YAGL_LOG_FUNC_EXIT(NULL);
}
-static inline unsigned yagl_get_fog_param_len(GLenum pname)
+YAGL_API void glLightModelf(GLenum pname, GLfloat param)
{
- if (pname == GL_FOG_COLOR) {
- return 4;
+ YAGL_LOG_FUNC_ENTER_SPLIT2(glLightModelf, GLenum, GLfloat, pname, param);
+
+ YAGL_GET_CTX();
+
+ if (pname != GL_LIGHT_MODEL_TWO_SIDE) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ } else {
+ yagl_host_glLightModelf(pname, param);
}
- return 1;
+ YAGL_LOG_FUNC_EXIT(NULL);
}
-static inline unsigned yagl_get_light_model_param_len(GLenum pname)
+YAGL_API void glLightModelx(GLenum pname,
+ GLfixed param)
{
- if (pname == GL_LIGHT_MODEL_AMBIENT) {
- return 4;
+ YAGL_LOG_FUNC_ENTER_SPLIT2(glLightModelx, GLenum, GLfixed, pname, param);
+
+ YAGL_GET_CTX();
+
+ if (pname != GL_LIGHT_MODEL_TWO_SIDE) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ } else {
+ yagl_host_glLightModelf(pname, (GLfloat)param);
}
- return 1;
+ YAGL_LOG_FUNC_EXIT(NULL);
}
-YAGL_IMPLEMENT_API_NORET2(glAlphaFunc, GLenum, GLclampf, func, ref)
-YAGL_IMPLEMENT_API_NORET2(glAlphaFuncx, GLenum, GLclampx, func, ref)
-YAGL_IMPLEMENT_API_NORET3(glTexEnvi, GLenum, GLenum, GLint, target, pname, param)
-YAGL_IMPLEMENT_API_NORET3(glTexEnvf, GLenum, GLenum, GLfloat, target, pname, param)
-YAGL_IMPLEMENT_API_NORET3(glTexEnvx, GLenum, GLenum, GLfixed, target, pname, param)
-YAGL_IMPLEMENT_API_NORET1(glMatrixMode, GLenum, mode)
-YAGL_IMPLEMENT_API_NORET0(glLoadIdentity)
-YAGL_IMPLEMENT_API_NORET0(glPopMatrix)
-YAGL_IMPLEMENT_API_NORET0(glPushMatrix)
-YAGL_IMPLEMENT_API_NORET4(glRotatef, GLfloat, GLfloat, GLfloat, GLfloat, angle, x, y, z)
-YAGL_IMPLEMENT_API_NORET4(glRotatex, GLfixed, GLfixed, GLfixed, GLfixed, angle, x, y, z)
-YAGL_IMPLEMENT_API_NORET3(glTranslatef, GLfloat, GLfloat, GLfloat, x, y, z)
-YAGL_IMPLEMENT_API_NORET3(glTranslatex, GLfixed, GLfixed, GLfixed, x, y, z)
-YAGL_IMPLEMENT_API_NORET3(glScalef, GLfloat, GLfloat, GLfloat, x, y, z)
-YAGL_IMPLEMENT_API_NORET3(glScalex, GLfixed, GLfixed, GLfixed, x, y, z)
-YAGL_IMPLEMENT_API_NORET6(glOrthof, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, left, right, bottom, top, zNear, zFar)
-YAGL_IMPLEMENT_API_NORET6(glOrthox, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, left, right, bottom, top, zNear, zFar)
-YAGL_IMPLEMENT_API_NORET1(glPointSize, GLfloat, size)
-YAGL_IMPLEMENT_API_NORET1(glPointSizex, GLfixed, size)
-YAGL_IMPLEMENT_API_NORET1(glLineWidthx, GLfixed, width)
-YAGL_IMPLEMENT_API_NORET3(glTexParameterx, GLenum, GLenum, GLfixed, target, pname, param)
-YAGL_IMPLEMENT_API_NORET4(glColor4f, GLfloat, GLfloat, GLfloat, GLfloat, red, green, blue, alpha)
-YAGL_IMPLEMENT_API_NORET4(glColor4ub, GLubyte, GLubyte, GLubyte, GLubyte, red, green, blue, alpha)
-YAGL_IMPLEMENT_API_NORET4(glColor4x, GLfixed, GLfixed, GLfixed, GLfixed, red, green, blue, alpha)
-YAGL_IMPLEMENT_API_NORET3(glNormal3f, GLfloat, GLfloat, GLfloat, nx, ny, nz)
-YAGL_IMPLEMENT_API_NORET3(glNormal3x, GLfixed, GLfixed, GLfixed, nx, ny, nz)
-YAGL_IMPLEMENT_API_NORET4(glClearColorx, GLclampx, GLclampx, GLclampx, GLclampx, red, green, blue, alpha)
-YAGL_IMPLEMENT_API_NORET1(glClearDepthx, GLclampx, depth)
-YAGL_IMPLEMENT_API_NORET5(glMultiTexCoord4f, GLenum, GLfloat, GLfloat, GLfloat, GLfloat, target, s, t, r, q)
-YAGL_IMPLEMENT_API_NORET5(glMultiTexCoord4x, GLenum, GLfixed, GLfixed, GLfixed, GLfixed, target, s, t, r, q)
-YAGL_IMPLEMENT_API_NORET2(glPointParameterf, GLenum, GLfloat, pname, param)
-YAGL_IMPLEMENT_API_NORET2(glPointParameterx, GLenum, GLfixed, pname, param)
-YAGL_IMPLEMENT_API_NORET2(glFogf, GLenum, GLfloat, pname, param)
-YAGL_IMPLEMENT_API_NORET2(glFogx, GLenum, GLfixed, pname, param)
-YAGL_IMPLEMENT_API_NORET6(glFrustumf, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, left, right, bottom, top, zNear, zFar)
-YAGL_IMPLEMENT_API_NORET6(glFrustumx, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, left, right, bottom, top, zNear, zFar)
-YAGL_IMPLEMENT_API_NORET3(glLightf, GLenum, GLenum, GLfloat, light, pname, param)
-YAGL_IMPLEMENT_API_NORET3(glLightx, GLenum, GLenum, GLfixed, light, pname, param)
-YAGL_IMPLEMENT_API_NORET2(glLightModelf, GLenum, GLfloat, pname, param)
-YAGL_IMPLEMENT_API_NORET2(glLightModelx, GLenum, GLfixed, pname, param)
-YAGL_IMPLEMENT_API_NORET3(glMaterialf, GLenum, GLenum, GLfloat, face, pname, param)
-YAGL_IMPLEMENT_API_NORET3(glMaterialx, GLenum, GLenum, GLfixed, face, pname, param)
-YAGL_IMPLEMENT_API_NORET1(glShadeModel, GLenum, mode)
-YAGL_IMPLEMENT_API_NORET2(glSampleCoveragex, GLclampx, GLboolean, value, invert)
-YAGL_IMPLEMENT_API_NORET2(glDepthRangex, GLclampx, GLclampx, zNear, zFar)
-YAGL_IMPLEMENT_API_NORET1(glLogicOp, GLenum, opcode)
-YAGL_IMPLEMENT_API_NORET2(glPolygonOffsetx, GLfixed, GLfixed, factor, units)
+YAGL_API void glMaterialf(GLenum face,
+ GLenum pname,
+ GLfloat param)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT3(glMaterialf, GLenum, GLenum, GLfloat, face, pname, param);
+
+ YAGL_GET_CTX();
+
+ if (face != GL_FRONT_AND_BACK) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ } else {
+ yagl_host_glMaterialf(face, pname, param);
+ }
+
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
+
+YAGL_API void glMaterialx(GLenum face,
+ GLenum pname,
+ GLfixed param)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT3(glMaterialx, GLenum, GLenum, GLfixed, face, pname, param);
+
+ YAGL_GET_CTX();
+
+ if (face != GL_FRONT_AND_BACK) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ } else {
+ yagl_host_glMaterialf(face, pname, yagl_fixed_to_float(param));
+ }
+
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
+
+YAGL_API void glSampleCoveragex(GLclampx value,
+ GLboolean invert)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT2(glSampleCoveragex, GLclampx, GLboolean, value, invert);
+
+ YAGL_GET_CTX();
+
+ yagl_gles_context_sample_coverage(&ctx->base,
+ yagl_fixed_to_float(value),
+ invert);
+
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
+
+YAGL_API void glDepthRangex(GLclampx zNear, GLclampx zFar)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT2(glDepthRangex, GLclampx, GLclampx, zNear, zFar);
+
+ YAGL_GET_CTX();
+
+ yagl_gles_context_depth_rangef(&ctx->base,
+ yagl_fixed_to_float(zNear),
+ yagl_fixed_to_float(zFar));
+
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
+
+YAGL_API void glPolygonOffsetx(GLfixed factor, GLfixed units)
+{
+ YAGL_LOG_FUNC_ENTER_SPLIT2(glPolygonOffsetx, GLfixed, GLfixed, factor, units);
+
+ YAGL_GET_CTX();
+
+ yagl_gles_context_polygon_offset(&ctx->base,
+ yagl_fixed_to_float(factor),
+ yagl_fixed_to_float(units));
+
+ YAGL_LOG_FUNC_EXIT(NULL);
+}
YAGL_API void glTexEnviv(GLenum target, GLenum pname, const GLint *params)
{
- unsigned count = yagl_get_texenv_param_len(pname);
+ int count = 0;
YAGL_LOG_FUNC_ENTER_SPLIT3(glTexEnviv, GLenum, GLenum, const GLint*, target, pname, params);
+ YAGL_GET_CTX();
+
+ if (target != GL_TEXTURE_ENV && target != GL_POINT_SPRITE_OES) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
+ if (!yagl_gles1_get_texenv_param_count(pname, &count)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
yagl_host_glTexEnviv(target, pname, params, count);
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
{
- unsigned count = yagl_get_texenv_param_len(pname);
+ int count = 0;
YAGL_LOG_FUNC_ENTER_SPLIT3(glTexEnvfv, GLenum, GLenum, const GLfloat *, target, pname, params);
+ YAGL_GET_CTX();
+
+ if (target != GL_TEXTURE_ENV && target != GL_POINT_SPRITE_OES) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
+ if (!yagl_gles1_get_texenv_param_count(pname, &count)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
yagl_host_glTexEnvfv(target, pname, params, count);
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glTexEnvxv(GLenum target, GLenum pname, const GLfixed *params)
{
- unsigned count = yagl_get_texenv_param_len(pname);
+ GLfloat paramsf[100]; // This fits all cases.
+ int i, count = 0;
YAGL_LOG_FUNC_ENTER_SPLIT3(glTexEnvxv, GLenum, GLenum, const GLfixed *, target, pname, params);
- yagl_host_glTexEnvxv(target, pname, params, count);
+ YAGL_GET_CTX();
+
+ if (target != GL_TEXTURE_ENV && target != GL_POINT_SPRITE_OES) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+ if (!yagl_gles1_get_texenv_param_count(pname, &count)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
+ if (params) {
+ if ((pname == GL_TEXTURE_ENV_COLOR) ||
+ (pname == GL_RGB_SCALE) ||
+ (pname == GL_ALPHA_SCALE)) {
+ for (i = 0; i < count; ++i) {
+ paramsf[i] = yagl_fixed_to_float(params[i]);
+ }
+ } else {
+ for (i = 0; i < count; ++i) {
+ paramsf[i] = (GLfloat)params[i];
+ }
+ }
+
+ yagl_host_glTexEnvfv(target, pname, paramsf, count);
+ } else {
+ yagl_host_glTexEnvfv(target, pname, NULL, 0);
+ }
+
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
@@ -345,53 +753,86 @@ YAGL_API void glClientActiveTexture(GLenum texture)
{
YAGL_LOG_FUNC_ENTER_SPLIT1(glClientActiveTexture, GLenum, texture);
+ YAGL_GET_CTX();
+
+ if ((texture < GL_TEXTURE0) ||
+ (texture >= (GL_TEXTURE0 + ctx->base.num_texture_units))) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
+ ctx->client_active_texture = texture - GL_TEXTURE0;
+
yagl_host_glClientActiveTexture(texture);
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
-YAGL_API void glDisableClientState(GLenum array)
+YAGL_API void glDisableClientState(GLenum array_name)
{
- struct yagl_gles_context *ctx;
+ unsigned arr_idx;
+ struct yagl_gles_array *array;
- YAGL_LOG_FUNC_ENTER_SPLIT1(glDisableClientState, GLenum, array);
+ YAGL_LOG_FUNC_ENTER_SPLIT1(glDisableClientState, GLenum, array_name);
- ctx = yagl_gles_context_get();
+ YAGL_GET_CTX();
- if (ctx && ctx->arrays) {
- ctx->arrays[yagl_gles1_array_idx_get(ctx, array)].enabled = 0;
+ if (!yagl_gles1_array_idx_get(ctx, array_name, &arr_idx)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
}
- yagl_host_glDisableClientState(array);
+ array = &ctx->base.arrays[arr_idx];
+
+ yagl_gles_array_enable(array, 0);
+
+ if (array_name != GL_POINT_SIZE_ARRAY_OES) {
+ yagl_host_glDisableClientState(array_name);
+ }
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
-YAGL_API void glEnableClientState(GLenum array)
+YAGL_API void glEnableClientState(GLenum array_name)
{
- struct yagl_gles_context *ctx;
+ unsigned arr_idx;
+ struct yagl_gles_array *array;
- YAGL_LOG_FUNC_ENTER_SPLIT1(glEnableClientState, GLenum, array);
+ YAGL_LOG_FUNC_ENTER_SPLIT1(glEnableClientState, GLenum, array_name);
- ctx = yagl_gles_context_get();
+ YAGL_GET_CTX();
- if (ctx && ctx->arrays) {
- ctx->arrays[yagl_gles1_array_idx_get(ctx, array)].enabled = 1;
+ if (!yagl_gles1_array_idx_get(ctx, array_name, &arr_idx)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
}
- yagl_host_glEnableClientState(array);
+ array = &ctx->base.arrays[arr_idx];
+
+ yagl_gles_array_enable(array, 1);
+
+ if (array_name != GL_POINT_SIZE_ARRAY_OES) {
+ yagl_host_glEnableClientState(array_name);
+ }
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API const GLubyte* glGetString(GLenum name)
{
- struct yagl_gles_context *ctx;
+ struct yagl_gles1_context *ctx;
const char *str = NULL;
- YAGL_LOG_FUNC_ENTER(glGetString, "name = %d", name);
+ YAGL_LOG_FUNC_ENTER(glGetString, "name = 0x%X", name);
- ctx = yagl_gles_context_get();
+ ctx = (struct yagl_gles1_context*)yagl_get_client_context();
+
+ if (!ctx || (ctx->base.base.client_api != yagl_client_api_gles1)) {
+ ctx = NULL;
+ }
switch (name) {
case GL_VENDOR:
@@ -405,139 +846,430 @@ YAGL_API const GLubyte* glGetString(GLenum name)
break;
case GL_EXTENSIONS:
if (ctx) {
- if (!ctx->extensions) {
- int32_t size = 0;
- yagl_host_glGetExtensionStringYAGL(NULL, 0, &size);
- ctx->extensions = yagl_malloc0(size);
- yagl_host_glGetExtensionStringYAGL(ctx->extensions, size, NULL);
- }
- str = ctx->extensions;
+ str = yagl_gles_context_get_extensions(&ctx->base);
} else {
str = "";
}
break;
default:
str = "";
- break;
}
- YAGL_LOG_FUNC_EXIT(NULL);
+ YAGL_LOG_FUNC_EXIT("%s", str);
return (const GLubyte*)str;
}
YAGL_API void glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
{
- unsigned count = yagl_get_texenv_param_len(pname);
+ int count = 0;
YAGL_LOG_FUNC_ENTER_SPLIT3(glGetTexEnviv, GLenum, GLenum, GLint *, target, pname, params);
+ YAGL_GET_CTX();
+
+ if (target != GL_TEXTURE_ENV && target != GL_POINT_SPRITE_OES) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
+ if (!yagl_gles1_get_texenv_param_count(pname, &count)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
yagl_host_glGetTexEnviv(target, pname, params, count, NULL);
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
{
- unsigned count = yagl_get_texenv_param_len(pname);
+ int count = 0;
YAGL_LOG_FUNC_ENTER_SPLIT3(glGetTexEnvfv, GLenum, GLenum, GLfloat *, target, pname, params);
+ YAGL_GET_CTX();
+
+ if (target != GL_TEXTURE_ENV && target != GL_POINT_SPRITE_OES) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
+ if (!yagl_gles1_get_texenv_param_count(pname, &count)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
yagl_host_glGetTexEnvfv(target, pname, params, count, NULL);
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glGetTexEnvxv(GLenum target, GLenum pname, GLfixed *params)
{
- unsigned count = yagl_get_texenv_param_len(pname);
+ int i, count = 0;
+ GLfloat paramsf[100]; // This fits all cases.
YAGL_LOG_FUNC_ENTER_SPLIT3(glGetTexEnvxv, GLenum, GLenum, GLint *, target, pname, params);
- yagl_host_glGetTexEnvxv(target, pname, params, count, NULL);
+ YAGL_GET_CTX();
+
+ if (target != GL_TEXTURE_ENV && target != GL_POINT_SPRITE_OES) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
+ if (!yagl_gles1_get_texenv_param_count(pname, &count)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
+ yagl_host_glGetTexEnvfv(target, pname, paramsf, count, NULL);
+ if (params) {
+ if ((pname == GL_TEXTURE_ENV_COLOR) ||
+ (pname == GL_RGB_SCALE) ||
+ (pname == GL_ALPHA_SCALE)) {
+ for (i = 0; i < count; ++i) {
+ params[i] = yagl_float_to_fixed(paramsf[i]);
+ }
+ } else {
+ for (i = 0; i < count; ++i) {
+ params[i] = (GLfixed)paramsf[i];
+ }
+ }
+ }
+
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glGetPointerv(GLenum pname, GLvoid** pointer)
{
+ struct yagl_gles_array *array = NULL;
+
YAGL_LOG_FUNC_ENTER_SPLIT2(glGetPointerv, GLenum, GLvoid**, pname, pointer);
- yagl_host_glGetPointerv(pname, pointer);
+ YAGL_GET_CTX();
+ switch (pname) {
+ case GL_VERTEX_ARRAY_POINTER:
+ array = &ctx->base.arrays[yagl_gles1_array_vertex];
+ break;
+ case GL_COLOR_ARRAY_POINTER:
+ array = &ctx->base.arrays[yagl_gles1_array_color];
+ break;
+ case GL_NORMAL_ARRAY_POINTER:
+ array = &ctx->base.arrays[yagl_gles1_array_normal];
+ break;
+ case GL_TEXTURE_COORD_ARRAY_POINTER:
+ array = &ctx->base.arrays[yagl_gles1_array_texcoord + ctx->client_active_texture];
+ break;
+ case GL_POINT_SIZE_ARRAY_POINTER_OES:
+ array = &ctx->base.arrays[yagl_gles1_array_pointsize];
+ break;
+ default:
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
+ if (pointer) {
+ if (array->vbo) {
+ *pointer = (GLvoid*)array->offset;
+ } else {
+ *pointer = (GLvoid*)array->ptr;
+ }
+ }
+
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glNormalPointer(GLenum type, GLsizei stride, const GLvoid* pointer)
{
+ struct yagl_gles_array *array;
+
YAGL_LOG_FUNC_ENTER_SPLIT3(glNormalPointer, GLenum, GLsizei, const GLvoid*, type, stride, pointer);
- yagl_set_array_pointer(GL_NORMAL_ARRAY, 3, type, stride, pointer);
+ YAGL_GET_CTX();
+
+ if (stride < 0) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ goto out;
+ }
- yagl_host_glNormalPointer(type, stride, pointer);
+ if (type != GL_FLOAT && type != GL_FIXED &&
+ type != GL_SHORT && type != GL_BYTE) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+ array = &ctx->base.arrays[yagl_gles1_array_normal];
+
+ if (ctx->base.vbo) {
+ if (!yagl_gles_array_update_vbo(array,
+ 3,
+ type,
+ type == GL_FIXED,
+ GL_FALSE,
+ stride,
+ ctx->base.vbo,
+ (GLint)pointer)) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ }
+ } else {
+ if (!yagl_gles_array_update(array,
+ 3,
+ type,
+ type == GL_FIXED,
+ GL_FALSE,
+ stride,
+ pointer)) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ }
+ }
+
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
{
+ struct yagl_gles_array *array;
+
YAGL_LOG_FUNC_ENTER_SPLIT4(glVertexPointer, GLint, GLenum, GLsizei, const GLvoid*, size, type, stride, pointer);
- yagl_set_array_pointer(GL_VERTEX_ARRAY, size, type, stride, pointer);
+ YAGL_GET_CTX();
+
+ if ((size < 2) || (size > 4) || (stride < 0)) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ goto out;
+ }
+
+ if (type != GL_FLOAT && type != GL_FIXED &&
+ type != GL_SHORT && type != GL_BYTE) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
- yagl_host_glVertexPointer(size, type, stride, pointer);
+ array = &ctx->base.arrays[yagl_gles1_array_vertex];
+
+ if (ctx->base.vbo) {
+ if (!yagl_gles_array_update_vbo(array,
+ size,
+ type,
+ type == GL_FIXED || type == GL_BYTE,
+ GL_FALSE,
+ stride,
+ ctx->base.vbo,
+ (GLint)pointer)) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ }
+ } else {
+ if (!yagl_gles_array_update(array,
+ size,
+ type,
+ type == GL_FIXED || type == GL_BYTE,
+ GL_FALSE,
+ stride,
+ pointer)) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ }
+ }
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
{
+ struct yagl_gles_array *array;
+
YAGL_LOG_FUNC_ENTER_SPLIT4(glColorPointer, GLint, GLenum, GLsizei, const GLvoid*, size, type, stride, pointer);
- yagl_set_array_pointer(GL_COLOR_ARRAY, size, type, stride, pointer);
+ YAGL_GET_CTX();
+
+ if (size != 4 || stride < 0) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ goto out;
+ }
- yagl_host_glColorPointer(size, type, stride, pointer);
+ if (type != GL_FLOAT && type != GL_FIXED && type != GL_UNSIGNED_BYTE) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+ array = &ctx->base.arrays[yagl_gles1_array_color];
+
+ if (ctx->base.vbo) {
+ if (!yagl_gles_array_update_vbo(array,
+ size,
+ type,
+ type == GL_FIXED,
+ GL_FALSE,
+ stride,
+ ctx->base.vbo,
+ (GLint)pointer)) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ }
+ } else {
+ if (!yagl_gles_array_update(array,
+ size,
+ type,
+ type == GL_FIXED,
+ GL_FALSE,
+ stride,
+ pointer)) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ }
+ }
+
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer)
{
+ struct yagl_gles_array *array;
+
YAGL_LOG_FUNC_ENTER_SPLIT4(glTexCoordPointer, GLint, GLenum, GLsizei, const GLvoid*, size, type, stride, pointer);
- yagl_set_array_pointer(GL_TEXTURE_COORD_ARRAY, size, type, stride, pointer);
+ YAGL_GET_CTX();
+
+ if ((size < 2) || (size > 4) || (stride < 0)) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ goto out;
+ }
+
+ if (type != GL_FLOAT && type != GL_FIXED &&
+ type != GL_SHORT && type != GL_BYTE) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
- yagl_host_glTexCoordPointer(size, type, stride, pointer);
+ array = &ctx->base.arrays[yagl_gles1_array_texcoord + ctx->client_active_texture];
+
+ if (ctx->base.vbo) {
+ if (!yagl_gles_array_update_vbo(array,
+ size,
+ type,
+ type == GL_FIXED || type == GL_BYTE,
+ GL_FALSE,
+ stride,
+ ctx->base.vbo,
+ (GLint)pointer)) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ }
+ } else {
+ if (!yagl_gles_array_update(array,
+ size,
+ type,
+ type == GL_FIXED || type == GL_BYTE,
+ GL_FALSE,
+ stride,
+ pointer)) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ }
+ }
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid* pointer)
{
+ struct yagl_gles_array *array;
+
YAGL_LOG_FUNC_ENTER_SPLIT3(glPointSizePointerOES, GLenum, GLsizei, const GLvoid*, type, stride, pointer);
- yagl_set_array_pointer(GL_POINT_SIZE_ARRAY_OES, 1, type, stride, pointer);
+ YAGL_GET_CTX();
+
+ if (stride < 0) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ goto out;
+ }
+
+ if (type != GL_FLOAT && type != GL_FIXED) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
- yagl_host_glPointSizePointerOES(type, stride, pointer);
+ array = &ctx->base.arrays[yagl_gles1_array_pointsize];
+
+ if (ctx->base.vbo) {
+ if (!yagl_gles_array_update_vbo(array,
+ 1,
+ type,
+ type == GL_FIXED,
+ GL_FALSE,
+ stride,
+ ctx->base.vbo,
+ (GLint)pointer)) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ }
+ } else {
+ if (!yagl_gles_array_update(array,
+ 1,
+ type,
+ type == GL_FIXED,
+ GL_FALSE,
+ stride,
+ pointer)) {
+ YAGL_SET_ERR(GL_INVALID_VALUE);
+ }
+ }
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glTexParameterxv(GLenum target, GLenum pname, const GLfixed *params)
{
+ GLfloat paramf;
+
YAGL_LOG_FUNC_ENTER_SPLIT3(glTexParameterxv, GLenum, GLenum, const GLfixed*, target, pname, params);
- yagl_host_glTexParameterxv(target, pname, params, 1);
+ YAGL_GET_CTX();
+
+ if (target != GL_TEXTURE_2D) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
+ if (params) {
+ paramf = (GLfloat)params[0];
+ yagl_gles_context_tex_parameterfv(&ctx->base, target, pname, &paramf);
+ } else {
+ yagl_gles_context_tex_parameterfv(&ctx->base, target, pname, NULL);
+ }
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params)
{
+ GLfloat paramf;
+
YAGL_LOG_FUNC_ENTER_SPLIT3(glGetTexParameterxv, GLenum, GLenum, GLfixed*, target, pname, params);
- yagl_host_glGetTexParameterxv(target, pname, params);
+ YAGL_GET_CTX();
+
+ if (target != GL_TEXTURE_2D) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
+ yagl_gles_context_get_tex_parameterfv(&ctx->base, target, pname, &paramf);
+ if (params) {
+ *params = (GLfixed)paramf;
+ }
+
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
@@ -550,8 +1282,22 @@ YAGL_API void glMultMatrixf(const GLfloat* m)
YAGL_API void glMultMatrixx(const GLfixed* m)
{
+ GLfloat tmp[16];
+ int i;
+
YAGL_LOG_FUNC_ENTER_SPLIT1(glMultMatrixx, const GLfixed*, m);
- yagl_host_glMultMatrixx(m, 16);
+
+ YAGL_GET_CTX();
+
+ if (m) {
+ for (i = 0; i < 16; ++i) {
+ tmp[i] = yagl_fixed_to_float(m[i]);
+ }
+ yagl_host_glMultMatrixf(tmp, 16);
+ } else {
+ yagl_host_glMultMatrixf(NULL, 16);
+ }
+
YAGL_LOG_FUNC_EXIT(NULL);
}
@@ -564,52 +1310,120 @@ YAGL_API void glLoadMatrixf(const GLfloat* m)
YAGL_API void glLoadMatrixx(const GLfixed* m)
{
+ GLfloat tmp[16];
+ int i;
+
YAGL_LOG_FUNC_ENTER_SPLIT1(glLoadMatrixx, const GLfixed*, m);
- yagl_host_glLoadMatrixx(m, 16);
+
+ YAGL_GET_CTX();
+
+ if (m) {
+ for (i = 0; i < 16; ++i) {
+ tmp[i] = yagl_fixed_to_float(m[i]);
+ }
+ yagl_host_glLoadMatrixf(tmp, 16);
+ } else {
+ yagl_host_glLoadMatrixf(NULL, 16);
+ }
+
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glPointParameterfv(GLenum pname, const GLfloat *params)
{
- unsigned count = yagl_get_point_param_len(pname);
+ int count = 0;
YAGL_LOG_FUNC_ENTER_SPLIT2(glPointParameterfv, GLenum, const GLfloat *, pname, params);
+ YAGL_GET_CTX();
+
+ if (!yagl_gles1_get_point_param_count(pname, &count)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
yagl_host_glPointParameterfv(pname, params, count);
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glPointParameterxv(GLenum pname, const GLfixed *params)
{
- unsigned count = yagl_get_point_param_len(pname);
+ GLfloat paramsf[100]; // This fits all cases.
+ int i, count = 0;
YAGL_LOG_FUNC_ENTER_SPLIT2(glPointParameterxv, GLenum, const GLfixed *, pname, params);
- yagl_host_glPointParameterxv(pname, params, count);
+ YAGL_GET_CTX();
+
+ if (!yagl_gles1_get_point_param_count(pname, &count)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
+ if (params) {
+ for (i = 0; i < count; ++i) {
+ paramsf[i] = yagl_fixed_to_float(params[i]);
+ }
+ yagl_host_glPointParameterfv(pname, paramsf, count);
+ } else {
+ yagl_host_glPointParameterfv(pname, NULL, count);
+ }
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glFogfv(GLenum pname, const GLfloat *params)
{
- unsigned count = yagl_get_fog_param_len(pname);
+ int count = 0;
YAGL_LOG_FUNC_ENTER_SPLIT2(glFogfv, GLenum, const GLfloat *, pname, params);
+ YAGL_GET_CTX();
+
+ if (!yagl_gles1_get_fog_param_count(pname, &count)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
yagl_host_glFogfv(pname, params, count);
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glFogxv(GLenum pname, const GLfixed *params)
{
- unsigned count = yagl_get_fog_param_len(pname);
+ GLfloat paramsf[100]; // This fits all cases.
+ int i, count = 0;
YAGL_LOG_FUNC_ENTER_SPLIT2(glFogxv, GLenum, const GLfixed *, pname, params);
- yagl_host_glFogxv(pname, params, count);
+ YAGL_GET_CTX();
+
+ if (!yagl_gles1_get_fog_param_count(pname, &count)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+ if (params) {
+ if (pname == GL_FOG_MODE) {
+ for (i = 0; i < count; ++i) {
+ paramsf[i] = (GLfloat)params[i];
+ }
+ } else {
+ for (i = 0; i < count; ++i) {
+ paramsf[i] = yagl_fixed_to_float(params[i]);
+ }
+ }
+ yagl_host_glFogfv(pname, paramsf, count);
+ } else {
+ yagl_host_glFogfv(pname, NULL, count);
+ }
+
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
@@ -617,17 +1431,43 @@ YAGL_API void glClipPlanef(GLenum plane, const GLfloat *equation)
{
YAGL_LOG_FUNC_ENTER_SPLIT2(glClipPlanef, GLenum, const GLfloat *, plane, equation);
+ YAGL_GET_CTX();
+
+ if (plane < GL_CLIP_PLANE0 || plane >= (GL_CLIP_PLANE0 + ctx->max_clip_planes)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
yagl_host_glClipPlanef(plane, equation, 4);
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glClipPlanex(GLenum plane, const GLfixed *equation)
{
+ GLfloat equationf[4];
+ int i;
+
YAGL_LOG_FUNC_ENTER_SPLIT2(glClipPlanex, GLenum, const GLfixed *, plane, equation);
- yagl_host_glClipPlanex(plane, equation, 4);
+ YAGL_GET_CTX();
+ if (plane < GL_CLIP_PLANE0 || plane >= (GL_CLIP_PLANE0 + ctx->max_clip_planes)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
+ if (equation) {
+ for (i = 0; i < 4; ++i) {
+ equationf[i] = yagl_fixed_to_float(equation[i]);
+ }
+ yagl_host_glClipPlanef(plane, equationf, 4);
+ } else {
+ yagl_host_glClipPlanef(plane, NULL, 4);
+ }
+
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
@@ -635,156 +1475,313 @@ YAGL_API void glGetClipPlanef(GLenum pname, GLfloat *eqn)
{
YAGL_LOG_FUNC_ENTER_SPLIT2(glGetClipPlanef, GLenum, GLfloat*, pname, eqn);
+ YAGL_GET_CTX();
+
+ if (pname < GL_CLIP_PLANE0 || pname >= (GL_CLIP_PLANE0 + ctx->max_clip_planes)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
yagl_host_glGetClipPlanef(pname, eqn, 4, NULL);
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glGetClipPlanex(GLenum pname, GLfixed *eqn)
{
+ GLfloat equationf[4];
+ int i;
+
YAGL_LOG_FUNC_ENTER_SPLIT2(glGetClipPlanex, GLenum, GLfixed*, pname, eqn);
- yagl_host_glGetClipPlanex(pname, eqn, 4, NULL);
+ YAGL_GET_CTX();
+
+ if (pname < GL_CLIP_PLANE0 ||
+ pname >= (GL_CLIP_PLANE0 + ctx->max_clip_planes)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
+ yagl_host_glGetClipPlanef(pname, equationf, 4, NULL);
+
+ if (eqn) {
+ for (i = 0; i < 4; ++i) {
+ eqn[i] = yagl_float_to_fixed(equationf[i]);
+ }
+ }
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glLightfv(GLenum light, GLenum pname, const GLfloat *params)
{
- unsigned count;
+ int count = 0;
YAGL_LOG_FUNC_ENTER_SPLIT3(glLightfv, GLenum, GLenum, const GLfloat *, light, pname, params);
- count = yagl_get_light_param_len(pname);
+ YAGL_GET_CTX();
+
+ if (light < GL_LIGHT0 || light >= (GL_LIGHT0 + ctx->max_lights) ||
+ !yagl_gles1_get_light_param_count(pname, &count)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
yagl_host_glLightfv(light, pname, params, count);
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glLightxv(GLenum light, GLenum pname, const GLfixed *params)
{
- unsigned count;
+ GLfloat paramsf[100]; // This fits all cases.
+ int i, count = 0;
YAGL_LOG_FUNC_ENTER_SPLIT3(glLightxv, GLenum, GLenum, const GLfixed *, light, pname, params);
- count = yagl_get_light_param_len(pname);
+ YAGL_GET_CTX();
+
+ if (light < GL_LIGHT0 || light >= (GL_LIGHT0 + ctx->max_lights) ||
+ !yagl_gles1_get_light_param_count(pname, &count)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
- yagl_host_glLightxv(light, pname, params, count);
+ if (params) {
+ for (i = 0; i < count; ++i) {
+ paramsf[i] = yagl_fixed_to_float(params[i]);
+ }
+ yagl_host_glLightfv(light, pname, paramsf, count);
+ } else {
+ yagl_host_glLightfv(light, pname, NULL, count);
+ }
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glLightModelfv(GLenum pname, const GLfloat *params)
{
- unsigned count = yagl_get_light_model_param_len(pname);
+ int count = 0;
YAGL_LOG_FUNC_ENTER_SPLIT2(glLightModelfv, GLenum, const GLfloat *, pname, params);
+ YAGL_GET_CTX();
+
+ if (!yagl_gles1_get_light_model_param_count(pname, &count)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
yagl_host_glLightModelfv(pname, params, count);
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glLightModelxv(GLenum pname, const GLfixed *params)
{
- unsigned count = yagl_get_light_model_param_len(pname);
+ GLfloat paramsf[100]; // This fits all cases.
+ int i, count = 0;
YAGL_LOG_FUNC_ENTER_SPLIT2(glLightModelxv, GLenum, const GLfixed *, pname, params);
- yagl_host_glLightModelxv(pname, params, count);
+ YAGL_GET_CTX();
+ if (!yagl_gles1_get_light_model_param_count(pname, &count)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
+ if (params) {
+ if (pname == GL_LIGHT_MODEL_TWO_SIDE) {
+ for (i = 0; i < count; ++i) {
+ paramsf[i] = (GLfloat)(params[i]);
+ }
+ } else {
+ for (i = 0; i < count; ++i) {
+ paramsf[i] = yagl_fixed_to_float(params[i]);
+ }
+ }
+ yagl_host_glLightModelfv(pname, paramsf, count);
+ } else {
+ yagl_host_glLightModelfv(pname, NULL, count);
+ }
+
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
{
- unsigned count;
+ int count = 0;
YAGL_LOG_FUNC_ENTER_SPLIT3(glGetLightfv, GLenum, GLenum, GLfloat*, light, pname, params);
- count = yagl_get_light_param_len(pname);
+ YAGL_GET_CTX();
+
+ if (light < GL_LIGHT0 || light >= (GL_LIGHT0 + ctx->max_lights) ||
+ !yagl_gles1_get_light_param_count(pname, &count)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
yagl_host_glGetLightfv(light, pname, params, count, NULL);
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glGetLightxv(GLenum light, GLenum pname, GLfixed *params)
{
- unsigned count;
+ GLfloat paramsf[100]; // This fits all cases.
+ int i, count = 0;
YAGL_LOG_FUNC_ENTER_SPLIT3(glGetLightxv, GLenum, GLenum, GLfixed*, light, pname, params);
- count = yagl_get_light_param_len(pname);
+ YAGL_GET_CTX();
- yagl_host_glGetLightxv(light, pname, params, count, NULL);
+ if (light < GL_LIGHT0 || light >= (GL_LIGHT0 + ctx->max_lights) ||
+ !yagl_gles1_get_light_param_count(pname, &count)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
+ yagl_host_glGetLightfv(light, pname, paramsf, count, NULL);
+ if (params) {
+ for (i = 0; i < count; ++i) {
+ params[i] = yagl_float_to_fixed(paramsf[i]);
+ }
+ }
+
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
{
- unsigned count;
+ int count = 0;
YAGL_LOG_FUNC_ENTER_SPLIT3(glMaterialfv, GLenum, GLenum, const GLfloat *, face, pname, params);
- count = yagl_get_material_param_len(pname);
+ YAGL_GET_CTX();
+
+ if (face != GL_FRONT_AND_BACK ||
+ !yagl_gles1_get_material_param_count(pname, &count)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
yagl_host_glMaterialfv(face, pname, params, count);
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glMaterialxv(GLenum face, GLenum pname, const GLfixed *params)
{
- unsigned count;
+ GLfloat paramsf[100]; // This fits all cases.
+ int i, count = 0;
YAGL_LOG_FUNC_ENTER_SPLIT3(glMaterialxv, GLenum, GLenum, const GLfixed *, face, pname, params);
- count = yagl_get_material_param_len(pname);
+ YAGL_GET_CTX();
- yagl_host_glMaterialxv(face, pname, params, count);
+ if (face != GL_FRONT_AND_BACK ||
+ !yagl_gles1_get_material_param_count(pname, &count)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
+
+ if (params) {
+ for (i = 0; i < count; ++i) {
+ paramsf[i] = yagl_fixed_to_float(params[i]);
+ }
+ yagl_host_glMaterialfv(face, pname, paramsf, count);
+ } else {
+ yagl_host_glMaterialfv(face, pname, NULL, count);
+ }
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
{
- unsigned count;
+ int count = 0;
YAGL_LOG_FUNC_ENTER_SPLIT3(glGetMaterialfv, GLenum, GLenum, GLfloat*, face, pname, params);
- count = yagl_get_material_param_len(pname);
+ YAGL_GET_CTX();
+
+ if (!yagl_gles1_get_material_param_count(pname, &count)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
yagl_host_glGetMaterialfv(face, pname, params, count, NULL);
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glGetMaterialxv(GLenum light, GLenum pname, GLfixed *params)
{
- unsigned count;
+ GLfloat paramsf[100]; // This fits all cases.
+ int i, count = 0;
YAGL_LOG_FUNC_ENTER_SPLIT3(glGetMaterialxv, GLenum, GLenum, GLfixed*, light, pname, params);
- count = yagl_get_material_param_len(pname);
+ YAGL_GET_CTX();
+
+ if (!yagl_gles1_get_material_param_count(pname, &count)) {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ goto out;
+ }
- yagl_host_glGetMaterialxv(light, pname, params, count, NULL);
+ yagl_host_glGetMaterialfv(light, pname, paramsf, count, NULL);
+ if (params) {
+ for (i = 0; i < count; ++i) {
+ params[i] = yagl_float_to_fixed(paramsf[i]);
+ }
+ }
+
+out:
YAGL_LOG_FUNC_EXIT(NULL);
}
YAGL_API void glGetFixedv(GLenum pname, GLfixed* params)
{
- GLfixed tmp[100]; // This fits all cases.
- int32_t num = 0;
+ GLfloat floats[100]; // This fits all cases.
+ uint32_t i, num = 0;
+ int needs_map;
YAGL_LOG_FUNC_ENTER_SPLIT2(glGetFixedv, GLenum, GLfixed*, pname, params);
- yagl_host_glGetFixedv(pname, tmp, sizeof(tmp)/sizeof(tmp[0]), &num);
+
+ YAGL_GET_CTX();
+
+ if (!yagl_gles_context_get_floatv(&ctx->base, pname, floats, &num, &needs_map)) {
+ GLint ints[100]; // This fits all cases.
+ if (yagl_gles_context_get_integerv(&ctx->base, pname, ints, &num)) {
+ for (i = 0; i < num; ++i) {
+ floats[i] = ints[i];
+ }
+ } else {
+ YAGL_SET_ERR(GL_INVALID_ENUM);
+ }
+ }
+
if (params) {
- memcpy(params, tmp, num * sizeof(tmp[0]));
+ for (i = 0; i < num; ++i) {
+ params[i] = yagl_float_to_fixed(floats[i]);
+ }
}
+
YAGL_LOG_FUNC_EXIT(NULL);
}
@@ -792,139 +1789,96 @@ YAGL_API void glGetFixedv(GLenum pname, GLfixed* params)
YAGL_API GLboolean glIsRenderbufferOES(GLuint renderbuffer)
{
- GLboolean tmp;
-
- YAGL_LOG_FUNC_ENTER_SPLIT1(glIsRenderbufferOES, GLuint, renderbuffer);
- tmp = yagl_host_glIsRenderbuffer(renderbuffer);
- YAGL_LOG_FUNC_EXIT_SPLIT(GLboolean, tmp);
-
- return tmp;
+ return glIsRenderbuffer(renderbuffer);
}
YAGL_API void glBindRenderbufferOES(GLenum target, GLuint renderbuffer)
{
- YAGL_LOG_FUNC_ENTER_SPLIT2(glBindRenderbufferOES, GLenum, GLuint, target, renderbuffer);
- yagl_host_glBindRenderbuffer(target, renderbuffer);
- YAGL_LOG_FUNC_EXIT(NULL);
+ glBindRenderbuffer(target, renderbuffer);
}
YAGL_API void glDeleteRenderbuffersOES(GLsizei n, const GLuint* renderbuffers)
{
- YAGL_LOG_FUNC_ENTER_SPLIT2(glDeleteRenderbuffersOES, GLsizei, const GLuint*, n, renderbuffers);
- yagl_host_glDeleteRenderbuffers(renderbuffers, n);
- YAGL_LOG_FUNC_EXIT(NULL);
+ glDeleteRenderbuffers(n, renderbuffers);
}
YAGL_API void glGenRenderbuffersOES(GLsizei n, GLuint* renderbuffers)
{
- YAGL_LOG_FUNC_ENTER_SPLIT2(glGenRenderbuffersOES, GLsizei, GLuint*, n, renderbuffers);
- yagl_host_glGenRenderbuffers(renderbuffers, n, NULL);
- YAGL_LOG_FUNC_EXIT(NULL);
+ glGenRenderbuffers(n, renderbuffers);
}
YAGL_API void glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
{
- YAGL_LOG_FUNC_ENTER_SPLIT4(glRenderbufferStorageOES, GLenum, GLenum, GLsizei, GLsizei, target, internalformat, width, height);
- yagl_host_glRenderbufferStorage(target, internalformat, width, height);
- YAGL_LOG_FUNC_EXIT(NULL);
+ glRenderbufferStorage(target, internalformat, width, height);
}
YAGL_API void glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint* params)
{
- YAGL_LOG_FUNC_ENTER_SPLIT3(glGetRenderbufferParameterivOES, GLenum, GLenum, GLint*, target, pname, params);
- yagl_host_glGetRenderbufferParameteriv(target, pname, params);
- YAGL_LOG_FUNC_EXIT(NULL);
+ glGetRenderbufferParameteriv(target, pname, params);
}
YAGL_API GLboolean glIsFramebufferOES(GLuint framebuffer)
{
- GLboolean tmp;
-
- YAGL_LOG_FUNC_ENTER_SPLIT1(glIsFramebufferOES, GLuint, framebuffer);
- tmp = yagl_host_glIsFramebuffer(framebuffer);
- YAGL_LOG_FUNC_EXIT_SPLIT(GLboolean, tmp);
-
- return tmp;
+ return glIsFramebuffer(framebuffer);
}
YAGL_API void glBindFramebufferOES(GLenum target, GLuint framebuffer)
{
- YAGL_LOG_FUNC_ENTER_SPLIT2(glBindFramebufferOES, GLenum, GLuint, target, framebuffer);
- yagl_host_glBindFramebuffer(target, framebuffer);
- YAGL_LOG_FUNC_EXIT(NULL);
+ glBindFramebuffer(target, framebuffer);
}
YAGL_API void glDeleteFramebuffersOES(GLsizei n, const GLuint* framebuffers)
{
- YAGL_LOG_FUNC_ENTER_SPLIT2(glDeleteFramebuffersOES, GLsizei, const GLuint*, n, framebuffers);
- yagl_host_glDeleteFramebuffers(framebuffers, n);
- YAGL_LOG_FUNC_EXIT(NULL);
+ glDeleteFramebuffers(n, framebuffers);
}
YAGL_API void glGenFramebuffersOES(GLsizei n, GLuint* framebuffers)
{
- YAGL_LOG_FUNC_ENTER_SPLIT2(glGenFramebuffersOES, GLsizei, GLuint*, n, framebuffers);
- yagl_host_glGenFramebuffers(framebuffers, n, NULL);
- YAGL_LOG_FUNC_EXIT(NULL);
+ glGenFramebuffers(n, framebuffers);
}
YAGL_API GLenum glCheckFramebufferStatusOES(GLenum target)
{
- GLenum tmp;
- YAGL_LOG_FUNC_ENTER_SPLIT1(glCheckFramebufferStatusOES, GLenum, target);
- tmp = yagl_host_glCheckFramebufferStatus(target);
- YAGL_LOG_FUNC_EXIT_SPLIT(GLenum, tmp);
- return tmp;
+ return glCheckFramebufferStatus(target);
}
YAGL_API void glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
- YAGL_LOG_FUNC_ENTER_SPLIT5(glFramebufferTexture2DOES, GLenum, GLenum, GLenum, GLuint, GLint, target, attachment, textarget, texture, level);
- yagl_host_glFramebufferTexture2D(target, attachment, textarget, texture, level);
- YAGL_LOG_FUNC_EXIT(NULL);
+ glFramebufferTexture2D(target, attachment, textarget, texture, level);
}
YAGL_API void glFramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
- YAGL_LOG_FUNC_ENTER_SPLIT4(glFramebufferRenderbufferOES, GLenum, GLenum, GLenum, GLuint, target, attachment, renderbuffertarget, renderbuffer);
- yagl_host_glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
- YAGL_LOG_FUNC_EXIT(NULL);
+ glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}
YAGL_API void glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint* params)
{
- YAGL_LOG_FUNC_ENTER_SPLIT4(glGetFramebufferAttachmentParameterivOES, GLenum, GLenum, GLenum, GLint*, target, attachment, pname, params);
- yagl_host_glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
- YAGL_LOG_FUNC_EXIT(NULL);
+ glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
}
YAGL_API void glGenerateMipmapOES(GLenum target)
{
- YAGL_LOG_FUNC_ENTER_SPLIT1(glGenerateMipmapOES, GLenum, target);
- yagl_host_glGenerateMipmap(target);
- YAGL_LOG_FUNC_EXIT(NULL);
+ glGenerateMipmap(target);
}
/* GL_OES_blend_subtract */
+
YAGL_API void glBlendEquationOES(GLenum mode)
{
- YAGL_LOG_FUNC_ENTER_SPLIT1(glBlendEquationOES, GLenum, mode);
- yagl_host_glBlendEquation(mode);
- YAGL_LOG_FUNC_EXIT(NULL);
+ glBlendEquation(mode);
}
/* GL_OES_blend_equation_separate */
+
YAGL_API void glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha)
{
- YAGL_LOG_FUNC_ENTER_SPLIT2(glBlendEquationSeparateOES, GLenum, GLenum, modeRGB, modeAlpha);
- yagl_host_glBlendEquationSeparate(modeRGB, modeAlpha);
- YAGL_LOG_FUNC_EXIT(NULL);
+ glBlendEquationSeparate(modeRGB, modeAlpha);
}
/* GL_OES_blend_func_separate */
+
YAGL_API void glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
{
- YAGL_LOG_FUNC_ENTER_SPLIT4(glBlendFuncSeparateOES, GLenum, GLenum, GLenum, GLenum, srcRGB, dstRGB, srcAlpha, dstAlpha);
- yagl_host_glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
- YAGL_LOG_FUNC_EXIT(NULL);
+ glBlendFuncSeparate(srcRGB, dstRGB, srcAlpha, dstAlpha);
}
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-04 22:55:49 +0000