host/gl/OpenGLESDispatch/gles1_only_dispatch_logging_wrappers.impl

// Auto-generated with: android/scripts/gen-entries.py --mode=dispatch_logging_wrappers stream-servers/gl/OpenGLESDispatch/gles1_only.entries --output=stream-servers/gl/OpenGLESDispatch/gles1_only_dispatch_logging_wrappers.impl
// DO NOT EDIT THIS FILE

void glAlphaFunc_dispatchLoggingWrapper(GLenum func, GLclampf ref) {
	DISPATCH_DEBUG_LOG("glAlphaFunc(func:0x%X, ref:%f)", func, ref);
	GLDispatch::glAlphaFunc_underlying(func, ref);
}

void glBegin_dispatchLoggingWrapper(GLenum mode) {
	DISPATCH_DEBUG_LOG("glBegin(mode:0x%X)", mode);
	GLDispatch::glBegin_underlying(mode);
}

void glClientActiveTexture_dispatchLoggingWrapper(GLenum texture) {
	DISPATCH_DEBUG_LOG("glClientActiveTexture(texture:0x%X)", texture);
	GLDispatch::glClientActiveTexture_underlying(texture);
}

void glClipPlane_dispatchLoggingWrapper(GLenum plane, const GLdouble * equation) {
	DISPATCH_DEBUG_LOG("glClipPlane(plane:0x%X, equation:%p)", plane, equation);
	GLDispatch::glClipPlane_underlying(plane, equation);
}

void glColor4d_dispatchLoggingWrapper(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha) {
	DISPATCH_DEBUG_LOG("glColor4d(red:%f, green:%f, blue:%f, alpha:%f)", red, green, blue, alpha);
	GLDispatch::glColor4d_underlying(red, green, blue, alpha);
}

void glColor4f_dispatchLoggingWrapper(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) {
	DISPATCH_DEBUG_LOG("glColor4f(red:%f, green:%f, blue:%f, alpha:%f)", red, green, blue, alpha);
	GLDispatch::glColor4f_underlying(red, green, blue, alpha);
}

void glColor4fv_dispatchLoggingWrapper(const GLfloat * v) {
	DISPATCH_DEBUG_LOG("glColor4fv(v:%p)", v);
	GLDispatch::glColor4fv_underlying(v);
}

void glColor4ub_dispatchLoggingWrapper(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) {
	DISPATCH_DEBUG_LOG("glColor4ub(red:%u, green:%u, blue:%u, alpha:%u)", red, green, blue, alpha);
	GLDispatch::glColor4ub_underlying(red, green, blue, alpha);
}

void glColor4ubv_dispatchLoggingWrapper(const GLubyte * v) {
	DISPATCH_DEBUG_LOG("glColor4ubv(v:%p)", v);
	GLDispatch::glColor4ubv_underlying(v);
}

void glColorPointer_dispatchLoggingWrapper(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) {
	DISPATCH_DEBUG_LOG("glColorPointer(size:%d, type:0x%X, stride:%d, pointer:%p)", size, type, stride, pointer);
	GLDispatch::glColorPointer_underlying(size, type, stride, pointer);
}

void glDisableClientState_dispatchLoggingWrapper(GLenum array) {
	DISPATCH_DEBUG_LOG("glDisableClientState(array:0x%X)", array);
	GLDispatch::glDisableClientState_underlying(array);
}

void glEnableClientState_dispatchLoggingWrapper(GLenum array) {
	DISPATCH_DEBUG_LOG("glEnableClientState(array:0x%X)", array);
	GLDispatch::glEnableClientState_underlying(array);
}

void glEnd_dispatchLoggingWrapper() {
	DISPATCH_DEBUG_LOG("glEnd()");
	GLDispatch::glEnd_underlying();
}

void glFogf_dispatchLoggingWrapper(GLenum pname, GLfloat param) {
	DISPATCH_DEBUG_LOG("glFogf(pname:0x%X, param:%f)", pname, param);
	GLDispatch::glFogf_underlying(pname, param);
}

void glFogfv_dispatchLoggingWrapper(GLenum pname, const GLfloat * params) {
	DISPATCH_DEBUG_LOG("glFogfv(pname:0x%X, params:%p)", pname, params);
	GLDispatch::glFogfv_underlying(pname, params);
}

void glGetClipPlane_dispatchLoggingWrapper(GLenum plane, GLdouble * equation) {
	DISPATCH_DEBUG_LOG("glGetClipPlane(plane:0x%X, equation:%p)", plane, equation);
	GLDispatch::glGetClipPlane_underlying(plane, equation);
}

void glGetDoublev_dispatchLoggingWrapper(GLenum pname, GLdouble * params) {
	DISPATCH_DEBUG_LOG("glGetDoublev(pname:0x%X, params:%p)", pname, params);
	GLDispatch::glGetDoublev_underlying(pname, params);
}

void glGetLightfv_dispatchLoggingWrapper(GLenum light, GLenum pname, GLfloat * params) {
	DISPATCH_DEBUG_LOG("glGetLightfv(light:0x%X, pname:0x%X, params:%p)", light, pname, params);
	GLDispatch::glGetLightfv_underlying(light, pname, params);
}

void glGetMaterialfv_dispatchLoggingWrapper(GLenum face, GLenum pname, GLfloat * params) {
	DISPATCH_DEBUG_LOG("glGetMaterialfv(face:0x%X, pname:0x%X, params:%p)", face, pname, params);
	GLDispatch::glGetMaterialfv_underlying(face, pname, params);
}

void glGetPointerv_dispatchLoggingWrapper(GLenum pname, GLvoid* * params) {
	DISPATCH_DEBUG_LOG("glGetPointerv(pname:0x%X, params:%p)", pname, params);
	GLDispatch::glGetPointerv_underlying(pname, params);
}

void glGetTexEnvfv_dispatchLoggingWrapper(GLenum target, GLenum pname, GLfloat * params) {
	DISPATCH_DEBUG_LOG("glGetTexEnvfv(target:0x%X, pname:0x%X, params:%p)", target, pname, params);
	GLDispatch::glGetTexEnvfv_underlying(target, pname, params);
}

void glGetTexEnviv_dispatchLoggingWrapper(GLenum target, GLenum pname, GLint * params) {
	DISPATCH_DEBUG_LOG("glGetTexEnviv(target:0x%X, pname:0x%X, params:%p)", target, pname, params);
	GLDispatch::glGetTexEnviv_underlying(target, pname, params);
}

void glLightf_dispatchLoggingWrapper(GLenum light, GLenum pname, GLfloat param) {
	DISPATCH_DEBUG_LOG("glLightf(light:0x%X, pname:0x%X, param:%f)", light, pname, param);
	GLDispatch::glLightf_underlying(light, pname, param);
}

void glLightfv_dispatchLoggingWrapper(GLenum light, GLenum pname, const GLfloat * params) {
	DISPATCH_DEBUG_LOG("glLightfv(light:0x%X, pname:0x%X, params:%p)", light, pname, params);
	GLDispatch::glLightfv_underlying(light, pname, params);
}

void glLightModelf_dispatchLoggingWrapper(GLenum pname, GLfloat param) {
	DISPATCH_DEBUG_LOG("glLightModelf(pname:0x%X, param:%f)", pname, param);
	GLDispatch::glLightModelf_underlying(pname, param);
}

void glLightModelfv_dispatchLoggingWrapper(GLenum pname, const GLfloat * params) {
	DISPATCH_DEBUG_LOG("glLightModelfv(pname:0x%X, params:%p)", pname, params);
	GLDispatch::glLightModelfv_underlying(pname, params);
}

void glLoadIdentity_dispatchLoggingWrapper() {
	DISPATCH_DEBUG_LOG("glLoadIdentity()");
	GLDispatch::glLoadIdentity_underlying();
}

void glLoadMatrixf_dispatchLoggingWrapper(const GLfloat * m) {
	DISPATCH_DEBUG_LOG("glLoadMatrixf(m:%p)", m);
	GLDispatch::glLoadMatrixf_underlying(m);
}

void glLogicOp_dispatchLoggingWrapper(GLenum opcode) {
	DISPATCH_DEBUG_LOG("glLogicOp(opcode:0x%X)", opcode);
	GLDispatch::glLogicOp_underlying(opcode);
}

void glMaterialf_dispatchLoggingWrapper(GLenum face, GLenum pname, GLfloat param) {
	DISPATCH_DEBUG_LOG("glMaterialf(face:0x%X, pname:0x%X, param:%f)", face, pname, param);
	GLDispatch::glMaterialf_underlying(face, pname, param);
}

void glMaterialfv_dispatchLoggingWrapper(GLenum face, GLenum pname, const GLfloat * params) {
	DISPATCH_DEBUG_LOG("glMaterialfv(face:0x%X, pname:0x%X, params:%p)", face, pname, params);
	GLDispatch::glMaterialfv_underlying(face, pname, params);
}

void glMultiTexCoord2fv_dispatchLoggingWrapper(GLenum target, const GLfloat * v) {
	DISPATCH_DEBUG_LOG("glMultiTexCoord2fv(target:0x%X, v:%p)", target, v);
	GLDispatch::glMultiTexCoord2fv_underlying(target, v);
}

void glMultiTexCoord2sv_dispatchLoggingWrapper(GLenum target, const GLshort * v) {
	DISPATCH_DEBUG_LOG("glMultiTexCoord2sv(target:0x%X, v:%p)", target, v);
	GLDispatch::glMultiTexCoord2sv_underlying(target, v);
}

void glMultiTexCoord3fv_dispatchLoggingWrapper(GLenum target, const GLfloat * v) {
	DISPATCH_DEBUG_LOG("glMultiTexCoord3fv(target:0x%X, v:%p)", target, v);
	GLDispatch::glMultiTexCoord3fv_underlying(target, v);
}

void glMultiTexCoord3sv_dispatchLoggingWrapper(GLenum target, const GLshort * v) {
	DISPATCH_DEBUG_LOG("glMultiTexCoord3sv(target:0x%X, v:%p)", target, v);
	GLDispatch::glMultiTexCoord3sv_underlying(target, v);
}

void glMultiTexCoord4f_dispatchLoggingWrapper(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) {
	DISPATCH_DEBUG_LOG("glMultiTexCoord4f(target:0x%X, s:%f, t:%f, r:%f, q:%f)", target, s, t, r, q);
	GLDispatch::glMultiTexCoord4f_underlying(target, s, t, r, q);
}

void glMultiTexCoord4fv_dispatchLoggingWrapper(GLenum target, const GLfloat * v) {
	DISPATCH_DEBUG_LOG("glMultiTexCoord4fv(target:0x%X, v:%p)", target, v);
	GLDispatch::glMultiTexCoord4fv_underlying(target, v);
}

void glMultiTexCoord4sv_dispatchLoggingWrapper(GLenum target, const GLshort * v) {
	DISPATCH_DEBUG_LOG("glMultiTexCoord4sv(target:0x%X, v:%p)", target, v);
	GLDispatch::glMultiTexCoord4sv_underlying(target, v);
}

void glMultMatrixf_dispatchLoggingWrapper(const GLfloat * m) {
	DISPATCH_DEBUG_LOG("glMultMatrixf(m:%p)", m);
	GLDispatch::glMultMatrixf_underlying(m);
}

void glNormal3f_dispatchLoggingWrapper(GLfloat nx, GLfloat ny, GLfloat nz) {
	DISPATCH_DEBUG_LOG("glNormal3f(nx:%f, ny:%f, nz:%f)", nx, ny, nz);
	GLDispatch::glNormal3f_underlying(nx, ny, nz);
}

void glNormal3fv_dispatchLoggingWrapper(const GLfloat * v) {
	DISPATCH_DEBUG_LOG("glNormal3fv(v:%p)", v);
	GLDispatch::glNormal3fv_underlying(v);
}

void glNormal3sv_dispatchLoggingWrapper(const GLshort * v) {
	DISPATCH_DEBUG_LOG("glNormal3sv(v:%p)", v);
	GLDispatch::glNormal3sv_underlying(v);
}

void glOrtho_dispatchLoggingWrapper(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar) {
	DISPATCH_DEBUG_LOG("glOrtho(left:%f, right:%f, bottom:%f, top:%f, zNear:%f, zFar:%f)", left, right, bottom, top, zNear, zFar);
	GLDispatch::glOrtho_underlying(left, right, bottom, top, zNear, zFar);
}

void glPointParameterf_dispatchLoggingWrapper(GLenum param, GLfloat value) {
	DISPATCH_DEBUG_LOG("glPointParameterf(param:0x%X, value:%f)", param, value);
	GLDispatch::glPointParameterf_underlying(param, value);
}

void glPointParameterfv_dispatchLoggingWrapper(GLenum param, const GLfloat * values) {
	DISPATCH_DEBUG_LOG("glPointParameterfv(param:0x%X, values:%p)", param, values);
	GLDispatch::glPointParameterfv_underlying(param, values);
}

void glPointSize_dispatchLoggingWrapper(GLfloat size) {
	DISPATCH_DEBUG_LOG("glPointSize(size:%f)", size);
	GLDispatch::glPointSize_underlying(size);
}

void glRotatef_dispatchLoggingWrapper(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) {
	DISPATCH_DEBUG_LOG("glRotatef(angle:%f, x:%f, y:%f, z:%f)", angle, x, y, z);
	GLDispatch::glRotatef_underlying(angle, x, y, z);
}

void glScalef_dispatchLoggingWrapper(GLfloat x, GLfloat y, GLfloat z) {
	DISPATCH_DEBUG_LOG("glScalef(x:%f, y:%f, z:%f)", x, y, z);
	GLDispatch::glScalef_underlying(x, y, z);
}

void glTexEnvf_dispatchLoggingWrapper(GLenum target, GLenum pname, GLfloat param) {
	DISPATCH_DEBUG_LOG("glTexEnvf(target:0x%X, pname:0x%X, param:%f)", target, pname, param);
	GLDispatch::glTexEnvf_underlying(target, pname, param);
}

void glTexEnvfv_dispatchLoggingWrapper(GLenum target, GLenum pname, const GLfloat * params) {
	DISPATCH_DEBUG_LOG("glTexEnvfv(target:0x%X, pname:0x%X, params:%p)", target, pname, params);
	GLDispatch::glTexEnvfv_underlying(target, pname, params);
}

void glMatrixMode_dispatchLoggingWrapper(GLenum mode) {
	DISPATCH_DEBUG_LOG("glMatrixMode(mode:0x%X)", mode);
	GLDispatch::glMatrixMode_underlying(mode);
}

void glNormalPointer_dispatchLoggingWrapper(GLenum type, GLsizei stride, const GLvoid * pointer) {
	DISPATCH_DEBUG_LOG("glNormalPointer(type:0x%X, stride:%d, pointer:%p)", type, stride, pointer);
	GLDispatch::glNormalPointer_underlying(type, stride, pointer);
}

void glPopMatrix_dispatchLoggingWrapper() {
	DISPATCH_DEBUG_LOG("glPopMatrix()");
	GLDispatch::glPopMatrix_underlying();
}

void glPushMatrix_dispatchLoggingWrapper() {
	DISPATCH_DEBUG_LOG("glPushMatrix()");
	GLDispatch::glPushMatrix_underlying();
}

void glShadeModel_dispatchLoggingWrapper(GLenum mode) {
	DISPATCH_DEBUG_LOG("glShadeModel(mode:0x%X)", mode);
	GLDispatch::glShadeModel_underlying(mode);
}

void glTexCoordPointer_dispatchLoggingWrapper(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) {
	DISPATCH_DEBUG_LOG("glTexCoordPointer(size:%d, type:0x%X, stride:%d, pointer:%p)", size, type, stride, pointer);
	GLDispatch::glTexCoordPointer_underlying(size, type, stride, pointer);
}

void glTexEnvi_dispatchLoggingWrapper(GLenum target, GLenum pname, GLint param) {
	DISPATCH_DEBUG_LOG("glTexEnvi(target:0x%X, pname:0x%X, param:%d)", target, pname, param);
	GLDispatch::glTexEnvi_underlying(target, pname, param);
}

void glTexEnviv_dispatchLoggingWrapper(GLenum target, GLenum pname, const GLint * params) {
	DISPATCH_DEBUG_LOG("glTexEnviv(target:0x%X, pname:0x%X, params:%p)", target, pname, params);
	GLDispatch::glTexEnviv_underlying(target, pname, params);
}

void glTranslatef_dispatchLoggingWrapper(GLfloat x, GLfloat y, GLfloat z) {
	DISPATCH_DEBUG_LOG("glTranslatef(x:%f, y:%f, z:%f)", x, y, z);
	GLDispatch::glTranslatef_underlying(x, y, z);
}

void glVertexPointer_dispatchLoggingWrapper(GLint size, GLenum type, GLsizei stride, const GLvoid * pointer) {
	DISPATCH_DEBUG_LOG("glVertexPointer(size:%d, type:0x%X, stride:%d, pointer:%p)", size, type, stride, pointer);
	GLDispatch::glVertexPointer_underlying(size, type, stride, pointer);
}

void glClipPlanef_dispatchLoggingWrapper(GLenum plane, const GLfloat * equation) {
	DISPATCH_DEBUG_LOG("glClipPlanef(plane:0x%X, equation:%p)", plane, equation);
	GLDispatch::glClipPlanef_underlying(plane, equation);
}

void glFrustumf_dispatchLoggingWrapper(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) {
	DISPATCH_DEBUG_LOG("glFrustumf(left:%f, right:%f, bottom:%f, top:%f, zNear:%f, zFar:%f)", left, right, bottom, top, zNear, zFar);
	GLDispatch::glFrustumf_underlying(left, right, bottom, top, zNear, zFar);
}

void glGetClipPlanef_dispatchLoggingWrapper(GLenum pname, GLfloat eqn[4]) {
	DISPATCH_DEBUG_LOG("glGetClipPlanef(pname:0x%X, eqn[4]:%p)", pname, eqn);
	GLDispatch::glGetClipPlanef_underlying(pname, eqn);
}

void glOrthof_dispatchLoggingWrapper(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) {
	DISPATCH_DEBUG_LOG("glOrthof(left:%f, right:%f, bottom:%f, top:%f, zNear:%f, zFar:%f)", left, right, bottom, top, zNear, zFar);
	GLDispatch::glOrthof_underlying(left, right, bottom, top, zNear, zFar);
}

void glAlphaFuncx_dispatchLoggingWrapper(GLenum func, GLclampx ref) {
	DISPATCH_DEBUG_LOG("glAlphaFuncx(func:0x%X, ref:%d)", func, ref);
	GLDispatch::glAlphaFuncx_underlying(func, ref);
}

void glClearColorx_dispatchLoggingWrapper(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) {
	DISPATCH_DEBUG_LOG("glClearColorx(red:%d, green:%d, blue:%d, alpha:%d)", red, green, blue, alpha);
	GLDispatch::glClearColorx_underlying(red, green, blue, alpha);
}

void glClearDepthx_dispatchLoggingWrapper(GLclampx depth) {
	DISPATCH_DEBUG_LOG("glClearDepthx(depth:%d)", depth);
	GLDispatch::glClearDepthx_underlying(depth);
}

void glColor4x_dispatchLoggingWrapper(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) {
	DISPATCH_DEBUG_LOG("glColor4x(red:%d, green:%d, blue:%d, alpha:%d)", red, green, blue, alpha);
	GLDispatch::glColor4x_underlying(red, green, blue, alpha);
}

void glDepthRangex_dispatchLoggingWrapper(GLclampx zNear, GLclampx zFar) {
	DISPATCH_DEBUG_LOG("glDepthRangex(zNear:%d, zFar:%d)", zNear, zFar);
	GLDispatch::glDepthRangex_underlying(zNear, zFar);
}

void glFogx_dispatchLoggingWrapper(GLenum pname, GLfixed param) {
	DISPATCH_DEBUG_LOG("glFogx(pname:0x%X, param:%d)", pname, param);
	GLDispatch::glFogx_underlying(pname, param);
}

void glFogxv_dispatchLoggingWrapper(GLenum pname, const GLfixed * params) {
	DISPATCH_DEBUG_LOG("glFogxv(pname:0x%X, params:%p)", pname, params);
	GLDispatch::glFogxv_underlying(pname, params);
}

void glFrustumx_dispatchLoggingWrapper(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) {
	DISPATCH_DEBUG_LOG("glFrustumx(left:%d, right:%d, bottom:%d, top:%d, zNear:%d, zFar:%d)", left, right, bottom, top, zNear, zFar);
	GLDispatch::glFrustumx_underlying(left, right, bottom, top, zNear, zFar);
}

void glClipPlanex_dispatchLoggingWrapper(GLenum pname, const GLfixed * eqn) {
	DISPATCH_DEBUG_LOG("glClipPlanex(pname:0x%X, eqn:%p)", pname, eqn);
	GLDispatch::glClipPlanex_underlying(pname, eqn);
}

void glGetFixedv_dispatchLoggingWrapper(GLenum pname, GLfixed * params) {
	DISPATCH_DEBUG_LOG("glGetFixedv(pname:0x%X, params:%p)", pname, params);
	GLDispatch::glGetFixedv_underlying(pname, params);
}

void glGetLightxv_dispatchLoggingWrapper(GLenum light, GLenum pname, GLfixed * params) {
	DISPATCH_DEBUG_LOG("glGetLightxv(light:0x%X, pname:0x%X, params:%p)", light, pname, params);
	GLDispatch::glGetLightxv_underlying(light, pname, params);
}

void glGetMaterialxv_dispatchLoggingWrapper(GLenum face, GLenum pname, GLfixed * params) {
	DISPATCH_DEBUG_LOG("glGetMaterialxv(face:0x%X, pname:0x%X, params:%p)", face, pname, params);
	GLDispatch::glGetMaterialxv_underlying(face, pname, params);
}

void glGetTexEnvxv_dispatchLoggingWrapper(GLenum env, GLenum pname, GLfixed * params) {
	DISPATCH_DEBUG_LOG("glGetTexEnvxv(env:0x%X, pname:0x%X, params:%p)", env, pname, params);
	GLDispatch::glGetTexEnvxv_underlying(env, pname, params);
}

void glGetTexParameterxv_dispatchLoggingWrapper(GLenum target, GLenum pname, GLfixed * params) {
	DISPATCH_DEBUG_LOG("glGetTexParameterxv(target:0x%X, pname:0x%X, params:%p)", target, pname, params);
	GLDispatch::glGetTexParameterxv_underlying(target, pname, params);
}

void glLightModelx_dispatchLoggingWrapper(GLenum pname, GLfixed param) {
	DISPATCH_DEBUG_LOG("glLightModelx(pname:0x%X, param:%d)", pname, param);
	GLDispatch::glLightModelx_underlying(pname, param);
}

void glLightModelxv_dispatchLoggingWrapper(GLenum pname, const GLfixed * params) {
	DISPATCH_DEBUG_LOG("glLightModelxv(pname:0x%X, params:%p)", pname, params);
	GLDispatch::glLightModelxv_underlying(pname, params);
}

void glLightx_dispatchLoggingWrapper(GLenum light, GLenum pname, GLfixed param) {
	DISPATCH_DEBUG_LOG("glLightx(light:0x%X, pname:0x%X, param:%d)", light, pname, param);
	GLDispatch::glLightx_underlying(light, pname, param);
}

void glLightxv_dispatchLoggingWrapper(GLenum light, GLenum pname, const GLfixed * params) {
	DISPATCH_DEBUG_LOG("glLightxv(light:0x%X, pname:0x%X, params:%p)", light, pname, params);
	GLDispatch::glLightxv_underlying(light, pname, params);
}

void glLineWidthx_dispatchLoggingWrapper(GLfixed width) {
	DISPATCH_DEBUG_LOG("glLineWidthx(width:%d)", width);
	GLDispatch::glLineWidthx_underlying(width);
}

void glLoadMatrixx_dispatchLoggingWrapper(const GLfixed * m) {
	DISPATCH_DEBUG_LOG("glLoadMatrixx(m:%p)", m);
	GLDispatch::glLoadMatrixx_underlying(m);
}

void glMaterialx_dispatchLoggingWrapper(GLenum face, GLenum pname, GLfixed param) {
	DISPATCH_DEBUG_LOG("glMaterialx(face:0x%X, pname:0x%X, param:%d)", face, pname, param);
	GLDispatch::glMaterialx_underlying(face, pname, param);
}

void glMaterialxv_dispatchLoggingWrapper(GLenum face, GLenum pname, const GLfixed * params) {
	DISPATCH_DEBUG_LOG("glMaterialxv(face:0x%X, pname:0x%X, params:%p)", face, pname, params);
	GLDispatch::glMaterialxv_underlying(face, pname, params);
}

void glMultMatrixx_dispatchLoggingWrapper(const GLfixed * m) {
	DISPATCH_DEBUG_LOG("glMultMatrixx(m:%p)", m);
	GLDispatch::glMultMatrixx_underlying(m);
}

void glMultiTexCoord4x_dispatchLoggingWrapper(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) {
	DISPATCH_DEBUG_LOG("glMultiTexCoord4x(target:0x%X, s:%d, t:%d, r:%d, q:%d)", target, s, t, r, q);
	GLDispatch::glMultiTexCoord4x_underlying(target, s, t, r, q);
}

void glNormal3x_dispatchLoggingWrapper(GLfixed nx, GLfixed ny, GLfixed nz) {
	DISPATCH_DEBUG_LOG("glNormal3x(nx:%d, ny:%d, nz:%d)", nx, ny, nz);
	GLDispatch::glNormal3x_underlying(nx, ny, nz);
}

void glOrthox_dispatchLoggingWrapper(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) {
	DISPATCH_DEBUG_LOG("glOrthox(left:%d, right:%d, bottom:%d, top:%d, zNear:%d, zFar:%d)", left, right, bottom, top, zNear, zFar);
	GLDispatch::glOrthox_underlying(left, right, bottom, top, zNear, zFar);
}

void glPointParameterx_dispatchLoggingWrapper(GLenum pname, GLfixed param) {
	DISPATCH_DEBUG_LOG("glPointParameterx(pname:0x%X, param:%d)", pname, param);
	GLDispatch::glPointParameterx_underlying(pname, param);
}

void glPointParameterxv_dispatchLoggingWrapper(GLenum pname, const GLfixed * params) {
	DISPATCH_DEBUG_LOG("glPointParameterxv(pname:0x%X, params:%p)", pname, params);
	GLDispatch::glPointParameterxv_underlying(pname, params);
}

void glPointSizex_dispatchLoggingWrapper(GLfixed size) {
	DISPATCH_DEBUG_LOG("glPointSizex(size:%d)", size);
	GLDispatch::glPointSizex_underlying(size);
}

void glPolygonOffsetx_dispatchLoggingWrapper(GLfixed factor, GLfixed units) {
	DISPATCH_DEBUG_LOG("glPolygonOffsetx(factor:%d, units:%d)", factor, units);
	GLDispatch::glPolygonOffsetx_underlying(factor, units);
}

void glRotatex_dispatchLoggingWrapper(GLfixed angle, GLfixed x, GLfixed y, GLfixed z) {
	DISPATCH_DEBUG_LOG("glRotatex(angle:%d, x:%d, y:%d, z:%d)", angle, x, y, z);
	GLDispatch::glRotatex_underlying(angle, x, y, z);
}

void glSampleCoveragex_dispatchLoggingWrapper(GLclampx value, GLboolean invert) {
	DISPATCH_DEBUG_LOG("glSampleCoveragex(value:%d, invert:%d)", value, invert);
	GLDispatch::glSampleCoveragex_underlying(value, invert);
}

void glScalex_dispatchLoggingWrapper(GLfixed x, GLfixed y, GLfixed z) {
	DISPATCH_DEBUG_LOG("glScalex(x:%d, y:%d, z:%d)", x, y, z);
	GLDispatch::glScalex_underlying(x, y, z);
}

void glTexEnvx_dispatchLoggingWrapper(GLenum target, GLenum pname, GLfixed param) {
	DISPATCH_DEBUG_LOG("glTexEnvx(target:0x%X, pname:0x%X, param:%d)", target, pname, param);
	GLDispatch::glTexEnvx_underlying(target, pname, param);
}

void glTexEnvxv_dispatchLoggingWrapper(GLenum target, GLenum pname, const GLfixed * params) {
	DISPATCH_DEBUG_LOG("glTexEnvxv(target:0x%X, pname:0x%X, params:%p)", target, pname, params);
	GLDispatch::glTexEnvxv_underlying(target, pname, params);
}

void glTexParameterx_dispatchLoggingWrapper(GLenum target, GLenum pname, GLfixed param) {
	DISPATCH_DEBUG_LOG("glTexParameterx(target:0x%X, pname:0x%X, param:%d)", target, pname, param);
	GLDispatch::glTexParameterx_underlying(target, pname, param);
}

void glTexParameterxv_dispatchLoggingWrapper(GLenum target, GLenum pname, const GLfixed * params) {
	DISPATCH_DEBUG_LOG("glTexParameterxv(target:0x%X, pname:0x%X, params:%p)", target, pname, params);
	GLDispatch::glTexParameterxv_underlying(target, pname, params);
}

void glTranslatex_dispatchLoggingWrapper(GLfixed x, GLfixed y, GLfixed z) {
	DISPATCH_DEBUG_LOG("glTranslatex(x:%d, y:%d, z:%d)", x, y, z);
	GLDispatch::glTranslatex_underlying(x, y, z);
}

void glGetClipPlanex_dispatchLoggingWrapper(GLenum pname, GLfixed eqn[4]) {
	DISPATCH_DEBUG_LOG("glGetClipPlanex(pname:0x%X, eqn[4]:%p)", pname, eqn);
	GLDispatch::glGetClipPlanex_underlying(pname, eqn);
}