From 963e01aa1fc7f5747bb6a53861d89bc0c04ca634 Mon Sep 17 00:00:00 2001 From: Igor Mitsyanko Date: Wed, 28 Nov 2012 13:31:36 +0400 Subject: Implement GLES1 API Change-Id: I9dfeedf7bb2462901377e85f676e9a816674b420 Signed-off-by: Igor Mitsyanko --- GLESv1_CM/yagl_gles1_calls.c | 763 ++++++++++++++++++++++++++++++++++++++----- 1 file changed, 674 insertions(+), 89 deletions(-) (limited to 'GLESv1_CM/yagl_gles1_calls.c') diff --git a/GLESv1_CM/yagl_gles1_calls.c b/GLESv1_CM/yagl_gles1_calls.c index 4991cf6..8c2192f 100644 --- a/GLESv1_CM/yagl_gles1_calls.c +++ b/GLESv1_CM/yagl_gles1_calls.c @@ -2,6 +2,8 @@ #include "yagl_host_gles1_calls.h" #include "yagl_impl.h" #include "yagl_mem.h" +#include "yagl_batch_gl.h" +#include "yagl_mem_gl.h" #include "yagl_gles_context.h" #include "yagl_malloc.h" #include @@ -11,8 +13,10 @@ #include #include "yagl_gles_utils.h" -/* GLES1 has arrays of vertices, normals, colors, texture coordinates and - * point sizes. Every texture unit has its own texture coordinates array */ +/* + * 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, @@ -21,8 +25,48 @@ typedef enum { YAGL_GLES1_ARRAY_TEX_COORD, } YaglGles1ArrayType; -static inline void yagl_query_array(struct yagl_gles_array *arr, - YaglGles1ArrayType arr_type) +static inline int yagl_get_active_tex_index(void) +{ + return YAGL_GLES1_ARRAY_TEX_COORD + + yagl_get_integer(GL_CLIENT_ACTIVE_TEXTURE) - GL_TEXTURE0; +} + +static unsigned yagl_gles1_array_idx_get(struct yagl_gles_context *ctx, + GLenum array) +{ + unsigned ret; + + switch (array) { + case GL_VERTEX_ARRAY: + ret = YAGL_GLES1_ARRAY_VERTEX; + break; + case GL_COLOR_ARRAY: + ret = YAGL_GLES1_ARRAY_COLOR; + break; + case GL_NORMAL_ARRAY: + ret = YAGL_GLES1_ARRAY_NORMAL; + break; + case GL_TEXTURE_COORD_ARRAY: + ret = yagl_get_active_tex_index(); + break; + case GL_POINT_SIZE_ARRAY_OES: + ret = YAGL_GLES1_ARRAY_POINTSIZE; + break; + default: + ret = -1; + break; + } + + if (ret >= ctx->num_arrays) { + fprintf(stderr, "Error! Array with index %d doesn't exist at %s:%d\n", + ret, __func__, __LINE__); + } + + return ret; +} + +static void yagl_query_gles1_array(struct yagl_gles_array *arr, + YaglGles1ArrayType arr_type) { GLenum name, buff_bind, stride, pointer; @@ -52,12 +96,15 @@ static inline void yagl_query_array(struct yagl_gles_array *arr, pointer = GL_POINT_SIZE_ARRAY_POINTER_OES; break; case YAGL_GLES1_ARRAY_TEX_COORD: - /* The rest are texture arrays */ 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); } arr->enabled = yagl_get_integer(name); @@ -82,7 +129,7 @@ static inline void yagl_set_client_active_texture(GLenum tex) } static void yagl_query_texture_arrays(struct yagl_gles_array *arrays, - int num_texture_units) + int num_texture_units) { GLint cur_text; int i; @@ -91,7 +138,7 @@ static void yagl_query_texture_arrays(struct yagl_gles_array *arrays, for (i = 0; i < num_texture_units; ++i) { yagl_set_client_active_texture(GL_TEXTURE0 + i); - yagl_query_array(&arrays[i], YAGL_GLES1_ARRAY_TEX_COORD); + yagl_query_gles1_array(&arrays[i], YAGL_GLES1_ARRAY_TEX_COORD); } yagl_set_client_active_texture(cur_text); @@ -114,69 +161,249 @@ void yagl_update_arrays(void) ctx->arrays = yagl_malloc0(sizeof(*ctx->arrays) * ctx->num_arrays); for (i = YAGL_GLES1_ARRAY_VERTEX; i < YAGL_GLES1_ARRAY_TEX_COORD; ++i) { - yagl_query_array(&ctx->arrays[i], i); + yagl_query_gles1_array(&ctx->arrays[i], i); } yagl_query_texture_arrays(&ctx->arrays[YAGL_GLES1_ARRAY_TEX_COORD], num_texture_units); } +static void yagl_set_array_pointer(GLenum array_type, + GLint size, + GLenum type, + GLsizei stride, + const GLvoid* pointer) +{ + struct yagl_gles_context *ctx = yagl_gles_context_get(); + int el_size = 0; + unsigned arr_idx; + + 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; + } 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; + } + } +} + +static inline unsigned yagl_get_light_param_len(GLenum pname) +{ + 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; + } +} + +static inline unsigned yagl_get_material_param_len(GLenum pname) +{ + 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; + } +} + +static inline unsigned yagl_get_texenv_param_len(GLenum pname) +{ + if (pname == GL_TEXTURE_ENV_COLOR) { + return 4; + } + + return 1; +} + +static inline unsigned yagl_get_point_param_len(GLenum pname) +{ + if (pname == GL_POINT_DISTANCE_ATTENUATION) { + return 3; + } + + return 1; +} + +static inline unsigned yagl_get_fog_param_len(GLenum pname) +{ + if (pname == GL_FOG_COLOR) { + return 4; + } + + return 1; +} + +static inline unsigned yagl_get_light_model_param_len(GLenum pname) +{ + if (pname == GL_LIGHT_MODEL_AMBIENT) { + return 4; + } + + return 1; +} + YAGL_IMPLEMENT_API_NORET2(glAlphaFunc, GLenum, GLclampf, func, ref) -YAGL_IMPLEMENT_API_NORET2(glClipPlanef, GLenum, const GLfloat*, plane, equation) -YAGL_IMPLEMENT_API_NORET4(glColor4f, GLfloat, GLfloat, GLfloat, GLfloat, red, green, blue, alpha) -YAGL_IMPLEMENT_API_NORET2(glFogf, GLenum, GLfloat, pname, param) -YAGL_IMPLEMENT_API_NORET2(glFogfv, GLenum, const GLfloat*, pname, params) -YAGL_IMPLEMENT_API_NORET6(glFrustumf, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, left, right, bottom, top, zNear, zFar) -YAGL_IMPLEMENT_API_NORET2(glGetClipPlanef, GLenum, GLfloat*, pname, eqn) -YAGL_IMPLEMENT_API_NORET3(glGetLightfv, GLenum, GLenum, GLfloat*, light, pname, params) -YAGL_IMPLEMENT_API_NORET3(glGetMaterialfv, GLenum, GLenum, GLfloat*, face, pname, params) -YAGL_IMPLEMENT_API_NORET3(glGetTexEnvfv, GLenum, GLenum, GLfloat*, env, pname, params) -YAGL_IMPLEMENT_API_NORET2(glLightModelf, GLenum, GLfloat, pname, param) -YAGL_IMPLEMENT_API_NORET2(glLightModelfv, GLenum, const GLfloat*, pname, params) -YAGL_IMPLEMENT_API_NORET3(glLightf, GLenum, GLenum, GLfloat, light, pname, param) -YAGL_IMPLEMENT_API_NORET3(glLightfv, GLenum, GLenum, const GLfloat*, light, pname, params) -YAGL_IMPLEMENT_API_NORET1(glLoadMatrixf, const GLfloat*, m) -YAGL_IMPLEMENT_API_NORET3(glMaterialf, GLenum, GLenum, GLfloat, face, pname, param) -YAGL_IMPLEMENT_API_NORET3(glMaterialfv, GLenum, GLenum, const GLfloat*, face, pname, params) -YAGL_IMPLEMENT_API_NORET1(glMultMatrixf, const GLfloat*, m) -YAGL_IMPLEMENT_API_NORET5(glMultiTexCoord4f, GLenum, GLfloat, GLfloat, GLfloat, GLfloat, target, s, t, r, q) -YAGL_IMPLEMENT_API_NORET3(glNormal3f, GLfloat, GLfloat, GLfloat, nx, ny, nz) -YAGL_IMPLEMENT_API_NORET6(glOrthof, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, left, right, bottom, top, zNear, zFar) -YAGL_IMPLEMENT_API_NORET2(glPointParameterf, GLenum, GLfloat, pname, param) -YAGL_IMPLEMENT_API_NORET2(glPointParameterfv, GLenum, const GLfloat*, pname, params) -YAGL_IMPLEMENT_API_NORET1(glPointSize, GLfloat, size) -YAGL_IMPLEMENT_API_NORET3(glPointSizePointerOES, GLenum, GLsizei, const GLvoid*, type, stride, pointer) -YAGL_IMPLEMENT_API_NORET4(glRotatef, GLfloat, GLfloat, GLfloat, GLfloat, angle, x, y, z) -YAGL_IMPLEMENT_API_NORET3(glScalef, GLfloat, GLfloat, GLfloat, x, y, z) +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(glTexEnvfv, GLenum, GLenum, const GLfloat*, target, pname, params) +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_NORET2(glAlphaFuncx, GLenum, GLclampx, func, ref) -YAGL_IMPLEMENT_API_NORET4(glClearColorx, GLclampx, GLclampx, GLclampx, GLclampx, red, green, blue, alpha) -YAGL_IMPLEMENT_API_NORET1(glClearDepthx, GLclampx, depth) -YAGL_IMPLEMENT_API_NORET1(glClientActiveTexture, GLenum, texture) -YAGL_IMPLEMENT_API_NORET2(glClipPlanex, GLenum, const GLfixed*, plane, equation) +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_NORET4(glColorPointer, GLint, GLenum, GLsizei, const GLvoid*, size, type, stride, pointer) -YAGL_IMPLEMENT_API_NORET2(glDepthRangex, GLclampx, GLclampx, zNear, zFar) -YAGL_IMPLEMENT_API_NORET1(glDisableClientState, GLenum, array) -YAGL_IMPLEMENT_API_NORET1(glEnableClientState, GLenum, array) +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_NORET2(glFogxv, GLenum, const GLfixed*, pname, params) +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_NORET2(glGetClipPlanex, GLenum, GLfixed*, pname, eqn) -YAGL_IMPLEMENT_API_NORET2(glGetFixedv, GLenum, GLfixed*, pname, params) -YAGL_IMPLEMENT_API_NORET3(glGetLightxv, GLenum, GLenum, GLfixed*, light, pname, params) -YAGL_IMPLEMENT_API_NORET3(glGetMaterialxv, GLenum, GLenum, GLfixed*, face, pname, params) -YAGL_IMPLEMENT_API_NORET2(glGetPointerv, GLenum, GLvoid**, pname, params) +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 glTexEnviv(GLenum target, GLenum pname, const GLint *params) +{ + unsigned count = yagl_get_texenv_param_len(pname); + + YAGL_LOG_FUNC_ENTER_SPLIT3(glTexEnviv, GLenum, GLenum, const GLint*, target, pname, params); + + while (!yagl_host_glTexEnviv(target, pname, yagl_batch_put_GLints(params, count))) {} + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) +{ + unsigned count = yagl_get_texenv_param_len(pname); + + YAGL_LOG_FUNC_ENTER_SPLIT3(glTexEnvfv, GLenum, GLenum, const GLfloat *, target, pname, params); + + while (!yagl_host_glTexEnvfv(target, pname, yagl_batch_put_GLfloats(params, count))) {} + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glTexEnvxv(GLenum target, GLenum pname, const GLfixed *params) +{ + unsigned count = yagl_get_texenv_param_len(pname); + + YAGL_LOG_FUNC_ENTER_SPLIT3(glTexEnvxv, GLenum, GLenum, const GLfixed *, target, pname, params); + + while (!yagl_host_glTexEnvxv(target, pname, yagl_batch_put_GLfixeds(params, count))) {} + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glClientActiveTexture(GLenum texture) +{ + YAGL_LOG_FUNC_ENTER_SPLIT1(glClientActiveTexture, GLenum, texture); + + YAGL_HOST_CALL_ASSERT(yagl_host_glClientActiveTexture(texture)); + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glDisableClientState(GLenum array) +{ + struct yagl_gles_context *ctx; + + YAGL_LOG_FUNC_ENTER_SPLIT1(glDisableClientState, GLenum, array); + + ctx = yagl_gles_context_get(); + + if (ctx && ctx->arrays) { + ctx->arrays[yagl_gles1_array_idx_get(ctx, array)].enabled = 0; + } + + YAGL_HOST_CALL_ASSERT(yagl_host_glDisableClientState(array)); + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glEnableClientState(GLenum array) +{ + struct yagl_gles_context *ctx; + + YAGL_LOG_FUNC_ENTER_SPLIT1(glEnableClientState, GLenum, array); + + ctx = yagl_gles_context_get(); + + if (ctx && ctx->arrays) { + ctx->arrays[yagl_gles1_array_idx_get(ctx, array)].enabled = 1; + } + + YAGL_HOST_CALL_ASSERT(yagl_host_glEnableClientState(array)); + + YAGL_LOG_FUNC_EXIT(NULL); +} YAGL_API const GLubyte* glGetString(GLenum name) { + struct yagl_gles_context *ctx; const char *str = NULL; YAGL_LOG_FUNC_ENTER(glGetString, "name = %d", name); + ctx = yagl_gles_context_get(); + switch (name) { case GL_VENDOR: str = "Samsung"; @@ -188,10 +415,23 @@ YAGL_API const GLubyte* glGetString(GLenum name) str = "YaGL GLESv1_CM"; break; case GL_EXTENSIONS: - str = ""; + if (ctx) { + if (!ctx->extensions) { + GLuint size = 0, tmp; + YAGL_HOST_CALL_ASSERT(yagl_host_glGetExtensionStringYAGL(&size, NULL)); + ctx->extensions = yagl_malloc0(size); + do { + yagl_mem_probe_write(ctx->extensions, size); + } while (!yagl_host_glGetExtensionStringYAGL(&tmp, ctx->extensions)); + } + str = ctx->extensions; + } else { + str = ""; + } break; default: str = ""; + break; } YAGL_LOG_FUNC_EXIT(NULL); @@ -199,41 +439,386 @@ YAGL_API const GLubyte* glGetString(GLenum name) return (const GLubyte*)str; } -YAGL_IMPLEMENT_API_NORET3(glGetTexEnviv, GLenum, GLenum, GLint*, env, pname, params) -YAGL_IMPLEMENT_API_NORET3(glGetTexEnvxv, GLenum, GLenum, GLfixed*, env, pname, params) -YAGL_IMPLEMENT_API_NORET3(glGetTexParameterxv, GLenum, GLenum, GLfixed*, target, pname, params) -YAGL_IMPLEMENT_API_NORET2(glLightModelx, GLenum, GLfixed, pname, param) -YAGL_IMPLEMENT_API_NORET2(glLightModelxv, GLenum, const GLfixed*, pname, params) -YAGL_IMPLEMENT_API_NORET3(glLightx, GLenum, GLenum, GLfixed, light, pname, param) -YAGL_IMPLEMENT_API_NORET3(glLightxv, GLenum, GLenum, const GLfixed*, light, pname, params) -YAGL_IMPLEMENT_API_NORET1(glLineWidthx, GLfixed, width) -YAGL_IMPLEMENT_API_NORET0(glLoadIdentity) -YAGL_IMPLEMENT_API_NORET1(glLoadMatrixx, const GLfixed*, m) -YAGL_IMPLEMENT_API_NORET1(glLogicOp, GLenum, opcode) -YAGL_IMPLEMENT_API_NORET3(glMaterialx, GLenum, GLenum, GLfixed, face, pname, param) -YAGL_IMPLEMENT_API_NORET3(glMaterialxv, GLenum, GLenum, const GLfixed*, face, pname, params) -YAGL_IMPLEMENT_API_NORET1(glMatrixMode, GLenum, mode) -YAGL_IMPLEMENT_API_NORET1(glMultMatrixx, const GLfixed*, m) -YAGL_IMPLEMENT_API_NORET5(glMultiTexCoord4x, GLenum, GLfixed, GLfixed, GLfixed, GLfixed, target, s, t, r, q) -YAGL_IMPLEMENT_API_NORET3(glNormal3x, GLfixed, GLfixed, GLfixed, nx, ny, nz) -YAGL_IMPLEMENT_API_NORET3(glNormalPointer, GLenum, GLsizei, const GLvoid*, type, stride, pointer) -YAGL_IMPLEMENT_API_NORET6(glOrthox, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, left, right, bottom, top, zNear, zFar) -YAGL_IMPLEMENT_API_NORET2(glPointParameterx, GLenum, GLfixed, pname, param) -YAGL_IMPLEMENT_API_NORET2(glPointParameterxv, GLenum, const GLfixed*, pname, params) -YAGL_IMPLEMENT_API_NORET1(glPointSizex, GLfixed, size) -YAGL_IMPLEMENT_API_NORET2(glPolygonOffsetx, GLfixed, GLfixed, factor, units) -YAGL_IMPLEMENT_API_NORET0(glPopMatrix) -YAGL_IMPLEMENT_API_NORET0(glPushMatrix) -YAGL_IMPLEMENT_API_NORET4(glRotatex, GLfixed, GLfixed, GLfixed, GLfixed, angle, x, y, z) -YAGL_IMPLEMENT_API_NORET2(glSampleCoveragex, GLclampx, GLboolean, value, invert) -YAGL_IMPLEMENT_API_NORET3(glScalex, GLfixed, GLfixed, GLfixed, x, y, z) -YAGL_IMPLEMENT_API_NORET1(glShadeModel, GLenum, mode) -YAGL_IMPLEMENT_API_NORET4(glTexCoordPointer, GLint, GLenum, GLsizei, const GLvoid*, size, type, stride, pointer) -YAGL_IMPLEMENT_API_NORET3(glTexEnvi, GLenum, GLenum, GLint, target, pname, param) -YAGL_IMPLEMENT_API_NORET3(glTexEnvx, GLenum, GLenum, GLfixed, target, pname, param) -YAGL_IMPLEMENT_API_NORET3(glTexEnviv, GLenum, GLenum, const GLint*, target, pname, params) -YAGL_IMPLEMENT_API_NORET3(glTexEnvxv, GLenum, GLenum, const GLfixed*, target, pname, params) -YAGL_IMPLEMENT_API_NORET3(glTexParameterx, GLenum, GLenum, GLfixed, target, pname, param) -YAGL_IMPLEMENT_API_NORET3(glTexParameterxv, GLenum, GLenum, const GLfixed*, target, pname, params) -YAGL_IMPLEMENT_API_NORET3(glTranslatex, GLfixed, GLfixed, GLfixed, x, y, z) -YAGL_IMPLEMENT_API_NORET4(glVertexPointer, GLint, GLenum, GLsizei, const GLvoid*, size, type, stride, pointer) +YAGL_API void glGetTexEnviv(GLenum target, GLenum pname, GLint *params) +{ + unsigned count = yagl_get_texenv_param_len(pname); + unsigned i; + + YAGL_LOG_FUNC_ENTER_SPLIT3(glGetTexEnviv, GLenum, GLenum, GLint *, target, pname, params); + + do { + for (i = 0; i < count; ++i) { + yagl_mem_probe_write_GLint(params[i]); + } + } while (!yagl_host_glGetTexEnviv(target, pname, params)); + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params) +{ + unsigned count = yagl_get_texenv_param_len(pname); + unsigned i; + + YAGL_LOG_FUNC_ENTER_SPLIT3(glGetTexEnvfv, GLenum, GLenum, GLfloat *, target, pname, params); + + do { + for (i = 0; i < count; ++i) { + yagl_mem_probe_write_GLfloat(params + i); + } + } while (!yagl_host_glGetTexEnvfv(target, pname, params)); + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glGetTexEnvxv(GLenum target, GLenum pname, GLfixed *params) +{ + unsigned count = yagl_get_texenv_param_len(pname); + unsigned i; + + YAGL_LOG_FUNC_ENTER_SPLIT3(glGetTexEnvxv, GLenum, GLenum, GLint *, target, pname, params); + + do { + for (i = 0; i < count; ++i) { + yagl_mem_probe_write_GLfixed(params[i]); + } + } while (!yagl_host_glGetTexEnvxv(target, pname, params)); + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glGetPointerv(GLenum pname, GLvoid** pointer) +{ + YAGL_LOG_FUNC_ENTER_SPLIT2(glGetPointerv, GLenum, GLvoid**, pname, pointer); + + do { + yagl_mem_probe_write(pointer, sizeof(*pointer)); + } while (!yagl_host_glGetPointerv(pname, pointer)); + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glNormalPointer(GLenum type, GLsizei stride, const GLvoid* pointer) +{ + 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_HOST_CALL_ASSERT(yagl_host_glNormalPointer(type, stride, pointer)); + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) +{ + 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_HOST_CALL_ASSERT(yagl_host_glVertexPointer(size, type, stride, pointer)); + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) +{ + 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_HOST_CALL_ASSERT(yagl_host_glColorPointer(size, type, stride, pointer)); + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid* pointer) +{ + 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_HOST_CALL_ASSERT(yagl_host_glTexCoordPointer(size, type, stride, pointer)); + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid* pointer) +{ + 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_HOST_CALL_ASSERT(yagl_host_glPointSizePointerOES(type, stride, pointer)); + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glTexParameterxv(GLenum target, GLenum pname, const GLfixed *params) +{ + YAGL_LOG_FUNC_ENTER_SPLIT3(glTexParameterxv, GLenum, GLenum, const GLfixed*, target, pname, params); + while (!yagl_host_glTexParameterxv(target, pname, yagl_batch_put_GLfixeds(params, 1))) {} + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params) +{ + YAGL_LOG_FUNC_ENTER_SPLIT3(glGetTexParameterxv, GLenum, GLenum, GLfixed*, target, pname, params); + + do { + yagl_mem_probe_write_GLfixed(params); + } while (!yagl_host_glGetTexParameterxv(target, pname, params)); + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glMultMatrixf(const GLfloat* m) +{ + YAGL_LOG_FUNC_ENTER_SPLIT1(glMultMatrixf, const GLfloat*, m); + while (!yagl_host_glMultMatrixf(yagl_batch_put_GLfloats(m, 16))) {} + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glMultMatrixx(const GLfixed* m) +{ + YAGL_LOG_FUNC_ENTER_SPLIT1(glMultMatrixx, const GLfixed*, m); + while (!yagl_host_glMultMatrixx(yagl_batch_put_GLfixeds(m, 16))) {} + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glLoadMatrixf(const GLfloat* m) +{ + YAGL_LOG_FUNC_ENTER_SPLIT1(glLoadMatrixf, const GLfloat*, m); + while (!yagl_host_glLoadMatrixf(yagl_batch_put_GLfloats(m, 16))) {} + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glLoadMatrixx(const GLfixed* m) +{ + YAGL_LOG_FUNC_ENTER_SPLIT1(glLoadMatrixx, const GLfixed*, m); + while (!yagl_host_glLoadMatrixx(yagl_batch_put_GLfixeds(m, 16))) {} + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glPointParameterfv(GLenum pname, const GLfloat *params) +{ + unsigned count = yagl_get_point_param_len(pname); + + YAGL_LOG_FUNC_ENTER_SPLIT2(glPointParameterfv, GLenum, const GLfloat *, pname, params); + + while (!yagl_host_glPointParameterfv(pname, yagl_batch_put_GLfloats(params, count))) {} + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glPointParameterxv(GLenum pname, const GLfixed *params) +{ + unsigned count = yagl_get_point_param_len(pname); + + YAGL_LOG_FUNC_ENTER_SPLIT2(glPointParameterxv, GLenum, const GLfixed *, pname, params); + + while (!yagl_host_glPointParameterxv(pname, yagl_batch_put_GLfixeds(params, count))) {} + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glFogfv(GLenum pname, const GLfloat *params) +{ + unsigned count = yagl_get_fog_param_len(pname); + + YAGL_LOG_FUNC_ENTER_SPLIT2(glFogfv, GLenum, const GLfloat *, pname, params); + + while (!yagl_host_glFogfv(pname, yagl_batch_put_GLfloats(params, count))) {} + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glFogxv(GLenum pname, const GLfixed *params) +{ + unsigned count = yagl_get_fog_param_len(pname); + + YAGL_LOG_FUNC_ENTER_SPLIT2(glFogxv, GLenum, const GLfixed *, pname, params); + + while (!yagl_host_glFogxv(pname, yagl_batch_put_GLfixeds(params, count))) {} + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glClipPlanef(GLenum plane, const GLfloat *equation) +{ + YAGL_LOG_FUNC_ENTER_SPLIT2(glClipPlanef, GLenum, const GLfloat *, plane, equation); + while (!yagl_host_glClipPlanef(plane, yagl_batch_put_GLfloats(equation, 4))) {} + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glClipPlanex(GLenum plane, const GLfixed *equation) +{ + YAGL_LOG_FUNC_ENTER_SPLIT2(glClipPlanex, GLenum, const GLfixed *, plane, equation); + while (!yagl_host_glClipPlanex(plane, yagl_batch_put_GLfixeds(equation, 4))) {} + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glGetClipPlanef(GLenum pname, GLfloat *eqn) +{ + YAGL_LOG_FUNC_ENTER_SPLIT2(glGetClipPlanef, GLenum, GLfloat*, pname, eqn); + + do { + yagl_mem_probe_write(eqn, 4 * sizeof(GLfloat)); + } while (!yagl_host_glGetClipPlanef(pname, eqn)); + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glGetClipPlanex(GLenum pname, GLfixed *eqn) +{ + YAGL_LOG_FUNC_ENTER_SPLIT2(glGetClipPlanex, GLenum, GLfixed*, pname, eqn); + + do { + yagl_mem_probe_write(eqn, 4 * sizeof(GLfixed)); + } while (!yagl_host_glGetClipPlanex(pname, eqn)); + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glLightfv(GLenum light, GLenum pname, const GLfloat *params) +{ + unsigned count; + + YAGL_LOG_FUNC_ENTER_SPLIT3(glLightfv, GLenum, GLenum, const GLfloat *, light, pname, params); + + count = yagl_get_light_param_len(pname); + + while (!yagl_host_glLightfv(light, pname, yagl_batch_put_GLfloats(params, count))) {} + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glLightxv(GLenum light, GLenum pname, const GLfixed *params) +{ + unsigned count; + + YAGL_LOG_FUNC_ENTER_SPLIT3(glLightxv, GLenum, GLenum, const GLfixed *, light, pname, params); + + count = yagl_get_light_param_len(pname); + + while (!yagl_host_glLightxv(light, pname, yagl_batch_put_GLfixeds(params, count))) {} + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glLightModelfv(GLenum pname, const GLfloat *params) +{ + unsigned count = yagl_get_light_model_param_len(pname); + + YAGL_LOG_FUNC_ENTER_SPLIT2(glLightModelfv, GLenum, const GLfloat *, pname, params); + + while (!yagl_host_glLightModelfv(pname, yagl_batch_put_GLfloats(params, count))) {} + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glLightModelxv(GLenum pname, const GLfixed *params) +{ + unsigned count = yagl_get_light_model_param_len(pname); + + YAGL_LOG_FUNC_ENTER_SPLIT2(glLightModelxv, GLenum, const GLfixed *, pname, params); + + while (!yagl_host_glLightModelxv(pname, yagl_batch_put_GLfixeds(params, count))) {} + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glGetLightfv(GLenum light, GLenum pname, GLfloat *params) +{ + unsigned count; + + YAGL_LOG_FUNC_ENTER_SPLIT3(glGetLightfv, GLenum, GLenum, GLfloat*, light, pname, params); + + count = yagl_get_light_param_len(pname); + + do { + yagl_mem_probe_write(params, count * sizeof(GLfloat)); + } while (!yagl_host_glGetLightfv(light, pname, params)); + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glGetLightxv(GLenum light, GLenum pname, GLfixed *params) +{ + unsigned count; + + YAGL_LOG_FUNC_ENTER_SPLIT3(glGetLightxv, GLenum, GLenum, GLfixed*, light, pname, params); + + count = yagl_get_light_param_len(pname); + + do { + yagl_mem_probe_write(params, count * sizeof(GLfixed)); + } while (!yagl_host_glGetLightxv(light, pname, params)); + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) +{ + unsigned count; + + YAGL_LOG_FUNC_ENTER_SPLIT3(glMaterialfv, GLenum, GLenum, const GLfloat *, face, pname, params); + + count = yagl_get_material_param_len(pname); + + while (!yagl_host_glMaterialfv(face, pname, yagl_batch_put_GLfloats(params, count))) {} + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glMaterialxv(GLenum face, GLenum pname, const GLfixed *params) +{ + unsigned count; + + YAGL_LOG_FUNC_ENTER_SPLIT3(glMaterialxv, GLenum, GLenum, const GLfixed *, face, pname, params); + + count = yagl_get_material_param_len(pname); + + while (!yagl_host_glMaterialxv(face, pname, yagl_batch_put_GLfixeds(params, count))) {} + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params) +{ + unsigned count; + + YAGL_LOG_FUNC_ENTER_SPLIT3(glGetMaterialfv, GLenum, GLenum, GLfloat*, face, pname, params); + + count = yagl_get_material_param_len(pname); + + do { + yagl_mem_probe_write(params, count * sizeof(GLfloat)); + } while (!yagl_host_glGetMaterialfv(face, pname, params)); + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glGetMaterialxv(GLenum light, GLenum pname, GLfixed *params) +{ + unsigned count; + + YAGL_LOG_FUNC_ENTER_SPLIT3(glGetMaterialxv, GLenum, GLenum, GLfixed*, light, pname, params); + + count = yagl_get_material_param_len(pname); + + do { + yagl_mem_probe_write(params, count * sizeof(GLfixed)); + } while (!yagl_host_glGetMaterialxv(light, pname, params)); + + YAGL_LOG_FUNC_EXIT(NULL); +} + +YAGL_API void glGetFixedv(GLenum pname, GLfixed* params) +{ + YAGL_LOG_FUNC_ENTER_SPLIT2(glGetFixedv, GLenum, GLfixed*, pname, params); + + do { + yagl_mem_probe_write_GLfixed(params); + } while (!yagl_host_glGetFixedv(pname, params)); + + YAGL_LOG_FUNC_EXIT(NULL); +} -- cgit v1.2.3