/*
 * -- DO NOT EDIT --
 * Generated by dyngl.pl from ./tools/glfuncs.h
 */

void OSMesaDriver::nfglAccum(GLenum op, GLfloat value)
{
	D(bug("nfosmesa: glAccum(%s, %f)", gl_enum_name(op), value));
	fn.glAccum(op, value);
}

void OSMesaDriver::nfglAccumxOES(GLenum op, GLfixed value)
{
	D(bug("nfosmesa: glAccumxOES(%s, 0x%x)", gl_enum_name(op), value));
	fn.glAccumxOES(op, value);
}

GLboolean OSMesaDriver::nfglAcquireKeyedMutexWin32EXT(GLuint memory, GLuint64 key, GLuint timeout)
{
	D(bug("nfosmesa: glAcquireKeyedMutexWin32EXT(%u, %" PRIu64 ", %u)", memory, key, timeout));
	GLboolean __ret = fn.glAcquireKeyedMutexWin32EXT(memory, key, timeout);
	return __ret;
}

void OSMesaDriver::nfglActiveProgramEXT(GLuint program)
{
	D(bug("nfosmesa: glActiveProgramEXT(%u)", program));
	fn.glActiveProgramEXT(program);
}

void OSMesaDriver::nfglActiveShaderProgram(GLuint pipeline, GLuint program)
{
	D(bug("nfosmesa: glActiveShaderProgram(%u, %u)", pipeline, program));
	fn.glActiveShaderProgram(pipeline, program);
}

void OSMesaDriver::nfglActiveStencilFaceEXT(GLenum face)
{
	D(bug("nfosmesa: glActiveStencilFaceEXT(%s)", gl_enum_name(face)));
	fn.glActiveStencilFaceEXT(face);
}

void OSMesaDriver::nfglActiveTexture(GLenum texture)
{
	D(bug("nfosmesa: glActiveTexture(%s)", gl_enum_name(texture)));
	fn.glActiveTexture(texture);
}

void OSMesaDriver::nfglActiveTextureARB(GLenum texture)
{
	D(bug("nfosmesa: glActiveTextureARB(%s)", gl_enum_name(texture)));
	fn.glActiveTextureARB(texture);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglActiveVaryingNV(GLuint program, memptr name)
#else
void OSMesaDriver::nfglActiveVaryingNV(GLuint program, const GLchar *name)
#endif
{
	D(bug("nfosmesa: glActiveVaryingNV(%u, " PRI_PTR ")", program, AtariOffset(name)));
FN_GLACTIVEVARYINGNV(program, name);
}

void OSMesaDriver::nfglAddSwapHintRectWIN(GLint x, GLint y, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glAddSwapHintRectWIN(%d, %d, %d, %d)", x, y, width, height));
	fn.glAddSwapHintRectWIN(x, y, width, height);
}

void OSMesaDriver::nfglAlphaFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod)
{
	D(bug("nfosmesa: glAlphaFragmentOp1ATI(%s, %u, %u, %u, %u, %u)", gl_enum_name(op), dst, dstMod, arg1, arg1Rep, arg1Mod));
	fn.glAlphaFragmentOp1ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod);
}

void OSMesaDriver::nfglAlphaFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod)
{
	D(bug("nfosmesa: glAlphaFragmentOp2ATI(%s, %u, %u, %u, %u, %u, %u, %u, %u)", gl_enum_name(op), dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod));
	fn.glAlphaFragmentOp2ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
}

void OSMesaDriver::nfglAlphaFragmentOp3ATI(GLenum op, GLuint dst, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod)
{
	D(bug("nfosmesa: glAlphaFragmentOp3ATI(%s, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u)", gl_enum_name(op), dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod));
	fn.glAlphaFragmentOp3ATI(op, dst, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
}

void OSMesaDriver::nfglAlphaFunc(GLenum func, GLclampf ref)
{
	D(bug("nfosmesa: glAlphaFunc(%s, %f)", gl_enum_name(func), ref));
	fn.glAlphaFunc(func, ref);
}

void OSMesaDriver::nfglAlphaFuncxOES(GLenum func, GLfixed ref)
{
	D(bug("nfosmesa: glAlphaFuncxOES(%s, 0x%x)", gl_enum_name(func), ref));
	fn.glAlphaFuncxOES(func, ref);
}

void OSMesaDriver::nfglAlphaToCoverageDitherControlNV(GLenum mode)
{
	D(bug("nfosmesa: glAlphaToCoverageDitherControlNV(%s)", gl_enum_name(mode)));
	fn.glAlphaToCoverageDitherControlNV(mode);
}

void OSMesaDriver::nfglApplyFramebufferAttachmentCMAAINTEL(void)
{
	D(bug("nfosmesa: glApplyFramebufferAttachmentCMAAINTEL()"));
	fn.glApplyFramebufferAttachmentCMAAINTEL();
}

void OSMesaDriver::nfglApplyTextureEXT(GLenum mode)
{
	D(bug("nfosmesa: glApplyTextureEXT(%s)", gl_enum_name(mode)));
	fn.glApplyTextureEXT(mode);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLboolean OSMesaDriver::nfglAreProgramsResidentNV(GLsizei n, memptr programs, memptr residences)
#else
GLboolean OSMesaDriver::nfglAreProgramsResidentNV(GLsizei n, const GLuint *programs, GLboolean *residences)
#endif
{
	D(bug("nfosmesa: glAreProgramsResidentNV(%d, " PRI_PTR ", " PRI_PTR ")", n, AtariOffset(programs), AtariOffset(residences)));
FN_GLAREPROGRAMSRESIDENTNV(n, programs, residences);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLboolean OSMesaDriver::nfglAreTexturesResident(GLsizei n, memptr textures, memptr residences)
#else
GLboolean OSMesaDriver::nfglAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
#endif
{
	D(bug("nfosmesa: glAreTexturesResident(%d, " PRI_PTR ", " PRI_PTR ")", n, AtariOffset(textures), AtariOffset(residences)));
FN_GLARETEXTURESRESIDENT(n, textures, residences);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLboolean OSMesaDriver::nfglAreTexturesResidentEXT(GLsizei n, memptr textures, memptr residences)
#else
GLboolean OSMesaDriver::nfglAreTexturesResidentEXT(GLsizei n, const GLuint *textures, GLboolean *residences)
#endif
{
	D(bug("nfosmesa: glAreTexturesResidentEXT(%d, " PRI_PTR ", " PRI_PTR ")", n, AtariOffset(textures), AtariOffset(residences)));
FN_GLARETEXTURESRESIDENTEXT(n, textures, residences);
}

void OSMesaDriver::nfglArrayElement(GLint i)
{
	D(bug("nfosmesa: glArrayElement(%d)", i));
FN_GLARRAYELEMENT(i);
}

void OSMesaDriver::nfglArrayElementEXT(GLint i)
{
	D(bug("nfosmesa: glArrayElementEXT(%d)", i));
FN_GLARRAYELEMENTEXT(i);
}

void OSMesaDriver::nfglArrayObjectATI(GLenum array, GLint size, GLenum type, GLsizei stride, GLuint buffer, GLuint offset)
{
	D(bug("nfosmesa: glArrayObjectATI(%s, %d, %s, %d, %u, %u)", gl_enum_name(array), size, gl_enum_name(type), stride, buffer, offset));
FN_GLARRAYOBJECTATI(array, size, type, stride, buffer, offset);
}

void OSMesaDriver::nfglAsyncMarkerSGIX(GLuint marker)
{
	D(bug("nfosmesa: glAsyncMarkerSGIX(%u)", marker));
	fn.glAsyncMarkerSGIX(marker);
}

void OSMesaDriver::nfglAttachObjectARB(GLhandleARB containerObj, GLhandleARB obj)
{
	D(bug("nfosmesa: glAttachObjectARB(%u, %u)", (unsigned int)(uintptr_t)containerObj, (unsigned int)(uintptr_t)obj));
	fn.glAttachObjectARB(containerObj, obj);
}

void OSMesaDriver::nfglAttachShader(GLuint program, GLuint shader)
{
	D(bug("nfosmesa: glAttachShader(%u, %u)", program, shader));
	fn.glAttachShader(program, shader);
}

void OSMesaDriver::nfglBegin(GLenum mode)
{
	D(bug("nfosmesa: glBegin(%s)", gl_enum_name(mode)));
	fn.glBegin(mode);
}

void OSMesaDriver::nfglBeginConditionalRender(GLuint id, GLenum mode)
{
	D(bug("nfosmesa: glBeginConditionalRender(%u, %s)", id, gl_enum_name(mode)));
	fn.glBeginConditionalRender(id, mode);
}

void OSMesaDriver::nfglBeginConditionalRenderNV(GLuint id, GLenum mode)
{
	D(bug("nfosmesa: glBeginConditionalRenderNV(%u, %s)", id, gl_enum_name(mode)));
	fn.glBeginConditionalRenderNV(id, mode);
}

void OSMesaDriver::nfglBeginConditionalRenderNVX(GLuint id)
{
	D(bug("nfosmesa: glBeginConditionalRenderNVX(%u)", id));
	fn.glBeginConditionalRenderNVX(id);
}

void OSMesaDriver::nfglBeginFragmentShaderATI(void)
{
	D(bug("nfosmesa: glBeginFragmentShaderATI()"));
	fn.glBeginFragmentShaderATI();
}

void OSMesaDriver::nfglBeginOcclusionQueryNV(GLuint id)
{
	D(bug("nfosmesa: glBeginOcclusionQueryNV(%u)", id));
	fn.glBeginOcclusionQueryNV(id);
}

void OSMesaDriver::nfglBeginPerfMonitorAMD(GLuint monitor)
{
	D(bug("nfosmesa: glBeginPerfMonitorAMD(%u)", monitor));
	fn.glBeginPerfMonitorAMD(monitor);
}

void OSMesaDriver::nfglBeginPerfQueryINTEL(GLuint queryHandle)
{
	D(bug("nfosmesa: glBeginPerfQueryINTEL(%u)", queryHandle));
	fn.glBeginPerfQueryINTEL(queryHandle);
}

void OSMesaDriver::nfglBeginQuery(GLenum target, GLuint id)
{
	D(bug("nfosmesa: glBeginQuery(%s, %u)", gl_enum_name(target), id));
	fn.glBeginQuery(target, id);
}

void OSMesaDriver::nfglBeginQueryARB(GLenum target, GLuint id)
{
	D(bug("nfosmesa: glBeginQueryARB(%s, %u)", gl_enum_name(target), id));
	fn.glBeginQueryARB(target, id);
}

void OSMesaDriver::nfglBeginQueryIndexed(GLenum target, GLuint index, GLuint id)
{
	D(bug("nfosmesa: glBeginQueryIndexed(%s, %u, %u)", gl_enum_name(target), index, id));
	fn.glBeginQueryIndexed(target, index, id);
}

void OSMesaDriver::nfglBeginTransformFeedback(GLenum primitiveMode)
{
	D(bug("nfosmesa: glBeginTransformFeedback(%s)", gl_enum_name(primitiveMode)));
	fn.glBeginTransformFeedback(primitiveMode);
}

void OSMesaDriver::nfglBeginTransformFeedbackEXT(GLenum primitiveMode)
{
	D(bug("nfosmesa: glBeginTransformFeedbackEXT(%s)", gl_enum_name(primitiveMode)));
	fn.glBeginTransformFeedbackEXT(primitiveMode);
}

void OSMesaDriver::nfglBeginTransformFeedbackNV(GLenum primitiveMode)
{
	D(bug("nfosmesa: glBeginTransformFeedbackNV(%s)", gl_enum_name(primitiveMode)));
	fn.glBeginTransformFeedbackNV(primitiveMode);
}

void OSMesaDriver::nfglBeginVertexShaderEXT(void)
{
	D(bug("nfosmesa: glBeginVertexShaderEXT()"));
	fn.glBeginVertexShaderEXT();
}

void OSMesaDriver::nfglBeginVideoCaptureNV(GLuint video_capture_slot)
{
	D(bug("nfosmesa: glBeginVideoCaptureNV(%u)", video_capture_slot));
	fn.glBeginVideoCaptureNV(video_capture_slot);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBindAttribLocation(GLuint program, GLuint index, memptr name)
#else
void OSMesaDriver::nfglBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
#endif
{
	D(bug("nfosmesa: glBindAttribLocation(%u, %u, " PRI_PTR ")", program, index, AtariOffset(name)));
FN_GLBINDATTRIBLOCATION(program, index, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBindAttribLocationARB(GLhandleARB programObj, GLuint index, memptr name)
#else
void OSMesaDriver::nfglBindAttribLocationARB(GLhandleARB programObj, GLuint index, const GLcharARB *name)
#endif
{
	D(bug("nfosmesa: glBindAttribLocationARB(%u, %u, " PRI_PTR ")", (unsigned int)(uintptr_t)programObj, index, AtariOffset(name)));
FN_GLBINDATTRIBLOCATIONARB(programObj, index, name);
}

void OSMesaDriver::nfglBindBuffer(GLenum target, GLuint buffer)
{
	D(bug("nfosmesa: glBindBuffer(%s, %u)", gl_enum_name(target), buffer));
FN_GLBINDBUFFER(target, buffer);
}

void OSMesaDriver::nfglBindBufferARB(GLenum target, GLuint buffer)
{
	D(bug("nfosmesa: glBindBufferARB(%s, %u)", gl_enum_name(target), buffer));
FN_GLBINDBUFFERARB(target, buffer);
}

void OSMesaDriver::nfglBindBufferBase(GLenum target, GLuint index, GLuint buffer)
{
	D(bug("nfosmesa: glBindBufferBase(%s, %u, %u)", gl_enum_name(target), index, buffer));
FN_GLBINDBUFFERBASE(target, index, buffer);
}

void OSMesaDriver::nfglBindBufferBaseEXT(GLenum target, GLuint index, GLuint buffer)
{
	D(bug("nfosmesa: glBindBufferBaseEXT(%s, %u, %u)", gl_enum_name(target), index, buffer));
FN_GLBINDBUFFERBASEEXT(target, index, buffer);
}

void OSMesaDriver::nfglBindBufferBaseNV(GLenum target, GLuint index, GLuint buffer)
{
	D(bug("nfosmesa: glBindBufferBaseNV(%s, %u, %u)", gl_enum_name(target), index, buffer));
FN_GLBINDBUFFERBASENV(target, index, buffer);
}

void OSMesaDriver::nfglBindBufferOffsetEXT(GLenum target, GLuint index, GLuint buffer, GLintptr offset)
{
	D(bug("nfosmesa: glBindBufferOffsetEXT(%s, %u, %u, %" PRI_IPTR ")", gl_enum_name(target), index, buffer, offset));
	fn.glBindBufferOffsetEXT(target, index, buffer, offset);
}

void OSMesaDriver::nfglBindBufferOffsetNV(GLenum target, GLuint index, GLuint buffer, GLintptr offset)
{
	D(bug("nfosmesa: glBindBufferOffsetNV(%s, %u, %u, %" PRI_IPTR ")", gl_enum_name(target), index, buffer, offset));
	fn.glBindBufferOffsetNV(target, index, buffer, offset);
}

void OSMesaDriver::nfglBindBufferRange(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
	D(bug("nfosmesa: glBindBufferRange(%s, %u, %u, %" PRI_IPTR ", %" PRI_IPTR ")", gl_enum_name(target), index, buffer, offset, size));
FN_GLBINDBUFFERRANGE(target, index, buffer, offset, size);
}

void OSMesaDriver::nfglBindBufferRangeEXT(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
	D(bug("nfosmesa: glBindBufferRangeEXT(%s, %u, %u, %" PRI_IPTR ", %" PRI_IPTR ")", gl_enum_name(target), index, buffer, offset, size));
FN_GLBINDBUFFERRANGEEXT(target, index, buffer, offset, size);
}

void OSMesaDriver::nfglBindBufferRangeNV(GLenum target, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
	D(bug("nfosmesa: glBindBufferRangeNV(%s, %u, %u, %" PRI_IPTR ", %" PRI_IPTR ")", gl_enum_name(target), index, buffer, offset, size));
FN_GLBINDBUFFERRANGENV(target, index, buffer, offset, size);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBindBuffersBase(GLenum target, GLuint first, GLsizei count, memptr buffers)
#else
void OSMesaDriver::nfglBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint *buffers)
#endif
{
	D(bug("nfosmesa: glBindBuffersBase(%s, %u, %d, " PRI_PTR ")", gl_enum_name(target), first, count, AtariOffset(buffers)));
FN_GLBINDBUFFERSBASE(target, first, count, buffers);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBindBuffersRange(GLenum target, GLuint first, GLsizei count, memptr buffers, memptr offsets, memptr sizes)
#else
void OSMesaDriver::nfglBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes)
#endif
{
	D(bug("nfosmesa: glBindBuffersRange(%s, %u, %d, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", gl_enum_name(target), first, count, AtariOffset(buffers), AtariOffset(offsets), AtariOffset(sizes)));
FN_GLBINDBUFFERSRANGE(target, first, count, buffers, offsets, sizes);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBindFragDataLocation(GLuint program, GLuint color, memptr name)
#else
void OSMesaDriver::nfglBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
#endif
{
	D(bug("nfosmesa: glBindFragDataLocation(%u, %u, " PRI_PTR ")", program, color, AtariOffset(name)));
FN_GLBINDFRAGDATALOCATION(program, color, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBindFragDataLocationEXT(GLuint program, GLuint color, memptr name)
#else
void OSMesaDriver::nfglBindFragDataLocationEXT(GLuint program, GLuint color, const GLchar *name)
#endif
{
	D(bug("nfosmesa: glBindFragDataLocationEXT(%u, %u, " PRI_PTR ")", program, color, AtariOffset(name)));
FN_GLBINDFRAGDATALOCATIONEXT(program, color, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, memptr name)
#else
void OSMesaDriver::nfglBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
#endif
{
	D(bug("nfosmesa: glBindFragDataLocationIndexed(%u, %u, %u, " PRI_PTR ")", program, colorNumber, index, AtariOffset(name)));
FN_GLBINDFRAGDATALOCATIONINDEXED(program, colorNumber, index, name);
}

void OSMesaDriver::nfglBindFragmentShaderATI(GLuint id)
{
	D(bug("nfosmesa: glBindFragmentShaderATI(%u)", id));
	fn.glBindFragmentShaderATI(id);
}

void OSMesaDriver::nfglBindFramebuffer(GLenum target, GLuint framebuffer)
{
	D(bug("nfosmesa: glBindFramebuffer(%s, %u)", gl_enum_name(target), framebuffer));
	fn.glBindFramebuffer(target, framebuffer);
}

void OSMesaDriver::nfglBindFramebufferEXT(GLenum target, GLuint framebuffer)
{
	D(bug("nfosmesa: glBindFramebufferEXT(%s, %u)", gl_enum_name(target), framebuffer));
	fn.glBindFramebufferEXT(target, framebuffer);
}

void OSMesaDriver::nfglBindImageTexture(GLuint unit, GLuint texture, GLint level, GLboolean32 layered, GLint layer, GLenum access, GLenum format)
{
	D(bug("nfosmesa: glBindImageTexture(%u, %u, %d, %d, %d, %s, %s)", unit, texture, level, layered, layer, gl_enum_name(access), gl_enum_name(format)));
	fn.glBindImageTexture(unit, texture, level, layered, layer, access, format);
}

void OSMesaDriver::nfglBindImageTextureEXT(GLuint index, GLuint texture, GLint level, GLboolean32 layered, GLint layer, GLenum access, GLint format)
{
	D(bug("nfosmesa: glBindImageTextureEXT(%u, %u, %d, %d, %d, %s, %d)", index, texture, level, layered, layer, gl_enum_name(access), format));
	fn.glBindImageTextureEXT(index, texture, level, layered, layer, access, format);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBindImageTextures(GLuint first, GLsizei count, memptr textures)
#else
void OSMesaDriver::nfglBindImageTextures(GLuint first, GLsizei count, const GLuint *textures)
#endif
{
	D(bug("nfosmesa: glBindImageTextures(%u, %d, " PRI_PTR ")", first, count, AtariOffset(textures)));
FN_GLBINDIMAGETEXTURES(first, count, textures);
}

GLuint OSMesaDriver::nfglBindLightParameterEXT(GLenum light, GLenum value)
{
	D(bug("nfosmesa: glBindLightParameterEXT(%s, %s)", gl_enum_name(light), gl_enum_name(value)));
	GLuint __ret = fn.glBindLightParameterEXT(light, value);
	return __ret;
}

GLuint OSMesaDriver::nfglBindMaterialParameterEXT(GLenum face, GLenum value)
{
	D(bug("nfosmesa: glBindMaterialParameterEXT(%s, %s)", gl_enum_name(face), gl_enum_name(value)));
	GLuint __ret = fn.glBindMaterialParameterEXT(face, value);
	return __ret;
}

void OSMesaDriver::nfglBindMultiTextureEXT(GLenum texunit, GLenum target, GLuint texture)
{
	D(bug("nfosmesa: glBindMultiTextureEXT(%s, %s, %u)", gl_enum_name(texunit), gl_enum_name(target), texture));
	fn.glBindMultiTextureEXT(texunit, target, texture);
}

GLuint OSMesaDriver::nfglBindParameterEXT(GLenum value)
{
	D(bug("nfosmesa: glBindParameterEXT(%s)", gl_enum_name(value)));
	GLuint __ret = fn.glBindParameterEXT(value);
	return __ret;
}

void OSMesaDriver::nfglBindProgramARB(GLenum target, GLuint program)
{
	D(bug("nfosmesa: glBindProgramARB(%s, %u)", gl_enum_name(target), program));
	fn.glBindProgramARB(target, program);
}

void OSMesaDriver::nfglBindProgramNV(GLenum target, GLuint id)
{
	D(bug("nfosmesa: glBindProgramNV(%s, %u)", gl_enum_name(target), id));
	fn.glBindProgramNV(target, id);
}

void OSMesaDriver::nfglBindProgramPipeline(GLuint pipeline)
{
	D(bug("nfosmesa: glBindProgramPipeline(%u)", pipeline));
	fn.glBindProgramPipeline(pipeline);
}

void OSMesaDriver::nfglBindRenderbuffer(GLenum target, GLuint renderbuffer)
{
	D(bug("nfosmesa: glBindRenderbuffer(%s, %u)", gl_enum_name(target), renderbuffer));
	fn.glBindRenderbuffer(target, renderbuffer);
}

void OSMesaDriver::nfglBindRenderbufferEXT(GLenum target, GLuint renderbuffer)
{
	D(bug("nfosmesa: glBindRenderbufferEXT(%s, %u)", gl_enum_name(target), renderbuffer));
	fn.glBindRenderbufferEXT(target, renderbuffer);
}

void OSMesaDriver::nfglBindSampler(GLuint unit, GLuint sampler)
{
	D(bug("nfosmesa: glBindSampler(%u, %u)", unit, sampler));
	fn.glBindSampler(unit, sampler);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBindSamplers(GLuint first, GLsizei count, memptr samplers)
#else
void OSMesaDriver::nfglBindSamplers(GLuint first, GLsizei count, const GLuint *samplers)
#endif
{
	D(bug("nfosmesa: glBindSamplers(%u, %d, " PRI_PTR ")", first, count, AtariOffset(samplers)));
FN_GLBINDSAMPLERS(first, count, samplers);
}

GLuint OSMesaDriver::nfglBindTexGenParameterEXT(GLenum unit, GLenum coord, GLenum value)
{
	D(bug("nfosmesa: glBindTexGenParameterEXT(%s, %s, %s)", gl_enum_name(unit), gl_enum_name(coord), gl_enum_name(value)));
	GLuint __ret = fn.glBindTexGenParameterEXT(unit, coord, value);
	return __ret;
}

void OSMesaDriver::nfglBindTexture(GLenum target, GLuint texture)
{
	D(bug("nfosmesa: glBindTexture(%s, %u)", gl_enum_name(target), texture));
	fn.glBindTexture(target, texture);
}

void OSMesaDriver::nfglBindTextureEXT(GLenum target, GLuint texture)
{
	D(bug("nfosmesa: glBindTextureEXT(%s, %u)", gl_enum_name(target), texture));
	fn.glBindTextureEXT(target, texture);
}

void OSMesaDriver::nfglBindTextureUnit(GLuint unit, GLuint texture)
{
	D(bug("nfosmesa: glBindTextureUnit(%u, %u)", unit, texture));
	fn.glBindTextureUnit(unit, texture);
}

GLuint OSMesaDriver::nfglBindTextureUnitParameterEXT(GLenum unit, GLenum value)
{
	D(bug("nfosmesa: glBindTextureUnitParameterEXT(%s, %s)", gl_enum_name(unit), gl_enum_name(value)));
	GLuint __ret = fn.glBindTextureUnitParameterEXT(unit, value);
	return __ret;
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBindTextures(GLuint first, GLsizei count, memptr textures)
#else
void OSMesaDriver::nfglBindTextures(GLuint first, GLsizei count, const GLuint *textures)
#endif
{
	D(bug("nfosmesa: glBindTextures(%u, %d, " PRI_PTR ")", first, count, AtariOffset(textures)));
FN_GLBINDTEXTURES(first, count, textures);
}

void OSMesaDriver::nfglBindTransformFeedback(GLenum target, GLuint id)
{
	D(bug("nfosmesa: glBindTransformFeedback(%s, %u)", gl_enum_name(target), id));
	fn.glBindTransformFeedback(target, id);
}

void OSMesaDriver::nfglBindTransformFeedbackNV(GLenum target, GLuint id)
{
	D(bug("nfosmesa: glBindTransformFeedbackNV(%s, %u)", gl_enum_name(target), id));
	fn.glBindTransformFeedbackNV(target, id);
}

void OSMesaDriver::nfglBindVertexArray(GLuint array)
{
	D(bug("nfosmesa: glBindVertexArray(%u)", array));
	fn.glBindVertexArray(array);
}

void OSMesaDriver::nfglBindVertexArrayAPPLE(GLuint array)
{
	D(bug("nfosmesa: glBindVertexArrayAPPLE(%u)", array));
	fn.glBindVertexArrayAPPLE(array);
}

void OSMesaDriver::nfglBindVertexBuffer(GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
{
	D(bug("nfosmesa: glBindVertexBuffer(%u, %u, %" PRI_IPTR ", %d)", bindingindex, buffer, offset, stride));
FN_GLBINDVERTEXBUFFER(bindingindex, buffer, offset, stride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBindVertexBuffers(GLuint first, GLsizei count, memptr buffers, memptr offsets, memptr strides)
#else
void OSMesaDriver::nfglBindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
#endif
{
	D(bug("nfosmesa: glBindVertexBuffers(%u, %d, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", first, count, AtariOffset(buffers), AtariOffset(offsets), AtariOffset(strides)));
FN_GLBINDVERTEXBUFFERS(first, count, buffers, offsets, strides);
}

void OSMesaDriver::nfglBindVertexShaderEXT(GLuint id)
{
	D(bug("nfosmesa: glBindVertexShaderEXT(%u)", id));
	fn.glBindVertexShaderEXT(id);
}

void OSMesaDriver::nfglBindVideoCaptureStreamBufferNV(GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLintptrARB offset)
{
	D(bug("nfosmesa: glBindVideoCaptureStreamBufferNV(%u, %u, %s, %" PRI_IPTR ")", video_capture_slot, stream, gl_enum_name(frame_region), offset));
	fn.glBindVideoCaptureStreamBufferNV(video_capture_slot, stream, frame_region, offset);
}

void OSMesaDriver::nfglBindVideoCaptureStreamTextureNV(GLuint video_capture_slot, GLuint stream, GLenum frame_region, GLenum target, GLuint texture)
{
	D(bug("nfosmesa: glBindVideoCaptureStreamTextureNV(%u, %u, %s, %s, %u)", video_capture_slot, stream, gl_enum_name(frame_region), gl_enum_name(target), texture));
	fn.glBindVideoCaptureStreamTextureNV(video_capture_slot, stream, frame_region, target, texture);
}

void OSMesaDriver::nfglBinormal3bEXT(GLbyte32 bx, GLbyte32 by, GLbyte32 bz)
{
	D(bug("nfosmesa: glBinormal3bEXT(%d, %d, %d)", bx, by, bz));
	fn.glBinormal3bEXT(bx, by, bz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBinormal3bvEXT(memptr v)
#else
void OSMesaDriver::nfglBinormal3bvEXT(const GLbyte *v)
#endif
{
	D(bug("nfosmesa: glBinormal3bvEXT(" PRI_PTR ")", AtariOffset(v)));
FN_GLBINORMAL3BVEXT(v);
}

void OSMesaDriver::nfglBinormal3dEXT(GLdouble bx, GLdouble by, GLdouble bz)
{
	D(bug("nfosmesa: glBinormal3dEXT(%f, %f, %f)", bx, by, bz));
	fn.glBinormal3dEXT(bx, by, bz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBinormal3dvEXT(memptr v)
#else
void OSMesaDriver::nfglBinormal3dvEXT(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glBinormal3dvEXT(" PRI_PTR ")", AtariOffset(v)));
FN_GLBINORMAL3DVEXT(v);
}

void OSMesaDriver::nfglBinormal3fEXT(GLfloat bx, GLfloat by, GLfloat bz)
{
	D(bug("nfosmesa: glBinormal3fEXT(%f, %f, %f)", bx, by, bz));
	fn.glBinormal3fEXT(bx, by, bz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBinormal3fvEXT(memptr v)
#else
void OSMesaDriver::nfglBinormal3fvEXT(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glBinormal3fvEXT(" PRI_PTR ")", AtariOffset(v)));
FN_GLBINORMAL3FVEXT(v);
}

void OSMesaDriver::nfglBinormal3iEXT(GLint bx, GLint by, GLint bz)
{
	D(bug("nfosmesa: glBinormal3iEXT(%d, %d, %d)", bx, by, bz));
	fn.glBinormal3iEXT(bx, by, bz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBinormal3ivEXT(memptr v)
#else
void OSMesaDriver::nfglBinormal3ivEXT(const GLint *v)
#endif
{
	D(bug("nfosmesa: glBinormal3ivEXT(" PRI_PTR ")", AtariOffset(v)));
FN_GLBINORMAL3IVEXT(v);
}

void OSMesaDriver::nfglBinormal3sEXT(GLshort32 bx, GLshort32 by, GLshort32 bz)
{
	D(bug("nfosmesa: glBinormal3sEXT(%d, %d, %d)", bx, by, bz));
	fn.glBinormal3sEXT(bx, by, bz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBinormal3svEXT(memptr v)
#else
void OSMesaDriver::nfglBinormal3svEXT(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glBinormal3svEXT(" PRI_PTR ")", AtariOffset(v)));
FN_GLBINORMAL3SVEXT(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBinormalPointerEXT(GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglBinormalPointerEXT(GLenum type, GLsizei stride, const void *pointer)
#endif
{
	D(bug("nfosmesa: glBinormalPointerEXT(%s, %d, " PRI_PTR ")", gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLBINORMALPOINTEREXT(type, stride, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, memptr bitmap)
#else
void OSMesaDriver::nfglBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
#endif
{
	D(bug("nfosmesa: glBitmap(%d, %d, %f, %f, %f, %f, " PRI_PTR ")", width, height, xorig, yorig, xmove, ymove, AtariOffset(bitmap)));
FN_GLBITMAP(width, height, xorig, yorig, xmove, ymove, bitmap);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBitmapxOES(GLsizei width, GLsizei height, GLfixed xorig, GLfixed yorig, GLfixed xmove, GLfixed ymove, memptr bitmap)
#else
void OSMesaDriver::nfglBitmapxOES(GLsizei width, GLsizei height, GLfixed xorig, GLfixed yorig, GLfixed xmove, GLfixed ymove, const GLubyte *bitmap)
#endif
{
	D(bug("nfosmesa: glBitmapxOES(%d, %d, 0x%x, 0x%x, 0x%x, 0x%x, " PRI_PTR ")", width, height, xorig, yorig, xmove, ymove, AtariOffset(bitmap)));
FN_GLBITMAPXOES(width, height, xorig, yorig, xmove, ymove, bitmap);
}

void OSMesaDriver::nfglBlendBarrierKHR(void)
{
	D(bug("nfosmesa: glBlendBarrierKHR()"));
	fn.glBlendBarrierKHR();
}

void OSMesaDriver::nfglBlendBarrierNV(void)
{
	D(bug("nfosmesa: glBlendBarrierNV()"));
	fn.glBlendBarrierNV();
}

void OSMesaDriver::nfglBlendColor(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
	D(bug("nfosmesa: glBlendColor(%f, %f, %f, %f)", red, green, blue, alpha));
	fn.glBlendColor(red, green, blue, alpha);
}

void OSMesaDriver::nfglBlendColorEXT(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
	D(bug("nfosmesa: glBlendColorEXT(%f, %f, %f, %f)", red, green, blue, alpha));
	fn.glBlendColorEXT(red, green, blue, alpha);
}

void OSMesaDriver::nfglBlendColorxOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
{
	D(bug("nfosmesa: glBlendColorxOES(0x%x, 0x%x, 0x%x, 0x%x)", red, green, blue, alpha));
	fn.glBlendColorxOES(red, green, blue, alpha);
}

void OSMesaDriver::nfglBlendEquation(GLenum mode)
{
	D(bug("nfosmesa: glBlendEquation(%s)", gl_enum_name(mode)));
	fn.glBlendEquation(mode);
}

void OSMesaDriver::nfglBlendEquationEXT(GLenum mode)
{
	D(bug("nfosmesa: glBlendEquationEXT(%s)", gl_enum_name(mode)));
	fn.glBlendEquationEXT(mode);
}

void OSMesaDriver::nfglBlendEquationIndexedAMD(GLuint buf, GLenum mode)
{
	D(bug("nfosmesa: glBlendEquationIndexedAMD(%u, %s)", buf, gl_enum_name(mode)));
	fn.glBlendEquationIndexedAMD(buf, mode);
}

void OSMesaDriver::nfglBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha)
{
	D(bug("nfosmesa: glBlendEquationSeparate(%s, %s)", gl_enum_name(modeRGB), gl_enum_name(modeAlpha)));
	fn.glBlendEquationSeparate(modeRGB, modeAlpha);
}

void OSMesaDriver::nfglBlendEquationSeparateATI(GLenum equationRGB, GLenum equationAlpha)
{
	D(bug("nfosmesa: glBlendEquationSeparateATI(%s, %s)", gl_enum_name(equationRGB), gl_enum_name(equationAlpha)));
	fn.glBlendEquationSeparateATI(equationRGB, equationAlpha);
}

void OSMesaDriver::nfglBlendEquationSeparateEXT(GLenum modeRGB, GLenum modeAlpha)
{
	D(bug("nfosmesa: glBlendEquationSeparateEXT(%s, %s)", gl_enum_name(modeRGB), gl_enum_name(modeAlpha)));
	fn.glBlendEquationSeparateEXT(modeRGB, modeAlpha);
}

void OSMesaDriver::nfglBlendEquationSeparateIndexedAMD(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
{
	D(bug("nfosmesa: glBlendEquationSeparateIndexedAMD(%u, %s, %s)", buf, gl_enum_name(modeRGB), gl_enum_name(modeAlpha)));
	fn.glBlendEquationSeparateIndexedAMD(buf, modeRGB, modeAlpha);
}

void OSMesaDriver::nfglBlendEquationSeparatei(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
{
	D(bug("nfosmesa: glBlendEquationSeparatei(%u, %s, %s)", buf, gl_enum_name(modeRGB), gl_enum_name(modeAlpha)));
	fn.glBlendEquationSeparatei(buf, modeRGB, modeAlpha);
}

void OSMesaDriver::nfglBlendEquationSeparateiARB(GLuint buf, GLenum modeRGB, GLenum modeAlpha)
{
	D(bug("nfosmesa: glBlendEquationSeparateiARB(%u, %s, %s)", buf, gl_enum_name(modeRGB), gl_enum_name(modeAlpha)));
	fn.glBlendEquationSeparateiARB(buf, modeRGB, modeAlpha);
}

void OSMesaDriver::nfglBlendEquationi(GLuint buf, GLenum mode)
{
	D(bug("nfosmesa: glBlendEquationi(%u, %s)", buf, gl_enum_name(mode)));
	fn.glBlendEquationi(buf, mode);
}

void OSMesaDriver::nfglBlendEquationiARB(GLuint buf, GLenum mode)
{
	D(bug("nfosmesa: glBlendEquationiARB(%u, %s)", buf, gl_enum_name(mode)));
	fn.glBlendEquationiARB(buf, mode);
}

void OSMesaDriver::nfglBlendFunc(GLenum sfactor, GLenum dfactor)
{
	D(bug("nfosmesa: glBlendFunc(%s, %s)", gl_enum_name(sfactor), gl_enum_name(dfactor)));
	fn.glBlendFunc(sfactor, dfactor);
}

void OSMesaDriver::nfglBlendFuncIndexedAMD(GLuint buf, GLenum src, GLenum dst)
{
	D(bug("nfosmesa: glBlendFuncIndexedAMD(%u, %s, %s)", buf, gl_enum_name(src), gl_enum_name(dst)));
	fn.glBlendFuncIndexedAMD(buf, src, dst);
}

void OSMesaDriver::nfglBlendFuncSeparate(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
{
	D(bug("nfosmesa: glBlendFuncSeparate(%s, %s, %s, %s)", gl_enum_name(sfactorRGB), gl_enum_name(dfactorRGB), gl_enum_name(sfactorAlpha), gl_enum_name(dfactorAlpha)));
	fn.glBlendFuncSeparate(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}

void OSMesaDriver::nfglBlendFuncSeparateEXT(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
{
	D(bug("nfosmesa: glBlendFuncSeparateEXT(%s, %s, %s, %s)", gl_enum_name(sfactorRGB), gl_enum_name(dfactorRGB), gl_enum_name(sfactorAlpha), gl_enum_name(dfactorAlpha)));
	fn.glBlendFuncSeparateEXT(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}

void OSMesaDriver::nfglBlendFuncSeparateINGR(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
{
	D(bug("nfosmesa: glBlendFuncSeparateINGR(%s, %s, %s, %s)", gl_enum_name(sfactorRGB), gl_enum_name(dfactorRGB), gl_enum_name(sfactorAlpha), gl_enum_name(dfactorAlpha)));
	fn.glBlendFuncSeparateINGR(sfactorRGB, dfactorRGB, sfactorAlpha, dfactorAlpha);
}

void OSMesaDriver::nfglBlendFuncSeparateIndexedAMD(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
{
	D(bug("nfosmesa: glBlendFuncSeparateIndexedAMD(%u, %s, %s, %s, %s)", buf, gl_enum_name(srcRGB), gl_enum_name(dstRGB), gl_enum_name(srcAlpha), gl_enum_name(dstAlpha)));
	fn.glBlendFuncSeparateIndexedAMD(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}

void OSMesaDriver::nfglBlendFuncSeparatei(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
{
	D(bug("nfosmesa: glBlendFuncSeparatei(%u, %s, %s, %s, %s)", buf, gl_enum_name(srcRGB), gl_enum_name(dstRGB), gl_enum_name(srcAlpha), gl_enum_name(dstAlpha)));
	fn.glBlendFuncSeparatei(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}

void OSMesaDriver::nfglBlendFuncSeparateiARB(GLuint buf, GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha)
{
	D(bug("nfosmesa: glBlendFuncSeparateiARB(%u, %s, %s, %s, %s)", buf, gl_enum_name(srcRGB), gl_enum_name(dstRGB), gl_enum_name(srcAlpha), gl_enum_name(dstAlpha)));
	fn.glBlendFuncSeparateiARB(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}

void OSMesaDriver::nfglBlendFunci(GLuint buf, GLenum src, GLenum dst)
{
	D(bug("nfosmesa: glBlendFunci(%u, %s, %s)", buf, gl_enum_name(src), gl_enum_name(dst)));
	fn.glBlendFunci(buf, src, dst);
}

void OSMesaDriver::nfglBlendFunciARB(GLuint buf, GLenum src, GLenum dst)
{
	D(bug("nfosmesa: glBlendFunciARB(%u, %s, %s)", buf, gl_enum_name(src), gl_enum_name(dst)));
	fn.glBlendFunciARB(buf, src, dst);
}

void OSMesaDriver::nfglBlendParameteriNV(GLenum pname, GLint value)
{
	D(bug("nfosmesa: glBlendParameteriNV(%s, %d)", gl_enum_name(pname), value));
	fn.glBlendParameteriNV(pname, value);
}

void OSMesaDriver::nfglBlitFramebuffer(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
{
	D(bug("nfosmesa: glBlitFramebuffer(%d, %d, %d, %d, %d, %d, %d, %d, 0x%x, %s)", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, gl_enum_name(filter)));
	fn.glBlitFramebuffer(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}

void OSMesaDriver::nfglBlitFramebufferEXT(GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
{
	D(bug("nfosmesa: glBlitFramebufferEXT(%d, %d, %d, %d, %d, %d, %d, %d, 0x%x, %s)", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, gl_enum_name(filter)));
	fn.glBlitFramebufferEXT(srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}

void OSMesaDriver::nfglBlitNamedFramebuffer(GLuint readFramebuffer, GLuint drawFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
{
	D(bug("nfosmesa: glBlitNamedFramebuffer(%u, %u, %d, %d, %d, %d, %d, %d, %d, %d, 0x%x, %s)", readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, gl_enum_name(filter)));
	fn.glBlitNamedFramebuffer(readFramebuffer, drawFramebuffer, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}

void OSMesaDriver::nfglBufferAddressRangeNV(GLenum pname, GLuint index, GLuint64EXT address, GLsizeiptr length)
{
	D(bug("nfosmesa: glBufferAddressRangeNV(%s, %u, %" PRIu64 ", %" PRI_IPTR ")", gl_enum_name(pname), index, address, length));
	fn.glBufferAddressRangeNV(pname, index, address, length);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBufferData(GLenum target, GLsizeiptr size, memptr data, GLenum usage)
#else
void OSMesaDriver::nfglBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage)
#endif
{
	D(bug("nfosmesa: glBufferData(%s, %" PRI_IPTR ", " PRI_PTR ", %s)", gl_enum_name(target), size, AtariOffset(data), gl_enum_name(usage)));
FN_GLBUFFERDATA(target, size, data, usage);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBufferDataARB(GLenum target, GLsizeiptrARB size, memptr data, GLenum usage)
#else
void OSMesaDriver::nfglBufferDataARB(GLenum target, GLsizeiptrARB size, const void *data, GLenum usage)
#endif
{
	D(bug("nfosmesa: glBufferDataARB(%s, %" PRI_IPTR ", " PRI_PTR ", %s)", gl_enum_name(target), size, AtariOffset(data), gl_enum_name(usage)));
FN_GLBUFFERDATAARB(target, size, data, usage);
}

void OSMesaDriver::nfglBufferPageCommitmentARB(GLenum target, GLintptr offset, GLsizeiptr size, GLboolean32 commit)
{
	D(bug("nfosmesa: glBufferPageCommitmentARB(%s, %" PRI_IPTR ", %" PRI_IPTR ", %d)", gl_enum_name(target), offset, size, commit));
	fn.glBufferPageCommitmentARB(target, offset, size, commit);
}

void OSMesaDriver::nfglBufferParameteriAPPLE(GLenum target, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glBufferParameteriAPPLE(%s, %s, %d)", gl_enum_name(target), gl_enum_name(pname), param));
	fn.glBufferParameteriAPPLE(target, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBufferStorage(GLenum target, GLsizeiptr size, memptr data, GLbitfield flags)
#else
void OSMesaDriver::nfglBufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags)
#endif
{
	D(bug("nfosmesa: glBufferStorage(%s, %" PRI_IPTR ", " PRI_PTR ", 0x%x)", gl_enum_name(target), size, AtariOffset(data), flags));
FN_GLBUFFERSTORAGE(target, size, data, flags);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBufferStorageExternalEXT(GLenum target, GLintptr offset, GLsizeiptr size, memptr clientBuffer, GLbitfield flags)
#else
void OSMesaDriver::nfglBufferStorageExternalEXT(GLenum target, GLintptr offset, GLsizeiptr size, GLeglClientBufferEXT clientBuffer, GLbitfield flags)
#endif
{
	D(bug("nfosmesa: glBufferStorageExternalEXT(%s, %" PRI_IPTR ", %" PRI_IPTR ", " PRI_PTR ", 0x%x)", gl_enum_name(target), offset, size, AtariOffset(clientBuffer), flags));
FN_GLBUFFERSTORAGEEXTERNALEXT(target, offset, size, clientBuffer, flags);
}

void OSMesaDriver::nfglBufferStorageMemEXT(GLenum target, GLsizeiptr size, GLuint memory, GLuint64 offset)
{
	D(bug("nfosmesa: glBufferStorageMemEXT(%s, %" PRI_IPTR ", %u, %" PRIu64 ")", gl_enum_name(target), size, memory, offset));
	fn.glBufferStorageMemEXT(target, size, memory, offset);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, memptr data)
#else
void OSMesaDriver::nfglBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data)
#endif
{
	D(bug("nfosmesa: glBufferSubData(%s, %" PRI_IPTR ", %" PRI_IPTR ", " PRI_PTR ")", gl_enum_name(target), offset, size, AtariOffset(data)));
FN_GLBUFFERSUBDATA(target, offset, size, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, memptr data)
#else
void OSMesaDriver::nfglBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const void *data)
#endif
{
	D(bug("nfosmesa: glBufferSubDataARB(%s, %" PRI_IPTR ", %" PRI_IPTR ", " PRI_PTR ")", gl_enum_name(target), offset, size, AtariOffset(data)));
FN_GLBUFFERSUBDATAARB(target, offset, size, data);
}

void OSMesaDriver::nfglCallCommandListNV(GLuint list)
{
	D(bug("nfosmesa: glCallCommandListNV(%u)", list));
	fn.glCallCommandListNV(list);
}

void OSMesaDriver::nfglCallList(GLuint list)
{
	D(bug("nfosmesa: glCallList(%u)", list));
	fn.glCallList(list);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCallLists(GLsizei n, GLenum type, memptr lists)
#else
void OSMesaDriver::nfglCallLists(GLsizei n, GLenum type, const GLvoid *lists)
#endif
{
	D(bug("nfosmesa: glCallLists(%d, %s, " PRI_PTR ")", n, gl_enum_name(type), AtariOffset(lists)));
FN_GLCALLLISTS(n, type, lists);
}

GLenum OSMesaDriver::nfglCheckFramebufferStatus(GLenum target)
{
	D(bug("nfosmesa: glCheckFramebufferStatus(%s)", gl_enum_name(target)));
	GLenum __ret = fn.glCheckFramebufferStatus(target);
	return __ret;
}

GLenum OSMesaDriver::nfglCheckFramebufferStatusEXT(GLenum target)
{
	D(bug("nfosmesa: glCheckFramebufferStatusEXT(%s)", gl_enum_name(target)));
	GLenum __ret = fn.glCheckFramebufferStatusEXT(target);
	return __ret;
}

GLenum OSMesaDriver::nfglCheckNamedFramebufferStatus(GLuint framebuffer, GLenum target)
{
	D(bug("nfosmesa: glCheckNamedFramebufferStatus(%u, %s)", framebuffer, gl_enum_name(target)));
	GLenum __ret = fn.glCheckNamedFramebufferStatus(framebuffer, target);
	return __ret;
}

GLenum OSMesaDriver::nfglCheckNamedFramebufferStatusEXT(GLuint framebuffer, GLenum target)
{
	D(bug("nfosmesa: glCheckNamedFramebufferStatusEXT(%u, %s)", framebuffer, gl_enum_name(target)));
	GLenum __ret = fn.glCheckNamedFramebufferStatusEXT(framebuffer, target);
	return __ret;
}

void OSMesaDriver::nfglClampColor(GLenum target, GLenum clamp)
{
	D(bug("nfosmesa: glClampColor(%s, %s)", gl_enum_name(target), gl_enum_name(clamp)));
	fn.glClampColor(target, clamp);
}

void OSMesaDriver::nfglClampColorARB(GLenum target, GLenum clamp)
{
	D(bug("nfosmesa: glClampColorARB(%s, %s)", gl_enum_name(target), gl_enum_name(clamp)));
	fn.glClampColorARB(target, clamp);
}

void OSMesaDriver::nfglClear(GLbitfield mask)
{
	D(bug("nfosmesa: glClear(0x%x)", mask));
	fn.glClear(mask);
}

void OSMesaDriver::nfglClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
	D(bug("nfosmesa: glClearAccum(%f, %f, %f, %f)", red, green, blue, alpha));
	fn.glClearAccum(red, green, blue, alpha);
}

void OSMesaDriver::nfglClearAccumxOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
{
	D(bug("nfosmesa: glClearAccumxOES(0x%x, 0x%x, 0x%x, 0x%x)", red, green, blue, alpha));
	fn.glClearAccumxOES(red, green, blue, alpha);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, memptr data)
#else
void OSMesaDriver::nfglClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data)
#endif
{
	D(bug("nfosmesa: glClearBufferData(%s, %s, %s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(internalformat), gl_enum_name(format), gl_enum_name(type), AtariOffset(data)));
FN_GLCLEARBUFFERDATA(target, internalformat, format, type, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, memptr data)
#else
void OSMesaDriver::nfglClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
#endif
{
	D(bug("nfosmesa: glClearBufferSubData(%s, %s, %" PRI_IPTR ", %" PRI_IPTR ", %s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(internalformat), offset, size, gl_enum_name(format), gl_enum_name(type), AtariOffset(data)));
FN_GLCLEARBUFFERSUBDATA(target, internalformat, offset, size, format, type, data);
}

void OSMesaDriver::nfglClearBufferfi(GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
{
	D(bug("nfosmesa: glClearBufferfi(%s, %d, %f, %d)", gl_enum_name(buffer), drawbuffer, depth, stencil));
	fn.glClearBufferfi(buffer, drawbuffer, depth, stencil);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglClearBufferfv(GLenum buffer, GLint drawbuffer, memptr value)
#else
void OSMesaDriver::nfglClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glClearBufferfv(%s, %d, " PRI_PTR ")", gl_enum_name(buffer), drawbuffer, AtariOffset(value)));
FN_GLCLEARBUFFERFV(buffer, drawbuffer, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglClearBufferiv(GLenum buffer, GLint drawbuffer, memptr value)
#else
void OSMesaDriver::nfglClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
#endif
{
	D(bug("nfosmesa: glClearBufferiv(%s, %d, " PRI_PTR ")", gl_enum_name(buffer), drawbuffer, AtariOffset(value)));
FN_GLCLEARBUFFERIV(buffer, drawbuffer, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglClearBufferuiv(GLenum buffer, GLint drawbuffer, memptr value)
#else
void OSMesaDriver::nfglClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glClearBufferuiv(%s, %d, " PRI_PTR ")", gl_enum_name(buffer), drawbuffer, AtariOffset(value)));
FN_GLCLEARBUFFERUIV(buffer, drawbuffer, value);
}

void OSMesaDriver::nfglClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
	D(bug("nfosmesa: glClearColor(%f, %f, %f, %f)", red, green, blue, alpha));
	fn.glClearColor(red, green, blue, alpha);
}

void OSMesaDriver::nfglClearColorIiEXT(GLint red, GLint green, GLint blue, GLint alpha)
{
	D(bug("nfosmesa: glClearColorIiEXT(%d, %d, %d, %d)", red, green, blue, alpha));
	fn.glClearColorIiEXT(red, green, blue, alpha);
}

void OSMesaDriver::nfglClearColorIuiEXT(GLuint red, GLuint green, GLuint blue, GLuint alpha)
{
	D(bug("nfosmesa: glClearColorIuiEXT(%u, %u, %u, %u)", red, green, blue, alpha));
	fn.glClearColorIuiEXT(red, green, blue, alpha);
}

void OSMesaDriver::nfglClearColorxOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
{
	D(bug("nfosmesa: glClearColorxOES(0x%x, 0x%x, 0x%x, 0x%x)", red, green, blue, alpha));
	fn.glClearColorxOES(red, green, blue, alpha);
}

void OSMesaDriver::nfglClearDebugLogMESA(GLhandleARB obj, GLenum logType, GLenum shaderType)
{
	D(bug("nfosmesa: glClearDebugLogMESA(%u, %s, %s)", (unsigned int)(uintptr_t)obj, gl_enum_name(logType), gl_enum_name(shaderType)));
	fn.glClearDebugLogMESA(obj, logType, shaderType);
}

void OSMesaDriver::nfglClearDepth(GLclampd depth)
{
	D(bug("nfosmesa: glClearDepth(%f)", depth));
	fn.glClearDepth(depth);
}

void OSMesaDriver::nfglClearDepthdNV(GLdouble depth)
{
	D(bug("nfosmesa: glClearDepthdNV(%f)", depth));
	fn.glClearDepthdNV(depth);
}

void OSMesaDriver::nfglClearDepthf(GLfloat d)
{
	D(bug("nfosmesa: glClearDepthf(%f)", d));
	fn.glClearDepthf(d);
}

void OSMesaDriver::nfglClearDepthfOES(GLclampf depth)
{
	D(bug("nfosmesa: glClearDepthfOES(%f)", depth));
	fn.glClearDepthfOES(depth);
}

void OSMesaDriver::nfglClearDepthxOES(GLfixed depth)
{
	D(bug("nfosmesa: glClearDepthxOES(0x%x)", depth));
	fn.glClearDepthxOES(depth);
}

void OSMesaDriver::nfglClearIndex(GLfloat c)
{
	D(bug("nfosmesa: glClearIndex(%f)", c));
	fn.glClearIndex(c);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglClearNamedBufferData(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, memptr data)
#else
void OSMesaDriver::nfglClearNamedBufferData(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data)
#endif
{
	D(bug("nfosmesa: glClearNamedBufferData(%u, %s, %s, %s, " PRI_PTR ")", buffer, gl_enum_name(internalformat), gl_enum_name(format), gl_enum_name(type), AtariOffset(data)));
FN_GLCLEARNAMEDBUFFERDATA(buffer, internalformat, format, type, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglClearNamedBufferDataEXT(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, memptr data)
#else
void OSMesaDriver::nfglClearNamedBufferDataEXT(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data)
#endif
{
	D(bug("nfosmesa: glClearNamedBufferDataEXT(%u, %s, %s, %s, " PRI_PTR ")", buffer, gl_enum_name(internalformat), gl_enum_name(format), gl_enum_name(type), AtariOffset(data)));
FN_GLCLEARNAMEDBUFFERDATAEXT(buffer, internalformat, format, type, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglClearNamedBufferSubData(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, memptr data)
#else
void OSMesaDriver::nfglClearNamedBufferSubData(GLuint buffer, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
#endif
{
	D(bug("nfosmesa: glClearNamedBufferSubData(%u, %s, %" PRI_IPTR ", %" PRI_IPTR ", %s, %s, " PRI_PTR ")", buffer, gl_enum_name(internalformat), offset, size, gl_enum_name(format), gl_enum_name(type), AtariOffset(data)));
FN_GLCLEARNAMEDBUFFERSUBDATA(buffer, internalformat, offset, size, format, type, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglClearNamedBufferSubDataEXT(GLuint buffer, GLenum internalformat, GLsizeiptr offset, GLsizeiptr size, GLenum format, GLenum type, memptr data)
#else
void OSMesaDriver::nfglClearNamedBufferSubDataEXT(GLuint buffer, GLenum internalformat, GLsizeiptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
#endif
{
	D(bug("nfosmesa: glClearNamedBufferSubDataEXT(%u, %s, %" PRI_IPTR ", %" PRI_IPTR ", %s, %s, " PRI_PTR ")", buffer, gl_enum_name(internalformat), offset, size, gl_enum_name(format), gl_enum_name(type), AtariOffset(data)));
FN_GLCLEARNAMEDBUFFERSUBDATAEXT(buffer, internalformat, offset, size, format, type, data);
}

void OSMesaDriver::nfglClearNamedFramebufferfi(GLuint framebuffer, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil)
{
	D(bug("nfosmesa: glClearNamedFramebufferfi(%u, %s, %d, %f, %d)", framebuffer, gl_enum_name(buffer), drawbuffer, depth, stencil));
	fn.glClearNamedFramebufferfi(framebuffer, buffer, drawbuffer, depth, stencil);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglClearNamedFramebufferfv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, memptr value)
#else
void OSMesaDriver::nfglClearNamedFramebufferfv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glClearNamedFramebufferfv(%u, %s, %d, " PRI_PTR ")", framebuffer, gl_enum_name(buffer), drawbuffer, AtariOffset(value)));
FN_GLCLEARNAMEDFRAMEBUFFERFV(framebuffer, buffer, drawbuffer, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglClearNamedFramebufferiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, memptr value)
#else
void OSMesaDriver::nfglClearNamedFramebufferiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLint *value)
#endif
{
	D(bug("nfosmesa: glClearNamedFramebufferiv(%u, %s, %d, " PRI_PTR ")", framebuffer, gl_enum_name(buffer), drawbuffer, AtariOffset(value)));
FN_GLCLEARNAMEDFRAMEBUFFERIV(framebuffer, buffer, drawbuffer, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglClearNamedFramebufferuiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, memptr value)
#else
void OSMesaDriver::nfglClearNamedFramebufferuiv(GLuint framebuffer, GLenum buffer, GLint drawbuffer, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glClearNamedFramebufferuiv(%u, %s, %d, " PRI_PTR ")", framebuffer, gl_enum_name(buffer), drawbuffer, AtariOffset(value)));
FN_GLCLEARNAMEDFRAMEBUFFERUIV(framebuffer, buffer, drawbuffer, value);
}

void OSMesaDriver::nfglClearStencil(GLint s)
{
	D(bug("nfosmesa: glClearStencil(%d)", s));
	fn.glClearStencil(s);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, memptr data)
#else
void OSMesaDriver::nfglClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void *data)
#endif
{
	D(bug("nfosmesa: glClearTexImage(%u, %d, %s, %s, " PRI_PTR ")", texture, level, gl_enum_name(format), gl_enum_name(type), AtariOffset(data)));
FN_GLCLEARTEXIMAGE(texture, level, format, type, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglClearTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, memptr data)
#else
void OSMesaDriver::nfglClearTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *data)
#endif
{
	D(bug("nfosmesa: glClearTexSubImage(%u, %d, %d, %d, %d, %d, %d, %d, %s, %s, " PRI_PTR ")", texture, level, xoffset, yoffset, zoffset, width, height, depth, gl_enum_name(format), gl_enum_name(type), AtariOffset(data)));
FN_GLCLEARTEXSUBIMAGE(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
}

void OSMesaDriver::nfglClientActiveTexture(GLenum texture)
{
	D(bug("nfosmesa: glClientActiveTexture(%s)", gl_enum_name(texture)));
	fn.glClientActiveTexture(texture);
}

void OSMesaDriver::nfglClientActiveTextureARB(GLenum texture)
{
	D(bug("nfosmesa: glClientActiveTextureARB(%s)", gl_enum_name(texture)));
	fn.glClientActiveTextureARB(texture);
}

void OSMesaDriver::nfglClientActiveVertexStreamATI(GLenum stream)
{
	D(bug("nfosmesa: glClientActiveVertexStreamATI(%s)", gl_enum_name(stream)));
	fn.glClientActiveVertexStreamATI(stream);
}

void OSMesaDriver::nfglClientAttribDefaultEXT(GLbitfield mask)
{
	D(bug("nfosmesa: glClientAttribDefaultEXT(0x%x)", mask));
	fn.glClientAttribDefaultEXT(mask);
}

GLenum OSMesaDriver::nfglClientWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
{
	D(bug("nfosmesa: glClientWaitSync(" PRI_PTR ", 0x%x, %" PRIu64 ")", (unsigned int)(uintptr_t)sync, flags, timeout));
	GLenum __ret = fn.glClientWaitSync(sync, flags, timeout);
	return __ret;
}

void OSMesaDriver::nfglClipControl(GLenum origin, GLenum depth)
{
	D(bug("nfosmesa: glClipControl(%s, %s)", gl_enum_name(origin), gl_enum_name(depth)));
	fn.glClipControl(origin, depth);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglClipPlane(GLenum plane, memptr equation)
#else
void OSMesaDriver::nfglClipPlane(GLenum plane, const GLdouble *equation)
#endif
{
	D(bug("nfosmesa: glClipPlane(%s, " PRI_PTR ")", gl_enum_name(plane), AtariOffset(equation)));
FN_GLCLIPPLANE(plane, equation);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglClipPlanefOES(GLenum plane, memptr equation)
#else
void OSMesaDriver::nfglClipPlanefOES(GLenum plane, const GLfloat *equation)
#endif
{
	D(bug("nfosmesa: glClipPlanefOES(%s, " PRI_PTR ")", gl_enum_name(plane), AtariOffset(equation)));
FN_GLCLIPPLANEFOES(plane, equation);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglClipPlanexOES(GLenum plane, memptr equation)
#else
void OSMesaDriver::nfglClipPlanexOES(GLenum plane, const GLfixed *equation)
#endif
{
	D(bug("nfosmesa: glClipPlanexOES(%s, " PRI_PTR ")", gl_enum_name(plane), AtariOffset(equation)));
FN_GLCLIPPLANEXOES(plane, equation);
}

void OSMesaDriver::nfglColor3b(GLbyte32 red, GLbyte32 green, GLbyte32 blue)
{
	D(bug("nfosmesa: glColor3b(%d, %d, %d)", red, green, blue));
	fn.glColor3b(red, green, blue);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor3bv(memptr v)
#else
void OSMesaDriver::nfglColor3bv(const GLbyte *v)
#endif
{
	D(bug("nfosmesa: glColor3bv(" PRI_PTR ")", AtariOffset(v)));
FN_GLCOLOR3BV(v);
}

void OSMesaDriver::nfglColor3d(GLdouble red, GLdouble green, GLdouble blue)
{
	D(bug("nfosmesa: glColor3d(%f, %f, %f)", red, green, blue));
	fn.glColor3d(red, green, blue);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor3dv(memptr v)
#else
void OSMesaDriver::nfglColor3dv(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glColor3dv(" PRI_PTR ")", AtariOffset(v)));
FN_GLCOLOR3DV(v);
}

void OSMesaDriver::nfglColor3f(GLfloat red, GLfloat green, GLfloat blue)
{
	D(bug("nfosmesa: glColor3f(%f, %f, %f)", red, green, blue));
	fn.glColor3f(red, green, blue);
}

void OSMesaDriver::nfglColor3fVertex3fSUN(GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glColor3fVertex3fSUN(%f, %f, %f, %f, %f, %f)", r, g, b, x, y, z));
	fn.glColor3fVertex3fSUN(r, g, b, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor3fVertex3fvSUN(memptr c, memptr v)
#else
void OSMesaDriver::nfglColor3fVertex3fvSUN(const GLfloat *c, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glColor3fVertex3fvSUN(" PRI_PTR ", " PRI_PTR ")", AtariOffset(c), AtariOffset(v)));
FN_GLCOLOR3FVERTEX3FVSUN(c, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor3fv(memptr v)
#else
void OSMesaDriver::nfglColor3fv(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glColor3fv(" PRI_PTR ")", AtariOffset(v)));
FN_GLCOLOR3FV(v);
}

void OSMesaDriver::nfglColor3hNV(GLhalfNV32 red, GLhalfNV32 green, GLhalfNV32 blue)
{
	D(bug("nfosmesa: glColor3hNV(%u, %u, %u)", red, green, blue));
	fn.glColor3hNV(red, green, blue);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor3hvNV(memptr v)
#else
void OSMesaDriver::nfglColor3hvNV(const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glColor3hvNV(" PRI_PTR ")", AtariOffset(v)));
FN_GLCOLOR3HVNV(v);
}

void OSMesaDriver::nfglColor3i(GLint red, GLint green, GLint blue)
{
	D(bug("nfosmesa: glColor3i(%d, %d, %d)", red, green, blue));
	fn.glColor3i(red, green, blue);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor3iv(memptr v)
#else
void OSMesaDriver::nfglColor3iv(const GLint *v)
#endif
{
	D(bug("nfosmesa: glColor3iv(" PRI_PTR ")", AtariOffset(v)));
FN_GLCOLOR3IV(v);
}

void OSMesaDriver::nfglColor3s(GLshort32 red, GLshort32 green, GLshort32 blue)
{
	D(bug("nfosmesa: glColor3s(%d, %d, %d)", red, green, blue));
	fn.glColor3s(red, green, blue);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor3sv(memptr v)
#else
void OSMesaDriver::nfglColor3sv(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glColor3sv(" PRI_PTR ")", AtariOffset(v)));
FN_GLCOLOR3SV(v);
}

void OSMesaDriver::nfglColor3ub(GLubyte32 red, GLubyte32 green, GLubyte32 blue)
{
	D(bug("nfosmesa: glColor3ub(%u, %u, %u)", red, green, blue));
	fn.glColor3ub(red, green, blue);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor3ubv(memptr v)
#else
void OSMesaDriver::nfglColor3ubv(const GLubyte *v)
#endif
{
	D(bug("nfosmesa: glColor3ubv(" PRI_PTR ")", AtariOffset(v)));
FN_GLCOLOR3UBV(v);
}

void OSMesaDriver::nfglColor3ui(GLuint red, GLuint green, GLuint blue)
{
	D(bug("nfosmesa: glColor3ui(%u, %u, %u)", red, green, blue));
	fn.glColor3ui(red, green, blue);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor3uiv(memptr v)
#else
void OSMesaDriver::nfglColor3uiv(const GLuint *v)
#endif
{
	D(bug("nfosmesa: glColor3uiv(" PRI_PTR ")", AtariOffset(v)));
FN_GLCOLOR3UIV(v);
}

void OSMesaDriver::nfglColor3us(GLushort32 red, GLushort32 green, GLushort32 blue)
{
	D(bug("nfosmesa: glColor3us(%u, %u, %u)", red, green, blue));
	fn.glColor3us(red, green, blue);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor3usv(memptr v)
#else
void OSMesaDriver::nfglColor3usv(const GLushort *v)
#endif
{
	D(bug("nfosmesa: glColor3usv(" PRI_PTR ")", AtariOffset(v)));
FN_GLCOLOR3USV(v);
}

void OSMesaDriver::nfglColor3xOES(GLfixed red, GLfixed green, GLfixed blue)
{
	D(bug("nfosmesa: glColor3xOES(0x%x, 0x%x, 0x%x)", red, green, blue));
	fn.glColor3xOES(red, green, blue);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor3xvOES(memptr components)
#else
void OSMesaDriver::nfglColor3xvOES(const GLfixed *components)
#endif
{
	D(bug("nfosmesa: glColor3xvOES(" PRI_PTR ")", AtariOffset(components)));
FN_GLCOLOR3XVOES(components);
}

void OSMesaDriver::nfglColor4b(GLbyte32 red, GLbyte32 green, GLbyte32 blue, GLbyte32 alpha)
{
	D(bug("nfosmesa: glColor4b(%d, %d, %d, %d)", red, green, blue, alpha));
	fn.glColor4b(red, green, blue, alpha);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor4bv(memptr v)
#else
void OSMesaDriver::nfglColor4bv(const GLbyte *v)
#endif
{
	D(bug("nfosmesa: glColor4bv(" PRI_PTR ")", AtariOffset(v)));
FN_GLCOLOR4BV(v);
}

void OSMesaDriver::nfglColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
{
	D(bug("nfosmesa: glColor4d(%f, %f, %f, %f)", red, green, blue, alpha));
	fn.glColor4d(red, green, blue, alpha);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor4dv(memptr v)
#else
void OSMesaDriver::nfglColor4dv(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glColor4dv(" PRI_PTR ")", AtariOffset(v)));
FN_GLCOLOR4DV(v);
}

void OSMesaDriver::nfglColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
	D(bug("nfosmesa: glColor4f(%f, %f, %f, %f)", red, green, blue, alpha));
	fn.glColor4f(red, green, blue, alpha);
}

void OSMesaDriver::nfglColor4fNormal3fVertex3fSUN(GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glColor4fNormal3fVertex3fSUN(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f)", r, g, b, a, nx, ny, nz, x, y, z));
	fn.glColor4fNormal3fVertex3fSUN(r, g, b, a, nx, ny, nz, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor4fNormal3fVertex3fvSUN(memptr c, memptr n, memptr v)
#else
void OSMesaDriver::nfglColor4fNormal3fVertex3fvSUN(const GLfloat *c, const GLfloat *n, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glColor4fNormal3fVertex3fvSUN(" PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", AtariOffset(c), AtariOffset(n), AtariOffset(v)));
FN_GLCOLOR4FNORMAL3FVERTEX3FVSUN(c, n, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor4fv(memptr v)
#else
void OSMesaDriver::nfglColor4fv(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glColor4fv(" PRI_PTR ")", AtariOffset(v)));
FN_GLCOLOR4FV(v);
}

void OSMesaDriver::nfglColor4hNV(GLhalfNV32 red, GLhalfNV32 green, GLhalfNV32 blue, GLhalfNV32 alpha)
{
	D(bug("nfosmesa: glColor4hNV(%u, %u, %u, %u)", red, green, blue, alpha));
	fn.glColor4hNV(red, green, blue, alpha);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor4hvNV(memptr v)
#else
void OSMesaDriver::nfglColor4hvNV(const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glColor4hvNV(" PRI_PTR ")", AtariOffset(v)));
FN_GLCOLOR4HVNV(v);
}

void OSMesaDriver::nfglColor4i(GLint red, GLint green, GLint blue, GLint alpha)
{
	D(bug("nfosmesa: glColor4i(%d, %d, %d, %d)", red, green, blue, alpha));
	fn.glColor4i(red, green, blue, alpha);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor4iv(memptr v)
#else
void OSMesaDriver::nfglColor4iv(const GLint *v)
#endif
{
	D(bug("nfosmesa: glColor4iv(" PRI_PTR ")", AtariOffset(v)));
FN_GLCOLOR4IV(v);
}

void OSMesaDriver::nfglColor4s(GLshort32 red, GLshort32 green, GLshort32 blue, GLshort32 alpha)
{
	D(bug("nfosmesa: glColor4s(%d, %d, %d, %d)", red, green, blue, alpha));
	fn.glColor4s(red, green, blue, alpha);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor4sv(memptr v)
#else
void OSMesaDriver::nfglColor4sv(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glColor4sv(" PRI_PTR ")", AtariOffset(v)));
FN_GLCOLOR4SV(v);
}

void OSMesaDriver::nfglColor4ub(GLubyte32 red, GLubyte32 green, GLubyte32 blue, GLubyte32 alpha)
{
	D(bug("nfosmesa: glColor4ub(%u, %u, %u, %u)", red, green, blue, alpha));
	fn.glColor4ub(red, green, blue, alpha);
}

void OSMesaDriver::nfglColor4ubVertex2fSUN(GLubyte32 r, GLubyte32 g, GLubyte32 b, GLubyte32 a, GLfloat x, GLfloat y)
{
	D(bug("nfosmesa: glColor4ubVertex2fSUN(%u, %u, %u, %u, %f, %f)", r, g, b, a, x, y));
	fn.glColor4ubVertex2fSUN(r, g, b, a, x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor4ubVertex2fvSUN(memptr c, memptr v)
#else
void OSMesaDriver::nfglColor4ubVertex2fvSUN(const GLubyte *c, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glColor4ubVertex2fvSUN(" PRI_PTR ", " PRI_PTR ")", AtariOffset(c), AtariOffset(v)));
FN_GLCOLOR4UBVERTEX2FVSUN(c, v);
}

void OSMesaDriver::nfglColor4ubVertex3fSUN(GLubyte32 r, GLubyte32 g, GLubyte32 b, GLubyte32 a, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glColor4ubVertex3fSUN(%u, %u, %u, %u, %f, %f, %f)", r, g, b, a, x, y, z));
	fn.glColor4ubVertex3fSUN(r, g, b, a, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor4ubVertex3fvSUN(memptr c, memptr v)
#else
void OSMesaDriver::nfglColor4ubVertex3fvSUN(const GLubyte *c, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glColor4ubVertex3fvSUN(" PRI_PTR ", " PRI_PTR ")", AtariOffset(c), AtariOffset(v)));
FN_GLCOLOR4UBVERTEX3FVSUN(c, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor4ubv(memptr v)
#else
void OSMesaDriver::nfglColor4ubv(const GLubyte *v)
#endif
{
	D(bug("nfosmesa: glColor4ubv(" PRI_PTR ")", AtariOffset(v)));
FN_GLCOLOR4UBV(v);
}

void OSMesaDriver::nfglColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
{
	D(bug("nfosmesa: glColor4ui(%u, %u, %u, %u)", red, green, blue, alpha));
	fn.glColor4ui(red, green, blue, alpha);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor4uiv(memptr v)
#else
void OSMesaDriver::nfglColor4uiv(const GLuint *v)
#endif
{
	D(bug("nfosmesa: glColor4uiv(" PRI_PTR ")", AtariOffset(v)));
FN_GLCOLOR4UIV(v);
}

void OSMesaDriver::nfglColor4us(GLushort32 red, GLushort32 green, GLushort32 blue, GLushort32 alpha)
{
	D(bug("nfosmesa: glColor4us(%u, %u, %u, %u)", red, green, blue, alpha));
	fn.glColor4us(red, green, blue, alpha);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor4usv(memptr v)
#else
void OSMesaDriver::nfglColor4usv(const GLushort *v)
#endif
{
	D(bug("nfosmesa: glColor4usv(" PRI_PTR ")", AtariOffset(v)));
FN_GLCOLOR4USV(v);
}

void OSMesaDriver::nfglColor4xOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha)
{
	D(bug("nfosmesa: glColor4xOES(0x%x, 0x%x, 0x%x, 0x%x)", red, green, blue, alpha));
	fn.glColor4xOES(red, green, blue, alpha);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColor4xvOES(memptr components)
#else
void OSMesaDriver::nfglColor4xvOES(const GLfixed *components)
#endif
{
	D(bug("nfosmesa: glColor4xvOES(" PRI_PTR ")", AtariOffset(components)));
FN_GLCOLOR4XVOES(components);
}

void OSMesaDriver::nfglColorFormatNV(GLint size, GLenum type, GLsizei stride)
{
	D(bug("nfosmesa: glColorFormatNV(%d, %s, %d)", size, gl_enum_name(type), stride));
	fn.glColorFormatNV(size, type, stride);
}

void OSMesaDriver::nfglColorFragmentOp1ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod)
{
	D(bug("nfosmesa: glColorFragmentOp1ATI(%s, %u, %u, %u, %u, %u, %u)", gl_enum_name(op), dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod));
	fn.glColorFragmentOp1ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod);
}

void OSMesaDriver::nfglColorFragmentOp2ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod)
{
	D(bug("nfosmesa: glColorFragmentOp2ATI(%s, %u, %u, %u, %u, %u, %u, %u, %u, %u)", gl_enum_name(op), dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod));
	fn.glColorFragmentOp2ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod);
}

void OSMesaDriver::nfglColorFragmentOp3ATI(GLenum op, GLuint dst, GLuint dstMask, GLuint dstMod, GLuint arg1, GLuint arg1Rep, GLuint arg1Mod, GLuint arg2, GLuint arg2Rep, GLuint arg2Mod, GLuint arg3, GLuint arg3Rep, GLuint arg3Mod)
{
	D(bug("nfosmesa: glColorFragmentOp3ATI(%s, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u)", gl_enum_name(op), dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod));
	fn.glColorFragmentOp3ATI(op, dst, dstMask, dstMod, arg1, arg1Rep, arg1Mod, arg2, arg2Rep, arg2Mod, arg3, arg3Rep, arg3Mod);
}

void OSMesaDriver::nfglColorMask(GLboolean32 red, GLboolean32 green, GLboolean32 blue, GLboolean32 alpha)
{
	D(bug("nfosmesa: glColorMask(%d, %d, %d, %d)", red, green, blue, alpha));
	fn.glColorMask(red, green, blue, alpha);
}

void OSMesaDriver::nfglColorMaskIndexedEXT(GLuint index, GLboolean32 r, GLboolean32 g, GLboolean32 b, GLboolean32 a)
{
	D(bug("nfosmesa: glColorMaskIndexedEXT(%u, %d, %d, %d, %d)", index, r, g, b, a));
	fn.glColorMaskIndexedEXT(index, r, g, b, a);
}

void OSMesaDriver::nfglColorMaski(GLuint index, GLboolean32 r, GLboolean32 g, GLboolean32 b, GLboolean32 a)
{
	D(bug("nfosmesa: glColorMaski(%u, %d, %d, %d, %d)", index, r, g, b, a));
	fn.glColorMaski(index, r, g, b, a);
}

void OSMesaDriver::nfglColorMaterial(GLenum face, GLenum mode)
{
	D(bug("nfosmesa: glColorMaterial(%s, %s)", gl_enum_name(face), gl_enum_name(mode)));
	fn.glColorMaterial(face, mode);
}

void OSMesaDriver::nfglColorP3ui(GLenum type, GLuint color)
{
	D(bug("nfosmesa: glColorP3ui(%s, %u)", gl_enum_name(type), color));
	fn.glColorP3ui(type, color);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColorP3uiv(GLenum type, memptr color)
#else
void OSMesaDriver::nfglColorP3uiv(GLenum type, const GLuint *color)
#endif
{
	D(bug("nfosmesa: glColorP3uiv(%s, " PRI_PTR ")", gl_enum_name(type), AtariOffset(color)));
FN_GLCOLORP3UIV(type, color);
}

void OSMesaDriver::nfglColorP4ui(GLenum type, GLuint color)
{
	D(bug("nfosmesa: glColorP4ui(%s, %u)", gl_enum_name(type), color));
	fn.glColorP4ui(type, color);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColorP4uiv(GLenum type, memptr color)
#else
void OSMesaDriver::nfglColorP4uiv(GLenum type, const GLuint *color)
#endif
{
	D(bug("nfosmesa: glColorP4uiv(%s, " PRI_PTR ")", gl_enum_name(type), AtariOffset(color)));
FN_GLCOLORP4UIV(type, color);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColorPointer(GLint size, GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
#endif
{
	D(bug("nfosmesa: glColorPointer(%d, %s, %d, " PRI_PTR ")", size, gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLCOLORPOINTER(size, type, stride, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, memptr pointer)
#else
void OSMesaDriver::nfglColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer)
#endif
{
	D(bug("nfosmesa: glColorPointerEXT(%d, %s, %d, %d, " PRI_PTR ")", size, gl_enum_name(type), stride, count, AtariOffset(pointer)));
FN_GLCOLORPOINTEREXT(size, type, stride, count, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColorPointerListIBM(GLint size, GLenum type, GLint stride, memptr pointer, GLint ptrstride)
#else
void OSMesaDriver::nfglColorPointerListIBM(GLint size, GLenum type, GLint stride, const void * *pointer, GLint ptrstride)
#endif
{
	D(bug("nfosmesa: glColorPointerListIBM(%d, %s, %d, " PRI_PTR ", %d)", size, gl_enum_name(type), stride, AtariOffset(pointer), ptrstride));
FN_GLCOLORPOINTERLISTIBM(size, type, stride, pointer, ptrstride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColorPointervINTEL(GLint size, GLenum type, memptr pointer)
#else
void OSMesaDriver::nfglColorPointervINTEL(GLint size, GLenum type, const void * *pointer)
#endif
{
	D(bug("nfosmesa: glColorPointervINTEL(%d, %s, " PRI_PTR ")", size, gl_enum_name(type), AtariOffset(pointer)));
FN_GLCOLORPOINTERVINTEL(size, type, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, memptr data)
#else
void OSMesaDriver::nfglColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data)
#endif
{
	D(bug("nfosmesa: glColorSubTable(%s, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), start, count, gl_enum_name(format), gl_enum_name(type), AtariOffset(data)));
FN_GLCOLORSUBTABLE(target, start, count, format, type, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, memptr data)
#else
void OSMesaDriver::nfglColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data)
#endif
{
	D(bug("nfosmesa: glColorSubTableEXT(%s, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), start, count, gl_enum_name(format), gl_enum_name(type), AtariOffset(data)));
FN_GLCOLORSUBTABLEEXT(target, start, count, format, type, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, memptr table)
#else
void OSMesaDriver::nfglColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table)
#endif
{
	D(bug("nfosmesa: glColorTable(%s, %s, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(internalformat), width, gl_enum_name(format), gl_enum_name(type), AtariOffset(table)));
FN_GLCOLORTABLE(target, internalformat, width, format, type, table);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColorTableEXT(GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, memptr table)
#else
void OSMesaDriver::nfglColorTableEXT(GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const void *table)
#endif
{
	D(bug("nfosmesa: glColorTableEXT(%s, %s, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(internalFormat), width, gl_enum_name(format), gl_enum_name(type), AtariOffset(table)));
FN_GLCOLORTABLEEXT(target, internalFormat, width, format, type, table);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColorTableParameterfv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glColorTableParameterfv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLCOLORTABLEPARAMETERFV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColorTableParameterfvSGI(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglColorTableParameterfvSGI(GLenum target, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glColorTableParameterfvSGI(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLCOLORTABLEPARAMETERFVSGI(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColorTableParameteriv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glColorTableParameteriv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLCOLORTABLEPARAMETERIV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColorTableParameterivSGI(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglColorTableParameterivSGI(GLenum target, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glColorTableParameterivSGI(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLCOLORTABLEPARAMETERIVSGI(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglColorTableSGI(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, memptr table)
#else
void OSMesaDriver::nfglColorTableSGI(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table)
#endif
{
	D(bug("nfosmesa: glColorTableSGI(%s, %s, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(internalformat), width, gl_enum_name(format), gl_enum_name(type), AtariOffset(table)));
FN_GLCOLORTABLESGI(target, internalformat, width, format, type, table);
}

void OSMesaDriver::nfglCombinerInputNV(GLenum stage, GLenum portion, GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage)
{
	D(bug("nfosmesa: glCombinerInputNV(%s, %s, %s, %s, %s, %s)", gl_enum_name(stage), gl_enum_name(portion), gl_enum_name(variable), gl_enum_name(input), gl_enum_name(mapping), gl_enum_name(componentUsage)));
	fn.glCombinerInputNV(stage, portion, variable, input, mapping, componentUsage);
}

void OSMesaDriver::nfglCombinerOutputNV(GLenum stage, GLenum portion, GLenum abOutput, GLenum cdOutput, GLenum sumOutput, GLenum scale, GLenum bias, GLboolean32 abDotProduct, GLboolean32 cdDotProduct, GLboolean32 muxSum)
{
	D(bug("nfosmesa: glCombinerOutputNV(%s, %s, %s, %s, %s, %s, %s, %d, %d, %d)", gl_enum_name(stage), gl_enum_name(portion), gl_enum_name(abOutput), gl_enum_name(cdOutput), gl_enum_name(sumOutput), gl_enum_name(scale), gl_enum_name(bias), abDotProduct, cdDotProduct, muxSum));
	fn.glCombinerOutputNV(stage, portion, abOutput, cdOutput, sumOutput, scale, bias, abDotProduct, cdDotProduct, muxSum);
}

void OSMesaDriver::nfglCombinerParameterfNV(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glCombinerParameterfNV(%s, %f)", gl_enum_name(pname), param));
	fn.glCombinerParameterfNV(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCombinerParameterfvNV(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglCombinerParameterfvNV(GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glCombinerParameterfvNV(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLfloat __params_tmp[__params_size];
	GLfloat *__params_ptmp = Atari2HostFloatArray(__params_size, params, __params_tmp);
	fn.glCombinerParameterfvNV(pname, __params_ptmp);
#else
	fn.glCombinerParameterfvNV(pname, HostAddr(params, const GLfloat *));
#endif
}

void OSMesaDriver::nfglCombinerParameteriNV(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glCombinerParameteriNV(%s, %d)", gl_enum_name(pname), param));
	fn.glCombinerParameteriNV(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCombinerParameterivNV(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglCombinerParameterivNV(GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glCombinerParameterivNV(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLint __params_tmp[__params_size];
	GLint *__params_ptmp = Atari2HostIntArray(__params_size, params, __params_tmp);
	fn.glCombinerParameterivNV(pname, __params_ptmp);
#else
	fn.glCombinerParameterivNV(pname, HostAddr(params, const GLint *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCombinerStageParameterfvNV(GLenum stage, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglCombinerStageParameterfvNV(GLenum stage, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glCombinerStageParameterfvNV(%s, %s, " PRI_PTR ")", gl_enum_name(stage), gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLfloat __params_tmp[__params_size];
	GLfloat *__params_ptmp = Atari2HostFloatArray(__params_size, params, __params_tmp);
	fn.glCombinerStageParameterfvNV(stage, pname, __params_ptmp);
#else
	fn.glCombinerStageParameterfvNV(stage, pname, HostAddr(params, const GLfloat *));
#endif
}

void OSMesaDriver::nfglCommandListSegmentsNV(GLuint list, GLuint segments)
{
	D(bug("nfosmesa: glCommandListSegmentsNV(%u, %u)", list, segments));
	fn.glCommandListSegmentsNV(list, segments);
}

void OSMesaDriver::nfglCompileCommandListNV(GLuint list)
{
	D(bug("nfosmesa: glCompileCommandListNV(%u)", list));
	fn.glCompileCommandListNV(list);
}

void OSMesaDriver::nfglCompileShader(GLuint shader)
{
	D(bug("nfosmesa: glCompileShader(%u)", shader));
	fn.glCompileShader(shader);
}

void OSMesaDriver::nfglCompileShaderARB(GLhandleARB shaderObj)
{
	D(bug("nfosmesa: glCompileShaderARB(%u)", (unsigned int)(uintptr_t)shaderObj));
	fn.glCompileShaderARB(shaderObj);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompileShaderIncludeARB(GLuint shader, GLsizei count, memptr path, memptr length)
#else
void OSMesaDriver::nfglCompileShaderIncludeARB(GLuint shader, GLsizei count, const GLchar *const *path, const GLint *length)
#endif
{
	D(bug("nfosmesa: glCompileShaderIncludeARB(%u, %d, " PRI_PTR ", " PRI_PTR ")", shader, count, AtariOffset(path), AtariOffset(length)));
FN_GLCOMPILESHADERINCLUDEARB(shader, count, path, length);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, memptr bits)
#else
void OSMesaDriver::nfglCompressedMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits)
#endif
{
	D(bug("nfosmesa: glCompressedMultiTexImage1DEXT(%s, %s, %d, %s, %d, %d, %d, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), level, gl_enum_name(internalformat), width, border, imageSize, AtariOffset(bits)));
FN_GLCOMPRESSEDMULTITEXIMAGE1DEXT(texunit, target, level, internalformat, width, border, imageSize, bits);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, memptr bits)
#else
void OSMesaDriver::nfglCompressedMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits)
#endif
{
	D(bug("nfosmesa: glCompressedMultiTexImage2DEXT(%s, %s, %d, %s, %d, %d, %d, %d, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), level, gl_enum_name(internalformat), width, height, border, imageSize, AtariOffset(bits)));
FN_GLCOMPRESSEDMULTITEXIMAGE2DEXT(texunit, target, level, internalformat, width, height, border, imageSize, bits);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, memptr bits)
#else
void OSMesaDriver::nfglCompressedMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits)
#endif
{
	D(bug("nfosmesa: glCompressedMultiTexImage3DEXT(%s, %s, %d, %s, %d, %d, %d, %d, %d, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), level, gl_enum_name(internalformat), width, height, depth, border, imageSize, AtariOffset(bits)));
FN_GLCOMPRESSEDMULTITEXIMAGE3DEXT(texunit, target, level, internalformat, width, height, depth, border, imageSize, bits);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, memptr bits)
#else
void OSMesaDriver::nfglCompressedMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits)
#endif
{
	D(bug("nfosmesa: glCompressedMultiTexSubImage1DEXT(%s, %s, %d, %d, %d, %s, %d, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), level, xoffset, width, gl_enum_name(format), imageSize, AtariOffset(bits)));
FN_GLCOMPRESSEDMULTITEXSUBIMAGE1DEXT(texunit, target, level, xoffset, width, format, imageSize, bits);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, memptr bits)
#else
void OSMesaDriver::nfglCompressedMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits)
#endif
{
	D(bug("nfosmesa: glCompressedMultiTexSubImage2DEXT(%s, %s, %d, %d, %d, %d, %d, %s, %d, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), level, xoffset, yoffset, width, height, gl_enum_name(format), imageSize, AtariOffset(bits)));
FN_GLCOMPRESSEDMULTITEXSUBIMAGE2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, memptr bits)
#else
void OSMesaDriver::nfglCompressedMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *bits)
#endif
{
	D(bug("nfosmesa: glCompressedMultiTexSubImage3DEXT(%s, %s, %d, %d, %d, %d, %d, %d, %d, %s, %d, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), level, xoffset, yoffset, zoffset, width, height, depth, gl_enum_name(format), imageSize, AtariOffset(bits)));
FN_GLCOMPRESSEDMULTITEXSUBIMAGE3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, memptr data)
#else
void OSMesaDriver::nfglCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data)
#endif
{
	D(bug("nfosmesa: glCompressedTexImage1D(%s, %d, %s, %d, %d, %d, " PRI_PTR ")", gl_enum_name(target), level, gl_enum_name(internalformat), width, border, imageSize, AtariOffset(data)));
FN_GLCOMPRESSEDTEXIMAGE1D(target, level, internalformat, width, border, imageSize, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTexImage1DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, memptr data)
#else
void OSMesaDriver::nfglCompressedTexImage1DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data)
#endif
{
	D(bug("nfosmesa: glCompressedTexImage1DARB(%s, %d, %s, %d, %d, %d, " PRI_PTR ")", gl_enum_name(target), level, gl_enum_name(internalformat), width, border, imageSize, AtariOffset(data)));
FN_GLCOMPRESSEDTEXIMAGE1DARB(target, level, internalformat, width, border, imageSize, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, memptr data)
#else
void OSMesaDriver::nfglCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data)
#endif
{
	D(bug("nfosmesa: glCompressedTexImage2D(%s, %d, %s, %d, %d, %d, %d, " PRI_PTR ")", gl_enum_name(target), level, gl_enum_name(internalformat), width, height, border, imageSize, AtariOffset(data)));
FN_GLCOMPRESSEDTEXIMAGE2D(target, level, internalformat, width, height, border, imageSize, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTexImage2DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, memptr data)
#else
void OSMesaDriver::nfglCompressedTexImage2DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data)
#endif
{
	D(bug("nfosmesa: glCompressedTexImage2DARB(%s, %d, %s, %d, %d, %d, %d, " PRI_PTR ")", gl_enum_name(target), level, gl_enum_name(internalformat), width, height, border, imageSize, AtariOffset(data)));
FN_GLCOMPRESSEDTEXIMAGE2DARB(target, level, internalformat, width, height, border, imageSize, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, memptr data)
#else
void OSMesaDriver::nfglCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data)
#endif
{
	D(bug("nfosmesa: glCompressedTexImage3D(%s, %d, %s, %d, %d, %d, %d, %d, " PRI_PTR ")", gl_enum_name(target), level, gl_enum_name(internalformat), width, height, depth, border, imageSize, AtariOffset(data)));
FN_GLCOMPRESSEDTEXIMAGE3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTexImage3DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, memptr data)
#else
void OSMesaDriver::nfglCompressedTexImage3DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data)
#endif
{
	D(bug("nfosmesa: glCompressedTexImage3DARB(%s, %d, %s, %d, %d, %d, %d, %d, " PRI_PTR ")", gl_enum_name(target), level, gl_enum_name(internalformat), width, height, depth, border, imageSize, AtariOffset(data)));
FN_GLCOMPRESSEDTEXIMAGE3DARB(target, level, internalformat, width, height, depth, border, imageSize, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, memptr data)
#else
void OSMesaDriver::nfglCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
#endif
{
	D(bug("nfosmesa: glCompressedTexSubImage1D(%s, %d, %d, %d, %s, %d, " PRI_PTR ")", gl_enum_name(target), level, xoffset, width, gl_enum_name(format), imageSize, AtariOffset(data)));
FN_GLCOMPRESSEDTEXSUBIMAGE1D(target, level, xoffset, width, format, imageSize, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, memptr data)
#else
void OSMesaDriver::nfglCompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
#endif
{
	D(bug("nfosmesa: glCompressedTexSubImage1DARB(%s, %d, %d, %d, %s, %d, " PRI_PTR ")", gl_enum_name(target), level, xoffset, width, gl_enum_name(format), imageSize, AtariOffset(data)));
FN_GLCOMPRESSEDTEXSUBIMAGE1DARB(target, level, xoffset, width, format, imageSize, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, memptr data)
#else
void OSMesaDriver::nfglCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
#endif
{
	D(bug("nfosmesa: glCompressedTexSubImage2D(%s, %d, %d, %d, %d, %d, %s, %d, " PRI_PTR ")", gl_enum_name(target), level, xoffset, yoffset, width, height, gl_enum_name(format), imageSize, AtariOffset(data)));
FN_GLCOMPRESSEDTEXSUBIMAGE2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, memptr data)
#else
void OSMesaDriver::nfglCompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
#endif
{
	D(bug("nfosmesa: glCompressedTexSubImage2DARB(%s, %d, %d, %d, %d, %d, %s, %d, " PRI_PTR ")", gl_enum_name(target), level, xoffset, yoffset, width, height, gl_enum_name(format), imageSize, AtariOffset(data)));
FN_GLCOMPRESSEDTEXSUBIMAGE2DARB(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, memptr data)
#else
void OSMesaDriver::nfglCompressedTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)
#endif
{
	D(bug("nfosmesa: glCompressedTexSubImage3D(%s, %d, %d, %d, %d, %d, %d, %d, %s, %d, " PRI_PTR ")", gl_enum_name(target), level, xoffset, yoffset, zoffset, width, height, depth, gl_enum_name(format), imageSize, AtariOffset(data)));
FN_GLCOMPRESSEDTEXSUBIMAGE3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, memptr data)
#else
void OSMesaDriver::nfglCompressedTexSubImage3DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)
#endif
{
	D(bug("nfosmesa: glCompressedTexSubImage3DARB(%s, %d, %d, %d, %d, %d, %d, %d, %s, %d, " PRI_PTR ")", gl_enum_name(target), level, xoffset, yoffset, zoffset, width, height, depth, gl_enum_name(format), imageSize, AtariOffset(data)));
FN_GLCOMPRESSEDTEXSUBIMAGE3DARB(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, memptr bits)
#else
void OSMesaDriver::nfglCompressedTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits)
#endif
{
	D(bug("nfosmesa: glCompressedTextureImage1DEXT(%u, %s, %d, %s, %d, %d, %d, " PRI_PTR ")", texture, gl_enum_name(target), level, gl_enum_name(internalformat), width, border, imageSize, AtariOffset(bits)));
FN_GLCOMPRESSEDTEXTUREIMAGE1DEXT(texture, target, level, internalformat, width, border, imageSize, bits);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, memptr bits)
#else
void OSMesaDriver::nfglCompressedTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits)
#endif
{
	D(bug("nfosmesa: glCompressedTextureImage2DEXT(%u, %s, %d, %s, %d, %d, %d, %d, " PRI_PTR ")", texture, gl_enum_name(target), level, gl_enum_name(internalformat), width, height, border, imageSize, AtariOffset(bits)));
FN_GLCOMPRESSEDTEXTUREIMAGE2DEXT(texture, target, level, internalformat, width, height, border, imageSize, bits);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, memptr bits)
#else
void OSMesaDriver::nfglCompressedTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits)
#endif
{
	D(bug("nfosmesa: glCompressedTextureImage3DEXT(%u, %s, %d, %s, %d, %d, %d, %d, %d, " PRI_PTR ")", texture, gl_enum_name(target), level, gl_enum_name(internalformat), width, height, depth, border, imageSize, AtariOffset(bits)));
FN_GLCOMPRESSEDTEXTUREIMAGE3DEXT(texture, target, level, internalformat, width, height, depth, border, imageSize, bits);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, memptr data)
#else
void OSMesaDriver::nfglCompressedTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
#endif
{
	D(bug("nfosmesa: glCompressedTextureSubImage1D(%u, %d, %d, %d, %s, %d, " PRI_PTR ")", texture, level, xoffset, width, gl_enum_name(format), imageSize, AtariOffset(data)));
FN_GLCOMPRESSEDTEXTURESUBIMAGE1D(texture, level, xoffset, width, format, imageSize, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, memptr bits)
#else
void OSMesaDriver::nfglCompressedTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits)
#endif
{
	D(bug("nfosmesa: glCompressedTextureSubImage1DEXT(%u, %s, %d, %d, %d, %s, %d, " PRI_PTR ")", texture, gl_enum_name(target), level, xoffset, width, gl_enum_name(format), imageSize, AtariOffset(bits)));
FN_GLCOMPRESSEDTEXTURESUBIMAGE1DEXT(texture, target, level, xoffset, width, format, imageSize, bits);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, memptr data)
#else
void OSMesaDriver::nfglCompressedTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
#endif
{
	D(bug("nfosmesa: glCompressedTextureSubImage2D(%u, %d, %d, %d, %d, %d, %s, %d, " PRI_PTR ")", texture, level, xoffset, yoffset, width, height, gl_enum_name(format), imageSize, AtariOffset(data)));
FN_GLCOMPRESSEDTEXTURESUBIMAGE2D(texture, level, xoffset, yoffset, width, height, format, imageSize, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, memptr bits)
#else
void OSMesaDriver::nfglCompressedTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits)
#endif
{
	D(bug("nfosmesa: glCompressedTextureSubImage2DEXT(%u, %s, %d, %d, %d, %d, %d, %s, %d, " PRI_PTR ")", texture, gl_enum_name(target), level, xoffset, yoffset, width, height, gl_enum_name(format), imageSize, AtariOffset(bits)));
FN_GLCOMPRESSEDTEXTURESUBIMAGE2DEXT(texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, memptr data)
#else
void OSMesaDriver::nfglCompressedTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *data)
#endif
{
	D(bug("nfosmesa: glCompressedTextureSubImage3D(%u, %d, %d, %d, %d, %d, %d, %d, %s, %d, " PRI_PTR ")", texture, level, xoffset, yoffset, zoffset, width, height, depth, gl_enum_name(format), imageSize, AtariOffset(data)));
FN_GLCOMPRESSEDTEXTURESUBIMAGE3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCompressedTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, memptr bits)
#else
void OSMesaDriver::nfglCompressedTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLsizei imageSize, const void *bits)
#endif
{
	D(bug("nfosmesa: glCompressedTextureSubImage3DEXT(%u, %s, %d, %d, %d, %d, %d, %d, %d, %s, %d, " PRI_PTR ")", texture, gl_enum_name(target), level, xoffset, yoffset, zoffset, width, height, depth, gl_enum_name(format), imageSize, AtariOffset(bits)));
FN_GLCOMPRESSEDTEXTURESUBIMAGE3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
}

void OSMesaDriver::nfglConservativeRasterParameterfNV(GLenum pname, GLfloat value)
{
	D(bug("nfosmesa: glConservativeRasterParameterfNV(%s, %f)", gl_enum_name(pname), value));
	fn.glConservativeRasterParameterfNV(pname, value);
}

void OSMesaDriver::nfglConservativeRasterParameteriNV(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glConservativeRasterParameteriNV(%s, %d)", gl_enum_name(pname), param));
	fn.glConservativeRasterParameteriNV(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, memptr image)
#else
void OSMesaDriver::nfglConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image)
#endif
{
	D(bug("nfosmesa: glConvolutionFilter1D(%s, %s, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(internalformat), width, gl_enum_name(format), gl_enum_name(type), AtariOffset(image)));
FN_GLCONVOLUTIONFILTER1D(target, internalformat, width, format, type, image);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglConvolutionFilter1DEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, memptr image)
#else
void OSMesaDriver::nfglConvolutionFilter1DEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image)
#endif
{
	D(bug("nfosmesa: glConvolutionFilter1DEXT(%s, %s, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(internalformat), width, gl_enum_name(format), gl_enum_name(type), AtariOffset(image)));
FN_GLCONVOLUTIONFILTER1DEXT(target, internalformat, width, format, type, image);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, memptr image)
#else
void OSMesaDriver::nfglConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image)
#endif
{
	D(bug("nfosmesa: glConvolutionFilter2D(%s, %s, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(internalformat), width, height, gl_enum_name(format), gl_enum_name(type), AtariOffset(image)));
FN_GLCONVOLUTIONFILTER2D(target, internalformat, width, height, format, type, image);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglConvolutionFilter2DEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, memptr image)
#else
void OSMesaDriver::nfglConvolutionFilter2DEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image)
#endif
{
	D(bug("nfosmesa: glConvolutionFilter2DEXT(%s, %s, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(internalformat), width, height, gl_enum_name(format), gl_enum_name(type), AtariOffset(image)));
FN_GLCONVOLUTIONFILTER2DEXT(target, internalformat, width, height, format, type, image);
}

void OSMesaDriver::nfglConvolutionParameterf(GLenum target, GLenum pname, GLfloat params)
{
	D(bug("nfosmesa: glConvolutionParameterf(%s, %s, %f)", gl_enum_name(target), gl_enum_name(pname), params));
	fn.glConvolutionParameterf(target, pname, params);
}

void OSMesaDriver::nfglConvolutionParameterfEXT(GLenum target, GLenum pname, GLfloat params)
{
	D(bug("nfosmesa: glConvolutionParameterfEXT(%s, %s, %f)", gl_enum_name(target), gl_enum_name(pname), params));
	fn.glConvolutionParameterfEXT(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglConvolutionParameterfv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glConvolutionParameterfv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLCONVOLUTIONPARAMETERFV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglConvolutionParameterfvEXT(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglConvolutionParameterfvEXT(GLenum target, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glConvolutionParameterfvEXT(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLCONVOLUTIONPARAMETERFVEXT(target, pname, params);
}

void OSMesaDriver::nfglConvolutionParameteri(GLenum target, GLenum pname, GLint params)
{
	D(bug("nfosmesa: glConvolutionParameteri(%s, %s, %d)", gl_enum_name(target), gl_enum_name(pname), params));
	fn.glConvolutionParameteri(target, pname, params);
}

void OSMesaDriver::nfglConvolutionParameteriEXT(GLenum target, GLenum pname, GLint params)
{
	D(bug("nfosmesa: glConvolutionParameteriEXT(%s, %s, %d)", gl_enum_name(target), gl_enum_name(pname), params));
	fn.glConvolutionParameteriEXT(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglConvolutionParameteriv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glConvolutionParameteriv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLCONVOLUTIONPARAMETERIV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglConvolutionParameterivEXT(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglConvolutionParameterivEXT(GLenum target, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glConvolutionParameterivEXT(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLCONVOLUTIONPARAMETERIVEXT(target, pname, params);
}

void OSMesaDriver::nfglConvolutionParameterxOES(GLenum target, GLenum pname, GLfixed param)
{
	D(bug("nfosmesa: glConvolutionParameterxOES(%s, %s, 0x%x)", gl_enum_name(target), gl_enum_name(pname), param));
	fn.glConvolutionParameterxOES(target, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglConvolutionParameterxvOES(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglConvolutionParameterxvOES(GLenum target, GLenum pname, const GLfixed *params)
#endif
{
	D(bug("nfosmesa: glConvolutionParameterxvOES(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLCONVOLUTIONPARAMETERXVOES(target, pname, params);
}

void OSMesaDriver::nfglCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
{
	D(bug("nfosmesa: glCopyBufferSubData(%s, %s, %" PRI_IPTR ", %" PRI_IPTR ", %" PRI_IPTR ")", gl_enum_name(readTarget), gl_enum_name(writeTarget), readOffset, writeOffset, size));
	fn.glCopyBufferSubData(readTarget, writeTarget, readOffset, writeOffset, size);
}

void OSMesaDriver::nfglCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
{
	D(bug("nfosmesa: glCopyColorSubTable(%s, %d, %d, %d, %d)", gl_enum_name(target), start, x, y, width));
	fn.glCopyColorSubTable(target, start, x, y, width);
}

void OSMesaDriver::nfglCopyColorSubTableEXT(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
{
	D(bug("nfosmesa: glCopyColorSubTableEXT(%s, %d, %d, %d, %d)", gl_enum_name(target), start, x, y, width));
	fn.glCopyColorSubTableEXT(target, start, x, y, width);
}

void OSMesaDriver::nfglCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
{
	D(bug("nfosmesa: glCopyColorTable(%s, %s, %d, %d, %d)", gl_enum_name(target), gl_enum_name(internalformat), x, y, width));
	fn.glCopyColorTable(target, internalformat, x, y, width);
}

void OSMesaDriver::nfglCopyColorTableSGI(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
{
	D(bug("nfosmesa: glCopyColorTableSGI(%s, %s, %d, %d, %d)", gl_enum_name(target), gl_enum_name(internalformat), x, y, width));
	fn.glCopyColorTableSGI(target, internalformat, x, y, width);
}

void OSMesaDriver::nfglCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
{
	D(bug("nfosmesa: glCopyConvolutionFilter1D(%s, %s, %d, %d, %d)", gl_enum_name(target), gl_enum_name(internalformat), x, y, width));
	fn.glCopyConvolutionFilter1D(target, internalformat, x, y, width);
}

void OSMesaDriver::nfglCopyConvolutionFilter1DEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
{
	D(bug("nfosmesa: glCopyConvolutionFilter1DEXT(%s, %s, %d, %d, %d)", gl_enum_name(target), gl_enum_name(internalformat), x, y, width));
	fn.glCopyConvolutionFilter1DEXT(target, internalformat, x, y, width);
}

void OSMesaDriver::nfglCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glCopyConvolutionFilter2D(%s, %s, %d, %d, %d, %d)", gl_enum_name(target), gl_enum_name(internalformat), x, y, width, height));
	fn.glCopyConvolutionFilter2D(target, internalformat, x, y, width, height);
}

void OSMesaDriver::nfglCopyConvolutionFilter2DEXT(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glCopyConvolutionFilter2DEXT(%s, %s, %d, %d, %d, %d)", gl_enum_name(target), gl_enum_name(internalformat), x, y, width, height));
	fn.glCopyConvolutionFilter2DEXT(target, internalformat, x, y, width, height);
}

void OSMesaDriver::nfglCopyImageSubData(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
{
	D(bug("nfosmesa: glCopyImageSubData(%u, %s, %d, %d, %d, %d, %u, %s, %d, %d, %d, %d, %d, %d, %d)", srcName, gl_enum_name(srcTarget), srcLevel, srcX, srcY, srcZ, dstName, gl_enum_name(dstTarget), dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth));
	fn.glCopyImageSubData(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
}

void OSMesaDriver::nfglCopyImageSubDataNV(GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth)
{
	D(bug("nfosmesa: glCopyImageSubDataNV(%u, %s, %d, %d, %d, %d, %u, %s, %d, %d, %d, %d, %d, %d, %d)", srcName, gl_enum_name(srcTarget), srcLevel, srcX, srcY, srcZ, dstName, gl_enum_name(dstTarget), dstLevel, dstX, dstY, dstZ, width, height, depth));
	fn.glCopyImageSubDataNV(srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth);
}

void OSMesaDriver::nfglCopyMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
{
	D(bug("nfosmesa: glCopyMultiTexImage1DEXT(%s, %s, %d, %s, %d, %d, %d, %d)", gl_enum_name(texunit), gl_enum_name(target), level, gl_enum_name(internalformat), x, y, width, border));
	fn.glCopyMultiTexImage1DEXT(texunit, target, level, internalformat, x, y, width, border);
}

void OSMesaDriver::nfglCopyMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
	D(bug("nfosmesa: glCopyMultiTexImage2DEXT(%s, %s, %d, %s, %d, %d, %d, %d, %d)", gl_enum_name(texunit), gl_enum_name(target), level, gl_enum_name(internalformat), x, y, width, height, border));
	fn.glCopyMultiTexImage2DEXT(texunit, target, level, internalformat, x, y, width, height, border);
}

void OSMesaDriver::nfglCopyMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
{
	D(bug("nfosmesa: glCopyMultiTexSubImage1DEXT(%s, %s, %d, %d, %d, %d, %d)", gl_enum_name(texunit), gl_enum_name(target), level, xoffset, x, y, width));
	fn.glCopyMultiTexSubImage1DEXT(texunit, target, level, xoffset, x, y, width);
}

void OSMesaDriver::nfglCopyMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glCopyMultiTexSubImage2DEXT(%s, %s, %d, %d, %d, %d, %d, %d, %d)", gl_enum_name(texunit), gl_enum_name(target), level, xoffset, yoffset, x, y, width, height));
	fn.glCopyMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, x, y, width, height);
}

void OSMesaDriver::nfglCopyMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glCopyMultiTexSubImage3DEXT(%s, %s, %d, %d, %d, %d, %d, %d, %d, %d)", gl_enum_name(texunit), gl_enum_name(target), level, xoffset, yoffset, zoffset, x, y, width, height));
	fn.glCopyMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height);
}

void OSMesaDriver::nfglCopyNamedBufferSubData(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
{
	D(bug("nfosmesa: glCopyNamedBufferSubData(%u, %u, %" PRI_IPTR ", %" PRI_IPTR ", %" PRI_IPTR ")", readBuffer, writeBuffer, readOffset, writeOffset, size));
	fn.glCopyNamedBufferSubData(readBuffer, writeBuffer, readOffset, writeOffset, size);
}

void OSMesaDriver::nfglCopyPathNV(GLuint resultPath, GLuint srcPath)
{
	D(bug("nfosmesa: glCopyPathNV(%u, %u)", resultPath, srcPath));
	fn.glCopyPathNV(resultPath, srcPath);
}

void OSMesaDriver::nfglCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
{
	D(bug("nfosmesa: glCopyPixels(%d, %d, %d, %d, %s)", x, y, width, height, gl_enum_name(type)));
	fn.glCopyPixels(x, y, width, height, type);
}

void OSMesaDriver::nfglCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
{
	D(bug("nfosmesa: glCopyTexImage1D(%s, %d, %s, %d, %d, %d, %d)", gl_enum_name(target), level, gl_enum_name(internalformat), x, y, width, border));
	fn.glCopyTexImage1D(target, level, internalformat, x, y, width, border);
}

void OSMesaDriver::nfglCopyTexImage1DEXT(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
{
	D(bug("nfosmesa: glCopyTexImage1DEXT(%s, %d, %s, %d, %d, %d, %d)", gl_enum_name(target), level, gl_enum_name(internalformat), x, y, width, border));
	fn.glCopyTexImage1DEXT(target, level, internalformat, x, y, width, border);
}

void OSMesaDriver::nfglCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
	D(bug("nfosmesa: glCopyTexImage2D(%s, %d, %s, %d, %d, %d, %d, %d)", gl_enum_name(target), level, gl_enum_name(internalformat), x, y, width, height, border));
	fn.glCopyTexImage2D(target, level, internalformat, x, y, width, height, border);
}

void OSMesaDriver::nfglCopyTexImage2DEXT(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
	D(bug("nfosmesa: glCopyTexImage2DEXT(%s, %d, %s, %d, %d, %d, %d, %d)", gl_enum_name(target), level, gl_enum_name(internalformat), x, y, width, height, border));
	fn.glCopyTexImage2DEXT(target, level, internalformat, x, y, width, height, border);
}

void OSMesaDriver::nfglCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
{
	D(bug("nfosmesa: glCopyTexSubImage1D(%s, %d, %d, %d, %d, %d)", gl_enum_name(target), level, xoffset, x, y, width));
	fn.glCopyTexSubImage1D(target, level, xoffset, x, y, width);
}

void OSMesaDriver::nfglCopyTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
{
	D(bug("nfosmesa: glCopyTexSubImage1DEXT(%s, %d, %d, %d, %d, %d)", gl_enum_name(target), level, xoffset, x, y, width));
	fn.glCopyTexSubImage1DEXT(target, level, xoffset, x, y, width);
}

void OSMesaDriver::nfglCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glCopyTexSubImage2D(%s, %d, %d, %d, %d, %d, %d, %d)", gl_enum_name(target), level, xoffset, yoffset, x, y, width, height));
	fn.glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height);
}

void OSMesaDriver::nfglCopyTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glCopyTexSubImage2DEXT(%s, %d, %d, %d, %d, %d, %d, %d)", gl_enum_name(target), level, xoffset, yoffset, x, y, width, height));
	fn.glCopyTexSubImage2DEXT(target, level, xoffset, yoffset, x, y, width, height);
}

void OSMesaDriver::nfglCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glCopyTexSubImage3D(%s, %d, %d, %d, %d, %d, %d, %d, %d)", gl_enum_name(target), level, xoffset, yoffset, zoffset, x, y, width, height));
	fn.glCopyTexSubImage3D(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}

void OSMesaDriver::nfglCopyTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glCopyTexSubImage3DEXT(%s, %d, %d, %d, %d, %d, %d, %d, %d)", gl_enum_name(target), level, xoffset, yoffset, zoffset, x, y, width, height));
	fn.glCopyTexSubImage3DEXT(target, level, xoffset, yoffset, zoffset, x, y, width, height);
}

void OSMesaDriver::nfglCopyTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
{
	D(bug("nfosmesa: glCopyTextureImage1DEXT(%u, %s, %d, %s, %d, %d, %d, %d)", texture, gl_enum_name(target), level, gl_enum_name(internalformat), x, y, width, border));
	fn.glCopyTextureImage1DEXT(texture, target, level, internalformat, x, y, width, border);
}

void OSMesaDriver::nfglCopyTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
{
	D(bug("nfosmesa: glCopyTextureImage2DEXT(%u, %s, %d, %s, %d, %d, %d, %d, %d)", texture, gl_enum_name(target), level, gl_enum_name(internalformat), x, y, width, height, border));
	fn.glCopyTextureImage2DEXT(texture, target, level, internalformat, x, y, width, height, border);
}

void OSMesaDriver::nfglCopyTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
{
	D(bug("nfosmesa: glCopyTextureSubImage1D(%u, %d, %d, %d, %d, %d)", texture, level, xoffset, x, y, width));
	fn.glCopyTextureSubImage1D(texture, level, xoffset, x, y, width);
}

void OSMesaDriver::nfglCopyTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
{
	D(bug("nfosmesa: glCopyTextureSubImage1DEXT(%u, %s, %d, %d, %d, %d, %d)", texture, gl_enum_name(target), level, xoffset, x, y, width));
	fn.glCopyTextureSubImage1DEXT(texture, target, level, xoffset, x, y, width);
}

void OSMesaDriver::nfglCopyTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glCopyTextureSubImage2D(%u, %d, %d, %d, %d, %d, %d, %d)", texture, level, xoffset, yoffset, x, y, width, height));
	fn.glCopyTextureSubImage2D(texture, level, xoffset, yoffset, x, y, width, height);
}

void OSMesaDriver::nfglCopyTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glCopyTextureSubImage2DEXT(%u, %s, %d, %d, %d, %d, %d, %d, %d)", texture, gl_enum_name(target), level, xoffset, yoffset, x, y, width, height));
	fn.glCopyTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, x, y, width, height);
}

void OSMesaDriver::nfglCopyTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glCopyTextureSubImage3D(%u, %d, %d, %d, %d, %d, %d, %d, %d)", texture, level, xoffset, yoffset, zoffset, x, y, width, height));
	fn.glCopyTextureSubImage3D(texture, level, xoffset, yoffset, zoffset, x, y, width, height);
}

void OSMesaDriver::nfglCopyTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glCopyTextureSubImage3DEXT(%u, %s, %d, %d, %d, %d, %d, %d, %d, %d)", texture, gl_enum_name(target), level, xoffset, yoffset, zoffset, x, y, width, height));
	fn.glCopyTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, x, y, width, height);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCoverFillPathInstancedNV(GLsizei numPaths, GLenum pathNameType, memptr paths, GLuint pathBase, GLenum coverMode, GLenum transformType, memptr transformValues)
#else
void OSMesaDriver::nfglCoverFillPathInstancedNV(GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat *transformValues)
#endif
{
	D(bug("nfosmesa: glCoverFillPathInstancedNV(%d, %s, " PRI_PTR ", %u, %s, %s, " PRI_PTR ")", numPaths, gl_enum_name(pathNameType), AtariOffset(paths), pathBase, gl_enum_name(coverMode), gl_enum_name(transformType), AtariOffset(transformValues)));
FN_GLCOVERFILLPATHINSTANCEDNV(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
}

void OSMesaDriver::nfglCoverFillPathNV(GLuint path, GLenum coverMode)
{
	D(bug("nfosmesa: glCoverFillPathNV(%u, %s)", path, gl_enum_name(coverMode)));
	fn.glCoverFillPathNV(path, coverMode);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCoverStrokePathInstancedNV(GLsizei numPaths, GLenum pathNameType, memptr paths, GLuint pathBase, GLenum coverMode, GLenum transformType, memptr transformValues)
#else
void OSMesaDriver::nfglCoverStrokePathInstancedNV(GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat *transformValues)
#endif
{
	D(bug("nfosmesa: glCoverStrokePathInstancedNV(%d, %s, " PRI_PTR ", %u, %s, %s, " PRI_PTR ")", numPaths, gl_enum_name(pathNameType), AtariOffset(paths), pathBase, gl_enum_name(coverMode), gl_enum_name(transformType), AtariOffset(transformValues)));
FN_GLCOVERSTROKEPATHINSTANCEDNV(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
}

void OSMesaDriver::nfglCoverStrokePathNV(GLuint path, GLenum coverMode)
{
	D(bug("nfosmesa: glCoverStrokePathNV(%u, %s)", path, gl_enum_name(coverMode)));
	fn.glCoverStrokePathNV(path, coverMode);
}

void OSMesaDriver::nfglCoverageModulationNV(GLenum components)
{
	D(bug("nfosmesa: glCoverageModulationNV(%s)", gl_enum_name(components)));
	fn.glCoverageModulationNV(components);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCoverageModulationTableNV(GLsizei n, memptr v)
#else
void OSMesaDriver::nfglCoverageModulationTableNV(GLsizei n, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glCoverageModulationTableNV(%d, " PRI_PTR ")", n, AtariOffset(v)));
FN_GLCOVERAGEMODULATIONTABLENV(n, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCreateBuffers(GLsizei n, memptr buffers)
#else
void OSMesaDriver::nfglCreateBuffers(GLsizei n, GLuint *buffers)
#endif
{
	D(bug("nfosmesa: glCreateBuffers(%d, " PRI_PTR ")", n, AtariOffset(buffers)));
FN_GLCREATEBUFFERS(n, buffers);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCreateCommandListsNV(GLsizei n, memptr lists)
#else
void OSMesaDriver::nfglCreateCommandListsNV(GLsizei n, GLuint *lists)
#endif
{
	D(bug("nfosmesa: glCreateCommandListsNV(%d, " PRI_PTR ")", n, AtariOffset(lists)));
FN_GLCREATECOMMANDLISTSNV(n, lists);
}

GLhandleARB OSMesaDriver::nfglCreateDebugObjectMESA(void)
{
	D(bug("nfosmesa: glCreateDebugObjectMESA()"));
	GLhandleARB __ret = fn.glCreateDebugObjectMESA();
	return __ret;
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCreateFramebuffers(GLsizei n, memptr framebuffers)
#else
void OSMesaDriver::nfglCreateFramebuffers(GLsizei n, GLuint *framebuffers)
#endif
{
	D(bug("nfosmesa: glCreateFramebuffers(%d, " PRI_PTR ")", n, AtariOffset(framebuffers)));
FN_GLCREATEFRAMEBUFFERS(n, framebuffers);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCreateMemoryObjectsEXT(GLsizei n, memptr memoryObjects)
#else
void OSMesaDriver::nfglCreateMemoryObjectsEXT(GLsizei n, GLuint *memoryObjects)
#endif
{
	D(bug("nfosmesa: glCreateMemoryObjectsEXT(%d, " PRI_PTR ")", n, AtariOffset(memoryObjects)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __memoryObjects_size = MAX(n, 0);
	GLuint __memoryObjects_tmp[__memoryObjects_size];
	fn.glCreateMemoryObjectsEXT(n, __memoryObjects_tmp);
	Host2AtariIntArray(__memoryObjects_size, __memoryObjects_tmp, memoryObjects);
#else
	fn.glCreateMemoryObjectsEXT(n, HostAddr(memoryObjects, GLuint *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCreatePerfQueryINTEL(GLuint queryId, memptr queryHandle)
#else
void OSMesaDriver::nfglCreatePerfQueryINTEL(GLuint queryId, GLuint *queryHandle)
#endif
{
	D(bug("nfosmesa: glCreatePerfQueryINTEL(%u, " PRI_PTR ")", queryId, AtariOffset(queryHandle)));
FN_GLCREATEPERFQUERYINTEL(queryId, queryHandle);
}

GLuint OSMesaDriver::nfglCreateProgram(void)
{
	D(bug("nfosmesa: glCreateProgram()"));
	GLuint __ret = fn.glCreateProgram();
	return __ret;
}

GLhandleARB OSMesaDriver::nfglCreateProgramObjectARB(void)
{
	D(bug("nfosmesa: glCreateProgramObjectARB()"));
	GLhandleARB __ret = fn.glCreateProgramObjectARB();
	return __ret;
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCreateProgramPipelines(GLsizei n, memptr pipelines)
#else
void OSMesaDriver::nfglCreateProgramPipelines(GLsizei n, GLuint *pipelines)
#endif
{
	D(bug("nfosmesa: glCreateProgramPipelines(%d, " PRI_PTR ")", n, AtariOffset(pipelines)));
FN_GLCREATEPROGRAMPIPELINES(n, pipelines);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCreateQueries(GLenum target, GLsizei n, memptr ids)
#else
void OSMesaDriver::nfglCreateQueries(GLenum target, GLsizei n, GLuint *ids)
#endif
{
	D(bug("nfosmesa: glCreateQueries(%s, %d, " PRI_PTR ")", gl_enum_name(target), n, AtariOffset(ids)));
FN_GLCREATEQUERIES(target, n, ids);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCreateRenderbuffers(GLsizei n, memptr renderbuffers)
#else
void OSMesaDriver::nfglCreateRenderbuffers(GLsizei n, GLuint *renderbuffers)
#endif
{
	D(bug("nfosmesa: glCreateRenderbuffers(%d, " PRI_PTR ")", n, AtariOffset(renderbuffers)));
FN_GLCREATERENDERBUFFERS(n, renderbuffers);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCreateSamplers(GLsizei n, memptr samplers)
#else
void OSMesaDriver::nfglCreateSamplers(GLsizei n, GLuint *samplers)
#endif
{
	D(bug("nfosmesa: glCreateSamplers(%d, " PRI_PTR ")", n, AtariOffset(samplers)));
FN_GLCREATESAMPLERS(n, samplers);
}

GLuint OSMesaDriver::nfglCreateShader(GLenum type)
{
	D(bug("nfosmesa: glCreateShader(%s)", gl_enum_name(type)));
	GLuint __ret = fn.glCreateShader(type);
	return __ret;
}

GLhandleARB OSMesaDriver::nfglCreateShaderObjectARB(GLenum shaderType)
{
	D(bug("nfosmesa: glCreateShaderObjectARB(%s)", gl_enum_name(shaderType)));
	GLhandleARB __ret = fn.glCreateShaderObjectARB(shaderType);
	return __ret;
}

#if NFOSMESA_POINTER_AS_MEMARG
GLuint OSMesaDriver::nfglCreateShaderProgramEXT(GLenum type, memptr string)
#else
GLuint OSMesaDriver::nfglCreateShaderProgramEXT(GLenum type, const GLchar *string)
#endif
{
	D(bug("nfosmesa: glCreateShaderProgramEXT(%s, " PRI_PTR ")", gl_enum_name(type), AtariOffset(string)));
FN_GLCREATESHADERPROGRAMEXT(type, string);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLuint OSMesaDriver::nfglCreateShaderProgramv(GLenum type, GLsizei count, memptr strings)
#else
GLuint OSMesaDriver::nfglCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings)
#endif
{
	D(bug("nfosmesa: glCreateShaderProgramv(%s, %d, " PRI_PTR ")", gl_enum_name(type), count, AtariOffset(strings)));
FN_GLCREATESHADERPROGRAMV(type, count, strings);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCreateStatesNV(GLsizei n, memptr states)
#else
void OSMesaDriver::nfglCreateStatesNV(GLsizei n, GLuint *states)
#endif
{
	D(bug("nfosmesa: glCreateStatesNV(%d, " PRI_PTR ")", n, AtariOffset(states)));
FN_GLCREATESTATESNV(n, states);
}

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
GLsync OSMesaDriver::nfglCreateSyncFromCLeventARB(memptr context, memptr event, GLbitfield flags)
#else
GLsync OSMesaDriver::nfglCreateSyncFromCLeventARB(struct _cl_context *context, struct _cl_event *event, GLbitfield flags)
#endif
{
	D(bug("nfosmesa: glCreateSyncFromCLeventARB(" PRI_PTR ", " PRI_PTR ", 0x%x)", AtariOffset(context), AtariOffset(event), flags));
	GLsync __ret = fn.glCreateSyncFromCLeventARB(context, event, flags);
	return __ret;
}
#endif

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCreateTextures(GLenum target, GLsizei n, memptr textures)
#else
void OSMesaDriver::nfglCreateTextures(GLenum target, GLsizei n, GLuint *textures)
#endif
{
	D(bug("nfosmesa: glCreateTextures(%s, %d, " PRI_PTR ")", gl_enum_name(target), n, AtariOffset(textures)));
FN_GLCREATETEXTURES(target, n, textures);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCreateTransformFeedbacks(GLsizei n, memptr ids)
#else
void OSMesaDriver::nfglCreateTransformFeedbacks(GLsizei n, GLuint *ids)
#endif
{
	D(bug("nfosmesa: glCreateTransformFeedbacks(%d, " PRI_PTR ")", n, AtariOffset(ids)));
FN_GLCREATETRANSFORMFEEDBACKS(n, ids);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCreateVertexArrays(GLsizei n, memptr arrays)
#else
void OSMesaDriver::nfglCreateVertexArrays(GLsizei n, GLuint *arrays)
#endif
{
	D(bug("nfosmesa: glCreateVertexArrays(%d, " PRI_PTR ")", n, AtariOffset(arrays)));
FN_GLCREATEVERTEXARRAYS(n, arrays);
}

void OSMesaDriver::nfglCullFace(GLenum mode)
{
	D(bug("nfosmesa: glCullFace(%s)", gl_enum_name(mode)));
	fn.glCullFace(mode);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCullParameterdvEXT(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglCullParameterdvEXT(GLenum pname, GLdouble *params)
#endif
{
	D(bug("nfosmesa: glCullParameterdvEXT(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_DOUBLE_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLdouble __params_tmp[__params_size];
	GLdouble *__params_ptmp = Atari2HostDoubleArray(__params_size, params, __params_tmp);
	fn.glCullParameterdvEXT(pname, __params_ptmp);
#else
	fn.glCullParameterdvEXT(pname, HostAddr(params, GLdouble *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglCullParameterfvEXT(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglCullParameterfvEXT(GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glCullParameterfvEXT(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLfloat __params_tmp[__params_size];
	GLfloat *__params_ptmp = Atari2HostFloatArray(__params_size, params, __params_tmp);
	fn.glCullParameterfvEXT(pname, __params_ptmp);
#else
	fn.glCullParameterfvEXT(pname, HostAddr(params, GLfloat *));
#endif
}

void OSMesaDriver::nfglCurrentPaletteMatrixARB(GLint index)
{
	D(bug("nfosmesa: glCurrentPaletteMatrixARB(%d)", index));
	fn.glCurrentPaletteMatrixARB(index);
}

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDebugMessageCallback(memptr callback, memptr userParam)
#else
void OSMesaDriver::nfglDebugMessageCallback(GLDEBUGPROC callback, const void *userParam)
#endif
{
	D(bug("nfosmesa: glDebugMessageCallback(" PRI_PTR ", " PRI_PTR ")", AtariOffset(callback), AtariOffset(userParam)));
FN_GLDEBUGMESSAGECALLBACK(callback, userParam);
}
#endif

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDebugMessageCallbackAMD(memptr callback, memptr userParam)
#else
void OSMesaDriver::nfglDebugMessageCallbackAMD(GLDEBUGPROCAMD callback, void *userParam)
#endif
{
	D(bug("nfosmesa: glDebugMessageCallbackAMD(" PRI_PTR ", " PRI_PTR ")", AtariOffset(callback), AtariOffset(userParam)));
FN_GLDEBUGMESSAGECALLBACKAMD(callback, userParam);
}
#endif

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDebugMessageCallbackARB(memptr callback, memptr userParam)
#else
void OSMesaDriver::nfglDebugMessageCallbackARB(GLDEBUGPROCARB callback, const void *userParam)
#endif
{
	D(bug("nfosmesa: glDebugMessageCallbackARB(" PRI_PTR ", " PRI_PTR ")", AtariOffset(callback), AtariOffset(userParam)));
FN_GLDEBUGMESSAGECALLBACKARB(callback, userParam);
}
#endif

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, memptr ids, GLboolean32 enabled)
#else
void OSMesaDriver::nfglDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean32 enabled)
#endif
{
	D(bug("nfosmesa: glDebugMessageControl(%s, %s, %s, %d, " PRI_PTR ", %d)", gl_enum_name(source), gl_enum_name(type), gl_enum_name(severity), count, AtariOffset(ids), enabled));
FN_GLDEBUGMESSAGECONTROL(source, type, severity, count, ids, enabled);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDebugMessageControlARB(GLenum source, GLenum type, GLenum severity, GLsizei count, memptr ids, GLboolean32 enabled)
#else
void OSMesaDriver::nfglDebugMessageControlARB(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean32 enabled)
#endif
{
	D(bug("nfosmesa: glDebugMessageControlARB(%s, %s, %s, %d, " PRI_PTR ", %d)", gl_enum_name(source), gl_enum_name(type), gl_enum_name(severity), count, AtariOffset(ids), enabled));
#if NFOSMESA_NEED_INT_CONV
	GLint const __ids_size = MAX(count, 0);
	GLuint __ids_tmp[__ids_size];
	GLuint *__ids_ptmp = Atari2HostIntArray(__ids_size, ids, __ids_tmp);
	fn.glDebugMessageControlARB(source, type, severity, count, __ids_ptmp, enabled);
#else
	fn.glDebugMessageControlARB(source, type, severity, count, HostAddr(ids, const GLuint *), enabled);
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDebugMessageEnableAMD(GLenum category, GLenum severity, GLsizei count, memptr ids, GLboolean32 enabled)
#else
void OSMesaDriver::nfglDebugMessageEnableAMD(GLenum category, GLenum severity, GLsizei count, const GLuint *ids, GLboolean32 enabled)
#endif
{
	D(bug("nfosmesa: glDebugMessageEnableAMD(%s, %s, %d, " PRI_PTR ", %d)", gl_enum_name(category), gl_enum_name(severity), count, AtariOffset(ids), enabled));
#if NFOSMESA_NEED_INT_CONV
	GLint const __ids_size = MAX(count, 0);
	GLuint __ids_tmp[__ids_size];
	GLuint *__ids_ptmp = Atari2HostIntArray(__ids_size, ids, __ids_tmp);
	fn.glDebugMessageEnableAMD(category, severity, count, __ids_ptmp, enabled);
#else
	fn.glDebugMessageEnableAMD(category, severity, count, HostAddr(ids, const GLuint *), enabled);
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, memptr buf)
#else
void OSMesaDriver::nfglDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)
#endif
{
	D(bug("nfosmesa: glDebugMessageInsert(%s, %s, %u, %s, %d, " PRI_PTR ")", gl_enum_name(source), gl_enum_name(type), id, gl_enum_name(severity), length, AtariOffset(buf)));
FN_GLDEBUGMESSAGEINSERT(source, type, id, severity, length, buf);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDebugMessageInsertAMD(GLenum category, GLenum severity, GLuint id, GLsizei length, memptr buf)
#else
void OSMesaDriver::nfglDebugMessageInsertAMD(GLenum category, GLenum severity, GLuint id, GLsizei length, const GLchar *buf)
#endif
{
	D(bug("nfosmesa: glDebugMessageInsertAMD(%s, %s, %u, %d, " PRI_PTR ")", gl_enum_name(category), gl_enum_name(severity), id, length, AtariOffset(buf)));
#if NFOSMESA_NEED_BYTE_CONV
	GLint const __buf_size = length >= 0 ? length : safe_strlen(buf) + 1;
	GLchar __buf_tmp[__buf_size];
	GLchar *__buf_ptmp = Atari2HostByteArray(__buf_size, buf, __buf_tmp);
	fn.glDebugMessageInsertAMD(category, severity, id, length, __buf_ptmp);
#else
	fn.glDebugMessageInsertAMD(category, severity, id, length, HostAddr(buf, const GLchar *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDebugMessageInsertARB(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, memptr buf)
#else
void OSMesaDriver::nfglDebugMessageInsertARB(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)
#endif
{
	D(bug("nfosmesa: glDebugMessageInsertARB(%s, %s, %u, %s, %d, " PRI_PTR ")", gl_enum_name(source), gl_enum_name(type), id, gl_enum_name(severity), length, AtariOffset(buf)));
#if NFOSMESA_NEED_BYTE_CONV
	GLint const __buf_size = length >= 0 ? length : safe_strlen(buf) + 1;
	GLchar __buf_tmp[__buf_size];
	GLchar *__buf_ptmp = Atari2HostByteArray(__buf_size, buf, __buf_tmp);
	fn.glDebugMessageInsertARB(source, type, id, severity, length, __buf_ptmp);
#else
	fn.glDebugMessageInsertARB(source, type, id, severity, length, HostAddr(buf, const GLchar *));
#endif
}

void OSMesaDriver::nfglDeformSGIX(GLbitfield mask)
{
	D(bug("nfosmesa: glDeformSGIX(0x%x)", mask));
	fn.glDeformSGIX(mask);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeformationMap3dSGIX(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, memptr points)
#else
void OSMesaDriver::nfglDeformationMap3dSGIX(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, GLdouble w1, GLdouble w2, GLint wstride, GLint worder, const GLdouble *points)
#endif
{
	D(bug("nfosmesa: glDeformationMap3dSGIX(%s, %f, %f, %d, %d, %f, %f, %d, %d, %f, %f, %d, %d, " PRI_PTR ")", gl_enum_name(target), u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, AtariOffset(points)));
FN_GLDEFORMATIONMAP3DSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeformationMap3fSGIX(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, memptr points)
#else
void OSMesaDriver::nfglDeformationMap3fSGIX(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, GLfloat w1, GLfloat w2, GLint wstride, GLint worder, const GLfloat *points)
#endif
{
	D(bug("nfosmesa: glDeformationMap3fSGIX(%s, %f, %f, %d, %d, %f, %f, %d, %d, %f, %f, %d, %d, " PRI_PTR ")", gl_enum_name(target), u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, AtariOffset(points)));
FN_GLDEFORMATIONMAP3FSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
}

void OSMesaDriver::nfglDeleteAsyncMarkersSGIX(GLuint marker, GLsizei range)
{
	D(bug("nfosmesa: glDeleteAsyncMarkersSGIX(%u, %d)", marker, range));
	fn.glDeleteAsyncMarkersSGIX(marker, range);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteBuffers(GLsizei n, memptr buffers)
#else
void OSMesaDriver::nfglDeleteBuffers(GLsizei n, const GLuint *buffers)
#endif
{
	D(bug("nfosmesa: glDeleteBuffers(%d, " PRI_PTR ")", n, AtariOffset(buffers)));
FN_GLDELETEBUFFERS(n, buffers);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteBuffersARB(GLsizei n, memptr buffers)
#else
void OSMesaDriver::nfglDeleteBuffersARB(GLsizei n, const GLuint *buffers)
#endif
{
	D(bug("nfosmesa: glDeleteBuffersARB(%d, " PRI_PTR ")", n, AtariOffset(buffers)));
FN_GLDELETEBUFFERSARB(n, buffers);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteCommandListsNV(GLsizei n, memptr lists)
#else
void OSMesaDriver::nfglDeleteCommandListsNV(GLsizei n, const GLuint *lists)
#endif
{
	D(bug("nfosmesa: glDeleteCommandListsNV(%d, " PRI_PTR ")", n, AtariOffset(lists)));
FN_GLDELETECOMMANDLISTSNV(n, lists);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteFencesAPPLE(GLsizei n, memptr fences)
#else
void OSMesaDriver::nfglDeleteFencesAPPLE(GLsizei n, const GLuint *fences)
#endif
{
	D(bug("nfosmesa: glDeleteFencesAPPLE(%d, " PRI_PTR ")", n, AtariOffset(fences)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __fences_size = MAX(n, 0);
	GLuint __fences_tmp[__fences_size];
	GLuint *__fences_ptmp = Atari2HostIntArray(__fences_size, fences, __fences_tmp);
	fn.glDeleteFencesAPPLE(n, __fences_ptmp);
#else
	fn.glDeleteFencesAPPLE(n, HostAddr(fences, const GLuint *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteFencesNV(GLsizei n, memptr fences)
#else
void OSMesaDriver::nfglDeleteFencesNV(GLsizei n, const GLuint *fences)
#endif
{
	D(bug("nfosmesa: glDeleteFencesNV(%d, " PRI_PTR ")", n, AtariOffset(fences)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __fences_size = MAX(n, 0);
	GLuint __fences_tmp[__fences_size];
	GLuint *__fences_ptmp = Atari2HostIntArray(__fences_size, fences, __fences_tmp);
	fn.glDeleteFencesNV(n, __fences_ptmp);
#else
	fn.glDeleteFencesNV(n, HostAddr(fences, const GLuint *));
#endif
}

void OSMesaDriver::nfglDeleteFragmentShaderATI(GLuint id)
{
	D(bug("nfosmesa: glDeleteFragmentShaderATI(%u)", id));
	fn.glDeleteFragmentShaderATI(id);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteFramebuffers(GLsizei n, memptr framebuffers)
#else
void OSMesaDriver::nfglDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
#endif
{
	D(bug("nfosmesa: glDeleteFramebuffers(%d, " PRI_PTR ")", n, AtariOffset(framebuffers)));
FN_GLDELETEFRAMEBUFFERS(n, framebuffers);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteFramebuffersEXT(GLsizei n, memptr framebuffers)
#else
void OSMesaDriver::nfglDeleteFramebuffersEXT(GLsizei n, const GLuint *framebuffers)
#endif
{
	D(bug("nfosmesa: glDeleteFramebuffersEXT(%d, " PRI_PTR ")", n, AtariOffset(framebuffers)));
FN_GLDELETEFRAMEBUFFERSEXT(n, framebuffers);
}

void OSMesaDriver::nfglDeleteLists(GLuint list, GLsizei range)
{
	D(bug("nfosmesa: glDeleteLists(%u, %d)", list, range));
	fn.glDeleteLists(list, range);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteMemoryObjectsEXT(GLsizei n, memptr memoryObjects)
#else
void OSMesaDriver::nfglDeleteMemoryObjectsEXT(GLsizei n, const GLuint *memoryObjects)
#endif
{
	D(bug("nfosmesa: glDeleteMemoryObjectsEXT(%d, " PRI_PTR ")", n, AtariOffset(memoryObjects)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __memoryObjects_size = MAX(n, 0);
	GLuint __memoryObjects_tmp[__memoryObjects_size];
	GLuint *__memoryObjects_ptmp = Atari2HostIntArray(__memoryObjects_size, memoryObjects, __memoryObjects_tmp);
	fn.glDeleteMemoryObjectsEXT(n, __memoryObjects_ptmp);
#else
	fn.glDeleteMemoryObjectsEXT(n, HostAddr(memoryObjects, const GLuint *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteNamedStringARB(GLint namelen, memptr name)
#else
void OSMesaDriver::nfglDeleteNamedStringARB(GLint namelen, const GLchar *name)
#endif
{
	D(bug("nfosmesa: glDeleteNamedStringARB(%d, " PRI_PTR ")", namelen, AtariOffset(name)));
FN_GLDELETENAMEDSTRINGARB(namelen, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteNamesAMD(GLenum identifier, GLuint num, memptr names)
#else
void OSMesaDriver::nfglDeleteNamesAMD(GLenum identifier, GLuint num, const GLuint *names)
#endif
{
	D(bug("nfosmesa: glDeleteNamesAMD(%s, %u, " PRI_PTR ")", gl_enum_name(identifier), num, AtariOffset(names)));
FN_GLDELETENAMESAMD(identifier, num, names);
}

void OSMesaDriver::nfglDeleteObjectARB(GLhandleARB obj)
{
	D(bug("nfosmesa: glDeleteObjectARB(%u)", (unsigned int)(uintptr_t)obj));
	fn.glDeleteObjectARB(obj);
}

void OSMesaDriver::nfglDeleteObjectBufferATI(GLuint buffer)
{
	D(bug("nfosmesa: glDeleteObjectBufferATI(%u)", buffer));
FN_GLDELETEOBJECTBUFFERATI(buffer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteOcclusionQueriesNV(GLsizei n, memptr ids)
#else
void OSMesaDriver::nfglDeleteOcclusionQueriesNV(GLsizei n, const GLuint *ids)
#endif
{
	D(bug("nfosmesa: glDeleteOcclusionQueriesNV(%d, " PRI_PTR ")", n, AtariOffset(ids)));
FN_GLDELETEOCCLUSIONQUERIESNV(n, ids);
}

void OSMesaDriver::nfglDeletePathsNV(GLuint path, GLsizei range)
{
	D(bug("nfosmesa: glDeletePathsNV(%u, %d)", path, range));
	fn.glDeletePathsNV(path, range);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeletePerfMonitorsAMD(GLsizei n, memptr monitors)
#else
void OSMesaDriver::nfglDeletePerfMonitorsAMD(GLsizei n, GLuint *monitors)
#endif
{
	D(bug("nfosmesa: glDeletePerfMonitorsAMD(%d, " PRI_PTR ")", n, AtariOffset(monitors)));
FN_GLDELETEPERFMONITORSAMD(n, monitors);
}

void OSMesaDriver::nfglDeletePerfQueryINTEL(GLuint queryHandle)
{
	D(bug("nfosmesa: glDeletePerfQueryINTEL(%u)", queryHandle));
	fn.glDeletePerfQueryINTEL(queryHandle);
}

void OSMesaDriver::nfglDeleteProgram(GLuint program)
{
	D(bug("nfosmesa: glDeleteProgram(%u)", program));
	fn.glDeleteProgram(program);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteProgramPipelines(GLsizei n, memptr pipelines)
#else
void OSMesaDriver::nfglDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
#endif
{
	D(bug("nfosmesa: glDeleteProgramPipelines(%d, " PRI_PTR ")", n, AtariOffset(pipelines)));
FN_GLDELETEPROGRAMPIPELINES(n, pipelines);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteProgramsARB(GLsizei n, memptr programs)
#else
void OSMesaDriver::nfglDeleteProgramsARB(GLsizei n, const GLuint *programs)
#endif
{
	D(bug("nfosmesa: glDeleteProgramsARB(%d, " PRI_PTR ")", n, AtariOffset(programs)));
FN_GLDELETEPROGRAMSARB(n, programs);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteProgramsNV(GLsizei n, memptr programs)
#else
void OSMesaDriver::nfglDeleteProgramsNV(GLsizei n, const GLuint *programs)
#endif
{
	D(bug("nfosmesa: glDeleteProgramsNV(%d, " PRI_PTR ")", n, AtariOffset(programs)));
FN_GLDELETEPROGRAMSNV(n, programs);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteQueries(GLsizei n, memptr ids)
#else
void OSMesaDriver::nfglDeleteQueries(GLsizei n, const GLuint *ids)
#endif
{
	D(bug("nfosmesa: glDeleteQueries(%d, " PRI_PTR ")", n, AtariOffset(ids)));
FN_GLDELETEQUERIES(n, ids);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteQueriesARB(GLsizei n, memptr ids)
#else
void OSMesaDriver::nfglDeleteQueriesARB(GLsizei n, const GLuint *ids)
#endif
{
	D(bug("nfosmesa: glDeleteQueriesARB(%d, " PRI_PTR ")", n, AtariOffset(ids)));
FN_GLDELETEQUERIESARB(n, ids);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteQueryResourceTagNV(GLsizei n, memptr tagIds)
#else
void OSMesaDriver::nfglDeleteQueryResourceTagNV(GLsizei n, const GLint *tagIds)
#endif
{
	D(bug("nfosmesa: glDeleteQueryResourceTagNV(%d, " PRI_PTR ")", n, AtariOffset(tagIds)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __tagIds_size = MAX(n, 0);
	GLint __tagIds_tmp[__tagIds_size];
	GLint *__tagIds_ptmp = Atari2HostIntArray(__tagIds_size, tagIds, __tagIds_tmp);
	fn.glDeleteQueryResourceTagNV(n, __tagIds_ptmp);
#else
	fn.glDeleteQueryResourceTagNV(n, HostAddr(tagIds, const GLint *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteRenderbuffers(GLsizei n, memptr renderbuffers)
#else
void OSMesaDriver::nfglDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
#endif
{
	D(bug("nfosmesa: glDeleteRenderbuffers(%d, " PRI_PTR ")", n, AtariOffset(renderbuffers)));
FN_GLDELETERENDERBUFFERS(n, renderbuffers);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteRenderbuffersEXT(GLsizei n, memptr renderbuffers)
#else
void OSMesaDriver::nfglDeleteRenderbuffersEXT(GLsizei n, const GLuint *renderbuffers)
#endif
{
	D(bug("nfosmesa: glDeleteRenderbuffersEXT(%d, " PRI_PTR ")", n, AtariOffset(renderbuffers)));
FN_GLDELETERENDERBUFFERSEXT(n, renderbuffers);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteSamplers(GLsizei count, memptr samplers)
#else
void OSMesaDriver::nfglDeleteSamplers(GLsizei count, const GLuint *samplers)
#endif
{
	D(bug("nfosmesa: glDeleteSamplers(%d, " PRI_PTR ")", count, AtariOffset(samplers)));
FN_GLDELETESAMPLERS(count, samplers);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteSemaphoresEXT(GLsizei n, memptr semaphores)
#else
void OSMesaDriver::nfglDeleteSemaphoresEXT(GLsizei n, const GLuint *semaphores)
#endif
{
	D(bug("nfosmesa: glDeleteSemaphoresEXT(%d, " PRI_PTR ")", n, AtariOffset(semaphores)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __semaphores_size = MAX(n, 0);
	GLuint __semaphores_tmp[__semaphores_size];
	GLuint *__semaphores_ptmp = Atari2HostIntArray(__semaphores_size, semaphores, __semaphores_tmp);
	fn.glDeleteSemaphoresEXT(n, __semaphores_ptmp);
#else
	fn.glDeleteSemaphoresEXT(n, HostAddr(semaphores, const GLuint *));
#endif
}

void OSMesaDriver::nfglDeleteShader(GLuint shader)
{
	D(bug("nfosmesa: glDeleteShader(%u)", shader));
	fn.glDeleteShader(shader);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteStatesNV(GLsizei n, memptr states)
#else
void OSMesaDriver::nfglDeleteStatesNV(GLsizei n, const GLuint *states)
#endif
{
	D(bug("nfosmesa: glDeleteStatesNV(%d, " PRI_PTR ")", n, AtariOffset(states)));
FN_GLDELETESTATESNV(n, states);
}

void OSMesaDriver::nfglDeleteSync(GLsync sync)
{
	D(bug("nfosmesa: glDeleteSync(" PRI_PTR ")", (unsigned int)(uintptr_t)sync));
	fn.glDeleteSync(sync);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteTextures(GLsizei n, memptr textures)
#else
void OSMesaDriver::nfglDeleteTextures(GLsizei n, const GLuint *textures)
#endif
{
	D(bug("nfosmesa: glDeleteTextures(%d, " PRI_PTR ")", n, AtariOffset(textures)));
FN_GLDELETETEXTURES(n, textures);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteTexturesEXT(GLsizei n, memptr textures)
#else
void OSMesaDriver::nfglDeleteTexturesEXT(GLsizei n, const GLuint *textures)
#endif
{
	D(bug("nfosmesa: glDeleteTexturesEXT(%d, " PRI_PTR ")", n, AtariOffset(textures)));
FN_GLDELETETEXTURESEXT(n, textures);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteTransformFeedbacks(GLsizei n, memptr ids)
#else
void OSMesaDriver::nfglDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
#endif
{
	D(bug("nfosmesa: glDeleteTransformFeedbacks(%d, " PRI_PTR ")", n, AtariOffset(ids)));
FN_GLDELETETRANSFORMFEEDBACKS(n, ids);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteTransformFeedbacksNV(GLsizei n, memptr ids)
#else
void OSMesaDriver::nfglDeleteTransformFeedbacksNV(GLsizei n, const GLuint *ids)
#endif
{
	D(bug("nfosmesa: glDeleteTransformFeedbacksNV(%d, " PRI_PTR ")", n, AtariOffset(ids)));
FN_GLDELETETRANSFORMFEEDBACKSNV(n, ids);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteVertexArrays(GLsizei n, memptr arrays)
#else
void OSMesaDriver::nfglDeleteVertexArrays(GLsizei n, const GLuint *arrays)
#endif
{
	D(bug("nfosmesa: glDeleteVertexArrays(%d, " PRI_PTR ")", n, AtariOffset(arrays)));
FN_GLDELETEVERTEXARRAYS(n, arrays);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDeleteVertexArraysAPPLE(GLsizei n, memptr arrays)
#else
void OSMesaDriver::nfglDeleteVertexArraysAPPLE(GLsizei n, const GLuint *arrays)
#endif
{
	D(bug("nfosmesa: glDeleteVertexArraysAPPLE(%d, " PRI_PTR ")", n, AtariOffset(arrays)));
FN_GLDELETEVERTEXARRAYSAPPLE(n, arrays);
}

void OSMesaDriver::nfglDeleteVertexShaderEXT(GLuint id)
{
	D(bug("nfosmesa: glDeleteVertexShaderEXT(%u)", id));
	fn.glDeleteVertexShaderEXT(id);
}

void OSMesaDriver::nfglDepthBoundsEXT(GLclampd zmin, GLclampd zmax)
{
	D(bug("nfosmesa: glDepthBoundsEXT(%f, %f)", zmin, zmax));
	fn.glDepthBoundsEXT(zmin, zmax);
}

void OSMesaDriver::nfglDepthBoundsdNV(GLdouble zmin, GLdouble zmax)
{
	D(bug("nfosmesa: glDepthBoundsdNV(%f, %f)", zmin, zmax));
	fn.glDepthBoundsdNV(zmin, zmax);
}

void OSMesaDriver::nfglDepthFunc(GLenum func)
{
	D(bug("nfosmesa: glDepthFunc(%s)", gl_enum_name(func)));
	fn.glDepthFunc(func);
}

void OSMesaDriver::nfglDepthMask(GLboolean32 flag)
{
	D(bug("nfosmesa: glDepthMask(%d)", flag));
	fn.glDepthMask(flag);
}

void OSMesaDriver::nfglDepthRange(GLclampd zNear, GLclampd zFar)
{
	D(bug("nfosmesa: glDepthRange(%f, %f)", zNear, zFar));
	fn.glDepthRange(zNear, zFar);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDepthRangeArrayv(GLuint first, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glDepthRangeArrayv(%u, %d, " PRI_PTR ")", first, count, AtariOffset(v)));
FN_GLDEPTHRANGEARRAYV(first, count, v);
}

void OSMesaDriver::nfglDepthRangeIndexed(GLuint index, GLdouble n, GLdouble f)
{
	D(bug("nfosmesa: glDepthRangeIndexed(%u, %f, %f)", index, n, f));
	fn.glDepthRangeIndexed(index, n, f);
}

void OSMesaDriver::nfglDepthRangedNV(GLdouble zNear, GLdouble zFar)
{
	D(bug("nfosmesa: glDepthRangedNV(%f, %f)", zNear, zFar));
	fn.glDepthRangedNV(zNear, zFar);
}

void OSMesaDriver::nfglDepthRangef(GLfloat n, GLfloat f)
{
	D(bug("nfosmesa: glDepthRangef(%f, %f)", n, f));
	fn.glDepthRangef(n, f);
}

void OSMesaDriver::nfglDepthRangefOES(GLclampf n, GLclampf f)
{
	D(bug("nfosmesa: glDepthRangefOES(%f, %f)", n, f));
	fn.glDepthRangefOES(n, f);
}

void OSMesaDriver::nfglDepthRangexOES(GLfixed n, GLfixed f)
{
	D(bug("nfosmesa: glDepthRangexOES(0x%x, 0x%x)", n, f));
	fn.glDepthRangexOES(n, f);
}

void OSMesaDriver::nfglDetachObjectARB(GLhandleARB containerObj, GLhandleARB attachedObj)
{
	D(bug("nfosmesa: glDetachObjectARB(%u, %u)", (unsigned int)(uintptr_t)containerObj, (unsigned int)(uintptr_t)attachedObj));
	fn.glDetachObjectARB(containerObj, attachedObj);
}

void OSMesaDriver::nfglDetachShader(GLuint program, GLuint shader)
{
	D(bug("nfosmesa: glDetachShader(%u, %u)", program, shader));
	fn.glDetachShader(program, shader);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDetailTexFuncSGIS(GLenum target, GLsizei n, memptr points)
#else
void OSMesaDriver::nfglDetailTexFuncSGIS(GLenum target, GLsizei n, const GLfloat *points)
#endif
{
	D(bug("nfosmesa: glDetailTexFuncSGIS(%s, %d, " PRI_PTR ")", gl_enum_name(target), n, AtariOffset(points)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __points_size = MAX(n * 2, 0);
	GLfloat __points_tmp[__points_size];
	GLfloat *__points_ptmp = Atari2HostFloatArray(__points_size, points, __points_tmp);
	fn.glDetailTexFuncSGIS(target, n, __points_ptmp);
#else
	fn.glDetailTexFuncSGIS(target, n, HostAddr(points, const GLfloat *));
#endif
}

void OSMesaDriver::nfglDisable(GLenum cap)
{
	D(bug("nfosmesa: glDisable(%s)", gl_enum_name(cap)));
FN_GLDISABLE(cap);
}

void OSMesaDriver::nfglDisableClientState(GLenum array)
{
	D(bug("nfosmesa: glDisableClientState(%s)", gl_enum_name(array)));
FN_GLDISABLECLIENTSTATE(array);
}

void OSMesaDriver::nfglDisableClientStateIndexedEXT(GLenum array, GLuint index)
{
	D(bug("nfosmesa: glDisableClientStateIndexedEXT(%s, %u)", gl_enum_name(array), index));
	fn.glDisableClientStateIndexedEXT(array, index);
}

void OSMesaDriver::nfglDisableClientStateiEXT(GLenum array, GLuint index)
{
	D(bug("nfosmesa: glDisableClientStateiEXT(%s, %u)", gl_enum_name(array), index));
	fn.glDisableClientStateiEXT(array, index);
}

void OSMesaDriver::nfglDisableIndexedEXT(GLenum target, GLuint index)
{
	D(bug("nfosmesa: glDisableIndexedEXT(%s, %u)", gl_enum_name(target), index));
	fn.glDisableIndexedEXT(target, index);
}

void OSMesaDriver::nfglDisableTraceMESA(GLbitfield mask)
{
	D(bug("nfosmesa: glDisableTraceMESA(0x%x)", mask));
	fn.glDisableTraceMESA(mask);
}

void OSMesaDriver::nfglDisableVariantClientStateEXT(GLuint id)
{
	D(bug("nfosmesa: glDisableVariantClientStateEXT(%u)", id));
FN_GLDISABLEVARIANTCLIENTSTATEEXT(id);
}

void OSMesaDriver::nfglDisableVertexArrayAttrib(GLuint vaobj, GLuint index)
{
	D(bug("nfosmesa: glDisableVertexArrayAttrib(%u, %u)", vaobj, index));
	fn.glDisableVertexArrayAttrib(vaobj, index);
}

void OSMesaDriver::nfglDisableVertexArrayAttribEXT(GLuint vaobj, GLuint index)
{
	D(bug("nfosmesa: glDisableVertexArrayAttribEXT(%u, %u)", vaobj, index));
	fn.glDisableVertexArrayAttribEXT(vaobj, index);
}

void OSMesaDriver::nfglDisableVertexArrayEXT(GLuint vaobj, GLenum array)
{
	D(bug("nfosmesa: glDisableVertexArrayEXT(%u, %s)", vaobj, gl_enum_name(array)));
	fn.glDisableVertexArrayEXT(vaobj, array);
}

void OSMesaDriver::nfglDisableVertexAttribAPPLE(GLuint index, GLenum pname)
{
	D(bug("nfosmesa: glDisableVertexAttribAPPLE(%u, %s)", index, gl_enum_name(pname)));
	fn.glDisableVertexAttribAPPLE(index, pname);
}

void OSMesaDriver::nfglDisableVertexAttribArray(GLuint index)
{
	D(bug("nfosmesa: glDisableVertexAttribArray(%u)", index));
	fn.glDisableVertexAttribArray(index);
}

void OSMesaDriver::nfglDisableVertexAttribArrayARB(GLuint index)
{
	D(bug("nfosmesa: glDisableVertexAttribArrayARB(%u)", index));
	fn.glDisableVertexAttribArrayARB(index);
}

void OSMesaDriver::nfglDisablei(GLenum target, GLuint index)
{
	D(bug("nfosmesa: glDisablei(%s, %u)", gl_enum_name(target), index));
	fn.glDisablei(target, index);
}

void OSMesaDriver::nfglDispatchCompute(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z)
{
	D(bug("nfosmesa: glDispatchCompute(%u, %u, %u)", num_groups_x, num_groups_y, num_groups_z));
	fn.glDispatchCompute(num_groups_x, num_groups_y, num_groups_z);
}

void OSMesaDriver::nfglDispatchComputeGroupSizeARB(GLuint num_groups_x, GLuint num_groups_y, GLuint num_groups_z, GLuint group_size_x, GLuint group_size_y, GLuint group_size_z)
{
	D(bug("nfosmesa: glDispatchComputeGroupSizeARB(%u, %u, %u, %u, %u, %u)", num_groups_x, num_groups_y, num_groups_z, group_size_x, group_size_y, group_size_z));
	fn.glDispatchComputeGroupSizeARB(num_groups_x, num_groups_y, num_groups_z, group_size_x, group_size_y, group_size_z);
}

void OSMesaDriver::nfglDispatchComputeIndirect(GLintptr indirect)
{
	D(bug("nfosmesa: glDispatchComputeIndirect(%" PRI_IPTR ")", indirect));
FN_GLDISPATCHCOMPUTEINDIRECT(indirect);
}

void OSMesaDriver::nfglDrawArrays(GLenum mode, GLint first, GLsizei count)
{
	D(bug("nfosmesa: glDrawArrays(%s, %d, %d)", gl_enum_name(mode), first, count));
FN_GLDRAWARRAYS(mode, first, count);
}

void OSMesaDriver::nfglDrawArraysEXT(GLenum mode, GLint first, GLsizei count)
{
	D(bug("nfosmesa: glDrawArraysEXT(%s, %d, %d)", gl_enum_name(mode), first, count));
FN_GLDRAWARRAYSEXT(mode, first, count);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawArraysIndirect(GLenum mode, memptr indirect)
#else
void OSMesaDriver::nfglDrawArraysIndirect(GLenum mode, const void *indirect)
#endif
{
	D(bug("nfosmesa: glDrawArraysIndirect(%s, " PRI_PTR ")", gl_enum_name(mode), AtariOffset(indirect)));
FN_GLDRAWARRAYSINDIRECT(mode, indirect);
}

void OSMesaDriver::nfglDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
{
	D(bug("nfosmesa: glDrawArraysInstanced(%s, %d, %d, %d)", gl_enum_name(mode), first, count, instancecount));
FN_GLDRAWARRAYSINSTANCED(mode, first, count, instancecount);
}

void OSMesaDriver::nfglDrawArraysInstancedARB(GLenum mode, GLint first, GLsizei count, GLsizei primcount)
{
	D(bug("nfosmesa: glDrawArraysInstancedARB(%s, %d, %d, %d)", gl_enum_name(mode), first, count, primcount));
FN_GLDRAWARRAYSINSTANCEDARB(mode, first, count, primcount);
}

void OSMesaDriver::nfglDrawArraysInstancedBaseInstance(GLenum mode, GLint first, GLsizei count, GLsizei instancecount, GLuint baseinstance)
{
	D(bug("nfosmesa: glDrawArraysInstancedBaseInstance(%s, %d, %d, %d, %u)", gl_enum_name(mode), first, count, instancecount, baseinstance));
	fn.glDrawArraysInstancedBaseInstance(mode, first, count, instancecount, baseinstance);
}

void OSMesaDriver::nfglDrawArraysInstancedEXT(GLenum mode, GLint start, GLsizei count, GLsizei primcount)
{
	D(bug("nfosmesa: glDrawArraysInstancedEXT(%s, %d, %d, %d)", gl_enum_name(mode), start, count, primcount));
FN_GLDRAWARRAYSINSTANCEDEXT(mode, start, count, primcount);
}

void OSMesaDriver::nfglDrawBuffer(GLenum mode)
{
	D(bug("nfosmesa: glDrawBuffer(%s)", gl_enum_name(mode)));
	fn.glDrawBuffer(mode);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawBuffers(GLsizei n, memptr bufs)
#else
void OSMesaDriver::nfglDrawBuffers(GLsizei n, const GLenum *bufs)
#endif
{
	D(bug("nfosmesa: glDrawBuffers(%d, " PRI_PTR ")", n, AtariOffset(bufs)));
FN_GLDRAWBUFFERS(n, bufs);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawBuffersARB(GLsizei n, memptr bufs)
#else
void OSMesaDriver::nfglDrawBuffersARB(GLsizei n, const GLenum *bufs)
#endif
{
	D(bug("nfosmesa: glDrawBuffersARB(%d, " PRI_PTR ")", n, AtariOffset(bufs)));
FN_GLDRAWBUFFERSARB(n, bufs);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawBuffersATI(GLsizei n, memptr bufs)
#else
void OSMesaDriver::nfglDrawBuffersATI(GLsizei n, const GLenum *bufs)
#endif
{
	D(bug("nfosmesa: glDrawBuffersATI(%d, " PRI_PTR ")", n, AtariOffset(bufs)));
FN_GLDRAWBUFFERSATI(n, bufs);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawCommandsAddressNV(GLenum primitiveMode, memptr indirects, memptr sizes, GLuint count)
#else
void OSMesaDriver::nfglDrawCommandsAddressNV(GLenum primitiveMode, const GLuint64 *indirects, const GLsizei *sizes, GLuint count)
#endif
{
	D(bug("nfosmesa: glDrawCommandsAddressNV(%s, " PRI_PTR ", " PRI_PTR ", %u)", gl_enum_name(primitiveMode), AtariOffset(indirects), AtariOffset(sizes), count));
FN_GLDRAWCOMMANDSADDRESSNV(primitiveMode, indirects, sizes, count);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawCommandsNV(GLenum primitiveMode, GLuint buffer, memptr indirects, memptr sizes, GLuint count)
#else
void OSMesaDriver::nfglDrawCommandsNV(GLenum primitiveMode, GLuint buffer, const GLintptr *indirects, const GLsizei *sizes, GLuint count)
#endif
{
	D(bug("nfosmesa: glDrawCommandsNV(%s, %u, " PRI_PTR ", " PRI_PTR ", %u)", gl_enum_name(primitiveMode), buffer, AtariOffset(indirects), AtariOffset(sizes), count));
FN_GLDRAWCOMMANDSNV(primitiveMode, buffer, indirects, sizes, count);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawCommandsStatesAddressNV(memptr indirects, memptr sizes, memptr states, memptr fbos, GLuint count)
#else
void OSMesaDriver::nfglDrawCommandsStatesAddressNV(const GLuint64 *indirects, const GLsizei *sizes, const GLuint *states, const GLuint *fbos, GLuint count)
#endif
{
	D(bug("nfosmesa: glDrawCommandsStatesAddressNV(" PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", %u)", AtariOffset(indirects), AtariOffset(sizes), AtariOffset(states), AtariOffset(fbos), count));
FN_GLDRAWCOMMANDSSTATESADDRESSNV(indirects, sizes, states, fbos, count);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawCommandsStatesNV(GLuint buffer, memptr indirects, memptr sizes, memptr states, memptr fbos, GLuint count)
#else
void OSMesaDriver::nfglDrawCommandsStatesNV(GLuint buffer, const GLintptr *indirects, const GLsizei *sizes, const GLuint *states, const GLuint *fbos, GLuint count)
#endif
{
	D(bug("nfosmesa: glDrawCommandsStatesNV(%u, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", %u)", buffer, AtariOffset(indirects), AtariOffset(sizes), AtariOffset(states), AtariOffset(fbos), count));
FN_GLDRAWCOMMANDSSTATESNV(buffer, indirects, sizes, states, fbos, count);
}

void OSMesaDriver::nfglDrawElementArrayAPPLE(GLenum mode, GLint first, GLsizei count)
{
	D(bug("nfosmesa: glDrawElementArrayAPPLE(%s, %d, %d)", gl_enum_name(mode), first, count));
FN_GLDRAWELEMENTARRAYAPPLE(mode, first, count);
}

void OSMesaDriver::nfglDrawElementArrayATI(GLenum mode, GLsizei count)
{
	D(bug("nfosmesa: glDrawElementArrayATI(%s, %d)", gl_enum_name(mode), count));
FN_GLDRAWELEMENTARRAYATI(mode, count);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawElements(GLenum mode, GLsizei count, GLenum type, memptr indices)
#else
void OSMesaDriver::nfglDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
#endif
{
	D(bug("nfosmesa: glDrawElements(%s, %d, %s, " PRI_PTR ")", gl_enum_name(mode), count, gl_enum_name(type), AtariOffset(indices)));
FN_GLDRAWELEMENTS(mode, count, type, indices);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, memptr indices, GLint basevertex)
#else
void OSMesaDriver::nfglDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex)
#endif
{
	D(bug("nfosmesa: glDrawElementsBaseVertex(%s, %d, %s, " PRI_PTR ", %d)", gl_enum_name(mode), count, gl_enum_name(type), AtariOffset(indices), basevertex));
FN_GLDRAWELEMENTSBASEVERTEX(mode, count, type, indices, basevertex);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawElementsIndirect(GLenum mode, GLenum type, memptr indirect)
#else
void OSMesaDriver::nfglDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
#endif
{
	D(bug("nfosmesa: glDrawElementsIndirect(%s, %s, " PRI_PTR ")", gl_enum_name(mode), gl_enum_name(type), AtariOffset(indirect)));
FN_GLDRAWELEMENTSINDIRECT(mode, type, indirect);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, memptr indices, GLsizei instancecount)
#else
void OSMesaDriver::nfglDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount)
#endif
{
	D(bug("nfosmesa: glDrawElementsInstanced(%s, %d, %s, " PRI_PTR ", %d)", gl_enum_name(mode), count, gl_enum_name(type), AtariOffset(indices), instancecount));
FN_GLDRAWELEMENTSINSTANCED(mode, count, type, indices, instancecount);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawElementsInstancedARB(GLenum mode, GLsizei count, GLenum type, memptr indices, GLsizei primcount)
#else
void OSMesaDriver::nfglDrawElementsInstancedARB(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount)
#endif
{
	D(bug("nfosmesa: glDrawElementsInstancedARB(%s, %d, %s, " PRI_PTR ", %d)", gl_enum_name(mode), count, gl_enum_name(type), AtariOffset(indices), primcount));
FN_GLDRAWELEMENTSINSTANCEDARB(mode, count, type, indices, primcount);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, memptr indices, GLsizei instancecount, GLuint baseinstance)
#else
void OSMesaDriver::nfglDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
#endif
{
	D(bug("nfosmesa: glDrawElementsInstancedBaseInstance(%s, %d, %s, " PRI_PTR ", %d, %u)", gl_enum_name(mode), count, gl_enum_name(type), AtariOffset(indices), instancecount, baseinstance));
FN_GLDRAWELEMENTSINSTANCEDBASEINSTANCE(mode, count, type, indices, instancecount, baseinstance);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, memptr indices, GLsizei instancecount, GLint basevertex)
#else
void OSMesaDriver::nfglDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex)
#endif
{
	D(bug("nfosmesa: glDrawElementsInstancedBaseVertex(%s, %d, %s, " PRI_PTR ", %d, %d)", gl_enum_name(mode), count, gl_enum_name(type), AtariOffset(indices), instancecount, basevertex));
FN_GLDRAWELEMENTSINSTANCEDBASEVERTEX(mode, count, type, indices, instancecount, basevertex);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, memptr indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
#else
void OSMesaDriver::nfglDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
#endif
{
	D(bug("nfosmesa: glDrawElementsInstancedBaseVertexBaseInstance(%s, %d, %s, " PRI_PTR ", %d, %d, %u)", gl_enum_name(mode), count, gl_enum_name(type), AtariOffset(indices), instancecount, basevertex, baseinstance));
FN_GLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCE(mode, count, type, indices, instancecount, basevertex, baseinstance);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawElementsInstancedEXT(GLenum mode, GLsizei count, GLenum type, memptr indices, GLsizei primcount)
#else
void OSMesaDriver::nfglDrawElementsInstancedEXT(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount)
#endif
{
	D(bug("nfosmesa: glDrawElementsInstancedEXT(%s, %d, %s, " PRI_PTR ", %d)", gl_enum_name(mode), count, gl_enum_name(type), AtariOffset(indices), primcount));
FN_GLDRAWELEMENTSINSTANCEDEXT(mode, count, type, indices, primcount);
}

void OSMesaDriver::nfglDrawMeshArraysSUN(GLenum mode, GLint first, GLsizei count, GLsizei width)
{
	D(bug("nfosmesa: glDrawMeshArraysSUN(%s, %d, %d, %d)", gl_enum_name(mode), first, count, width));
	fn.glDrawMeshArraysSUN(mode, first, count, width);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
#endif
{
	D(bug("nfosmesa: glDrawPixels(%d, %d, %s, %s, " PRI_PTR ")", width, height, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLDRAWPIXELS(width, height, format, type, pixels);
}

void OSMesaDriver::nfglDrawRangeElementArrayAPPLE(GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count)
{
	D(bug("nfosmesa: glDrawRangeElementArrayAPPLE(%s, %u, %u, %d, %d)", gl_enum_name(mode), start, end, first, count));
FN_GLDRAWRANGEELEMENTARRAYAPPLE(mode, start, end, first, count);
}

void OSMesaDriver::nfglDrawRangeElementArrayATI(GLenum mode, GLuint start, GLuint end, GLsizei count)
{
	D(bug("nfosmesa: glDrawRangeElementArrayATI(%s, %u, %u, %d)", gl_enum_name(mode), start, end, count));
FN_GLDRAWRANGEELEMENTARRAYATI(mode, start, end, count);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, memptr indices)
#else
void OSMesaDriver::nfglDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices)
#endif
{
	D(bug("nfosmesa: glDrawRangeElements(%s, %u, %u, %d, %s, " PRI_PTR ")", gl_enum_name(mode), start, end, count, gl_enum_name(type), AtariOffset(indices)));
FN_GLDRAWRANGEELEMENTS(mode, start, end, count, type, indices);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, memptr indices, GLint basevertex)
#else
void OSMesaDriver::nfglDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex)
#endif
{
	D(bug("nfosmesa: glDrawRangeElementsBaseVertex(%s, %u, %u, %d, %s, " PRI_PTR ", %d)", gl_enum_name(mode), start, end, count, gl_enum_name(type), AtariOffset(indices), basevertex));
FN_GLDRAWRANGEELEMENTSBASEVERTEX(mode, start, end, count, type, indices, basevertex);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglDrawRangeElementsEXT(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, memptr indices)
#else
void OSMesaDriver::nfglDrawRangeElementsEXT(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices)
#endif
{
	D(bug("nfosmesa: glDrawRangeElementsEXT(%s, %u, %u, %d, %s, " PRI_PTR ")", gl_enum_name(mode), start, end, count, gl_enum_name(type), AtariOffset(indices)));
FN_GLDRAWRANGEELEMENTSEXT(mode, start, end, count, type, indices);
}

void OSMesaDriver::nfglDrawTextureNV(GLuint texture, GLuint sampler, GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1, GLfloat z, GLfloat s0, GLfloat t0, GLfloat s1, GLfloat t1)
{
	D(bug("nfosmesa: glDrawTextureNV(%u, %u, %f, %f, %f, %f, %f, %f, %f, %f, %f)", texture, sampler, x0, y0, x1, y1, z, s0, t0, s1, t1));
	fn.glDrawTextureNV(texture, sampler, x0, y0, x1, y1, z, s0, t0, s1, t1);
}

void OSMesaDriver::nfglDrawTransformFeedback(GLenum mode, GLuint id)
{
	D(bug("nfosmesa: glDrawTransformFeedback(%s, %u)", gl_enum_name(mode), id));
	fn.glDrawTransformFeedback(mode, id);
}

void OSMesaDriver::nfglDrawTransformFeedbackInstanced(GLenum mode, GLuint id, GLsizei instancecount)
{
	D(bug("nfosmesa: glDrawTransformFeedbackInstanced(%s, %u, %d)", gl_enum_name(mode), id, instancecount));
	fn.glDrawTransformFeedbackInstanced(mode, id, instancecount);
}

void OSMesaDriver::nfglDrawTransformFeedbackNV(GLenum mode, GLuint id)
{
	D(bug("nfosmesa: glDrawTransformFeedbackNV(%s, %u)", gl_enum_name(mode), id));
	fn.glDrawTransformFeedbackNV(mode, id);
}

void OSMesaDriver::nfglDrawTransformFeedbackStream(GLenum mode, GLuint id, GLuint stream)
{
	D(bug("nfosmesa: glDrawTransformFeedbackStream(%s, %u, %u)", gl_enum_name(mode), id, stream));
	fn.glDrawTransformFeedbackStream(mode, id, stream);
}

void OSMesaDriver::nfglDrawTransformFeedbackStreamInstanced(GLenum mode, GLuint id, GLuint stream, GLsizei instancecount)
{
	D(bug("nfosmesa: glDrawTransformFeedbackStreamInstanced(%s, %u, %u, %d)", gl_enum_name(mode), id, stream, instancecount));
	fn.glDrawTransformFeedbackStreamInstanced(mode, id, stream, instancecount);
}

void OSMesaDriver::nfglDrawVkImageNV(GLuint64 vkImage, GLuint sampler, GLfloat x0, GLfloat y0, GLfloat x1, GLfloat y1, GLfloat z, GLfloat s0, GLfloat t0, GLfloat s1, GLfloat t1)
{
	D(bug("nfosmesa: glDrawVkImageNV(%" PRIu64 ", %u, %f, %f, %f, %f, %f, %f, %f, %f, %f)", vkImage, sampler, x0, y0, x1, y1, z, s0, t0, s1, t1));
	fn.glDrawVkImageNV(vkImage, sampler, x0, y0, x1, y1, z, s0, t0, s1, t1);
}

void OSMesaDriver::nfglEdgeFlag(GLboolean32 flag)
{
	D(bug("nfosmesa: glEdgeFlag(%d)", flag));
	fn.glEdgeFlag(flag);
}

void OSMesaDriver::nfglEdgeFlagFormatNV(GLsizei stride)
{
	D(bug("nfosmesa: glEdgeFlagFormatNV(%d)", stride));
	fn.glEdgeFlagFormatNV(stride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglEdgeFlagPointer(GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
#endif
{
	D(bug("nfosmesa: glEdgeFlagPointer(%d, " PRI_PTR ")", stride, AtariOffset(pointer)));
FN_GLEDGEFLAGPOINTER(stride, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglEdgeFlagPointerEXT(GLsizei stride, GLsizei count, memptr pointer)
#else
void OSMesaDriver::nfglEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *pointer)
#endif
{
	D(bug("nfosmesa: glEdgeFlagPointerEXT(%d, %d, " PRI_PTR ")", stride, count, AtariOffset(pointer)));
FN_GLEDGEFLAGPOINTEREXT(stride, count, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglEdgeFlagPointerListIBM(GLint stride, memptr pointer, GLint ptrstride)
#else
void OSMesaDriver::nfglEdgeFlagPointerListIBM(GLint stride, const GLboolean * *pointer, GLint ptrstride)
#endif
{
	D(bug("nfosmesa: glEdgeFlagPointerListIBM(%d, " PRI_PTR ", %d)", stride, AtariOffset(pointer), ptrstride));
FN_GLEDGEFLAGPOINTERLISTIBM(stride, pointer, ptrstride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglEdgeFlagv(memptr flag)
#else
void OSMesaDriver::nfglEdgeFlagv(const GLboolean *flag)
#endif
{
	D(bug("nfosmesa: glEdgeFlagv(" PRI_PTR ")", AtariOffset(flag)));
FN_GLEDGEFLAGV(flag);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglElementPointerAPPLE(GLenum type, memptr pointer)
#else
void OSMesaDriver::nfglElementPointerAPPLE(GLenum type, const void *pointer)
#endif
{
	D(bug("nfosmesa: glElementPointerAPPLE(%s, " PRI_PTR ")", gl_enum_name(type), AtariOffset(pointer)));
FN_GLELEMENTPOINTERAPPLE(type, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglElementPointerATI(GLenum type, memptr pointer)
#else
void OSMesaDriver::nfglElementPointerATI(GLenum type, const void *pointer)
#endif
{
	D(bug("nfosmesa: glElementPointerATI(%s, " PRI_PTR ")", gl_enum_name(type), AtariOffset(pointer)));
FN_GLELEMENTPOINTERATI(type, pointer);
}

void OSMesaDriver::nfglEnable(GLenum cap)
{
	D(bug("nfosmesa: glEnable(%s)", gl_enum_name(cap)));
FN_GLENABLE(cap);
}

void OSMesaDriver::nfglEnableClientState(GLenum array)
{
	D(bug("nfosmesa: glEnableClientState(%s)", gl_enum_name(array)));
FN_GLENABLECLIENTSTATE(array);
}

void OSMesaDriver::nfglEnableClientStateIndexedEXT(GLenum array, GLuint index)
{
	D(bug("nfosmesa: glEnableClientStateIndexedEXT(%s, %u)", gl_enum_name(array), index));
	fn.glEnableClientStateIndexedEXT(array, index);
}

void OSMesaDriver::nfglEnableClientStateiEXT(GLenum array, GLuint index)
{
	D(bug("nfosmesa: glEnableClientStateiEXT(%s, %u)", gl_enum_name(array), index));
	fn.glEnableClientStateiEXT(array, index);
}

void OSMesaDriver::nfglEnableIndexedEXT(GLenum target, GLuint index)
{
	D(bug("nfosmesa: glEnableIndexedEXT(%s, %u)", gl_enum_name(target), index));
	fn.glEnableIndexedEXT(target, index);
}

void OSMesaDriver::nfglEnableTraceMESA(GLbitfield mask)
{
	D(bug("nfosmesa: glEnableTraceMESA(0x%x)", mask));
	fn.glEnableTraceMESA(mask);
}

void OSMesaDriver::nfglEnableVariantClientStateEXT(GLuint id)
{
	D(bug("nfosmesa: glEnableVariantClientStateEXT(%u)", id));
FN_GLENABLEVARIANTCLIENTSTATEEXT(id);
}

void OSMesaDriver::nfglEnableVertexArrayAttrib(GLuint vaobj, GLuint index)
{
	D(bug("nfosmesa: glEnableVertexArrayAttrib(%u, %u)", vaobj, index));
	fn.glEnableVertexArrayAttrib(vaobj, index);
}

void OSMesaDriver::nfglEnableVertexArrayAttribEXT(GLuint vaobj, GLuint index)
{
	D(bug("nfosmesa: glEnableVertexArrayAttribEXT(%u, %u)", vaobj, index));
	fn.glEnableVertexArrayAttribEXT(vaobj, index);
}

void OSMesaDriver::nfglEnableVertexArrayEXT(GLuint vaobj, GLenum array)
{
	D(bug("nfosmesa: glEnableVertexArrayEXT(%u, %s)", vaobj, gl_enum_name(array)));
	fn.glEnableVertexArrayEXT(vaobj, array);
}

void OSMesaDriver::nfglEnableVertexAttribAPPLE(GLuint index, GLenum pname)
{
	D(bug("nfosmesa: glEnableVertexAttribAPPLE(%u, %s)", index, gl_enum_name(pname)));
	fn.glEnableVertexAttribAPPLE(index, pname);
}

void OSMesaDriver::nfglEnableVertexAttribArray(GLuint index)
{
	D(bug("nfosmesa: glEnableVertexAttribArray(%u)", index));
	fn.glEnableVertexAttribArray(index);
}

void OSMesaDriver::nfglEnableVertexAttribArrayARB(GLuint index)
{
	D(bug("nfosmesa: glEnableVertexAttribArrayARB(%u)", index));
	fn.glEnableVertexAttribArrayARB(index);
}

void OSMesaDriver::nfglEnablei(GLenum target, GLuint index)
{
	D(bug("nfosmesa: glEnablei(%s, %u)", gl_enum_name(target), index));
	fn.glEnablei(target, index);
}

void OSMesaDriver::nfglEnd(void)
{
	D(bug("nfosmesa: glEnd()"));
	fn.glEnd();
}

void OSMesaDriver::nfglEndConditionalRender(void)
{
	D(bug("nfosmesa: glEndConditionalRender()"));
	fn.glEndConditionalRender();
}

void OSMesaDriver::nfglEndConditionalRenderNV(void)
{
	D(bug("nfosmesa: glEndConditionalRenderNV()"));
	fn.glEndConditionalRenderNV();
}

void OSMesaDriver::nfglEndConditionalRenderNVX(void)
{
	D(bug("nfosmesa: glEndConditionalRenderNVX()"));
	fn.glEndConditionalRenderNVX();
}

void OSMesaDriver::nfglEndFragmentShaderATI(void)
{
	D(bug("nfosmesa: glEndFragmentShaderATI()"));
	fn.glEndFragmentShaderATI();
}

void OSMesaDriver::nfglEndList(void)
{
	D(bug("nfosmesa: glEndList()"));
	fn.glEndList();
}

void OSMesaDriver::nfglEndOcclusionQueryNV(void)
{
	D(bug("nfosmesa: glEndOcclusionQueryNV()"));
	fn.glEndOcclusionQueryNV();
}

void OSMesaDriver::nfglEndPerfMonitorAMD(GLuint monitor)
{
	D(bug("nfosmesa: glEndPerfMonitorAMD(%u)", monitor));
	fn.glEndPerfMonitorAMD(monitor);
}

void OSMesaDriver::nfglEndPerfQueryINTEL(GLuint queryHandle)
{
	D(bug("nfosmesa: glEndPerfQueryINTEL(%u)", queryHandle));
	fn.glEndPerfQueryINTEL(queryHandle);
}

void OSMesaDriver::nfglEndQuery(GLenum target)
{
	D(bug("nfosmesa: glEndQuery(%s)", gl_enum_name(target)));
	fn.glEndQuery(target);
}

void OSMesaDriver::nfglEndQueryARB(GLenum target)
{
	D(bug("nfosmesa: glEndQueryARB(%s)", gl_enum_name(target)));
	fn.glEndQueryARB(target);
}

void OSMesaDriver::nfglEndQueryIndexed(GLenum target, GLuint index)
{
	D(bug("nfosmesa: glEndQueryIndexed(%s, %u)", gl_enum_name(target), index));
	fn.glEndQueryIndexed(target, index);
}

void OSMesaDriver::nfglEndTraceMESA(void)
{
	D(bug("nfosmesa: glEndTraceMESA()"));
	fn.glEndTraceMESA();
}

void OSMesaDriver::nfglEndTransformFeedback(void)
{
	D(bug("nfosmesa: glEndTransformFeedback()"));
	fn.glEndTransformFeedback();
}

void OSMesaDriver::nfglEndTransformFeedbackEXT(void)
{
	D(bug("nfosmesa: glEndTransformFeedbackEXT()"));
	fn.glEndTransformFeedbackEXT();
}

void OSMesaDriver::nfglEndTransformFeedbackNV(void)
{
	D(bug("nfosmesa: glEndTransformFeedbackNV()"));
	fn.glEndTransformFeedbackNV();
}

void OSMesaDriver::nfglEndVertexShaderEXT(void)
{
	D(bug("nfosmesa: glEndVertexShaderEXT()"));
	fn.glEndVertexShaderEXT();
}

void OSMesaDriver::nfglEndVideoCaptureNV(GLuint video_capture_slot)
{
	D(bug("nfosmesa: glEndVideoCaptureNV(%u)", video_capture_slot));
	fn.glEndVideoCaptureNV(video_capture_slot);
}

void OSMesaDriver::nfglEvalCoord1d(GLdouble u)
{
	D(bug("nfosmesa: glEvalCoord1d(%f)", u));
	fn.glEvalCoord1d(u);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglEvalCoord1dv(memptr u)
#else
void OSMesaDriver::nfglEvalCoord1dv(const GLdouble *u)
#endif
{
	D(bug("nfosmesa: glEvalCoord1dv(" PRI_PTR ")", AtariOffset(u)));
FN_GLEVALCOORD1DV(u);
}

void OSMesaDriver::nfglEvalCoord1f(GLfloat u)
{
	D(bug("nfosmesa: glEvalCoord1f(%f)", u));
	fn.glEvalCoord1f(u);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglEvalCoord1fv(memptr u)
#else
void OSMesaDriver::nfglEvalCoord1fv(const GLfloat *u)
#endif
{
	D(bug("nfosmesa: glEvalCoord1fv(" PRI_PTR ")", AtariOffset(u)));
FN_GLEVALCOORD1FV(u);
}

void OSMesaDriver::nfglEvalCoord1xOES(GLfixed u)
{
	D(bug("nfosmesa: glEvalCoord1xOES(0x%x)", u));
	fn.glEvalCoord1xOES(u);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglEvalCoord1xvOES(memptr coords)
#else
void OSMesaDriver::nfglEvalCoord1xvOES(const GLfixed *coords)
#endif
{
	D(bug("nfosmesa: glEvalCoord1xvOES(" PRI_PTR ")", AtariOffset(coords)));
FN_GLEVALCOORD1XVOES(coords);
}

void OSMesaDriver::nfglEvalCoord2d(GLdouble u, GLdouble v)
{
	D(bug("nfosmesa: glEvalCoord2d(%f, %f)", u, v));
	fn.glEvalCoord2d(u, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglEvalCoord2dv(memptr u)
#else
void OSMesaDriver::nfglEvalCoord2dv(const GLdouble *u)
#endif
{
	D(bug("nfosmesa: glEvalCoord2dv(" PRI_PTR ")", AtariOffset(u)));
FN_GLEVALCOORD2DV(u);
}

void OSMesaDriver::nfglEvalCoord2f(GLfloat u, GLfloat v)
{
	D(bug("nfosmesa: glEvalCoord2f(%f, %f)", u, v));
	fn.glEvalCoord2f(u, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglEvalCoord2fv(memptr u)
#else
void OSMesaDriver::nfglEvalCoord2fv(const GLfloat *u)
#endif
{
	D(bug("nfosmesa: glEvalCoord2fv(" PRI_PTR ")", AtariOffset(u)));
FN_GLEVALCOORD2FV(u);
}

void OSMesaDriver::nfglEvalCoord2xOES(GLfixed u, GLfixed v)
{
	D(bug("nfosmesa: glEvalCoord2xOES(0x%x, 0x%x)", u, v));
	fn.glEvalCoord2xOES(u, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglEvalCoord2xvOES(memptr coords)
#else
void OSMesaDriver::nfglEvalCoord2xvOES(const GLfixed *coords)
#endif
{
	D(bug("nfosmesa: glEvalCoord2xvOES(" PRI_PTR ")", AtariOffset(coords)));
FN_GLEVALCOORD2XVOES(coords);
}

void OSMesaDriver::nfglEvalMapsNV(GLenum target, GLenum mode)
{
	D(bug("nfosmesa: glEvalMapsNV(%s, %s)", gl_enum_name(target), gl_enum_name(mode)));
	fn.glEvalMapsNV(target, mode);
}

void OSMesaDriver::nfglEvalMesh1(GLenum mode, GLint i1, GLint i2)
{
	D(bug("nfosmesa: glEvalMesh1(%s, %d, %d)", gl_enum_name(mode), i1, i2));
	fn.glEvalMesh1(mode, i1, i2);
}

void OSMesaDriver::nfglEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
{
	D(bug("nfosmesa: glEvalMesh2(%s, %d, %d, %d, %d)", gl_enum_name(mode), i1, i2, j1, j2));
	fn.glEvalMesh2(mode, i1, i2, j1, j2);
}

void OSMesaDriver::nfglEvalPoint1(GLint i)
{
	D(bug("nfosmesa: glEvalPoint1(%d)", i));
	fn.glEvalPoint1(i);
}

void OSMesaDriver::nfglEvalPoint2(GLint i, GLint j)
{
	D(bug("nfosmesa: glEvalPoint2(%d, %d)", i, j));
	fn.glEvalPoint2(i, j);
}

void OSMesaDriver::nfglEvaluateDepthValuesARB(void)
{
	D(bug("nfosmesa: glEvaluateDepthValuesARB()"));
	fn.glEvaluateDepthValuesARB();
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglExecuteProgramNV(GLenum target, GLuint id, memptr params)
#else
void OSMesaDriver::nfglExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glExecuteProgramNV(%s, %u, " PRI_PTR ")", gl_enum_name(target), id, AtariOffset(params)));
FN_GLEXECUTEPROGRAMNV(target, id, params);
}

void OSMesaDriver::nfglExtractComponentEXT(GLuint res, GLuint src, GLuint num)
{
	D(bug("nfosmesa: glExtractComponentEXT(%u, %u, %u)", res, src, num));
	fn.glExtractComponentEXT(res, src, num);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFeedbackBuffer(GLsizei size, GLenum type, memptr buffer)
#else
void OSMesaDriver::nfglFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
#endif
{
	D(bug("nfosmesa: glFeedbackBuffer(%d, %s, " PRI_PTR ")", size, gl_enum_name(type), AtariOffset(buffer)));
FN_GLFEEDBACKBUFFER(size, type, buffer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFeedbackBufferxOES(GLsizei n, GLenum type, memptr buffer)
#else
void OSMesaDriver::nfglFeedbackBufferxOES(GLsizei n, GLenum type, const GLfixed *buffer)
#endif
{
	D(bug("nfosmesa: glFeedbackBufferxOES(%d, %s, " PRI_PTR ")", n, gl_enum_name(type), AtariOffset(buffer)));
FN_GLFEEDBACKBUFFERXOES(n, type, buffer);
}

GLsync OSMesaDriver::nfglFenceSync(GLenum condition, GLbitfield flags)
{
	D(bug("nfosmesa: glFenceSync(%s, 0x%x)", gl_enum_name(condition), flags));
	GLsync __ret = fn.glFenceSync(condition, flags);
	return __ret;
}

void OSMesaDriver::nfglFinalCombinerInputNV(GLenum variable, GLenum input, GLenum mapping, GLenum componentUsage)
{
	D(bug("nfosmesa: glFinalCombinerInputNV(%s, %s, %s, %s)", gl_enum_name(variable), gl_enum_name(input), gl_enum_name(mapping), gl_enum_name(componentUsage)));
	fn.glFinalCombinerInputNV(variable, input, mapping, componentUsage);
}

void OSMesaDriver::nfglFinish(void)
{
	D(bug("nfosmesa: glFinish()"));
FN_GLFINISH();
}

#if NFOSMESA_POINTER_AS_MEMARG
GLint OSMesaDriver::nfglFinishAsyncSGIX(memptr markerp)
#else
GLint OSMesaDriver::nfglFinishAsyncSGIX(GLuint *markerp)
#endif
{
	D(bug("nfosmesa: glFinishAsyncSGIX(" PRI_PTR ")", AtariOffset(markerp)));
FN_GLFINISHASYNCSGIX(markerp);
}

void OSMesaDriver::nfglFinishFenceAPPLE(GLuint fence)
{
	D(bug("nfosmesa: glFinishFenceAPPLE(%u)", fence));
	fn.glFinishFenceAPPLE(fence);
}

void OSMesaDriver::nfglFinishFenceNV(GLuint fence)
{
	D(bug("nfosmesa: glFinishFenceNV(%u)", fence));
	fn.glFinishFenceNV(fence);
}

void OSMesaDriver::nfglFinishObjectAPPLE(GLenum object, GLuint name)
{
	D(bug("nfosmesa: glFinishObjectAPPLE(%s, %u)", gl_enum_name(object), name));
	fn.glFinishObjectAPPLE(object, name);
}

void OSMesaDriver::nfglFinishRenderAPPLE(void)
{
	D(bug("nfosmesa: glFinishRenderAPPLE()"));
	fn.glFinishRenderAPPLE();
}

void OSMesaDriver::nfglFinishTextureSUNX(void)
{
	D(bug("nfosmesa: glFinishTextureSUNX()"));
	fn.glFinishTextureSUNX();
}

void OSMesaDriver::nfglFlush(void)
{
	D(bug("nfosmesa: glFlush()"));
FN_GLFLUSH();
}

void OSMesaDriver::nfglFlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length)
{
	D(bug("nfosmesa: glFlushMappedBufferRange(%s, %" PRI_IPTR ", %" PRI_IPTR ")", gl_enum_name(target), offset, length));
	fn.glFlushMappedBufferRange(target, offset, length);
}

void OSMesaDriver::nfglFlushMappedBufferRangeAPPLE(GLenum target, GLintptr offset, GLsizeiptr size)
{
	D(bug("nfosmesa: glFlushMappedBufferRangeAPPLE(%s, %" PRI_IPTR ", %" PRI_IPTR ")", gl_enum_name(target), offset, size));
	fn.glFlushMappedBufferRangeAPPLE(target, offset, size);
}

void OSMesaDriver::nfglFlushMappedNamedBufferRange(GLuint buffer, GLintptr offset, GLsizeiptr length)
{
	D(bug("nfosmesa: glFlushMappedNamedBufferRange(%u, %" PRI_IPTR ", %" PRI_IPTR ")", buffer, offset, length));
	fn.glFlushMappedNamedBufferRange(buffer, offset, length);
}

void OSMesaDriver::nfglFlushMappedNamedBufferRangeEXT(GLuint buffer, GLintptr offset, GLsizeiptr length)
{
	D(bug("nfosmesa: glFlushMappedNamedBufferRangeEXT(%u, %" PRI_IPTR ", %" PRI_IPTR ")", buffer, offset, length));
	fn.glFlushMappedNamedBufferRangeEXT(buffer, offset, length);
}

void OSMesaDriver::nfglFlushPixelDataRangeNV(GLenum target)
{
	D(bug("nfosmesa: glFlushPixelDataRangeNV(%s)", gl_enum_name(target)));
	fn.glFlushPixelDataRangeNV(target);
}

void OSMesaDriver::nfglFlushRasterSGIX(void)
{
	D(bug("nfosmesa: glFlushRasterSGIX()"));
	fn.glFlushRasterSGIX();
}

void OSMesaDriver::nfglFlushRenderAPPLE(void)
{
	D(bug("nfosmesa: glFlushRenderAPPLE()"));
	fn.glFlushRenderAPPLE();
}

void OSMesaDriver::nfglFlushStaticDataIBM(GLenum target)
{
	D(bug("nfosmesa: glFlushStaticDataIBM(%s)", gl_enum_name(target)));
	fn.glFlushStaticDataIBM(target);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFlushVertexArrayRangeAPPLE(GLsizei length, memptr pointer)
#else
void OSMesaDriver::nfglFlushVertexArrayRangeAPPLE(GLsizei length, void *pointer)
#endif
{
	D(bug("nfosmesa: glFlushVertexArrayRangeAPPLE(%d, " PRI_PTR ")", length, AtariOffset(pointer)));
FN_GLFLUSHVERTEXARRAYRANGEAPPLE(length, pointer);
}

void OSMesaDriver::nfglFlushVertexArrayRangeNV(void)
{
	D(bug("nfosmesa: glFlushVertexArrayRangeNV()"));
	fn.glFlushVertexArrayRangeNV();
}

void OSMesaDriver::nfglFogCoordFormatNV(GLenum type, GLsizei stride)
{
	D(bug("nfosmesa: glFogCoordFormatNV(%s, %d)", gl_enum_name(type), stride));
	fn.glFogCoordFormatNV(type, stride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFogCoordPointer(GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglFogCoordPointer(GLenum type, GLsizei stride, const void *pointer)
#endif
{
	D(bug("nfosmesa: glFogCoordPointer(%s, %d, " PRI_PTR ")", gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLFOGCOORDPOINTER(type, stride, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFogCoordPointerEXT(GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglFogCoordPointerEXT(GLenum type, GLsizei stride, const void *pointer)
#endif
{
	D(bug("nfosmesa: glFogCoordPointerEXT(%s, %d, " PRI_PTR ")", gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLFOGCOORDPOINTEREXT(type, stride, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFogCoordPointerListIBM(GLenum type, GLint stride, memptr pointer, GLint ptrstride)
#else
void OSMesaDriver::nfglFogCoordPointerListIBM(GLenum type, GLint stride, const void * *pointer, GLint ptrstride)
#endif
{
	D(bug("nfosmesa: glFogCoordPointerListIBM(%s, %d, " PRI_PTR ", %d)", gl_enum_name(type), stride, AtariOffset(pointer), ptrstride));
FN_GLFOGCOORDPOINTERLISTIBM(type, stride, pointer, ptrstride);
}

void OSMesaDriver::nfglFogCoordd(GLdouble coord)
{
	D(bug("nfosmesa: glFogCoordd(%f)", coord));
	fn.glFogCoordd(coord);
}

void OSMesaDriver::nfglFogCoorddEXT(GLdouble coord)
{
	D(bug("nfosmesa: glFogCoorddEXT(%f)", coord));
	fn.glFogCoorddEXT(coord);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFogCoorddv(memptr coord)
#else
void OSMesaDriver::nfglFogCoorddv(const GLdouble *coord)
#endif
{
	D(bug("nfosmesa: glFogCoorddv(" PRI_PTR ")", AtariOffset(coord)));
FN_GLFOGCOORDDV(coord);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFogCoorddvEXT(memptr coord)
#else
void OSMesaDriver::nfglFogCoorddvEXT(const GLdouble *coord)
#endif
{
	D(bug("nfosmesa: glFogCoorddvEXT(" PRI_PTR ")", AtariOffset(coord)));
FN_GLFOGCOORDDVEXT(coord);
}

void OSMesaDriver::nfglFogCoordf(GLfloat coord)
{
	D(bug("nfosmesa: glFogCoordf(%f)", coord));
	fn.glFogCoordf(coord);
}

void OSMesaDriver::nfglFogCoordfEXT(GLfloat coord)
{
	D(bug("nfosmesa: glFogCoordfEXT(%f)", coord));
	fn.glFogCoordfEXT(coord);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFogCoordfv(memptr coord)
#else
void OSMesaDriver::nfglFogCoordfv(const GLfloat *coord)
#endif
{
	D(bug("nfosmesa: glFogCoordfv(" PRI_PTR ")", AtariOffset(coord)));
FN_GLFOGCOORDFV(coord);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFogCoordfvEXT(memptr coord)
#else
void OSMesaDriver::nfglFogCoordfvEXT(const GLfloat *coord)
#endif
{
	D(bug("nfosmesa: glFogCoordfvEXT(" PRI_PTR ")", AtariOffset(coord)));
FN_GLFOGCOORDFVEXT(coord);
}

void OSMesaDriver::nfglFogCoordhNV(GLhalfNV32 fog)
{
	D(bug("nfosmesa: glFogCoordhNV(%u)", fog));
	fn.glFogCoordhNV(fog);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFogCoordhvNV(memptr fog)
#else
void OSMesaDriver::nfglFogCoordhvNV(const GLhalfNV *fog)
#endif
{
	D(bug("nfosmesa: glFogCoordhvNV(" PRI_PTR ")", AtariOffset(fog)));
FN_GLFOGCOORDHVNV(fog);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFogFuncSGIS(GLsizei n, memptr points)
#else
void OSMesaDriver::nfglFogFuncSGIS(GLsizei n, const GLfloat *points)
#endif
{
	D(bug("nfosmesa: glFogFuncSGIS(%d, " PRI_PTR ")", n, AtariOffset(points)));
FN_GLFOGFUNCSGIS(n, points);
}

void OSMesaDriver::nfglFogf(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glFogf(%s, %f)", gl_enum_name(pname), param));
	fn.glFogf(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFogfv(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglFogfv(GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glFogfv(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLFOGFV(pname, params);
}

void OSMesaDriver::nfglFogi(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glFogi(%s, %d)", gl_enum_name(pname), param));
	fn.glFogi(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFogiv(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglFogiv(GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glFogiv(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLFOGIV(pname, params);
}

void OSMesaDriver::nfglFogxOES(GLenum pname, GLfixed param)
{
	D(bug("nfosmesa: glFogxOES(%s, 0x%x)", gl_enum_name(pname), param));
	fn.glFogxOES(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFogxvOES(GLenum pname, memptr param)
#else
void OSMesaDriver::nfglFogxvOES(GLenum pname, const GLfixed *param)
#endif
{
	D(bug("nfosmesa: glFogxvOES(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(param)));
FN_GLFOGXVOES(pname, param);
}

void OSMesaDriver::nfglFragmentColorMaterialSGIX(GLenum face, GLenum mode)
{
	D(bug("nfosmesa: glFragmentColorMaterialSGIX(%s, %s)", gl_enum_name(face), gl_enum_name(mode)));
	fn.glFragmentColorMaterialSGIX(face, mode);
}

void OSMesaDriver::nfglFragmentCoverageColorNV(GLuint color)
{
	D(bug("nfosmesa: glFragmentCoverageColorNV(%u)", color));
	fn.glFragmentCoverageColorNV(color);
}

void OSMesaDriver::nfglFragmentLightModelfSGIX(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glFragmentLightModelfSGIX(%s, %f)", gl_enum_name(pname), param));
	fn.glFragmentLightModelfSGIX(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFragmentLightModelfvSGIX(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglFragmentLightModelfvSGIX(GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glFragmentLightModelfvSGIX(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLFRAGMENTLIGHTMODELFVSGIX(pname, params);
}

void OSMesaDriver::nfglFragmentLightModeliSGIX(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glFragmentLightModeliSGIX(%s, %d)", gl_enum_name(pname), param));
	fn.glFragmentLightModeliSGIX(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFragmentLightModelivSGIX(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglFragmentLightModelivSGIX(GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glFragmentLightModelivSGIX(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLFRAGMENTLIGHTMODELIVSGIX(pname, params);
}

void OSMesaDriver::nfglFragmentLightfSGIX(GLenum light, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glFragmentLightfSGIX(%s, %s, %f)", gl_enum_name(light), gl_enum_name(pname), param));
	fn.glFragmentLightfSGIX(light, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFragmentLightfvSGIX(GLenum light, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglFragmentLightfvSGIX(GLenum light, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glFragmentLightfvSGIX(%s, %s, " PRI_PTR ")", gl_enum_name(light), gl_enum_name(pname), AtariOffset(params)));
FN_GLFRAGMENTLIGHTFVSGIX(light, pname, params);
}

void OSMesaDriver::nfglFragmentLightiSGIX(GLenum light, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glFragmentLightiSGIX(%s, %s, %d)", gl_enum_name(light), gl_enum_name(pname), param));
	fn.glFragmentLightiSGIX(light, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFragmentLightivSGIX(GLenum light, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglFragmentLightivSGIX(GLenum light, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glFragmentLightivSGIX(%s, %s, " PRI_PTR ")", gl_enum_name(light), gl_enum_name(pname), AtariOffset(params)));
FN_GLFRAGMENTLIGHTIVSGIX(light, pname, params);
}

void OSMesaDriver::nfglFragmentMaterialfSGIX(GLenum face, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glFragmentMaterialfSGIX(%s, %s, %f)", gl_enum_name(face), gl_enum_name(pname), param));
	fn.glFragmentMaterialfSGIX(face, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFragmentMaterialfvSGIX(GLenum face, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglFragmentMaterialfvSGIX(GLenum face, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glFragmentMaterialfvSGIX(%s, %s, " PRI_PTR ")", gl_enum_name(face), gl_enum_name(pname), AtariOffset(params)));
FN_GLFRAGMENTMATERIALFVSGIX(face, pname, params);
}

void OSMesaDriver::nfglFragmentMaterialiSGIX(GLenum face, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glFragmentMaterialiSGIX(%s, %s, %d)", gl_enum_name(face), gl_enum_name(pname), param));
	fn.glFragmentMaterialiSGIX(face, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFragmentMaterialivSGIX(GLenum face, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglFragmentMaterialivSGIX(GLenum face, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glFragmentMaterialivSGIX(%s, %s, " PRI_PTR ")", gl_enum_name(face), gl_enum_name(pname), AtariOffset(params)));
FN_GLFRAGMENTMATERIALIVSGIX(face, pname, params);
}

void OSMesaDriver::nfglFrameTerminatorGREMEDY(void)
{
	D(bug("nfosmesa: glFrameTerminatorGREMEDY()"));
	fn.glFrameTerminatorGREMEDY();
}

void OSMesaDriver::nfglFrameZoomSGIX(GLint factor)
{
	D(bug("nfosmesa: glFrameZoomSGIX(%d)", factor));
	fn.glFrameZoomSGIX(factor);
}

void OSMesaDriver::nfglFramebufferDrawBufferEXT(GLuint framebuffer, GLenum mode)
{
	D(bug("nfosmesa: glFramebufferDrawBufferEXT(%u, %s)", framebuffer, gl_enum_name(mode)));
	fn.glFramebufferDrawBufferEXT(framebuffer, mode);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFramebufferDrawBuffersEXT(GLuint framebuffer, GLsizei n, memptr bufs)
#else
void OSMesaDriver::nfglFramebufferDrawBuffersEXT(GLuint framebuffer, GLsizei n, const GLenum *bufs)
#endif
{
	D(bug("nfosmesa: glFramebufferDrawBuffersEXT(%u, %d, " PRI_PTR ")", framebuffer, n, AtariOffset(bufs)));
FN_GLFRAMEBUFFERDRAWBUFFERSEXT(framebuffer, n, bufs);
}

void OSMesaDriver::nfglFramebufferParameteri(GLenum target, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glFramebufferParameteri(%s, %s, %d)", gl_enum_name(target), gl_enum_name(pname), param));
	fn.glFramebufferParameteri(target, pname, param);
}

void OSMesaDriver::nfglFramebufferReadBufferEXT(GLuint framebuffer, GLenum mode)
{
	D(bug("nfosmesa: glFramebufferReadBufferEXT(%u, %s)", framebuffer, gl_enum_name(mode)));
	fn.glFramebufferReadBufferEXT(framebuffer, mode);
}

void OSMesaDriver::nfglFramebufferRenderbuffer(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
	D(bug("nfosmesa: glFramebufferRenderbuffer(%s, %s, %s, %u)", gl_enum_name(target), gl_enum_name(attachment), gl_enum_name(renderbuffertarget), renderbuffer));
	fn.glFramebufferRenderbuffer(target, attachment, renderbuffertarget, renderbuffer);
}

void OSMesaDriver::nfglFramebufferRenderbufferEXT(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
	D(bug("nfosmesa: glFramebufferRenderbufferEXT(%s, %s, %s, %u)", gl_enum_name(target), gl_enum_name(attachment), gl_enum_name(renderbuffertarget), renderbuffer));
	fn.glFramebufferRenderbufferEXT(target, attachment, renderbuffertarget, renderbuffer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFramebufferSampleLocationsfvARB(GLenum target, GLuint start, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglFramebufferSampleLocationsfvARB(GLenum target, GLuint start, GLsizei count, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glFramebufferSampleLocationsfvARB(%s, %u, %d, " PRI_PTR ")", gl_enum_name(target), start, count, AtariOffset(v)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __v_size = MAX(count, 0);
	GLfloat __v_tmp[__v_size];
	GLfloat *__v_ptmp = Atari2HostFloatArray(__v_size, v, __v_tmp);
	fn.glFramebufferSampleLocationsfvARB(target, start, count, __v_ptmp);
#else
	fn.glFramebufferSampleLocationsfvARB(target, start, count, HostAddr(v, const GLfloat *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFramebufferSampleLocationsfvNV(GLenum target, GLuint start, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglFramebufferSampleLocationsfvNV(GLenum target, GLuint start, GLsizei count, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glFramebufferSampleLocationsfvNV(%s, %u, %d, " PRI_PTR ")", gl_enum_name(target), start, count, AtariOffset(v)));
FN_GLFRAMEBUFFERSAMPLELOCATIONSFVNV(target, start, count, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglFramebufferSamplePositionsfvAMD(GLenum target, GLuint numsamples, GLuint pixelindex, memptr values)
#else
void OSMesaDriver::nfglFramebufferSamplePositionsfvAMD(GLenum target, GLuint numsamples, GLuint pixelindex, const GLfloat *values)
#endif
{
	D(bug("nfosmesa: glFramebufferSamplePositionsfvAMD(%s, %u, %u, " PRI_PTR ")", gl_enum_name(target), numsamples, pixelindex, AtariOffset(values)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __values_size = MAX(numsamples, 0);
	GLfloat __values_tmp[__values_size];
	GLfloat *__values_ptmp = Atari2HostFloatArray(__values_size, values, __values_tmp);
	fn.glFramebufferSamplePositionsfvAMD(target, numsamples, pixelindex, __values_ptmp);
#else
	fn.glFramebufferSamplePositionsfvAMD(target, numsamples, pixelindex, HostAddr(values, const GLfloat *));
#endif
}

void OSMesaDriver::nfglFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
{
	D(bug("nfosmesa: glFramebufferTexture(%s, %s, %u, %d)", gl_enum_name(target), gl_enum_name(attachment), texture, level));
	fn.glFramebufferTexture(target, attachment, texture, level);
}

void OSMesaDriver::nfglFramebufferTexture1D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
	D(bug("nfosmesa: glFramebufferTexture1D(%s, %s, %s, %u, %d)", gl_enum_name(target), gl_enum_name(attachment), gl_enum_name(textarget), texture, level));
	fn.glFramebufferTexture1D(target, attachment, textarget, texture, level);
}

void OSMesaDriver::nfglFramebufferTexture1DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
	D(bug("nfosmesa: glFramebufferTexture1DEXT(%s, %s, %s, %u, %d)", gl_enum_name(target), gl_enum_name(attachment), gl_enum_name(textarget), texture, level));
	fn.glFramebufferTexture1DEXT(target, attachment, textarget, texture, level);
}

void OSMesaDriver::nfglFramebufferTexture2D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
	D(bug("nfosmesa: glFramebufferTexture2D(%s, %s, %s, %u, %d)", gl_enum_name(target), gl_enum_name(attachment), gl_enum_name(textarget), texture, level));
	fn.glFramebufferTexture2D(target, attachment, textarget, texture, level);
}

void OSMesaDriver::nfglFramebufferTexture2DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
	D(bug("nfosmesa: glFramebufferTexture2DEXT(%s, %s, %s, %u, %d)", gl_enum_name(target), gl_enum_name(attachment), gl_enum_name(textarget), texture, level));
	fn.glFramebufferTexture2DEXT(target, attachment, textarget, texture, level);
}

void OSMesaDriver::nfglFramebufferTexture3D(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
{
	D(bug("nfosmesa: glFramebufferTexture3D(%s, %s, %s, %u, %d, %d)", gl_enum_name(target), gl_enum_name(attachment), gl_enum_name(textarget), texture, level, zoffset));
	fn.glFramebufferTexture3D(target, attachment, textarget, texture, level, zoffset);
}

void OSMesaDriver::nfglFramebufferTexture3DEXT(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
{
	D(bug("nfosmesa: glFramebufferTexture3DEXT(%s, %s, %s, %u, %d, %d)", gl_enum_name(target), gl_enum_name(attachment), gl_enum_name(textarget), texture, level, zoffset));
	fn.glFramebufferTexture3DEXT(target, attachment, textarget, texture, level, zoffset);
}

void OSMesaDriver::nfglFramebufferTextureARB(GLenum target, GLenum attachment, GLuint texture, GLint level)
{
	D(bug("nfosmesa: glFramebufferTextureARB(%s, %s, %u, %d)", gl_enum_name(target), gl_enum_name(attachment), texture, level));
	fn.glFramebufferTextureARB(target, attachment, texture, level);
}

void OSMesaDriver::nfglFramebufferTextureEXT(GLenum target, GLenum attachment, GLuint texture, GLint level)
{
	D(bug("nfosmesa: glFramebufferTextureEXT(%s, %s, %u, %d)", gl_enum_name(target), gl_enum_name(attachment), texture, level));
	fn.glFramebufferTextureEXT(target, attachment, texture, level);
}

void OSMesaDriver::nfglFramebufferTextureFaceARB(GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face)
{
	D(bug("nfosmesa: glFramebufferTextureFaceARB(%s, %s, %u, %d, %s)", gl_enum_name(target), gl_enum_name(attachment), texture, level, gl_enum_name(face)));
	fn.glFramebufferTextureFaceARB(target, attachment, texture, level, face);
}

void OSMesaDriver::nfglFramebufferTextureFaceEXT(GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face)
{
	D(bug("nfosmesa: glFramebufferTextureFaceEXT(%s, %s, %u, %d, %s)", gl_enum_name(target), gl_enum_name(attachment), texture, level, gl_enum_name(face)));
	fn.glFramebufferTextureFaceEXT(target, attachment, texture, level, face);
}

void OSMesaDriver::nfglFramebufferTextureLayer(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
{
	D(bug("nfosmesa: glFramebufferTextureLayer(%s, %s, %u, %d, %d)", gl_enum_name(target), gl_enum_name(attachment), texture, level, layer));
	fn.glFramebufferTextureLayer(target, attachment, texture, level, layer);
}

void OSMesaDriver::nfglFramebufferTextureLayerARB(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
{
	D(bug("nfosmesa: glFramebufferTextureLayerARB(%s, %s, %u, %d, %d)", gl_enum_name(target), gl_enum_name(attachment), texture, level, layer));
	fn.glFramebufferTextureLayerARB(target, attachment, texture, level, layer);
}

void OSMesaDriver::nfglFramebufferTextureLayerEXT(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer)
{
	D(bug("nfosmesa: glFramebufferTextureLayerEXT(%s, %s, %u, %d, %d)", gl_enum_name(target), gl_enum_name(attachment), texture, level, layer));
	fn.glFramebufferTextureLayerEXT(target, attachment, texture, level, layer);
}

void OSMesaDriver::nfglFramebufferTextureMultiviewOVR(GLenum target, GLenum attachment, GLuint texture, GLint level, GLint baseViewIndex, GLsizei numViews)
{
	D(bug("nfosmesa: glFramebufferTextureMultiviewOVR(%s, %s, %u, %d, %d, %d)", gl_enum_name(target), gl_enum_name(attachment), texture, level, baseViewIndex, numViews));
	fn.glFramebufferTextureMultiviewOVR(target, attachment, texture, level, baseViewIndex, numViews);
}

void OSMesaDriver::nfglFreeObjectBufferATI(GLuint buffer)
{
	D(bug("nfosmesa: glFreeObjectBufferATI(%u)", buffer));
FN_GLFREEOBJECTBUFFERATI(buffer);
}

void OSMesaDriver::nfglFrontFace(GLenum mode)
{
	D(bug("nfosmesa: glFrontFace(%s)", gl_enum_name(mode)));
	fn.glFrontFace(mode);
}

void OSMesaDriver::nfglFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
	D(bug("nfosmesa: glFrustum(%f, %f, %f, %f, %f, %f)", left, right, bottom, top, zNear, zFar));
	fn.glFrustum(left, right, bottom, top, zNear, zFar);
}

void OSMesaDriver::nfglFrustumfOES(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f)
{
	D(bug("nfosmesa: glFrustumfOES(%f, %f, %f, %f, %f, %f)", l, r, b, t, n, f));
	fn.glFrustumfOES(l, r, b, t, n, f);
}

void OSMesaDriver::nfglFrustumxOES(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f)
{
	D(bug("nfosmesa: glFrustumxOES(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x)", l, r, b, t, n, f));
	fn.glFrustumxOES(l, r, b, t, n, f);
}

GLuint OSMesaDriver::nfglGenAsyncMarkersSGIX(GLsizei range)
{
	D(bug("nfosmesa: glGenAsyncMarkersSGIX(%d)", range));
	GLuint __ret = fn.glGenAsyncMarkersSGIX(range);
	return __ret;
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenBuffers(GLsizei n, memptr buffers)
#else
void OSMesaDriver::nfglGenBuffers(GLsizei n, GLuint *buffers)
#endif
{
	D(bug("nfosmesa: glGenBuffers(%d, " PRI_PTR ")", n, AtariOffset(buffers)));
FN_GLGENBUFFERS(n, buffers);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenBuffersARB(GLsizei n, memptr buffers)
#else
void OSMesaDriver::nfglGenBuffersARB(GLsizei n, GLuint *buffers)
#endif
{
	D(bug("nfosmesa: glGenBuffersARB(%d, " PRI_PTR ")", n, AtariOffset(buffers)));
FN_GLGENBUFFERSARB(n, buffers);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenFencesAPPLE(GLsizei n, memptr fences)
#else
void OSMesaDriver::nfglGenFencesAPPLE(GLsizei n, GLuint *fences)
#endif
{
	D(bug("nfosmesa: glGenFencesAPPLE(%d, " PRI_PTR ")", n, AtariOffset(fences)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __fences_size = MAX(n, 0);
	GLuint __fences_tmp[__fences_size];
	fn.glGenFencesAPPLE(n, __fences_tmp);
	Host2AtariIntArray(__fences_size, __fences_tmp, fences);
#else
	fn.glGenFencesAPPLE(n, HostAddr(fences, GLuint *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenFencesNV(GLsizei n, memptr fences)
#else
void OSMesaDriver::nfglGenFencesNV(GLsizei n, GLuint *fences)
#endif
{
	D(bug("nfosmesa: glGenFencesNV(%d, " PRI_PTR ")", n, AtariOffset(fences)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __fences_size = MAX(n, 0);
	GLuint __fences_tmp[__fences_size];
	fn.glGenFencesNV(n, __fences_tmp);
	Host2AtariIntArray(__fences_size, __fences_tmp, fences);
#else
	fn.glGenFencesNV(n, HostAddr(fences, GLuint *));
#endif
}

GLuint OSMesaDriver::nfglGenFragmentShadersATI(GLuint range)
{
	D(bug("nfosmesa: glGenFragmentShadersATI(%u)", range));
	GLuint __ret = fn.glGenFragmentShadersATI(range);
	return __ret;
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenFramebuffers(GLsizei n, memptr framebuffers)
#else
void OSMesaDriver::nfglGenFramebuffers(GLsizei n, GLuint *framebuffers)
#endif
{
	D(bug("nfosmesa: glGenFramebuffers(%d, " PRI_PTR ")", n, AtariOffset(framebuffers)));
FN_GLGENFRAMEBUFFERS(n, framebuffers);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenFramebuffersEXT(GLsizei n, memptr framebuffers)
#else
void OSMesaDriver::nfglGenFramebuffersEXT(GLsizei n, GLuint *framebuffers)
#endif
{
	D(bug("nfosmesa: glGenFramebuffersEXT(%d, " PRI_PTR ")", n, AtariOffset(framebuffers)));
FN_GLGENFRAMEBUFFERSEXT(n, framebuffers);
}

GLuint OSMesaDriver::nfglGenLists(GLsizei range)
{
	D(bug("nfosmesa: glGenLists(%d)", range));
	GLuint __ret = fn.glGenLists(range);
	return __ret;
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenNamesAMD(GLenum identifier, GLuint num, memptr names)
#else
void OSMesaDriver::nfglGenNamesAMD(GLenum identifier, GLuint num, GLuint *names)
#endif
{
	D(bug("nfosmesa: glGenNamesAMD(%s, %u, " PRI_PTR ")", gl_enum_name(identifier), num, AtariOffset(names)));
FN_GLGENNAMESAMD(identifier, num, names);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenOcclusionQueriesNV(GLsizei n, memptr ids)
#else
void OSMesaDriver::nfglGenOcclusionQueriesNV(GLsizei n, GLuint *ids)
#endif
{
	D(bug("nfosmesa: glGenOcclusionQueriesNV(%d, " PRI_PTR ")", n, AtariOffset(ids)));
FN_GLGENOCCLUSIONQUERIESNV(n, ids);
}

GLuint OSMesaDriver::nfglGenPathsNV(GLsizei range)
{
	D(bug("nfosmesa: glGenPathsNV(%d)", range));
	GLuint __ret = fn.glGenPathsNV(range);
	return __ret;
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenPerfMonitorsAMD(GLsizei n, memptr monitors)
#else
void OSMesaDriver::nfglGenPerfMonitorsAMD(GLsizei n, GLuint *monitors)
#endif
{
	D(bug("nfosmesa: glGenPerfMonitorsAMD(%d, " PRI_PTR ")", n, AtariOffset(monitors)));
FN_GLGENPERFMONITORSAMD(n, monitors);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenProgramPipelines(GLsizei n, memptr pipelines)
#else
void OSMesaDriver::nfglGenProgramPipelines(GLsizei n, GLuint *pipelines)
#endif
{
	D(bug("nfosmesa: glGenProgramPipelines(%d, " PRI_PTR ")", n, AtariOffset(pipelines)));
FN_GLGENPROGRAMPIPELINES(n, pipelines);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenProgramsARB(GLsizei n, memptr programs)
#else
void OSMesaDriver::nfglGenProgramsARB(GLsizei n, GLuint *programs)
#endif
{
	D(bug("nfosmesa: glGenProgramsARB(%d, " PRI_PTR ")", n, AtariOffset(programs)));
FN_GLGENPROGRAMSARB(n, programs);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenProgramsNV(GLsizei n, memptr programs)
#else
void OSMesaDriver::nfglGenProgramsNV(GLsizei n, GLuint *programs)
#endif
{
	D(bug("nfosmesa: glGenProgramsNV(%d, " PRI_PTR ")", n, AtariOffset(programs)));
FN_GLGENPROGRAMSNV(n, programs);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenQueries(GLsizei n, memptr ids)
#else
void OSMesaDriver::nfglGenQueries(GLsizei n, GLuint *ids)
#endif
{
	D(bug("nfosmesa: glGenQueries(%d, " PRI_PTR ")", n, AtariOffset(ids)));
FN_GLGENQUERIES(n, ids);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenQueriesARB(GLsizei n, memptr ids)
#else
void OSMesaDriver::nfglGenQueriesARB(GLsizei n, GLuint *ids)
#endif
{
	D(bug("nfosmesa: glGenQueriesARB(%d, " PRI_PTR ")", n, AtariOffset(ids)));
FN_GLGENQUERIESARB(n, ids);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenQueryResourceTagNV(GLsizei n, memptr tagIds)
#else
void OSMesaDriver::nfglGenQueryResourceTagNV(GLsizei n, GLint *tagIds)
#endif
{
	D(bug("nfosmesa: glGenQueryResourceTagNV(%d, " PRI_PTR ")", n, AtariOffset(tagIds)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __tagIds_size = MAX(n, 0);
	GLint __tagIds_tmp[__tagIds_size];
	fn.glGenQueryResourceTagNV(n, __tagIds_tmp);
	Host2AtariIntArray(__tagIds_size, __tagIds_tmp, tagIds);
#else
	fn.glGenQueryResourceTagNV(n, HostAddr(tagIds, GLint *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenRenderbuffers(GLsizei n, memptr renderbuffers)
#else
void OSMesaDriver::nfglGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
#endif
{
	D(bug("nfosmesa: glGenRenderbuffers(%d, " PRI_PTR ")", n, AtariOffset(renderbuffers)));
FN_GLGENRENDERBUFFERS(n, renderbuffers);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenRenderbuffersEXT(GLsizei n, memptr renderbuffers)
#else
void OSMesaDriver::nfglGenRenderbuffersEXT(GLsizei n, GLuint *renderbuffers)
#endif
{
	D(bug("nfosmesa: glGenRenderbuffersEXT(%d, " PRI_PTR ")", n, AtariOffset(renderbuffers)));
FN_GLGENRENDERBUFFERSEXT(n, renderbuffers);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenSamplers(GLsizei count, memptr samplers)
#else
void OSMesaDriver::nfglGenSamplers(GLsizei count, GLuint *samplers)
#endif
{
	D(bug("nfosmesa: glGenSamplers(%d, " PRI_PTR ")", count, AtariOffset(samplers)));
FN_GLGENSAMPLERS(count, samplers);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenSemaphoresEXT(GLsizei n, memptr semaphores)
#else
void OSMesaDriver::nfglGenSemaphoresEXT(GLsizei n, GLuint *semaphores)
#endif
{
	D(bug("nfosmesa: glGenSemaphoresEXT(%d, " PRI_PTR ")", n, AtariOffset(semaphores)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __semaphores_size = MAX(n, 0);
	GLuint __semaphores_tmp[__semaphores_size];
	fn.glGenSemaphoresEXT(n, __semaphores_tmp);
	Host2AtariIntArray(__semaphores_size, __semaphores_tmp, semaphores);
#else
	fn.glGenSemaphoresEXT(n, HostAddr(semaphores, GLuint *));
#endif
}

GLuint OSMesaDriver::nfglGenSymbolsEXT(GLenum datatype, GLenum storagetype, GLenum range, GLuint components)
{
	D(bug("nfosmesa: glGenSymbolsEXT(%s, %s, %s, %u)", gl_enum_name(datatype), gl_enum_name(storagetype), gl_enum_name(range), components));
	GLuint __ret = fn.glGenSymbolsEXT(datatype, storagetype, range, components);
	return __ret;
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenTextures(GLsizei n, memptr textures)
#else
void OSMesaDriver::nfglGenTextures(GLsizei n, GLuint *textures)
#endif
{
	D(bug("nfosmesa: glGenTextures(%d, " PRI_PTR ")", n, AtariOffset(textures)));
FN_GLGENTEXTURES(n, textures);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenTexturesEXT(GLsizei n, memptr textures)
#else
void OSMesaDriver::nfglGenTexturesEXT(GLsizei n, GLuint *textures)
#endif
{
	D(bug("nfosmesa: glGenTexturesEXT(%d, " PRI_PTR ")", n, AtariOffset(textures)));
FN_GLGENTEXTURESEXT(n, textures);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenTransformFeedbacks(GLsizei n, memptr ids)
#else
void OSMesaDriver::nfglGenTransformFeedbacks(GLsizei n, GLuint *ids)
#endif
{
	D(bug("nfosmesa: glGenTransformFeedbacks(%d, " PRI_PTR ")", n, AtariOffset(ids)));
FN_GLGENTRANSFORMFEEDBACKS(n, ids);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenTransformFeedbacksNV(GLsizei n, memptr ids)
#else
void OSMesaDriver::nfglGenTransformFeedbacksNV(GLsizei n, GLuint *ids)
#endif
{
	D(bug("nfosmesa: glGenTransformFeedbacksNV(%d, " PRI_PTR ")", n, AtariOffset(ids)));
FN_GLGENTRANSFORMFEEDBACKSNV(n, ids);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenVertexArrays(GLsizei n, memptr arrays)
#else
void OSMesaDriver::nfglGenVertexArrays(GLsizei n, GLuint *arrays)
#endif
{
	D(bug("nfosmesa: glGenVertexArrays(%d, " PRI_PTR ")", n, AtariOffset(arrays)));
FN_GLGENVERTEXARRAYS(n, arrays);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGenVertexArraysAPPLE(GLsizei n, memptr arrays)
#else
void OSMesaDriver::nfglGenVertexArraysAPPLE(GLsizei n, GLuint *arrays)
#endif
{
	D(bug("nfosmesa: glGenVertexArraysAPPLE(%d, " PRI_PTR ")", n, AtariOffset(arrays)));
FN_GLGENVERTEXARRAYSAPPLE(n, arrays);
}

GLuint OSMesaDriver::nfglGenVertexShadersEXT(GLuint range)
{
	D(bug("nfosmesa: glGenVertexShadersEXT(%u)", range));
	GLuint __ret = fn.glGenVertexShadersEXT(range);
	return __ret;
}

void OSMesaDriver::nfglGenerateMipmap(GLenum target)
{
	D(bug("nfosmesa: glGenerateMipmap(%s)", gl_enum_name(target)));
	fn.glGenerateMipmap(target);
}

void OSMesaDriver::nfglGenerateMipmapEXT(GLenum target)
{
	D(bug("nfosmesa: glGenerateMipmapEXT(%s)", gl_enum_name(target)));
	fn.glGenerateMipmapEXT(target);
}

void OSMesaDriver::nfglGenerateMultiTexMipmapEXT(GLenum texunit, GLenum target)
{
	D(bug("nfosmesa: glGenerateMultiTexMipmapEXT(%s, %s)", gl_enum_name(texunit), gl_enum_name(target)));
	fn.glGenerateMultiTexMipmapEXT(texunit, target);
}

void OSMesaDriver::nfglGenerateTextureMipmap(GLuint texture)
{
	D(bug("nfosmesa: glGenerateTextureMipmap(%u)", texture));
	fn.glGenerateTextureMipmap(texture);
}

void OSMesaDriver::nfglGenerateTextureMipmapEXT(GLuint texture, GLenum target)
{
	D(bug("nfosmesa: glGenerateTextureMipmapEXT(%u, %s)", texture, gl_enum_name(target)));
	fn.glGenerateTextureMipmapEXT(texture, target);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetActiveAtomicCounterBufferiv(%u, %u, %s, " PRI_PTR ")", program, bufferIndex, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETACTIVEATOMICCOUNTERBUFFERIV(program, bufferIndex, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, memptr length, memptr size, memptr type, memptr name)
#else
void OSMesaDriver::nfglGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
#endif
{
	D(bug("nfosmesa: glGetActiveAttrib(%u, %u, %d, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", program, index, bufSize, AtariOffset(length), AtariOffset(size), AtariOffset(type), AtariOffset(name)));
FN_GLGETACTIVEATTRIB(program, index, bufSize, length, size, type, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, memptr length, memptr size, memptr type, memptr name)
#else
void OSMesaDriver::nfglGetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name)
#endif
{
	D(bug("nfosmesa: glGetActiveAttribARB(%u, %u, %d, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", (unsigned int)(uintptr_t)programObj, index, maxLength, AtariOffset(length), AtariOffset(size), AtariOffset(type), AtariOffset(name)));
FN_GLGETACTIVEATTRIBARB(programObj, index, maxLength, length, size, type, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, memptr length, memptr name)
#else
void OSMesaDriver::nfglGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
#endif
{
	D(bug("nfosmesa: glGetActiveSubroutineName(%u, %s, %u, %d, " PRI_PTR ", " PRI_PTR ")", program, gl_enum_name(shadertype), index, bufsize, AtariOffset(length), AtariOffset(name)));
FN_GLGETACTIVESUBROUTINENAME(program, shadertype, index, bufsize, length, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, memptr length, memptr name)
#else
void OSMesaDriver::nfglGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
#endif
{
	D(bug("nfosmesa: glGetActiveSubroutineUniformName(%u, %s, %u, %d, " PRI_PTR ", " PRI_PTR ")", program, gl_enum_name(shadertype), index, bufsize, AtariOffset(length), AtariOffset(name)));
FN_GLGETACTIVESUBROUTINEUNIFORMNAME(program, shadertype, index, bufsize, length, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, memptr values)
#else
void OSMesaDriver::nfglGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
#endif
{
	D(bug("nfosmesa: glGetActiveSubroutineUniformiv(%u, %s, %u, %s, " PRI_PTR ")", program, gl_enum_name(shadertype), index, gl_enum_name(pname), AtariOffset(values)));
FN_GLGETACTIVESUBROUTINEUNIFORMIV(program, shadertype, index, pname, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, memptr length, memptr size, memptr type, memptr name)
#else
void OSMesaDriver::nfglGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
#endif
{
	D(bug("nfosmesa: glGetActiveUniform(%u, %u, %d, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", program, index, bufSize, AtariOffset(length), AtariOffset(size), AtariOffset(type), AtariOffset(name)));
FN_GLGETACTIVEUNIFORM(program, index, bufSize, length, size, type, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, memptr length, memptr size, memptr type, memptr name)
#else
void OSMesaDriver::nfglGetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name)
#endif
{
	D(bug("nfosmesa: glGetActiveUniformARB(%u, %u, %d, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", (unsigned int)(uintptr_t)programObj, index, maxLength, AtariOffset(length), AtariOffset(size), AtariOffset(type), AtariOffset(name)));
#if NFOSMESA_NEED_BYTE_CONV || NFOSMESA_NEED_INT_CONV
	GLint const __length_size = 1;
	GLsizei __length_tmp[__length_size] = { 0 };
	GLint const __size_size = 1;
	GLint __size_tmp[__size_size] = { 0 };
	GLint const __type_size = 1;
	GLenum __type_tmp[__type_size] = { 0 };
	GLint const __name_size = MAX(maxLength, 0);
	GLcharARB __name_tmp[__name_size];
	fn.glGetActiveUniformARB(programObj, index, maxLength, __length_tmp, __size_tmp, __type_tmp, __name_tmp);
	Host2AtariIntArray(__length_size, __length_tmp, length);
	Host2AtariIntArray(__size_size, __size_tmp, size);
	Host2AtariIntArray(__type_size, __type_tmp, type);
	Host2AtariByteArray(MIN(__length_tmp[0] + 1, maxLength), __name_tmp, name);
#else
	fn.glGetActiveUniformARB(programObj, index, maxLength, HostAddr(length, GLsizei *), HostAddr(size, GLint *), HostAddr(type, GLenum *), HostAddr(name, GLcharARB *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
GLuint OSMesaDriver::nfglGetActiveUniformBlockIndex(GLuint program, memptr uniformBlockName)
#else
GLuint OSMesaDriver::nfglGetActiveUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
#endif
{
	D(bug("nfosmesa: glGetActiveUniformBlockIndex(%u, " PRI_PTR ")", program, AtariOffset(uniformBlockName)));
FN_GLGETACTIVEUNIFORMBLOCKINDEX(program, uniformBlockName);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, memptr length, memptr uniformBlockName)
#else
void OSMesaDriver::nfglGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
#endif
{
	D(bug("nfosmesa: glGetActiveUniformBlockName(%u, %u, %d, " PRI_PTR ", " PRI_PTR ")", program, uniformBlockIndex, bufSize, AtariOffset(length), AtariOffset(uniformBlockName)));
FN_GLGETACTIVEUNIFORMBLOCKNAME(program, uniformBlockIndex, bufSize, length, uniformBlockName);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetActiveUniformBlockiv(%u, %u, %s, " PRI_PTR ")", program, uniformBlockIndex, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETACTIVEUNIFORMBLOCKIV(program, uniformBlockIndex, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, memptr length, memptr uniformName)
#else
void OSMesaDriver::nfglGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
#endif
{
	D(bug("nfosmesa: glGetActiveUniformName(%u, %u, %d, " PRI_PTR ", " PRI_PTR ")", program, uniformIndex, bufSize, AtariOffset(length), AtariOffset(uniformName)));
FN_GLGETACTIVEUNIFORMNAME(program, uniformIndex, bufSize, length, uniformName);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetActiveUniformsiv(GLuint program, GLsizei uniformCount, memptr uniformIndices, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetActiveUniformsiv(%u, %d, " PRI_PTR ", %s, " PRI_PTR ")", program, uniformCount, AtariOffset(uniformIndices), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETACTIVEUNIFORMSIV(program, uniformCount, uniformIndices, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, memptr length, memptr size, memptr type, memptr name)
#else
void OSMesaDriver::nfglGetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
#endif
{
	D(bug("nfosmesa: glGetActiveVaryingNV(%u, %u, %d, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", program, index, bufSize, AtariOffset(length), AtariOffset(size), AtariOffset(type), AtariOffset(name)));
FN_GLGETACTIVEVARYINGNV(program, index, bufSize, length, size, type, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetArrayObjectfvATI(GLenum array, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetArrayObjectfvATI(GLenum array, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetArrayObjectfvATI(%s, %s, " PRI_PTR ")", gl_enum_name(array), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETARRAYOBJECTFVATI(array, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetArrayObjectivATI(GLenum array, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetArrayObjectivATI(GLenum array, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetArrayObjectivATI(%s, %s, " PRI_PTR ")", gl_enum_name(array), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETARRAYOBJECTIVATI(array, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, memptr count, memptr obj)
#else
void OSMesaDriver::nfglGetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj)
#endif
{
	D(bug("nfosmesa: glGetAttachedObjectsARB(%u, %d, " PRI_PTR ", " PRI_PTR ")", (unsigned int)(uintptr_t)containerObj, maxCount, AtariOffset(count), AtariOffset(obj)));
#if NFOSMESA_NEED_INT_CONV || NFOSMESA_NEED_INT_CONV || defined(__APPLE__)
	GLint const __count_size = 1;
	GLsizei __count_tmp[__count_size] = { 0 };
	GLint const __obj_size = MAX(maxCount, 0);
	GLhandleARB __obj_tmp[__obj_size];
	fn.glGetAttachedObjectsARB(containerObj, maxCount, __count_tmp, __obj_tmp);
	Host2AtariIntArray(__count_size, __count_tmp, count);
	Host2AtariHandleARB(MIN(__count_tmp[0], maxCount), __obj_tmp, obj);
#else
	fn.glGetAttachedObjectsARB(containerObj, maxCount, HostAddr(count, GLsizei *), HostAddr(obj, GLhandleARB *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetAttachedShaders(GLuint program, GLsizei maxCount, memptr count, memptr shaders)
#else
void OSMesaDriver::nfglGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders)
#endif
{
	D(bug("nfosmesa: glGetAttachedShaders(%u, %d, " PRI_PTR ", " PRI_PTR ")", program, maxCount, AtariOffset(count), AtariOffset(shaders)));
FN_GLGETATTACHEDSHADERS(program, maxCount, count, shaders);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLint OSMesaDriver::nfglGetAttribLocation(GLuint program, memptr name)
#else
GLint OSMesaDriver::nfglGetAttribLocation(GLuint program, const GLchar *name)
#endif
{
	D(bug("nfosmesa: glGetAttribLocation(%u, " PRI_PTR ")", program, AtariOffset(name)));
FN_GLGETATTRIBLOCATION(program, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLint OSMesaDriver::nfglGetAttribLocationARB(GLhandleARB programObj, memptr name)
#else
GLint OSMesaDriver::nfglGetAttribLocationARB(GLhandleARB programObj, const GLcharARB *name)
#endif
{
	D(bug("nfosmesa: glGetAttribLocationARB(%u, " PRI_PTR ")", (unsigned int)(uintptr_t)programObj, AtariOffset(name)));
FN_GLGETATTRIBLOCATIONARB(programObj, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetBooleanIndexedvEXT(GLenum target, GLuint index, memptr data)
#else
void OSMesaDriver::nfglGetBooleanIndexedvEXT(GLenum target, GLuint index, GLboolean *data)
#endif
{
	D(bug("nfosmesa: glGetBooleanIndexedvEXT(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(data)));
FN_GLGETBOOLEANINDEXEDVEXT(target, index, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetBooleani_v(GLenum target, GLuint index, memptr data)
#else
void OSMesaDriver::nfglGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
#endif
{
	D(bug("nfosmesa: glGetBooleani_v(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(data)));
FN_GLGETBOOLEANI_V(target, index, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetBooleanv(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetBooleanv(GLenum pname, GLboolean *params)
#endif
{
	D(bug("nfosmesa: glGetBooleanv(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLGETBOOLEANV(pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetBufferParameteri64v(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
#endif
{
	D(bug("nfosmesa: glGetBufferParameteri64v(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETBUFFERPARAMETERI64V(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetBufferParameteriv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetBufferParameteriv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETBUFFERPARAMETERIV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetBufferParameterivARB(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetBufferParameterivARB(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetBufferParameterivARB(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETBUFFERPARAMETERIVARB(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetBufferParameterui64vNV(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetBufferParameterui64vNV(GLenum target, GLenum pname, GLuint64EXT *params)
#endif
{
	D(bug("nfosmesa: glGetBufferParameterui64vNV(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETBUFFERPARAMETERUI64VNV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetBufferPointerv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetBufferPointerv(GLenum target, GLenum pname, void * *params)
#endif
{
	D(bug("nfosmesa: glGetBufferPointerv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETBUFFERPOINTERV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetBufferPointervARB(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetBufferPointervARB(GLenum target, GLenum pname, void * *params)
#endif
{
	D(bug("nfosmesa: glGetBufferPointervARB(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETBUFFERPOINTERVARB(target, pname, params);
}

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, memptr data)
#else
void OSMesaDriver::nfglGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data)
#endif
{
	D(bug("nfosmesa: glGetBufferSubData(%s, %" PRI_IPTR ", %" PRI_IPTR ", " PRI_PTR ")", gl_enum_name(target), offset, size, AtariOffset(data)));
FN_GLGETBUFFERSUBDATA(target, offset, size, data);
}
#endif

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, memptr data)
#else
void OSMesaDriver::nfglGetBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, void *data)
#endif
{
	D(bug("nfosmesa: glGetBufferSubDataARB(%s, %" PRI_IPTR ", %" PRI_IPTR ", " PRI_PTR ")", gl_enum_name(target), offset, size, AtariOffset(data)));
FN_GLGETBUFFERSUBDATAARB(target, offset, size, data);
}
#endif

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetClipPlane(GLenum plane, memptr equation)
#else
void OSMesaDriver::nfglGetClipPlane(GLenum plane, GLdouble *equation)
#endif
{
	D(bug("nfosmesa: glGetClipPlane(%s, " PRI_PTR ")", gl_enum_name(plane), AtariOffset(equation)));
FN_GLGETCLIPPLANE(plane, equation);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetClipPlanefOES(GLenum plane, memptr equation)
#else
void OSMesaDriver::nfglGetClipPlanefOES(GLenum plane, GLfloat *equation)
#endif
{
	D(bug("nfosmesa: glGetClipPlanefOES(%s, " PRI_PTR ")", gl_enum_name(plane), AtariOffset(equation)));
FN_GLGETCLIPPLANEFOES(plane, equation);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetClipPlanexOES(GLenum plane, memptr equation)
#else
void OSMesaDriver::nfglGetClipPlanexOES(GLenum plane, GLfixed *equation)
#endif
{
	D(bug("nfosmesa: glGetClipPlanexOES(%s, " PRI_PTR ")", gl_enum_name(plane), AtariOffset(equation)));
FN_GLGETCLIPPLANEXOES(plane, equation);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetColorTable(GLenum target, GLenum format, GLenum type, memptr table)
#else
void OSMesaDriver::nfglGetColorTable(GLenum target, GLenum format, GLenum type, void *table)
#endif
{
	D(bug("nfosmesa: glGetColorTable(%s, %s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(format), gl_enum_name(type), AtariOffset(table)));
FN_GLGETCOLORTABLE(target, format, type, table);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetColorTableEXT(GLenum target, GLenum format, GLenum type, memptr data)
#else
void OSMesaDriver::nfglGetColorTableEXT(GLenum target, GLenum format, GLenum type, void *data)
#endif
{
	D(bug("nfosmesa: glGetColorTableEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(format), gl_enum_name(type), AtariOffset(data)));
FN_GLGETCOLORTABLEEXT(target, format, type, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetColorTableParameterfv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetColorTableParameterfv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETCOLORTABLEPARAMETERFV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetColorTableParameterfvEXT(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetColorTableParameterfvEXT(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETCOLORTABLEPARAMETERFVEXT(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetColorTableParameterfvSGI(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetColorTableParameterfvSGI(GLenum target, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetColorTableParameterfvSGI(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETCOLORTABLEPARAMETERFVSGI(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetColorTableParameteriv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetColorTableParameteriv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETCOLORTABLEPARAMETERIV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetColorTableParameterivEXT(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetColorTableParameterivEXT(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetColorTableParameterivEXT(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETCOLORTABLEPARAMETERIVEXT(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetColorTableParameterivSGI(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetColorTableParameterivSGI(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetColorTableParameterivSGI(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETCOLORTABLEPARAMETERIVSGI(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetColorTableSGI(GLenum target, GLenum format, GLenum type, memptr table)
#else
void OSMesaDriver::nfglGetColorTableSGI(GLenum target, GLenum format, GLenum type, void *table)
#endif
{
	D(bug("nfosmesa: glGetColorTableSGI(%s, %s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(format), gl_enum_name(type), AtariOffset(table)));
FN_GLGETCOLORTABLESGI(target, format, type, table);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetCombinerInputParameterfvNV(%s, %s, %s, %s, " PRI_PTR ")", gl_enum_name(stage), gl_enum_name(portion), gl_enum_name(variable), gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLfloat __params_tmp[__params_size];
	fn.glGetCombinerInputParameterfvNV(stage, portion, variable, pname, __params_tmp);
	Host2AtariFloatArray(__params_size, __params_tmp, params);
#else
	fn.glGetCombinerInputParameterfvNV(stage, portion, variable, pname, HostAddr(params, GLfloat *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetCombinerInputParameterivNV(%s, %s, %s, %s, " PRI_PTR ")", gl_enum_name(stage), gl_enum_name(portion), gl_enum_name(variable), gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLint __params_tmp[__params_size];
	fn.glGetCombinerInputParameterivNV(stage, portion, variable, pname, __params_tmp);
	Host2AtariIntArray(__params_size, __params_tmp, params);
#else
	fn.glGetCombinerInputParameterivNV(stage, portion, variable, pname, HostAddr(params, GLint *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetCombinerOutputParameterfvNV(%s, %s, %s, " PRI_PTR ")", gl_enum_name(stage), gl_enum_name(portion), gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLfloat __params_tmp[__params_size];
	fn.glGetCombinerOutputParameterfvNV(stage, portion, pname, __params_tmp);
	Host2AtariFloatArray(__params_size, __params_tmp, params);
#else
	fn.glGetCombinerOutputParameterfvNV(stage, portion, pname, HostAddr(params, GLfloat *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetCombinerOutputParameterivNV(%s, %s, %s, " PRI_PTR ")", gl_enum_name(stage), gl_enum_name(portion), gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLint __params_tmp[__params_size];
	fn.glGetCombinerOutputParameterivNV(stage, portion, pname, __params_tmp);
	Host2AtariIntArray(__params_size, __params_tmp, params);
#else
	fn.glGetCombinerOutputParameterivNV(stage, portion, pname, HostAddr(params, GLint *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetCombinerStageParameterfvNV(GLenum stage, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetCombinerStageParameterfvNV(GLenum stage, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetCombinerStageParameterfvNV(%s, %s, " PRI_PTR ")", gl_enum_name(stage), gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLfloat __params_tmp[__params_size];
	fn.glGetCombinerStageParameterfvNV(stage, pname, __params_tmp);
	Host2AtariFloatArray(__params_size, __params_tmp, params);
#else
	fn.glGetCombinerStageParameterfvNV(stage, pname, HostAddr(params, GLfloat *));
#endif
}

GLuint OSMesaDriver::nfglGetCommandHeaderNV(GLenum tokenID, GLuint size)
{
	D(bug("nfosmesa: glGetCommandHeaderNV(%s, %u)", gl_enum_name(tokenID), size));
	GLuint __ret = fn.glGetCommandHeaderNV(tokenID, size);
	return __ret;
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetCompressedMultiTexImageEXT(GLenum texunit, GLenum target, GLint lod, memptr img)
#else
void OSMesaDriver::nfglGetCompressedMultiTexImageEXT(GLenum texunit, GLenum target, GLint lod, void *img)
#endif
{
	D(bug("nfosmesa: glGetCompressedMultiTexImageEXT(%s, %s, %d, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), lod, AtariOffset(img)));
FN_GLGETCOMPRESSEDMULTITEXIMAGEEXT(texunit, target, lod, img);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetCompressedTexImage(GLenum target, GLint level, memptr img)
#else
void OSMesaDriver::nfglGetCompressedTexImage(GLenum target, GLint level, void *img)
#endif
{
	D(bug("nfosmesa: glGetCompressedTexImage(%s, %d, " PRI_PTR ")", gl_enum_name(target), level, AtariOffset(img)));
FN_GLGETCOMPRESSEDTEXIMAGE(target, level, img);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetCompressedTexImageARB(GLenum target, GLint level, memptr img)
#else
void OSMesaDriver::nfglGetCompressedTexImageARB(GLenum target, GLint level, void *img)
#endif
{
	D(bug("nfosmesa: glGetCompressedTexImageARB(%s, %d, " PRI_PTR ")", gl_enum_name(target), level, AtariOffset(img)));
FN_GLGETCOMPRESSEDTEXIMAGEARB(target, level, img);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetCompressedTextureImage(GLuint texture, GLint level, GLsizei bufSize, memptr pixels)
#else
void OSMesaDriver::nfglGetCompressedTextureImage(GLuint texture, GLint level, GLsizei bufSize, void *pixels)
#endif
{
	D(bug("nfosmesa: glGetCompressedTextureImage(%u, %d, %d, " PRI_PTR ")", texture, level, bufSize, AtariOffset(pixels)));
FN_GLGETCOMPRESSEDTEXTUREIMAGE(texture, level, bufSize, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetCompressedTextureImageEXT(GLuint texture, GLenum target, GLint lod, memptr img)
#else
void OSMesaDriver::nfglGetCompressedTextureImageEXT(GLuint texture, GLenum target, GLint lod, void *img)
#endif
{
	D(bug("nfosmesa: glGetCompressedTextureImageEXT(%u, %s, %d, " PRI_PTR ")", texture, gl_enum_name(target), lod, AtariOffset(img)));
FN_GLGETCOMPRESSEDTEXTUREIMAGEEXT(texture, target, lod, img);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetCompressedTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, memptr pixels)
#else
void OSMesaDriver::nfglGetCompressedTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei bufSize, void *pixels)
#endif
{
	D(bug("nfosmesa: glGetCompressedTextureSubImage(%u, %d, %d, %d, %d, %d, %d, %d, %d, " PRI_PTR ")", texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, AtariOffset(pixels)));
FN_GLGETCOMPRESSEDTEXTURESUBIMAGE(texture, level, xoffset, yoffset, zoffset, width, height, depth, bufSize, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetConvolutionFilter(GLenum target, GLenum format, GLenum type, memptr image)
#else
void OSMesaDriver::nfglGetConvolutionFilter(GLenum target, GLenum format, GLenum type, void *image)
#endif
{
	D(bug("nfosmesa: glGetConvolutionFilter(%s, %s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(format), gl_enum_name(type), AtariOffset(image)));
FN_GLGETCONVOLUTIONFILTER(target, format, type, image);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetConvolutionFilterEXT(GLenum target, GLenum format, GLenum type, memptr image)
#else
void OSMesaDriver::nfglGetConvolutionFilterEXT(GLenum target, GLenum format, GLenum type, void *image)
#endif
{
	D(bug("nfosmesa: glGetConvolutionFilterEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(format), gl_enum_name(type), AtariOffset(image)));
FN_GLGETCONVOLUTIONFILTEREXT(target, format, type, image);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetConvolutionParameterfv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetConvolutionParameterfv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETCONVOLUTIONPARAMETERFV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetConvolutionParameterfvEXT(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetConvolutionParameterfvEXT(GLenum target, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetConvolutionParameterfvEXT(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETCONVOLUTIONPARAMETERFVEXT(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetConvolutionParameteriv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetConvolutionParameteriv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETCONVOLUTIONPARAMETERIV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetConvolutionParameterivEXT(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetConvolutionParameterivEXT(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetConvolutionParameterivEXT(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETCONVOLUTIONPARAMETERIVEXT(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetConvolutionParameterxvOES(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetConvolutionParameterxvOES(GLenum target, GLenum pname, GLfixed *params)
#endif
{
	D(bug("nfosmesa: glGetConvolutionParameterxvOES(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETCONVOLUTIONPARAMETERXVOES(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetCoverageModulationTableNV(GLsizei bufsize, memptr v)
#else
void OSMesaDriver::nfglGetCoverageModulationTableNV(GLsizei bufsize, GLfloat *v)
#endif
{
	D(bug("nfosmesa: glGetCoverageModulationTableNV(%d, " PRI_PTR ")", bufsize, AtariOffset(v)));
FN_GLGETCOVERAGEMODULATIONTABLENV(bufsize, v);
}

GLsizei OSMesaDriver::nfglGetDebugLogLengthMESA(GLhandleARB obj, GLenum logType, GLenum shaderType)
{
	D(bug("nfosmesa: glGetDebugLogLengthMESA(%u, %s, %s)", (unsigned int)(uintptr_t)obj, gl_enum_name(logType), gl_enum_name(shaderType)));
	GLsizei __ret = fn.glGetDebugLogLengthMESA(obj, logType, shaderType);
	return __ret;
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetDebugLogMESA(GLhandleARB obj, GLenum logType, GLenum shaderType, GLsizei maxLength, memptr length, memptr debugLog)
#else
void OSMesaDriver::nfglGetDebugLogMESA(GLhandleARB obj, GLenum logType, GLenum shaderType, GLsizei maxLength, GLsizei *length, GLcharARB *debugLog)
#endif
{
	D(bug("nfosmesa: glGetDebugLogMESA(%u, %s, %s, %d, " PRI_PTR ", " PRI_PTR ")", (unsigned int)(uintptr_t)obj, gl_enum_name(logType), gl_enum_name(shaderType), maxLength, AtariOffset(length), AtariOffset(debugLog)));
FN_GLGETDEBUGLOGMESA(obj, logType, shaderType, maxLength, length, debugLog);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLuint OSMesaDriver::nfglGetDebugMessageLog(GLuint count, GLsizei bufSize, memptr sources, memptr types, memptr ids, memptr severities, memptr lengths, memptr messageLog)
#else
GLuint OSMesaDriver::nfglGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
#endif
{
	D(bug("nfosmesa: glGetDebugMessageLog(%u, %d, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", count, bufSize, AtariOffset(sources), AtariOffset(types), AtariOffset(ids), AtariOffset(severities), AtariOffset(lengths), AtariOffset(messageLog)));
FN_GLGETDEBUGMESSAGELOG(count, bufSize, sources, types, ids, severities, lengths, messageLog);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLuint OSMesaDriver::nfglGetDebugMessageLogAMD(GLuint count, GLsizei bufsize, memptr categories, memptr severities, memptr ids, memptr lengths, memptr message)
#else
GLuint OSMesaDriver::nfglGetDebugMessageLogAMD(GLuint count, GLsizei bufsize, GLenum *categories, GLuint *severities, GLuint *ids, GLsizei *lengths, GLchar *message)
#endif
{
	D(bug("nfosmesa: glGetDebugMessageLogAMD(%u, %d, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", count, bufsize, AtariOffset(categories), AtariOffset(severities), AtariOffset(ids), AtariOffset(lengths), AtariOffset(message)));
#if NFOSMESA_NEED_BYTE_CONV || NFOSMESA_NEED_INT_CONV
	GLint const __categories_size = MAX(count, 0);
	GLenum __categories_tmp[__categories_size];
	GLint const __severities_size = MAX(count, 0);
	GLuint __severities_tmp[__severities_size];
	GLint const __ids_size = MAX(count, 0);
	GLuint __ids_tmp[__ids_size];
	GLint const __lengths_size = MAX(count, 0);
	GLsizei __lengths_tmp[__lengths_size];
	GLint const __message_size = MAX(bufsize, 0);
	GLchar __message_tmp[__message_size];
	GLuint __ret = fn.glGetDebugMessageLogAMD(count, bufsize, __categories_tmp, __severities_tmp, __ids_tmp, __lengths_tmp, __message_tmp);
	Host2AtariIntArray(MIN(__ret, count), __categories_tmp, categories);
	Host2AtariIntArray(MIN(__ret, count), __severities_tmp, severities);
	Host2AtariIntArray(MIN(__ret, count), __ids_tmp, ids);
	Host2AtariIntArray(MIN(__ret, count), __lengths_tmp, lengths);
	Host2AtariByteArray(__message_size, __message_tmp, message);
#else
	GLuint __ret = fn.glGetDebugMessageLogAMD(count, bufsize, HostAddr(categories, GLenum *), HostAddr(severities, GLuint *), HostAddr(ids, GLuint *), HostAddr(lengths, GLsizei *), HostAddr(message, GLchar *));
#endif
	return __ret;
}

#if NFOSMESA_POINTER_AS_MEMARG
GLuint OSMesaDriver::nfglGetDebugMessageLogARB(GLuint count, GLsizei bufSize, memptr sources, memptr types, memptr ids, memptr severities, memptr lengths, memptr messageLog)
#else
GLuint OSMesaDriver::nfglGetDebugMessageLogARB(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
#endif
{
	D(bug("nfosmesa: glGetDebugMessageLogARB(%u, %d, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", count, bufSize, AtariOffset(sources), AtariOffset(types), AtariOffset(ids), AtariOffset(severities), AtariOffset(lengths), AtariOffset(messageLog)));
#if NFOSMESA_NEED_BYTE_CONV || NFOSMESA_NEED_INT_CONV
	GLint const __sources_size = MAX(count, 0);
	GLenum __sources_tmp[__sources_size];
	GLint const __types_size = MAX(count, 0);
	GLenum __types_tmp[__types_size];
	GLint const __ids_size = MAX(count, 0);
	GLuint __ids_tmp[__ids_size];
	GLint const __severities_size = MAX(count, 0);
	GLenum __severities_tmp[__severities_size];
	GLint const __lengths_size = MAX(count, 0);
	GLsizei __lengths_tmp[__lengths_size];
	GLint const __messageLog_size = MAX(bufSize, 0);
	GLchar __messageLog_tmp[__messageLog_size];
	GLuint __ret = fn.glGetDebugMessageLogARB(count, bufSize, __sources_tmp, __types_tmp, __ids_tmp, __severities_tmp, __lengths_tmp, __messageLog_tmp);
	Host2AtariIntArray(MIN(__ret, count), __sources_tmp, sources);
	Host2AtariIntArray(MIN(__ret, count), __types_tmp, types);
	Host2AtariIntArray(MIN(__ret, count), __ids_tmp, ids);
	Host2AtariIntArray(MIN(__ret, count), __severities_tmp, severities);
	Host2AtariIntArray(MIN(__ret, count), __lengths_tmp, lengths);
	Host2AtariByteArray(__messageLog_size, __messageLog_tmp, messageLog);
#else
	GLuint __ret = fn.glGetDebugMessageLogARB(count, bufSize, HostAddr(sources, GLenum *), HostAddr(types, GLenum *), HostAddr(ids, GLuint *), HostAddr(severities, GLenum *), HostAddr(lengths, GLsizei *), HostAddr(messageLog, GLchar *));
#endif
	return __ret;
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetDetailTexFuncSGIS(GLenum target, memptr points)
#else
void OSMesaDriver::nfglGetDetailTexFuncSGIS(GLenum target, GLfloat *points)
#endif
{
	D(bug("nfosmesa: glGetDetailTexFuncSGIS(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(points)));
FN_GLGETDETAILTEXFUNCSGIS(target, points);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetDoubleIndexedvEXT(GLenum target, GLuint index, memptr data)
#else
void OSMesaDriver::nfglGetDoubleIndexedvEXT(GLenum target, GLuint index, GLdouble *data)
#endif
{
	D(bug("nfosmesa: glGetDoubleIndexedvEXT(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(data)));
FN_GLGETDOUBLEINDEXEDVEXT(target, index, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetDoublei_v(GLenum target, GLuint index, memptr data)
#else
void OSMesaDriver::nfglGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
#endif
{
	D(bug("nfosmesa: glGetDoublei_v(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(data)));
FN_GLGETDOUBLEI_V(target, index, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetDoublei_vEXT(GLenum pname, GLuint index, memptr params)
#else
void OSMesaDriver::nfglGetDoublei_vEXT(GLenum pname, GLuint index, GLdouble *params)
#endif
{
	D(bug("nfosmesa: glGetDoublei_vEXT(%s, %u, " PRI_PTR ")", gl_enum_name(pname), index, AtariOffset(params)));
FN_GLGETDOUBLEI_VEXT(pname, index, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetDoublev(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetDoublev(GLenum pname, GLdouble *params)
#endif
{
	D(bug("nfosmesa: glGetDoublev(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLGETDOUBLEV(pname, params);
}

GLenum OSMesaDriver::nfglGetError(void)
{
	D(bug("nfosmesa: glGetError()"));
FN_GLGETERROR();
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetFenceivNV(GLuint fence, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetFenceivNV(GLuint fence, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetFenceivNV(%u, %s, " PRI_PTR ")", fence, gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLint __params_tmp[__params_size];
	fn.glGetFenceivNV(fence, pname, __params_tmp);
	Host2AtariIntArray(__params_size, __params_tmp, params);
#else
	fn.glGetFenceivNV(fence, pname, HostAddr(params, GLint *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetFinalCombinerInputParameterfvNV(%s, %s, " PRI_PTR ")", gl_enum_name(variable), gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLfloat __params_tmp[__params_size];
	fn.glGetFinalCombinerInputParameterfvNV(variable, pname, __params_tmp);
	Host2AtariFloatArray(__params_size, __params_tmp, params);
#else
	fn.glGetFinalCombinerInputParameterfvNV(variable, pname, HostAddr(params, GLfloat *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetFinalCombinerInputParameterivNV(%s, %s, " PRI_PTR ")", gl_enum_name(variable), gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLint __params_tmp[__params_size];
	fn.glGetFinalCombinerInputParameterivNV(variable, pname, __params_tmp);
	Host2AtariIntArray(__params_size, __params_tmp, params);
#else
	fn.glGetFinalCombinerInputParameterivNV(variable, pname, HostAddr(params, GLint *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetFirstPerfQueryIdINTEL(memptr queryId)
#else
void OSMesaDriver::nfglGetFirstPerfQueryIdINTEL(GLuint *queryId)
#endif
{
	D(bug("nfosmesa: glGetFirstPerfQueryIdINTEL(" PRI_PTR ")", AtariOffset(queryId)));
FN_GLGETFIRSTPERFQUERYIDINTEL(queryId);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetFixedvOES(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetFixedvOES(GLenum pname, GLfixed *params)
#endif
{
	D(bug("nfosmesa: glGetFixedvOES(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLGETFIXEDVOES(pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetFloatIndexedvEXT(GLenum target, GLuint index, memptr data)
#else
void OSMesaDriver::nfglGetFloatIndexedvEXT(GLenum target, GLuint index, GLfloat *data)
#endif
{
	D(bug("nfosmesa: glGetFloatIndexedvEXT(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(data)));
FN_GLGETFLOATINDEXEDVEXT(target, index, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetFloati_v(GLenum target, GLuint index, memptr data)
#else
void OSMesaDriver::nfglGetFloati_v(GLenum target, GLuint index, GLfloat *data)
#endif
{
	D(bug("nfosmesa: glGetFloati_v(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(data)));
FN_GLGETFLOATI_V(target, index, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetFloati_vEXT(GLenum pname, GLuint index, memptr params)
#else
void OSMesaDriver::nfglGetFloati_vEXT(GLenum pname, GLuint index, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetFloati_vEXT(%s, %u, " PRI_PTR ")", gl_enum_name(pname), index, AtariOffset(params)));
FN_GLGETFLOATI_VEXT(pname, index, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetFloatv(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetFloatv(GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetFloatv(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLGETFLOATV(pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetFogFuncSGIS(memptr points)
#else
void OSMesaDriver::nfglGetFogFuncSGIS(GLfloat *points)
#endif
{
	D(bug("nfosmesa: glGetFogFuncSGIS(" PRI_PTR ")", AtariOffset(points)));
FN_GLGETFOGFUNCSGIS(points);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLint OSMesaDriver::nfglGetFragDataIndex(GLuint program, memptr name)
#else
GLint OSMesaDriver::nfglGetFragDataIndex(GLuint program, const GLchar *name)
#endif
{
	D(bug("nfosmesa: glGetFragDataIndex(%u, " PRI_PTR ")", program, AtariOffset(name)));
FN_GLGETFRAGDATAINDEX(program, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLint OSMesaDriver::nfglGetFragDataLocation(GLuint program, memptr name)
#else
GLint OSMesaDriver::nfglGetFragDataLocation(GLuint program, const GLchar *name)
#endif
{
	D(bug("nfosmesa: glGetFragDataLocation(%u, " PRI_PTR ")", program, AtariOffset(name)));
FN_GLGETFRAGDATALOCATION(program, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLint OSMesaDriver::nfglGetFragDataLocationEXT(GLuint program, memptr name)
#else
GLint OSMesaDriver::nfglGetFragDataLocationEXT(GLuint program, const GLchar *name)
#endif
{
	D(bug("nfosmesa: glGetFragDataLocationEXT(%u, " PRI_PTR ")", program, AtariOffset(name)));
FN_GLGETFRAGDATALOCATIONEXT(program, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetFragmentLightfvSGIX(GLenum light, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetFragmentLightfvSGIX(GLenum light, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetFragmentLightfvSGIX(%s, %s, " PRI_PTR ")", gl_enum_name(light), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETFRAGMENTLIGHTFVSGIX(light, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetFragmentLightivSGIX(GLenum light, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetFragmentLightivSGIX(GLenum light, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetFragmentLightivSGIX(%s, %s, " PRI_PTR ")", gl_enum_name(light), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETFRAGMENTLIGHTIVSGIX(light, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetFragmentMaterialfvSGIX(GLenum face, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetFragmentMaterialfvSGIX(GLenum face, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetFragmentMaterialfvSGIX(%s, %s, " PRI_PTR ")", gl_enum_name(face), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETFRAGMENTMATERIALFVSGIX(face, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetFragmentMaterialivSGIX(GLenum face, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetFragmentMaterialivSGIX(GLenum face, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetFragmentMaterialivSGIX(%s, %s, " PRI_PTR ")", gl_enum_name(face), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETFRAGMENTMATERIALIVSGIX(face, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetFramebufferAttachmentParameteriv(%s, %s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(attachment), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETFRAMEBUFFERATTACHMENTPARAMETERIV(target, attachment, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetFramebufferAttachmentParameterivEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(attachment), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXT(target, attachment, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetFramebufferParameterfvAMD(GLenum target, GLenum pname, GLuint numsamples, GLuint pixelindex, GLsizei size, memptr values)
#else
void OSMesaDriver::nfglGetFramebufferParameterfvAMD(GLenum target, GLenum pname, GLuint numsamples, GLuint pixelindex, GLsizei size, GLfloat *values)
#endif
{
	D(bug("nfosmesa: glGetFramebufferParameterfvAMD(%s, %s, %u, %u, %d, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), numsamples, pixelindex, size, AtariOffset(values)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __values_size = MAX(numsamples, 0);
	GLfloat __values_tmp[__values_size];
	fn.glGetFramebufferParameterfvAMD(target, pname, numsamples, pixelindex, size, __values_tmp);
	Host2AtariFloatArray(__values_size, __values_tmp, values);
#else
	fn.glGetFramebufferParameterfvAMD(target, pname, numsamples, pixelindex, size, HostAddr(values, GLfloat *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetFramebufferParameteriv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetFramebufferParameteriv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETFRAMEBUFFERPARAMETERIV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetFramebufferParameterivEXT(GLuint framebuffer, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetFramebufferParameterivEXT(GLuint framebuffer, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetFramebufferParameterivEXT(%u, %s, " PRI_PTR ")", framebuffer, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETFRAMEBUFFERPARAMETERIVEXT(framebuffer, pname, params);
}

GLenum OSMesaDriver::nfglGetGraphicsResetStatus(void)
{
	D(bug("nfosmesa: glGetGraphicsResetStatus()"));
	GLenum __ret = fn.glGetGraphicsResetStatus();
	return __ret;
}

GLenum OSMesaDriver::nfglGetGraphicsResetStatusARB(void)
{
	D(bug("nfosmesa: glGetGraphicsResetStatusARB()"));
	GLenum __ret = fn.glGetGraphicsResetStatusARB();
	return __ret;
}

GLhandleARB OSMesaDriver::nfglGetHandleARB(GLenum pname)
{
	D(bug("nfosmesa: glGetHandleARB(%s)", gl_enum_name(pname)));
	GLhandleARB __ret = fn.glGetHandleARB(pname);
	return __ret;
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetHistogram(GLenum target, GLboolean32 reset, GLenum format, GLenum type, memptr values)
#else
void OSMesaDriver::nfglGetHistogram(GLenum target, GLboolean32 reset, GLenum format, GLenum type, void *values)
#endif
{
	D(bug("nfosmesa: glGetHistogram(%s, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), reset, gl_enum_name(format), gl_enum_name(type), AtariOffset(values)));
FN_GLGETHISTOGRAM(target, reset, format, type, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetHistogramEXT(GLenum target, GLboolean32 reset, GLenum format, GLenum type, memptr values)
#else
void OSMesaDriver::nfglGetHistogramEXT(GLenum target, GLboolean32 reset, GLenum format, GLenum type, void *values)
#endif
{
	D(bug("nfosmesa: glGetHistogramEXT(%s, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), reset, gl_enum_name(format), gl_enum_name(type), AtariOffset(values)));
FN_GLGETHISTOGRAMEXT(target, reset, format, type, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetHistogramParameterfv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetHistogramParameterfv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETHISTOGRAMPARAMETERFV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetHistogramParameterfvEXT(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetHistogramParameterfvEXT(GLenum target, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetHistogramParameterfvEXT(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETHISTOGRAMPARAMETERFVEXT(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetHistogramParameteriv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetHistogramParameteriv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETHISTOGRAMPARAMETERIV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetHistogramParameterivEXT(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetHistogramParameterivEXT(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetHistogramParameterivEXT(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETHISTOGRAMPARAMETERIVEXT(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetHistogramParameterxvOES(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetHistogramParameterxvOES(GLenum target, GLenum pname, GLfixed *params)
#endif
{
	D(bug("nfosmesa: glGetHistogramParameterxvOES(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETHISTOGRAMPARAMETERXVOES(target, pname, params);
}

GLuint64 OSMesaDriver::nfglGetImageHandleARB(GLuint texture, GLint level, GLboolean32 layered, GLint layer, GLenum format)
{
	D(bug("nfosmesa: glGetImageHandleARB(%u, %d, %d, %d, %s)", texture, level, layered, layer, gl_enum_name(format)));
FN_GLGETIMAGEHANDLEARB(texture, level, layered, layer, format);
}

GLuint64 OSMesaDriver::nfglGetImageHandleNV(GLuint texture, GLint level, GLboolean32 layered, GLint layer, GLenum format)
{
	D(bug("nfosmesa: glGetImageHandleNV(%u, %d, %d, %d, %s)", texture, level, layered, layer, gl_enum_name(format)));
FN_GLGETIMAGEHANDLENV(texture, level, layered, layer, format);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetImageTransformParameterfvHP(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetImageTransformParameterfvHP(GLenum target, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetImageTransformParameterfvHP(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETIMAGETRANSFORMPARAMETERFVHP(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetImageTransformParameterivHP(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetImageTransformParameterivHP(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetImageTransformParameterivHP(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETIMAGETRANSFORMPARAMETERIVHP(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetInfoLogARB(GLhandleARB obj, GLsizei maxLength, memptr length, memptr infoLog)
#else
void OSMesaDriver::nfglGetInfoLogARB(GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog)
#endif
{
	D(bug("nfosmesa: glGetInfoLogARB(%u, %d, " PRI_PTR ", " PRI_PTR ")", (unsigned int)(uintptr_t)obj, maxLength, AtariOffset(length), AtariOffset(infoLog)));
#if NFOSMESA_NEED_BYTE_CONV || NFOSMESA_NEED_INT_CONV
	GLint const __length_size = 1;
	GLsizei __length_tmp[__length_size] = { 0 };
	GLint const __infoLog_size = MAX(maxLength, 0);
	GLcharARB __infoLog_tmp[__infoLog_size];
	fn.glGetInfoLogARB(obj, maxLength, __length_tmp, __infoLog_tmp);
	Host2AtariIntArray(__length_size, __length_tmp, length);
	Host2AtariByteArray(MIN(__length_tmp[0] + 1, maxLength), __infoLog_tmp, infoLog);
#else
	fn.glGetInfoLogARB(obj, maxLength, HostAddr(length, GLsizei *), HostAddr(infoLog, GLcharARB *));
#endif
}

GLint OSMesaDriver::nfglGetInstrumentsSGIX(void)
{
	D(bug("nfosmesa: glGetInstrumentsSGIX()"));
	GLint __ret = fn.glGetInstrumentsSGIX();
	return __ret;
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetInteger64i_v(GLenum target, GLuint index, memptr data)
#else
void OSMesaDriver::nfglGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
#endif
{
	D(bug("nfosmesa: glGetInteger64i_v(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(data)));
FN_GLGETINTEGER64I_V(target, index, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetInteger64v(GLenum pname, memptr data)
#else
void OSMesaDriver::nfglGetInteger64v(GLenum pname, GLint64 *data)
#endif
{
	D(bug("nfosmesa: glGetInteger64v(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(data)));
FN_GLGETINTEGER64V(pname, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetIntegerIndexedvEXT(GLenum target, GLuint index, memptr data)
#else
void OSMesaDriver::nfglGetIntegerIndexedvEXT(GLenum target, GLuint index, GLint *data)
#endif
{
	D(bug("nfosmesa: glGetIntegerIndexedvEXT(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(data)));
FN_GLGETINTEGERINDEXEDVEXT(target, index, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetIntegeri_v(GLenum target, GLuint index, memptr data)
#else
void OSMesaDriver::nfglGetIntegeri_v(GLenum target, GLuint index, GLint *data)
#endif
{
	D(bug("nfosmesa: glGetIntegeri_v(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(data)));
FN_GLGETINTEGERI_V(target, index, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetIntegerui64i_vNV(GLenum value, GLuint index, memptr result)
#else
void OSMesaDriver::nfglGetIntegerui64i_vNV(GLenum value, GLuint index, GLuint64EXT *result)
#endif
{
	D(bug("nfosmesa: glGetIntegerui64i_vNV(%s, %u, " PRI_PTR ")", gl_enum_name(value), index, AtariOffset(result)));
FN_GLGETINTEGERUI64I_VNV(value, index, result);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetIntegerui64vNV(GLenum value, memptr result)
#else
void OSMesaDriver::nfglGetIntegerui64vNV(GLenum value, GLuint64EXT *result)
#endif
{
	D(bug("nfosmesa: glGetIntegerui64vNV(%s, " PRI_PTR ")", gl_enum_name(value), AtariOffset(result)));
FN_GLGETINTEGERUI64VNV(value, result);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetIntegerv(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetIntegerv(GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetIntegerv(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLGETINTEGERV(pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetInternalformatSampleivNV(GLenum target, GLenum internalformat, GLsizei samples, GLenum pname, GLsizei bufSize, memptr params)
#else
void OSMesaDriver::nfglGetInternalformatSampleivNV(GLenum target, GLenum internalformat, GLsizei samples, GLenum pname, GLsizei bufSize, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetInternalformatSampleivNV(%s, %s, %d, %s, %d, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(internalformat), samples, gl_enum_name(pname), bufSize, AtariOffset(params)));
FN_GLGETINTERNALFORMATSAMPLEIVNV(target, internalformat, samples, pname, bufSize, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, memptr params)
#else
void OSMesaDriver::nfglGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params)
#endif
{
	D(bug("nfosmesa: glGetInternalformati64v(%s, %s, %s, %d, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(internalformat), gl_enum_name(pname), bufSize, AtariOffset(params)));
FN_GLGETINTERNALFORMATI64V(target, internalformat, pname, bufSize, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, memptr params)
#else
void OSMesaDriver::nfglGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetInternalformativ(%s, %s, %s, %d, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(internalformat), gl_enum_name(pname), bufSize, AtariOffset(params)));
FN_GLGETINTERNALFORMATIV(target, internalformat, pname, bufSize, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetInvariantBooleanvEXT(GLuint id, GLenum value, memptr data)
#else
void OSMesaDriver::nfglGetInvariantBooleanvEXT(GLuint id, GLenum value, GLboolean *data)
#endif
{
	D(bug("nfosmesa: glGetInvariantBooleanvEXT(%u, %s, " PRI_PTR ")", id, gl_enum_name(value), AtariOffset(data)));
FN_GLGETINVARIANTBOOLEANVEXT(id, value, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetInvariantFloatvEXT(GLuint id, GLenum value, memptr data)
#else
void OSMesaDriver::nfglGetInvariantFloatvEXT(GLuint id, GLenum value, GLfloat *data)
#endif
{
	D(bug("nfosmesa: glGetInvariantFloatvEXT(%u, %s, " PRI_PTR ")", id, gl_enum_name(value), AtariOffset(data)));
FN_GLGETINVARIANTFLOATVEXT(id, value, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetInvariantIntegervEXT(GLuint id, GLenum value, memptr data)
#else
void OSMesaDriver::nfglGetInvariantIntegervEXT(GLuint id, GLenum value, GLint *data)
#endif
{
	D(bug("nfosmesa: glGetInvariantIntegervEXT(%u, %s, " PRI_PTR ")", id, gl_enum_name(value), AtariOffset(data)));
FN_GLGETINVARIANTINTEGERVEXT(id, value, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetLightfv(GLenum light, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetLightfv(GLenum light, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetLightfv(%s, %s, " PRI_PTR ")", gl_enum_name(light), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETLIGHTFV(light, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetLightiv(GLenum light, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetLightiv(GLenum light, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetLightiv(%s, %s, " PRI_PTR ")", gl_enum_name(light), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETLIGHTIV(light, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetLightxOES(GLenum light, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetLightxOES(GLenum light, GLenum pname, GLfixed *params)
#endif
{
	D(bug("nfosmesa: glGetLightxOES(%s, %s, " PRI_PTR ")", gl_enum_name(light), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETLIGHTXOES(light, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetListParameterfvSGIX(GLuint list, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetListParameterfvSGIX(GLuint list, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetListParameterfvSGIX(%u, %s, " PRI_PTR ")", list, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETLISTPARAMETERFVSGIX(list, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetListParameterivSGIX(GLuint list, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetListParameterivSGIX(GLuint list, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetListParameterivSGIX(%u, %s, " PRI_PTR ")", list, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETLISTPARAMETERIVSGIX(list, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetLocalConstantBooleanvEXT(GLuint id, GLenum value, memptr data)
#else
void OSMesaDriver::nfglGetLocalConstantBooleanvEXT(GLuint id, GLenum value, GLboolean *data)
#endif
{
	D(bug("nfosmesa: glGetLocalConstantBooleanvEXT(%u, %s, " PRI_PTR ")", id, gl_enum_name(value), AtariOffset(data)));
FN_GLGETLOCALCONSTANTBOOLEANVEXT(id, value, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetLocalConstantFloatvEXT(GLuint id, GLenum value, memptr data)
#else
void OSMesaDriver::nfglGetLocalConstantFloatvEXT(GLuint id, GLenum value, GLfloat *data)
#endif
{
	D(bug("nfosmesa: glGetLocalConstantFloatvEXT(%u, %s, " PRI_PTR ")", id, gl_enum_name(value), AtariOffset(data)));
FN_GLGETLOCALCONSTANTFLOATVEXT(id, value, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetLocalConstantIntegervEXT(GLuint id, GLenum value, memptr data)
#else
void OSMesaDriver::nfglGetLocalConstantIntegervEXT(GLuint id, GLenum value, GLint *data)
#endif
{
	D(bug("nfosmesa: glGetLocalConstantIntegervEXT(%u, %s, " PRI_PTR ")", id, gl_enum_name(value), AtariOffset(data)));
FN_GLGETLOCALCONSTANTINTEGERVEXT(id, value, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetMapAttribParameterfvNV(%s, %u, %s, " PRI_PTR ")", gl_enum_name(target), index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMAPATTRIBPARAMETERFVNV(target, index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetMapAttribParameterivNV(%s, %u, %s, " PRI_PTR ")", gl_enum_name(target), index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMAPATTRIBPARAMETERIVNV(target, index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean32 packed, memptr points)
#else
void OSMesaDriver::nfglGetMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean32 packed, void *points)
#endif
{
	D(bug("nfosmesa: glGetMapControlPointsNV(%s, %u, %s, %d, %d, %d, " PRI_PTR ")", gl_enum_name(target), index, gl_enum_name(type), ustride, vstride, packed, AtariOffset(points)));
FN_GLGETMAPCONTROLPOINTSNV(target, index, type, ustride, vstride, packed, points);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMapParameterfvNV(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMapParameterfvNV(GLenum target, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetMapParameterfvNV(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMAPPARAMETERFVNV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMapParameterivNV(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMapParameterivNV(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetMapParameterivNV(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMAPPARAMETERIVNV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMapdv(GLenum target, GLenum query, memptr v)
#else
void OSMesaDriver::nfglGetMapdv(GLenum target, GLenum query, GLdouble *v)
#endif
{
	D(bug("nfosmesa: glGetMapdv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(query), AtariOffset(v)));
FN_GLGETMAPDV(target, query, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMapfv(GLenum target, GLenum query, memptr v)
#else
void OSMesaDriver::nfglGetMapfv(GLenum target, GLenum query, GLfloat *v)
#endif
{
	D(bug("nfosmesa: glGetMapfv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(query), AtariOffset(v)));
FN_GLGETMAPFV(target, query, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMapiv(GLenum target, GLenum query, memptr v)
#else
void OSMesaDriver::nfglGetMapiv(GLenum target, GLenum query, GLint *v)
#endif
{
	D(bug("nfosmesa: glGetMapiv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(query), AtariOffset(v)));
FN_GLGETMAPIV(target, query, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMapxvOES(GLenum target, GLenum query, memptr v)
#else
void OSMesaDriver::nfglGetMapxvOES(GLenum target, GLenum query, GLfixed *v)
#endif
{
	D(bug("nfosmesa: glGetMapxvOES(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(query), AtariOffset(v)));
FN_GLGETMAPXVOES(target, query, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMaterialfv(GLenum face, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetMaterialfv(%s, %s, " PRI_PTR ")", gl_enum_name(face), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMATERIALFV(face, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMaterialiv(GLenum face, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMaterialiv(GLenum face, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetMaterialiv(%s, %s, " PRI_PTR ")", gl_enum_name(face), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMATERIALIV(face, pname, params);
}

void OSMesaDriver::nfglGetMaterialxOES(GLenum face, GLenum pname, GLfixed param)
{
	D(bug("nfosmesa: glGetMaterialxOES(%s, %s, 0x%x)", gl_enum_name(face), gl_enum_name(pname), param));
	fn.glGetMaterialxOES(face, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMemoryObjectParameterivEXT(GLuint memoryObject, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMemoryObjectParameterivEXT(GLuint memoryObject, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetMemoryObjectParameterivEXT(%u, %s, " PRI_PTR ")", memoryObject, gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLint __params_tmp[__params_size];
	fn.glGetMemoryObjectParameterivEXT(memoryObject, pname, __params_tmp);
	Host2AtariIntArray(__params_size, __params_tmp, params);
#else
	fn.glGetMemoryObjectParameterivEXT(memoryObject, pname, HostAddr(params, GLint *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMinmax(GLenum target, GLboolean32 reset, GLenum format, GLenum type, memptr values)
#else
void OSMesaDriver::nfglGetMinmax(GLenum target, GLboolean32 reset, GLenum format, GLenum type, void *values)
#endif
{
	D(bug("nfosmesa: glGetMinmax(%s, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), reset, gl_enum_name(format), gl_enum_name(type), AtariOffset(values)));
FN_GLGETMINMAX(target, reset, format, type, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMinmaxEXT(GLenum target, GLboolean32 reset, GLenum format, GLenum type, memptr values)
#else
void OSMesaDriver::nfglGetMinmaxEXT(GLenum target, GLboolean32 reset, GLenum format, GLenum type, void *values)
#endif
{
	D(bug("nfosmesa: glGetMinmaxEXT(%s, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), reset, gl_enum_name(format), gl_enum_name(type), AtariOffset(values)));
FN_GLGETMINMAXEXT(target, reset, format, type, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMinmaxParameterfv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetMinmaxParameterfv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMINMAXPARAMETERFV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMinmaxParameterfvEXT(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMinmaxParameterfvEXT(GLenum target, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetMinmaxParameterfvEXT(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMINMAXPARAMETERFVEXT(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMinmaxParameteriv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetMinmaxParameteriv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMINMAXPARAMETERIV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMinmaxParameterivEXT(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMinmaxParameterivEXT(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetMinmaxParameterivEXT(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMINMAXPARAMETERIVEXT(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMultiTexEnvfvEXT(GLenum texunit, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMultiTexEnvfvEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetMultiTexEnvfvEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMULTITEXENVFVEXT(texunit, target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMultiTexEnvivEXT(GLenum texunit, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMultiTexEnvivEXT(GLenum texunit, GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetMultiTexEnvivEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMULTITEXENVIVEXT(texunit, target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMultiTexGendvEXT(GLenum texunit, GLenum coord, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMultiTexGendvEXT(GLenum texunit, GLenum coord, GLenum pname, GLdouble *params)
#endif
{
	D(bug("nfosmesa: glGetMultiTexGendvEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(coord), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMULTITEXGENDVEXT(texunit, coord, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMultiTexGenfvEXT(GLenum texunit, GLenum coord, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMultiTexGenfvEXT(GLenum texunit, GLenum coord, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetMultiTexGenfvEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(coord), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMULTITEXGENFVEXT(texunit, coord, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMultiTexGenivEXT(GLenum texunit, GLenum coord, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMultiTexGenivEXT(GLenum texunit, GLenum coord, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetMultiTexGenivEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(coord), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMULTITEXGENIVEXT(texunit, coord, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMultiTexImageEXT(GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglGetMultiTexImageEXT(GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
#endif
{
	D(bug("nfosmesa: glGetMultiTexImageEXT(%s, %s, %d, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), level, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLGETMULTITEXIMAGEEXT(texunit, target, level, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMultiTexLevelParameterfvEXT(GLenum texunit, GLenum target, GLint level, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMultiTexLevelParameterfvEXT(GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetMultiTexLevelParameterfvEXT(%s, %s, %d, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), level, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMULTITEXLEVELPARAMETERFVEXT(texunit, target, level, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMultiTexLevelParameterivEXT(GLenum texunit, GLenum target, GLint level, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMultiTexLevelParameterivEXT(GLenum texunit, GLenum target, GLint level, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetMultiTexLevelParameterivEXT(%s, %s, %d, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), level, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMULTITEXLEVELPARAMETERIVEXT(texunit, target, level, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMultiTexParameterIivEXT(GLenum texunit, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMultiTexParameterIivEXT(GLenum texunit, GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetMultiTexParameterIivEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMULTITEXPARAMETERIIVEXT(texunit, target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMultiTexParameterIuivEXT(GLenum texunit, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMultiTexParameterIuivEXT(GLenum texunit, GLenum target, GLenum pname, GLuint *params)
#endif
{
	D(bug("nfosmesa: glGetMultiTexParameterIuivEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMULTITEXPARAMETERIUIVEXT(texunit, target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetMultiTexParameterfvEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMULTITEXPARAMETERFVEXT(texunit, target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetMultiTexParameterivEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETMULTITEXPARAMETERIVEXT(texunit, target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMultisamplefv(GLenum pname, GLuint index, memptr val)
#else
void OSMesaDriver::nfglGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
#endif
{
	D(bug("nfosmesa: glGetMultisamplefv(%s, %u, " PRI_PTR ")", gl_enum_name(pname), index, AtariOffset(val)));
FN_GLGETMULTISAMPLEFV(pname, index, val);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetMultisamplefvNV(GLenum pname, GLuint index, memptr val)
#else
void OSMesaDriver::nfglGetMultisamplefvNV(GLenum pname, GLuint index, GLfloat *val)
#endif
{
	D(bug("nfosmesa: glGetMultisamplefvNV(%s, %u, " PRI_PTR ")", gl_enum_name(pname), index, AtariOffset(val)));
FN_GLGETMULTISAMPLEFVNV(pname, index, val);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedBufferParameteri64v(GLuint buffer, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetNamedBufferParameteri64v(GLuint buffer, GLenum pname, GLint64 *params)
#endif
{
	D(bug("nfosmesa: glGetNamedBufferParameteri64v(%u, %s, " PRI_PTR ")", buffer, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETNAMEDBUFFERPARAMETERI64V(buffer, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedBufferParameteriv(GLuint buffer, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetNamedBufferParameteriv(GLuint buffer, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetNamedBufferParameteriv(%u, %s, " PRI_PTR ")", buffer, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETNAMEDBUFFERPARAMETERIV(buffer, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedBufferParameterivEXT(GLuint buffer, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetNamedBufferParameterivEXT(GLuint buffer, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetNamedBufferParameterivEXT(%u, %s, " PRI_PTR ")", buffer, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETNAMEDBUFFERPARAMETERIVEXT(buffer, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedBufferParameterui64vNV(GLuint buffer, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetNamedBufferParameterui64vNV(GLuint buffer, GLenum pname, GLuint64EXT *params)
#endif
{
	D(bug("nfosmesa: glGetNamedBufferParameterui64vNV(%u, %s, " PRI_PTR ")", buffer, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETNAMEDBUFFERPARAMETERUI64VNV(buffer, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedBufferPointerv(GLuint buffer, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetNamedBufferPointerv(GLuint buffer, GLenum pname, void * *params)
#endif
{
	D(bug("nfosmesa: glGetNamedBufferPointerv(%u, %s, " PRI_PTR ")", buffer, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETNAMEDBUFFERPOINTERV(buffer, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedBufferPointervEXT(GLuint buffer, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetNamedBufferPointervEXT(GLuint buffer, GLenum pname, void * *params)
#endif
{
	D(bug("nfosmesa: glGetNamedBufferPointervEXT(%u, %s, " PRI_PTR ")", buffer, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETNAMEDBUFFERPOINTERVEXT(buffer, pname, params);
}

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr size, memptr data)
#else
void OSMesaDriver::nfglGetNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr size, void *data)
#endif
{
	D(bug("nfosmesa: glGetNamedBufferSubData(%u, %" PRI_IPTR ", %" PRI_IPTR ", " PRI_PTR ")", buffer, offset, size, AtariOffset(data)));
FN_GLGETNAMEDBUFFERSUBDATA(buffer, offset, size, data);
}
#endif

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, memptr data)
#else
void OSMesaDriver::nfglGetNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, void *data)
#endif
{
	D(bug("nfosmesa: glGetNamedBufferSubDataEXT(%u, %" PRI_IPTR ", %" PRI_IPTR ", " PRI_PTR ")", buffer, offset, size, AtariOffset(data)));
FN_GLGETNAMEDBUFFERSUBDATAEXT(buffer, offset, size, data);
}
#endif

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedFramebufferAttachmentParameteriv(GLuint framebuffer, GLenum attachment, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetNamedFramebufferAttachmentParameteriv(GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetNamedFramebufferAttachmentParameteriv(%u, %s, %s, " PRI_PTR ")", framebuffer, gl_enum_name(attachment), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIV(framebuffer, attachment, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedFramebufferAttachmentParameterivEXT(GLuint framebuffer, GLenum attachment, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetNamedFramebufferAttachmentParameterivEXT(GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetNamedFramebufferAttachmentParameterivEXT(%u, %s, %s, " PRI_PTR ")", framebuffer, gl_enum_name(attachment), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXT(framebuffer, attachment, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedFramebufferParameterfvAMD(GLuint framebuffer, GLenum pname, GLuint numsamples, GLuint pixelindex, GLsizei size, memptr values)
#else
void OSMesaDriver::nfglGetNamedFramebufferParameterfvAMD(GLuint framebuffer, GLenum pname, GLuint numsamples, GLuint pixelindex, GLsizei size, GLfloat *values)
#endif
{
	D(bug("nfosmesa: glGetNamedFramebufferParameterfvAMD(%u, %s, %u, %u, %d, " PRI_PTR ")", framebuffer, gl_enum_name(pname), numsamples, pixelindex, size, AtariOffset(values)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __values_size = MAX(numsamples, 0);
	GLfloat __values_tmp[__values_size];
	fn.glGetNamedFramebufferParameterfvAMD(framebuffer, pname, numsamples, pixelindex, size, __values_tmp);
	Host2AtariFloatArray(__values_size, __values_tmp, values);
#else
	fn.glGetNamedFramebufferParameterfvAMD(framebuffer, pname, numsamples, pixelindex, size, HostAddr(values, GLfloat *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedFramebufferParameteriv(GLuint framebuffer, GLenum pname, memptr param)
#else
void OSMesaDriver::nfglGetNamedFramebufferParameteriv(GLuint framebuffer, GLenum pname, GLint *param)
#endif
{
	D(bug("nfosmesa: glGetNamedFramebufferParameteriv(%u, %s, " PRI_PTR ")", framebuffer, gl_enum_name(pname), AtariOffset(param)));
FN_GLGETNAMEDFRAMEBUFFERPARAMETERIV(framebuffer, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedFramebufferParameterivEXT(GLuint framebuffer, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetNamedFramebufferParameterivEXT(GLuint framebuffer, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetNamedFramebufferParameterivEXT(%u, %s, " PRI_PTR ")", framebuffer, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETNAMEDFRAMEBUFFERPARAMETERIVEXT(framebuffer, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedProgramLocalParameterIivEXT(GLuint program, GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglGetNamedProgramLocalParameterIivEXT(GLuint program, GLenum target, GLuint index, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetNamedProgramLocalParameterIivEXT(%u, %s, %u, " PRI_PTR ")", program, gl_enum_name(target), index, AtariOffset(params)));
FN_GLGETNAMEDPROGRAMLOCALPARAMETERIIVEXT(program, target, index, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedProgramLocalParameterIuivEXT(GLuint program, GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglGetNamedProgramLocalParameterIuivEXT(GLuint program, GLenum target, GLuint index, GLuint *params)
#endif
{
	D(bug("nfosmesa: glGetNamedProgramLocalParameterIuivEXT(%u, %s, %u, " PRI_PTR ")", program, gl_enum_name(target), index, AtariOffset(params)));
FN_GLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXT(program, target, index, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedProgramLocalParameterdvEXT(GLuint program, GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglGetNamedProgramLocalParameterdvEXT(GLuint program, GLenum target, GLuint index, GLdouble *params)
#endif
{
	D(bug("nfosmesa: glGetNamedProgramLocalParameterdvEXT(%u, %s, %u, " PRI_PTR ")", program, gl_enum_name(target), index, AtariOffset(params)));
FN_GLGETNAMEDPROGRAMLOCALPARAMETERDVEXT(program, target, index, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedProgramLocalParameterfvEXT(GLuint program, GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglGetNamedProgramLocalParameterfvEXT(GLuint program, GLenum target, GLuint index, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetNamedProgramLocalParameterfvEXT(%u, %s, %u, " PRI_PTR ")", program, gl_enum_name(target), index, AtariOffset(params)));
FN_GLGETNAMEDPROGRAMLOCALPARAMETERFVEXT(program, target, index, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedProgramStringEXT(GLuint program, GLenum target, GLenum pname, memptr string)
#else
void OSMesaDriver::nfglGetNamedProgramStringEXT(GLuint program, GLenum target, GLenum pname, void *string)
#endif
{
	D(bug("nfosmesa: glGetNamedProgramStringEXT(%u, %s, %s, " PRI_PTR ")", program, gl_enum_name(target), gl_enum_name(pname), AtariOffset(string)));
FN_GLGETNAMEDPROGRAMSTRINGEXT(program, target, pname, string);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedProgramivEXT(GLuint program, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetNamedProgramivEXT(GLuint program, GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetNamedProgramivEXT(%u, %s, %s, " PRI_PTR ")", program, gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETNAMEDPROGRAMIVEXT(program, target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedRenderbufferParameteriv(GLuint renderbuffer, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetNamedRenderbufferParameteriv(GLuint renderbuffer, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetNamedRenderbufferParameteriv(%u, %s, " PRI_PTR ")", renderbuffer, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETNAMEDRENDERBUFFERPARAMETERIV(renderbuffer, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedRenderbufferParameterivEXT(GLuint renderbuffer, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetNamedRenderbufferParameterivEXT(GLuint renderbuffer, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetNamedRenderbufferParameterivEXT(%u, %s, " PRI_PTR ")", renderbuffer, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETNAMEDRENDERBUFFERPARAMETERIVEXT(renderbuffer, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedStringARB(GLint namelen, memptr name, GLsizei bufSize, memptr stringlen, memptr string)
#else
void OSMesaDriver::nfglGetNamedStringARB(GLint namelen, const GLchar *name, GLsizei bufSize, GLint *stringlen, GLchar *string)
#endif
{
	D(bug("nfosmesa: glGetNamedStringARB(%d, " PRI_PTR ", %d, " PRI_PTR ", " PRI_PTR ")", namelen, AtariOffset(name), bufSize, AtariOffset(stringlen), AtariOffset(string)));
FN_GLGETNAMEDSTRINGARB(namelen, name, bufSize, stringlen, string);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNamedStringivARB(GLint namelen, memptr name, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetNamedStringivARB(GLint namelen, const GLchar *name, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetNamedStringivARB(%d, " PRI_PTR ", %s, " PRI_PTR ")", namelen, AtariOffset(name), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETNAMEDSTRINGIVARB(namelen, name, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetNextPerfQueryIdINTEL(GLuint queryId, memptr nextQueryId)
#else
void OSMesaDriver::nfglGetNextPerfQueryIdINTEL(GLuint queryId, GLuint *nextQueryId)
#endif
{
	D(bug("nfosmesa: glGetNextPerfQueryIdINTEL(%u, " PRI_PTR ")", queryId, AtariOffset(nextQueryId)));
FN_GLGETNEXTPERFQUERYIDINTEL(queryId, nextQueryId);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetObjectBufferfvATI(GLuint buffer, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetObjectBufferfvATI(GLuint buffer, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetObjectBufferfvATI(%u, %s, " PRI_PTR ")", buffer, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETOBJECTBUFFERFVATI(buffer, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetObjectBufferivATI(GLuint buffer, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetObjectBufferivATI(GLuint buffer, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetObjectBufferivATI(%u, %s, " PRI_PTR ")", buffer, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETOBJECTBUFFERIVATI(buffer, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, memptr length, memptr label)
#else
void OSMesaDriver::nfglGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
#endif
{
	D(bug("nfosmesa: glGetObjectLabel(%s, %u, %d, " PRI_PTR ", " PRI_PTR ")", gl_enum_name(identifier), name, bufSize, AtariOffset(length), AtariOffset(label)));
FN_GLGETOBJECTLABEL(identifier, name, bufSize, length, label);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetObjectLabelEXT(GLenum type, GLuint object, GLsizei bufSize, memptr length, memptr label)
#else
void OSMesaDriver::nfglGetObjectLabelEXT(GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label)
#endif
{
	D(bug("nfosmesa: glGetObjectLabelEXT(%s, %u, %d, " PRI_PTR ", " PRI_PTR ")", gl_enum_name(type), object, bufSize, AtariOffset(length), AtariOffset(label)));
FN_GLGETOBJECTLABELEXT(type, object, bufSize, length, label);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetObjectParameterfvARB(GLhandleARB obj, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetObjectParameterfvARB(GLhandleARB obj, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetObjectParameterfvARB(%u, %s, " PRI_PTR ")", (unsigned int)(uintptr_t)obj, gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __params_size = 1;
	GLfloat __params_tmp[__params_size] = { 0 };
	fn.glGetObjectParameterfvARB(obj, pname, __params_tmp);
	Host2AtariFloatArray(__params_size, __params_tmp, params);
#else
	fn.glGetObjectParameterfvARB(obj, pname, HostAddr(params, GLfloat *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetObjectParameterivAPPLE(GLenum objectType, GLuint name, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetObjectParameterivAPPLE(GLenum objectType, GLuint name, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetObjectParameterivAPPLE(%s, %u, %s, " PRI_PTR ")", gl_enum_name(objectType), name, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETOBJECTPARAMETERIVAPPLE(objectType, name, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetObjectParameterivARB(GLhandleARB obj, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetObjectParameterivARB(GLhandleARB obj, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetObjectParameterivARB(%u, %s, " PRI_PTR ")", (unsigned int)(uintptr_t)obj, gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __params_size = 1;
	GLint __params_tmp[__params_size] = { 0 };
	fn.glGetObjectParameterivARB(obj, pname, __params_tmp);
	Host2AtariIntArray(__params_size, __params_tmp, params);
#else
	fn.glGetObjectParameterivARB(obj, pname, HostAddr(params, GLint *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetObjectPtrLabel(memptr ptr, GLsizei bufSize, memptr length, memptr label)
#else
void OSMesaDriver::nfglGetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)
#endif
{
	D(bug("nfosmesa: glGetObjectPtrLabel(" PRI_PTR ", %d, " PRI_PTR ", " PRI_PTR ")", AtariOffset(ptr), bufSize, AtariOffset(length), AtariOffset(label)));
FN_GLGETOBJECTPTRLABEL(ptr, bufSize, length, label);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetOcclusionQueryivNV(GLuint id, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetOcclusionQueryivNV(GLuint id, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetOcclusionQueryivNV(%u, %s, " PRI_PTR ")", id, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETOCCLUSIONQUERYIVNV(id, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetOcclusionQueryuivNV(GLuint id, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetOcclusionQueryuivNV(GLuint id, GLenum pname, GLuint *params)
#endif
{
	D(bug("nfosmesa: glGetOcclusionQueryuivNV(%u, %s, " PRI_PTR ")", id, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETOCCLUSIONQUERYUIVNV(id, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPathColorGenfvNV(GLenum color, GLenum pname, memptr value)
#else
void OSMesaDriver::nfglGetPathColorGenfvNV(GLenum color, GLenum pname, GLfloat *value)
#endif
{
	D(bug("nfosmesa: glGetPathColorGenfvNV(%s, %s, " PRI_PTR ")", gl_enum_name(color), gl_enum_name(pname), AtariOffset(value)));
FN_GLGETPATHCOLORGENFVNV(color, pname, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPathColorGenivNV(GLenum color, GLenum pname, memptr value)
#else
void OSMesaDriver::nfglGetPathColorGenivNV(GLenum color, GLenum pname, GLint *value)
#endif
{
	D(bug("nfosmesa: glGetPathColorGenivNV(%s, %s, " PRI_PTR ")", gl_enum_name(color), gl_enum_name(pname), AtariOffset(value)));
FN_GLGETPATHCOLORGENIVNV(color, pname, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPathCommandsNV(GLuint path, memptr commands)
#else
void OSMesaDriver::nfglGetPathCommandsNV(GLuint path, GLubyte *commands)
#endif
{
	D(bug("nfosmesa: glGetPathCommandsNV(%u, " PRI_PTR ")", path, AtariOffset(commands)));
FN_GLGETPATHCOMMANDSNV(path, commands);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPathCoordsNV(GLuint path, memptr coords)
#else
void OSMesaDriver::nfglGetPathCoordsNV(GLuint path, GLfloat *coords)
#endif
{
	D(bug("nfosmesa: glGetPathCoordsNV(%u, " PRI_PTR ")", path, AtariOffset(coords)));
FN_GLGETPATHCOORDSNV(path, coords);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPathDashArrayNV(GLuint path, memptr dashArray)
#else
void OSMesaDriver::nfglGetPathDashArrayNV(GLuint path, GLfloat *dashArray)
#endif
{
	D(bug("nfosmesa: glGetPathDashArrayNV(%u, " PRI_PTR ")", path, AtariOffset(dashArray)));
FN_GLGETPATHDASHARRAYNV(path, dashArray);
}

GLfloat OSMesaDriver::nfglGetPathLengthNV(GLuint path, GLsizei startSegment, GLsizei numSegments)
{
	D(bug("nfosmesa: glGetPathLengthNV(%u, %d, %d)", path, startSegment, numSegments));
	GLfloat __ret = fn.glGetPathLengthNV(path, startSegment, numSegments);
	return __ret;
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPathMetricRangeNV(GLbitfield metricQueryMask, GLuint firstPathName, GLsizei numPaths, GLsizei stride, memptr metrics)
#else
void OSMesaDriver::nfglGetPathMetricRangeNV(GLbitfield metricQueryMask, GLuint firstPathName, GLsizei numPaths, GLsizei stride, GLfloat *metrics)
#endif
{
	D(bug("nfosmesa: glGetPathMetricRangeNV(0x%x, %u, %d, %d, " PRI_PTR ")", metricQueryMask, firstPathName, numPaths, stride, AtariOffset(metrics)));
FN_GLGETPATHMETRICRANGENV(metricQueryMask, firstPathName, numPaths, stride, metrics);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPathMetricsNV(GLbitfield metricQueryMask, GLsizei numPaths, GLenum pathNameType, memptr paths, GLuint pathBase, GLsizei stride, memptr metrics)
#else
void OSMesaDriver::nfglGetPathMetricsNV(GLbitfield metricQueryMask, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLsizei stride, GLfloat *metrics)
#endif
{
	D(bug("nfosmesa: glGetPathMetricsNV(0x%x, %d, %s, " PRI_PTR ", %u, %d, " PRI_PTR ")", metricQueryMask, numPaths, gl_enum_name(pathNameType), AtariOffset(paths), pathBase, stride, AtariOffset(metrics)));
FN_GLGETPATHMETRICSNV(metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPathParameterfvNV(GLuint path, GLenum pname, memptr value)
#else
void OSMesaDriver::nfglGetPathParameterfvNV(GLuint path, GLenum pname, GLfloat *value)
#endif
{
	D(bug("nfosmesa: glGetPathParameterfvNV(%u, %s, " PRI_PTR ")", path, gl_enum_name(pname), AtariOffset(value)));
FN_GLGETPATHPARAMETERFVNV(path, pname, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPathParameterivNV(GLuint path, GLenum pname, memptr value)
#else
void OSMesaDriver::nfglGetPathParameterivNV(GLuint path, GLenum pname, GLint *value)
#endif
{
	D(bug("nfosmesa: glGetPathParameterivNV(%u, %s, " PRI_PTR ")", path, gl_enum_name(pname), AtariOffset(value)));
FN_GLGETPATHPARAMETERIVNV(path, pname, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPathSpacingNV(GLenum pathListMode, GLsizei numPaths, GLenum pathNameType, memptr paths, GLuint pathBase, GLfloat advanceScale, GLfloat kerningScale, GLenum transformType, memptr returnedSpacing)
#else
void OSMesaDriver::nfglGetPathSpacingNV(GLenum pathListMode, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLfloat advanceScale, GLfloat kerningScale, GLenum transformType, GLfloat *returnedSpacing)
#endif
{
	D(bug("nfosmesa: glGetPathSpacingNV(%s, %d, %s, " PRI_PTR ", %u, %f, %f, %s, " PRI_PTR ")", gl_enum_name(pathListMode), numPaths, gl_enum_name(pathNameType), AtariOffset(paths), pathBase, advanceScale, kerningScale, gl_enum_name(transformType), AtariOffset(returnedSpacing)));
FN_GLGETPATHSPACINGNV(pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPathTexGenfvNV(GLenum texCoordSet, GLenum pname, memptr value)
#else
void OSMesaDriver::nfglGetPathTexGenfvNV(GLenum texCoordSet, GLenum pname, GLfloat *value)
#endif
{
	D(bug("nfosmesa: glGetPathTexGenfvNV(%s, %s, " PRI_PTR ")", gl_enum_name(texCoordSet), gl_enum_name(pname), AtariOffset(value)));
FN_GLGETPATHTEXGENFVNV(texCoordSet, pname, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPathTexGenivNV(GLenum texCoordSet, GLenum pname, memptr value)
#else
void OSMesaDriver::nfglGetPathTexGenivNV(GLenum texCoordSet, GLenum pname, GLint *value)
#endif
{
	D(bug("nfosmesa: glGetPathTexGenivNV(%s, %s, " PRI_PTR ")", gl_enum_name(texCoordSet), gl_enum_name(pname), AtariOffset(value)));
FN_GLGETPATHTEXGENIVNV(texCoordSet, pname, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPerfCounterInfoINTEL(GLuint queryId, GLuint counterId, GLuint counterNameLength, memptr counterName, GLuint counterDescLength, memptr counterDesc, memptr counterOffset, memptr counterDataSize, memptr counterTypeEnum, memptr counterDataTypeEnum, memptr rawCounterMaxValue)
#else
void OSMesaDriver::nfglGetPerfCounterInfoINTEL(GLuint queryId, GLuint counterId, GLuint counterNameLength, GLchar *counterName, GLuint counterDescLength, GLchar *counterDesc, GLuint *counterOffset, GLuint *counterDataSize, GLuint *counterTypeEnum, GLuint *counterDataTypeEnum, GLuint64 *rawCounterMaxValue)
#endif
{
	D(bug("nfosmesa: glGetPerfCounterInfoINTEL(%u, %u, %u, " PRI_PTR ", %u, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", queryId, counterId, counterNameLength, AtariOffset(counterName), counterDescLength, AtariOffset(counterDesc), AtariOffset(counterOffset), AtariOffset(counterDataSize), AtariOffset(counterTypeEnum), AtariOffset(counterDataTypeEnum), AtariOffset(rawCounterMaxValue)));
FN_GLGETPERFCOUNTERINFOINTEL(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname, GLsizei dataSize, memptr data, memptr bytesWritten)
#else
void OSMesaDriver::nfglGetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname, GLsizei dataSize, GLuint *data, GLint *bytesWritten)
#endif
{
	D(bug("nfosmesa: glGetPerfMonitorCounterDataAMD(%u, %s, %d, " PRI_PTR ", " PRI_PTR ")", monitor, gl_enum_name(pname), dataSize, AtariOffset(data), AtariOffset(bytesWritten)));
FN_GLGETPERFMONITORCOUNTERDATAAMD(monitor, pname, dataSize, data, bytesWritten);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname, memptr data)
#else
void OSMesaDriver::nfglGetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname, void *data)
#endif
{
	D(bug("nfosmesa: glGetPerfMonitorCounterInfoAMD(%u, %u, %s, " PRI_PTR ")", group, counter, gl_enum_name(pname), AtariOffset(data)));
FN_GLGETPERFMONITORCOUNTERINFOAMD(group, counter, pname, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPerfMonitorCounterStringAMD(GLuint group, GLuint counter, GLsizei bufSize, memptr length, memptr counterString)
#else
void OSMesaDriver::nfglGetPerfMonitorCounterStringAMD(GLuint group, GLuint counter, GLsizei bufSize, GLsizei *length, GLchar *counterString)
#endif
{
	D(bug("nfosmesa: glGetPerfMonitorCounterStringAMD(%u, %u, %d, " PRI_PTR ", " PRI_PTR ")", group, counter, bufSize, AtariOffset(length), AtariOffset(counterString)));
FN_GLGETPERFMONITORCOUNTERSTRINGAMD(group, counter, bufSize, length, counterString);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPerfMonitorCountersAMD(GLuint group, memptr numCounters, memptr maxActiveCounters, GLsizei counterSize, memptr counters)
#else
void OSMesaDriver::nfglGetPerfMonitorCountersAMD(GLuint group, GLint *numCounters, GLint *maxActiveCounters, GLsizei counterSize, GLuint *counters)
#endif
{
	D(bug("nfosmesa: glGetPerfMonitorCountersAMD(%u, " PRI_PTR ", " PRI_PTR ", %d, " PRI_PTR ")", group, AtariOffset(numCounters), AtariOffset(maxActiveCounters), counterSize, AtariOffset(counters)));
FN_GLGETPERFMONITORCOUNTERSAMD(group, numCounters, maxActiveCounters, counterSize, counters);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize, memptr length, memptr groupString)
#else
void OSMesaDriver::nfglGetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize, GLsizei *length, GLchar *groupString)
#endif
{
	D(bug("nfosmesa: glGetPerfMonitorGroupStringAMD(%u, %d, " PRI_PTR ", " PRI_PTR ")", group, bufSize, AtariOffset(length), AtariOffset(groupString)));
FN_GLGETPERFMONITORGROUPSTRINGAMD(group, bufSize, length, groupString);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPerfMonitorGroupsAMD(memptr numGroups, GLsizei groupsSize, memptr groups)
#else
void OSMesaDriver::nfglGetPerfMonitorGroupsAMD(GLint *numGroups, GLsizei groupsSize, GLuint *groups)
#endif
{
	D(bug("nfosmesa: glGetPerfMonitorGroupsAMD(" PRI_PTR ", %d, " PRI_PTR ")", AtariOffset(numGroups), groupsSize, AtariOffset(groups)));
FN_GLGETPERFMONITORGROUPSAMD(numGroups, groupsSize, groups);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPerfQueryDataINTEL(GLuint queryHandle, GLuint flags, GLsizei dataSize, memptr data, memptr bytesWritten)
#else
void OSMesaDriver::nfglGetPerfQueryDataINTEL(GLuint queryHandle, GLuint flags, GLsizei dataSize, GLvoid *data, GLuint *bytesWritten)
#endif
{
	D(bug("nfosmesa: glGetPerfQueryDataINTEL(%u, %u, %d, " PRI_PTR ", " PRI_PTR ")", queryHandle, flags, dataSize, AtariOffset(data), AtariOffset(bytesWritten)));
FN_GLGETPERFQUERYDATAINTEL(queryHandle, flags, dataSize, data, bytesWritten);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPerfQueryIdByNameINTEL(memptr queryName, memptr queryId)
#else
void OSMesaDriver::nfglGetPerfQueryIdByNameINTEL(GLchar *queryName, GLuint *queryId)
#endif
{
	D(bug("nfosmesa: glGetPerfQueryIdByNameINTEL(" PRI_PTR ", " PRI_PTR ")", AtariOffset(queryName), AtariOffset(queryId)));
FN_GLGETPERFQUERYIDBYNAMEINTEL(queryName, queryId);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPerfQueryInfoINTEL(GLuint queryId, GLuint queryNameLength, memptr queryName, memptr dataSize, memptr noCounters, memptr noInstances, memptr capsMask)
#else
void OSMesaDriver::nfglGetPerfQueryInfoINTEL(GLuint queryId, GLuint queryNameLength, GLchar *queryName, GLuint *dataSize, GLuint *noCounters, GLuint *noInstances, GLuint *capsMask)
#endif
{
	D(bug("nfosmesa: glGetPerfQueryInfoINTEL(%u, %u, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", queryId, queryNameLength, AtariOffset(queryName), AtariOffset(dataSize), AtariOffset(noCounters), AtariOffset(noInstances), AtariOffset(capsMask)));
FN_GLGETPERFQUERYINFOINTEL(queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPixelMapfv(GLenum map, memptr values)
#else
void OSMesaDriver::nfglGetPixelMapfv(GLenum map, GLfloat *values)
#endif
{
	D(bug("nfosmesa: glGetPixelMapfv(%s, " PRI_PTR ")", gl_enum_name(map), AtariOffset(values)));
FN_GLGETPIXELMAPFV(map, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPixelMapuiv(GLenum map, memptr values)
#else
void OSMesaDriver::nfglGetPixelMapuiv(GLenum map, GLuint *values)
#endif
{
	D(bug("nfosmesa: glGetPixelMapuiv(%s, " PRI_PTR ")", gl_enum_name(map), AtariOffset(values)));
FN_GLGETPIXELMAPUIV(map, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPixelMapusv(GLenum map, memptr values)
#else
void OSMesaDriver::nfglGetPixelMapusv(GLenum map, GLushort *values)
#endif
{
	D(bug("nfosmesa: glGetPixelMapusv(%s, " PRI_PTR ")", gl_enum_name(map), AtariOffset(values)));
FN_GLGETPIXELMAPUSV(map, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPixelMapxv(GLenum map, GLint size, memptr values)
#else
void OSMesaDriver::nfglGetPixelMapxv(GLenum map, GLint size, GLfixed *values)
#endif
{
	D(bug("nfosmesa: glGetPixelMapxv(%s, %d, " PRI_PTR ")", gl_enum_name(map), size, AtariOffset(values)));
FN_GLGETPIXELMAPXV(map, size, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPixelTexGenParameterfvSGIS(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetPixelTexGenParameterfvSGIS(GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetPixelTexGenParameterfvSGIS(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLGETPIXELTEXGENPARAMETERFVSGIS(pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPixelTexGenParameterivSGIS(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetPixelTexGenParameterivSGIS(GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetPixelTexGenParameterivSGIS(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLGETPIXELTEXGENPARAMETERIVSGIS(pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPixelTransformParameterfvEXT(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetPixelTransformParameterfvEXT(GLenum target, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetPixelTransformParameterfvEXT(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETPIXELTRANSFORMPARAMETERFVEXT(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPixelTransformParameterivEXT(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetPixelTransformParameterivEXT(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetPixelTransformParameterivEXT(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETPIXELTRANSFORMPARAMETERIVEXT(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPointerIndexedvEXT(GLenum target, GLuint index, memptr data)
#else
void OSMesaDriver::nfglGetPointerIndexedvEXT(GLenum target, GLuint index, void * *data)
#endif
{
	D(bug("nfosmesa: glGetPointerIndexedvEXT(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(data)));
FN_GLGETPOINTERINDEXEDVEXT(target, index, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPointeri_vEXT(GLenum pname, GLuint index, memptr params)
#else
void OSMesaDriver::nfglGetPointeri_vEXT(GLenum pname, GLuint index, void * *params)
#endif
{
	D(bug("nfosmesa: glGetPointeri_vEXT(%s, %u, " PRI_PTR ")", gl_enum_name(pname), index, AtariOffset(params)));
FN_GLGETPOINTERI_VEXT(pname, index, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPointerv(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetPointerv(GLenum pname, GLvoid* *params)
#endif
{
	D(bug("nfosmesa: glGetPointerv(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLGETPOINTERV(pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPointervEXT(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetPointervEXT(GLenum pname, void * *params)
#endif
{
	D(bug("nfosmesa: glGetPointervEXT(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLGETPOINTERVEXT(pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetPolygonStipple(memptr mask)
#else
void OSMesaDriver::nfglGetPolygonStipple(GLubyte *mask)
#endif
{
	D(bug("nfosmesa: glGetPolygonStipple(" PRI_PTR ")", AtariOffset(mask)));
FN_GLGETPOLYGONSTIPPLE(mask);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramBinary(GLuint program, GLsizei bufSize, memptr length, memptr binaryFormat, memptr binary)
#else
void OSMesaDriver::nfglGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary)
#endif
{
	D(bug("nfosmesa: glGetProgramBinary(%u, %d, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", program, bufSize, AtariOffset(length), AtariOffset(binaryFormat), AtariOffset(binary)));
FN_GLGETPROGRAMBINARY(program, bufSize, length, binaryFormat, binary);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramEnvParameterIivNV(GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglGetProgramEnvParameterIivNV(GLenum target, GLuint index, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetProgramEnvParameterIivNV(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(params)));
FN_GLGETPROGRAMENVPARAMETERIIVNV(target, index, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramEnvParameterIuivNV(GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglGetProgramEnvParameterIuivNV(GLenum target, GLuint index, GLuint *params)
#endif
{
	D(bug("nfosmesa: glGetProgramEnvParameterIuivNV(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(params)));
FN_GLGETPROGRAMENVPARAMETERIUIVNV(target, index, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramEnvParameterdvARB(GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglGetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble *params)
#endif
{
	D(bug("nfosmesa: glGetProgramEnvParameterdvARB(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(params)));
FN_GLGETPROGRAMENVPARAMETERDVARB(target, index, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramEnvParameterfvARB(GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglGetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetProgramEnvParameterfvARB(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(params)));
FN_GLGETPROGRAMENVPARAMETERFVARB(target, index, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramInfoLog(GLuint program, GLsizei bufSize, memptr length, memptr infoLog)
#else
void OSMesaDriver::nfglGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
#endif
{
	D(bug("nfosmesa: glGetProgramInfoLog(%u, %d, " PRI_PTR ", " PRI_PTR ")", program, bufSize, AtariOffset(length), AtariOffset(infoLog)));
FN_GLGETPROGRAMINFOLOG(program, bufSize, length, infoLog);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetProgramInterfaceiv(%u, %s, %s, " PRI_PTR ")", program, gl_enum_name(programInterface), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETPROGRAMINTERFACEIV(program, programInterface, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramLocalParameterIivNV(GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglGetProgramLocalParameterIivNV(GLenum target, GLuint index, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetProgramLocalParameterIivNV(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(params)));
FN_GLGETPROGRAMLOCALPARAMETERIIVNV(target, index, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramLocalParameterIuivNV(GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglGetProgramLocalParameterIuivNV(GLenum target, GLuint index, GLuint *params)
#endif
{
	D(bug("nfosmesa: glGetProgramLocalParameterIuivNV(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(params)));
FN_GLGETPROGRAMLOCALPARAMETERIUIVNV(target, index, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramLocalParameterdvARB(GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglGetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble *params)
#endif
{
	D(bug("nfosmesa: glGetProgramLocalParameterdvARB(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(params)));
FN_GLGETPROGRAMLOCALPARAMETERDVARB(target, index, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramLocalParameterfvARB(GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglGetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetProgramLocalParameterfvARB(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(params)));
FN_GLGETPROGRAMLOCALPARAMETERFVARB(target, index, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramNamedParameterdvNV(GLuint id, GLsizei len, memptr name, memptr params)
#else
void OSMesaDriver::nfglGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte *name, GLdouble *params)
#endif
{
	D(bug("nfosmesa: glGetProgramNamedParameterdvNV(%u, %d, " PRI_PTR ", " PRI_PTR ")", id, len, AtariOffset(name), AtariOffset(params)));
FN_GLGETPROGRAMNAMEDPARAMETERDVNV(id, len, name, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramNamedParameterfvNV(GLuint id, GLsizei len, memptr name, memptr params)
#else
void OSMesaDriver::nfglGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte *name, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetProgramNamedParameterfvNV(%u, %d, " PRI_PTR ", " PRI_PTR ")", id, len, AtariOffset(name), AtariOffset(params)));
FN_GLGETPROGRAMNAMEDPARAMETERFVNV(id, len, name, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble *params)
#endif
{
	D(bug("nfosmesa: glGetProgramParameterdvNV(%s, %u, %s, " PRI_PTR ")", gl_enum_name(target), index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETPROGRAMPARAMETERDVNV(target, index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetProgramParameterfvNV(%s, %u, %s, " PRI_PTR ")", gl_enum_name(target), index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETPROGRAMPARAMETERFVNV(target, index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, memptr length, memptr infoLog)
#else
void OSMesaDriver::nfglGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
#endif
{
	D(bug("nfosmesa: glGetProgramPipelineInfoLog(%u, %d, " PRI_PTR ", " PRI_PTR ")", pipeline, bufSize, AtariOffset(length), AtariOffset(infoLog)));
FN_GLGETPROGRAMPIPELINEINFOLOG(pipeline, bufSize, length, infoLog);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramPipelineiv(GLuint pipeline, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetProgramPipelineiv(%u, %s, " PRI_PTR ")", pipeline, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETPROGRAMPIPELINEIV(pipeline, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramRegisterfvMESA(GLenum target, GLsizei len, memptr name, memptr v)
#else
void OSMesaDriver::nfglGetProgramRegisterfvMESA(GLenum target, GLsizei len, const GLubyte *name, GLfloat *v)
#endif
{
	D(bug("nfosmesa: glGetProgramRegisterfvMESA(%s, %d, " PRI_PTR ", " PRI_PTR ")", gl_enum_name(target), len, AtariOffset(name), AtariOffset(v)));
FN_GLGETPROGRAMREGISTERFVMESA(target, len, name, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLuint OSMesaDriver::nfglGetProgramResourceIndex(GLuint program, GLenum programInterface, memptr name)
#else
GLuint OSMesaDriver::nfglGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name)
#endif
{
	D(bug("nfosmesa: glGetProgramResourceIndex(%u, %s, " PRI_PTR ")", program, gl_enum_name(programInterface), AtariOffset(name)));
FN_GLGETPROGRAMRESOURCEINDEX(program, programInterface, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLint OSMesaDriver::nfglGetProgramResourceLocation(GLuint program, GLenum programInterface, memptr name)
#else
GLint OSMesaDriver::nfglGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name)
#endif
{
	D(bug("nfosmesa: glGetProgramResourceLocation(%u, %s, " PRI_PTR ")", program, gl_enum_name(programInterface), AtariOffset(name)));
FN_GLGETPROGRAMRESOURCELOCATION(program, programInterface, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLint OSMesaDriver::nfglGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, memptr name)
#else
GLint OSMesaDriver::nfglGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar *name)
#endif
{
	D(bug("nfosmesa: glGetProgramResourceLocationIndex(%u, %s, " PRI_PTR ")", program, gl_enum_name(programInterface), AtariOffset(name)));
FN_GLGETPROGRAMRESOURCELOCATIONINDEX(program, programInterface, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, memptr length, memptr name)
#else
void OSMesaDriver::nfglGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
#endif
{
	D(bug("nfosmesa: glGetProgramResourceName(%u, %s, %u, %d, " PRI_PTR ", " PRI_PTR ")", program, gl_enum_name(programInterface), index, bufSize, AtariOffset(length), AtariOffset(name)));
FN_GLGETPROGRAMRESOURCENAME(program, programInterface, index, bufSize, length, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramResourcefvNV(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, memptr props, GLsizei bufSize, memptr length, memptr params)
#else
void OSMesaDriver::nfglGetProgramResourcefvNV(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetProgramResourcefvNV(%u, %s, %u, %d, " PRI_PTR ", %d, " PRI_PTR ", " PRI_PTR ")", program, gl_enum_name(programInterface), index, propCount, AtariOffset(props), bufSize, AtariOffset(length), AtariOffset(params)));
FN_GLGETPROGRAMRESOURCEFVNV(program, programInterface, index, propCount, props, bufSize, length, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, memptr props, GLsizei bufSize, memptr length, memptr params)
#else
void OSMesaDriver::nfglGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetProgramResourceiv(%u, %s, %u, %d, " PRI_PTR ", %d, " PRI_PTR ", " PRI_PTR ")", program, gl_enum_name(programInterface), index, propCount, AtariOffset(props), bufSize, AtariOffset(length), AtariOffset(params)));
FN_GLGETPROGRAMRESOURCEIV(program, programInterface, index, propCount, props, bufSize, length, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, memptr values)
#else
void OSMesaDriver::nfglGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
#endif
{
	D(bug("nfosmesa: glGetProgramStageiv(%u, %s, %s, " PRI_PTR ")", program, gl_enum_name(shadertype), gl_enum_name(pname), AtariOffset(values)));
FN_GLGETPROGRAMSTAGEIV(program, shadertype, pname, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramStringARB(GLenum target, GLenum pname, memptr string)
#else
void OSMesaDriver::nfglGetProgramStringARB(GLenum target, GLenum pname, void *string)
#endif
{
	D(bug("nfosmesa: glGetProgramStringARB(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(string)));
FN_GLGETPROGRAMSTRINGARB(target, pname, string);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramStringNV(GLuint id, GLenum pname, memptr program)
#else
void OSMesaDriver::nfglGetProgramStringNV(GLuint id, GLenum pname, GLubyte *program)
#endif
{
	D(bug("nfosmesa: glGetProgramStringNV(%u, %s, " PRI_PTR ")", id, gl_enum_name(pname), AtariOffset(program)));
FN_GLGETPROGRAMSTRINGNV(id, pname, program);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramSubroutineParameteruivNV(GLenum target, GLuint index, memptr param)
#else
void OSMesaDriver::nfglGetProgramSubroutineParameteruivNV(GLenum target, GLuint index, GLuint *param)
#endif
{
	D(bug("nfosmesa: glGetProgramSubroutineParameteruivNV(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(param)));
FN_GLGETPROGRAMSUBROUTINEPARAMETERUIVNV(target, index, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramiv(GLuint program, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetProgramiv(GLuint program, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetProgramiv(%u, %s, " PRI_PTR ")", program, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETPROGRAMIV(program, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramivARB(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetProgramivARB(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetProgramivARB(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETPROGRAMIVARB(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetProgramivNV(GLuint id, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetProgramivNV(GLuint id, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetProgramivNV(%u, %s, " PRI_PTR ")", id, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETPROGRAMIVNV(id, pname, params);
}

void OSMesaDriver::nfglGetQueryBufferObjecti64v(GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
{
	D(bug("nfosmesa: glGetQueryBufferObjecti64v(%u, %u, %s, %" PRI_IPTR ")", id, buffer, gl_enum_name(pname), offset));
	fn.glGetQueryBufferObjecti64v(id, buffer, pname, offset);
}

void OSMesaDriver::nfglGetQueryBufferObjectiv(GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
{
	D(bug("nfosmesa: glGetQueryBufferObjectiv(%u, %u, %s, %" PRI_IPTR ")", id, buffer, gl_enum_name(pname), offset));
	fn.glGetQueryBufferObjectiv(id, buffer, pname, offset);
}

void OSMesaDriver::nfglGetQueryBufferObjectui64v(GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
{
	D(bug("nfosmesa: glGetQueryBufferObjectui64v(%u, %u, %s, %" PRI_IPTR ")", id, buffer, gl_enum_name(pname), offset));
	fn.glGetQueryBufferObjectui64v(id, buffer, pname, offset);
}

void OSMesaDriver::nfglGetQueryBufferObjectuiv(GLuint id, GLuint buffer, GLenum pname, GLintptr offset)
{
	D(bug("nfosmesa: glGetQueryBufferObjectuiv(%u, %u, %s, %" PRI_IPTR ")", id, buffer, gl_enum_name(pname), offset));
	fn.glGetQueryBufferObjectuiv(id, buffer, pname, offset);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetQueryIndexediv(%s, %u, %s, " PRI_PTR ")", gl_enum_name(target), index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETQUERYINDEXEDIV(target, index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetQueryObjecti64v(GLuint id, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
#endif
{
	D(bug("nfosmesa: glGetQueryObjecti64v(%u, %s, " PRI_PTR ")", id, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETQUERYOBJECTI64V(id, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetQueryObjecti64vEXT(GLuint id, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params)
#endif
{
	D(bug("nfosmesa: glGetQueryObjecti64vEXT(%u, %s, " PRI_PTR ")", id, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETQUERYOBJECTI64VEXT(id, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetQueryObjectiv(GLuint id, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetQueryObjectiv(%u, %s, " PRI_PTR ")", id, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETQUERYOBJECTIV(id, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetQueryObjectivARB(GLuint id, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetQueryObjectivARB(GLuint id, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetQueryObjectivARB(%u, %s, " PRI_PTR ")", id, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETQUERYOBJECTIVARB(id, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetQueryObjectui64v(GLuint id, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
#endif
{
	D(bug("nfosmesa: glGetQueryObjectui64v(%u, %s, " PRI_PTR ")", id, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETQUERYOBJECTUI64V(id, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetQueryObjectui64vEXT(GLuint id, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *params)
#endif
{
	D(bug("nfosmesa: glGetQueryObjectui64vEXT(%u, %s, " PRI_PTR ")", id, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETQUERYOBJECTUI64VEXT(id, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetQueryObjectuiv(GLuint id, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
#endif
{
	D(bug("nfosmesa: glGetQueryObjectuiv(%u, %s, " PRI_PTR ")", id, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETQUERYOBJECTUIV(id, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetQueryObjectuivARB(GLuint id, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint *params)
#endif
{
	D(bug("nfosmesa: glGetQueryObjectuivARB(%u, %s, " PRI_PTR ")", id, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETQUERYOBJECTUIVARB(id, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetQueryiv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetQueryiv(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetQueryiv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETQUERYIV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetQueryivARB(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetQueryivARB(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetQueryivARB(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETQUERYIVARB(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetRenderbufferParameteriv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetRenderbufferParameteriv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETRENDERBUFFERPARAMETERIV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetRenderbufferParameterivEXT(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetRenderbufferParameterivEXT(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETRENDERBUFFERPARAMETERIVEXT(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetSamplerParameterIiv(GLuint sampler, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetSamplerParameterIiv(%u, %s, " PRI_PTR ")", sampler, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETSAMPLERPARAMETERIIV(sampler, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetSamplerParameterIuiv(GLuint sampler, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
#endif
{
	D(bug("nfosmesa: glGetSamplerParameterIuiv(%u, %s, " PRI_PTR ")", sampler, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETSAMPLERPARAMETERIUIV(sampler, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetSamplerParameterfv(GLuint sampler, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetSamplerParameterfv(%u, %s, " PRI_PTR ")", sampler, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETSAMPLERPARAMETERFV(sampler, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetSamplerParameteriv(GLuint sampler, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetSamplerParameteriv(%u, %s, " PRI_PTR ")", sampler, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETSAMPLERPARAMETERIV(sampler, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetSemaphoreParameterui64vEXT(GLuint semaphore, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetSemaphoreParameterui64vEXT(GLuint semaphore, GLenum pname, GLuint64 *params)
#endif
{
	D(bug("nfosmesa: glGetSemaphoreParameterui64vEXT(%u, %s, " PRI_PTR ")", semaphore, gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLuint64 __params_tmp[__params_size];
	fn.glGetSemaphoreParameterui64vEXT(semaphore, pname, __params_tmp);
	Host2AtariInt64Array(__params_size, __params_tmp, params);
#else
	fn.glGetSemaphoreParameterui64vEXT(semaphore, pname, HostAddr(params, GLuint64 *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetSeparableFilter(GLenum target, GLenum format, GLenum type, memptr row, memptr column, memptr span)
#else
void OSMesaDriver::nfglGetSeparableFilter(GLenum target, GLenum format, GLenum type, void *row, void *column, void *span)
#endif
{
	D(bug("nfosmesa: glGetSeparableFilter(%s, %s, %s, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", gl_enum_name(target), gl_enum_name(format), gl_enum_name(type), AtariOffset(row), AtariOffset(column), AtariOffset(span)));
FN_GLGETSEPARABLEFILTER(target, format, type, row, column, span);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetSeparableFilterEXT(GLenum target, GLenum format, GLenum type, memptr row, memptr column, memptr span)
#else
void OSMesaDriver::nfglGetSeparableFilterEXT(GLenum target, GLenum format, GLenum type, void *row, void *column, void *span)
#endif
{
	D(bug("nfosmesa: glGetSeparableFilterEXT(%s, %s, %s, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", gl_enum_name(target), gl_enum_name(format), gl_enum_name(type), AtariOffset(row), AtariOffset(column), AtariOffset(span)));
FN_GLGETSEPARABLEFILTEREXT(target, format, type, row, column, span);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetShaderInfoLog(GLuint shader, GLsizei bufSize, memptr length, memptr infoLog)
#else
void OSMesaDriver::nfglGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
#endif
{
	D(bug("nfosmesa: glGetShaderInfoLog(%u, %d, " PRI_PTR ", " PRI_PTR ")", shader, bufSize, AtariOffset(length), AtariOffset(infoLog)));
FN_GLGETSHADERINFOLOG(shader, bufSize, length, infoLog);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, memptr range, memptr precision)
#else
void OSMesaDriver::nfglGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
#endif
{
	D(bug("nfosmesa: glGetShaderPrecisionFormat(%s, %s, " PRI_PTR ", " PRI_PTR ")", gl_enum_name(shadertype), gl_enum_name(precisiontype), AtariOffset(range), AtariOffset(precision)));
FN_GLGETSHADERPRECISIONFORMAT(shadertype, precisiontype, range, precision);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetShaderSource(GLuint shader, GLsizei bufSize, memptr length, memptr source)
#else
void OSMesaDriver::nfglGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
#endif
{
	D(bug("nfosmesa: glGetShaderSource(%u, %d, " PRI_PTR ", " PRI_PTR ")", shader, bufSize, AtariOffset(length), AtariOffset(source)));
FN_GLGETSHADERSOURCE(shader, bufSize, length, source);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, memptr length, memptr source)
#else
void OSMesaDriver::nfglGetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *source)
#endif
{
	D(bug("nfosmesa: glGetShaderSourceARB(%u, %d, " PRI_PTR ", " PRI_PTR ")", (unsigned int)(uintptr_t)obj, maxLength, AtariOffset(length), AtariOffset(source)));
#if NFOSMESA_NEED_BYTE_CONV || NFOSMESA_NEED_INT_CONV
	GLint const __length_size = 1;
	GLsizei __length_tmp[__length_size] = { 0 };
	GLint const __source_size = MAX(maxLength, 0);
	GLcharARB __source_tmp[__source_size];
	fn.glGetShaderSourceARB(obj, maxLength, __length_tmp, __source_tmp);
	Host2AtariIntArray(__length_size, __length_tmp, length);
	Host2AtariByteArray(MIN(__length_tmp[0] + 1, maxLength), __source_tmp, source);
#else
	fn.glGetShaderSourceARB(obj, maxLength, HostAddr(length, GLsizei *), HostAddr(source, GLcharARB *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetShaderiv(GLuint shader, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetShaderiv(GLuint shader, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetShaderiv(%u, %s, " PRI_PTR ")", shader, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETSHADERIV(shader, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetSharpenTexFuncSGIS(GLenum target, memptr points)
#else
void OSMesaDriver::nfglGetSharpenTexFuncSGIS(GLenum target, GLfloat *points)
#endif
{
	D(bug("nfosmesa: glGetSharpenTexFuncSGIS(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(points)));
FN_GLGETSHARPENTEXFUNCSGIS(target, points);
}

GLushort OSMesaDriver::nfglGetStageIndexNV(GLenum shadertype)
{
	D(bug("nfosmesa: glGetStageIndexNV(%s)", gl_enum_name(shadertype)));
	GLushort __ret = fn.glGetStageIndexNV(shadertype);
	return __ret;
}

#if 0
const GLubyte * OSMesaDriver::nfglGetString(GLenum name)
{
	D(bug("nfosmesa: glGetString(%s)", gl_enum_name(name)));
FN_GLGETSTRING(name);
}
#endif

#if 0
const GLubyte * OSMesaDriver::nfglGetStringi(GLenum name, GLuint index)
{
	D(bug("nfosmesa: glGetStringi(%s, %u)", gl_enum_name(name), index));
	const GLubyte * __ret = fn.glGetStringi(name, index);
	return __ret;
}
#endif

#if NFOSMESA_POINTER_AS_MEMARG
GLuint OSMesaDriver::nfglGetSubroutineIndex(GLuint program, GLenum shadertype, memptr name)
#else
GLuint OSMesaDriver::nfglGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
#endif
{
	D(bug("nfosmesa: glGetSubroutineIndex(%u, %s, " PRI_PTR ")", program, gl_enum_name(shadertype), AtariOffset(name)));
FN_GLGETSUBROUTINEINDEX(program, shadertype, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLint OSMesaDriver::nfglGetSubroutineUniformLocation(GLuint program, GLenum shadertype, memptr name)
#else
GLint OSMesaDriver::nfglGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
#endif
{
	D(bug("nfosmesa: glGetSubroutineUniformLocation(%u, %s, " PRI_PTR ")", program, gl_enum_name(shadertype), AtariOffset(name)));
FN_GLGETSUBROUTINEUNIFORMLOCATION(program, shadertype, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, memptr length, memptr values)
#else
void OSMesaDriver::nfglGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
#endif
{
	D(bug("nfosmesa: glGetSynciv(" PRI_PTR ", %s, %d, " PRI_PTR ", " PRI_PTR ")", (unsigned int)(uintptr_t)sync, gl_enum_name(pname), bufSize, AtariOffset(length), AtariOffset(values)));
FN_GLGETSYNCIV(sync, pname, bufSize, length, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexBumpParameterfvATI(GLenum pname, memptr param)
#else
void OSMesaDriver::nfglGetTexBumpParameterfvATI(GLenum pname, GLfloat *param)
#endif
{
	D(bug("nfosmesa: glGetTexBumpParameterfvATI(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(param)));
FN_GLGETTEXBUMPPARAMETERFVATI(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexBumpParameterivATI(GLenum pname, memptr param)
#else
void OSMesaDriver::nfglGetTexBumpParameterivATI(GLenum pname, GLint *param)
#endif
{
	D(bug("nfosmesa: glGetTexBumpParameterivATI(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(param)));
FN_GLGETTEXBUMPPARAMETERIVATI(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexEnvfv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetTexEnvfv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXENVFV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexEnviv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTexEnviv(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetTexEnviv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXENVIV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexEnvxvOES(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTexEnvxvOES(GLenum target, GLenum pname, GLfixed *params)
#endif
{
	D(bug("nfosmesa: glGetTexEnvxvOES(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXENVXVOES(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexFilterFuncSGIS(GLenum target, GLenum filter, memptr weights)
#else
void OSMesaDriver::nfglGetTexFilterFuncSGIS(GLenum target, GLenum filter, GLfloat *weights)
#endif
{
	D(bug("nfosmesa: glGetTexFilterFuncSGIS(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(filter), AtariOffset(weights)));
FN_GLGETTEXFILTERFUNCSGIS(target, filter, weights);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexGendv(GLenum coord, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
#endif
{
	D(bug("nfosmesa: glGetTexGendv(%s, %s, " PRI_PTR ")", gl_enum_name(coord), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXGENDV(coord, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexGenfv(GLenum coord, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetTexGenfv(%s, %s, " PRI_PTR ")", gl_enum_name(coord), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXGENFV(coord, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexGeniv(GLenum coord, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetTexGeniv(%s, %s, " PRI_PTR ")", gl_enum_name(coord), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXGENIV(coord, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexGenxvOES(GLenum coord, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params)
#endif
{
	D(bug("nfosmesa: glGetTexGenxvOES(%s, %s, " PRI_PTR ")", gl_enum_name(coord), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXGENXVOES(coord, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
#endif
{
	D(bug("nfosmesa: glGetTexImage(%s, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), level, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLGETTEXIMAGE(target, level, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetTexLevelParameterfv(%s, %d, %s, " PRI_PTR ")", gl_enum_name(target), level, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXLEVELPARAMETERFV(target, level, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetTexLevelParameteriv(%s, %d, %s, " PRI_PTR ")", gl_enum_name(target), level, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXLEVELPARAMETERIV(target, level, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexLevelParameterxvOES(GLenum target, GLint level, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTexLevelParameterxvOES(GLenum target, GLint level, GLenum pname, GLfixed *params)
#endif
{
	D(bug("nfosmesa: glGetTexLevelParameterxvOES(%s, %d, %s, " PRI_PTR ")", gl_enum_name(target), level, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXLEVELPARAMETERXVOES(target, level, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexParameterIiv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetTexParameterIiv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXPARAMETERIIV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexParameterIivEXT(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTexParameterIivEXT(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetTexParameterIivEXT(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXPARAMETERIIVEXT(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexParameterIuiv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
#endif
{
	D(bug("nfosmesa: glGetTexParameterIuiv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXPARAMETERIUIV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexParameterIuivEXT(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTexParameterIuivEXT(GLenum target, GLenum pname, GLuint *params)
#endif
{
	D(bug("nfosmesa: glGetTexParameterIuivEXT(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXPARAMETERIUIVEXT(target, pname, params);
}

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexParameterPointervAPPLE(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTexParameterPointervAPPLE(GLenum target, GLenum pname, void * *params)
#endif
{
	D(bug("nfosmesa: glGetTexParameterPointervAPPLE(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXPARAMETERPOINTERVAPPLE(target, pname, params);
}
#endif

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexParameterfv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetTexParameterfv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXPARAMETERFV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexParameteriv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetTexParameteriv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXPARAMETERIV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTexParameterxvOES(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTexParameterxvOES(GLenum target, GLenum pname, GLfixed *params)
#endif
{
	D(bug("nfosmesa: glGetTexParameterxvOES(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXPARAMETERXVOES(target, pname, params);
}

GLuint64 OSMesaDriver::nfglGetTextureHandleARB(GLuint texture)
{
	D(bug("nfosmesa: glGetTextureHandleARB(%u)", texture));
FN_GLGETTEXTUREHANDLEARB(texture);
}

GLuint64 OSMesaDriver::nfglGetTextureHandleNV(GLuint texture)
{
	D(bug("nfosmesa: glGetTextureHandleNV(%u)", texture));
FN_GLGETTEXTUREHANDLENV(texture);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTextureImage(GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, memptr pixels)
#else
void OSMesaDriver::nfglGetTextureImage(GLuint texture, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
#endif
{
	D(bug("nfosmesa: glGetTextureImage(%u, %d, %s, %s, %d, " PRI_PTR ")", texture, level, gl_enum_name(format), gl_enum_name(type), bufSize, AtariOffset(pixels)));
FN_GLGETTEXTUREIMAGE(texture, level, format, type, bufSize, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTextureImageEXT(GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglGetTextureImageEXT(GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
#endif
{
	D(bug("nfosmesa: glGetTextureImageEXT(%u, %s, %d, %s, %s, " PRI_PTR ")", texture, gl_enum_name(target), level, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLGETTEXTUREIMAGEEXT(texture, target, level, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTextureLevelParameterfv(GLuint texture, GLint level, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTextureLevelParameterfv(GLuint texture, GLint level, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetTextureLevelParameterfv(%u, %d, %s, " PRI_PTR ")", texture, level, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXTURELEVELPARAMETERFV(texture, level, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTextureLevelParameterfvEXT(GLuint texture, GLenum target, GLint level, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTextureLevelParameterfvEXT(GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetTextureLevelParameterfvEXT(%u, %s, %d, %s, " PRI_PTR ")", texture, gl_enum_name(target), level, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXTURELEVELPARAMETERFVEXT(texture, target, level, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTextureLevelParameteriv(GLuint texture, GLint level, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTextureLevelParameteriv(GLuint texture, GLint level, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetTextureLevelParameteriv(%u, %d, %s, " PRI_PTR ")", texture, level, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXTURELEVELPARAMETERIV(texture, level, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTextureLevelParameterivEXT(GLuint texture, GLenum target, GLint level, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTextureLevelParameterivEXT(GLuint texture, GLenum target, GLint level, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetTextureLevelParameterivEXT(%u, %s, %d, %s, " PRI_PTR ")", texture, gl_enum_name(target), level, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXTURELEVELPARAMETERIVEXT(texture, target, level, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTextureParameterIiv(GLuint texture, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTextureParameterIiv(GLuint texture, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetTextureParameterIiv(%u, %s, " PRI_PTR ")", texture, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXTUREPARAMETERIIV(texture, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTextureParameterIivEXT(GLuint texture, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTextureParameterIivEXT(GLuint texture, GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetTextureParameterIivEXT(%u, %s, %s, " PRI_PTR ")", texture, gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXTUREPARAMETERIIVEXT(texture, target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTextureParameterIuiv(GLuint texture, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTextureParameterIuiv(GLuint texture, GLenum pname, GLuint *params)
#endif
{
	D(bug("nfosmesa: glGetTextureParameterIuiv(%u, %s, " PRI_PTR ")", texture, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXTUREPARAMETERIUIV(texture, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTextureParameterIuivEXT(GLuint texture, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTextureParameterIuivEXT(GLuint texture, GLenum target, GLenum pname, GLuint *params)
#endif
{
	D(bug("nfosmesa: glGetTextureParameterIuivEXT(%u, %s, %s, " PRI_PTR ")", texture, gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXTUREPARAMETERIUIVEXT(texture, target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTextureParameterfv(GLuint texture, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTextureParameterfv(GLuint texture, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetTextureParameterfv(%u, %s, " PRI_PTR ")", texture, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXTUREPARAMETERFV(texture, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetTextureParameterfvEXT(%u, %s, %s, " PRI_PTR ")", texture, gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXTUREPARAMETERFVEXT(texture, target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTextureParameteriv(GLuint texture, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTextureParameteriv(GLuint texture, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetTextureParameteriv(%u, %s, " PRI_PTR ")", texture, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXTUREPARAMETERIV(texture, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetTextureParameterivEXT(%u, %s, %s, " PRI_PTR ")", texture, gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTEXTUREPARAMETERIVEXT(texture, target, pname, params);
}

GLuint64 OSMesaDriver::nfglGetTextureSamplerHandleARB(GLuint texture, GLuint sampler)
{
	D(bug("nfosmesa: glGetTextureSamplerHandleARB(%u, %u)", texture, sampler));
FN_GLGETTEXTURESAMPLERHANDLEARB(texture, sampler);
}

GLuint64 OSMesaDriver::nfglGetTextureSamplerHandleNV(GLuint texture, GLuint sampler)
{
	D(bug("nfosmesa: glGetTextureSamplerHandleNV(%u, %u)", texture, sampler));
FN_GLGETTEXTURESAMPLERHANDLENV(texture, sampler);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, memptr pixels)
#else
void OSMesaDriver::nfglGetTextureSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
#endif
{
	D(bug("nfosmesa: glGetTextureSubImage(%u, %d, %d, %d, %d, %d, %d, %d, %s, %s, %d, " PRI_PTR ")", texture, level, xoffset, yoffset, zoffset, width, height, depth, gl_enum_name(format), gl_enum_name(type), bufSize, AtariOffset(pixels)));
FN_GLGETTEXTURESUBIMAGE(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, bufSize, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetTrackMatrixivNV(%s, %u, %s, " PRI_PTR ")", gl_enum_name(target), address, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETTRACKMATRIXIVNV(target, address, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, memptr length, memptr size, memptr type, memptr name)
#else
void OSMesaDriver::nfglGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
#endif
{
	D(bug("nfosmesa: glGetTransformFeedbackVarying(%u, %u, %d, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", program, index, bufSize, AtariOffset(length), AtariOffset(size), AtariOffset(type), AtariOffset(name)));
FN_GLGETTRANSFORMFEEDBACKVARYING(program, index, bufSize, length, size, type, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTransformFeedbackVaryingEXT(GLuint program, GLuint index, GLsizei bufSize, memptr length, memptr size, memptr type, memptr name)
#else
void OSMesaDriver::nfglGetTransformFeedbackVaryingEXT(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
#endif
{
	D(bug("nfosmesa: glGetTransformFeedbackVaryingEXT(%u, %u, %d, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", program, index, bufSize, AtariOffset(length), AtariOffset(size), AtariOffset(type), AtariOffset(name)));
FN_GLGETTRANSFORMFEEDBACKVARYINGEXT(program, index, bufSize, length, size, type, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTransformFeedbackVaryingNV(GLuint program, GLuint index, memptr location)
#else
void OSMesaDriver::nfglGetTransformFeedbackVaryingNV(GLuint program, GLuint index, GLint *location)
#endif
{
	D(bug("nfosmesa: glGetTransformFeedbackVaryingNV(%u, %u, " PRI_PTR ")", program, index, AtariOffset(location)));
FN_GLGETTRANSFORMFEEDBACKVARYINGNV(program, index, location);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTransformFeedbacki64_v(GLuint xfb, GLenum pname, GLuint index, memptr param)
#else
void OSMesaDriver::nfglGetTransformFeedbacki64_v(GLuint xfb, GLenum pname, GLuint index, GLint64 *param)
#endif
{
	D(bug("nfosmesa: glGetTransformFeedbacki64_v(%u, %s, %u, " PRI_PTR ")", xfb, gl_enum_name(pname), index, AtariOffset(param)));
FN_GLGETTRANSFORMFEEDBACKI64_V(xfb, pname, index, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTransformFeedbacki_v(GLuint xfb, GLenum pname, GLuint index, memptr param)
#else
void OSMesaDriver::nfglGetTransformFeedbacki_v(GLuint xfb, GLenum pname, GLuint index, GLint *param)
#endif
{
	D(bug("nfosmesa: glGetTransformFeedbacki_v(%u, %s, %u, " PRI_PTR ")", xfb, gl_enum_name(pname), index, AtariOffset(param)));
FN_GLGETTRANSFORMFEEDBACKI_V(xfb, pname, index, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetTransformFeedbackiv(GLuint xfb, GLenum pname, memptr param)
#else
void OSMesaDriver::nfglGetTransformFeedbackiv(GLuint xfb, GLenum pname, GLint *param)
#endif
{
	D(bug("nfosmesa: glGetTransformFeedbackiv(%u, %s, " PRI_PTR ")", xfb, gl_enum_name(pname), AtariOffset(param)));
FN_GLGETTRANSFORMFEEDBACKIV(xfb, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLuint OSMesaDriver::nfglGetUniformBlockIndex(GLuint program, memptr uniformBlockName)
#else
GLuint OSMesaDriver::nfglGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
#endif
{
	D(bug("nfosmesa: glGetUniformBlockIndex(%u, " PRI_PTR ")", program, AtariOffset(uniformBlockName)));
FN_GLGETUNIFORMBLOCKINDEX(program, uniformBlockName);
}

GLint OSMesaDriver::nfglGetUniformBufferSizeEXT(GLuint program, GLint location)
{
	D(bug("nfosmesa: glGetUniformBufferSizeEXT(%u, %d)", program, location));
	GLint __ret = fn.glGetUniformBufferSizeEXT(program, location);
	return __ret;
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetUniformIndices(GLuint program, GLsizei uniformCount, memptr uniformNames, memptr uniformIndices)
#else
void OSMesaDriver::nfglGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const *uniformNames, GLuint *uniformIndices)
#endif
{
	D(bug("nfosmesa: glGetUniformIndices(%u, %d, " PRI_PTR ", " PRI_PTR ")", program, uniformCount, AtariOffset(uniformNames), AtariOffset(uniformIndices)));
FN_GLGETUNIFORMINDICES(program, uniformCount, uniformNames, uniformIndices);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLint OSMesaDriver::nfglGetUniformLocation(GLuint program, memptr name)
#else
GLint OSMesaDriver::nfglGetUniformLocation(GLuint program, const GLchar *name)
#endif
{
	D(bug("nfosmesa: glGetUniformLocation(%u, " PRI_PTR ")", program, AtariOffset(name)));
FN_GLGETUNIFORMLOCATION(program, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLint OSMesaDriver::nfglGetUniformLocationARB(GLhandleARB programObj, memptr name)
#else
GLint OSMesaDriver::nfglGetUniformLocationARB(GLhandleARB programObj, const GLcharARB *name)
#endif
{
	D(bug("nfosmesa: glGetUniformLocationARB(%u, " PRI_PTR ")", (unsigned int)(uintptr_t)programObj, AtariOffset(name)));
#if NFOSMESA_NEED_BYTE_CONV
	GLint const __name_size = safe_strlen(name);
	GLcharARB __name_tmp[__name_size];
	GLcharARB *__name_ptmp = Atari2HostByteArray(__name_size, name, __name_tmp);
	GLint __ret = fn.glGetUniformLocationARB(programObj, __name_ptmp);
#else
	GLint __ret = fn.glGetUniformLocationARB(programObj, HostAddr(name, const GLcharARB *));
#endif
	return __ret;
}

GLintptr OSMesaDriver::nfglGetUniformOffsetEXT(GLuint program, GLint location)
{
	D(bug("nfosmesa: glGetUniformOffsetEXT(%u, %d)", program, location));
	GLintptr __ret = fn.glGetUniformOffsetEXT(program, location);
	return __ret;
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetUniformSubroutineuiv(GLenum shadertype, GLint location, memptr params)
#else
void OSMesaDriver::nfglGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
#endif
{
	D(bug("nfosmesa: glGetUniformSubroutineuiv(%s, %d, " PRI_PTR ")", gl_enum_name(shadertype), location, AtariOffset(params)));
FN_GLGETUNIFORMSUBROUTINEUIV(shadertype, location, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetUniformdv(GLuint program, GLint location, memptr params)
#else
void OSMesaDriver::nfglGetUniformdv(GLuint program, GLint location, GLdouble *params)
#endif
{
	D(bug("nfosmesa: glGetUniformdv(%u, %d, " PRI_PTR ")", program, location, AtariOffset(params)));
FN_GLGETUNIFORMDV(program, location, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetUniformfv(GLuint program, GLint location, memptr params)
#else
void OSMesaDriver::nfglGetUniformfv(GLuint program, GLint location, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetUniformfv(%u, %d, " PRI_PTR ")", program, location, AtariOffset(params)));
FN_GLGETUNIFORMFV(program, location, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetUniformfvARB(GLhandleARB programObj, GLint location, memptr params)
#else
void OSMesaDriver::nfglGetUniformfvARB(GLhandleARB programObj, GLint location, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetUniformfvARB(%u, %d, " PRI_PTR ")", (unsigned int)(uintptr_t)programObj, location, AtariOffset(params)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __params_size = 1;
	GLfloat __params_tmp[__params_size] = { 0 };
	fn.glGetUniformfvARB(programObj, location, __params_tmp);
	Host2AtariFloatArray(__params_size, __params_tmp, params);
#else
	fn.glGetUniformfvARB(programObj, location, HostAddr(params, GLfloat *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetUniformi64vARB(GLuint program, GLint location, memptr params)
#else
void OSMesaDriver::nfglGetUniformi64vARB(GLuint program, GLint location, GLint64 *params)
#endif
{
	D(bug("nfosmesa: glGetUniformi64vARB(%u, %d, " PRI_PTR ")", program, location, AtariOffset(params)));
FN_GLGETUNIFORMI64VARB(program, location, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetUniformi64vNV(GLuint program, GLint location, memptr params)
#else
void OSMesaDriver::nfglGetUniformi64vNV(GLuint program, GLint location, GLint64EXT *params)
#endif
{
	D(bug("nfosmesa: glGetUniformi64vNV(%u, %d, " PRI_PTR ")", program, location, AtariOffset(params)));
FN_GLGETUNIFORMI64VNV(program, location, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetUniformiv(GLuint program, GLint location, memptr params)
#else
void OSMesaDriver::nfglGetUniformiv(GLuint program, GLint location, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetUniformiv(%u, %d, " PRI_PTR ")", program, location, AtariOffset(params)));
FN_GLGETUNIFORMIV(program, location, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetUniformivARB(GLhandleARB programObj, GLint location, memptr params)
#else
void OSMesaDriver::nfglGetUniformivARB(GLhandleARB programObj, GLint location, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetUniformivARB(%u, %d, " PRI_PTR ")", (unsigned int)(uintptr_t)programObj, location, AtariOffset(params)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __params_size = 1;
	GLint __params_tmp[__params_size] = { 0 };
	fn.glGetUniformivARB(programObj, location, __params_tmp);
	Host2AtariIntArray(__params_size, __params_tmp, params);
#else
	fn.glGetUniformivARB(programObj, location, HostAddr(params, GLint *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetUniformui64vARB(GLuint program, GLint location, memptr params)
#else
void OSMesaDriver::nfglGetUniformui64vARB(GLuint program, GLint location, GLuint64 *params)
#endif
{
	D(bug("nfosmesa: glGetUniformui64vARB(%u, %d, " PRI_PTR ")", program, location, AtariOffset(params)));
FN_GLGETUNIFORMUI64VARB(program, location, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetUniformui64vNV(GLuint program, GLint location, memptr params)
#else
void OSMesaDriver::nfglGetUniformui64vNV(GLuint program, GLint location, GLuint64EXT *params)
#endif
{
	D(bug("nfosmesa: glGetUniformui64vNV(%u, %d, " PRI_PTR ")", program, location, AtariOffset(params)));
FN_GLGETUNIFORMUI64VNV(program, location, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetUniformuiv(GLuint program, GLint location, memptr params)
#else
void OSMesaDriver::nfglGetUniformuiv(GLuint program, GLint location, GLuint *params)
#endif
{
	D(bug("nfosmesa: glGetUniformuiv(%u, %d, " PRI_PTR ")", program, location, AtariOffset(params)));
FN_GLGETUNIFORMUIV(program, location, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetUniformuivEXT(GLuint program, GLint location, memptr params)
#else
void OSMesaDriver::nfglGetUniformuivEXT(GLuint program, GLint location, GLuint *params)
#endif
{
	D(bug("nfosmesa: glGetUniformuivEXT(%u, %d, " PRI_PTR ")", program, location, AtariOffset(params)));
FN_GLGETUNIFORMUIVEXT(program, location, params);
}

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetUnsignedBytei_vEXT(GLenum target, GLuint index, memptr data)
#else
void OSMesaDriver::nfglGetUnsignedBytei_vEXT(GLenum target, GLuint index, GLubyte *data)
#endif
{
	D(bug("nfosmesa: glGetUnsignedBytei_vEXT(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(data)));
	fn.glGetUnsignedBytei_vEXT(target, index, data);
}
#endif

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetUnsignedBytevEXT(GLenum pname, memptr data)
#else
void OSMesaDriver::nfglGetUnsignedBytevEXT(GLenum pname, GLubyte *data)
#endif
{
	D(bug("nfosmesa: glGetUnsignedBytevEXT(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(data)));
	fn.glGetUnsignedBytevEXT(pname, data);
}
#endif

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVariantArrayObjectfvATI(GLuint id, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVariantArrayObjectfvATI(GLuint id, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetVariantArrayObjectfvATI(%u, %s, " PRI_PTR ")", id, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVARIANTARRAYOBJECTFVATI(id, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVariantArrayObjectivATI(GLuint id, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVariantArrayObjectivATI(GLuint id, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetVariantArrayObjectivATI(%u, %s, " PRI_PTR ")", id, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVARIANTARRAYOBJECTIVATI(id, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVariantBooleanvEXT(GLuint id, GLenum value, memptr data)
#else
void OSMesaDriver::nfglGetVariantBooleanvEXT(GLuint id, GLenum value, GLboolean *data)
#endif
{
	D(bug("nfosmesa: glGetVariantBooleanvEXT(%u, %s, " PRI_PTR ")", id, gl_enum_name(value), AtariOffset(data)));
FN_GLGETVARIANTBOOLEANVEXT(id, value, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVariantFloatvEXT(GLuint id, GLenum value, memptr data)
#else
void OSMesaDriver::nfglGetVariantFloatvEXT(GLuint id, GLenum value, GLfloat *data)
#endif
{
	D(bug("nfosmesa: glGetVariantFloatvEXT(%u, %s, " PRI_PTR ")", id, gl_enum_name(value), AtariOffset(data)));
FN_GLGETVARIANTFLOATVEXT(id, value, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVariantIntegervEXT(GLuint id, GLenum value, memptr data)
#else
void OSMesaDriver::nfglGetVariantIntegervEXT(GLuint id, GLenum value, GLint *data)
#endif
{
	D(bug("nfosmesa: glGetVariantIntegervEXT(%u, %s, " PRI_PTR ")", id, gl_enum_name(value), AtariOffset(data)));
FN_GLGETVARIANTINTEGERVEXT(id, value, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVariantPointervEXT(GLuint id, GLenum value, memptr data)
#else
void OSMesaDriver::nfglGetVariantPointervEXT(GLuint id, GLenum value, void * *data)
#endif
{
	D(bug("nfosmesa: glGetVariantPointervEXT(%u, %s, " PRI_PTR ")", id, gl_enum_name(value), AtariOffset(data)));
FN_GLGETVARIANTPOINTERVEXT(id, value, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLint OSMesaDriver::nfglGetVaryingLocationNV(GLuint program, memptr name)
#else
GLint OSMesaDriver::nfglGetVaryingLocationNV(GLuint program, const GLchar *name)
#endif
{
	D(bug("nfosmesa: glGetVaryingLocationNV(%u, " PRI_PTR ")", program, AtariOffset(name)));
FN_GLGETVARYINGLOCATIONNV(program, name);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexArrayIndexed64iv(GLuint vaobj, GLuint index, GLenum pname, memptr param)
#else
void OSMesaDriver::nfglGetVertexArrayIndexed64iv(GLuint vaobj, GLuint index, GLenum pname, GLint64 *param)
#endif
{
	D(bug("nfosmesa: glGetVertexArrayIndexed64iv(%u, %u, %s, " PRI_PTR ")", vaobj, index, gl_enum_name(pname), AtariOffset(param)));
FN_GLGETVERTEXARRAYINDEXED64IV(vaobj, index, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexArrayIndexediv(GLuint vaobj, GLuint index, GLenum pname, memptr param)
#else
void OSMesaDriver::nfglGetVertexArrayIndexediv(GLuint vaobj, GLuint index, GLenum pname, GLint *param)
#endif
{
	D(bug("nfosmesa: glGetVertexArrayIndexediv(%u, %u, %s, " PRI_PTR ")", vaobj, index, gl_enum_name(pname), AtariOffset(param)));
FN_GLGETVERTEXARRAYINDEXEDIV(vaobj, index, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexArrayIntegeri_vEXT(GLuint vaobj, GLuint index, GLenum pname, memptr param)
#else
void OSMesaDriver::nfglGetVertexArrayIntegeri_vEXT(GLuint vaobj, GLuint index, GLenum pname, GLint *param)
#endif
{
	D(bug("nfosmesa: glGetVertexArrayIntegeri_vEXT(%u, %u, %s, " PRI_PTR ")", vaobj, index, gl_enum_name(pname), AtariOffset(param)));
FN_GLGETVERTEXARRAYINTEGERI_VEXT(vaobj, index, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexArrayIntegervEXT(GLuint vaobj, GLenum pname, memptr param)
#else
void OSMesaDriver::nfglGetVertexArrayIntegervEXT(GLuint vaobj, GLenum pname, GLint *param)
#endif
{
	D(bug("nfosmesa: glGetVertexArrayIntegervEXT(%u, %s, " PRI_PTR ")", vaobj, gl_enum_name(pname), AtariOffset(param)));
FN_GLGETVERTEXARRAYINTEGERVEXT(vaobj, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexArrayPointeri_vEXT(GLuint vaobj, GLuint index, GLenum pname, memptr param)
#else
void OSMesaDriver::nfglGetVertexArrayPointeri_vEXT(GLuint vaobj, GLuint index, GLenum pname, void * *param)
#endif
{
	D(bug("nfosmesa: glGetVertexArrayPointeri_vEXT(%u, %u, %s, " PRI_PTR ")", vaobj, index, gl_enum_name(pname), AtariOffset(param)));
FN_GLGETVERTEXARRAYPOINTERI_VEXT(vaobj, index, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexArrayPointervEXT(GLuint vaobj, GLenum pname, memptr param)
#else
void OSMesaDriver::nfglGetVertexArrayPointervEXT(GLuint vaobj, GLenum pname, void * *param)
#endif
{
	D(bug("nfosmesa: glGetVertexArrayPointervEXT(%u, %s, " PRI_PTR ")", vaobj, gl_enum_name(pname), AtariOffset(param)));
FN_GLGETVERTEXARRAYPOINTERVEXT(vaobj, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexArrayiv(GLuint vaobj, GLenum pname, memptr param)
#else
void OSMesaDriver::nfglGetVertexArrayiv(GLuint vaobj, GLenum pname, GLint *param)
#endif
{
	D(bug("nfosmesa: glGetVertexArrayiv(%u, %s, " PRI_PTR ")", vaobj, gl_enum_name(pname), AtariOffset(param)));
FN_GLGETVERTEXARRAYIV(vaobj, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribArrayObjectfvATI(GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVertexAttribArrayObjectfvATI(GLuint index, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribArrayObjectfvATI(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVERTEXATTRIBARRAYOBJECTFVATI(index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribArrayObjectivATI(GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVertexAttribArrayObjectivATI(GLuint index, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribArrayObjectivATI(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVERTEXATTRIBARRAYOBJECTIVATI(index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribIiv(GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribIiv(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVERTEXATTRIBIIV(index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribIivEXT(GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVertexAttribIivEXT(GLuint index, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribIivEXT(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVERTEXATTRIBIIVEXT(index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribIuiv(GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribIuiv(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVERTEXATTRIBIUIV(index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribIuivEXT(GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVertexAttribIuivEXT(GLuint index, GLenum pname, GLuint *params)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribIuivEXT(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVERTEXATTRIBIUIVEXT(index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribLdv(GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribLdv(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVERTEXATTRIBLDV(index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribLdvEXT(GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVertexAttribLdvEXT(GLuint index, GLenum pname, GLdouble *params)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribLdvEXT(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVERTEXATTRIBLDVEXT(index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribLi64vNV(GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVertexAttribLi64vNV(GLuint index, GLenum pname, GLint64EXT *params)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribLi64vNV(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVERTEXATTRIBLI64VNV(index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribLui64vARB(GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVertexAttribLui64vARB(GLuint index, GLenum pname, GLuint64EXT *params)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribLui64vARB(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVERTEXATTRIBLUI64VARB(index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribLui64vNV(GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVertexAttribLui64vNV(GLuint index, GLenum pname, GLuint64EXT *params)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribLui64vNV(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVERTEXATTRIBLUI64VNV(index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribPointerv(GLuint index, GLenum pname, memptr pointer)
#else
void OSMesaDriver::nfglGetVertexAttribPointerv(GLuint index, GLenum pname, void * *pointer)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribPointerv(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(pointer)));
FN_GLGETVERTEXATTRIBPOINTERV(index, pname, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribPointervARB(GLuint index, GLenum pname, memptr pointer)
#else
void OSMesaDriver::nfglGetVertexAttribPointervARB(GLuint index, GLenum pname, void * *pointer)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribPointervARB(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(pointer)));
FN_GLGETVERTEXATTRIBPOINTERVARB(index, pname, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribPointervNV(GLuint index, GLenum pname, memptr pointer)
#else
void OSMesaDriver::nfglGetVertexAttribPointervNV(GLuint index, GLenum pname, void * *pointer)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribPointervNV(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(pointer)));
FN_GLGETVERTEXATTRIBPOINTERVNV(index, pname, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribdv(GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribdv(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVERTEXATTRIBDV(index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribdvARB(GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble *params)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribdvARB(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVERTEXATTRIBDVARB(index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribdvNV(GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble *params)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribdvNV(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVERTEXATTRIBDVNV(index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribfv(GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribfv(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVERTEXATTRIBFV(index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribfvARB(GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribfvARB(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVERTEXATTRIBFVARB(index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribfvNV(GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribfvNV(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVERTEXATTRIBFVNV(index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribiv(GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribiv(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVERTEXATTRIBIV(index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribivARB(GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVertexAttribivARB(GLuint index, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribivARB(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVERTEXATTRIBIVARB(index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVertexAttribivNV(GLuint index, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVertexAttribivNV(GLuint index, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetVertexAttribivNV(%u, %s, " PRI_PTR ")", index, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVERTEXATTRIBIVNV(index, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVideoCaptureStreamdvNV(GLuint video_capture_slot, GLuint stream, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVideoCaptureStreamdvNV(GLuint video_capture_slot, GLuint stream, GLenum pname, GLdouble *params)
#endif
{
	D(bug("nfosmesa: glGetVideoCaptureStreamdvNV(%u, %u, %s, " PRI_PTR ")", video_capture_slot, stream, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVIDEOCAPTURESTREAMDVNV(video_capture_slot, stream, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVideoCaptureStreamfvNV(GLuint video_capture_slot, GLuint stream, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVideoCaptureStreamfvNV(GLuint video_capture_slot, GLuint stream, GLenum pname, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetVideoCaptureStreamfvNV(%u, %u, %s, " PRI_PTR ")", video_capture_slot, stream, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVIDEOCAPTURESTREAMFVNV(video_capture_slot, stream, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVideoCaptureStreamivNV(GLuint video_capture_slot, GLuint stream, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVideoCaptureStreamivNV(GLuint video_capture_slot, GLuint stream, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetVideoCaptureStreamivNV(%u, %u, %s, " PRI_PTR ")", video_capture_slot, stream, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVIDEOCAPTURESTREAMIVNV(video_capture_slot, stream, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVideoCaptureivNV(GLuint video_capture_slot, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVideoCaptureivNV(GLuint video_capture_slot, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetVideoCaptureivNV(%u, %s, " PRI_PTR ")", video_capture_slot, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVIDEOCAPTUREIVNV(video_capture_slot, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVideoi64vNV(GLuint video_slot, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVideoi64vNV(GLuint video_slot, GLenum pname, GLint64EXT *params)
#endif
{
	D(bug("nfosmesa: glGetVideoi64vNV(%u, %s, " PRI_PTR ")", video_slot, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVIDEOI64VNV(video_slot, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVideoivNV(GLuint video_slot, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVideoivNV(GLuint video_slot, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetVideoivNV(%u, %s, " PRI_PTR ")", video_slot, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVIDEOIVNV(video_slot, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVideoui64vNV(GLuint video_slot, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVideoui64vNV(GLuint video_slot, GLenum pname, GLuint64EXT *params)
#endif
{
	D(bug("nfosmesa: glGetVideoui64vNV(%u, %s, " PRI_PTR ")", video_slot, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVIDEOUI64VNV(video_slot, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetVideouivNV(GLuint video_slot, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglGetVideouivNV(GLuint video_slot, GLenum pname, GLuint *params)
#endif
{
	D(bug("nfosmesa: glGetVideouivNV(%u, %s, " PRI_PTR ")", video_slot, gl_enum_name(pname), AtariOffset(params)));
FN_GLGETVIDEOUIVNV(video_slot, pname, params);
}

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
GLVULKANPROCNV OSMesaDriver::nfglGetVkProcAddrNV(memptr name)
#else
GLVULKANPROCNV OSMesaDriver::nfglGetVkProcAddrNV(const GLchar *name)
#endif
{
	D(bug("nfosmesa: glGetVkProcAddrNV(" PRI_PTR ")", AtariOffset(name)));
	GLVULKANPROCNV __ret = fn.glGetVkProcAddrNV(name);
	return __ret;
}
#endif

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnColorTable(GLenum target, GLenum format, GLenum type, GLsizei bufSize, memptr table)
#else
void OSMesaDriver::nfglGetnColorTable(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *table)
#endif
{
	D(bug("nfosmesa: glGetnColorTable(%s, %s, %s, %d, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(format), gl_enum_name(type), bufSize, AtariOffset(table)));
FN_GLGETNCOLORTABLE(target, format, type, bufSize, table);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnColorTableARB(GLenum target, GLenum format, GLenum type, GLsizei bufSize, memptr table)
#else
void OSMesaDriver::nfglGetnColorTableARB(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *table)
#endif
{
	D(bug("nfosmesa: glGetnColorTableARB(%s, %s, %s, %d, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(format), gl_enum_name(type), bufSize, AtariOffset(table)));
FN_GLGETNCOLORTABLEARB(target, format, type, bufSize, table);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnCompressedTexImage(GLenum target, GLint lod, GLsizei bufSize, memptr pixels)
#else
void OSMesaDriver::nfglGetnCompressedTexImage(GLenum target, GLint lod, GLsizei bufSize, void *pixels)
#endif
{
	D(bug("nfosmesa: glGetnCompressedTexImage(%s, %d, %d, " PRI_PTR ")", gl_enum_name(target), lod, bufSize, AtariOffset(pixels)));
FN_GLGETNCOMPRESSEDTEXIMAGE(target, lod, bufSize, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnCompressedTexImageARB(GLenum target, GLint lod, GLsizei bufSize, memptr img)
#else
void OSMesaDriver::nfglGetnCompressedTexImageARB(GLenum target, GLint lod, GLsizei bufSize, void *img)
#endif
{
	D(bug("nfosmesa: glGetnCompressedTexImageARB(%s, %d, %d, " PRI_PTR ")", gl_enum_name(target), lod, bufSize, AtariOffset(img)));
FN_GLGETNCOMPRESSEDTEXIMAGEARB(target, lod, bufSize, img);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnConvolutionFilter(GLenum target, GLenum format, GLenum type, GLsizei bufSize, memptr image)
#else
void OSMesaDriver::nfglGetnConvolutionFilter(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *image)
#endif
{
	D(bug("nfosmesa: glGetnConvolutionFilter(%s, %s, %s, %d, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(format), gl_enum_name(type), bufSize, AtariOffset(image)));
FN_GLGETNCONVOLUTIONFILTER(target, format, type, bufSize, image);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnConvolutionFilterARB(GLenum target, GLenum format, GLenum type, GLsizei bufSize, memptr image)
#else
void OSMesaDriver::nfglGetnConvolutionFilterARB(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *image)
#endif
{
	D(bug("nfosmesa: glGetnConvolutionFilterARB(%s, %s, %s, %d, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(format), gl_enum_name(type), bufSize, AtariOffset(image)));
FN_GLGETNCONVOLUTIONFILTERARB(target, format, type, bufSize, image);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnHistogram(GLenum target, GLboolean32 reset, GLenum format, GLenum type, GLsizei bufSize, memptr values)
#else
void OSMesaDriver::nfglGetnHistogram(GLenum target, GLboolean32 reset, GLenum format, GLenum type, GLsizei bufSize, void *values)
#endif
{
	D(bug("nfosmesa: glGetnHistogram(%s, %d, %s, %s, %d, " PRI_PTR ")", gl_enum_name(target), reset, gl_enum_name(format), gl_enum_name(type), bufSize, AtariOffset(values)));
FN_GLGETNHISTOGRAM(target, reset, format, type, bufSize, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnHistogramARB(GLenum target, GLboolean32 reset, GLenum format, GLenum type, GLsizei bufSize, memptr values)
#else
void OSMesaDriver::nfglGetnHistogramARB(GLenum target, GLboolean32 reset, GLenum format, GLenum type, GLsizei bufSize, void *values)
#endif
{
	D(bug("nfosmesa: glGetnHistogramARB(%s, %d, %s, %s, %d, " PRI_PTR ")", gl_enum_name(target), reset, gl_enum_name(format), gl_enum_name(type), bufSize, AtariOffset(values)));
FN_GLGETNHISTOGRAMARB(target, reset, format, type, bufSize, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnMapdv(GLenum target, GLenum query, GLsizei bufSize, memptr v)
#else
void OSMesaDriver::nfglGetnMapdv(GLenum target, GLenum query, GLsizei bufSize, GLdouble *v)
#endif
{
	D(bug("nfosmesa: glGetnMapdv(%s, %s, %d, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(query), bufSize, AtariOffset(v)));
FN_GLGETNMAPDV(target, query, bufSize, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnMapdvARB(GLenum target, GLenum query, GLsizei bufSize, memptr v)
#else
void OSMesaDriver::nfglGetnMapdvARB(GLenum target, GLenum query, GLsizei bufSize, GLdouble *v)
#endif
{
	D(bug("nfosmesa: glGetnMapdvARB(%s, %s, %d, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(query), bufSize, AtariOffset(v)));
FN_GLGETNMAPDVARB(target, query, bufSize, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnMapfv(GLenum target, GLenum query, GLsizei bufSize, memptr v)
#else
void OSMesaDriver::nfglGetnMapfv(GLenum target, GLenum query, GLsizei bufSize, GLfloat *v)
#endif
{
	D(bug("nfosmesa: glGetnMapfv(%s, %s, %d, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(query), bufSize, AtariOffset(v)));
FN_GLGETNMAPFV(target, query, bufSize, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnMapfvARB(GLenum target, GLenum query, GLsizei bufSize, memptr v)
#else
void OSMesaDriver::nfglGetnMapfvARB(GLenum target, GLenum query, GLsizei bufSize, GLfloat *v)
#endif
{
	D(bug("nfosmesa: glGetnMapfvARB(%s, %s, %d, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(query), bufSize, AtariOffset(v)));
FN_GLGETNMAPFVARB(target, query, bufSize, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnMapiv(GLenum target, GLenum query, GLsizei bufSize, memptr v)
#else
void OSMesaDriver::nfglGetnMapiv(GLenum target, GLenum query, GLsizei bufSize, GLint *v)
#endif
{
	D(bug("nfosmesa: glGetnMapiv(%s, %s, %d, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(query), bufSize, AtariOffset(v)));
FN_GLGETNMAPIV(target, query, bufSize, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnMapivARB(GLenum target, GLenum query, GLsizei bufSize, memptr v)
#else
void OSMesaDriver::nfglGetnMapivARB(GLenum target, GLenum query, GLsizei bufSize, GLint *v)
#endif
{
	D(bug("nfosmesa: glGetnMapivARB(%s, %s, %d, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(query), bufSize, AtariOffset(v)));
FN_GLGETNMAPIVARB(target, query, bufSize, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnMinmax(GLenum target, GLboolean32 reset, GLenum format, GLenum type, GLsizei bufSize, memptr values)
#else
void OSMesaDriver::nfglGetnMinmax(GLenum target, GLboolean32 reset, GLenum format, GLenum type, GLsizei bufSize, void *values)
#endif
{
	D(bug("nfosmesa: glGetnMinmax(%s, %d, %s, %s, %d, " PRI_PTR ")", gl_enum_name(target), reset, gl_enum_name(format), gl_enum_name(type), bufSize, AtariOffset(values)));
FN_GLGETNMINMAX(target, reset, format, type, bufSize, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnMinmaxARB(GLenum target, GLboolean32 reset, GLenum format, GLenum type, GLsizei bufSize, memptr values)
#else
void OSMesaDriver::nfglGetnMinmaxARB(GLenum target, GLboolean32 reset, GLenum format, GLenum type, GLsizei bufSize, void *values)
#endif
{
	D(bug("nfosmesa: glGetnMinmaxARB(%s, %d, %s, %s, %d, " PRI_PTR ")", gl_enum_name(target), reset, gl_enum_name(format), gl_enum_name(type), bufSize, AtariOffset(values)));
FN_GLGETNMINMAXARB(target, reset, format, type, bufSize, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnPixelMapfv(GLenum map, GLsizei bufSize, memptr values)
#else
void OSMesaDriver::nfglGetnPixelMapfv(GLenum map, GLsizei bufSize, GLfloat *values)
#endif
{
	D(bug("nfosmesa: glGetnPixelMapfv(%s, %d, " PRI_PTR ")", gl_enum_name(map), bufSize, AtariOffset(values)));
FN_GLGETNPIXELMAPFV(map, bufSize, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnPixelMapfvARB(GLenum map, GLsizei bufSize, memptr values)
#else
void OSMesaDriver::nfglGetnPixelMapfvARB(GLenum map, GLsizei bufSize, GLfloat *values)
#endif
{
	D(bug("nfosmesa: glGetnPixelMapfvARB(%s, %d, " PRI_PTR ")", gl_enum_name(map), bufSize, AtariOffset(values)));
FN_GLGETNPIXELMAPFVARB(map, bufSize, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnPixelMapuiv(GLenum map, GLsizei bufSize, memptr values)
#else
void OSMesaDriver::nfglGetnPixelMapuiv(GLenum map, GLsizei bufSize, GLuint *values)
#endif
{
	D(bug("nfosmesa: glGetnPixelMapuiv(%s, %d, " PRI_PTR ")", gl_enum_name(map), bufSize, AtariOffset(values)));
FN_GLGETNPIXELMAPUIV(map, bufSize, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnPixelMapuivARB(GLenum map, GLsizei bufSize, memptr values)
#else
void OSMesaDriver::nfglGetnPixelMapuivARB(GLenum map, GLsizei bufSize, GLuint *values)
#endif
{
	D(bug("nfosmesa: glGetnPixelMapuivARB(%s, %d, " PRI_PTR ")", gl_enum_name(map), bufSize, AtariOffset(values)));
FN_GLGETNPIXELMAPUIVARB(map, bufSize, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnPixelMapusv(GLenum map, GLsizei bufSize, memptr values)
#else
void OSMesaDriver::nfglGetnPixelMapusv(GLenum map, GLsizei bufSize, GLushort *values)
#endif
{
	D(bug("nfosmesa: glGetnPixelMapusv(%s, %d, " PRI_PTR ")", gl_enum_name(map), bufSize, AtariOffset(values)));
FN_GLGETNPIXELMAPUSV(map, bufSize, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnPixelMapusvARB(GLenum map, GLsizei bufSize, memptr values)
#else
void OSMesaDriver::nfglGetnPixelMapusvARB(GLenum map, GLsizei bufSize, GLushort *values)
#endif
{
	D(bug("nfosmesa: glGetnPixelMapusvARB(%s, %d, " PRI_PTR ")", gl_enum_name(map), bufSize, AtariOffset(values)));
FN_GLGETNPIXELMAPUSVARB(map, bufSize, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnPolygonStipple(GLsizei bufSize, memptr pattern)
#else
void OSMesaDriver::nfglGetnPolygonStipple(GLsizei bufSize, GLubyte *pattern)
#endif
{
	D(bug("nfosmesa: glGetnPolygonStipple(%d, " PRI_PTR ")", bufSize, AtariOffset(pattern)));
FN_GLGETNPOLYGONSTIPPLE(bufSize, pattern);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnPolygonStippleARB(GLsizei bufSize, memptr pattern)
#else
void OSMesaDriver::nfglGetnPolygonStippleARB(GLsizei bufSize, GLubyte *pattern)
#endif
{
	D(bug("nfosmesa: glGetnPolygonStippleARB(%d, " PRI_PTR ")", bufSize, AtariOffset(pattern)));
FN_GLGETNPOLYGONSTIPPLEARB(bufSize, pattern);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnSeparableFilter(GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, memptr row, GLsizei columnBufSize, memptr column, memptr span)
#else
void OSMesaDriver::nfglGetnSeparableFilter(GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void *row, GLsizei columnBufSize, void *column, void *span)
#endif
{
	D(bug("nfosmesa: glGetnSeparableFilter(%s, %s, %s, %d, " PRI_PTR ", %d, " PRI_PTR ", " PRI_PTR ")", gl_enum_name(target), gl_enum_name(format), gl_enum_name(type), rowBufSize, AtariOffset(row), columnBufSize, AtariOffset(column), AtariOffset(span)));
FN_GLGETNSEPARABLEFILTER(target, format, type, rowBufSize, row, columnBufSize, column, span);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnSeparableFilterARB(GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, memptr row, GLsizei columnBufSize, memptr column, memptr span)
#else
void OSMesaDriver::nfglGetnSeparableFilterARB(GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void *row, GLsizei columnBufSize, void *column, void *span)
#endif
{
	D(bug("nfosmesa: glGetnSeparableFilterARB(%s, %s, %s, %d, " PRI_PTR ", %d, " PRI_PTR ", " PRI_PTR ")", gl_enum_name(target), gl_enum_name(format), gl_enum_name(type), rowBufSize, AtariOffset(row), columnBufSize, AtariOffset(column), AtariOffset(span)));
FN_GLGETNSEPARABLEFILTERARB(target, format, type, rowBufSize, row, columnBufSize, column, span);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, memptr pixels)
#else
void OSMesaDriver::nfglGetnTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *pixels)
#endif
{
	D(bug("nfosmesa: glGetnTexImage(%s, %d, %s, %s, %d, " PRI_PTR ")", gl_enum_name(target), level, gl_enum_name(format), gl_enum_name(type), bufSize, AtariOffset(pixels)));
FN_GLGETNTEXIMAGE(target, level, format, type, bufSize, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnTexImageARB(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, memptr img)
#else
void OSMesaDriver::nfglGetnTexImageARB(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *img)
#endif
{
	D(bug("nfosmesa: glGetnTexImageARB(%s, %d, %s, %s, %d, " PRI_PTR ")", gl_enum_name(target), level, gl_enum_name(format), gl_enum_name(type), bufSize, AtariOffset(img)));
FN_GLGETNTEXIMAGEARB(target, level, format, type, bufSize, img);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnUniformdv(GLuint program, GLint location, GLsizei bufSize, memptr params)
#else
void OSMesaDriver::nfglGetnUniformdv(GLuint program, GLint location, GLsizei bufSize, GLdouble *params)
#endif
{
	D(bug("nfosmesa: glGetnUniformdv(%u, %d, %d, " PRI_PTR ")", program, location, bufSize, AtariOffset(params)));
FN_GLGETNUNIFORMDV(program, location, bufSize, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnUniformdvARB(GLuint program, GLint location, GLsizei bufSize, memptr params)
#else
void OSMesaDriver::nfglGetnUniformdvARB(GLuint program, GLint location, GLsizei bufSize, GLdouble *params)
#endif
{
	D(bug("nfosmesa: glGetnUniformdvARB(%u, %d, %d, " PRI_PTR ")", program, location, bufSize, AtariOffset(params)));
FN_GLGETNUNIFORMDVARB(program, location, bufSize, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnUniformfv(GLuint program, GLint location, GLsizei bufSize, memptr params)
#else
void OSMesaDriver::nfglGetnUniformfv(GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetnUniformfv(%u, %d, %d, " PRI_PTR ")", program, location, bufSize, AtariOffset(params)));
FN_GLGETNUNIFORMFV(program, location, bufSize, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnUniformfvARB(GLuint program, GLint location, GLsizei bufSize, memptr params)
#else
void OSMesaDriver::nfglGetnUniformfvARB(GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
#endif
{
	D(bug("nfosmesa: glGetnUniformfvARB(%u, %d, %d, " PRI_PTR ")", program, location, bufSize, AtariOffset(params)));
FN_GLGETNUNIFORMFVARB(program, location, bufSize, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnUniformi64vARB(GLuint program, GLint location, GLsizei bufSize, memptr params)
#else
void OSMesaDriver::nfglGetnUniformi64vARB(GLuint program, GLint location, GLsizei bufSize, GLint64 *params)
#endif
{
	D(bug("nfosmesa: glGetnUniformi64vARB(%u, %d, %d, " PRI_PTR ")", program, location, bufSize, AtariOffset(params)));
FN_GLGETNUNIFORMI64VARB(program, location, bufSize, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnUniformiv(GLuint program, GLint location, GLsizei bufSize, memptr params)
#else
void OSMesaDriver::nfglGetnUniformiv(GLuint program, GLint location, GLsizei bufSize, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetnUniformiv(%u, %d, %d, " PRI_PTR ")", program, location, bufSize, AtariOffset(params)));
FN_GLGETNUNIFORMIV(program, location, bufSize, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnUniformivARB(GLuint program, GLint location, GLsizei bufSize, memptr params)
#else
void OSMesaDriver::nfglGetnUniformivARB(GLuint program, GLint location, GLsizei bufSize, GLint *params)
#endif
{
	D(bug("nfosmesa: glGetnUniformivARB(%u, %d, %d, " PRI_PTR ")", program, location, bufSize, AtariOffset(params)));
FN_GLGETNUNIFORMIVARB(program, location, bufSize, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnUniformui64vARB(GLuint program, GLint location, GLsizei bufSize, memptr params)
#else
void OSMesaDriver::nfglGetnUniformui64vARB(GLuint program, GLint location, GLsizei bufSize, GLuint64 *params)
#endif
{
	D(bug("nfosmesa: glGetnUniformui64vARB(%u, %d, %d, " PRI_PTR ")", program, location, bufSize, AtariOffset(params)));
FN_GLGETNUNIFORMUI64VARB(program, location, bufSize, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize, memptr params)
#else
void OSMesaDriver::nfglGetnUniformuiv(GLuint program, GLint location, GLsizei bufSize, GLuint *params)
#endif
{
	D(bug("nfosmesa: glGetnUniformuiv(%u, %d, %d, " PRI_PTR ")", program, location, bufSize, AtariOffset(params)));
FN_GLGETNUNIFORMUIV(program, location, bufSize, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglGetnUniformuivARB(GLuint program, GLint location, GLsizei bufSize, memptr params)
#else
void OSMesaDriver::nfglGetnUniformuivARB(GLuint program, GLint location, GLsizei bufSize, GLuint *params)
#endif
{
	D(bug("nfosmesa: glGetnUniformuivARB(%u, %d, %d, " PRI_PTR ")", program, location, bufSize, AtariOffset(params)));
FN_GLGETNUNIFORMUIVARB(program, location, bufSize, params);
}

void OSMesaDriver::nfglGlobalAlphaFactorbSUN(GLbyte32 factor)
{
	D(bug("nfosmesa: glGlobalAlphaFactorbSUN(%d)", factor));
	fn.glGlobalAlphaFactorbSUN(factor);
}

void OSMesaDriver::nfglGlobalAlphaFactordSUN(GLdouble factor)
{
	D(bug("nfosmesa: glGlobalAlphaFactordSUN(%f)", factor));
	fn.glGlobalAlphaFactordSUN(factor);
}

void OSMesaDriver::nfglGlobalAlphaFactorfSUN(GLfloat factor)
{
	D(bug("nfosmesa: glGlobalAlphaFactorfSUN(%f)", factor));
	fn.glGlobalAlphaFactorfSUN(factor);
}

void OSMesaDriver::nfglGlobalAlphaFactoriSUN(GLint factor)
{
	D(bug("nfosmesa: glGlobalAlphaFactoriSUN(%d)", factor));
	fn.glGlobalAlphaFactoriSUN(factor);
}

void OSMesaDriver::nfglGlobalAlphaFactorsSUN(GLshort32 factor)
{
	D(bug("nfosmesa: glGlobalAlphaFactorsSUN(%d)", factor));
	fn.glGlobalAlphaFactorsSUN(factor);
}

void OSMesaDriver::nfglGlobalAlphaFactorubSUN(GLubyte32 factor)
{
	D(bug("nfosmesa: glGlobalAlphaFactorubSUN(%u)", factor));
	fn.glGlobalAlphaFactorubSUN(factor);
}

void OSMesaDriver::nfglGlobalAlphaFactoruiSUN(GLuint factor)
{
	D(bug("nfosmesa: glGlobalAlphaFactoruiSUN(%u)", factor));
	fn.glGlobalAlphaFactoruiSUN(factor);
}

void OSMesaDriver::nfglGlobalAlphaFactorusSUN(GLushort32 factor)
{
	D(bug("nfosmesa: glGlobalAlphaFactorusSUN(%u)", factor));
	fn.glGlobalAlphaFactorusSUN(factor);
}

void OSMesaDriver::nfglHint(GLenum target, GLenum mode)
{
	D(bug("nfosmesa: glHint(%s, %s)", gl_enum_name(target), gl_enum_name(mode)));
	fn.glHint(target, mode);
}

void OSMesaDriver::nfglHintPGI(GLenum target, GLint mode)
{
	D(bug("nfosmesa: glHintPGI(%s, %d)", gl_enum_name(target), mode));
	fn.glHintPGI(target, mode);
}

void OSMesaDriver::nfglHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean32 sink)
{
	D(bug("nfosmesa: glHistogram(%s, %d, %s, %d)", gl_enum_name(target), width, gl_enum_name(internalformat), sink));
	fn.glHistogram(target, width, internalformat, sink);
}

void OSMesaDriver::nfglHistogramEXT(GLenum target, GLsizei width, GLenum internalformat, GLboolean32 sink)
{
	D(bug("nfosmesa: glHistogramEXT(%s, %d, %s, %d)", gl_enum_name(target), width, gl_enum_name(internalformat), sink));
	fn.glHistogramEXT(target, width, internalformat, sink);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglIglooInterfaceSGIX(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglIglooInterfaceSGIX(GLenum pname, const void *params)
#endif
{
	D(bug("nfosmesa: glIglooInterfaceSGIX(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLIGLOOINTERFACESGIX(pname, params);
}

void OSMesaDriver::nfglImageTransformParameterfHP(GLenum target, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glImageTransformParameterfHP(%s, %s, %f)", gl_enum_name(target), gl_enum_name(pname), param));
	fn.glImageTransformParameterfHP(target, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglImageTransformParameterfvHP(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglImageTransformParameterfvHP(GLenum target, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glImageTransformParameterfvHP(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLIMAGETRANSFORMPARAMETERFVHP(target, pname, params);
}

void OSMesaDriver::nfglImageTransformParameteriHP(GLenum target, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glImageTransformParameteriHP(%s, %s, %d)", gl_enum_name(target), gl_enum_name(pname), param));
	fn.glImageTransformParameteriHP(target, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglImageTransformParameterivHP(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglImageTransformParameterivHP(GLenum target, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glImageTransformParameterivHP(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLIMAGETRANSFORMPARAMETERIVHP(target, pname, params);
}

void OSMesaDriver::nfglImportMemoryFdEXT(GLuint memory, GLuint64 size, GLenum handleType, GLint fd)
{
	D(bug("nfosmesa: glImportMemoryFdEXT(%u, %" PRIu64 ", %s, %d)", memory, size, gl_enum_name(handleType), fd));
	fn.glImportMemoryFdEXT(memory, size, handleType, fd);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglImportMemoryWin32HandleEXT(GLuint memory, GLuint64 size, GLenum handleType, memptr handle)
#else
void OSMesaDriver::nfglImportMemoryWin32HandleEXT(GLuint memory, GLuint64 size, GLenum handleType, void *handle)
#endif
{
	D(bug("nfosmesa: glImportMemoryWin32HandleEXT(%u, %" PRIu64 ", %s, " PRI_PTR ")", memory, size, gl_enum_name(handleType), AtariOffset(handle)));
FN_GLIMPORTMEMORYWIN32HANDLEEXT(memory, size, handleType, handle);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglImportMemoryWin32NameEXT(GLuint memory, GLuint64 size, GLenum handleType, memptr name)
#else
void OSMesaDriver::nfglImportMemoryWin32NameEXT(GLuint memory, GLuint64 size, GLenum handleType, const void *name)
#endif
{
	D(bug("nfosmesa: glImportMemoryWin32NameEXT(%u, %" PRIu64 ", %s, " PRI_PTR ")", memory, size, gl_enum_name(handleType), AtariOffset(name)));
#if NFOSMESA_NEED_BYTE_CONV
	GLint const __name_size = safe_strlen(name) + 1;
	GLchar __name_tmp[__name_size];
	GLchar *__name_ptmp = Atari2HostByteArray(__name_size, name, __name_tmp);
	fn.glImportMemoryWin32NameEXT(memory, size, handleType, __name_ptmp);
#else
	fn.glImportMemoryWin32NameEXT(memory, size, handleType, HostAddr(name, const void *));
#endif
}

void OSMesaDriver::nfglImportSemaphoreFdEXT(GLuint semaphore, GLenum handleType, GLint fd)
{
	D(bug("nfosmesa: glImportSemaphoreFdEXT(%u, %s, %d)", semaphore, gl_enum_name(handleType), fd));
	fn.glImportSemaphoreFdEXT(semaphore, handleType, fd);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglImportSemaphoreWin32HandleEXT(GLuint semaphore, GLenum handleType, memptr handle)
#else
void OSMesaDriver::nfglImportSemaphoreWin32HandleEXT(GLuint semaphore, GLenum handleType, void *handle)
#endif
{
	D(bug("nfosmesa: glImportSemaphoreWin32HandleEXT(%u, %s, " PRI_PTR ")", semaphore, gl_enum_name(handleType), AtariOffset(handle)));
FN_GLIMPORTSEMAPHOREWIN32HANDLEEXT(semaphore, handleType, handle);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglImportSemaphoreWin32NameEXT(GLuint semaphore, GLenum handleType, memptr name)
#else
void OSMesaDriver::nfglImportSemaphoreWin32NameEXT(GLuint semaphore, GLenum handleType, const void *name)
#endif
{
	D(bug("nfosmesa: glImportSemaphoreWin32NameEXT(%u, %s, " PRI_PTR ")", semaphore, gl_enum_name(handleType), AtariOffset(name)));
#if NFOSMESA_NEED_BYTE_CONV
	GLint const __name_size = safe_strlen(name) + 1;
	GLchar __name_tmp[__name_size];
	GLchar *__name_ptmp = Atari2HostByteArray(__name_size, name, __name_tmp);
	fn.glImportSemaphoreWin32NameEXT(semaphore, handleType, __name_ptmp);
#else
	fn.glImportSemaphoreWin32NameEXT(semaphore, handleType, HostAddr(name, const void *));
#endif
}

#if 0
GLsync OSMesaDriver::nfglImportSyncEXT(GLenum external_sync_type, GLintptr external_sync, GLbitfield flags)
{
	D(bug("nfosmesa: glImportSyncEXT(%s, %" PRI_IPTR ", 0x%x)", gl_enum_name(external_sync_type), external_sync, flags));
	GLsync __ret = fn.glImportSyncEXT(external_sync_type, external_sync, flags);
	return __ret;
}
#endif

void OSMesaDriver::nfglIndexFormatNV(GLenum type, GLsizei stride)
{
	D(bug("nfosmesa: glIndexFormatNV(%s, %d)", gl_enum_name(type), stride));
	fn.glIndexFormatNV(type, stride);
}

void OSMesaDriver::nfglIndexFuncEXT(GLenum func, GLclampf ref)
{
	D(bug("nfosmesa: glIndexFuncEXT(%s, %f)", gl_enum_name(func), ref));
	fn.glIndexFuncEXT(func, ref);
}

void OSMesaDriver::nfglIndexMask(GLuint mask)
{
	D(bug("nfosmesa: glIndexMask(%u)", mask));
	fn.glIndexMask(mask);
}

void OSMesaDriver::nfglIndexMaterialEXT(GLenum face, GLenum mode)
{
	D(bug("nfosmesa: glIndexMaterialEXT(%s, %s)", gl_enum_name(face), gl_enum_name(mode)));
	fn.glIndexMaterialEXT(face, mode);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglIndexPointer(GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
#endif
{
	D(bug("nfosmesa: glIndexPointer(%s, %d, " PRI_PTR ")", gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLINDEXPOINTER(type, stride, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, memptr pointer)
#else
void OSMesaDriver::nfglIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const void *pointer)
#endif
{
	D(bug("nfosmesa: glIndexPointerEXT(%s, %d, %d, " PRI_PTR ")", gl_enum_name(type), stride, count, AtariOffset(pointer)));
FN_GLINDEXPOINTEREXT(type, stride, count, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglIndexPointerListIBM(GLenum type, GLint stride, memptr pointer, GLint ptrstride)
#else
void OSMesaDriver::nfglIndexPointerListIBM(GLenum type, GLint stride, const void * *pointer, GLint ptrstride)
#endif
{
	D(bug("nfosmesa: glIndexPointerListIBM(%s, %d, " PRI_PTR ", %d)", gl_enum_name(type), stride, AtariOffset(pointer), ptrstride));
FN_GLINDEXPOINTERLISTIBM(type, stride, pointer, ptrstride);
}

void OSMesaDriver::nfglIndexd(GLdouble c)
{
	D(bug("nfosmesa: glIndexd(%f)", c));
	fn.glIndexd(c);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglIndexdv(memptr c)
#else
void OSMesaDriver::nfglIndexdv(const GLdouble *c)
#endif
{
	D(bug("nfosmesa: glIndexdv(" PRI_PTR ")", AtariOffset(c)));
FN_GLINDEXDV(c);
}

void OSMesaDriver::nfglIndexf(GLfloat c)
{
	D(bug("nfosmesa: glIndexf(%f)", c));
	fn.glIndexf(c);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglIndexfv(memptr c)
#else
void OSMesaDriver::nfglIndexfv(const GLfloat *c)
#endif
{
	D(bug("nfosmesa: glIndexfv(" PRI_PTR ")", AtariOffset(c)));
FN_GLINDEXFV(c);
}

void OSMesaDriver::nfglIndexi(GLint c)
{
	D(bug("nfosmesa: glIndexi(%d)", c));
	fn.glIndexi(c);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglIndexiv(memptr c)
#else
void OSMesaDriver::nfglIndexiv(const GLint *c)
#endif
{
	D(bug("nfosmesa: glIndexiv(" PRI_PTR ")", AtariOffset(c)));
FN_GLINDEXIV(c);
}

void OSMesaDriver::nfglIndexs(GLshort32 c)
{
	D(bug("nfosmesa: glIndexs(%d)", c));
	fn.glIndexs(c);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglIndexsv(memptr c)
#else
void OSMesaDriver::nfglIndexsv(const GLshort *c)
#endif
{
	D(bug("nfosmesa: glIndexsv(" PRI_PTR ")", AtariOffset(c)));
FN_GLINDEXSV(c);
}

void OSMesaDriver::nfglIndexub(GLubyte32 c)
{
	D(bug("nfosmesa: glIndexub(%u)", c));
	fn.glIndexub(c);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglIndexubv(memptr c)
#else
void OSMesaDriver::nfglIndexubv(const GLubyte *c)
#endif
{
	D(bug("nfosmesa: glIndexubv(" PRI_PTR ")", AtariOffset(c)));
FN_GLINDEXUBV(c);
}

void OSMesaDriver::nfglIndexxOES(GLfixed component)
{
	D(bug("nfosmesa: glIndexxOES(0x%x)", component));
	fn.glIndexxOES(component);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglIndexxvOES(memptr component)
#else
void OSMesaDriver::nfglIndexxvOES(const GLfixed *component)
#endif
{
	D(bug("nfosmesa: glIndexxvOES(" PRI_PTR ")", AtariOffset(component)));
FN_GLINDEXXVOES(component);
}

void OSMesaDriver::nfglInitNames(void)
{
	D(bug("nfosmesa: glInitNames()"));
	fn.glInitNames();
}

void OSMesaDriver::nfglInsertComponentEXT(GLuint res, GLuint src, GLuint num)
{
	D(bug("nfosmesa: glInsertComponentEXT(%u, %u, %u)", res, src, num));
	fn.glInsertComponentEXT(res, src, num);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglInsertEventMarkerEXT(GLsizei length, memptr marker)
#else
void OSMesaDriver::nfglInsertEventMarkerEXT(GLsizei length, const GLchar *marker)
#endif
{
	D(bug("nfosmesa: glInsertEventMarkerEXT(%d, " PRI_PTR ")", length, AtariOffset(marker)));
#if NFOSMESA_NEED_BYTE_CONV
	GLint const __marker_size = length > 0 ? length : safe_strlen(marker) + 1;
	GLchar __marker_tmp[__marker_size];
	GLchar *__marker_ptmp = Atari2HostByteArray(__marker_size, marker, __marker_tmp);
	fn.glInsertEventMarkerEXT(length, __marker_ptmp);
#else
	fn.glInsertEventMarkerEXT(length, HostAddr(marker, const GLchar *));
#endif
}

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglInstrumentsBufferSGIX(GLsizei size, memptr buffer)
#else
void OSMesaDriver::nfglInstrumentsBufferSGIX(GLsizei size, GLint *buffer)
#endif
{
	D(bug("nfosmesa: glInstrumentsBufferSGIX(%d, " PRI_PTR ")", size, AtariOffset(buffer)));
FN_GLINSTRUMENTSBUFFERSGIX(size, buffer);
}
#endif

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglInterleavedArrays(GLenum format, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
#endif
{
	D(bug("nfosmesa: glInterleavedArrays(%s, %d, " PRI_PTR ")", gl_enum_name(format), stride, AtariOffset(pointer)));
FN_GLINTERLEAVEDARRAYS(format, stride, pointer);
}

void OSMesaDriver::nfglInterpolatePathsNV(GLuint resultPath, GLuint pathA, GLuint pathB, GLfloat weight)
{
	D(bug("nfosmesa: glInterpolatePathsNV(%u, %u, %u, %f)", resultPath, pathA, pathB, weight));
	fn.glInterpolatePathsNV(resultPath, pathA, pathB, weight);
}

void OSMesaDriver::nfglInvalidateBufferData(GLuint buffer)
{
	D(bug("nfosmesa: glInvalidateBufferData(%u)", buffer));
FN_GLINVALIDATEBUFFERDATA(buffer);
}

void OSMesaDriver::nfglInvalidateBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr length)
{
	D(bug("nfosmesa: glInvalidateBufferSubData(%u, %" PRI_IPTR ", %" PRI_IPTR ")", buffer, offset, length));
	fn.glInvalidateBufferSubData(buffer, offset, length);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglInvalidateFramebuffer(GLenum target, GLsizei numAttachments, memptr attachments)
#else
void OSMesaDriver::nfglInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
#endif
{
	D(bug("nfosmesa: glInvalidateFramebuffer(%s, %d, " PRI_PTR ")", gl_enum_name(target), numAttachments, AtariOffset(attachments)));
FN_GLINVALIDATEFRAMEBUFFER(target, numAttachments, attachments);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglInvalidateNamedFramebufferData(GLuint framebuffer, GLsizei numAttachments, memptr attachments)
#else
void OSMesaDriver::nfglInvalidateNamedFramebufferData(GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments)
#endif
{
	D(bug("nfosmesa: glInvalidateNamedFramebufferData(%u, %d, " PRI_PTR ")", framebuffer, numAttachments, AtariOffset(attachments)));
FN_GLINVALIDATENAMEDFRAMEBUFFERDATA(framebuffer, numAttachments, attachments);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglInvalidateNamedFramebufferSubData(GLuint framebuffer, GLsizei numAttachments, memptr attachments, GLint x, GLint y, GLsizei width, GLsizei height)
#else
void OSMesaDriver::nfglInvalidateNamedFramebufferSubData(GLuint framebuffer, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
#endif
{
	D(bug("nfosmesa: glInvalidateNamedFramebufferSubData(%u, %d, " PRI_PTR ", %d, %d, %d, %d)", framebuffer, numAttachments, AtariOffset(attachments), x, y, width, height));
FN_GLINVALIDATENAMEDFRAMEBUFFERSUBDATA(framebuffer, numAttachments, attachments, x, y, width, height);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, memptr attachments, GLint x, GLint y, GLsizei width, GLsizei height)
#else
void OSMesaDriver::nfglInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
#endif
{
	D(bug("nfosmesa: glInvalidateSubFramebuffer(%s, %d, " PRI_PTR ", %d, %d, %d, %d)", gl_enum_name(target), numAttachments, AtariOffset(attachments), x, y, width, height));
FN_GLINVALIDATESUBFRAMEBUFFER(target, numAttachments, attachments, x, y, width, height);
}

void OSMesaDriver::nfglInvalidateTexImage(GLuint texture, GLint level)
{
	D(bug("nfosmesa: glInvalidateTexImage(%u, %d)", texture, level));
	fn.glInvalidateTexImage(texture, level);
}

void OSMesaDriver::nfglInvalidateTexSubImage(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth)
{
	D(bug("nfosmesa: glInvalidateTexSubImage(%u, %d, %d, %d, %d, %d, %d, %d)", texture, level, xoffset, yoffset, zoffset, width, height, depth));
	fn.glInvalidateTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth);
}

GLboolean OSMesaDriver::nfglIsAsyncMarkerSGIX(GLuint marker)
{
	D(bug("nfosmesa: glIsAsyncMarkerSGIX(%u)", marker));
	GLboolean __ret = fn.glIsAsyncMarkerSGIX(marker);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsBuffer(GLuint buffer)
{
	D(bug("nfosmesa: glIsBuffer(%u)", buffer));
	GLboolean __ret = fn.glIsBuffer(buffer);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsBufferARB(GLuint buffer)
{
	D(bug("nfosmesa: glIsBufferARB(%u)", buffer));
	GLboolean __ret = fn.glIsBufferARB(buffer);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsBufferResidentNV(GLenum target)
{
	D(bug("nfosmesa: glIsBufferResidentNV(%s)", gl_enum_name(target)));
	GLboolean __ret = fn.glIsBufferResidentNV(target);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsCommandListNV(GLuint list)
{
	D(bug("nfosmesa: glIsCommandListNV(%u)", list));
	GLboolean __ret = fn.glIsCommandListNV(list);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsEnabled(GLenum cap)
{
	D(bug("nfosmesa: glIsEnabled(%s)", gl_enum_name(cap)));
FN_GLISENABLED(cap);
}

GLboolean OSMesaDriver::nfglIsEnabledIndexedEXT(GLenum target, GLuint index)
{
	D(bug("nfosmesa: glIsEnabledIndexedEXT(%s, %u)", gl_enum_name(target), index));
	GLboolean __ret = fn.glIsEnabledIndexedEXT(target, index);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsEnabledi(GLenum target, GLuint index)
{
	D(bug("nfosmesa: glIsEnabledi(%s, %u)", gl_enum_name(target), index));
	GLboolean __ret = fn.glIsEnabledi(target, index);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsFenceAPPLE(GLuint fence)
{
	D(bug("nfosmesa: glIsFenceAPPLE(%u)", fence));
	GLboolean __ret = fn.glIsFenceAPPLE(fence);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsFenceNV(GLuint fence)
{
	D(bug("nfosmesa: glIsFenceNV(%u)", fence));
	GLboolean __ret = fn.glIsFenceNV(fence);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsFramebuffer(GLuint framebuffer)
{
	D(bug("nfosmesa: glIsFramebuffer(%u)", framebuffer));
	GLboolean __ret = fn.glIsFramebuffer(framebuffer);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsFramebufferEXT(GLuint framebuffer)
{
	D(bug("nfosmesa: glIsFramebufferEXT(%u)", framebuffer));
	GLboolean __ret = fn.glIsFramebufferEXT(framebuffer);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsImageHandleResidentARB(GLuint64 handle)
{
	D(bug("nfosmesa: glIsImageHandleResidentARB(%" PRIu64 ")", handle));
	GLboolean __ret = fn.glIsImageHandleResidentARB(handle);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsImageHandleResidentNV(GLuint64 handle)
{
	D(bug("nfosmesa: glIsImageHandleResidentNV(%" PRIu64 ")", handle));
	GLboolean __ret = fn.glIsImageHandleResidentNV(handle);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsList(GLuint list)
{
	D(bug("nfosmesa: glIsList(%u)", list));
	GLboolean __ret = fn.glIsList(list);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsMemoryObjectEXT(GLuint memoryObject)
{
	D(bug("nfosmesa: glIsMemoryObjectEXT(%u)", memoryObject));
	GLboolean __ret = fn.glIsMemoryObjectEXT(memoryObject);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsNameAMD(GLenum identifier, GLuint name)
{
	D(bug("nfosmesa: glIsNameAMD(%s, %u)", gl_enum_name(identifier), name));
	GLboolean __ret = fn.glIsNameAMD(identifier, name);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsNamedBufferResidentNV(GLuint buffer)
{
	D(bug("nfosmesa: glIsNamedBufferResidentNV(%u)", buffer));
	GLboolean __ret = fn.glIsNamedBufferResidentNV(buffer);
	return __ret;
}

#if NFOSMESA_POINTER_AS_MEMARG
GLboolean OSMesaDriver::nfglIsNamedStringARB(GLint namelen, memptr name)
#else
GLboolean OSMesaDriver::nfglIsNamedStringARB(GLint namelen, const GLchar *name)
#endif
{
	D(bug("nfosmesa: glIsNamedStringARB(%d, " PRI_PTR ")", namelen, AtariOffset(name)));
FN_GLISNAMEDSTRINGARB(namelen, name);
}

GLboolean OSMesaDriver::nfglIsObjectBufferATI(GLuint buffer)
{
	D(bug("nfosmesa: glIsObjectBufferATI(%u)", buffer));
	GLboolean __ret = fn.glIsObjectBufferATI(buffer);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsOcclusionQueryNV(GLuint id)
{
	D(bug("nfosmesa: glIsOcclusionQueryNV(%u)", id));
	GLboolean __ret = fn.glIsOcclusionQueryNV(id);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsPathNV(GLuint path)
{
	D(bug("nfosmesa: glIsPathNV(%u)", path));
	GLboolean __ret = fn.glIsPathNV(path);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsPointInFillPathNV(GLuint path, GLuint mask, GLfloat x, GLfloat y)
{
	D(bug("nfosmesa: glIsPointInFillPathNV(%u, %u, %f, %f)", path, mask, x, y));
	GLboolean __ret = fn.glIsPointInFillPathNV(path, mask, x, y);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsPointInStrokePathNV(GLuint path, GLfloat x, GLfloat y)
{
	D(bug("nfosmesa: glIsPointInStrokePathNV(%u, %f, %f)", path, x, y));
	GLboolean __ret = fn.glIsPointInStrokePathNV(path, x, y);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsProgram(GLuint program)
{
	D(bug("nfosmesa: glIsProgram(%u)", program));
	GLboolean __ret = fn.glIsProgram(program);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsProgramARB(GLuint program)
{
	D(bug("nfosmesa: glIsProgramARB(%u)", program));
	GLboolean __ret = fn.glIsProgramARB(program);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsProgramNV(GLuint id)
{
	D(bug("nfosmesa: glIsProgramNV(%u)", id));
	GLboolean __ret = fn.glIsProgramNV(id);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsProgramPipeline(GLuint pipeline)
{
	D(bug("nfosmesa: glIsProgramPipeline(%u)", pipeline));
	GLboolean __ret = fn.glIsProgramPipeline(pipeline);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsQuery(GLuint id)
{
	D(bug("nfosmesa: glIsQuery(%u)", id));
	GLboolean __ret = fn.glIsQuery(id);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsQueryARB(GLuint id)
{
	D(bug("nfosmesa: glIsQueryARB(%u)", id));
	GLboolean __ret = fn.glIsQueryARB(id);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsRenderbuffer(GLuint renderbuffer)
{
	D(bug("nfosmesa: glIsRenderbuffer(%u)", renderbuffer));
	GLboolean __ret = fn.glIsRenderbuffer(renderbuffer);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsRenderbufferEXT(GLuint renderbuffer)
{
	D(bug("nfosmesa: glIsRenderbufferEXT(%u)", renderbuffer));
	GLboolean __ret = fn.glIsRenderbufferEXT(renderbuffer);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsSampler(GLuint sampler)
{
	D(bug("nfosmesa: glIsSampler(%u)", sampler));
	GLboolean __ret = fn.glIsSampler(sampler);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsSemaphoreEXT(GLuint semaphore)
{
	D(bug("nfosmesa: glIsSemaphoreEXT(%u)", semaphore));
	GLboolean __ret = fn.glIsSemaphoreEXT(semaphore);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsShader(GLuint shader)
{
	D(bug("nfosmesa: glIsShader(%u)", shader));
	GLboolean __ret = fn.glIsShader(shader);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsStateNV(GLuint state)
{
	D(bug("nfosmesa: glIsStateNV(%u)", state));
	GLboolean __ret = fn.glIsStateNV(state);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsSync(GLsync sync)
{
	D(bug("nfosmesa: glIsSync(" PRI_PTR ")", (unsigned int)(uintptr_t)sync));
	GLboolean __ret = fn.glIsSync(sync);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsTexture(GLuint texture)
{
	D(bug("nfosmesa: glIsTexture(%u)", texture));
	GLboolean __ret = fn.glIsTexture(texture);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsTextureEXT(GLuint texture)
{
	D(bug("nfosmesa: glIsTextureEXT(%u)", texture));
	GLboolean __ret = fn.glIsTextureEXT(texture);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsTextureHandleResidentARB(GLuint64 handle)
{
	D(bug("nfosmesa: glIsTextureHandleResidentARB(%" PRIu64 ")", handle));
	GLboolean __ret = fn.glIsTextureHandleResidentARB(handle);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsTextureHandleResidentNV(GLuint64 handle)
{
	D(bug("nfosmesa: glIsTextureHandleResidentNV(%" PRIu64 ")", handle));
	GLboolean __ret = fn.glIsTextureHandleResidentNV(handle);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsTransformFeedback(GLuint id)
{
	D(bug("nfosmesa: glIsTransformFeedback(%u)", id));
	GLboolean __ret = fn.glIsTransformFeedback(id);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsTransformFeedbackNV(GLuint id)
{
	D(bug("nfosmesa: glIsTransformFeedbackNV(%u)", id));
	GLboolean __ret = fn.glIsTransformFeedbackNV(id);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsVariantEnabledEXT(GLuint id, GLenum cap)
{
	D(bug("nfosmesa: glIsVariantEnabledEXT(%u, %s)", id, gl_enum_name(cap)));
	GLboolean __ret = fn.glIsVariantEnabledEXT(id, cap);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsVertexArray(GLuint array)
{
	D(bug("nfosmesa: glIsVertexArray(%u)", array));
	GLboolean __ret = fn.glIsVertexArray(array);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsVertexArrayAPPLE(GLuint array)
{
	D(bug("nfosmesa: glIsVertexArrayAPPLE(%u)", array));
	GLboolean __ret = fn.glIsVertexArrayAPPLE(array);
	return __ret;
}

GLboolean OSMesaDriver::nfglIsVertexAttribEnabledAPPLE(GLuint index, GLenum pname)
{
	D(bug("nfosmesa: glIsVertexAttribEnabledAPPLE(%u, %s)", index, gl_enum_name(pname)));
	GLboolean __ret = fn.glIsVertexAttribEnabledAPPLE(index, pname);
	return __ret;
}

void OSMesaDriver::nfglLGPUCopyImageSubDataNVX(GLuint sourceGpu, GLbitfield destinationGpuMask, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srxY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei width, GLsizei height, GLsizei depth)
{
	D(bug("nfosmesa: glLGPUCopyImageSubDataNVX(%u, 0x%x, %u, %s, %d, %d, %d, %d, %u, %s, %d, %d, %d, %d, %d, %d, %d)", sourceGpu, destinationGpuMask, srcName, gl_enum_name(srcTarget), srcLevel, srcX, srxY, srcZ, dstName, gl_enum_name(dstTarget), dstLevel, dstX, dstY, dstZ, width, height, depth));
	fn.glLGPUCopyImageSubDataNVX(sourceGpu, destinationGpuMask, srcName, srcTarget, srcLevel, srcX, srxY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, width, height, depth);
}

void OSMesaDriver::nfglLGPUInterlockNVX(void)
{
	D(bug("nfosmesa: glLGPUInterlockNVX()"));
	fn.glLGPUInterlockNVX();
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglLGPUNamedBufferSubDataNVX(GLbitfield gpuMask, GLuint buffer, GLintptr offset, GLsizeiptr size, memptr data)
#else
void OSMesaDriver::nfglLGPUNamedBufferSubDataNVX(GLbitfield gpuMask, GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data)
#endif
{
	D(bug("nfosmesa: glLGPUNamedBufferSubDataNVX(0x%x, %u, %" PRI_IPTR ", %" PRI_IPTR ", " PRI_PTR ")", gpuMask, buffer, offset, size, AtariOffset(data)));
#if NFOSMESA_NEED_BYTE_CONV
	GLint const __data_size = MAX(size, 0);
	GLbyte __data_tmp[__data_size];
	GLbyte *__data_ptmp = Atari2HostByteArray(__data_size, data, __data_tmp);
	fn.glLGPUNamedBufferSubDataNVX(gpuMask, buffer, offset, size, __data_ptmp);
#else
	fn.glLGPUNamedBufferSubDataNVX(gpuMask, buffer, offset, size, HostAddr(data, const void *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglLabelObjectEXT(GLenum type, GLuint object, GLsizei length, memptr label)
#else
void OSMesaDriver::nfglLabelObjectEXT(GLenum type, GLuint object, GLsizei length, const GLchar *label)
#endif
{
	D(bug("nfosmesa: glLabelObjectEXT(%s, %u, %d, " PRI_PTR ")", gl_enum_name(type), object, length, AtariOffset(label)));
FN_GLLABELOBJECTEXT(type, object, length, label);
}

void OSMesaDriver::nfglLightEnviSGIX(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glLightEnviSGIX(%s, %d)", gl_enum_name(pname), param));
	fn.glLightEnviSGIX(pname, param);
}

void OSMesaDriver::nfglLightModelf(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glLightModelf(%s, %f)", gl_enum_name(pname), param));
	fn.glLightModelf(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglLightModelfv(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglLightModelfv(GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glLightModelfv(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLLIGHTMODELFV(pname, params);
}

void OSMesaDriver::nfglLightModeli(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glLightModeli(%s, %d)", gl_enum_name(pname), param));
	fn.glLightModeli(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglLightModeliv(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglLightModeliv(GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glLightModeliv(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLLIGHTMODELIV(pname, params);
}

void OSMesaDriver::nfglLightModelxOES(GLenum pname, GLfixed param)
{
	D(bug("nfosmesa: glLightModelxOES(%s, 0x%x)", gl_enum_name(pname), param));
	fn.glLightModelxOES(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglLightModelxvOES(GLenum pname, memptr param)
#else
void OSMesaDriver::nfglLightModelxvOES(GLenum pname, const GLfixed *param)
#endif
{
	D(bug("nfosmesa: glLightModelxvOES(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(param)));
FN_GLLIGHTMODELXVOES(pname, param);
}

void OSMesaDriver::nfglLightf(GLenum light, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glLightf(%s, %s, %f)", gl_enum_name(light), gl_enum_name(pname), param));
	fn.glLightf(light, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglLightfv(GLenum light, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglLightfv(GLenum light, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glLightfv(%s, %s, " PRI_PTR ")", gl_enum_name(light), gl_enum_name(pname), AtariOffset(params)));
FN_GLLIGHTFV(light, pname, params);
}

void OSMesaDriver::nfglLighti(GLenum light, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glLighti(%s, %s, %d)", gl_enum_name(light), gl_enum_name(pname), param));
	fn.glLighti(light, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglLightiv(GLenum light, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglLightiv(GLenum light, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glLightiv(%s, %s, " PRI_PTR ")", gl_enum_name(light), gl_enum_name(pname), AtariOffset(params)));
FN_GLLIGHTIV(light, pname, params);
}

void OSMesaDriver::nfglLightxOES(GLenum light, GLenum pname, GLfixed param)
{
	D(bug("nfosmesa: glLightxOES(%s, %s, 0x%x)", gl_enum_name(light), gl_enum_name(pname), param));
	fn.glLightxOES(light, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglLightxvOES(GLenum light, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglLightxvOES(GLenum light, GLenum pname, const GLfixed *params)
#endif
{
	D(bug("nfosmesa: glLightxvOES(%s, %s, " PRI_PTR ")", gl_enum_name(light), gl_enum_name(pname), AtariOffset(params)));
FN_GLLIGHTXVOES(light, pname, params);
}

void OSMesaDriver::nfglLineStipple(GLint factor, GLushort32 pattern)
{
	D(bug("nfosmesa: glLineStipple(%d, %u)", factor, pattern));
	fn.glLineStipple(factor, pattern);
}

void OSMesaDriver::nfglLineWidth(GLfloat width)
{
	D(bug("nfosmesa: glLineWidth(%f)", width));
	fn.glLineWidth(width);
}

void OSMesaDriver::nfglLineWidthxOES(GLfixed width)
{
	D(bug("nfosmesa: glLineWidthxOES(0x%x)", width));
	fn.glLineWidthxOES(width);
}

void OSMesaDriver::nfglLinkProgram(GLuint program)
{
	D(bug("nfosmesa: glLinkProgram(%u)", program));
	fn.glLinkProgram(program);
}

void OSMesaDriver::nfglLinkProgramARB(GLhandleARB programObj)
{
	D(bug("nfosmesa: glLinkProgramARB(%u)", (unsigned int)(uintptr_t)programObj));
	fn.glLinkProgramARB(programObj);
}

void OSMesaDriver::nfglListBase(GLuint base)
{
	D(bug("nfosmesa: glListBase(%u)", base));
	fn.glListBase(base);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglListDrawCommandsStatesClientNV(GLuint list, GLuint segment, memptr indirects, memptr sizes, memptr states, memptr fbos, GLuint count)
#else
void OSMesaDriver::nfglListDrawCommandsStatesClientNV(GLuint list, GLuint segment, const void * *indirects, const GLsizei *sizes, const GLuint *states, const GLuint *fbos, GLuint count)
#endif
{
	D(bug("nfosmesa: glListDrawCommandsStatesClientNV(%u, %u, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", %u)", list, segment, AtariOffset(indirects), AtariOffset(sizes), AtariOffset(states), AtariOffset(fbos), count));
FN_GLLISTDRAWCOMMANDSSTATESCLIENTNV(list, segment, indirects, sizes, states, fbos, count);
}

void OSMesaDriver::nfglListParameterfSGIX(GLuint list, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glListParameterfSGIX(%u, %s, %f)", list, gl_enum_name(pname), param));
	fn.glListParameterfSGIX(list, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglListParameterfvSGIX(GLuint list, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglListParameterfvSGIX(GLuint list, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glListParameterfvSGIX(%u, %s, " PRI_PTR ")", list, gl_enum_name(pname), AtariOffset(params)));
FN_GLLISTPARAMETERFVSGIX(list, pname, params);
}

void OSMesaDriver::nfglListParameteriSGIX(GLuint list, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glListParameteriSGIX(%u, %s, %d)", list, gl_enum_name(pname), param));
	fn.glListParameteriSGIX(list, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglListParameterivSGIX(GLuint list, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglListParameterivSGIX(GLuint list, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glListParameterivSGIX(%u, %s, " PRI_PTR ")", list, gl_enum_name(pname), AtariOffset(params)));
FN_GLLISTPARAMETERIVSGIX(list, pname, params);
}

void OSMesaDriver::nfglLoadIdentity(void)
{
	D(bug("nfosmesa: glLoadIdentity()"));
	fn.glLoadIdentity();
}

void OSMesaDriver::nfglLoadIdentityDeformationMapSGIX(GLbitfield mask)
{
	D(bug("nfosmesa: glLoadIdentityDeformationMapSGIX(0x%x)", mask));
	fn.glLoadIdentityDeformationMapSGIX(mask);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglLoadMatrixd(memptr m)
#else
void OSMesaDriver::nfglLoadMatrixd(const GLdouble *m)
#endif
{
	D(bug("nfosmesa: glLoadMatrixd(" PRI_PTR ")", AtariOffset(m)));
FN_GLLOADMATRIXD(m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglLoadMatrixf(memptr m)
#else
void OSMesaDriver::nfglLoadMatrixf(const GLfloat *m)
#endif
{
	D(bug("nfosmesa: glLoadMatrixf(" PRI_PTR ")", AtariOffset(m)));
FN_GLLOADMATRIXF(m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglLoadMatrixxOES(memptr m)
#else
void OSMesaDriver::nfglLoadMatrixxOES(const GLfixed *m)
#endif
{
	D(bug("nfosmesa: glLoadMatrixxOES(" PRI_PTR ")", AtariOffset(m)));
FN_GLLOADMATRIXXOES(m);
}

void OSMesaDriver::nfglLoadName(GLuint name)
{
	D(bug("nfosmesa: glLoadName(%u)", name));
	fn.glLoadName(name);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglLoadProgramNV(GLenum target, GLuint id, GLsizei len, memptr program)
#else
void OSMesaDriver::nfglLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte *program)
#endif
{
	D(bug("nfosmesa: glLoadProgramNV(%s, %u, %d, " PRI_PTR ")", gl_enum_name(target), id, len, AtariOffset(program)));
FN_GLLOADPROGRAMNV(target, id, len, program);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglLoadTransposeMatrixd(memptr m)
#else
void OSMesaDriver::nfglLoadTransposeMatrixd(const GLdouble *m)
#endif
{
	D(bug("nfosmesa: glLoadTransposeMatrixd(" PRI_PTR ")", AtariOffset(m)));
FN_GLLOADTRANSPOSEMATRIXD(m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglLoadTransposeMatrixdARB(memptr m)
#else
void OSMesaDriver::nfglLoadTransposeMatrixdARB(const GLdouble *m)
#endif
{
	D(bug("nfosmesa: glLoadTransposeMatrixdARB(" PRI_PTR ")", AtariOffset(m)));
#if NFOSMESA_NEED_DOUBLE_CONV
	GLint const __m_size = MAX(16, 0);
	GLdouble __m_tmp[__m_size];
	GLdouble *__m_ptmp = Atari2HostDoubleArray(__m_size, m, __m_tmp);
	fn.glLoadTransposeMatrixdARB(__m_ptmp);
#else
	fn.glLoadTransposeMatrixdARB(HostAddr(m, const GLdouble *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglLoadTransposeMatrixf(memptr m)
#else
void OSMesaDriver::nfglLoadTransposeMatrixf(const GLfloat *m)
#endif
{
	D(bug("nfosmesa: glLoadTransposeMatrixf(" PRI_PTR ")", AtariOffset(m)));
FN_GLLOADTRANSPOSEMATRIXF(m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglLoadTransposeMatrixfARB(memptr m)
#else
void OSMesaDriver::nfglLoadTransposeMatrixfARB(const GLfloat *m)
#endif
{
	D(bug("nfosmesa: glLoadTransposeMatrixfARB(" PRI_PTR ")", AtariOffset(m)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __m_size = MAX(16, 0);
	GLfloat __m_tmp[__m_size];
	GLfloat *__m_ptmp = Atari2HostFloatArray(__m_size, m, __m_tmp);
	fn.glLoadTransposeMatrixfARB(__m_ptmp);
#else
	fn.glLoadTransposeMatrixfARB(HostAddr(m, const GLfloat *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglLoadTransposeMatrixxOES(memptr m)
#else
void OSMesaDriver::nfglLoadTransposeMatrixxOES(const GLfixed *m)
#endif
{
	D(bug("nfosmesa: glLoadTransposeMatrixxOES(" PRI_PTR ")", AtariOffset(m)));
FN_GLLOADTRANSPOSEMATRIXXOES(m);
}

void OSMesaDriver::nfglLockArraysEXT(GLint first, GLsizei count)
{
	D(bug("nfosmesa: glLockArraysEXT(%d, %d)", first, count));
FN_GLLOCKARRAYSEXT(first, count);
}

void OSMesaDriver::nfglLogicOp(GLenum opcode)
{
	D(bug("nfosmesa: glLogicOp(%s)", gl_enum_name(opcode)));
	fn.glLogicOp(opcode);
}

void OSMesaDriver::nfglMakeBufferNonResidentNV(GLenum target)
{
	D(bug("nfosmesa: glMakeBufferNonResidentNV(%s)", gl_enum_name(target)));
	fn.glMakeBufferNonResidentNV(target);
}

void OSMesaDriver::nfglMakeBufferResidentNV(GLenum target, GLenum access)
{
	D(bug("nfosmesa: glMakeBufferResidentNV(%s, %s)", gl_enum_name(target), gl_enum_name(access)));
	fn.glMakeBufferResidentNV(target, access);
}

void OSMesaDriver::nfglMakeImageHandleNonResidentARB(GLuint64 handle)
{
	D(bug("nfosmesa: glMakeImageHandleNonResidentARB(%" PRIu64 ")", handle));
	fn.glMakeImageHandleNonResidentARB(handle);
}

void OSMesaDriver::nfglMakeImageHandleNonResidentNV(GLuint64 handle)
{
	D(bug("nfosmesa: glMakeImageHandleNonResidentNV(%" PRIu64 ")", handle));
	fn.glMakeImageHandleNonResidentNV(handle);
}

void OSMesaDriver::nfglMakeImageHandleResidentARB(GLuint64 handle, GLenum access)
{
	D(bug("nfosmesa: glMakeImageHandleResidentARB(%" PRIu64 ", %s)", handle, gl_enum_name(access)));
	fn.glMakeImageHandleResidentARB(handle, access);
}

void OSMesaDriver::nfglMakeImageHandleResidentNV(GLuint64 handle, GLenum access)
{
	D(bug("nfosmesa: glMakeImageHandleResidentNV(%" PRIu64 ", %s)", handle, gl_enum_name(access)));
	fn.glMakeImageHandleResidentNV(handle, access);
}

void OSMesaDriver::nfglMakeNamedBufferNonResidentNV(GLuint buffer)
{
	D(bug("nfosmesa: glMakeNamedBufferNonResidentNV(%u)", buffer));
	fn.glMakeNamedBufferNonResidentNV(buffer);
}

void OSMesaDriver::nfglMakeNamedBufferResidentNV(GLuint buffer, GLenum access)
{
	D(bug("nfosmesa: glMakeNamedBufferResidentNV(%u, %s)", buffer, gl_enum_name(access)));
	fn.glMakeNamedBufferResidentNV(buffer, access);
}

void OSMesaDriver::nfglMakeTextureHandleNonResidentARB(GLuint64 handle)
{
	D(bug("nfosmesa: glMakeTextureHandleNonResidentARB(%" PRIu64 ")", handle));
	fn.glMakeTextureHandleNonResidentARB(handle);
}

void OSMesaDriver::nfglMakeTextureHandleNonResidentNV(GLuint64 handle)
{
	D(bug("nfosmesa: glMakeTextureHandleNonResidentNV(%" PRIu64 ")", handle));
	fn.glMakeTextureHandleNonResidentNV(handle);
}

void OSMesaDriver::nfglMakeTextureHandleResidentARB(GLuint64 handle)
{
	D(bug("nfosmesa: glMakeTextureHandleResidentARB(%" PRIu64 ")", handle));
	fn.glMakeTextureHandleResidentARB(handle);
}

void OSMesaDriver::nfglMakeTextureHandleResidentNV(GLuint64 handle)
{
	D(bug("nfosmesa: glMakeTextureHandleResidentNV(%" PRIu64 ")", handle));
	fn.glMakeTextureHandleResidentNV(handle);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, memptr points)
#else
void OSMesaDriver::nfglMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
#endif
{
	D(bug("nfosmesa: glMap1d(%s, %f, %f, %d, %d, " PRI_PTR ")", gl_enum_name(target), u1, u2, stride, order, AtariOffset(points)));
FN_GLMAP1D(target, u1, u2, stride, order, points);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, memptr points)
#else
void OSMesaDriver::nfglMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
#endif
{
	D(bug("nfosmesa: glMap1f(%s, %f, %f, %d, %d, " PRI_PTR ")", gl_enum_name(target), u1, u2, stride, order, AtariOffset(points)));
FN_GLMAP1F(target, u1, u2, stride, order, points);
}

void OSMesaDriver::nfglMap1xOES(GLenum target, GLfixed u1, GLfixed u2, GLint stride, GLint order, GLfixed points)
{
	D(bug("nfosmesa: glMap1xOES(%s, 0x%x, 0x%x, %d, %d, 0x%x)", gl_enum_name(target), u1, u2, stride, order, points));
	fn.glMap1xOES(target, u1, u2, stride, order, points);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, memptr points)
#else
void OSMesaDriver::nfglMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
#endif
{
	D(bug("nfosmesa: glMap2d(%s, %f, %f, %d, %d, %f, %f, %d, %d, " PRI_PTR ")", gl_enum_name(target), u1, u2, ustride, uorder, v1, v2, vstride, vorder, AtariOffset(points)));
FN_GLMAP2D(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, memptr points)
#else
void OSMesaDriver::nfglMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
#endif
{
	D(bug("nfosmesa: glMap2f(%s, %f, %f, %d, %d, %f, %f, %d, %d, " PRI_PTR ")", gl_enum_name(target), u1, u2, ustride, uorder, v1, v2, vstride, vorder, AtariOffset(points)));
FN_GLMAP2F(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
}

void OSMesaDriver::nfglMap2xOES(GLenum target, GLfixed u1, GLfixed u2, GLint ustride, GLint uorder, GLfixed v1, GLfixed v2, GLint vstride, GLint vorder, GLfixed points)
{
	D(bug("nfosmesa: glMap2xOES(%s, 0x%x, 0x%x, %d, %d, 0x%x, 0x%x, %d, %d, 0x%x)", gl_enum_name(target), u1, u2, ustride, uorder, v1, v2, vstride, vorder, points));
	fn.glMap2xOES(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
}

#if 0
void * OSMesaDriver::nfglMapBuffer(GLenum target, GLenum access)
{
	D(bug("nfosmesa: glMapBuffer(%s, %s)", gl_enum_name(target), gl_enum_name(access)));
FN_GLMAPBUFFER(target, access);
}
#endif

#if 0
void * OSMesaDriver::nfglMapBufferARB(GLenum target, GLenum access)
{
	D(bug("nfosmesa: glMapBufferARB(%s, %s)", gl_enum_name(target), gl_enum_name(access)));
FN_GLMAPBUFFERARB(target, access);
}
#endif

#if 0
void * OSMesaDriver::nfglMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
{
	D(bug("nfosmesa: glMapBufferRange(%s, %" PRI_IPTR ", %" PRI_IPTR ", 0x%x)", gl_enum_name(target), offset, length, access));
FN_GLMAPBUFFERRANGE(target, offset, length, access);
}
#endif

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean32 packed, memptr points)
#else
void OSMesaDriver::nfglMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean32 packed, const void *points)
#endif
{
	D(bug("nfosmesa: glMapControlPointsNV(%s, %u, %s, %d, %d, %d, %d, %d, " PRI_PTR ")", gl_enum_name(target), index, gl_enum_name(type), ustride, vstride, uorder, vorder, packed, AtariOffset(points)));
FN_GLMAPCONTROLPOINTSNV(target, index, type, ustride, vstride, uorder, vorder, packed, points);
}

void OSMesaDriver::nfglMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
{
	D(bug("nfosmesa: glMapGrid1d(%d, %f, %f)", un, u1, u2));
	fn.glMapGrid1d(un, u1, u2);
}

void OSMesaDriver::nfglMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
{
	D(bug("nfosmesa: glMapGrid1f(%d, %f, %f)", un, u1, u2));
	fn.glMapGrid1f(un, u1, u2);
}

void OSMesaDriver::nfglMapGrid1xOES(GLint n, GLfixed u1, GLfixed u2)
{
	D(bug("nfosmesa: glMapGrid1xOES(%d, 0x%x, 0x%x)", n, u1, u2));
	fn.glMapGrid1xOES(n, u1, u2);
}

void OSMesaDriver::nfglMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
{
	D(bug("nfosmesa: glMapGrid2d(%d, %f, %f, %d, %f, %f)", un, u1, u2, vn, v1, v2));
	fn.glMapGrid2d(un, u1, u2, vn, v1, v2);
}

void OSMesaDriver::nfglMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
{
	D(bug("nfosmesa: glMapGrid2f(%d, %f, %f, %d, %f, %f)", un, u1, u2, vn, v1, v2));
	fn.glMapGrid2f(un, u1, u2, vn, v1, v2);
}

void OSMesaDriver::nfglMapGrid2xOES(GLint n, GLfixed u1, GLfixed u2, GLfixed v1, GLfixed v2)
{
	D(bug("nfosmesa: glMapGrid2xOES(%d, 0x%x, 0x%x, 0x%x, 0x%x)", n, u1, u2, v1, v2));
	fn.glMapGrid2xOES(n, u1, u2, v1, v2);
}

#if 0
void * OSMesaDriver::nfglMapNamedBuffer(GLuint buffer, GLenum access)
{
	D(bug("nfosmesa: glMapNamedBuffer(%u, %s)", buffer, gl_enum_name(access)));
FN_GLMAPNAMEDBUFFER(buffer, access);
}
#endif

#if 0
void * OSMesaDriver::nfglMapNamedBufferEXT(GLuint buffer, GLenum access)
{
	D(bug("nfosmesa: glMapNamedBufferEXT(%u, %s)", buffer, gl_enum_name(access)));
	void * __ret = fn.glMapNamedBufferEXT(buffer, access);
	return __ret;
}
#endif

#if 0
void * OSMesaDriver::nfglMapNamedBufferRange(GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access)
{
	D(bug("nfosmesa: glMapNamedBufferRange(%u, %" PRI_IPTR ", %" PRI_IPTR ", 0x%x)", buffer, offset, length, access));
FN_GLMAPNAMEDBUFFERRANGE(buffer, offset, length, access);
}
#endif

#if 0
void * OSMesaDriver::nfglMapNamedBufferRangeEXT(GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access)
{
	D(bug("nfosmesa: glMapNamedBufferRangeEXT(%u, %" PRI_IPTR ", %" PRI_IPTR ", 0x%x)", buffer, offset, length, access));
	void * __ret = fn.glMapNamedBufferRangeEXT(buffer, offset, length, access);
	return __ret;
}
#endif

#if 0
void * OSMesaDriver::nfglMapObjectBufferATI(GLuint buffer)
{
	D(bug("nfosmesa: glMapObjectBufferATI(%u)", buffer));
	void * __ret = fn.glMapObjectBufferATI(buffer);
	return __ret;
}
#endif

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMapParameterfvNV(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglMapParameterfvNV(GLenum target, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glMapParameterfvNV(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLMAPPARAMETERFVNV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMapParameterivNV(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglMapParameterivNV(GLenum target, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glMapParameterivNV(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLMAPPARAMETERIVNV(target, pname, params);
}

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
void * OSMesaDriver::nfglMapTexture2DINTEL(GLuint texture, GLint level, GLbitfield access, memptr stride, memptr layout)
#else
void * OSMesaDriver::nfglMapTexture2DINTEL(GLuint texture, GLint level, GLbitfield access, const GLint *stride, const GLenum *layout)
#endif
{
	D(bug("nfosmesa: glMapTexture2DINTEL(%u, %d, 0x%x, " PRI_PTR ", " PRI_PTR ")", texture, level, access, AtariOffset(stride), AtariOffset(layout)));
	void * __ret = fn.glMapTexture2DINTEL(texture, level, access, stride, layout);
	return __ret;
}
#endif

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMapVertexAttrib1dAPPLE(GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint stride, GLint order, memptr points)
#else
void OSMesaDriver::nfglMapVertexAttrib1dAPPLE(GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
#endif
{
	D(bug("nfosmesa: glMapVertexAttrib1dAPPLE(%u, %u, %f, %f, %d, %d, " PRI_PTR ")", index, size, u1, u2, stride, order, AtariOffset(points)));
FN_GLMAPVERTEXATTRIB1DAPPLE(index, size, u1, u2, stride, order, points);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMapVertexAttrib1fAPPLE(GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint stride, GLint order, memptr points)
#else
void OSMesaDriver::nfglMapVertexAttrib1fAPPLE(GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
#endif
{
	D(bug("nfosmesa: glMapVertexAttrib1fAPPLE(%u, %u, %f, %f, %d, %d, " PRI_PTR ")", index, size, u1, u2, stride, order, AtariOffset(points)));
FN_GLMAPVERTEXATTRIB1FAPPLE(index, size, u1, u2, stride, order, points);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMapVertexAttrib2dAPPLE(GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, memptr points)
#else
void OSMesaDriver::nfglMapVertexAttrib2dAPPLE(GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
#endif
{
	D(bug("nfosmesa: glMapVertexAttrib2dAPPLE(%u, %u, %f, %f, %d, %d, %f, %f, %d, %d, " PRI_PTR ")", index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, AtariOffset(points)));
FN_GLMAPVERTEXATTRIB2DAPPLE(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMapVertexAttrib2fAPPLE(GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, memptr points)
#else
void OSMesaDriver::nfglMapVertexAttrib2fAPPLE(GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
#endif
{
	D(bug("nfosmesa: glMapVertexAttrib2fAPPLE(%u, %u, %f, %f, %d, %d, %f, %f, %d, %d, " PRI_PTR ")", index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, AtariOffset(points)));
FN_GLMAPVERTEXATTRIB2FAPPLE(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
}

void OSMesaDriver::nfglMaterialf(GLenum face, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glMaterialf(%s, %s, %f)", gl_enum_name(face), gl_enum_name(pname), param));
	fn.glMaterialf(face, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMaterialfv(GLenum face, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glMaterialfv(%s, %s, " PRI_PTR ")", gl_enum_name(face), gl_enum_name(pname), AtariOffset(params)));
FN_GLMATERIALFV(face, pname, params);
}

void OSMesaDriver::nfglMateriali(GLenum face, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glMateriali(%s, %s, %d)", gl_enum_name(face), gl_enum_name(pname), param));
	fn.glMateriali(face, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMaterialiv(GLenum face, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglMaterialiv(GLenum face, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glMaterialiv(%s, %s, " PRI_PTR ")", gl_enum_name(face), gl_enum_name(pname), AtariOffset(params)));
FN_GLMATERIALIV(face, pname, params);
}

void OSMesaDriver::nfglMaterialxOES(GLenum face, GLenum pname, GLfixed param)
{
	D(bug("nfosmesa: glMaterialxOES(%s, %s, 0x%x)", gl_enum_name(face), gl_enum_name(pname), param));
	fn.glMaterialxOES(face, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMaterialxvOES(GLenum face, GLenum pname, memptr param)
#else
void OSMesaDriver::nfglMaterialxvOES(GLenum face, GLenum pname, const GLfixed *param)
#endif
{
	D(bug("nfosmesa: glMaterialxvOES(%s, %s, " PRI_PTR ")", gl_enum_name(face), gl_enum_name(pname), AtariOffset(param)));
FN_GLMATERIALXVOES(face, pname, param);
}

void OSMesaDriver::nfglMatrixFrustumEXT(GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
	D(bug("nfosmesa: glMatrixFrustumEXT(%s, %f, %f, %f, %f, %f, %f)", gl_enum_name(mode), left, right, bottom, top, zNear, zFar));
	fn.glMatrixFrustumEXT(mode, left, right, bottom, top, zNear, zFar);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMatrixIndexPointerARB(GLint size, GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglMatrixIndexPointerARB(GLint size, GLenum type, GLsizei stride, const void *pointer)
#endif
{
	D(bug("nfosmesa: glMatrixIndexPointerARB(%d, %s, %d, " PRI_PTR ")", size, gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLMATRIXINDEXPOINTERARB(size, type, stride, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMatrixIndexubvARB(GLint size, memptr indices)
#else
void OSMesaDriver::nfglMatrixIndexubvARB(GLint size, const GLubyte *indices)
#endif
{
	D(bug("nfosmesa: glMatrixIndexubvARB(%d, " PRI_PTR ")", size, AtariOffset(indices)));
FN_GLMATRIXINDEXUBVARB(size, indices);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMatrixIndexuivARB(GLint size, memptr indices)
#else
void OSMesaDriver::nfglMatrixIndexuivARB(GLint size, const GLuint *indices)
#endif
{
	D(bug("nfosmesa: glMatrixIndexuivARB(%d, " PRI_PTR ")", size, AtariOffset(indices)));
FN_GLMATRIXINDEXUIVARB(size, indices);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMatrixIndexusvARB(GLint size, memptr indices)
#else
void OSMesaDriver::nfglMatrixIndexusvARB(GLint size, const GLushort *indices)
#endif
{
	D(bug("nfosmesa: glMatrixIndexusvARB(%d, " PRI_PTR ")", size, AtariOffset(indices)));
FN_GLMATRIXINDEXUSVARB(size, indices);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMatrixLoad3x2fNV(GLenum matrixMode, memptr m)
#else
void OSMesaDriver::nfglMatrixLoad3x2fNV(GLenum matrixMode, const GLfloat *m)
#endif
{
	D(bug("nfosmesa: glMatrixLoad3x2fNV(%s, " PRI_PTR ")", gl_enum_name(matrixMode), AtariOffset(m)));
FN_GLMATRIXLOAD3X2FNV(matrixMode, m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMatrixLoad3x3fNV(GLenum matrixMode, memptr m)
#else
void OSMesaDriver::nfglMatrixLoad3x3fNV(GLenum matrixMode, const GLfloat *m)
#endif
{
	D(bug("nfosmesa: glMatrixLoad3x3fNV(%s, " PRI_PTR ")", gl_enum_name(matrixMode), AtariOffset(m)));
FN_GLMATRIXLOAD3X3FNV(matrixMode, m);
}

void OSMesaDriver::nfglMatrixLoadIdentityEXT(GLenum mode)
{
	D(bug("nfosmesa: glMatrixLoadIdentityEXT(%s)", gl_enum_name(mode)));
	fn.glMatrixLoadIdentityEXT(mode);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMatrixLoadTranspose3x3fNV(GLenum matrixMode, memptr m)
#else
void OSMesaDriver::nfglMatrixLoadTranspose3x3fNV(GLenum matrixMode, const GLfloat *m)
#endif
{
	D(bug("nfosmesa: glMatrixLoadTranspose3x3fNV(%s, " PRI_PTR ")", gl_enum_name(matrixMode), AtariOffset(m)));
FN_GLMATRIXLOADTRANSPOSE3X3FNV(matrixMode, m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMatrixLoadTransposedEXT(GLenum mode, memptr m)
#else
void OSMesaDriver::nfglMatrixLoadTransposedEXT(GLenum mode, const GLdouble *m)
#endif
{
	D(bug("nfosmesa: glMatrixLoadTransposedEXT(%s, " PRI_PTR ")", gl_enum_name(mode), AtariOffset(m)));
FN_GLMATRIXLOADTRANSPOSEDEXT(mode, m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMatrixLoadTransposefEXT(GLenum mode, memptr m)
#else
void OSMesaDriver::nfglMatrixLoadTransposefEXT(GLenum mode, const GLfloat *m)
#endif
{
	D(bug("nfosmesa: glMatrixLoadTransposefEXT(%s, " PRI_PTR ")", gl_enum_name(mode), AtariOffset(m)));
FN_GLMATRIXLOADTRANSPOSEFEXT(mode, m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMatrixLoaddEXT(GLenum mode, memptr m)
#else
void OSMesaDriver::nfglMatrixLoaddEXT(GLenum mode, const GLdouble *m)
#endif
{
	D(bug("nfosmesa: glMatrixLoaddEXT(%s, " PRI_PTR ")", gl_enum_name(mode), AtariOffset(m)));
FN_GLMATRIXLOADDEXT(mode, m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMatrixLoadfEXT(GLenum mode, memptr m)
#else
void OSMesaDriver::nfglMatrixLoadfEXT(GLenum mode, const GLfloat *m)
#endif
{
	D(bug("nfosmesa: glMatrixLoadfEXT(%s, " PRI_PTR ")", gl_enum_name(mode), AtariOffset(m)));
FN_GLMATRIXLOADFEXT(mode, m);
}

void OSMesaDriver::nfglMatrixMode(GLenum mode)
{
	D(bug("nfosmesa: glMatrixMode(%s)", gl_enum_name(mode)));
	fn.glMatrixMode(mode);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMatrixMult3x2fNV(GLenum matrixMode, memptr m)
#else
void OSMesaDriver::nfglMatrixMult3x2fNV(GLenum matrixMode, const GLfloat *m)
#endif
{
	D(bug("nfosmesa: glMatrixMult3x2fNV(%s, " PRI_PTR ")", gl_enum_name(matrixMode), AtariOffset(m)));
FN_GLMATRIXMULT3X2FNV(matrixMode, m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMatrixMult3x3fNV(GLenum matrixMode, memptr m)
#else
void OSMesaDriver::nfglMatrixMult3x3fNV(GLenum matrixMode, const GLfloat *m)
#endif
{
	D(bug("nfosmesa: glMatrixMult3x3fNV(%s, " PRI_PTR ")", gl_enum_name(matrixMode), AtariOffset(m)));
FN_GLMATRIXMULT3X3FNV(matrixMode, m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMatrixMultTranspose3x3fNV(GLenum matrixMode, memptr m)
#else
void OSMesaDriver::nfglMatrixMultTranspose3x3fNV(GLenum matrixMode, const GLfloat *m)
#endif
{
	D(bug("nfosmesa: glMatrixMultTranspose3x3fNV(%s, " PRI_PTR ")", gl_enum_name(matrixMode), AtariOffset(m)));
FN_GLMATRIXMULTTRANSPOSE3X3FNV(matrixMode, m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMatrixMultTransposedEXT(GLenum mode, memptr m)
#else
void OSMesaDriver::nfglMatrixMultTransposedEXT(GLenum mode, const GLdouble *m)
#endif
{
	D(bug("nfosmesa: glMatrixMultTransposedEXT(%s, " PRI_PTR ")", gl_enum_name(mode), AtariOffset(m)));
FN_GLMATRIXMULTTRANSPOSEDEXT(mode, m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMatrixMultTransposefEXT(GLenum mode, memptr m)
#else
void OSMesaDriver::nfglMatrixMultTransposefEXT(GLenum mode, const GLfloat *m)
#endif
{
	D(bug("nfosmesa: glMatrixMultTransposefEXT(%s, " PRI_PTR ")", gl_enum_name(mode), AtariOffset(m)));
FN_GLMATRIXMULTTRANSPOSEFEXT(mode, m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMatrixMultdEXT(GLenum mode, memptr m)
#else
void OSMesaDriver::nfglMatrixMultdEXT(GLenum mode, const GLdouble *m)
#endif
{
	D(bug("nfosmesa: glMatrixMultdEXT(%s, " PRI_PTR ")", gl_enum_name(mode), AtariOffset(m)));
FN_GLMATRIXMULTDEXT(mode, m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMatrixMultfEXT(GLenum mode, memptr m)
#else
void OSMesaDriver::nfglMatrixMultfEXT(GLenum mode, const GLfloat *m)
#endif
{
	D(bug("nfosmesa: glMatrixMultfEXT(%s, " PRI_PTR ")", gl_enum_name(mode), AtariOffset(m)));
FN_GLMATRIXMULTFEXT(mode, m);
}

void OSMesaDriver::nfglMatrixOrthoEXT(GLenum mode, GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
	D(bug("nfosmesa: glMatrixOrthoEXT(%s, %f, %f, %f, %f, %f, %f)", gl_enum_name(mode), left, right, bottom, top, zNear, zFar));
	fn.glMatrixOrthoEXT(mode, left, right, bottom, top, zNear, zFar);
}

void OSMesaDriver::nfglMatrixPopEXT(GLenum mode)
{
	D(bug("nfosmesa: glMatrixPopEXT(%s)", gl_enum_name(mode)));
	fn.glMatrixPopEXT(mode);
}

void OSMesaDriver::nfglMatrixPushEXT(GLenum mode)
{
	D(bug("nfosmesa: glMatrixPushEXT(%s)", gl_enum_name(mode)));
	fn.glMatrixPushEXT(mode);
}

void OSMesaDriver::nfglMatrixRotatedEXT(GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glMatrixRotatedEXT(%s, %f, %f, %f, %f)", gl_enum_name(mode), angle, x, y, z));
	fn.glMatrixRotatedEXT(mode, angle, x, y, z);
}

void OSMesaDriver::nfglMatrixRotatefEXT(GLenum mode, GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glMatrixRotatefEXT(%s, %f, %f, %f, %f)", gl_enum_name(mode), angle, x, y, z));
	fn.glMatrixRotatefEXT(mode, angle, x, y, z);
}

void OSMesaDriver::nfglMatrixScaledEXT(GLenum mode, GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glMatrixScaledEXT(%s, %f, %f, %f)", gl_enum_name(mode), x, y, z));
	fn.glMatrixScaledEXT(mode, x, y, z);
}

void OSMesaDriver::nfglMatrixScalefEXT(GLenum mode, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glMatrixScalefEXT(%s, %f, %f, %f)", gl_enum_name(mode), x, y, z));
	fn.glMatrixScalefEXT(mode, x, y, z);
}

void OSMesaDriver::nfglMatrixTranslatedEXT(GLenum mode, GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glMatrixTranslatedEXT(%s, %f, %f, %f)", gl_enum_name(mode), x, y, z));
	fn.glMatrixTranslatedEXT(mode, x, y, z);
}

void OSMesaDriver::nfglMatrixTranslatefEXT(GLenum mode, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glMatrixTranslatefEXT(%s, %f, %f, %f)", gl_enum_name(mode), x, y, z));
	fn.glMatrixTranslatefEXT(mode, x, y, z);
}

void OSMesaDriver::nfglMaxShaderCompilerThreadsARB(GLuint count)
{
	D(bug("nfosmesa: glMaxShaderCompilerThreadsARB(%u)", count));
	fn.glMaxShaderCompilerThreadsARB(count);
}

void OSMesaDriver::nfglMaxShaderCompilerThreadsKHR(GLuint count)
{
	D(bug("nfosmesa: glMaxShaderCompilerThreadsKHR(%u)", count));
	fn.glMaxShaderCompilerThreadsKHR(count);
}

void OSMesaDriver::nfglMemoryBarrier(GLbitfield barriers)
{
	D(bug("nfosmesa: glMemoryBarrier(0x%x)", barriers));
	fn.glMemoryBarrier(barriers);
}

void OSMesaDriver::nfglMemoryBarrierByRegion(GLbitfield barriers)
{
	D(bug("nfosmesa: glMemoryBarrierByRegion(0x%x)", barriers));
	fn.glMemoryBarrierByRegion(barriers);
}

void OSMesaDriver::nfglMemoryBarrierEXT(GLbitfield barriers)
{
	D(bug("nfosmesa: glMemoryBarrierEXT(0x%x)", barriers));
	fn.glMemoryBarrierEXT(barriers);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMemoryObjectParameterivEXT(GLuint memoryObject, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglMemoryObjectParameterivEXT(GLuint memoryObject, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glMemoryObjectParameterivEXT(%u, %s, " PRI_PTR ")", memoryObject, gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLint __params_tmp[__params_size];
	GLint *__params_ptmp = Atari2HostIntArray(__params_size, params, __params_tmp);
	fn.glMemoryObjectParameterivEXT(memoryObject, pname, __params_ptmp);
#else
	fn.glMemoryObjectParameterivEXT(memoryObject, pname, HostAddr(params, const GLint *));
#endif
}

void OSMesaDriver::nfglMinSampleShading(GLfloat value)
{
	D(bug("nfosmesa: glMinSampleShading(%f)", value));
	fn.glMinSampleShading(value);
}

void OSMesaDriver::nfglMinSampleShadingARB(GLfloat value)
{
	D(bug("nfosmesa: glMinSampleShadingARB(%f)", value));
	fn.glMinSampleShadingARB(value);
}

void OSMesaDriver::nfglMinmax(GLenum target, GLenum internalformat, GLboolean32 sink)
{
	D(bug("nfosmesa: glMinmax(%s, %s, %d)", gl_enum_name(target), gl_enum_name(internalformat), sink));
	fn.glMinmax(target, internalformat, sink);
}

void OSMesaDriver::nfglMinmaxEXT(GLenum target, GLenum internalformat, GLboolean32 sink)
{
	D(bug("nfosmesa: glMinmaxEXT(%s, %s, %d)", gl_enum_name(target), gl_enum_name(internalformat), sink));
	fn.glMinmaxEXT(target, internalformat, sink);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultMatrixd(memptr m)
#else
void OSMesaDriver::nfglMultMatrixd(const GLdouble *m)
#endif
{
	D(bug("nfosmesa: glMultMatrixd(" PRI_PTR ")", AtariOffset(m)));
FN_GLMULTMATRIXD(m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultMatrixf(memptr m)
#else
void OSMesaDriver::nfglMultMatrixf(const GLfloat *m)
#endif
{
	D(bug("nfosmesa: glMultMatrixf(" PRI_PTR ")", AtariOffset(m)));
FN_GLMULTMATRIXF(m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultMatrixxOES(memptr m)
#else
void OSMesaDriver::nfglMultMatrixxOES(const GLfixed *m)
#endif
{
	D(bug("nfosmesa: glMultMatrixxOES(" PRI_PTR ")", AtariOffset(m)));
FN_GLMULTMATRIXXOES(m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultTransposeMatrixd(memptr m)
#else
void OSMesaDriver::nfglMultTransposeMatrixd(const GLdouble *m)
#endif
{
	D(bug("nfosmesa: glMultTransposeMatrixd(" PRI_PTR ")", AtariOffset(m)));
FN_GLMULTTRANSPOSEMATRIXD(m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultTransposeMatrixdARB(memptr m)
#else
void OSMesaDriver::nfglMultTransposeMatrixdARB(const GLdouble *m)
#endif
{
	D(bug("nfosmesa: glMultTransposeMatrixdARB(" PRI_PTR ")", AtariOffset(m)));
#if NFOSMESA_NEED_DOUBLE_CONV
	GLint const __m_size = MAX(16, 0);
	GLdouble __m_tmp[__m_size];
	GLdouble *__m_ptmp = Atari2HostDoubleArray(__m_size, m, __m_tmp);
	fn.glMultTransposeMatrixdARB(__m_ptmp);
#else
	fn.glMultTransposeMatrixdARB(HostAddr(m, const GLdouble *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultTransposeMatrixf(memptr m)
#else
void OSMesaDriver::nfglMultTransposeMatrixf(const GLfloat *m)
#endif
{
	D(bug("nfosmesa: glMultTransposeMatrixf(" PRI_PTR ")", AtariOffset(m)));
FN_GLMULTTRANSPOSEMATRIXF(m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultTransposeMatrixfARB(memptr m)
#else
void OSMesaDriver::nfglMultTransposeMatrixfARB(const GLfloat *m)
#endif
{
	D(bug("nfosmesa: glMultTransposeMatrixfARB(" PRI_PTR ")", AtariOffset(m)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __m_size = MAX(16, 0);
	GLfloat __m_tmp[__m_size];
	GLfloat *__m_ptmp = Atari2HostFloatArray(__m_size, m, __m_tmp);
	fn.glMultTransposeMatrixfARB(__m_ptmp);
#else
	fn.glMultTransposeMatrixfARB(HostAddr(m, const GLfloat *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultTransposeMatrixxOES(memptr m)
#else
void OSMesaDriver::nfglMultTransposeMatrixxOES(const GLfixed *m)
#endif
{
	D(bug("nfosmesa: glMultTransposeMatrixxOES(" PRI_PTR ")", AtariOffset(m)));
FN_GLMULTTRANSPOSEMATRIXXOES(m);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiDrawArrays(GLenum mode, memptr first, memptr count, GLsizei drawcount)
#else
void OSMesaDriver::nfglMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
#endif
{
	D(bug("nfosmesa: glMultiDrawArrays(%s, " PRI_PTR ", " PRI_PTR ", %d)", gl_enum_name(mode), AtariOffset(first), AtariOffset(count), drawcount));
FN_GLMULTIDRAWARRAYS(mode, first, count, drawcount);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiDrawArraysEXT(GLenum mode, memptr first, memptr count, GLsizei primcount)
#else
void OSMesaDriver::nfglMultiDrawArraysEXT(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount)
#endif
{
	D(bug("nfosmesa: glMultiDrawArraysEXT(%s, " PRI_PTR ", " PRI_PTR ", %d)", gl_enum_name(mode), AtariOffset(first), AtariOffset(count), primcount));
FN_GLMULTIDRAWARRAYSEXT(mode, first, count, primcount);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiDrawArraysIndirect(GLenum mode, memptr indirect, GLsizei drawcount, GLsizei stride)
#else
void OSMesaDriver::nfglMultiDrawArraysIndirect(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride)
#endif
{
	D(bug("nfosmesa: glMultiDrawArraysIndirect(%s, " PRI_PTR ", %d, %d)", gl_enum_name(mode), AtariOffset(indirect), drawcount, stride));
FN_GLMULTIDRAWARRAYSINDIRECT(mode, indirect, drawcount, stride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiDrawArraysIndirectAMD(GLenum mode, memptr indirect, GLsizei primcount, GLsizei stride)
#else
void OSMesaDriver::nfglMultiDrawArraysIndirectAMD(GLenum mode, const void *indirect, GLsizei primcount, GLsizei stride)
#endif
{
	D(bug("nfosmesa: glMultiDrawArraysIndirectAMD(%s, " PRI_PTR ", %d, %d)", gl_enum_name(mode), AtariOffset(indirect), primcount, stride));
FN_GLMULTIDRAWARRAYSINDIRECTAMD(mode, indirect, primcount, stride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiDrawArraysIndirectBindlessCountNV(GLenum mode, memptr indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount)
#else
void OSMesaDriver::nfglMultiDrawArraysIndirectBindlessCountNV(GLenum mode, const void *indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount)
#endif
{
	D(bug("nfosmesa: glMultiDrawArraysIndirectBindlessCountNV(%s, " PRI_PTR ", %d, %d, %d, %d)", gl_enum_name(mode), AtariOffset(indirect), drawCount, maxDrawCount, stride, vertexBufferCount));
FN_GLMULTIDRAWARRAYSINDIRECTBINDLESSCOUNTNV(mode, indirect, drawCount, maxDrawCount, stride, vertexBufferCount);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiDrawArraysIndirectBindlessNV(GLenum mode, memptr indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount)
#else
void OSMesaDriver::nfglMultiDrawArraysIndirectBindlessNV(GLenum mode, const void *indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount)
#endif
{
	D(bug("nfosmesa: glMultiDrawArraysIndirectBindlessNV(%s, " PRI_PTR ", %d, %d, %d)", gl_enum_name(mode), AtariOffset(indirect), drawCount, stride, vertexBufferCount));
FN_GLMULTIDRAWARRAYSINDIRECTBINDLESSNV(mode, indirect, drawCount, stride, vertexBufferCount);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiDrawArraysIndirectCount(GLenum mode, memptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride)
#else
void OSMesaDriver::nfglMultiDrawArraysIndirectCount(GLenum mode, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride)
#endif
{
	D(bug("nfosmesa: glMultiDrawArraysIndirectCount(%s, " PRI_PTR ", %" PRI_IPTR ", %d, %d)", gl_enum_name(mode), AtariOffset(indirect), drawcount, maxdrawcount, stride));
FN_GLMULTIDRAWARRAYSINDIRECTCOUNT(mode, indirect, drawcount, maxdrawcount, stride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiDrawArraysIndirectCountARB(GLenum mode, memptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride)
#else
void OSMesaDriver::nfglMultiDrawArraysIndirectCountARB(GLenum mode, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride)
#endif
{
	D(bug("nfosmesa: glMultiDrawArraysIndirectCountARB(%s, " PRI_PTR ", %" PRI_IPTR ", %d, %d)", gl_enum_name(mode), AtariOffset(indirect), drawcount, maxdrawcount, stride));
FN_GLMULTIDRAWARRAYSINDIRECTCOUNTARB(mode, indirect, drawcount, maxdrawcount, stride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiDrawElementArrayAPPLE(GLenum mode, memptr first, memptr count, GLsizei primcount)
#else
void OSMesaDriver::nfglMultiDrawElementArrayAPPLE(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount)
#endif
{
	D(bug("nfosmesa: glMultiDrawElementArrayAPPLE(%s, " PRI_PTR ", " PRI_PTR ", %d)", gl_enum_name(mode), AtariOffset(first), AtariOffset(count), primcount));
FN_GLMULTIDRAWELEMENTARRAYAPPLE(mode, first, count, primcount);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiDrawElements(GLenum mode, memptr count, GLenum type, memptr indices, GLsizei drawcount)
#else
void OSMesaDriver::nfglMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount)
#endif
{
	D(bug("nfosmesa: glMultiDrawElements(%s, " PRI_PTR ", %s, " PRI_PTR ", %d)", gl_enum_name(mode), AtariOffset(count), gl_enum_name(type), AtariOffset(indices), drawcount));
FN_GLMULTIDRAWELEMENTS(mode, count, type, indices, drawcount);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiDrawElementsBaseVertex(GLenum mode, memptr count, GLenum type, memptr indices, GLsizei drawcount, memptr basevertex)
#else
void OSMesaDriver::nfglMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount, const GLint *basevertex)
#endif
{
	D(bug("nfosmesa: glMultiDrawElementsBaseVertex(%s, " PRI_PTR ", %s, " PRI_PTR ", %d, " PRI_PTR ")", gl_enum_name(mode), AtariOffset(count), gl_enum_name(type), AtariOffset(indices), drawcount, AtariOffset(basevertex)));
FN_GLMULTIDRAWELEMENTSBASEVERTEX(mode, count, type, indices, drawcount, basevertex);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiDrawElementsEXT(GLenum mode, memptr count, GLenum type, memptr indices, GLsizei primcount)
#else
void OSMesaDriver::nfglMultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei primcount)
#endif
{
	D(bug("nfosmesa: glMultiDrawElementsEXT(%s, " PRI_PTR ", %s, " PRI_PTR ", %d)", gl_enum_name(mode), AtariOffset(count), gl_enum_name(type), AtariOffset(indices), primcount));
FN_GLMULTIDRAWELEMENTSEXT(mode, count, type, indices, primcount);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiDrawElementsIndirect(GLenum mode, GLenum type, memptr indirect, GLsizei drawcount, GLsizei stride)
#else
void OSMesaDriver::nfglMultiDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride)
#endif
{
	D(bug("nfosmesa: glMultiDrawElementsIndirect(%s, %s, " PRI_PTR ", %d, %d)", gl_enum_name(mode), gl_enum_name(type), AtariOffset(indirect), drawcount, stride));
FN_GLMULTIDRAWELEMENTSINDIRECT(mode, type, indirect, drawcount, stride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiDrawElementsIndirectAMD(GLenum mode, GLenum type, memptr indirect, GLsizei primcount, GLsizei stride)
#else
void OSMesaDriver::nfglMultiDrawElementsIndirectAMD(GLenum mode, GLenum type, const void *indirect, GLsizei primcount, GLsizei stride)
#endif
{
	D(bug("nfosmesa: glMultiDrawElementsIndirectAMD(%s, %s, " PRI_PTR ", %d, %d)", gl_enum_name(mode), gl_enum_name(type), AtariOffset(indirect), primcount, stride));
FN_GLMULTIDRAWELEMENTSINDIRECTAMD(mode, type, indirect, primcount, stride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiDrawElementsIndirectBindlessCountNV(GLenum mode, GLenum type, memptr indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount)
#else
void OSMesaDriver::nfglMultiDrawElementsIndirectBindlessCountNV(GLenum mode, GLenum type, const void *indirect, GLsizei drawCount, GLsizei maxDrawCount, GLsizei stride, GLint vertexBufferCount)
#endif
{
	D(bug("nfosmesa: glMultiDrawElementsIndirectBindlessCountNV(%s, %s, " PRI_PTR ", %d, %d, %d, %d)", gl_enum_name(mode), gl_enum_name(type), AtariOffset(indirect), drawCount, maxDrawCount, stride, vertexBufferCount));
FN_GLMULTIDRAWELEMENTSINDIRECTBINDLESSCOUNTNV(mode, type, indirect, drawCount, maxDrawCount, stride, vertexBufferCount);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiDrawElementsIndirectBindlessNV(GLenum mode, GLenum type, memptr indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount)
#else
void OSMesaDriver::nfglMultiDrawElementsIndirectBindlessNV(GLenum mode, GLenum type, const void *indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount)
#endif
{
	D(bug("nfosmesa: glMultiDrawElementsIndirectBindlessNV(%s, %s, " PRI_PTR ", %d, %d, %d)", gl_enum_name(mode), gl_enum_name(type), AtariOffset(indirect), drawCount, stride, vertexBufferCount));
FN_GLMULTIDRAWELEMENTSINDIRECTBINDLESSNV(mode, type, indirect, drawCount, stride, vertexBufferCount);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiDrawElementsIndirectCount(GLenum mode, GLenum type, memptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride)
#else
void OSMesaDriver::nfglMultiDrawElementsIndirectCount(GLenum mode, GLenum type, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride)
#endif
{
	D(bug("nfosmesa: glMultiDrawElementsIndirectCount(%s, %s, " PRI_PTR ", %" PRI_IPTR ", %d, %d)", gl_enum_name(mode), gl_enum_name(type), AtariOffset(indirect), drawcount, maxdrawcount, stride));
FN_GLMULTIDRAWELEMENTSINDIRECTCOUNT(mode, type, indirect, drawcount, maxdrawcount, stride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiDrawElementsIndirectCountARB(GLenum mode, GLenum type, memptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride)
#else
void OSMesaDriver::nfglMultiDrawElementsIndirectCountARB(GLenum mode, GLenum type, const void *indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride)
#endif
{
	D(bug("nfosmesa: glMultiDrawElementsIndirectCountARB(%s, %s, " PRI_PTR ", %" PRI_IPTR ", %d, %d)", gl_enum_name(mode), gl_enum_name(type), AtariOffset(indirect), drawcount, maxdrawcount, stride));
FN_GLMULTIDRAWELEMENTSINDIRECTCOUNTARB(mode, type, indirect, drawcount, maxdrawcount, stride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiDrawRangeElementArrayAPPLE(GLenum mode, GLuint start, GLuint end, memptr first, memptr count, GLsizei primcount)
#else
void OSMesaDriver::nfglMultiDrawRangeElementArrayAPPLE(GLenum mode, GLuint start, GLuint end, const GLint *first, const GLsizei *count, GLsizei primcount)
#endif
{
	D(bug("nfosmesa: glMultiDrawRangeElementArrayAPPLE(%s, %u, %u, " PRI_PTR ", " PRI_PTR ", %d)", gl_enum_name(mode), start, end, AtariOffset(first), AtariOffset(count), primcount));
FN_GLMULTIDRAWRANGEELEMENTARRAYAPPLE(mode, start, end, first, count, primcount);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiModeDrawArraysIBM(memptr mode, memptr first, memptr count, GLsizei primcount, GLint modestride)
#else
void OSMesaDriver::nfglMultiModeDrawArraysIBM(const GLenum *mode, const GLint *first, const GLsizei *count, GLsizei primcount, GLint modestride)
#endif
{
	D(bug("nfosmesa: glMultiModeDrawArraysIBM(" PRI_PTR ", " PRI_PTR ", " PRI_PTR ", %d, %d)", AtariOffset(mode), AtariOffset(first), AtariOffset(count), primcount, modestride));
FN_GLMULTIMODEDRAWARRAYSIBM(mode, first, count, primcount, modestride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiModeDrawElementsIBM(memptr mode, memptr count, GLenum type, memptr indices, GLsizei primcount, GLint modestride)
#else
void OSMesaDriver::nfglMultiModeDrawElementsIBM(const GLenum *mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei primcount, GLint modestride)
#endif
{
	D(bug("nfosmesa: glMultiModeDrawElementsIBM(" PRI_PTR ", " PRI_PTR ", %s, " PRI_PTR ", %d, %d)", AtariOffset(mode), AtariOffset(count), gl_enum_name(type), AtariOffset(indices), primcount, modestride));
FN_GLMULTIMODEDRAWELEMENTSIBM(mode, count, type, indices, primcount, modestride);
}

void OSMesaDriver::nfglMultiTexBufferEXT(GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer)
{
	D(bug("nfosmesa: glMultiTexBufferEXT(%s, %s, %s, %u)", gl_enum_name(texunit), gl_enum_name(target), gl_enum_name(internalformat), buffer));
	fn.glMultiTexBufferEXT(texunit, target, internalformat, buffer);
}

void OSMesaDriver::nfglMultiTexCoord1bOES(GLenum texture, GLbyte32 s)
{
	D(bug("nfosmesa: glMultiTexCoord1bOES(%s, %d)", gl_enum_name(texture), s));
	fn.glMultiTexCoord1bOES(texture, s);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord1bvOES(GLenum texture, memptr coords)
#else
void OSMesaDriver::nfglMultiTexCoord1bvOES(GLenum texture, const GLbyte *coords)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord1bvOES(%s, " PRI_PTR ")", gl_enum_name(texture), AtariOffset(coords)));
FN_GLMULTITEXCOORD1BVOES(texture, coords);
}

void OSMesaDriver::nfglMultiTexCoord1d(GLenum target, GLdouble s)
{
	D(bug("nfosmesa: glMultiTexCoord1d(%s, %f)", gl_enum_name(target), s));
	fn.glMultiTexCoord1d(target, s);
}

void OSMesaDriver::nfglMultiTexCoord1dARB(GLenum target, GLdouble s)
{
	D(bug("nfosmesa: glMultiTexCoord1dARB(%s, %f)", gl_enum_name(target), s));
	fn.glMultiTexCoord1dARB(target, s);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord1dv(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord1dv(GLenum target, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord1dv(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
FN_GLMULTITEXCOORD1DV(target, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord1dvARB(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord1dvARB(GLenum target, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord1dvARB(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
#if NFOSMESA_NEED_DOUBLE_CONV
	GLint const __v_size = 1;
	GLdouble __v_tmp[__v_size];
	GLdouble *__v_ptmp = Atari2HostDoubleArray(__v_size, v, __v_tmp);
	fn.glMultiTexCoord1dvARB(target, __v_ptmp);
#else
	fn.glMultiTexCoord1dvARB(target, HostAddr(v, const GLdouble *));
#endif
}

void OSMesaDriver::nfglMultiTexCoord1f(GLenum target, GLfloat s)
{
	D(bug("nfosmesa: glMultiTexCoord1f(%s, %f)", gl_enum_name(target), s));
	fn.glMultiTexCoord1f(target, s);
}

void OSMesaDriver::nfglMultiTexCoord1fARB(GLenum target, GLfloat s)
{
	D(bug("nfosmesa: glMultiTexCoord1fARB(%s, %f)", gl_enum_name(target), s));
	fn.glMultiTexCoord1fARB(target, s);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord1fv(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord1fv(GLenum target, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord1fv(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
FN_GLMULTITEXCOORD1FV(target, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord1fvARB(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord1fvARB(GLenum target, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord1fvARB(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __v_size = 1;
	GLfloat __v_tmp[__v_size];
	GLfloat *__v_ptmp = Atari2HostFloatArray(__v_size, v, __v_tmp);
	fn.glMultiTexCoord1fvARB(target, __v_ptmp);
#else
	fn.glMultiTexCoord1fvARB(target, HostAddr(v, const GLfloat *));
#endif
}

void OSMesaDriver::nfglMultiTexCoord1hNV(GLenum target, GLhalfNV32 s)
{
	D(bug("nfosmesa: glMultiTexCoord1hNV(%s, %u)", gl_enum_name(target), s));
	fn.glMultiTexCoord1hNV(target, s);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord1hvNV(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord1hvNV(GLenum target, const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord1hvNV(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
FN_GLMULTITEXCOORD1HVNV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord1i(GLenum target, GLint s)
{
	D(bug("nfosmesa: glMultiTexCoord1i(%s, %d)", gl_enum_name(target), s));
	fn.glMultiTexCoord1i(target, s);
}

void OSMesaDriver::nfglMultiTexCoord1iARB(GLenum target, GLint s)
{
	D(bug("nfosmesa: glMultiTexCoord1iARB(%s, %d)", gl_enum_name(target), s));
	fn.glMultiTexCoord1iARB(target, s);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord1iv(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord1iv(GLenum target, const GLint *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord1iv(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
FN_GLMULTITEXCOORD1IV(target, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord1ivARB(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord1ivARB(GLenum target, const GLint *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord1ivARB(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __v_size = 1;
	GLint __v_tmp[__v_size];
	GLint *__v_ptmp = Atari2HostIntArray(__v_size, v, __v_tmp);
	fn.glMultiTexCoord1ivARB(target, __v_ptmp);
#else
	fn.glMultiTexCoord1ivARB(target, HostAddr(v, const GLint *));
#endif
}

void OSMesaDriver::nfglMultiTexCoord1s(GLenum target, GLshort32 s)
{
	D(bug("nfosmesa: glMultiTexCoord1s(%s, %d)", gl_enum_name(target), s));
	fn.glMultiTexCoord1s(target, s);
}

void OSMesaDriver::nfglMultiTexCoord1sARB(GLenum target, GLshort32 s)
{
	D(bug("nfosmesa: glMultiTexCoord1sARB(%s, %d)", gl_enum_name(target), s));
	fn.glMultiTexCoord1sARB(target, s);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord1sv(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord1sv(GLenum target, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord1sv(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
FN_GLMULTITEXCOORD1SV(target, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord1svARB(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord1svARB(GLenum target, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord1svARB(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __v_size = 1;
	GLshort __v_tmp[__v_size];
	GLshort *__v_ptmp = Atari2HostShortArray(__v_size, v, __v_tmp);
	fn.glMultiTexCoord1svARB(target, __v_ptmp);
#else
	fn.glMultiTexCoord1svARB(target, HostAddr(v, const GLshort *));
#endif
}

void OSMesaDriver::nfglMultiTexCoord1xOES(GLenum texture, GLfixed s)
{
	D(bug("nfosmesa: glMultiTexCoord1xOES(%s, 0x%x)", gl_enum_name(texture), s));
	fn.glMultiTexCoord1xOES(texture, s);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord1xvOES(GLenum texture, memptr coords)
#else
void OSMesaDriver::nfglMultiTexCoord1xvOES(GLenum texture, const GLfixed *coords)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord1xvOES(%s, " PRI_PTR ")", gl_enum_name(texture), AtariOffset(coords)));
FN_GLMULTITEXCOORD1XVOES(texture, coords);
}

void OSMesaDriver::nfglMultiTexCoord2bOES(GLenum texture, GLbyte32 s, GLbyte32 t)
{
	D(bug("nfosmesa: glMultiTexCoord2bOES(%s, %d, %d)", gl_enum_name(texture), s, t));
	fn.glMultiTexCoord2bOES(texture, s, t);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord2bvOES(GLenum texture, memptr coords)
#else
void OSMesaDriver::nfglMultiTexCoord2bvOES(GLenum texture, const GLbyte *coords)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord2bvOES(%s, " PRI_PTR ")", gl_enum_name(texture), AtariOffset(coords)));
FN_GLMULTITEXCOORD2BVOES(texture, coords);
}

void OSMesaDriver::nfglMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
{
	D(bug("nfosmesa: glMultiTexCoord2d(%s, %f, %f)", gl_enum_name(target), s, t));
	fn.glMultiTexCoord2d(target, s, t);
}

void OSMesaDriver::nfglMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t)
{
	D(bug("nfosmesa: glMultiTexCoord2dARB(%s, %f, %f)", gl_enum_name(target), s, t));
	fn.glMultiTexCoord2dARB(target, s, t);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord2dv(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord2dv(GLenum target, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord2dv(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
FN_GLMULTITEXCOORD2DV(target, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord2dvARB(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord2dvARB(GLenum target, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord2dvARB(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
#if NFOSMESA_NEED_DOUBLE_CONV
	GLint const __v_size = MAX(2, 0);
	GLdouble __v_tmp[__v_size];
	GLdouble *__v_ptmp = Atari2HostDoubleArray(__v_size, v, __v_tmp);
	fn.glMultiTexCoord2dvARB(target, __v_ptmp);
#else
	fn.glMultiTexCoord2dvARB(target, HostAddr(v, const GLdouble *));
#endif
}

void OSMesaDriver::nfglMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
{
	D(bug("nfosmesa: glMultiTexCoord2f(%s, %f, %f)", gl_enum_name(target), s, t));
	fn.glMultiTexCoord2f(target, s, t);
}

void OSMesaDriver::nfglMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
{
	D(bug("nfosmesa: glMultiTexCoord2fARB(%s, %f, %f)", gl_enum_name(target), s, t));
	fn.glMultiTexCoord2fARB(target, s, t);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord2fv(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord2fv(GLenum target, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord2fv(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
FN_GLMULTITEXCOORD2FV(target, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord2fvARB(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord2fvARB(GLenum target, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord2fvARB(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __v_size = MAX(2, 0);
	GLfloat __v_tmp[__v_size];
	GLfloat *__v_ptmp = Atari2HostFloatArray(__v_size, v, __v_tmp);
	fn.glMultiTexCoord2fvARB(target, __v_ptmp);
#else
	fn.glMultiTexCoord2fvARB(target, HostAddr(v, const GLfloat *));
#endif
}

void OSMesaDriver::nfglMultiTexCoord2hNV(GLenum target, GLhalfNV32 s, GLhalfNV32 t)
{
	D(bug("nfosmesa: glMultiTexCoord2hNV(%s, %u, %u)", gl_enum_name(target), s, t));
	fn.glMultiTexCoord2hNV(target, s, t);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord2hvNV(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord2hvNV(GLenum target, const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord2hvNV(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
FN_GLMULTITEXCOORD2HVNV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord2i(GLenum target, GLint s, GLint t)
{
	D(bug("nfosmesa: glMultiTexCoord2i(%s, %d, %d)", gl_enum_name(target), s, t));
	fn.glMultiTexCoord2i(target, s, t);
}

void OSMesaDriver::nfglMultiTexCoord2iARB(GLenum target, GLint s, GLint t)
{
	D(bug("nfosmesa: glMultiTexCoord2iARB(%s, %d, %d)", gl_enum_name(target), s, t));
	fn.glMultiTexCoord2iARB(target, s, t);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord2iv(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord2iv(GLenum target, const GLint *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord2iv(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
FN_GLMULTITEXCOORD2IV(target, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord2ivARB(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord2ivARB(GLenum target, const GLint *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord2ivARB(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __v_size = MAX(2, 0);
	GLint __v_tmp[__v_size];
	GLint *__v_ptmp = Atari2HostIntArray(__v_size, v, __v_tmp);
	fn.glMultiTexCoord2ivARB(target, __v_ptmp);
#else
	fn.glMultiTexCoord2ivARB(target, HostAddr(v, const GLint *));
#endif
}

void OSMesaDriver::nfglMultiTexCoord2s(GLenum target, GLshort32 s, GLshort32 t)
{
	D(bug("nfosmesa: glMultiTexCoord2s(%s, %d, %d)", gl_enum_name(target), s, t));
	fn.glMultiTexCoord2s(target, s, t);
}

void OSMesaDriver::nfglMultiTexCoord2sARB(GLenum target, GLshort32 s, GLshort32 t)
{
	D(bug("nfosmesa: glMultiTexCoord2sARB(%s, %d, %d)", gl_enum_name(target), s, t));
	fn.glMultiTexCoord2sARB(target, s, t);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord2sv(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord2sv(GLenum target, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord2sv(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
FN_GLMULTITEXCOORD2SV(target, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord2svARB(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord2svARB(GLenum target, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord2svARB(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __v_size = MAX(2, 0);
	GLshort __v_tmp[__v_size];
	GLshort *__v_ptmp = Atari2HostShortArray(__v_size, v, __v_tmp);
	fn.glMultiTexCoord2svARB(target, __v_ptmp);
#else
	fn.glMultiTexCoord2svARB(target, HostAddr(v, const GLshort *));
#endif
}

void OSMesaDriver::nfglMultiTexCoord2xOES(GLenum texture, GLfixed s, GLfixed t)
{
	D(bug("nfosmesa: glMultiTexCoord2xOES(%s, 0x%x, 0x%x)", gl_enum_name(texture), s, t));
	fn.glMultiTexCoord2xOES(texture, s, t);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord2xvOES(GLenum texture, memptr coords)
#else
void OSMesaDriver::nfglMultiTexCoord2xvOES(GLenum texture, const GLfixed *coords)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord2xvOES(%s, " PRI_PTR ")", gl_enum_name(texture), AtariOffset(coords)));
FN_GLMULTITEXCOORD2XVOES(texture, coords);
}

void OSMesaDriver::nfglMultiTexCoord3bOES(GLenum texture, GLbyte32 s, GLbyte32 t, GLbyte32 r)
{
	D(bug("nfosmesa: glMultiTexCoord3bOES(%s, %d, %d, %d)", gl_enum_name(texture), s, t, r));
	fn.glMultiTexCoord3bOES(texture, s, t, r);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord3bvOES(GLenum texture, memptr coords)
#else
void OSMesaDriver::nfglMultiTexCoord3bvOES(GLenum texture, const GLbyte *coords)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord3bvOES(%s, " PRI_PTR ")", gl_enum_name(texture), AtariOffset(coords)));
FN_GLMULTITEXCOORD3BVOES(texture, coords);
}

void OSMesaDriver::nfglMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
{
	D(bug("nfosmesa: glMultiTexCoord3d(%s, %f, %f, %f)", gl_enum_name(target), s, t, r));
	fn.glMultiTexCoord3d(target, s, t, r);
}

void OSMesaDriver::nfglMultiTexCoord3dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r)
{
	D(bug("nfosmesa: glMultiTexCoord3dARB(%s, %f, %f, %f)", gl_enum_name(target), s, t, r));
	fn.glMultiTexCoord3dARB(target, s, t, r);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord3dv(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord3dv(GLenum target, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord3dv(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
FN_GLMULTITEXCOORD3DV(target, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord3dvARB(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord3dvARB(GLenum target, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord3dvARB(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
#if NFOSMESA_NEED_DOUBLE_CONV
	GLint const __v_size = MAX(3, 0);
	GLdouble __v_tmp[__v_size];
	GLdouble *__v_ptmp = Atari2HostDoubleArray(__v_size, v, __v_tmp);
	fn.glMultiTexCoord3dvARB(target, __v_ptmp);
#else
	fn.glMultiTexCoord3dvARB(target, HostAddr(v, const GLdouble *));
#endif
}

void OSMesaDriver::nfglMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
{
	D(bug("nfosmesa: glMultiTexCoord3f(%s, %f, %f, %f)", gl_enum_name(target), s, t, r));
	fn.glMultiTexCoord3f(target, s, t, r);
}

void OSMesaDriver::nfglMultiTexCoord3fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r)
{
	D(bug("nfosmesa: glMultiTexCoord3fARB(%s, %f, %f, %f)", gl_enum_name(target), s, t, r));
	fn.glMultiTexCoord3fARB(target, s, t, r);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord3fv(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord3fv(GLenum target, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord3fv(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
FN_GLMULTITEXCOORD3FV(target, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord3fvARB(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord3fvARB(GLenum target, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord3fvARB(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __v_size = MAX(3, 0);
	GLfloat __v_tmp[__v_size];
	GLfloat *__v_ptmp = Atari2HostFloatArray(__v_size, v, __v_tmp);
	fn.glMultiTexCoord3fvARB(target, __v_ptmp);
#else
	fn.glMultiTexCoord3fvARB(target, HostAddr(v, const GLfloat *));
#endif
}

void OSMesaDriver::nfglMultiTexCoord3hNV(GLenum target, GLhalfNV32 s, GLhalfNV32 t, GLhalfNV32 r)
{
	D(bug("nfosmesa: glMultiTexCoord3hNV(%s, %u, %u, %u)", gl_enum_name(target), s, t, r));
	fn.glMultiTexCoord3hNV(target, s, t, r);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord3hvNV(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord3hvNV(GLenum target, const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord3hvNV(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
FN_GLMULTITEXCOORD3HVNV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
{
	D(bug("nfosmesa: glMultiTexCoord3i(%s, %d, %d, %d)", gl_enum_name(target), s, t, r));
	fn.glMultiTexCoord3i(target, s, t, r);
}

void OSMesaDriver::nfglMultiTexCoord3iARB(GLenum target, GLint s, GLint t, GLint r)
{
	D(bug("nfosmesa: glMultiTexCoord3iARB(%s, %d, %d, %d)", gl_enum_name(target), s, t, r));
	fn.glMultiTexCoord3iARB(target, s, t, r);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord3iv(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord3iv(GLenum target, const GLint *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord3iv(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
FN_GLMULTITEXCOORD3IV(target, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord3ivARB(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord3ivARB(GLenum target, const GLint *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord3ivARB(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __v_size = MAX(3, 0);
	GLint __v_tmp[__v_size];
	GLint *__v_ptmp = Atari2HostIntArray(__v_size, v, __v_tmp);
	fn.glMultiTexCoord3ivARB(target, __v_ptmp);
#else
	fn.glMultiTexCoord3ivARB(target, HostAddr(v, const GLint *));
#endif
}

void OSMesaDriver::nfglMultiTexCoord3s(GLenum target, GLshort32 s, GLshort32 t, GLshort32 r)
{
	D(bug("nfosmesa: glMultiTexCoord3s(%s, %d, %d, %d)", gl_enum_name(target), s, t, r));
	fn.glMultiTexCoord3s(target, s, t, r);
}

void OSMesaDriver::nfglMultiTexCoord3sARB(GLenum target, GLshort32 s, GLshort32 t, GLshort32 r)
{
	D(bug("nfosmesa: glMultiTexCoord3sARB(%s, %d, %d, %d)", gl_enum_name(target), s, t, r));
	fn.glMultiTexCoord3sARB(target, s, t, r);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord3sv(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord3sv(GLenum target, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord3sv(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
FN_GLMULTITEXCOORD3SV(target, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord3svARB(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord3svARB(GLenum target, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord3svARB(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __v_size = MAX(3, 0);
	GLshort __v_tmp[__v_size];
	GLshort *__v_ptmp = Atari2HostShortArray(__v_size, v, __v_tmp);
	fn.glMultiTexCoord3svARB(target, __v_ptmp);
#else
	fn.glMultiTexCoord3svARB(target, HostAddr(v, const GLshort *));
#endif
}

void OSMesaDriver::nfglMultiTexCoord3xOES(GLenum texture, GLfixed s, GLfixed t, GLfixed r)
{
	D(bug("nfosmesa: glMultiTexCoord3xOES(%s, 0x%x, 0x%x, 0x%x)", gl_enum_name(texture), s, t, r));
	fn.glMultiTexCoord3xOES(texture, s, t, r);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord3xvOES(GLenum texture, memptr coords)
#else
void OSMesaDriver::nfglMultiTexCoord3xvOES(GLenum texture, const GLfixed *coords)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord3xvOES(%s, " PRI_PTR ")", gl_enum_name(texture), AtariOffset(coords)));
FN_GLMULTITEXCOORD3XVOES(texture, coords);
}

void OSMesaDriver::nfglMultiTexCoord4bOES(GLenum texture, GLbyte32 s, GLbyte32 t, GLbyte32 r, GLbyte32 q)
{
	D(bug("nfosmesa: glMultiTexCoord4bOES(%s, %d, %d, %d, %d)", gl_enum_name(texture), s, t, r, q));
	fn.glMultiTexCoord4bOES(texture, s, t, r, q);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord4bvOES(GLenum texture, memptr coords)
#else
void OSMesaDriver::nfglMultiTexCoord4bvOES(GLenum texture, const GLbyte *coords)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord4bvOES(%s, " PRI_PTR ")", gl_enum_name(texture), AtariOffset(coords)));
FN_GLMULTITEXCOORD4BVOES(texture, coords);
}

void OSMesaDriver::nfglMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
{
	D(bug("nfosmesa: glMultiTexCoord4d(%s, %f, %f, %f, %f)", gl_enum_name(target), s, t, r, q));
	fn.glMultiTexCoord4d(target, s, t, r, q);
}

void OSMesaDriver::nfglMultiTexCoord4dARB(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
{
	D(bug("nfosmesa: glMultiTexCoord4dARB(%s, %f, %f, %f, %f)", gl_enum_name(target), s, t, r, q));
	fn.glMultiTexCoord4dARB(target, s, t, r, q);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord4dv(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord4dv(GLenum target, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord4dv(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
FN_GLMULTITEXCOORD4DV(target, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord4dvARB(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord4dvARB(GLenum target, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord4dvARB(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
#if NFOSMESA_NEED_DOUBLE_CONV
	GLint const __v_size = MAX(4, 0);
	GLdouble __v_tmp[__v_size];
	GLdouble *__v_ptmp = Atari2HostDoubleArray(__v_size, v, __v_tmp);
	fn.glMultiTexCoord4dvARB(target, __v_ptmp);
#else
	fn.glMultiTexCoord4dvARB(target, HostAddr(v, const GLdouble *));
#endif
}

void OSMesaDriver::nfglMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
	D(bug("nfosmesa: glMultiTexCoord4f(%s, %f, %f, %f, %f)", gl_enum_name(target), s, t, r, q));
	fn.glMultiTexCoord4f(target, s, t, r, q);
}

void OSMesaDriver::nfglMultiTexCoord4fARB(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
	D(bug("nfosmesa: glMultiTexCoord4fARB(%s, %f, %f, %f, %f)", gl_enum_name(target), s, t, r, q));
	fn.glMultiTexCoord4fARB(target, s, t, r, q);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord4fv(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord4fv(GLenum target, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord4fv(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
FN_GLMULTITEXCOORD4FV(target, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord4fvARB(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord4fvARB(GLenum target, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord4fvARB(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __v_size = MAX(4, 0);
	GLfloat __v_tmp[__v_size];
	GLfloat *__v_ptmp = Atari2HostFloatArray(__v_size, v, __v_tmp);
	fn.glMultiTexCoord4fvARB(target, __v_ptmp);
#else
	fn.glMultiTexCoord4fvARB(target, HostAddr(v, const GLfloat *));
#endif
}

void OSMesaDriver::nfglMultiTexCoord4hNV(GLenum target, GLhalfNV32 s, GLhalfNV32 t, GLhalfNV32 r, GLhalfNV32 q)
{
	D(bug("nfosmesa: glMultiTexCoord4hNV(%s, %u, %u, %u, %u)", gl_enum_name(target), s, t, r, q));
	fn.glMultiTexCoord4hNV(target, s, t, r, q);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord4hvNV(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord4hvNV(GLenum target, const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord4hvNV(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
FN_GLMULTITEXCOORD4HVNV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
{
	D(bug("nfosmesa: glMultiTexCoord4i(%s, %d, %d, %d, %d)", gl_enum_name(target), s, t, r, q));
	fn.glMultiTexCoord4i(target, s, t, r, q);
}

void OSMesaDriver::nfglMultiTexCoord4iARB(GLenum target, GLint s, GLint t, GLint r, GLint q)
{
	D(bug("nfosmesa: glMultiTexCoord4iARB(%s, %d, %d, %d, %d)", gl_enum_name(target), s, t, r, q));
	fn.glMultiTexCoord4iARB(target, s, t, r, q);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord4iv(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord4iv(GLenum target, const GLint *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord4iv(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
FN_GLMULTITEXCOORD4IV(target, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord4ivARB(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord4ivARB(GLenum target, const GLint *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord4ivARB(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __v_size = MAX(4, 0);
	GLint __v_tmp[__v_size];
	GLint *__v_ptmp = Atari2HostIntArray(__v_size, v, __v_tmp);
	fn.glMultiTexCoord4ivARB(target, __v_ptmp);
#else
	fn.glMultiTexCoord4ivARB(target, HostAddr(v, const GLint *));
#endif
}

void OSMesaDriver::nfglMultiTexCoord4s(GLenum target, GLshort32 s, GLshort32 t, GLshort32 r, GLshort32 q)
{
	D(bug("nfosmesa: glMultiTexCoord4s(%s, %d, %d, %d, %d)", gl_enum_name(target), s, t, r, q));
	fn.glMultiTexCoord4s(target, s, t, r, q);
}

void OSMesaDriver::nfglMultiTexCoord4sARB(GLenum target, GLshort32 s, GLshort32 t, GLshort32 r, GLshort32 q)
{
	D(bug("nfosmesa: glMultiTexCoord4sARB(%s, %d, %d, %d, %d)", gl_enum_name(target), s, t, r, q));
	fn.glMultiTexCoord4sARB(target, s, t, r, q);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord4sv(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord4sv(GLenum target, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord4sv(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
FN_GLMULTITEXCOORD4SV(target, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord4svARB(GLenum target, memptr v)
#else
void OSMesaDriver::nfglMultiTexCoord4svARB(GLenum target, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord4svARB(%s, " PRI_PTR ")", gl_enum_name(target), AtariOffset(v)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __v_size = MAX(4, 0);
	GLshort __v_tmp[__v_size];
	GLshort *__v_ptmp = Atari2HostShortArray(__v_size, v, __v_tmp);
	fn.glMultiTexCoord4svARB(target, __v_ptmp);
#else
	fn.glMultiTexCoord4svARB(target, HostAddr(v, const GLshort *));
#endif
}

void OSMesaDriver::nfglMultiTexCoord4xOES(GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
{
	D(bug("nfosmesa: glMultiTexCoord4xOES(%s, 0x%x, 0x%x, 0x%x, 0x%x)", gl_enum_name(texture), s, t, r, q));
	fn.glMultiTexCoord4xOES(texture, s, t, r, q);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoord4xvOES(GLenum texture, memptr coords)
#else
void OSMesaDriver::nfglMultiTexCoord4xvOES(GLenum texture, const GLfixed *coords)
#endif
{
	D(bug("nfosmesa: glMultiTexCoord4xvOES(%s, " PRI_PTR ")", gl_enum_name(texture), AtariOffset(coords)));
FN_GLMULTITEXCOORD4XVOES(texture, coords);
}

void OSMesaDriver::nfglMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
{
	D(bug("nfosmesa: glMultiTexCoordP1ui(%s, %s, %u)", gl_enum_name(texture), gl_enum_name(type), coords));
	fn.glMultiTexCoordP1ui(texture, type, coords);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoordP1uiv(GLenum texture, GLenum type, memptr coords)
#else
void OSMesaDriver::nfglMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
#endif
{
	D(bug("nfosmesa: glMultiTexCoordP1uiv(%s, %s, " PRI_PTR ")", gl_enum_name(texture), gl_enum_name(type), AtariOffset(coords)));
FN_GLMULTITEXCOORDP1UIV(texture, type, coords);
}

void OSMesaDriver::nfglMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
{
	D(bug("nfosmesa: glMultiTexCoordP2ui(%s, %s, %u)", gl_enum_name(texture), gl_enum_name(type), coords));
	fn.glMultiTexCoordP2ui(texture, type, coords);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoordP2uiv(GLenum texture, GLenum type, memptr coords)
#else
void OSMesaDriver::nfglMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
#endif
{
	D(bug("nfosmesa: glMultiTexCoordP2uiv(%s, %s, " PRI_PTR ")", gl_enum_name(texture), gl_enum_name(type), AtariOffset(coords)));
FN_GLMULTITEXCOORDP2UIV(texture, type, coords);
}

void OSMesaDriver::nfglMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
{
	D(bug("nfosmesa: glMultiTexCoordP3ui(%s, %s, %u)", gl_enum_name(texture), gl_enum_name(type), coords));
	fn.glMultiTexCoordP3ui(texture, type, coords);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoordP3uiv(GLenum texture, GLenum type, memptr coords)
#else
void OSMesaDriver::nfglMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
#endif
{
	D(bug("nfosmesa: glMultiTexCoordP3uiv(%s, %s, " PRI_PTR ")", gl_enum_name(texture), gl_enum_name(type), AtariOffset(coords)));
FN_GLMULTITEXCOORDP3UIV(texture, type, coords);
}

void OSMesaDriver::nfglMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
{
	D(bug("nfosmesa: glMultiTexCoordP4ui(%s, %s, %u)", gl_enum_name(texture), gl_enum_name(type), coords));
	fn.glMultiTexCoordP4ui(texture, type, coords);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoordP4uiv(GLenum texture, GLenum type, memptr coords)
#else
void OSMesaDriver::nfglMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
#endif
{
	D(bug("nfosmesa: glMultiTexCoordP4uiv(%s, %s, " PRI_PTR ")", gl_enum_name(texture), gl_enum_name(type), AtariOffset(coords)));
FN_GLMULTITEXCOORDP4UIV(texture, type, coords);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexCoordPointerEXT(GLenum texunit, GLint size, GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglMultiTexCoordPointerEXT(GLenum texunit, GLint size, GLenum type, GLsizei stride, const void *pointer)
#endif
{
	D(bug("nfosmesa: glMultiTexCoordPointerEXT(%s, %d, %s, %d, " PRI_PTR ")", gl_enum_name(texunit), size, gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLMULTITEXCOORDPOINTEREXT(texunit, size, type, stride, pointer);
}

void OSMesaDriver::nfglMultiTexEnvfEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glMultiTexEnvfEXT(%s, %s, %s, %f)", gl_enum_name(texunit), gl_enum_name(target), gl_enum_name(pname), param));
	fn.glMultiTexEnvfEXT(texunit, target, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexEnvfvEXT(GLenum texunit, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglMultiTexEnvfvEXT(GLenum texunit, GLenum target, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glMultiTexEnvfvEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLMULTITEXENVFVEXT(texunit, target, pname, params);
}

void OSMesaDriver::nfglMultiTexEnviEXT(GLenum texunit, GLenum target, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glMultiTexEnviEXT(%s, %s, %s, %d)", gl_enum_name(texunit), gl_enum_name(target), gl_enum_name(pname), param));
	fn.glMultiTexEnviEXT(texunit, target, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexEnvivEXT(GLenum texunit, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglMultiTexEnvivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glMultiTexEnvivEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLMULTITEXENVIVEXT(texunit, target, pname, params);
}

void OSMesaDriver::nfglMultiTexGendEXT(GLenum texunit, GLenum coord, GLenum pname, GLdouble param)
{
	D(bug("nfosmesa: glMultiTexGendEXT(%s, %s, %s, %f)", gl_enum_name(texunit), gl_enum_name(coord), gl_enum_name(pname), param));
	fn.glMultiTexGendEXT(texunit, coord, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexGendvEXT(GLenum texunit, GLenum coord, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglMultiTexGendvEXT(GLenum texunit, GLenum coord, GLenum pname, const GLdouble *params)
#endif
{
	D(bug("nfosmesa: glMultiTexGendvEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(coord), gl_enum_name(pname), AtariOffset(params)));
FN_GLMULTITEXGENDVEXT(texunit, coord, pname, params);
}

void OSMesaDriver::nfglMultiTexGenfEXT(GLenum texunit, GLenum coord, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glMultiTexGenfEXT(%s, %s, %s, %f)", gl_enum_name(texunit), gl_enum_name(coord), gl_enum_name(pname), param));
	fn.glMultiTexGenfEXT(texunit, coord, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexGenfvEXT(GLenum texunit, GLenum coord, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglMultiTexGenfvEXT(GLenum texunit, GLenum coord, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glMultiTexGenfvEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(coord), gl_enum_name(pname), AtariOffset(params)));
FN_GLMULTITEXGENFVEXT(texunit, coord, pname, params);
}

void OSMesaDriver::nfglMultiTexGeniEXT(GLenum texunit, GLenum coord, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glMultiTexGeniEXT(%s, %s, %s, %d)", gl_enum_name(texunit), gl_enum_name(coord), gl_enum_name(pname), param));
	fn.glMultiTexGeniEXT(texunit, coord, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexGenivEXT(GLenum texunit, GLenum coord, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglMultiTexGenivEXT(GLenum texunit, GLenum coord, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glMultiTexGenivEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(coord), gl_enum_name(pname), AtariOffset(params)));
FN_GLMULTITEXGENIVEXT(texunit, coord, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glMultiTexImage1DEXT(%s, %s, %d, %s, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), level, gl_enum_name(internalformat), width, border, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLMULTITEXIMAGE1DEXT(texunit, target, level, internalformat, width, border, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glMultiTexImage2DEXT(%s, %s, %d, %s, %d, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), level, gl_enum_name(internalformat), width, height, border, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLMULTITEXIMAGE2DEXT(texunit, target, level, internalformat, width, height, border, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glMultiTexImage3DEXT(%s, %s, %d, %s, %d, %d, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), level, gl_enum_name(internalformat), width, height, depth, border, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLMULTITEXIMAGE3DEXT(texunit, target, level, internalformat, width, height, depth, border, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexParameterIivEXT(GLenum texunit, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglMultiTexParameterIivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glMultiTexParameterIivEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLMULTITEXPARAMETERIIVEXT(texunit, target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexParameterIuivEXT(GLenum texunit, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglMultiTexParameterIuivEXT(GLenum texunit, GLenum target, GLenum pname, const GLuint *params)
#endif
{
	D(bug("nfosmesa: glMultiTexParameterIuivEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLMULTITEXPARAMETERIUIVEXT(texunit, target, pname, params);
}

void OSMesaDriver::nfglMultiTexParameterfEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glMultiTexParameterfEXT(%s, %s, %s, %f)", gl_enum_name(texunit), gl_enum_name(target), gl_enum_name(pname), param));
	fn.glMultiTexParameterfEXT(texunit, target, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glMultiTexParameterfvEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLMULTITEXPARAMETERFVEXT(texunit, target, pname, params);
}

void OSMesaDriver::nfglMultiTexParameteriEXT(GLenum texunit, GLenum target, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glMultiTexParameteriEXT(%s, %s, %s, %d)", gl_enum_name(texunit), gl_enum_name(target), gl_enum_name(pname), param));
	fn.glMultiTexParameteriEXT(texunit, target, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glMultiTexParameterivEXT(%s, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLMULTITEXPARAMETERIVEXT(texunit, target, pname, params);
}

void OSMesaDriver::nfglMultiTexRenderbufferEXT(GLenum texunit, GLenum target, GLuint renderbuffer)
{
	D(bug("nfosmesa: glMultiTexRenderbufferEXT(%s, %s, %u)", gl_enum_name(texunit), gl_enum_name(target), renderbuffer));
	fn.glMultiTexRenderbufferEXT(texunit, target, renderbuffer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glMultiTexSubImage1DEXT(%s, %s, %d, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), level, xoffset, width, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLMULTITEXSUBIMAGE1DEXT(texunit, target, level, xoffset, width, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glMultiTexSubImage2DEXT(%s, %s, %d, %d, %d, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), level, xoffset, yoffset, width, height, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLMULTITEXSUBIMAGE2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglMultiTexSubImage3DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glMultiTexSubImage3DEXT(%s, %s, %d, %d, %d, %d, %d, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(texunit), gl_enum_name(target), level, xoffset, yoffset, zoffset, width, height, depth, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLMULTITEXSUBIMAGE3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
}

void OSMesaDriver::nfglMulticastBarrierNV(void)
{
	D(bug("nfosmesa: glMulticastBarrierNV()"));
	fn.glMulticastBarrierNV();
}

void OSMesaDriver::nfglMulticastBlitFramebufferNV(GLuint srcGpu, GLuint dstGpu, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter)
{
	D(bug("nfosmesa: glMulticastBlitFramebufferNV(%u, %u, %d, %d, %d, %d, %d, %d, %d, %d, 0x%x, %s)", srcGpu, dstGpu, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, gl_enum_name(filter)));
	fn.glMulticastBlitFramebufferNV(srcGpu, dstGpu, srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMulticastBufferSubDataNV(GLbitfield gpuMask, GLuint buffer, GLintptr offset, GLsizeiptr size, memptr data)
#else
void OSMesaDriver::nfglMulticastBufferSubDataNV(GLbitfield gpuMask, GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data)
#endif
{
	D(bug("nfosmesa: glMulticastBufferSubDataNV(0x%x, %u, %" PRI_IPTR ", %" PRI_IPTR ", " PRI_PTR ")", gpuMask, buffer, offset, size, AtariOffset(data)));
#if NFOSMESA_NEED_BYTE_CONV
	GLint const __data_size = MAX(size, 0);
	GLbyte __data_tmp[__data_size];
	GLbyte *__data_ptmp = Atari2HostByteArray(__data_size, data, __data_tmp);
	fn.glMulticastBufferSubDataNV(gpuMask, buffer, offset, size, __data_ptmp);
#else
	fn.glMulticastBufferSubDataNV(gpuMask, buffer, offset, size, HostAddr(data, const void *));
#endif
}

void OSMesaDriver::nfglMulticastCopyBufferSubDataNV(GLuint readGpu, GLbitfield writeGpuMask, GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
{
	D(bug("nfosmesa: glMulticastCopyBufferSubDataNV(%u, 0x%x, %u, %u, %" PRI_IPTR ", %" PRI_IPTR ", %" PRI_IPTR ")", readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size));
	fn.glMulticastCopyBufferSubDataNV(readGpu, writeGpuMask, readBuffer, writeBuffer, readOffset, writeOffset, size);
}

void OSMesaDriver::nfglMulticastCopyImageSubDataNV(GLuint srcGpu, GLbitfield dstGpuMask, GLuint srcName, GLenum srcTarget, GLint srcLevel, GLint srcX, GLint srcY, GLint srcZ, GLuint dstName, GLenum dstTarget, GLint dstLevel, GLint dstX, GLint dstY, GLint dstZ, GLsizei srcWidth, GLsizei srcHeight, GLsizei srcDepth)
{
	D(bug("nfosmesa: glMulticastCopyImageSubDataNV(%u, 0x%x, %u, %s, %d, %d, %d, %d, %u, %s, %d, %d, %d, %d, %d, %d, %d)", srcGpu, dstGpuMask, srcName, gl_enum_name(srcTarget), srcLevel, srcX, srcY, srcZ, dstName, gl_enum_name(dstTarget), dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth));
	fn.glMulticastCopyImageSubDataNV(srcGpu, dstGpuMask, srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, dstTarget, dstLevel, dstX, dstY, dstZ, srcWidth, srcHeight, srcDepth);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMulticastFramebufferSampleLocationsfvNV(GLuint gpu, GLuint framebuffer, GLuint start, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglMulticastFramebufferSampleLocationsfvNV(GLuint gpu, GLuint framebuffer, GLuint start, GLsizei count, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glMulticastFramebufferSampleLocationsfvNV(%u, %u, %u, %d, " PRI_PTR ")", gpu, framebuffer, start, count, AtariOffset(v)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __v_size = MAX(count, 0);
	GLfloat __v_tmp[__v_size];
	GLfloat *__v_ptmp = Atari2HostFloatArray(__v_size, v, __v_tmp);
	fn.glMulticastFramebufferSampleLocationsfvNV(gpu, framebuffer, start, count, __v_ptmp);
#else
	fn.glMulticastFramebufferSampleLocationsfvNV(gpu, framebuffer, start, count, HostAddr(v, const GLfloat *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMulticastGetQueryObjecti64vNV(GLuint gpu, GLuint id, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglMulticastGetQueryObjecti64vNV(GLuint gpu, GLuint id, GLenum pname, GLint64 *params)
#endif
{
	D(bug("nfosmesa: glMulticastGetQueryObjecti64vNV(%u, %u, %s, " PRI_PTR ")", gpu, id, gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLint64 __params_tmp[__params_size];
	fn.glMulticastGetQueryObjecti64vNV(gpu, id, pname, __params_tmp);
	Host2AtariInt64Array(__params_size, __params_tmp, params);
#else
	fn.glMulticastGetQueryObjecti64vNV(gpu, id, pname, HostAddr(params, GLint64 *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMulticastGetQueryObjectivNV(GLuint gpu, GLuint id, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglMulticastGetQueryObjectivNV(GLuint gpu, GLuint id, GLenum pname, GLint *params)
#endif
{
	D(bug("nfosmesa: glMulticastGetQueryObjectivNV(%u, %u, %s, " PRI_PTR ")", gpu, id, gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLint __params_tmp[__params_size];
	fn.glMulticastGetQueryObjectivNV(gpu, id, pname, __params_tmp);
	Host2AtariIntArray(__params_size, __params_tmp, params);
#else
	fn.glMulticastGetQueryObjectivNV(gpu, id, pname, HostAddr(params, GLint *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMulticastGetQueryObjectui64vNV(GLuint gpu, GLuint id, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglMulticastGetQueryObjectui64vNV(GLuint gpu, GLuint id, GLenum pname, GLuint64 *params)
#endif
{
	D(bug("nfosmesa: glMulticastGetQueryObjectui64vNV(%u, %u, %s, " PRI_PTR ")", gpu, id, gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLuint64 __params_tmp[__params_size];
	fn.glMulticastGetQueryObjectui64vNV(gpu, id, pname, __params_tmp);
	Host2AtariInt64Array(__params_size, __params_tmp, params);
#else
	fn.glMulticastGetQueryObjectui64vNV(gpu, id, pname, HostAddr(params, GLuint64 *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglMulticastGetQueryObjectuivNV(GLuint gpu, GLuint id, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglMulticastGetQueryObjectuivNV(GLuint gpu, GLuint id, GLenum pname, GLuint *params)
#endif
{
	D(bug("nfosmesa: glMulticastGetQueryObjectuivNV(%u, %u, %s, " PRI_PTR ")", gpu, id, gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLuint __params_tmp[__params_size];
	fn.glMulticastGetQueryObjectuivNV(gpu, id, pname, __params_tmp);
	Host2AtariIntArray(__params_size, __params_tmp, params);
#else
	fn.glMulticastGetQueryObjectuivNV(gpu, id, pname, HostAddr(params, GLuint *));
#endif
}

void OSMesaDriver::nfglMulticastWaitSyncNV(GLuint signalGpu, GLbitfield waitGpuMask)
{
	D(bug("nfosmesa: glMulticastWaitSyncNV(%u, 0x%x)", signalGpu, waitGpuMask));
	fn.glMulticastWaitSyncNV(signalGpu, waitGpuMask);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNamedBufferData(GLuint buffer, GLsizeiptr size, memptr data, GLenum usage)
#else
void OSMesaDriver::nfglNamedBufferData(GLuint buffer, GLsizeiptr size, const void *data, GLenum usage)
#endif
{
	D(bug("nfosmesa: glNamedBufferData(%u, %" PRI_IPTR ", " PRI_PTR ", %s)", buffer, size, AtariOffset(data), gl_enum_name(usage)));
FN_GLNAMEDBUFFERDATA(buffer, size, data, usage);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNamedBufferDataEXT(GLuint buffer, GLsizeiptr size, memptr data, GLenum usage)
#else
void OSMesaDriver::nfglNamedBufferDataEXT(GLuint buffer, GLsizeiptr size, const void *data, GLenum usage)
#endif
{
	D(bug("nfosmesa: glNamedBufferDataEXT(%u, %" PRI_IPTR ", " PRI_PTR ", %s)", buffer, size, AtariOffset(data), gl_enum_name(usage)));
FN_GLNAMEDBUFFERDATAEXT(buffer, size, data, usage);
}

void OSMesaDriver::nfglNamedBufferPageCommitmentARB(GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean32 commit)
{
	D(bug("nfosmesa: glNamedBufferPageCommitmentARB(%u, %" PRI_IPTR ", %" PRI_IPTR ", %d)", buffer, offset, size, commit));
	fn.glNamedBufferPageCommitmentARB(buffer, offset, size, commit);
}

void OSMesaDriver::nfglNamedBufferPageCommitmentEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, GLboolean32 commit)
{
	D(bug("nfosmesa: glNamedBufferPageCommitmentEXT(%u, %" PRI_IPTR ", %" PRI_IPTR ", %d)", buffer, offset, size, commit));
	fn.glNamedBufferPageCommitmentEXT(buffer, offset, size, commit);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNamedBufferStorage(GLuint buffer, GLsizeiptr size, memptr data, GLbitfield flags)
#else
void OSMesaDriver::nfglNamedBufferStorage(GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags)
#endif
{
	D(bug("nfosmesa: glNamedBufferStorage(%u, %" PRI_IPTR ", " PRI_PTR ", 0x%x)", buffer, size, AtariOffset(data), flags));
FN_GLNAMEDBUFFERSTORAGE(buffer, size, data, flags);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNamedBufferStorageEXT(GLuint buffer, GLsizeiptr size, memptr data, GLbitfield flags)
#else
void OSMesaDriver::nfglNamedBufferStorageEXT(GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags)
#endif
{
	D(bug("nfosmesa: glNamedBufferStorageEXT(%u, %" PRI_IPTR ", " PRI_PTR ", 0x%x)", buffer, size, AtariOffset(data), flags));
FN_GLNAMEDBUFFERSTORAGEEXT(buffer, size, data, flags);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNamedBufferStorageExternalEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, memptr clientBuffer, GLbitfield flags)
#else
void OSMesaDriver::nfglNamedBufferStorageExternalEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, GLeglClientBufferEXT clientBuffer, GLbitfield flags)
#endif
{
	D(bug("nfosmesa: glNamedBufferStorageExternalEXT(%u, %" PRI_IPTR ", %" PRI_IPTR ", " PRI_PTR ", 0x%x)", buffer, offset, size, AtariOffset(clientBuffer), flags));
FN_GLNAMEDBUFFERSTORAGEEXTERNALEXT(buffer, offset, size, clientBuffer, flags);
}

void OSMesaDriver::nfglNamedBufferStorageMemEXT(GLuint buffer, GLsizeiptr size, GLuint memory, GLuint64 offset)
{
	D(bug("nfosmesa: glNamedBufferStorageMemEXT(%u, %" PRI_IPTR ", %u, %" PRIu64 ")", buffer, size, memory, offset));
	fn.glNamedBufferStorageMemEXT(buffer, size, memory, offset);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr size, memptr data)
#else
void OSMesaDriver::nfglNamedBufferSubData(GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data)
#endif
{
	D(bug("nfosmesa: glNamedBufferSubData(%u, %" PRI_IPTR ", %" PRI_IPTR ", " PRI_PTR ")", buffer, offset, size, AtariOffset(data)));
FN_GLNAMEDBUFFERSUBDATA(buffer, offset, size, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, memptr data)
#else
void OSMesaDriver::nfglNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data)
#endif
{
	D(bug("nfosmesa: glNamedBufferSubDataEXT(%u, %" PRI_IPTR ", %" PRI_IPTR ", " PRI_PTR ")", buffer, offset, size, AtariOffset(data)));
FN_GLNAMEDBUFFERSUBDATAEXT(buffer, offset, size, data);
}

void OSMesaDriver::nfglNamedCopyBufferSubDataEXT(GLuint readBuffer, GLuint writeBuffer, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
{
	D(bug("nfosmesa: glNamedCopyBufferSubDataEXT(%u, %u, %" PRI_IPTR ", %" PRI_IPTR ", %" PRI_IPTR ")", readBuffer, writeBuffer, readOffset, writeOffset, size));
	fn.glNamedCopyBufferSubDataEXT(readBuffer, writeBuffer, readOffset, writeOffset, size);
}

void OSMesaDriver::nfglNamedFramebufferDrawBuffer(GLuint framebuffer, GLenum buf)
{
	D(bug("nfosmesa: glNamedFramebufferDrawBuffer(%u, %s)", framebuffer, gl_enum_name(buf)));
	fn.glNamedFramebufferDrawBuffer(framebuffer, buf);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNamedFramebufferDrawBuffers(GLuint framebuffer, GLsizei n, memptr bufs)
#else
void OSMesaDriver::nfglNamedFramebufferDrawBuffers(GLuint framebuffer, GLsizei n, const GLenum *bufs)
#endif
{
	D(bug("nfosmesa: glNamedFramebufferDrawBuffers(%u, %d, " PRI_PTR ")", framebuffer, n, AtariOffset(bufs)));
FN_GLNAMEDFRAMEBUFFERDRAWBUFFERS(framebuffer, n, bufs);
}

void OSMesaDriver::nfglNamedFramebufferParameteri(GLuint framebuffer, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glNamedFramebufferParameteri(%u, %s, %d)", framebuffer, gl_enum_name(pname), param));
	fn.glNamedFramebufferParameteri(framebuffer, pname, param);
}

void OSMesaDriver::nfglNamedFramebufferParameteriEXT(GLuint framebuffer, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glNamedFramebufferParameteriEXT(%u, %s, %d)", framebuffer, gl_enum_name(pname), param));
	fn.glNamedFramebufferParameteriEXT(framebuffer, pname, param);
}

void OSMesaDriver::nfglNamedFramebufferReadBuffer(GLuint framebuffer, GLenum src)
{
	D(bug("nfosmesa: glNamedFramebufferReadBuffer(%u, %s)", framebuffer, gl_enum_name(src)));
	fn.glNamedFramebufferReadBuffer(framebuffer, src);
}

void OSMesaDriver::nfglNamedFramebufferRenderbuffer(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
	D(bug("nfosmesa: glNamedFramebufferRenderbuffer(%u, %s, %s, %u)", framebuffer, gl_enum_name(attachment), gl_enum_name(renderbuffertarget), renderbuffer));
	fn.glNamedFramebufferRenderbuffer(framebuffer, attachment, renderbuffertarget, renderbuffer);
}

void OSMesaDriver::nfglNamedFramebufferRenderbufferEXT(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
	D(bug("nfosmesa: glNamedFramebufferRenderbufferEXT(%u, %s, %s, %u)", framebuffer, gl_enum_name(attachment), gl_enum_name(renderbuffertarget), renderbuffer));
	fn.glNamedFramebufferRenderbufferEXT(framebuffer, attachment, renderbuffertarget, renderbuffer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNamedFramebufferSampleLocationsfvARB(GLuint framebuffer, GLuint start, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglNamedFramebufferSampleLocationsfvARB(GLuint framebuffer, GLuint start, GLsizei count, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glNamedFramebufferSampleLocationsfvARB(%u, %u, %d, " PRI_PTR ")", framebuffer, start, count, AtariOffset(v)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __v_size = MAX(count, 0);
	GLfloat __v_tmp[__v_size];
	GLfloat *__v_ptmp = Atari2HostFloatArray(__v_size, v, __v_tmp);
	fn.glNamedFramebufferSampleLocationsfvARB(framebuffer, start, count, __v_ptmp);
#else
	fn.glNamedFramebufferSampleLocationsfvARB(framebuffer, start, count, HostAddr(v, const GLfloat *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNamedFramebufferSampleLocationsfvNV(GLuint framebuffer, GLuint start, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglNamedFramebufferSampleLocationsfvNV(GLuint framebuffer, GLuint start, GLsizei count, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glNamedFramebufferSampleLocationsfvNV(%u, %u, %d, " PRI_PTR ")", framebuffer, start, count, AtariOffset(v)));
FN_GLNAMEDFRAMEBUFFERSAMPLELOCATIONSFVNV(framebuffer, start, count, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNamedFramebufferSamplePositionsfvAMD(GLuint framebuffer, GLuint numsamples, GLuint pixelindex, memptr values)
#else
void OSMesaDriver::nfglNamedFramebufferSamplePositionsfvAMD(GLuint framebuffer, GLuint numsamples, GLuint pixelindex, const GLfloat *values)
#endif
{
	D(bug("nfosmesa: glNamedFramebufferSamplePositionsfvAMD(%u, %u, %u, " PRI_PTR ")", framebuffer, numsamples, pixelindex, AtariOffset(values)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __values_size = MAX(numsamples, 0);
	GLfloat __values_tmp[__values_size];
	GLfloat *__values_ptmp = Atari2HostFloatArray(__values_size, values, __values_tmp);
	fn.glNamedFramebufferSamplePositionsfvAMD(framebuffer, numsamples, pixelindex, __values_ptmp);
#else
	fn.glNamedFramebufferSamplePositionsfvAMD(framebuffer, numsamples, pixelindex, HostAddr(values, const GLfloat *));
#endif
}

void OSMesaDriver::nfglNamedFramebufferTexture(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level)
{
	D(bug("nfosmesa: glNamedFramebufferTexture(%u, %s, %u, %d)", framebuffer, gl_enum_name(attachment), texture, level));
	fn.glNamedFramebufferTexture(framebuffer, attachment, texture, level);
}

void OSMesaDriver::nfglNamedFramebufferTexture1DEXT(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
	D(bug("nfosmesa: glNamedFramebufferTexture1DEXT(%u, %s, %s, %u, %d)", framebuffer, gl_enum_name(attachment), gl_enum_name(textarget), texture, level));
	fn.glNamedFramebufferTexture1DEXT(framebuffer, attachment, textarget, texture, level);
}

void OSMesaDriver::nfglNamedFramebufferTexture2DEXT(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
	D(bug("nfosmesa: glNamedFramebufferTexture2DEXT(%u, %s, %s, %u, %d)", framebuffer, gl_enum_name(attachment), gl_enum_name(textarget), texture, level));
	fn.glNamedFramebufferTexture2DEXT(framebuffer, attachment, textarget, texture, level);
}

void OSMesaDriver::nfglNamedFramebufferTexture3DEXT(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLint zoffset)
{
	D(bug("nfosmesa: glNamedFramebufferTexture3DEXT(%u, %s, %s, %u, %d, %d)", framebuffer, gl_enum_name(attachment), gl_enum_name(textarget), texture, level, zoffset));
	fn.glNamedFramebufferTexture3DEXT(framebuffer, attachment, textarget, texture, level, zoffset);
}

void OSMesaDriver::nfglNamedFramebufferTextureEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level)
{
	D(bug("nfosmesa: glNamedFramebufferTextureEXT(%u, %s, %u, %d)", framebuffer, gl_enum_name(attachment), texture, level));
	fn.glNamedFramebufferTextureEXT(framebuffer, attachment, texture, level);
}

void OSMesaDriver::nfglNamedFramebufferTextureFaceEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLenum face)
{
	D(bug("nfosmesa: glNamedFramebufferTextureFaceEXT(%u, %s, %u, %d, %s)", framebuffer, gl_enum_name(attachment), texture, level, gl_enum_name(face)));
	fn.glNamedFramebufferTextureFaceEXT(framebuffer, attachment, texture, level, face);
}

void OSMesaDriver::nfglNamedFramebufferTextureLayer(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer)
{
	D(bug("nfosmesa: glNamedFramebufferTextureLayer(%u, %s, %u, %d, %d)", framebuffer, gl_enum_name(attachment), texture, level, layer));
	fn.glNamedFramebufferTextureLayer(framebuffer, attachment, texture, level, layer);
}

void OSMesaDriver::nfglNamedFramebufferTextureLayerEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer)
{
	D(bug("nfosmesa: glNamedFramebufferTextureLayerEXT(%u, %s, %u, %d, %d)", framebuffer, gl_enum_name(attachment), texture, level, layer));
	fn.glNamedFramebufferTextureLayerEXT(framebuffer, attachment, texture, level, layer);
}

void OSMesaDriver::nfglNamedProgramLocalParameter4dEXT(GLuint program, GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	D(bug("nfosmesa: glNamedProgramLocalParameter4dEXT(%u, %s, %u, %f, %f, %f, %f)", program, gl_enum_name(target), index, x, y, z, w));
	fn.glNamedProgramLocalParameter4dEXT(program, target, index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNamedProgramLocalParameter4dvEXT(GLuint program, GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglNamedProgramLocalParameter4dvEXT(GLuint program, GLenum target, GLuint index, const GLdouble *params)
#endif
{
	D(bug("nfosmesa: glNamedProgramLocalParameter4dvEXT(%u, %s, %u, " PRI_PTR ")", program, gl_enum_name(target), index, AtariOffset(params)));
FN_GLNAMEDPROGRAMLOCALPARAMETER4DVEXT(program, target, index, params);
}

void OSMesaDriver::nfglNamedProgramLocalParameter4fEXT(GLuint program, GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	D(bug("nfosmesa: glNamedProgramLocalParameter4fEXT(%u, %s, %u, %f, %f, %f, %f)", program, gl_enum_name(target), index, x, y, z, w));
	fn.glNamedProgramLocalParameter4fEXT(program, target, index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNamedProgramLocalParameter4fvEXT(GLuint program, GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglNamedProgramLocalParameter4fvEXT(GLuint program, GLenum target, GLuint index, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glNamedProgramLocalParameter4fvEXT(%u, %s, %u, " PRI_PTR ")", program, gl_enum_name(target), index, AtariOffset(params)));
FN_GLNAMEDPROGRAMLOCALPARAMETER4FVEXT(program, target, index, params);
}

void OSMesaDriver::nfglNamedProgramLocalParameterI4iEXT(GLuint program, GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w)
{
	D(bug("nfosmesa: glNamedProgramLocalParameterI4iEXT(%u, %s, %u, %d, %d, %d, %d)", program, gl_enum_name(target), index, x, y, z, w));
	fn.glNamedProgramLocalParameterI4iEXT(program, target, index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNamedProgramLocalParameterI4ivEXT(GLuint program, GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglNamedProgramLocalParameterI4ivEXT(GLuint program, GLenum target, GLuint index, const GLint *params)
#endif
{
	D(bug("nfosmesa: glNamedProgramLocalParameterI4ivEXT(%u, %s, %u, " PRI_PTR ")", program, gl_enum_name(target), index, AtariOffset(params)));
FN_GLNAMEDPROGRAMLOCALPARAMETERI4IVEXT(program, target, index, params);
}

void OSMesaDriver::nfglNamedProgramLocalParameterI4uiEXT(GLuint program, GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
	D(bug("nfosmesa: glNamedProgramLocalParameterI4uiEXT(%u, %s, %u, %u, %u, %u, %u)", program, gl_enum_name(target), index, x, y, z, w));
	fn.glNamedProgramLocalParameterI4uiEXT(program, target, index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNamedProgramLocalParameterI4uivEXT(GLuint program, GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglNamedProgramLocalParameterI4uivEXT(GLuint program, GLenum target, GLuint index, const GLuint *params)
#endif
{
	D(bug("nfosmesa: glNamedProgramLocalParameterI4uivEXT(%u, %s, %u, " PRI_PTR ")", program, gl_enum_name(target), index, AtariOffset(params)));
FN_GLNAMEDPROGRAMLOCALPARAMETERI4UIVEXT(program, target, index, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNamedProgramLocalParameters4fvEXT(GLuint program, GLenum target, GLuint index, GLsizei count, memptr params)
#else
void OSMesaDriver::nfglNamedProgramLocalParameters4fvEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glNamedProgramLocalParameters4fvEXT(%u, %s, %u, %d, " PRI_PTR ")", program, gl_enum_name(target), index, count, AtariOffset(params)));
FN_GLNAMEDPROGRAMLOCALPARAMETERS4FVEXT(program, target, index, count, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNamedProgramLocalParametersI4ivEXT(GLuint program, GLenum target, GLuint index, GLsizei count, memptr params)
#else
void OSMesaDriver::nfglNamedProgramLocalParametersI4ivEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLint *params)
#endif
{
	D(bug("nfosmesa: glNamedProgramLocalParametersI4ivEXT(%u, %s, %u, %d, " PRI_PTR ")", program, gl_enum_name(target), index, count, AtariOffset(params)));
FN_GLNAMEDPROGRAMLOCALPARAMETERSI4IVEXT(program, target, index, count, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNamedProgramLocalParametersI4uivEXT(GLuint program, GLenum target, GLuint index, GLsizei count, memptr params)
#else
void OSMesaDriver::nfglNamedProgramLocalParametersI4uivEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint *params)
#endif
{
	D(bug("nfosmesa: glNamedProgramLocalParametersI4uivEXT(%u, %s, %u, %d, " PRI_PTR ")", program, gl_enum_name(target), index, count, AtariOffset(params)));
FN_GLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXT(program, target, index, count, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNamedProgramStringEXT(GLuint program, GLenum target, GLenum format, GLsizei len, memptr string)
#else
void OSMesaDriver::nfglNamedProgramStringEXT(GLuint program, GLenum target, GLenum format, GLsizei len, const void *string)
#endif
{
	D(bug("nfosmesa: glNamedProgramStringEXT(%u, %s, %s, %d, " PRI_PTR ")", program, gl_enum_name(target), gl_enum_name(format), len, AtariOffset(string)));
FN_GLNAMEDPROGRAMSTRINGEXT(program, target, format, len, string);
}

void OSMesaDriver::nfglNamedRenderbufferStorage(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glNamedRenderbufferStorage(%u, %s, %d, %d)", renderbuffer, gl_enum_name(internalformat), width, height));
	fn.glNamedRenderbufferStorage(renderbuffer, internalformat, width, height);
}

void OSMesaDriver::nfglNamedRenderbufferStorageEXT(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glNamedRenderbufferStorageEXT(%u, %s, %d, %d)", renderbuffer, gl_enum_name(internalformat), width, height));
	fn.glNamedRenderbufferStorageEXT(renderbuffer, internalformat, width, height);
}

void OSMesaDriver::nfglNamedRenderbufferStorageMultisample(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glNamedRenderbufferStorageMultisample(%u, %d, %s, %d, %d)", renderbuffer, samples, gl_enum_name(internalformat), width, height));
	fn.glNamedRenderbufferStorageMultisample(renderbuffer, samples, internalformat, width, height);
}

void OSMesaDriver::nfglNamedRenderbufferStorageMultisampleCoverageEXT(GLuint renderbuffer, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glNamedRenderbufferStorageMultisampleCoverageEXT(%u, %d, %d, %s, %d, %d)", renderbuffer, coverageSamples, colorSamples, gl_enum_name(internalformat), width, height));
	fn.glNamedRenderbufferStorageMultisampleCoverageEXT(renderbuffer, coverageSamples, colorSamples, internalformat, width, height);
}

void OSMesaDriver::nfglNamedRenderbufferStorageMultisampleEXT(GLuint renderbuffer, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glNamedRenderbufferStorageMultisampleEXT(%u, %d, %s, %d, %d)", renderbuffer, samples, gl_enum_name(internalformat), width, height));
	fn.glNamedRenderbufferStorageMultisampleEXT(renderbuffer, samples, internalformat, width, height);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNamedStringARB(GLenum type, GLint namelen, memptr name, GLint stringlen, memptr string)
#else
void OSMesaDriver::nfglNamedStringARB(GLenum type, GLint namelen, const GLchar *name, GLint stringlen, const GLchar *string)
#endif
{
	D(bug("nfosmesa: glNamedStringARB(%s, %d, " PRI_PTR ", %d, " PRI_PTR ")", gl_enum_name(type), namelen, AtariOffset(name), stringlen, AtariOffset(string)));
FN_GLNAMEDSTRINGARB(type, namelen, name, stringlen, string);
}

void OSMesaDriver::nfglNewList(GLuint list, GLenum mode)
{
	D(bug("nfosmesa: glNewList(%u, %s)", list, gl_enum_name(mode)));
	fn.glNewList(list, mode);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLuint OSMesaDriver::nfglNewObjectBufferATI(GLsizei size, memptr pointer, GLenum usage)
#else
GLuint OSMesaDriver::nfglNewObjectBufferATI(GLsizei size, const void *pointer, GLenum usage)
#endif
{
	D(bug("nfosmesa: glNewObjectBufferATI(%d, " PRI_PTR ", %s)", size, AtariOffset(pointer), gl_enum_name(usage)));
FN_GLNEWOBJECTBUFFERATI(size, pointer, usage);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNewTraceMESA(GLbitfield mask, memptr traceName)
#else
void OSMesaDriver::nfglNewTraceMESA(GLbitfield mask, const GLubyte *traceName)
#endif
{
	D(bug("nfosmesa: glNewTraceMESA(0x%x, " PRI_PTR ")", mask, AtariOffset(traceName)));
FN_GLNEWTRACEMESA(mask, traceName);
}

void OSMesaDriver::nfglNormal3b(GLbyte32 nx, GLbyte32 ny, GLbyte32 nz)
{
	D(bug("nfosmesa: glNormal3b(%d, %d, %d)", nx, ny, nz));
	fn.glNormal3b(nx, ny, nz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNormal3bv(memptr v)
#else
void OSMesaDriver::nfglNormal3bv(const GLbyte *v)
#endif
{
	D(bug("nfosmesa: glNormal3bv(" PRI_PTR ")", AtariOffset(v)));
FN_GLNORMAL3BV(v);
}

void OSMesaDriver::nfglNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
{
	D(bug("nfosmesa: glNormal3d(%f, %f, %f)", nx, ny, nz));
	fn.glNormal3d(nx, ny, nz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNormal3dv(memptr v)
#else
void OSMesaDriver::nfglNormal3dv(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glNormal3dv(" PRI_PTR ")", AtariOffset(v)));
FN_GLNORMAL3DV(v);
}

void OSMesaDriver::nfglNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
{
	D(bug("nfosmesa: glNormal3f(%f, %f, %f)", nx, ny, nz));
	fn.glNormal3f(nx, ny, nz);
}

void OSMesaDriver::nfglNormal3fVertex3fSUN(GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glNormal3fVertex3fSUN(%f, %f, %f, %f, %f, %f)", nx, ny, nz, x, y, z));
	fn.glNormal3fVertex3fSUN(nx, ny, nz, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNormal3fVertex3fvSUN(memptr n, memptr v)
#else
void OSMesaDriver::nfglNormal3fVertex3fvSUN(const GLfloat *n, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glNormal3fVertex3fvSUN(" PRI_PTR ", " PRI_PTR ")", AtariOffset(n), AtariOffset(v)));
FN_GLNORMAL3FVERTEX3FVSUN(n, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNormal3fv(memptr v)
#else
void OSMesaDriver::nfglNormal3fv(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glNormal3fv(" PRI_PTR ")", AtariOffset(v)));
FN_GLNORMAL3FV(v);
}

void OSMesaDriver::nfglNormal3hNV(GLhalfNV32 nx, GLhalfNV32 ny, GLhalfNV32 nz)
{
	D(bug("nfosmesa: glNormal3hNV(%u, %u, %u)", nx, ny, nz));
	fn.glNormal3hNV(nx, ny, nz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNormal3hvNV(memptr v)
#else
void OSMesaDriver::nfglNormal3hvNV(const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glNormal3hvNV(" PRI_PTR ")", AtariOffset(v)));
FN_GLNORMAL3HVNV(v);
}

void OSMesaDriver::nfglNormal3i(GLint nx, GLint ny, GLint nz)
{
	D(bug("nfosmesa: glNormal3i(%d, %d, %d)", nx, ny, nz));
	fn.glNormal3i(nx, ny, nz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNormal3iv(memptr v)
#else
void OSMesaDriver::nfglNormal3iv(const GLint *v)
#endif
{
	D(bug("nfosmesa: glNormal3iv(" PRI_PTR ")", AtariOffset(v)));
FN_GLNORMAL3IV(v);
}

void OSMesaDriver::nfglNormal3s(GLshort32 nx, GLshort32 ny, GLshort32 nz)
{
	D(bug("nfosmesa: glNormal3s(%d, %d, %d)", nx, ny, nz));
	fn.glNormal3s(nx, ny, nz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNormal3sv(memptr v)
#else
void OSMesaDriver::nfglNormal3sv(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glNormal3sv(" PRI_PTR ")", AtariOffset(v)));
FN_GLNORMAL3SV(v);
}

void OSMesaDriver::nfglNormal3xOES(GLfixed nx, GLfixed ny, GLfixed nz)
{
	D(bug("nfosmesa: glNormal3xOES(0x%x, 0x%x, 0x%x)", nx, ny, nz));
	fn.glNormal3xOES(nx, ny, nz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNormal3xvOES(memptr coords)
#else
void OSMesaDriver::nfglNormal3xvOES(const GLfixed *coords)
#endif
{
	D(bug("nfosmesa: glNormal3xvOES(" PRI_PTR ")", AtariOffset(coords)));
FN_GLNORMAL3XVOES(coords);
}

void OSMesaDriver::nfglNormalFormatNV(GLenum type, GLsizei stride)
{
	D(bug("nfosmesa: glNormalFormatNV(%s, %d)", gl_enum_name(type), stride));
	fn.glNormalFormatNV(type, stride);
}

void OSMesaDriver::nfglNormalP3ui(GLenum type, GLuint coords)
{
	D(bug("nfosmesa: glNormalP3ui(%s, %u)", gl_enum_name(type), coords));
	fn.glNormalP3ui(type, coords);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNormalP3uiv(GLenum type, memptr coords)
#else
void OSMesaDriver::nfglNormalP3uiv(GLenum type, const GLuint *coords)
#endif
{
	D(bug("nfosmesa: glNormalP3uiv(%s, " PRI_PTR ")", gl_enum_name(type), AtariOffset(coords)));
FN_GLNORMALP3UIV(type, coords);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNormalPointer(GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
#endif
{
	D(bug("nfosmesa: glNormalPointer(%s, %d, " PRI_PTR ")", gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLNORMALPOINTER(type, stride, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, memptr pointer)
#else
void OSMesaDriver::nfglNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const void *pointer)
#endif
{
	D(bug("nfosmesa: glNormalPointerEXT(%s, %d, %d, " PRI_PTR ")", gl_enum_name(type), stride, count, AtariOffset(pointer)));
FN_GLNORMALPOINTEREXT(type, stride, count, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNormalPointerListIBM(GLenum type, GLint stride, memptr pointer, GLint ptrstride)
#else
void OSMesaDriver::nfglNormalPointerListIBM(GLenum type, GLint stride, const void * *pointer, GLint ptrstride)
#endif
{
	D(bug("nfosmesa: glNormalPointerListIBM(%s, %d, " PRI_PTR ", %d)", gl_enum_name(type), stride, AtariOffset(pointer), ptrstride));
FN_GLNORMALPOINTERLISTIBM(type, stride, pointer, ptrstride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNormalPointervINTEL(GLenum type, memptr pointer)
#else
void OSMesaDriver::nfglNormalPointervINTEL(GLenum type, const void * *pointer)
#endif
{
	D(bug("nfosmesa: glNormalPointervINTEL(%s, " PRI_PTR ")", gl_enum_name(type), AtariOffset(pointer)));
FN_GLNORMALPOINTERVINTEL(type, pointer);
}

void OSMesaDriver::nfglNormalStream3bATI(GLenum stream, GLbyte32 nx, GLbyte32 ny, GLbyte32 nz)
{
	D(bug("nfosmesa: glNormalStream3bATI(%s, %d, %d, %d)", gl_enum_name(stream), nx, ny, nz));
	fn.glNormalStream3bATI(stream, nx, ny, nz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNormalStream3bvATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglNormalStream3bvATI(GLenum stream, const GLbyte *coords)
#endif
{
	D(bug("nfosmesa: glNormalStream3bvATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLNORMALSTREAM3BVATI(stream, coords);
}

void OSMesaDriver::nfglNormalStream3dATI(GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz)
{
	D(bug("nfosmesa: glNormalStream3dATI(%s, %f, %f, %f)", gl_enum_name(stream), nx, ny, nz));
	fn.glNormalStream3dATI(stream, nx, ny, nz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNormalStream3dvATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglNormalStream3dvATI(GLenum stream, const GLdouble *coords)
#endif
{
	D(bug("nfosmesa: glNormalStream3dvATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLNORMALSTREAM3DVATI(stream, coords);
}

void OSMesaDriver::nfglNormalStream3fATI(GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz)
{
	D(bug("nfosmesa: glNormalStream3fATI(%s, %f, %f, %f)", gl_enum_name(stream), nx, ny, nz));
	fn.glNormalStream3fATI(stream, nx, ny, nz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNormalStream3fvATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglNormalStream3fvATI(GLenum stream, const GLfloat *coords)
#endif
{
	D(bug("nfosmesa: glNormalStream3fvATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLNORMALSTREAM3FVATI(stream, coords);
}

void OSMesaDriver::nfglNormalStream3iATI(GLenum stream, GLint nx, GLint ny, GLint nz)
{
	D(bug("nfosmesa: glNormalStream3iATI(%s, %d, %d, %d)", gl_enum_name(stream), nx, ny, nz));
	fn.glNormalStream3iATI(stream, nx, ny, nz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNormalStream3ivATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglNormalStream3ivATI(GLenum stream, const GLint *coords)
#endif
{
	D(bug("nfosmesa: glNormalStream3ivATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLNORMALSTREAM3IVATI(stream, coords);
}

void OSMesaDriver::nfglNormalStream3sATI(GLenum stream, GLshort32 nx, GLshort32 ny, GLshort32 nz)
{
	D(bug("nfosmesa: glNormalStream3sATI(%s, %d, %d, %d)", gl_enum_name(stream), nx, ny, nz));
	fn.glNormalStream3sATI(stream, nx, ny, nz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglNormalStream3svATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglNormalStream3svATI(GLenum stream, const GLshort *coords)
#endif
{
	D(bug("nfosmesa: glNormalStream3svATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLNORMALSTREAM3SVATI(stream, coords);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglObjectLabel(GLenum identifier, GLuint name, GLsizei length, memptr label)
#else
void OSMesaDriver::nfglObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
#endif
{
	D(bug("nfosmesa: glObjectLabel(%s, %u, %d, " PRI_PTR ")", gl_enum_name(identifier), name, length, AtariOffset(label)));
FN_GLOBJECTLABEL(identifier, name, length, label);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglObjectPtrLabel(memptr ptr, GLsizei length, memptr label)
#else
void OSMesaDriver::nfglObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label)
#endif
{
	D(bug("nfosmesa: glObjectPtrLabel(" PRI_PTR ", %d, " PRI_PTR ")", AtariOffset(ptr), length, AtariOffset(label)));
FN_GLOBJECTPTRLABEL(ptr, length, label);
}

GLenum OSMesaDriver::nfglObjectPurgeableAPPLE(GLenum objectType, GLuint name, GLenum option)
{
	D(bug("nfosmesa: glObjectPurgeableAPPLE(%s, %u, %s)", gl_enum_name(objectType), name, gl_enum_name(option)));
	GLenum __ret = fn.glObjectPurgeableAPPLE(objectType, name, option);
	return __ret;
}

GLenum OSMesaDriver::nfglObjectUnpurgeableAPPLE(GLenum objectType, GLuint name, GLenum option)
{
	D(bug("nfosmesa: glObjectUnpurgeableAPPLE(%s, %u, %s)", gl_enum_name(objectType), name, gl_enum_name(option)));
	GLenum __ret = fn.glObjectUnpurgeableAPPLE(objectType, name, option);
	return __ret;
}

void OSMesaDriver::nfglOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
	D(bug("nfosmesa: glOrtho(%f, %f, %f, %f, %f, %f)", left, right, bottom, top, zNear, zFar));
	fn.glOrtho(left, right, bottom, top, zNear, zFar);
}

void OSMesaDriver::nfglOrthofOES(GLfloat l, GLfloat r, GLfloat b, GLfloat t, GLfloat n, GLfloat f)
{
	D(bug("nfosmesa: glOrthofOES(%f, %f, %f, %f, %f, %f)", l, r, b, t, n, f));
	fn.glOrthofOES(l, r, b, t, n, f);
}

void OSMesaDriver::nfglOrthoxOES(GLfixed l, GLfixed r, GLfixed b, GLfixed t, GLfixed n, GLfixed f)
{
	D(bug("nfosmesa: glOrthoxOES(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x)", l, r, b, t, n, f));
	fn.glOrthoxOES(l, r, b, t, n, f);
}

void OSMesaDriver::nfglPNTrianglesfATI(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glPNTrianglesfATI(%s, %f)", gl_enum_name(pname), param));
	fn.glPNTrianglesfATI(pname, param);
}

void OSMesaDriver::nfglPNTrianglesiATI(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glPNTrianglesiATI(%s, %d)", gl_enum_name(pname), param));
	fn.glPNTrianglesiATI(pname, param);
}

void OSMesaDriver::nfglPassTexCoordATI(GLuint dst, GLuint coord, GLenum swizzle)
{
	D(bug("nfosmesa: glPassTexCoordATI(%u, %u, %s)", dst, coord, gl_enum_name(swizzle)));
	fn.glPassTexCoordATI(dst, coord, swizzle);
}

void OSMesaDriver::nfglPassThrough(GLfloat token)
{
	D(bug("nfosmesa: glPassThrough(%f)", token));
	fn.glPassThrough(token);
}

void OSMesaDriver::nfglPassThroughxOES(GLfixed token)
{
	D(bug("nfosmesa: glPassThroughxOES(0x%x)", token));
	fn.glPassThroughxOES(token);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPatchParameterfv(GLenum pname, memptr values)
#else
void OSMesaDriver::nfglPatchParameterfv(GLenum pname, const GLfloat *values)
#endif
{
	D(bug("nfosmesa: glPatchParameterfv(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(values)));
FN_GLPATCHPARAMETERFV(pname, values);
}

void OSMesaDriver::nfglPatchParameteri(GLenum pname, GLint value)
{
	D(bug("nfosmesa: glPatchParameteri(%s, %d)", gl_enum_name(pname), value));
	fn.glPatchParameteri(pname, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPathColorGenNV(GLenum color, GLenum genMode, GLenum colorFormat, memptr coeffs)
#else
void OSMesaDriver::nfglPathColorGenNV(GLenum color, GLenum genMode, GLenum colorFormat, const GLfloat *coeffs)
#endif
{
	D(bug("nfosmesa: glPathColorGenNV(%s, %s, %s, " PRI_PTR ")", gl_enum_name(color), gl_enum_name(genMode), gl_enum_name(colorFormat), AtariOffset(coeffs)));
FN_GLPATHCOLORGENNV(color, genMode, colorFormat, coeffs);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPathCommandsNV(GLuint path, GLsizei numCommands, memptr commands, GLsizei numCoords, GLenum coordType, memptr coords)
#else
void OSMesaDriver::nfglPathCommandsNV(GLuint path, GLsizei numCommands, const GLubyte *commands, GLsizei numCoords, GLenum coordType, const void *coords)
#endif
{
	D(bug("nfosmesa: glPathCommandsNV(%u, %d, " PRI_PTR ", %d, %s, " PRI_PTR ")", path, numCommands, AtariOffset(commands), numCoords, gl_enum_name(coordType), AtariOffset(coords)));
FN_GLPATHCOMMANDSNV(path, numCommands, commands, numCoords, coordType, coords);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPathCoordsNV(GLuint path, GLsizei numCoords, GLenum coordType, memptr coords)
#else
void OSMesaDriver::nfglPathCoordsNV(GLuint path, GLsizei numCoords, GLenum coordType, const void *coords)
#endif
{
	D(bug("nfosmesa: glPathCoordsNV(%u, %d, %s, " PRI_PTR ")", path, numCoords, gl_enum_name(coordType), AtariOffset(coords)));
FN_GLPATHCOORDSNV(path, numCoords, coordType, coords);
}

void OSMesaDriver::nfglPathCoverDepthFuncNV(GLenum func)
{
	D(bug("nfosmesa: glPathCoverDepthFuncNV(%s)", gl_enum_name(func)));
	fn.glPathCoverDepthFuncNV(func);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPathDashArrayNV(GLuint path, GLsizei dashCount, memptr dashArray)
#else
void OSMesaDriver::nfglPathDashArrayNV(GLuint path, GLsizei dashCount, const GLfloat *dashArray)
#endif
{
	D(bug("nfosmesa: glPathDashArrayNV(%u, %d, " PRI_PTR ")", path, dashCount, AtariOffset(dashArray)));
FN_GLPATHDASHARRAYNV(path, dashCount, dashArray);
}

void OSMesaDriver::nfglPathFogGenNV(GLenum genMode)
{
	D(bug("nfosmesa: glPathFogGenNV(%s)", gl_enum_name(genMode)));
	fn.glPathFogGenNV(genMode);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLenum OSMesaDriver::nfglPathGlyphIndexArrayNV(GLuint firstPathName, GLenum fontTarget, memptr fontName, GLbitfield fontStyle, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale)
#else
GLenum OSMesaDriver::nfglPathGlyphIndexArrayNV(GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale)
#endif
{
	D(bug("nfosmesa: glPathGlyphIndexArrayNV(%u, %s, " PRI_PTR ", 0x%x, %u, %d, %u, %f)", firstPathName, gl_enum_name(fontTarget), AtariOffset(fontName), fontStyle, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale));
FN_GLPATHGLYPHINDEXARRAYNV(firstPathName, fontTarget, fontName, fontStyle, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLenum OSMesaDriver::nfglPathGlyphIndexRangeNV(GLenum fontTarget, memptr fontName, GLbitfield fontStyle, GLuint pathParameterTemplate, GLfloat emScale, memptr baseAndCount)
#else
GLenum OSMesaDriver::nfglPathGlyphIndexRangeNV(GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint pathParameterTemplate, GLfloat emScale, GLuint *baseAndCount)
#endif
{
	D(bug("nfosmesa: glPathGlyphIndexRangeNV(%s, " PRI_PTR ", 0x%x, %u, %f, " PRI_PTR ")", gl_enum_name(fontTarget), AtariOffset(fontName), fontStyle, pathParameterTemplate, emScale, AtariOffset(baseAndCount)));
FN_GLPATHGLYPHINDEXRANGENV(fontTarget, fontName, fontStyle, pathParameterTemplate, emScale, baseAndCount);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPathGlyphRangeNV(GLuint firstPathName, GLenum fontTarget, memptr fontName, GLbitfield fontStyle, GLuint firstGlyph, GLsizei numGlyphs, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale)
#else
void OSMesaDriver::nfglPathGlyphRangeNV(GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint firstGlyph, GLsizei numGlyphs, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale)
#endif
{
	D(bug("nfosmesa: glPathGlyphRangeNV(%u, %s, " PRI_PTR ", 0x%x, %u, %d, %s, %u, %f)", firstPathName, gl_enum_name(fontTarget), AtariOffset(fontName), fontStyle, firstGlyph, numGlyphs, gl_enum_name(handleMissingGlyphs), pathParameterTemplate, emScale));
FN_GLPATHGLYPHRANGENV(firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPathGlyphsNV(GLuint firstPathName, GLenum fontTarget, memptr fontName, GLbitfield fontStyle, GLsizei numGlyphs, GLenum type, memptr charcodes, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale)
#else
void OSMesaDriver::nfglPathGlyphsNV(GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLsizei numGlyphs, GLenum type, const void *charcodes, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale)
#endif
{
	D(bug("nfosmesa: glPathGlyphsNV(%u, %s, " PRI_PTR ", 0x%x, %d, %s, " PRI_PTR ", %s, %u, %f)", firstPathName, gl_enum_name(fontTarget), AtariOffset(fontName), fontStyle, numGlyphs, gl_enum_name(type), AtariOffset(charcodes), gl_enum_name(handleMissingGlyphs), pathParameterTemplate, emScale));
FN_GLPATHGLYPHSNV(firstPathName, fontTarget, fontName, fontStyle, numGlyphs, type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLenum OSMesaDriver::nfglPathMemoryGlyphIndexArrayNV(GLuint firstPathName, GLenum fontTarget, GLsizeiptr fontSize, memptr fontData, GLsizei faceIndex, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale)
#else
GLenum OSMesaDriver::nfglPathMemoryGlyphIndexArrayNV(GLuint firstPathName, GLenum fontTarget, GLsizeiptr fontSize, const void *fontData, GLsizei faceIndex, GLuint firstGlyphIndex, GLsizei numGlyphs, GLuint pathParameterTemplate, GLfloat emScale)
#endif
{
	D(bug("nfosmesa: glPathMemoryGlyphIndexArrayNV(%u, %s, %" PRI_IPTR ", " PRI_PTR ", %d, %u, %d, %u, %f)", firstPathName, gl_enum_name(fontTarget), fontSize, AtariOffset(fontData), faceIndex, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale));
FN_GLPATHMEMORYGLYPHINDEXARRAYNV(firstPathName, fontTarget, fontSize, fontData, faceIndex, firstGlyphIndex, numGlyphs, pathParameterTemplate, emScale);
}

void OSMesaDriver::nfglPathParameterfNV(GLuint path, GLenum pname, GLfloat value)
{
	D(bug("nfosmesa: glPathParameterfNV(%u, %s, %f)", path, gl_enum_name(pname), value));
	fn.glPathParameterfNV(path, pname, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPathParameterfvNV(GLuint path, GLenum pname, memptr value)
#else
void OSMesaDriver::nfglPathParameterfvNV(GLuint path, GLenum pname, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glPathParameterfvNV(%u, %s, " PRI_PTR ")", path, gl_enum_name(pname), AtariOffset(value)));
FN_GLPATHPARAMETERFVNV(path, pname, value);
}

void OSMesaDriver::nfglPathParameteriNV(GLuint path, GLenum pname, GLint value)
{
	D(bug("nfosmesa: glPathParameteriNV(%u, %s, %d)", path, gl_enum_name(pname), value));
	fn.glPathParameteriNV(path, pname, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPathParameterivNV(GLuint path, GLenum pname, memptr value)
#else
void OSMesaDriver::nfglPathParameterivNV(GLuint path, GLenum pname, const GLint *value)
#endif
{
	D(bug("nfosmesa: glPathParameterivNV(%u, %s, " PRI_PTR ")", path, gl_enum_name(pname), AtariOffset(value)));
FN_GLPATHPARAMETERIVNV(path, pname, value);
}

void OSMesaDriver::nfglPathStencilDepthOffsetNV(GLfloat factor, GLfloat units)
{
	D(bug("nfosmesa: glPathStencilDepthOffsetNV(%f, %f)", factor, units));
	fn.glPathStencilDepthOffsetNV(factor, units);
}

void OSMesaDriver::nfglPathStencilFuncNV(GLenum func, GLint ref, GLuint mask)
{
	D(bug("nfosmesa: glPathStencilFuncNV(%s, %d, %u)", gl_enum_name(func), ref, mask));
	fn.glPathStencilFuncNV(func, ref, mask);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPathStringNV(GLuint path, GLenum format, GLsizei length, memptr pathString)
#else
void OSMesaDriver::nfglPathStringNV(GLuint path, GLenum format, GLsizei length, const void *pathString)
#endif
{
	D(bug("nfosmesa: glPathStringNV(%u, %s, %d, " PRI_PTR ")", path, gl_enum_name(format), length, AtariOffset(pathString)));
FN_GLPATHSTRINGNV(path, format, length, pathString);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPathSubCommandsNV(GLuint path, GLsizei commandStart, GLsizei commandsToDelete, GLsizei numCommands, memptr commands, GLsizei numCoords, GLenum coordType, memptr coords)
#else
void OSMesaDriver::nfglPathSubCommandsNV(GLuint path, GLsizei commandStart, GLsizei commandsToDelete, GLsizei numCommands, const GLubyte *commands, GLsizei numCoords, GLenum coordType, const void *coords)
#endif
{
	D(bug("nfosmesa: glPathSubCommandsNV(%u, %d, %d, %d, " PRI_PTR ", %d, %s, " PRI_PTR ")", path, commandStart, commandsToDelete, numCommands, AtariOffset(commands), numCoords, gl_enum_name(coordType), AtariOffset(coords)));
FN_GLPATHSUBCOMMANDSNV(path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPathSubCoordsNV(GLuint path, GLsizei coordStart, GLsizei numCoords, GLenum coordType, memptr coords)
#else
void OSMesaDriver::nfglPathSubCoordsNV(GLuint path, GLsizei coordStart, GLsizei numCoords, GLenum coordType, const void *coords)
#endif
{
	D(bug("nfosmesa: glPathSubCoordsNV(%u, %d, %d, %s, " PRI_PTR ")", path, coordStart, numCoords, gl_enum_name(coordType), AtariOffset(coords)));
FN_GLPATHSUBCOORDSNV(path, coordStart, numCoords, coordType, coords);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPathTexGenNV(GLenum texCoordSet, GLenum genMode, GLint components, memptr coeffs)
#else
void OSMesaDriver::nfglPathTexGenNV(GLenum texCoordSet, GLenum genMode, GLint components, const GLfloat *coeffs)
#endif
{
	D(bug("nfosmesa: glPathTexGenNV(%s, %s, %d, " PRI_PTR ")", gl_enum_name(texCoordSet), gl_enum_name(genMode), components, AtariOffset(coeffs)));
FN_GLPATHTEXGENNV(texCoordSet, genMode, components, coeffs);
}

void OSMesaDriver::nfglPauseTransformFeedback(void)
{
	D(bug("nfosmesa: glPauseTransformFeedback()"));
	fn.glPauseTransformFeedback();
}

void OSMesaDriver::nfglPauseTransformFeedbackNV(void)
{
	D(bug("nfosmesa: glPauseTransformFeedbackNV()"));
	fn.glPauseTransformFeedbackNV();
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPixelDataRangeNV(GLenum target, GLsizei length, memptr pointer)
#else
void OSMesaDriver::nfglPixelDataRangeNV(GLenum target, GLsizei length, const void *pointer)
#endif
{
	D(bug("nfosmesa: glPixelDataRangeNV(%s, %d, " PRI_PTR ")", gl_enum_name(target), length, AtariOffset(pointer)));
FN_GLPIXELDATARANGENV(target, length, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPixelMapfv(GLenum map, GLsizei mapsize, memptr values)
#else
void OSMesaDriver::nfglPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
#endif
{
	D(bug("nfosmesa: glPixelMapfv(%s, %d, " PRI_PTR ")", gl_enum_name(map), mapsize, AtariOffset(values)));
FN_GLPIXELMAPFV(map, mapsize, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPixelMapuiv(GLenum map, GLsizei mapsize, memptr values)
#else
void OSMesaDriver::nfglPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
#endif
{
	D(bug("nfosmesa: glPixelMapuiv(%s, %d, " PRI_PTR ")", gl_enum_name(map), mapsize, AtariOffset(values)));
FN_GLPIXELMAPUIV(map, mapsize, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPixelMapusv(GLenum map, GLsizei mapsize, memptr values)
#else
void OSMesaDriver::nfglPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
#endif
{
	D(bug("nfosmesa: glPixelMapusv(%s, %d, " PRI_PTR ")", gl_enum_name(map), mapsize, AtariOffset(values)));
FN_GLPIXELMAPUSV(map, mapsize, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPixelMapx(GLenum map, GLint size, memptr values)
#else
void OSMesaDriver::nfglPixelMapx(GLenum map, GLint size, const GLfixed *values)
#endif
{
	D(bug("nfosmesa: glPixelMapx(%s, %d, " PRI_PTR ")", gl_enum_name(map), size, AtariOffset(values)));
FN_GLPIXELMAPX(map, size, values);
}

void OSMesaDriver::nfglPixelStoref(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glPixelStoref(%s, %f)", gl_enum_name(pname), param));
	fn.glPixelStoref(pname, param);
}

void OSMesaDriver::nfglPixelStorei(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glPixelStorei(%s, %d)", gl_enum_name(pname), param));
	fn.glPixelStorei(pname, param);
}

void OSMesaDriver::nfglPixelStorex(GLenum pname, GLfixed param)
{
	D(bug("nfosmesa: glPixelStorex(%s, 0x%x)", gl_enum_name(pname), param));
	fn.glPixelStorex(pname, param);
}

void OSMesaDriver::nfglPixelTexGenParameterfSGIS(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glPixelTexGenParameterfSGIS(%s, %f)", gl_enum_name(pname), param));
	fn.glPixelTexGenParameterfSGIS(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPixelTexGenParameterfvSGIS(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglPixelTexGenParameterfvSGIS(GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glPixelTexGenParameterfvSGIS(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLPIXELTEXGENPARAMETERFVSGIS(pname, params);
}

void OSMesaDriver::nfglPixelTexGenParameteriSGIS(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glPixelTexGenParameteriSGIS(%s, %d)", gl_enum_name(pname), param));
	fn.glPixelTexGenParameteriSGIS(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPixelTexGenParameterivSGIS(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglPixelTexGenParameterivSGIS(GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glPixelTexGenParameterivSGIS(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLPIXELTEXGENPARAMETERIVSGIS(pname, params);
}

void OSMesaDriver::nfglPixelTexGenSGIX(GLenum mode)
{
	D(bug("nfosmesa: glPixelTexGenSGIX(%s)", gl_enum_name(mode)));
	fn.glPixelTexGenSGIX(mode);
}

void OSMesaDriver::nfglPixelTransferf(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glPixelTransferf(%s, %f)", gl_enum_name(pname), param));
	fn.glPixelTransferf(pname, param);
}

void OSMesaDriver::nfglPixelTransferi(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glPixelTransferi(%s, %d)", gl_enum_name(pname), param));
	fn.glPixelTransferi(pname, param);
}

void OSMesaDriver::nfglPixelTransferxOES(GLenum pname, GLfixed param)
{
	D(bug("nfosmesa: glPixelTransferxOES(%s, 0x%x)", gl_enum_name(pname), param));
	fn.glPixelTransferxOES(pname, param);
}

void OSMesaDriver::nfglPixelTransformParameterfEXT(GLenum target, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glPixelTransformParameterfEXT(%s, %s, %f)", gl_enum_name(target), gl_enum_name(pname), param));
	fn.glPixelTransformParameterfEXT(target, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPixelTransformParameterfvEXT(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglPixelTransformParameterfvEXT(GLenum target, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glPixelTransformParameterfvEXT(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLPIXELTRANSFORMPARAMETERFVEXT(target, pname, params);
}

void OSMesaDriver::nfglPixelTransformParameteriEXT(GLenum target, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glPixelTransformParameteriEXT(%s, %s, %d)", gl_enum_name(target), gl_enum_name(pname), param));
	fn.glPixelTransformParameteriEXT(target, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPixelTransformParameterivEXT(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglPixelTransformParameterivEXT(GLenum target, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glPixelTransformParameterivEXT(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLPIXELTRANSFORMPARAMETERIVEXT(target, pname, params);
}

void OSMesaDriver::nfglPixelZoom(GLfloat xfactor, GLfloat yfactor)
{
	D(bug("nfosmesa: glPixelZoom(%f, %f)", xfactor, yfactor));
	fn.glPixelZoom(xfactor, yfactor);
}

void OSMesaDriver::nfglPixelZoomxOES(GLfixed xfactor, GLfixed yfactor)
{
	D(bug("nfosmesa: glPixelZoomxOES(0x%x, 0x%x)", xfactor, yfactor));
	fn.glPixelZoomxOES(xfactor, yfactor);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLboolean OSMesaDriver::nfglPointAlongPathNV(GLuint path, GLsizei startSegment, GLsizei numSegments, GLfloat distance, memptr x, memptr y, memptr tangentX, memptr tangentY)
#else
GLboolean OSMesaDriver::nfglPointAlongPathNV(GLuint path, GLsizei startSegment, GLsizei numSegments, GLfloat distance, GLfloat *x, GLfloat *y, GLfloat *tangentX, GLfloat *tangentY)
#endif
{
	D(bug("nfosmesa: glPointAlongPathNV(%u, %d, %d, %f, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", path, startSegment, numSegments, distance, AtariOffset(x), AtariOffset(y), AtariOffset(tangentX), AtariOffset(tangentY)));
FN_GLPOINTALONGPATHNV(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
}

void OSMesaDriver::nfglPointParameterf(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glPointParameterf(%s, %f)", gl_enum_name(pname), param));
	fn.glPointParameterf(pname, param);
}

void OSMesaDriver::nfglPointParameterfARB(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glPointParameterfARB(%s, %f)", gl_enum_name(pname), param));
	fn.glPointParameterfARB(pname, param);
}

void OSMesaDriver::nfglPointParameterfEXT(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glPointParameterfEXT(%s, %f)", gl_enum_name(pname), param));
	fn.glPointParameterfEXT(pname, param);
}

void OSMesaDriver::nfglPointParameterfSGIS(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glPointParameterfSGIS(%s, %f)", gl_enum_name(pname), param));
	fn.glPointParameterfSGIS(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPointParameterfv(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglPointParameterfv(GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glPointParameterfv(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLPOINTPARAMETERFV(pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPointParameterfvARB(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglPointParameterfvARB(GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glPointParameterfvARB(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLPOINTPARAMETERFVARB(pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPointParameterfvEXT(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglPointParameterfvEXT(GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glPointParameterfvEXT(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLPOINTPARAMETERFVEXT(pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPointParameterfvSGIS(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglPointParameterfvSGIS(GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glPointParameterfvSGIS(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLPOINTPARAMETERFVSGIS(pname, params);
}

void OSMesaDriver::nfglPointParameteri(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glPointParameteri(%s, %d)", gl_enum_name(pname), param));
	fn.glPointParameteri(pname, param);
}

void OSMesaDriver::nfglPointParameteriNV(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glPointParameteriNV(%s, %d)", gl_enum_name(pname), param));
	fn.glPointParameteriNV(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPointParameteriv(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglPointParameteriv(GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glPointParameteriv(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLPOINTPARAMETERIV(pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPointParameterivNV(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglPointParameterivNV(GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glPointParameterivNV(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLPOINTPARAMETERIVNV(pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPointParameterxvOES(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglPointParameterxvOES(GLenum pname, const GLfixed *params)
#endif
{
	D(bug("nfosmesa: glPointParameterxvOES(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLPOINTPARAMETERXVOES(pname, params);
}

void OSMesaDriver::nfglPointSize(GLfloat size)
{
	D(bug("nfosmesa: glPointSize(%f)", size));
	fn.glPointSize(size);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPointSizePointerAPPLE(GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglPointSizePointerAPPLE(GLenum type, GLsizei stride, const GLvoid *pointer)
#endif
{
	D(bug("nfosmesa: glPointSizePointerAPPLE(%s, %d, " PRI_PTR ")", gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLPOINTSIZEPOINTERAPPLE(type, stride, pointer);
}

void OSMesaDriver::nfglPointSizexOES(GLfixed size)
{
	D(bug("nfosmesa: glPointSizexOES(0x%x)", size));
	fn.glPointSizexOES(size);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLint OSMesaDriver::nfglPollAsyncSGIX(memptr markerp)
#else
GLint OSMesaDriver::nfglPollAsyncSGIX(GLuint *markerp)
#endif
{
	D(bug("nfosmesa: glPollAsyncSGIX(" PRI_PTR ")", AtariOffset(markerp)));
FN_GLPOLLASYNCSGIX(markerp);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLint OSMesaDriver::nfglPollInstrumentsSGIX(memptr marker_p)
#else
GLint OSMesaDriver::nfglPollInstrumentsSGIX(GLint *marker_p)
#endif
{
	D(bug("nfosmesa: glPollInstrumentsSGIX(" PRI_PTR ")", AtariOffset(marker_p)));
FN_GLPOLLINSTRUMENTSSGIX(marker_p);
}

void OSMesaDriver::nfglPolygonMode(GLenum face, GLenum mode)
{
	D(bug("nfosmesa: glPolygonMode(%s, %s)", gl_enum_name(face), gl_enum_name(mode)));
	fn.glPolygonMode(face, mode);
}

void OSMesaDriver::nfglPolygonOffset(GLfloat factor, GLfloat units)
{
	D(bug("nfosmesa: glPolygonOffset(%f, %f)", factor, units));
	fn.glPolygonOffset(factor, units);
}

void OSMesaDriver::nfglPolygonOffsetClamp(GLfloat factor, GLfloat units, GLfloat clamp)
{
	D(bug("nfosmesa: glPolygonOffsetClamp(%f, %f, %f)", factor, units, clamp));
	fn.glPolygonOffsetClamp(factor, units, clamp);
}

void OSMesaDriver::nfglPolygonOffsetClampEXT(GLfloat factor, GLfloat units, GLfloat clamp)
{
	D(bug("nfosmesa: glPolygonOffsetClampEXT(%f, %f, %f)", factor, units, clamp));
	fn.glPolygonOffsetClampEXT(factor, units, clamp);
}

void OSMesaDriver::nfglPolygonOffsetEXT(GLfloat factor, GLfloat bias)
{
	D(bug("nfosmesa: glPolygonOffsetEXT(%f, %f)", factor, bias));
	fn.glPolygonOffsetEXT(factor, bias);
}

void OSMesaDriver::nfglPolygonOffsetxOES(GLfixed factor, GLfixed units)
{
	D(bug("nfosmesa: glPolygonOffsetxOES(0x%x, 0x%x)", factor, units));
	fn.glPolygonOffsetxOES(factor, units);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPolygonStipple(memptr mask)
#else
void OSMesaDriver::nfglPolygonStipple(const GLubyte *mask)
#endif
{
	D(bug("nfosmesa: glPolygonStipple(" PRI_PTR ")", AtariOffset(mask)));
FN_GLPOLYGONSTIPPLE(mask);
}

void OSMesaDriver::nfglPopAttrib(void)
{
	D(bug("nfosmesa: glPopAttrib()"));
	fn.glPopAttrib();
}

void OSMesaDriver::nfglPopClientAttrib(void)
{
	D(bug("nfosmesa: glPopClientAttrib()"));
	fn.glPopClientAttrib();
}

void OSMesaDriver::nfglPopDebugGroup(void)
{
	D(bug("nfosmesa: glPopDebugGroup()"));
	fn.glPopDebugGroup();
}

void OSMesaDriver::nfglPopGroupMarkerEXT(void)
{
	D(bug("nfosmesa: glPopGroupMarkerEXT()"));
	fn.glPopGroupMarkerEXT();
}

void OSMesaDriver::nfglPopMatrix(void)
{
	D(bug("nfosmesa: glPopMatrix()"));
	fn.glPopMatrix();
}

void OSMesaDriver::nfglPopName(void)
{
	D(bug("nfosmesa: glPopName()"));
	fn.glPopName();
}

void OSMesaDriver::nfglPresentFrameDualFillNV(GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLenum target1, GLuint fill1, GLenum target2, GLuint fill2, GLenum target3, GLuint fill3)
{
	D(bug("nfosmesa: glPresentFrameDualFillNV(%u, %" PRIu64 ", %u, %u, %s, %s, %u, %s, %u, %s, %u, %s, %u)", video_slot, minPresentTime, beginPresentTimeId, presentDurationId, gl_enum_name(type), gl_enum_name(target0), fill0, gl_enum_name(target1), fill1, gl_enum_name(target2), fill2, gl_enum_name(target3), fill3));
	fn.glPresentFrameDualFillNV(video_slot, minPresentTime, beginPresentTimeId, presentDurationId, type, target0, fill0, target1, fill1, target2, fill2, target3, fill3);
}

void OSMesaDriver::nfglPresentFrameKeyedNV(GLuint video_slot, GLuint64EXT minPresentTime, GLuint beginPresentTimeId, GLuint presentDurationId, GLenum type, GLenum target0, GLuint fill0, GLuint key0, GLenum target1, GLuint fill1, GLuint key1)
{
	D(bug("nfosmesa: glPresentFrameKeyedNV(%u, %" PRIu64 ", %u, %u, %s, %s, %u, %u, %s, %u, %u)", video_slot, minPresentTime, beginPresentTimeId, presentDurationId, gl_enum_name(type), gl_enum_name(target0), fill0, key0, gl_enum_name(target1), fill1, key1));
	fn.glPresentFrameKeyedNV(video_slot, minPresentTime, beginPresentTimeId, presentDurationId, type, target0, fill0, key0, target1, fill1, key1);
}

void OSMesaDriver::nfglPrimitiveBoundingBoxARB(GLfloat minX, GLfloat minY, GLfloat minZ, GLfloat minW, GLfloat maxX, GLfloat maxY, GLfloat maxZ, GLfloat maxW)
{
	D(bug("nfosmesa: glPrimitiveBoundingBoxARB(%f, %f, %f, %f, %f, %f, %f, %f)", minX, minY, minZ, minW, maxX, maxY, maxZ, maxW));
	fn.glPrimitiveBoundingBoxARB(minX, minY, minZ, minW, maxX, maxY, maxZ, maxW);
}

void OSMesaDriver::nfglPrimitiveRestartIndex(GLuint index)
{
	D(bug("nfosmesa: glPrimitiveRestartIndex(%u)", index));
	fn.glPrimitiveRestartIndex(index);
}

void OSMesaDriver::nfglPrimitiveRestartIndexNV(GLuint index)
{
	D(bug("nfosmesa: glPrimitiveRestartIndexNV(%u)", index));
	fn.glPrimitiveRestartIndexNV(index);
}

void OSMesaDriver::nfglPrimitiveRestartNV(void)
{
	D(bug("nfosmesa: glPrimitiveRestartNV()"));
	fn.glPrimitiveRestartNV();
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPrioritizeTextures(GLsizei n, memptr textures, memptr priorities)
#else
void OSMesaDriver::nfglPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities)
#endif
{
	D(bug("nfosmesa: glPrioritizeTextures(%d, " PRI_PTR ", " PRI_PTR ")", n, AtariOffset(textures), AtariOffset(priorities)));
FN_GLPRIORITIZETEXTURES(n, textures, priorities);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPrioritizeTexturesEXT(GLsizei n, memptr textures, memptr priorities)
#else
void OSMesaDriver::nfglPrioritizeTexturesEXT(GLsizei n, const GLuint *textures, const GLclampf *priorities)
#endif
{
	D(bug("nfosmesa: glPrioritizeTexturesEXT(%d, " PRI_PTR ", " PRI_PTR ")", n, AtariOffset(textures), AtariOffset(priorities)));
FN_GLPRIORITIZETEXTURESEXT(n, textures, priorities);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPrioritizeTexturesxOES(GLsizei n, memptr textures, memptr priorities)
#else
void OSMesaDriver::nfglPrioritizeTexturesxOES(GLsizei n, const GLuint *textures, const GLfixed *priorities)
#endif
{
	D(bug("nfosmesa: glPrioritizeTexturesxOES(%d, " PRI_PTR ", " PRI_PTR ")", n, AtariOffset(textures), AtariOffset(priorities)));
FN_GLPRIORITIZETEXTURESXOES(n, textures, priorities);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramBinary(GLuint program, GLenum binaryFormat, memptr binary, GLsizei length)
#else
void OSMesaDriver::nfglProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length)
#endif
{
	D(bug("nfosmesa: glProgramBinary(%u, %s, " PRI_PTR ", %d)", program, gl_enum_name(binaryFormat), AtariOffset(binary), length));
FN_GLPROGRAMBINARY(program, binaryFormat, binary, length);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramBufferParametersIivNV(GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, memptr params)
#else
void OSMesaDriver::nfglProgramBufferParametersIivNV(GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLint *params)
#endif
{
	D(bug("nfosmesa: glProgramBufferParametersIivNV(%s, %u, %u, %d, " PRI_PTR ")", gl_enum_name(target), bindingIndex, wordIndex, count, AtariOffset(params)));
FN_GLPROGRAMBUFFERPARAMETERSIIVNV(target, bindingIndex, wordIndex, count, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramBufferParametersIuivNV(GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, memptr params)
#else
void OSMesaDriver::nfglProgramBufferParametersIuivNV(GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLuint *params)
#endif
{
	D(bug("nfosmesa: glProgramBufferParametersIuivNV(%s, %u, %u, %d, " PRI_PTR ")", gl_enum_name(target), bindingIndex, wordIndex, count, AtariOffset(params)));
FN_GLPROGRAMBUFFERPARAMETERSIUIVNV(target, bindingIndex, wordIndex, count, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramBufferParametersfvNV(GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, memptr params)
#else
void OSMesaDriver::nfglProgramBufferParametersfvNV(GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glProgramBufferParametersfvNV(%s, %u, %u, %d, " PRI_PTR ")", gl_enum_name(target), bindingIndex, wordIndex, count, AtariOffset(params)));
FN_GLPROGRAMBUFFERPARAMETERSFVNV(target, bindingIndex, wordIndex, count, params);
}

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramCallbackMESA(GLenum target, memptr callback, memptr data)
#else
void OSMesaDriver::nfglProgramCallbackMESA(GLenum target, GLprogramcallbackMESA callback, GLvoid *data)
#endif
{
	D(bug("nfosmesa: glProgramCallbackMESA(%s, " PRI_PTR ", " PRI_PTR ")", gl_enum_name(target), AtariOffset(callback), AtariOffset(data)));
FN_GLPROGRAMCALLBACKMESA(target, callback, data);
}
#endif

void OSMesaDriver::nfglProgramEnvParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	D(bug("nfosmesa: glProgramEnvParameter4dARB(%s, %u, %f, %f, %f, %f)", gl_enum_name(target), index, x, y, z, w));
	fn.glProgramEnvParameter4dARB(target, index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramEnvParameter4dvARB(GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble *params)
#endif
{
	D(bug("nfosmesa: glProgramEnvParameter4dvARB(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(params)));
FN_GLPROGRAMENVPARAMETER4DVARB(target, index, params);
}

void OSMesaDriver::nfglProgramEnvParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	D(bug("nfosmesa: glProgramEnvParameter4fARB(%s, %u, %f, %f, %f, %f)", gl_enum_name(target), index, x, y, z, w));
	fn.glProgramEnvParameter4fARB(target, index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramEnvParameter4fvARB(GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glProgramEnvParameter4fvARB(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(params)));
FN_GLPROGRAMENVPARAMETER4FVARB(target, index, params);
}

void OSMesaDriver::nfglProgramEnvParameterI4iNV(GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w)
{
	D(bug("nfosmesa: glProgramEnvParameterI4iNV(%s, %u, %d, %d, %d, %d)", gl_enum_name(target), index, x, y, z, w));
	fn.glProgramEnvParameterI4iNV(target, index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramEnvParameterI4ivNV(GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglProgramEnvParameterI4ivNV(GLenum target, GLuint index, const GLint *params)
#endif
{
	D(bug("nfosmesa: glProgramEnvParameterI4ivNV(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(params)));
FN_GLPROGRAMENVPARAMETERI4IVNV(target, index, params);
}

void OSMesaDriver::nfglProgramEnvParameterI4uiNV(GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
	D(bug("nfosmesa: glProgramEnvParameterI4uiNV(%s, %u, %u, %u, %u, %u)", gl_enum_name(target), index, x, y, z, w));
	fn.glProgramEnvParameterI4uiNV(target, index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramEnvParameterI4uivNV(GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglProgramEnvParameterI4uivNV(GLenum target, GLuint index, const GLuint *params)
#endif
{
	D(bug("nfosmesa: glProgramEnvParameterI4uivNV(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(params)));
FN_GLPROGRAMENVPARAMETERI4UIVNV(target, index, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, memptr params)
#else
void OSMesaDriver::nfglProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glProgramEnvParameters4fvEXT(%s, %u, %d, " PRI_PTR ")", gl_enum_name(target), index, count, AtariOffset(params)));
FN_GLPROGRAMENVPARAMETERS4FVEXT(target, index, count, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramEnvParametersI4ivNV(GLenum target, GLuint index, GLsizei count, memptr params)
#else
void OSMesaDriver::nfglProgramEnvParametersI4ivNV(GLenum target, GLuint index, GLsizei count, const GLint *params)
#endif
{
	D(bug("nfosmesa: glProgramEnvParametersI4ivNV(%s, %u, %d, " PRI_PTR ")", gl_enum_name(target), index, count, AtariOffset(params)));
FN_GLPROGRAMENVPARAMETERSI4IVNV(target, index, count, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramEnvParametersI4uivNV(GLenum target, GLuint index, GLsizei count, memptr params)
#else
void OSMesaDriver::nfglProgramEnvParametersI4uivNV(GLenum target, GLuint index, GLsizei count, const GLuint *params)
#endif
{
	D(bug("nfosmesa: glProgramEnvParametersI4uivNV(%s, %u, %d, " PRI_PTR ")", gl_enum_name(target), index, count, AtariOffset(params)));
FN_GLPROGRAMENVPARAMETERSI4UIVNV(target, index, count, params);
}

void OSMesaDriver::nfglProgramLocalParameter4dARB(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	D(bug("nfosmesa: glProgramLocalParameter4dARB(%s, %u, %f, %f, %f, %f)", gl_enum_name(target), index, x, y, z, w));
	fn.glProgramLocalParameter4dARB(target, index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramLocalParameter4dvARB(GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble *params)
#endif
{
	D(bug("nfosmesa: glProgramLocalParameter4dvARB(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(params)));
FN_GLPROGRAMLOCALPARAMETER4DVARB(target, index, params);
}

void OSMesaDriver::nfglProgramLocalParameter4fARB(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	D(bug("nfosmesa: glProgramLocalParameter4fARB(%s, %u, %f, %f, %f, %f)", gl_enum_name(target), index, x, y, z, w));
	fn.glProgramLocalParameter4fARB(target, index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramLocalParameter4fvARB(GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glProgramLocalParameter4fvARB(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(params)));
FN_GLPROGRAMLOCALPARAMETER4FVARB(target, index, params);
}

void OSMesaDriver::nfglProgramLocalParameterI4iNV(GLenum target, GLuint index, GLint x, GLint y, GLint z, GLint w)
{
	D(bug("nfosmesa: glProgramLocalParameterI4iNV(%s, %u, %d, %d, %d, %d)", gl_enum_name(target), index, x, y, z, w));
	fn.glProgramLocalParameterI4iNV(target, index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramLocalParameterI4ivNV(GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglProgramLocalParameterI4ivNV(GLenum target, GLuint index, const GLint *params)
#endif
{
	D(bug("nfosmesa: glProgramLocalParameterI4ivNV(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(params)));
FN_GLPROGRAMLOCALPARAMETERI4IVNV(target, index, params);
}

void OSMesaDriver::nfglProgramLocalParameterI4uiNV(GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
	D(bug("nfosmesa: glProgramLocalParameterI4uiNV(%s, %u, %u, %u, %u, %u)", gl_enum_name(target), index, x, y, z, w));
	fn.glProgramLocalParameterI4uiNV(target, index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramLocalParameterI4uivNV(GLenum target, GLuint index, memptr params)
#else
void OSMesaDriver::nfglProgramLocalParameterI4uivNV(GLenum target, GLuint index, const GLuint *params)
#endif
{
	D(bug("nfosmesa: glProgramLocalParameterI4uivNV(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(params)));
FN_GLPROGRAMLOCALPARAMETERI4UIVNV(target, index, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, memptr params)
#else
void OSMesaDriver::nfglProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glProgramLocalParameters4fvEXT(%s, %u, %d, " PRI_PTR ")", gl_enum_name(target), index, count, AtariOffset(params)));
FN_GLPROGRAMLOCALPARAMETERS4FVEXT(target, index, count, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramLocalParametersI4ivNV(GLenum target, GLuint index, GLsizei count, memptr params)
#else
void OSMesaDriver::nfglProgramLocalParametersI4ivNV(GLenum target, GLuint index, GLsizei count, const GLint *params)
#endif
{
	D(bug("nfosmesa: glProgramLocalParametersI4ivNV(%s, %u, %d, " PRI_PTR ")", gl_enum_name(target), index, count, AtariOffset(params)));
FN_GLPROGRAMLOCALPARAMETERSI4IVNV(target, index, count, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramLocalParametersI4uivNV(GLenum target, GLuint index, GLsizei count, memptr params)
#else
void OSMesaDriver::nfglProgramLocalParametersI4uivNV(GLenum target, GLuint index, GLsizei count, const GLuint *params)
#endif
{
	D(bug("nfosmesa: glProgramLocalParametersI4uivNV(%s, %u, %d, " PRI_PTR ")", gl_enum_name(target), index, count, AtariOffset(params)));
FN_GLPROGRAMLOCALPARAMETERSI4UIVNV(target, index, count, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramNamedParameter4dNV(GLuint id, GLsizei len, memptr name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
#else
void OSMesaDriver::nfglProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
#endif
{
	D(bug("nfosmesa: glProgramNamedParameter4dNV(%u, %d, " PRI_PTR ", %f, %f, %f, %f)", id, len, AtariOffset(name), x, y, z, w));
FN_GLPROGRAMNAMEDPARAMETER4DNV(id, len, name, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramNamedParameter4dvNV(GLuint id, GLsizei len, memptr name, memptr v)
#else
void OSMesaDriver::nfglProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glProgramNamedParameter4dvNV(%u, %d, " PRI_PTR ", " PRI_PTR ")", id, len, AtariOffset(name), AtariOffset(v)));
FN_GLPROGRAMNAMEDPARAMETER4DVNV(id, len, name, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramNamedParameter4fNV(GLuint id, GLsizei len, memptr name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
#else
void OSMesaDriver::nfglProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
#endif
{
	D(bug("nfosmesa: glProgramNamedParameter4fNV(%u, %d, " PRI_PTR ", %f, %f, %f, %f)", id, len, AtariOffset(name), x, y, z, w));
FN_GLPROGRAMNAMEDPARAMETER4FNV(id, len, name, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramNamedParameter4fvNV(GLuint id, GLsizei len, memptr name, memptr v)
#else
void OSMesaDriver::nfglProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glProgramNamedParameter4fvNV(%u, %d, " PRI_PTR ", " PRI_PTR ")", id, len, AtariOffset(name), AtariOffset(v)));
FN_GLPROGRAMNAMEDPARAMETER4FVNV(id, len, name, v);
}

void OSMesaDriver::nfglProgramParameter4dNV(GLenum target, GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	D(bug("nfosmesa: glProgramParameter4dNV(%s, %u, %f, %f, %f, %f)", gl_enum_name(target), index, x, y, z, w));
	fn.glProgramParameter4dNV(target, index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramParameter4dvNV(GLenum target, GLuint index, memptr v)
#else
void OSMesaDriver::nfglProgramParameter4dvNV(GLenum target, GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glProgramParameter4dvNV(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(v)));
FN_GLPROGRAMPARAMETER4DVNV(target, index, v);
}

void OSMesaDriver::nfglProgramParameter4fNV(GLenum target, GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	D(bug("nfosmesa: glProgramParameter4fNV(%s, %u, %f, %f, %f, %f)", gl_enum_name(target), index, x, y, z, w));
	fn.glProgramParameter4fNV(target, index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramParameter4fvNV(GLenum target, GLuint index, memptr v)
#else
void OSMesaDriver::nfglProgramParameter4fvNV(GLenum target, GLuint index, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glProgramParameter4fvNV(%s, %u, " PRI_PTR ")", gl_enum_name(target), index, AtariOffset(v)));
FN_GLPROGRAMPARAMETER4FVNV(target, index, v);
}

void OSMesaDriver::nfglProgramParameteri(GLuint program, GLenum pname, GLint value)
{
	D(bug("nfosmesa: glProgramParameteri(%u, %s, %d)", program, gl_enum_name(pname), value));
	fn.glProgramParameteri(program, pname, value);
}

void OSMesaDriver::nfglProgramParameteriARB(GLuint program, GLenum pname, GLint value)
{
	D(bug("nfosmesa: glProgramParameteriARB(%u, %s, %d)", program, gl_enum_name(pname), value));
	fn.glProgramParameteriARB(program, pname, value);
}

void OSMesaDriver::nfglProgramParameteriEXT(GLuint program, GLenum pname, GLint value)
{
	D(bug("nfosmesa: glProgramParameteriEXT(%u, %s, %d)", program, gl_enum_name(pname), value));
	fn.glProgramParameteriEXT(program, pname, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramParameters4dvNV(GLenum target, GLuint index, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglProgramParameters4dvNV(GLenum target, GLuint index, GLsizei count, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glProgramParameters4dvNV(%s, %u, %d, " PRI_PTR ")", gl_enum_name(target), index, count, AtariOffset(v)));
FN_GLPROGRAMPARAMETERS4DVNV(target, index, count, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramParameters4fvNV(GLenum target, GLuint index, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglProgramParameters4fvNV(GLenum target, GLuint index, GLsizei count, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glProgramParameters4fvNV(%s, %u, %d, " PRI_PTR ")", gl_enum_name(target), index, count, AtariOffset(v)));
FN_GLPROGRAMPARAMETERS4FVNV(target, index, count, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramPathFragmentInputGenNV(GLuint program, GLint location, GLenum genMode, GLint components, memptr coeffs)
#else
void OSMesaDriver::nfglProgramPathFragmentInputGenNV(GLuint program, GLint location, GLenum genMode, GLint components, const GLfloat *coeffs)
#endif
{
	D(bug("nfosmesa: glProgramPathFragmentInputGenNV(%u, %d, %s, %d, " PRI_PTR ")", program, location, gl_enum_name(genMode), components, AtariOffset(coeffs)));
FN_GLPROGRAMPATHFRAGMENTINPUTGENNV(program, location, genMode, components, coeffs);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramStringARB(GLenum target, GLenum format, GLsizei len, memptr string)
#else
void OSMesaDriver::nfglProgramStringARB(GLenum target, GLenum format, GLsizei len, const void *string)
#endif
{
	D(bug("nfosmesa: glProgramStringARB(%s, %s, %d, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(format), len, AtariOffset(string)));
FN_GLPROGRAMSTRINGARB(target, format, len, string);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramSubroutineParametersuivNV(GLenum target, GLsizei count, memptr params)
#else
void OSMesaDriver::nfglProgramSubroutineParametersuivNV(GLenum target, GLsizei count, const GLuint *params)
#endif
{
	D(bug("nfosmesa: glProgramSubroutineParametersuivNV(%s, %d, " PRI_PTR ")", gl_enum_name(target), count, AtariOffset(params)));
FN_GLPROGRAMSUBROUTINEPARAMETERSUIVNV(target, count, params);
}

void OSMesaDriver::nfglProgramUniform1d(GLuint program, GLint location, GLdouble v0)
{
	D(bug("nfosmesa: glProgramUniform1d(%u, %d, %f)", program, location, v0));
	fn.glProgramUniform1d(program, location, v0);
}

void OSMesaDriver::nfglProgramUniform1dEXT(GLuint program, GLint location, GLdouble x)
{
	D(bug("nfosmesa: glProgramUniform1dEXT(%u, %d, %f)", program, location, x));
	fn.glProgramUniform1dEXT(program, location, x);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform1dv(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform1dv(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM1DV(program, location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform1dvEXT(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform1dvEXT(GLuint program, GLint location, GLsizei count, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform1dvEXT(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM1DVEXT(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform1f(GLuint program, GLint location, GLfloat v0)
{
	D(bug("nfosmesa: glProgramUniform1f(%u, %d, %f)", program, location, v0));
	fn.glProgramUniform1f(program, location, v0);
}

void OSMesaDriver::nfglProgramUniform1fEXT(GLuint program, GLint location, GLfloat v0)
{
	D(bug("nfosmesa: glProgramUniform1fEXT(%u, %d, %f)", program, location, v0));
	fn.glProgramUniform1fEXT(program, location, v0);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform1fv(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform1fv(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM1FV(program, location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform1fvEXT(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform1fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform1fvEXT(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM1FVEXT(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform1i(GLuint program, GLint location, GLint v0)
{
	D(bug("nfosmesa: glProgramUniform1i(%u, %d, %d)", program, location, v0));
	fn.glProgramUniform1i(program, location, v0);
}

void OSMesaDriver::nfglProgramUniform1i64ARB(GLuint program, GLint location, GLint64 x)
{
	D(bug("nfosmesa: glProgramUniform1i64ARB(%u, %d, %" PRId64 ")", program, location, x));
	fn.glProgramUniform1i64ARB(program, location, x);
}

void OSMesaDriver::nfglProgramUniform1i64NV(GLuint program, GLint location, GLint64EXT x)
{
	D(bug("nfosmesa: glProgramUniform1i64NV(%u, %d, %" PRId64 ")", program, location, x));
	fn.glProgramUniform1i64NV(program, location, x);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform1i64vARB(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform1i64vARB(GLuint program, GLint location, GLsizei count, const GLint64 *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform1i64vARB(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(1 * count, 0);
	GLint64 __value_tmp[__value_size];
	GLint64 *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glProgramUniform1i64vARB(program, location, count, __value_ptmp);
#else
	fn.glProgramUniform1i64vARB(program, location, count, HostAddr(value, const GLint64 *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform1i64vNV(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform1i64vNV(GLuint program, GLint location, GLsizei count, const GLint64EXT *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform1i64vNV(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(1 * count, 0);
	GLint64EXT __value_tmp[__value_size];
	GLint64EXT *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glProgramUniform1i64vNV(program, location, count, __value_ptmp);
#else
	fn.glProgramUniform1i64vNV(program, location, count, HostAddr(value, const GLint64EXT *));
#endif
}

void OSMesaDriver::nfglProgramUniform1iEXT(GLuint program, GLint location, GLint v0)
{
	D(bug("nfosmesa: glProgramUniform1iEXT(%u, %d, %d)", program, location, v0));
	fn.glProgramUniform1iEXT(program, location, v0);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform1iv(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform1iv(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM1IV(program, location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform1ivEXT(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform1ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform1ivEXT(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM1IVEXT(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform1ui(GLuint program, GLint location, GLuint v0)
{
	D(bug("nfosmesa: glProgramUniform1ui(%u, %d, %u)", program, location, v0));
	fn.glProgramUniform1ui(program, location, v0);
}

void OSMesaDriver::nfglProgramUniform1ui64ARB(GLuint program, GLint location, GLuint64 x)
{
	D(bug("nfosmesa: glProgramUniform1ui64ARB(%u, %d, %" PRIu64 ")", program, location, x));
	fn.glProgramUniform1ui64ARB(program, location, x);
}

void OSMesaDriver::nfglProgramUniform1ui64NV(GLuint program, GLint location, GLuint64EXT x)
{
	D(bug("nfosmesa: glProgramUniform1ui64NV(%u, %d, %" PRIu64 ")", program, location, x));
	fn.glProgramUniform1ui64NV(program, location, x);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform1ui64vARB(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform1ui64vARB(GLuint program, GLint location, GLsizei count, const GLuint64 *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform1ui64vARB(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(1 * count, 0);
	GLuint64 __value_tmp[__value_size];
	GLuint64 *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glProgramUniform1ui64vARB(program, location, count, __value_ptmp);
#else
	fn.glProgramUniform1ui64vARB(program, location, count, HostAddr(value, const GLuint64 *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform1ui64vNV(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform1ui64vNV(GLuint program, GLint location, GLsizei count, const GLuint64EXT *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform1ui64vNV(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(1 * count, 0);
	GLuint64EXT __value_tmp[__value_size];
	GLuint64EXT *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glProgramUniform1ui64vNV(program, location, count, __value_ptmp);
#else
	fn.glProgramUniform1ui64vNV(program, location, count, HostAddr(value, const GLuint64EXT *));
#endif
}

void OSMesaDriver::nfglProgramUniform1uiEXT(GLuint program, GLint location, GLuint v0)
{
	D(bug("nfosmesa: glProgramUniform1uiEXT(%u, %d, %u)", program, location, v0));
	fn.glProgramUniform1uiEXT(program, location, v0);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform1uiv(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform1uiv(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM1UIV(program, location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform1uivEXT(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform1uivEXT(GLuint program, GLint location, GLsizei count, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform1uivEXT(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM1UIVEXT(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform2d(GLuint program, GLint location, GLdouble v0, GLdouble v1)
{
	D(bug("nfosmesa: glProgramUniform2d(%u, %d, %f, %f)", program, location, v0, v1));
	fn.glProgramUniform2d(program, location, v0, v1);
}

void OSMesaDriver::nfglProgramUniform2dEXT(GLuint program, GLint location, GLdouble x, GLdouble y)
{
	D(bug("nfosmesa: glProgramUniform2dEXT(%u, %d, %f, %f)", program, location, x, y));
	fn.glProgramUniform2dEXT(program, location, x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform2dv(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform2dv(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM2DV(program, location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform2dvEXT(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform2dvEXT(GLuint program, GLint location, GLsizei count, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform2dvEXT(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM2DVEXT(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform2f(GLuint program, GLint location, GLfloat v0, GLfloat v1)
{
	D(bug("nfosmesa: glProgramUniform2f(%u, %d, %f, %f)", program, location, v0, v1));
	fn.glProgramUniform2f(program, location, v0, v1);
}

void OSMesaDriver::nfglProgramUniform2fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1)
{
	D(bug("nfosmesa: glProgramUniform2fEXT(%u, %d, %f, %f)", program, location, v0, v1));
	fn.glProgramUniform2fEXT(program, location, v0, v1);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform2fv(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform2fv(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM2FV(program, location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform2fvEXT(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform2fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform2fvEXT(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM2FVEXT(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform2i(GLuint program, GLint location, GLint v0, GLint v1)
{
	D(bug("nfosmesa: glProgramUniform2i(%u, %d, %d, %d)", program, location, v0, v1));
	fn.glProgramUniform2i(program, location, v0, v1);
}

void OSMesaDriver::nfglProgramUniform2i64ARB(GLuint program, GLint location, GLint64 x, GLint64 y)
{
	D(bug("nfosmesa: glProgramUniform2i64ARB(%u, %d, %" PRId64 ", %" PRId64 ")", program, location, x, y));
	fn.glProgramUniform2i64ARB(program, location, x, y);
}

void OSMesaDriver::nfglProgramUniform2i64NV(GLuint program, GLint location, GLint64EXT x, GLint64EXT y)
{
	D(bug("nfosmesa: glProgramUniform2i64NV(%u, %d, %" PRId64 ", %" PRId64 ")", program, location, x, y));
	fn.glProgramUniform2i64NV(program, location, x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform2i64vARB(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform2i64vARB(GLuint program, GLint location, GLsizei count, const GLint64 *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform2i64vARB(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(2 * count, 0);
	GLint64 __value_tmp[__value_size];
	GLint64 *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glProgramUniform2i64vARB(program, location, count, __value_ptmp);
#else
	fn.glProgramUniform2i64vARB(program, location, count, HostAddr(value, const GLint64 *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform2i64vNV(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform2i64vNV(GLuint program, GLint location, GLsizei count, const GLint64EXT *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform2i64vNV(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(2 * count, 0);
	GLint64EXT __value_tmp[__value_size];
	GLint64EXT *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glProgramUniform2i64vNV(program, location, count, __value_ptmp);
#else
	fn.glProgramUniform2i64vNV(program, location, count, HostAddr(value, const GLint64EXT *));
#endif
}

void OSMesaDriver::nfglProgramUniform2iEXT(GLuint program, GLint location, GLint v0, GLint v1)
{
	D(bug("nfosmesa: glProgramUniform2iEXT(%u, %d, %d, %d)", program, location, v0, v1));
	fn.glProgramUniform2iEXT(program, location, v0, v1);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform2iv(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform2iv(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM2IV(program, location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform2ivEXT(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform2ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform2ivEXT(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM2IVEXT(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform2ui(GLuint program, GLint location, GLuint v0, GLuint v1)
{
	D(bug("nfosmesa: glProgramUniform2ui(%u, %d, %u, %u)", program, location, v0, v1));
	fn.glProgramUniform2ui(program, location, v0, v1);
}

void OSMesaDriver::nfglProgramUniform2ui64ARB(GLuint program, GLint location, GLuint64 x, GLuint64 y)
{
	D(bug("nfosmesa: glProgramUniform2ui64ARB(%u, %d, %" PRIu64 ", %" PRIu64 ")", program, location, x, y));
	fn.glProgramUniform2ui64ARB(program, location, x, y);
}

void OSMesaDriver::nfglProgramUniform2ui64NV(GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y)
{
	D(bug("nfosmesa: glProgramUniform2ui64NV(%u, %d, %" PRIu64 ", %" PRIu64 ")", program, location, x, y));
	fn.glProgramUniform2ui64NV(program, location, x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform2ui64vARB(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform2ui64vARB(GLuint program, GLint location, GLsizei count, const GLuint64 *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform2ui64vARB(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(2 * count, 0);
	GLuint64 __value_tmp[__value_size];
	GLuint64 *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glProgramUniform2ui64vARB(program, location, count, __value_ptmp);
#else
	fn.glProgramUniform2ui64vARB(program, location, count, HostAddr(value, const GLuint64 *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform2ui64vNV(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform2ui64vNV(GLuint program, GLint location, GLsizei count, const GLuint64EXT *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform2ui64vNV(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(2 * count, 0);
	GLuint64EXT __value_tmp[__value_size];
	GLuint64EXT *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glProgramUniform2ui64vNV(program, location, count, __value_ptmp);
#else
	fn.glProgramUniform2ui64vNV(program, location, count, HostAddr(value, const GLuint64EXT *));
#endif
}

void OSMesaDriver::nfglProgramUniform2uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1)
{
	D(bug("nfosmesa: glProgramUniform2uiEXT(%u, %d, %u, %u)", program, location, v0, v1));
	fn.glProgramUniform2uiEXT(program, location, v0, v1);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform2uiv(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform2uiv(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM2UIV(program, location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform2uivEXT(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform2uivEXT(GLuint program, GLint location, GLsizei count, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform2uivEXT(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM2UIVEXT(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform3d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2)
{
	D(bug("nfosmesa: glProgramUniform3d(%u, %d, %f, %f, %f)", program, location, v0, v1, v2));
	fn.glProgramUniform3d(program, location, v0, v1, v2);
}

void OSMesaDriver::nfglProgramUniform3dEXT(GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glProgramUniform3dEXT(%u, %d, %f, %f, %f)", program, location, x, y, z));
	fn.glProgramUniform3dEXT(program, location, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform3dv(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform3dv(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM3DV(program, location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform3dvEXT(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform3dvEXT(GLuint program, GLint location, GLsizei count, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform3dvEXT(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM3DVEXT(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform3f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
{
	D(bug("nfosmesa: glProgramUniform3f(%u, %d, %f, %f, %f)", program, location, v0, v1, v2));
	fn.glProgramUniform3f(program, location, v0, v1, v2);
}

void OSMesaDriver::nfglProgramUniform3fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
{
	D(bug("nfosmesa: glProgramUniform3fEXT(%u, %d, %f, %f, %f)", program, location, v0, v1, v2));
	fn.glProgramUniform3fEXT(program, location, v0, v1, v2);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform3fv(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform3fv(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM3FV(program, location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform3fvEXT(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform3fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform3fvEXT(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM3FVEXT(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform3i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
{
	D(bug("nfosmesa: glProgramUniform3i(%u, %d, %d, %d, %d)", program, location, v0, v1, v2));
	fn.glProgramUniform3i(program, location, v0, v1, v2);
}

void OSMesaDriver::nfglProgramUniform3i64ARB(GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z)
{
	D(bug("nfosmesa: glProgramUniform3i64ARB(%u, %d, %" PRId64 ", %" PRId64 ", %" PRId64 ")", program, location, x, y, z));
	fn.glProgramUniform3i64ARB(program, location, x, y, z);
}

void OSMesaDriver::nfglProgramUniform3i64NV(GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z)
{
	D(bug("nfosmesa: glProgramUniform3i64NV(%u, %d, %" PRId64 ", %" PRId64 ", %" PRId64 ")", program, location, x, y, z));
	fn.glProgramUniform3i64NV(program, location, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform3i64vARB(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform3i64vARB(GLuint program, GLint location, GLsizei count, const GLint64 *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform3i64vARB(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(3 * count, 0);
	GLint64 __value_tmp[__value_size];
	GLint64 *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glProgramUniform3i64vARB(program, location, count, __value_ptmp);
#else
	fn.glProgramUniform3i64vARB(program, location, count, HostAddr(value, const GLint64 *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform3i64vNV(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform3i64vNV(GLuint program, GLint location, GLsizei count, const GLint64EXT *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform3i64vNV(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(3 * count, 0);
	GLint64EXT __value_tmp[__value_size];
	GLint64EXT *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glProgramUniform3i64vNV(program, location, count, __value_ptmp);
#else
	fn.glProgramUniform3i64vNV(program, location, count, HostAddr(value, const GLint64EXT *));
#endif
}

void OSMesaDriver::nfglProgramUniform3iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2)
{
	D(bug("nfosmesa: glProgramUniform3iEXT(%u, %d, %d, %d, %d)", program, location, v0, v1, v2));
	fn.glProgramUniform3iEXT(program, location, v0, v1, v2);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform3iv(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform3iv(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM3IV(program, location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform3ivEXT(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform3ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform3ivEXT(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM3IVEXT(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform3ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
{
	D(bug("nfosmesa: glProgramUniform3ui(%u, %d, %u, %u, %u)", program, location, v0, v1, v2));
	fn.glProgramUniform3ui(program, location, v0, v1, v2);
}

void OSMesaDriver::nfglProgramUniform3ui64ARB(GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z)
{
	D(bug("nfosmesa: glProgramUniform3ui64ARB(%u, %d, %" PRIu64 ", %" PRIu64 ", %" PRIu64 ")", program, location, x, y, z));
	fn.glProgramUniform3ui64ARB(program, location, x, y, z);
}

void OSMesaDriver::nfglProgramUniform3ui64NV(GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z)
{
	D(bug("nfosmesa: glProgramUniform3ui64NV(%u, %d, %" PRIu64 ", %" PRIu64 ", %" PRIu64 ")", program, location, x, y, z));
	fn.glProgramUniform3ui64NV(program, location, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform3ui64vARB(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform3ui64vARB(GLuint program, GLint location, GLsizei count, const GLuint64 *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform3ui64vARB(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(3 * count, 0);
	GLuint64 __value_tmp[__value_size];
	GLuint64 *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glProgramUniform3ui64vARB(program, location, count, __value_ptmp);
#else
	fn.glProgramUniform3ui64vARB(program, location, count, HostAddr(value, const GLuint64 *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform3ui64vNV(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform3ui64vNV(GLuint program, GLint location, GLsizei count, const GLuint64EXT *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform3ui64vNV(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(3 * count, 0);
	GLuint64EXT __value_tmp[__value_size];
	GLuint64EXT *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glProgramUniform3ui64vNV(program, location, count, __value_ptmp);
#else
	fn.glProgramUniform3ui64vNV(program, location, count, HostAddr(value, const GLuint64EXT *));
#endif
}

void OSMesaDriver::nfglProgramUniform3uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2)
{
	D(bug("nfosmesa: glProgramUniform3uiEXT(%u, %d, %u, %u, %u)", program, location, v0, v1, v2));
	fn.glProgramUniform3uiEXT(program, location, v0, v1, v2);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform3uiv(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform3uiv(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM3UIV(program, location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform3uivEXT(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform3uivEXT(GLuint program, GLint location, GLsizei count, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform3uivEXT(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM3UIVEXT(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform4d(GLuint program, GLint location, GLdouble v0, GLdouble v1, GLdouble v2, GLdouble v3)
{
	D(bug("nfosmesa: glProgramUniform4d(%u, %d, %f, %f, %f, %f)", program, location, v0, v1, v2, v3));
	fn.glProgramUniform4d(program, location, v0, v1, v2, v3);
}

void OSMesaDriver::nfglProgramUniform4dEXT(GLuint program, GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	D(bug("nfosmesa: glProgramUniform4dEXT(%u, %d, %f, %f, %f, %f)", program, location, x, y, z, w));
	fn.glProgramUniform4dEXT(program, location, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform4dv(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform4dv(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM4DV(program, location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform4dvEXT(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform4dvEXT(GLuint program, GLint location, GLsizei count, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform4dvEXT(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM4DVEXT(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform4f(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
{
	D(bug("nfosmesa: glProgramUniform4f(%u, %d, %f, %f, %f, %f)", program, location, v0, v1, v2, v3));
	fn.glProgramUniform4f(program, location, v0, v1, v2, v3);
}

void OSMesaDriver::nfglProgramUniform4fEXT(GLuint program, GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
{
	D(bug("nfosmesa: glProgramUniform4fEXT(%u, %d, %f, %f, %f, %f)", program, location, v0, v1, v2, v3));
	fn.glProgramUniform4fEXT(program, location, v0, v1, v2, v3);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform4fv(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform4fv(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM4FV(program, location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform4fvEXT(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform4fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform4fvEXT(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM4FVEXT(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform4i(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
{
	D(bug("nfosmesa: glProgramUniform4i(%u, %d, %d, %d, %d, %d)", program, location, v0, v1, v2, v3));
	fn.glProgramUniform4i(program, location, v0, v1, v2, v3);
}

void OSMesaDriver::nfglProgramUniform4i64ARB(GLuint program, GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w)
{
	D(bug("nfosmesa: glProgramUniform4i64ARB(%u, %d, %" PRId64 ", %" PRId64 ", %" PRId64 ", %" PRId64 ")", program, location, x, y, z, w));
	fn.glProgramUniform4i64ARB(program, location, x, y, z, w);
}

void OSMesaDriver::nfglProgramUniform4i64NV(GLuint program, GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w)
{
	D(bug("nfosmesa: glProgramUniform4i64NV(%u, %d, %" PRId64 ", %" PRId64 ", %" PRId64 ", %" PRId64 ")", program, location, x, y, z, w));
	fn.glProgramUniform4i64NV(program, location, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform4i64vARB(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform4i64vARB(GLuint program, GLint location, GLsizei count, const GLint64 *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform4i64vARB(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(4 * count, 0);
	GLint64 __value_tmp[__value_size];
	GLint64 *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glProgramUniform4i64vARB(program, location, count, __value_ptmp);
#else
	fn.glProgramUniform4i64vARB(program, location, count, HostAddr(value, const GLint64 *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform4i64vNV(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform4i64vNV(GLuint program, GLint location, GLsizei count, const GLint64EXT *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform4i64vNV(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(4 * count, 0);
	GLint64EXT __value_tmp[__value_size];
	GLint64EXT *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glProgramUniform4i64vNV(program, location, count, __value_ptmp);
#else
	fn.glProgramUniform4i64vNV(program, location, count, HostAddr(value, const GLint64EXT *));
#endif
}

void OSMesaDriver::nfglProgramUniform4iEXT(GLuint program, GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
{
	D(bug("nfosmesa: glProgramUniform4iEXT(%u, %d, %d, %d, %d, %d)", program, location, v0, v1, v2, v3));
	fn.glProgramUniform4iEXT(program, location, v0, v1, v2, v3);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform4iv(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform4iv(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM4IV(program, location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform4ivEXT(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform4ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform4ivEXT(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM4IVEXT(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform4ui(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
{
	D(bug("nfosmesa: glProgramUniform4ui(%u, %d, %u, %u, %u, %u)", program, location, v0, v1, v2, v3));
	fn.glProgramUniform4ui(program, location, v0, v1, v2, v3);
}

void OSMesaDriver::nfglProgramUniform4ui64ARB(GLuint program, GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w)
{
	D(bug("nfosmesa: glProgramUniform4ui64ARB(%u, %d, %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ")", program, location, x, y, z, w));
	fn.glProgramUniform4ui64ARB(program, location, x, y, z, w);
}

void OSMesaDriver::nfglProgramUniform4ui64NV(GLuint program, GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w)
{
	D(bug("nfosmesa: glProgramUniform4ui64NV(%u, %d, %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ")", program, location, x, y, z, w));
	fn.glProgramUniform4ui64NV(program, location, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform4ui64vARB(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform4ui64vARB(GLuint program, GLint location, GLsizei count, const GLuint64 *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform4ui64vARB(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(4 * count, 0);
	GLuint64 __value_tmp[__value_size];
	GLuint64 *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glProgramUniform4ui64vARB(program, location, count, __value_ptmp);
#else
	fn.glProgramUniform4ui64vARB(program, location, count, HostAddr(value, const GLuint64 *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform4ui64vNV(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform4ui64vNV(GLuint program, GLint location, GLsizei count, const GLuint64EXT *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform4ui64vNV(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(4 * count, 0);
	GLuint64EXT __value_tmp[__value_size];
	GLuint64EXT *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glProgramUniform4ui64vNV(program, location, count, __value_ptmp);
#else
	fn.glProgramUniform4ui64vNV(program, location, count, HostAddr(value, const GLuint64EXT *));
#endif
}

void OSMesaDriver::nfglProgramUniform4uiEXT(GLuint program, GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
{
	D(bug("nfosmesa: glProgramUniform4uiEXT(%u, %d, %u, %u, %u, %u)", program, location, v0, v1, v2, v3));
	fn.glProgramUniform4uiEXT(program, location, v0, v1, v2, v3);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform4uiv(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform4uiv(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM4UIV(program, location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniform4uivEXT(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniform4uivEXT(GLuint program, GLint location, GLsizei count, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glProgramUniform4uivEXT(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORM4UIVEXT(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniformHandleui64ARB(GLuint program, GLint location, GLuint64 value)
{
	D(bug("nfosmesa: glProgramUniformHandleui64ARB(%u, %d, %" PRIu64 ")", program, location, value));
	fn.glProgramUniformHandleui64ARB(program, location, value);
}

void OSMesaDriver::nfglProgramUniformHandleui64NV(GLuint program, GLint location, GLuint64 value)
{
	D(bug("nfosmesa: glProgramUniformHandleui64NV(%u, %d, %" PRIu64 ")", program, location, value));
	fn.glProgramUniformHandleui64NV(program, location, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformHandleui64vARB(GLuint program, GLint location, GLsizei count, memptr values)
#else
void OSMesaDriver::nfglProgramUniformHandleui64vARB(GLuint program, GLint location, GLsizei count, const GLuint64 *values)
#endif
{
	D(bug("nfosmesa: glProgramUniformHandleui64vARB(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(values)));
FN_GLPROGRAMUNIFORMHANDLEUI64VARB(program, location, count, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformHandleui64vNV(GLuint program, GLint location, GLsizei count, memptr values)
#else
void OSMesaDriver::nfglProgramUniformHandleui64vNV(GLuint program, GLint location, GLsizei count, const GLuint64 *values)
#endif
{
	D(bug("nfosmesa: glProgramUniformHandleui64vNV(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(values)));
FN_GLPROGRAMUNIFORMHANDLEUI64VNV(program, location, count, values);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix2dv(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX2DV(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix2dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix2dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix2dvEXT(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX2DVEXT(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix2fv(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX2FV(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix2fvEXT(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX2FVEXT(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix2x3dv(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX2X3DV(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix2x3dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix2x3dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix2x3dvEXT(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX2X3DVEXT(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix2x3fv(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX2X3FV(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix2x3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix2x3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix2x3fvEXT(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX2X3FVEXT(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix2x4dv(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX2X4DV(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix2x4dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix2x4dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix2x4dvEXT(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX2X4DVEXT(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix2x4fv(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX2X4FV(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix2x4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix2x4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix2x4fvEXT(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX2X4FVEXT(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix3dv(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX3DV(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix3dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix3dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix3dvEXT(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX3DVEXT(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix3fv(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX3FV(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix3fvEXT(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX3FVEXT(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix3x2dv(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX3X2DV(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix3x2dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix3x2dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix3x2dvEXT(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX3X2DVEXT(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix3x2fv(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX3X2FV(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix3x2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix3x2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix3x2fvEXT(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX3X2FVEXT(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix3x4dv(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX3X4DV(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix3x4dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix3x4dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix3x4dvEXT(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX3X4DVEXT(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix3x4fv(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX3X4FV(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix3x4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix3x4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix3x4fvEXT(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX3X4FVEXT(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix4dv(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX4DV(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix4dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix4dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix4dvEXT(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX4DVEXT(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix4fv(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX4FV(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix4fvEXT(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX4FVEXT(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix4x2dv(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX4X2DV(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix4x2dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix4x2dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix4x2dvEXT(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX4X2DVEXT(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix4x2fv(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX4X2FV(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix4x2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix4x2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix4x2fvEXT(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX4X2FVEXT(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix4x3dv(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX4X3DV(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix4x3dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix4x3dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix4x3dvEXT(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX4X3DVEXT(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix4x3fv(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX4X3FV(program, location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformMatrix4x3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglProgramUniformMatrix4x3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformMatrix4x3fvEXT(%u, %d, %d, %d, " PRI_PTR ")", program, location, count, transpose, AtariOffset(value)));
FN_GLPROGRAMUNIFORMMATRIX4X3FVEXT(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformui64NV(GLuint program, GLint location, GLuint64EXT value)
{
	D(bug("nfosmesa: glProgramUniformui64NV(%u, %d, %" PRIu64 ")", program, location, value));
	fn.glProgramUniformui64NV(program, location, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglProgramUniformui64vNV(GLuint program, GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglProgramUniformui64vNV(GLuint program, GLint location, GLsizei count, const GLuint64EXT *value)
#endif
{
	D(bug("nfosmesa: glProgramUniformui64vNV(%u, %d, %d, " PRI_PTR ")", program, location, count, AtariOffset(value)));
FN_GLPROGRAMUNIFORMUI64VNV(program, location, count, value);
}

void OSMesaDriver::nfglProgramVertexLimitNV(GLenum target, GLint limit)
{
	D(bug("nfosmesa: glProgramVertexLimitNV(%s, %d)", gl_enum_name(target), limit));
	fn.glProgramVertexLimitNV(target, limit);
}

void OSMesaDriver::nfglProvokingVertex(GLenum mode)
{
	D(bug("nfosmesa: glProvokingVertex(%s)", gl_enum_name(mode)));
	fn.glProvokingVertex(mode);
}

void OSMesaDriver::nfglProvokingVertexEXT(GLenum mode)
{
	D(bug("nfosmesa: glProvokingVertexEXT(%s)", gl_enum_name(mode)));
	fn.glProvokingVertexEXT(mode);
}

void OSMesaDriver::nfglPushAttrib(GLbitfield mask)
{
	D(bug("nfosmesa: glPushAttrib(0x%x)", mask));
	fn.glPushAttrib(mask);
}

void OSMesaDriver::nfglPushClientAttrib(GLbitfield mask)
{
	D(bug("nfosmesa: glPushClientAttrib(0x%x)", mask));
	fn.glPushClientAttrib(mask);
}

void OSMesaDriver::nfglPushClientAttribDefaultEXT(GLbitfield mask)
{
	D(bug("nfosmesa: glPushClientAttribDefaultEXT(0x%x)", mask));
	fn.glPushClientAttribDefaultEXT(mask);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPushDebugGroup(GLenum source, GLuint id, GLsizei length, memptr message)
#else
void OSMesaDriver::nfglPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message)
#endif
{
	D(bug("nfosmesa: glPushDebugGroup(%s, %u, %d, " PRI_PTR ")", gl_enum_name(source), id, length, AtariOffset(message)));
FN_GLPUSHDEBUGGROUP(source, id, length, message);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglPushGroupMarkerEXT(GLsizei length, memptr marker)
#else
void OSMesaDriver::nfglPushGroupMarkerEXT(GLsizei length, const GLchar *marker)
#endif
{
	D(bug("nfosmesa: glPushGroupMarkerEXT(%d, " PRI_PTR ")", length, AtariOffset(marker)));
#if NFOSMESA_NEED_BYTE_CONV
	GLint const __marker_size = length > 0 ? length : safe_strlen(marker) + 1;
	GLchar __marker_tmp[__marker_size];
	GLchar *__marker_ptmp = Atari2HostByteArray(__marker_size, marker, __marker_tmp);
	fn.glPushGroupMarkerEXT(length, __marker_ptmp);
#else
	fn.glPushGroupMarkerEXT(length, HostAddr(marker, const GLchar *));
#endif
}

void OSMesaDriver::nfglPushMatrix(void)
{
	D(bug("nfosmesa: glPushMatrix()"));
	fn.glPushMatrix();
}

void OSMesaDriver::nfglPushName(GLuint name)
{
	D(bug("nfosmesa: glPushName(%u)", name));
	fn.glPushName(name);
}

void OSMesaDriver::nfglQueryCounter(GLuint id, GLenum target)
{
	D(bug("nfosmesa: glQueryCounter(%u, %s)", id, gl_enum_name(target)));
	fn.glQueryCounter(id, target);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLbitfield OSMesaDriver::nfglQueryMatrixxOES(memptr mantissa, memptr exponent)
#else
GLbitfield OSMesaDriver::nfglQueryMatrixxOES(GLfixed *mantissa, GLint *exponent)
#endif
{
	D(bug("nfosmesa: glQueryMatrixxOES(" PRI_PTR ", " PRI_PTR ")", AtariOffset(mantissa), AtariOffset(exponent)));
FN_GLQUERYMATRIXXOES(mantissa, exponent);
}

void OSMesaDriver::nfglQueryObjectParameteruiAMD(GLenum target, GLuint id, GLenum pname, GLuint param)
{
	D(bug("nfosmesa: glQueryObjectParameteruiAMD(%s, %u, %s, %u)", gl_enum_name(target), id, gl_enum_name(pname), param));
	fn.glQueryObjectParameteruiAMD(target, id, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLint OSMesaDriver::nfglQueryResourceNV(GLenum queryType, GLint tagId, GLuint bufSize, memptr buffer)
#else
GLint OSMesaDriver::nfglQueryResourceNV(GLenum queryType, GLint tagId, GLuint bufSize, GLint *buffer)
#endif
{
	D(bug("nfosmesa: glQueryResourceNV(%s, %d, %u, " PRI_PTR ")", gl_enum_name(queryType), tagId, bufSize, AtariOffset(buffer)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __buffer_size = MAX(bufSize, 0);
	GLint __buffer_tmp[__buffer_size];
	GLint __ret = fn.glQueryResourceNV(queryType, tagId, bufSize, __buffer_tmp);
	Host2AtariIntArray(__buffer_size, __buffer_tmp, buffer);
#else
	GLint __ret = fn.glQueryResourceNV(queryType, tagId, bufSize, HostAddr(buffer, GLint *));
#endif
	return __ret;
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglQueryResourceTagNV(GLint tagId, memptr tagString)
#else
void OSMesaDriver::nfglQueryResourceTagNV(GLint tagId, const GLchar *tagString)
#endif
{
	D(bug("nfosmesa: glQueryResourceTagNV(%d, " PRI_PTR ")", tagId, AtariOffset(tagString)));
#if NFOSMESA_NEED_BYTE_CONV
	GLint const __tagString_size = safe_strlen(tagString) + 1;
	GLchar __tagString_tmp[__tagString_size];
	GLchar *__tagString_ptmp = Atari2HostByteArray(__tagString_size, tagString, __tagString_tmp);
	fn.glQueryResourceTagNV(tagId, __tagString_ptmp);
#else
	fn.glQueryResourceTagNV(tagId, HostAddr(tagString, const GLchar *));
#endif
}

void OSMesaDriver::nfglRasterPos2d(GLdouble x, GLdouble y)
{
	D(bug("nfosmesa: glRasterPos2d(%f, %f)", x, y));
	fn.glRasterPos2d(x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRasterPos2dv(memptr v)
#else
void OSMesaDriver::nfglRasterPos2dv(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glRasterPos2dv(" PRI_PTR ")", AtariOffset(v)));
FN_GLRASTERPOS2DV(v);
}

void OSMesaDriver::nfglRasterPos2f(GLfloat x, GLfloat y)
{
	D(bug("nfosmesa: glRasterPos2f(%f, %f)", x, y));
	fn.glRasterPos2f(x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRasterPos2fv(memptr v)
#else
void OSMesaDriver::nfglRasterPos2fv(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glRasterPos2fv(" PRI_PTR ")", AtariOffset(v)));
FN_GLRASTERPOS2FV(v);
}

void OSMesaDriver::nfglRasterPos2i(GLint x, GLint y)
{
	D(bug("nfosmesa: glRasterPos2i(%d, %d)", x, y));
	fn.glRasterPos2i(x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRasterPos2iv(memptr v)
#else
void OSMesaDriver::nfglRasterPos2iv(const GLint *v)
#endif
{
	D(bug("nfosmesa: glRasterPos2iv(" PRI_PTR ")", AtariOffset(v)));
FN_GLRASTERPOS2IV(v);
}

void OSMesaDriver::nfglRasterPos2s(GLshort32 x, GLshort32 y)
{
	D(bug("nfosmesa: glRasterPos2s(%d, %d)", x, y));
	fn.glRasterPos2s(x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRasterPos2sv(memptr v)
#else
void OSMesaDriver::nfglRasterPos2sv(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glRasterPos2sv(" PRI_PTR ")", AtariOffset(v)));
FN_GLRASTERPOS2SV(v);
}

void OSMesaDriver::nfglRasterPos2xOES(GLfixed x, GLfixed y)
{
	D(bug("nfosmesa: glRasterPos2xOES(0x%x, 0x%x)", x, y));
	fn.glRasterPos2xOES(x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRasterPos2xvOES(memptr coords)
#else
void OSMesaDriver::nfglRasterPos2xvOES(const GLfixed *coords)
#endif
{
	D(bug("nfosmesa: glRasterPos2xvOES(" PRI_PTR ")", AtariOffset(coords)));
FN_GLRASTERPOS2XVOES(coords);
}

void OSMesaDriver::nfglRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glRasterPos3d(%f, %f, %f)", x, y, z));
	fn.glRasterPos3d(x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRasterPos3dv(memptr v)
#else
void OSMesaDriver::nfglRasterPos3dv(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glRasterPos3dv(" PRI_PTR ")", AtariOffset(v)));
FN_GLRASTERPOS3DV(v);
}

void OSMesaDriver::nfglRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glRasterPos3f(%f, %f, %f)", x, y, z));
	fn.glRasterPos3f(x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRasterPos3fv(memptr v)
#else
void OSMesaDriver::nfglRasterPos3fv(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glRasterPos3fv(" PRI_PTR ")", AtariOffset(v)));
FN_GLRASTERPOS3FV(v);
}

void OSMesaDriver::nfglRasterPos3i(GLint x, GLint y, GLint z)
{
	D(bug("nfosmesa: glRasterPos3i(%d, %d, %d)", x, y, z));
	fn.glRasterPos3i(x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRasterPos3iv(memptr v)
#else
void OSMesaDriver::nfglRasterPos3iv(const GLint *v)
#endif
{
	D(bug("nfosmesa: glRasterPos3iv(" PRI_PTR ")", AtariOffset(v)));
FN_GLRASTERPOS3IV(v);
}

void OSMesaDriver::nfglRasterPos3s(GLshort32 x, GLshort32 y, GLshort32 z)
{
	D(bug("nfosmesa: glRasterPos3s(%d, %d, %d)", x, y, z));
	fn.glRasterPos3s(x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRasterPos3sv(memptr v)
#else
void OSMesaDriver::nfglRasterPos3sv(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glRasterPos3sv(" PRI_PTR ")", AtariOffset(v)));
FN_GLRASTERPOS3SV(v);
}

void OSMesaDriver::nfglRasterPos3xOES(GLfixed x, GLfixed y, GLfixed z)
{
	D(bug("nfosmesa: glRasterPos3xOES(0x%x, 0x%x, 0x%x)", x, y, z));
	fn.glRasterPos3xOES(x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRasterPos3xvOES(memptr coords)
#else
void OSMesaDriver::nfglRasterPos3xvOES(const GLfixed *coords)
#endif
{
	D(bug("nfosmesa: glRasterPos3xvOES(" PRI_PTR ")", AtariOffset(coords)));
FN_GLRASTERPOS3XVOES(coords);
}

void OSMesaDriver::nfglRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	D(bug("nfosmesa: glRasterPos4d(%f, %f, %f, %f)", x, y, z, w));
	fn.glRasterPos4d(x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRasterPos4dv(memptr v)
#else
void OSMesaDriver::nfglRasterPos4dv(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glRasterPos4dv(" PRI_PTR ")", AtariOffset(v)));
FN_GLRASTERPOS4DV(v);
}

void OSMesaDriver::nfglRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	D(bug("nfosmesa: glRasterPos4f(%f, %f, %f, %f)", x, y, z, w));
	fn.glRasterPos4f(x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRasterPos4fv(memptr v)
#else
void OSMesaDriver::nfglRasterPos4fv(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glRasterPos4fv(" PRI_PTR ")", AtariOffset(v)));
FN_GLRASTERPOS4FV(v);
}

void OSMesaDriver::nfglRasterPos4i(GLint x, GLint y, GLint z, GLint w)
{
	D(bug("nfosmesa: glRasterPos4i(%d, %d, %d, %d)", x, y, z, w));
	fn.glRasterPos4i(x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRasterPos4iv(memptr v)
#else
void OSMesaDriver::nfglRasterPos4iv(const GLint *v)
#endif
{
	D(bug("nfosmesa: glRasterPos4iv(" PRI_PTR ")", AtariOffset(v)));
FN_GLRASTERPOS4IV(v);
}

void OSMesaDriver::nfglRasterPos4s(GLshort32 x, GLshort32 y, GLshort32 z, GLshort32 w)
{
	D(bug("nfosmesa: glRasterPos4s(%d, %d, %d, %d)", x, y, z, w));
	fn.glRasterPos4s(x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRasterPos4sv(memptr v)
#else
void OSMesaDriver::nfglRasterPos4sv(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glRasterPos4sv(" PRI_PTR ")", AtariOffset(v)));
FN_GLRASTERPOS4SV(v);
}

void OSMesaDriver::nfglRasterPos4xOES(GLfixed x, GLfixed y, GLfixed z, GLfixed w)
{
	D(bug("nfosmesa: glRasterPos4xOES(0x%x, 0x%x, 0x%x, 0x%x)", x, y, z, w));
	fn.glRasterPos4xOES(x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRasterPos4xvOES(memptr coords)
#else
void OSMesaDriver::nfglRasterPos4xvOES(const GLfixed *coords)
#endif
{
	D(bug("nfosmesa: glRasterPos4xvOES(" PRI_PTR ")", AtariOffset(coords)));
FN_GLRASTERPOS4XVOES(coords);
}

void OSMesaDriver::nfglRasterSamplesEXT(GLuint samples, GLboolean32 fixedsamplelocations)
{
	D(bug("nfosmesa: glRasterSamplesEXT(%u, %d)", samples, fixedsamplelocations));
	fn.glRasterSamplesEXT(samples, fixedsamplelocations);
}

void OSMesaDriver::nfglReadBuffer(GLenum mode)
{
	D(bug("nfosmesa: glReadBuffer(%s)", gl_enum_name(mode)));
	fn.glReadBuffer(mode);
}

void OSMesaDriver::nfglReadInstrumentsSGIX(GLint marker)
{
	D(bug("nfosmesa: glReadInstrumentsSGIX(%d)", marker));
	fn.glReadInstrumentsSGIX(marker);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
#endif
{
	D(bug("nfosmesa: glReadPixels(%d, %d, %d, %d, %s, %s, " PRI_PTR ")", x, y, width, height, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLREADPIXELS(x, y, width, height, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, memptr data)
#else
void OSMesaDriver::nfglReadnPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data)
#endif
{
	D(bug("nfosmesa: glReadnPixels(%d, %d, %d, %d, %s, %s, %d, " PRI_PTR ")", x, y, width, height, gl_enum_name(format), gl_enum_name(type), bufSize, AtariOffset(data)));
FN_GLREADNPIXELS(x, y, width, height, format, type, bufSize, data);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglReadnPixelsARB(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, memptr data)
#else
void OSMesaDriver::nfglReadnPixelsARB(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data)
#endif
{
	D(bug("nfosmesa: glReadnPixelsARB(%d, %d, %d, %d, %s, %s, %d, " PRI_PTR ")", x, y, width, height, gl_enum_name(format), gl_enum_name(type), bufSize, AtariOffset(data)));
FN_GLREADNPIXELSARB(x, y, width, height, format, type, bufSize, data);
}

void OSMesaDriver::nfglRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
{
	D(bug("nfosmesa: glRectd(%f, %f, %f, %f)", x1, y1, x2, y2));
	fn.glRectd(x1, y1, x2, y2);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRectdv(memptr v1, memptr v2)
#else
void OSMesaDriver::nfglRectdv(const GLdouble *v1, const GLdouble *v2)
#endif
{
	D(bug("nfosmesa: glRectdv(" PRI_PTR ", " PRI_PTR ")", AtariOffset(v1), AtariOffset(v2)));
FN_GLRECTDV(v1, v2);
}

void OSMesaDriver::nfglRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
{
	D(bug("nfosmesa: glRectf(%f, %f, %f, %f)", x1, y1, x2, y2));
	fn.glRectf(x1, y1, x2, y2);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRectfv(memptr v1, memptr v2)
#else
void OSMesaDriver::nfglRectfv(const GLfloat *v1, const GLfloat *v2)
#endif
{
	D(bug("nfosmesa: glRectfv(" PRI_PTR ", " PRI_PTR ")", AtariOffset(v1), AtariOffset(v2)));
FN_GLRECTFV(v1, v2);
}

void OSMesaDriver::nfglRecti(GLint x1, GLint y1, GLint x2, GLint y2)
{
	D(bug("nfosmesa: glRecti(%d, %d, %d, %d)", x1, y1, x2, y2));
	fn.glRecti(x1, y1, x2, y2);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRectiv(memptr v1, memptr v2)
#else
void OSMesaDriver::nfglRectiv(const GLint *v1, const GLint *v2)
#endif
{
	D(bug("nfosmesa: glRectiv(" PRI_PTR ", " PRI_PTR ")", AtariOffset(v1), AtariOffset(v2)));
FN_GLRECTIV(v1, v2);
}

void OSMesaDriver::nfglRects(GLshort32 x1, GLshort32 y1, GLshort32 x2, GLshort32 y2)
{
	D(bug("nfosmesa: glRects(%d, %d, %d, %d)", x1, y1, x2, y2));
	fn.glRects(x1, y1, x2, y2);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRectsv(memptr v1, memptr v2)
#else
void OSMesaDriver::nfglRectsv(const GLshort *v1, const GLshort *v2)
#endif
{
	D(bug("nfosmesa: glRectsv(" PRI_PTR ", " PRI_PTR ")", AtariOffset(v1), AtariOffset(v2)));
FN_GLRECTSV(v1, v2);
}

void OSMesaDriver::nfglRectxOES(GLfixed x1, GLfixed y1, GLfixed x2, GLfixed y2)
{
	D(bug("nfosmesa: glRectxOES(0x%x, 0x%x, 0x%x, 0x%x)", x1, y1, x2, y2));
	fn.glRectxOES(x1, y1, x2, y2);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRectxvOES(memptr v1, memptr v2)
#else
void OSMesaDriver::nfglRectxvOES(const GLfixed *v1, const GLfixed *v2)
#endif
{
	D(bug("nfosmesa: glRectxvOES(" PRI_PTR ", " PRI_PTR ")", AtariOffset(v1), AtariOffset(v2)));
FN_GLRECTXVOES(v1, v2);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglReferencePlaneSGIX(memptr equation)
#else
void OSMesaDriver::nfglReferencePlaneSGIX(const GLdouble *equation)
#endif
{
	D(bug("nfosmesa: glReferencePlaneSGIX(" PRI_PTR ")", AtariOffset(equation)));
FN_GLREFERENCEPLANESGIX(equation);
}

GLboolean OSMesaDriver::nfglReleaseKeyedMutexWin32EXT(GLuint memory, GLuint64 key)
{
	D(bug("nfosmesa: glReleaseKeyedMutexWin32EXT(%u, %" PRIu64 ")", memory, key));
	GLboolean __ret = fn.glReleaseKeyedMutexWin32EXT(memory, key);
	return __ret;
}

void OSMesaDriver::nfglReleaseShaderCompiler(void)
{
	D(bug("nfosmesa: glReleaseShaderCompiler()"));
	fn.glReleaseShaderCompiler();
}

void OSMesaDriver::nfglRenderGpuMaskNV(GLbitfield mask)
{
	D(bug("nfosmesa: glRenderGpuMaskNV(0x%x)", mask));
	fn.glRenderGpuMaskNV(mask);
}

GLint OSMesaDriver::nfglRenderMode(GLenum mode)
{
	D(bug("nfosmesa: glRenderMode(%s)", gl_enum_name(mode)));
FN_GLRENDERMODE(mode);
}

void OSMesaDriver::nfglRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glRenderbufferStorage(%s, %s, %d, %d)", gl_enum_name(target), gl_enum_name(internalformat), width, height));
	fn.glRenderbufferStorage(target, internalformat, width, height);
}

void OSMesaDriver::nfglRenderbufferStorageEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glRenderbufferStorageEXT(%s, %s, %d, %d)", gl_enum_name(target), gl_enum_name(internalformat), width, height));
	fn.glRenderbufferStorageEXT(target, internalformat, width, height);
}

void OSMesaDriver::nfglRenderbufferStorageMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glRenderbufferStorageMultisample(%s, %d, %s, %d, %d)", gl_enum_name(target), samples, gl_enum_name(internalformat), width, height));
	fn.glRenderbufferStorageMultisample(target, samples, internalformat, width, height);
}

void OSMesaDriver::nfglRenderbufferStorageMultisampleCoverageNV(GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLenum internalformat, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glRenderbufferStorageMultisampleCoverageNV(%s, %d, %d, %s, %d, %d)", gl_enum_name(target), coverageSamples, colorSamples, gl_enum_name(internalformat), width, height));
	fn.glRenderbufferStorageMultisampleCoverageNV(target, coverageSamples, colorSamples, internalformat, width, height);
}

void OSMesaDriver::nfglRenderbufferStorageMultisampleEXT(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glRenderbufferStorageMultisampleEXT(%s, %d, %s, %d, %d)", gl_enum_name(target), samples, gl_enum_name(internalformat), width, height));
	fn.glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglReplacementCodePointerSUN(GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglReplacementCodePointerSUN(GLenum type, GLsizei stride, const void * *pointer)
#endif
{
	D(bug("nfosmesa: glReplacementCodePointerSUN(%s, %d, " PRI_PTR ")", gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLREPLACEMENTCODEPOINTERSUN(type, stride, pointer);
}

void OSMesaDriver::nfglReplacementCodeubSUN(GLubyte32 code)
{
	D(bug("nfosmesa: glReplacementCodeubSUN(%u)", code));
	fn.glReplacementCodeubSUN(code);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglReplacementCodeubvSUN(memptr code)
#else
void OSMesaDriver::nfglReplacementCodeubvSUN(const GLubyte *code)
#endif
{
	D(bug("nfosmesa: glReplacementCodeubvSUN(" PRI_PTR ")", AtariOffset(code)));
FN_GLREPLACEMENTCODEUBVSUN(code);
}

void OSMesaDriver::nfglReplacementCodeuiColor3fVertex3fSUN(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glReplacementCodeuiColor3fVertex3fSUN(%u, %f, %f, %f, %f, %f, %f)", rc, r, g, b, x, y, z));
	fn.glReplacementCodeuiColor3fVertex3fSUN(rc, r, g, b, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglReplacementCodeuiColor3fVertex3fvSUN(memptr rc, memptr c, memptr v)
#else
void OSMesaDriver::nfglReplacementCodeuiColor3fVertex3fvSUN(const GLuint *rc, const GLfloat *c, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glReplacementCodeuiColor3fVertex3fvSUN(" PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", AtariOffset(rc), AtariOffset(c), AtariOffset(v)));
FN_GLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUN(rc, c, v);
}

void OSMesaDriver::nfglReplacementCodeuiColor4fNormal3fVertex3fSUN(GLuint rc, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glReplacementCodeuiColor4fNormal3fVertex3fSUN(%u, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)", rc, r, g, b, a, nx, ny, nz, x, y, z));
	fn.glReplacementCodeuiColor4fNormal3fVertex3fSUN(rc, r, g, b, a, nx, ny, nz, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglReplacementCodeuiColor4fNormal3fVertex3fvSUN(memptr rc, memptr c, memptr n, memptr v)
#else
void OSMesaDriver::nfglReplacementCodeuiColor4fNormal3fVertex3fvSUN(const GLuint *rc, const GLfloat *c, const GLfloat *n, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glReplacementCodeuiColor4fNormal3fVertex3fvSUN(" PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", AtariOffset(rc), AtariOffset(c), AtariOffset(n), AtariOffset(v)));
FN_GLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUN(rc, c, n, v);
}

void OSMesaDriver::nfglReplacementCodeuiColor4ubVertex3fSUN(GLuint rc, GLubyte32 r, GLubyte32 g, GLubyte32 b, GLubyte32 a, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glReplacementCodeuiColor4ubVertex3fSUN(%u, %u, %u, %u, %u, %f, %f, %f)", rc, r, g, b, a, x, y, z));
	fn.glReplacementCodeuiColor4ubVertex3fSUN(rc, r, g, b, a, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglReplacementCodeuiColor4ubVertex3fvSUN(memptr rc, memptr c, memptr v)
#else
void OSMesaDriver::nfglReplacementCodeuiColor4ubVertex3fvSUN(const GLuint *rc, const GLubyte *c, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glReplacementCodeuiColor4ubVertex3fvSUN(" PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", AtariOffset(rc), AtariOffset(c), AtariOffset(v)));
FN_GLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUN(rc, c, v);
}

void OSMesaDriver::nfglReplacementCodeuiNormal3fVertex3fSUN(GLuint rc, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glReplacementCodeuiNormal3fVertex3fSUN(%u, %f, %f, %f, %f, %f, %f)", rc, nx, ny, nz, x, y, z));
	fn.glReplacementCodeuiNormal3fVertex3fSUN(rc, nx, ny, nz, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglReplacementCodeuiNormal3fVertex3fvSUN(memptr rc, memptr n, memptr v)
#else
void OSMesaDriver::nfglReplacementCodeuiNormal3fVertex3fvSUN(const GLuint *rc, const GLfloat *n, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glReplacementCodeuiNormal3fVertex3fvSUN(" PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", AtariOffset(rc), AtariOffset(n), AtariOffset(v)));
FN_GLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUN(rc, n, v);
}

void OSMesaDriver::nfglReplacementCodeuiSUN(GLuint code)
{
	D(bug("nfosmesa: glReplacementCodeuiSUN(%u)", code));
	fn.glReplacementCodeuiSUN(code);
}

void OSMesaDriver::nfglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(%u, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)", rc, s, t, r, g, b, a, nx, ny, nz, x, y, z));
	fn.glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fSUN(rc, s, t, r, g, b, a, nx, ny, nz, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(memptr rc, memptr tc, memptr c, memptr n, memptr v)
#else
void OSMesaDriver::nfglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(const GLuint *rc, const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(" PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", AtariOffset(rc), AtariOffset(tc), AtariOffset(c), AtariOffset(n), AtariOffset(v)));
FN_GLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUN(rc, tc, c, n, v);
}

void OSMesaDriver::nfglReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(%u, %f, %f, %f, %f, %f, %f, %f, %f)", rc, s, t, nx, ny, nz, x, y, z));
	fn.glReplacementCodeuiTexCoord2fNormal3fVertex3fSUN(rc, s, t, nx, ny, nz, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(memptr rc, memptr tc, memptr n, memptr v)
#else
void OSMesaDriver::nfglReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(const GLuint *rc, const GLfloat *tc, const GLfloat *n, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(" PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", AtariOffset(rc), AtariOffset(tc), AtariOffset(n), AtariOffset(v)));
FN_GLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUN(rc, tc, n, v);
}

void OSMesaDriver::nfglReplacementCodeuiTexCoord2fVertex3fSUN(GLuint rc, GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glReplacementCodeuiTexCoord2fVertex3fSUN(%u, %f, %f, %f, %f, %f)", rc, s, t, x, y, z));
	fn.glReplacementCodeuiTexCoord2fVertex3fSUN(rc, s, t, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglReplacementCodeuiTexCoord2fVertex3fvSUN(memptr rc, memptr tc, memptr v)
#else
void OSMesaDriver::nfglReplacementCodeuiTexCoord2fVertex3fvSUN(const GLuint *rc, const GLfloat *tc, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glReplacementCodeuiTexCoord2fVertex3fvSUN(" PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", AtariOffset(rc), AtariOffset(tc), AtariOffset(v)));
FN_GLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUN(rc, tc, v);
}

void OSMesaDriver::nfglReplacementCodeuiVertex3fSUN(GLuint rc, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glReplacementCodeuiVertex3fSUN(%u, %f, %f, %f)", rc, x, y, z));
	fn.glReplacementCodeuiVertex3fSUN(rc, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglReplacementCodeuiVertex3fvSUN(memptr rc, memptr v)
#else
void OSMesaDriver::nfglReplacementCodeuiVertex3fvSUN(const GLuint *rc, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glReplacementCodeuiVertex3fvSUN(" PRI_PTR ", " PRI_PTR ")", AtariOffset(rc), AtariOffset(v)));
FN_GLREPLACEMENTCODEUIVERTEX3FVSUN(rc, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglReplacementCodeuivSUN(memptr code)
#else
void OSMesaDriver::nfglReplacementCodeuivSUN(const GLuint *code)
#endif
{
	D(bug("nfosmesa: glReplacementCodeuivSUN(" PRI_PTR ")", AtariOffset(code)));
FN_GLREPLACEMENTCODEUIVSUN(code);
}

void OSMesaDriver::nfglReplacementCodeusSUN(GLushort32 code)
{
	D(bug("nfosmesa: glReplacementCodeusSUN(%u)", code));
	fn.glReplacementCodeusSUN(code);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglReplacementCodeusvSUN(memptr code)
#else
void OSMesaDriver::nfglReplacementCodeusvSUN(const GLushort *code)
#endif
{
	D(bug("nfosmesa: glReplacementCodeusvSUN(" PRI_PTR ")", AtariOffset(code)));
FN_GLREPLACEMENTCODEUSVSUN(code);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglRequestResidentProgramsNV(GLsizei n, memptr programs)
#else
void OSMesaDriver::nfglRequestResidentProgramsNV(GLsizei n, const GLuint *programs)
#endif
{
	D(bug("nfosmesa: glRequestResidentProgramsNV(%d, " PRI_PTR ")", n, AtariOffset(programs)));
FN_GLREQUESTRESIDENTPROGRAMSNV(n, programs);
}

void OSMesaDriver::nfglResetHistogram(GLenum target)
{
	D(bug("nfosmesa: glResetHistogram(%s)", gl_enum_name(target)));
	fn.glResetHistogram(target);
}

void OSMesaDriver::nfglResetHistogramEXT(GLenum target)
{
	D(bug("nfosmesa: glResetHistogramEXT(%s)", gl_enum_name(target)));
	fn.glResetHistogramEXT(target);
}

void OSMesaDriver::nfglResetMinmax(GLenum target)
{
	D(bug("nfosmesa: glResetMinmax(%s)", gl_enum_name(target)));
	fn.glResetMinmax(target);
}

void OSMesaDriver::nfglResetMinmaxEXT(GLenum target)
{
	D(bug("nfosmesa: glResetMinmaxEXT(%s)", gl_enum_name(target)));
	fn.glResetMinmaxEXT(target);
}

void OSMesaDriver::nfglResizeBuffersMESA(void)
{
	D(bug("nfosmesa: glResizeBuffersMESA()"));
	fn.glResizeBuffersMESA();
}

void OSMesaDriver::nfglResolveDepthValuesNV(void)
{
	D(bug("nfosmesa: glResolveDepthValuesNV()"));
	fn.glResolveDepthValuesNV();
}

void OSMesaDriver::nfglResumeTransformFeedback(void)
{
	D(bug("nfosmesa: glResumeTransformFeedback()"));
	fn.glResumeTransformFeedback();
}

void OSMesaDriver::nfglResumeTransformFeedbackNV(void)
{
	D(bug("nfosmesa: glResumeTransformFeedbackNV()"));
	fn.glResumeTransformFeedbackNV();
}

void OSMesaDriver::nfglRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glRotated(%f, %f, %f, %f)", angle, x, y, z));
	fn.glRotated(angle, x, y, z);
}

void OSMesaDriver::nfglRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glRotatef(%f, %f, %f, %f)", angle, x, y, z));
	fn.glRotatef(angle, x, y, z);
}

void OSMesaDriver::nfglRotatexOES(GLfixed angle, GLfixed x, GLfixed y, GLfixed z)
{
	D(bug("nfosmesa: glRotatexOES(0x%x, 0x%x, 0x%x, 0x%x)", angle, x, y, z));
	fn.glRotatexOES(angle, x, y, z);
}

void OSMesaDriver::nfglSampleCoverage(GLfloat value, GLboolean32 invert)
{
	D(bug("nfosmesa: glSampleCoverage(%f, %d)", value, invert));
	fn.glSampleCoverage(value, invert);
}

void OSMesaDriver::nfglSampleCoverageARB(GLfloat value, GLboolean32 invert)
{
	D(bug("nfosmesa: glSampleCoverageARB(%f, %d)", value, invert));
	fn.glSampleCoverageARB(value, invert);
}

void OSMesaDriver::nfglSampleCoverageOES(GLfixed value, GLboolean32 invert)
{
	D(bug("nfosmesa: glSampleCoverageOES(0x%x, %d)", value, invert));
	fn.glSampleCoverageOES(value, invert);
}

void OSMesaDriver::nfglSampleMapATI(GLuint dst, GLuint interp, GLenum swizzle)
{
	D(bug("nfosmesa: glSampleMapATI(%u, %u, %s)", dst, interp, gl_enum_name(swizzle)));
	fn.glSampleMapATI(dst, interp, swizzle);
}

void OSMesaDriver::nfglSampleMaskEXT(GLclampf value, GLboolean32 invert)
{
	D(bug("nfosmesa: glSampleMaskEXT(%f, %d)", value, invert));
	fn.glSampleMaskEXT(value, invert);
}

void OSMesaDriver::nfglSampleMaskIndexedNV(GLuint index, GLbitfield mask)
{
	D(bug("nfosmesa: glSampleMaskIndexedNV(%u, 0x%x)", index, mask));
	fn.glSampleMaskIndexedNV(index, mask);
}

void OSMesaDriver::nfglSampleMaskSGIS(GLclampf value, GLboolean32 invert)
{
	D(bug("nfosmesa: glSampleMaskSGIS(%f, %d)", value, invert));
	fn.glSampleMaskSGIS(value, invert);
}

void OSMesaDriver::nfglSampleMaski(GLuint maskNumber, GLbitfield mask)
{
	D(bug("nfosmesa: glSampleMaski(%u, 0x%x)", maskNumber, mask));
	fn.glSampleMaski(maskNumber, mask);
}

void OSMesaDriver::nfglSamplePass(GLenum mode)
{
	D(bug("nfosmesa: glSamplePass(%s)", gl_enum_name(mode)));
	fn.glSamplePass(mode);
}

void OSMesaDriver::nfglSamplePassARB(GLenum mode)
{
	D(bug("nfosmesa: glSamplePassARB(%s)", gl_enum_name(mode)));
	fn.glSamplePassARB(mode);
}

void OSMesaDriver::nfglSamplePatternEXT(GLenum pattern)
{
	D(bug("nfosmesa: glSamplePatternEXT(%s)", gl_enum_name(pattern)));
	fn.glSamplePatternEXT(pattern);
}

void OSMesaDriver::nfglSamplePatternSGIS(GLenum pattern)
{
	D(bug("nfosmesa: glSamplePatternSGIS(%s)", gl_enum_name(pattern)));
	fn.glSamplePatternSGIS(pattern);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSamplerParameterIiv(GLuint sampler, GLenum pname, memptr param)
#else
void OSMesaDriver::nfglSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
#endif
{
	D(bug("nfosmesa: glSamplerParameterIiv(%u, %s, " PRI_PTR ")", sampler, gl_enum_name(pname), AtariOffset(param)));
FN_GLSAMPLERPARAMETERIIV(sampler, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSamplerParameterIuiv(GLuint sampler, GLenum pname, memptr param)
#else
void OSMesaDriver::nfglSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
#endif
{
	D(bug("nfosmesa: glSamplerParameterIuiv(%u, %s, " PRI_PTR ")", sampler, gl_enum_name(pname), AtariOffset(param)));
FN_GLSAMPLERPARAMETERIUIV(sampler, pname, param);
}

void OSMesaDriver::nfglSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glSamplerParameterf(%u, %s, %f)", sampler, gl_enum_name(pname), param));
	fn.glSamplerParameterf(sampler, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSamplerParameterfv(GLuint sampler, GLenum pname, memptr param)
#else
void OSMesaDriver::nfglSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
#endif
{
	D(bug("nfosmesa: glSamplerParameterfv(%u, %s, " PRI_PTR ")", sampler, gl_enum_name(pname), AtariOffset(param)));
FN_GLSAMPLERPARAMETERFV(sampler, pname, param);
}

void OSMesaDriver::nfglSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glSamplerParameteri(%u, %s, %d)", sampler, gl_enum_name(pname), param));
	fn.glSamplerParameteri(sampler, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSamplerParameteriv(GLuint sampler, GLenum pname, memptr param)
#else
void OSMesaDriver::nfglSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
#endif
{
	D(bug("nfosmesa: glSamplerParameteriv(%u, %s, " PRI_PTR ")", sampler, gl_enum_name(pname), AtariOffset(param)));
FN_GLSAMPLERPARAMETERIV(sampler, pname, param);
}

void OSMesaDriver::nfglScaled(GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glScaled(%f, %f, %f)", x, y, z));
	fn.glScaled(x, y, z);
}

void OSMesaDriver::nfglScalef(GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glScalef(%f, %f, %f)", x, y, z));
	fn.glScalef(x, y, z);
}

void OSMesaDriver::nfglScalexOES(GLfixed x, GLfixed y, GLfixed z)
{
	D(bug("nfosmesa: glScalexOES(0x%x, 0x%x, 0x%x)", x, y, z));
	fn.glScalexOES(x, y, z);
}

void OSMesaDriver::nfglScissor(GLint x, GLint y, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glScissor(%d, %d, %d, %d)", x, y, width, height));
	fn.glScissor(x, y, width, height);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglScissorArrayv(GLuint first, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglScissorArrayv(GLuint first, GLsizei count, const GLint *v)
#endif
{
	D(bug("nfosmesa: glScissorArrayv(%u, %d, " PRI_PTR ")", first, count, AtariOffset(v)));
FN_GLSCISSORARRAYV(first, count, v);
}

void OSMesaDriver::nfglScissorIndexed(GLuint index, GLint left, GLint bottom, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glScissorIndexed(%u, %d, %d, %d, %d)", index, left, bottom, width, height));
	fn.glScissorIndexed(index, left, bottom, width, height);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglScissorIndexedv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglScissorIndexedv(GLuint index, const GLint *v)
#endif
{
	D(bug("nfosmesa: glScissorIndexedv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLSCISSORINDEXEDV(index, v);
}

void OSMesaDriver::nfglSecondaryColor3b(GLbyte32 red, GLbyte32 green, GLbyte32 blue)
{
	D(bug("nfosmesa: glSecondaryColor3b(%d, %d, %d)", red, green, blue));
	fn.glSecondaryColor3b(red, green, blue);
}

void OSMesaDriver::nfglSecondaryColor3bEXT(GLbyte32 red, GLbyte32 green, GLbyte32 blue)
{
	D(bug("nfosmesa: glSecondaryColor3bEXT(%d, %d, %d)", red, green, blue));
	fn.glSecondaryColor3bEXT(red, green, blue);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColor3bv(memptr v)
#else
void OSMesaDriver::nfglSecondaryColor3bv(const GLbyte *v)
#endif
{
	D(bug("nfosmesa: glSecondaryColor3bv(" PRI_PTR ")", AtariOffset(v)));
FN_GLSECONDARYCOLOR3BV(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColor3bvEXT(memptr v)
#else
void OSMesaDriver::nfglSecondaryColor3bvEXT(const GLbyte *v)
#endif
{
	D(bug("nfosmesa: glSecondaryColor3bvEXT(" PRI_PTR ")", AtariOffset(v)));
FN_GLSECONDARYCOLOR3BVEXT(v);
}

void OSMesaDriver::nfglSecondaryColor3d(GLdouble red, GLdouble green, GLdouble blue)
{
	D(bug("nfosmesa: glSecondaryColor3d(%f, %f, %f)", red, green, blue));
	fn.glSecondaryColor3d(red, green, blue);
}

void OSMesaDriver::nfglSecondaryColor3dEXT(GLdouble red, GLdouble green, GLdouble blue)
{
	D(bug("nfosmesa: glSecondaryColor3dEXT(%f, %f, %f)", red, green, blue));
	fn.glSecondaryColor3dEXT(red, green, blue);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColor3dv(memptr v)
#else
void OSMesaDriver::nfglSecondaryColor3dv(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glSecondaryColor3dv(" PRI_PTR ")", AtariOffset(v)));
FN_GLSECONDARYCOLOR3DV(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColor3dvEXT(memptr v)
#else
void OSMesaDriver::nfglSecondaryColor3dvEXT(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glSecondaryColor3dvEXT(" PRI_PTR ")", AtariOffset(v)));
FN_GLSECONDARYCOLOR3DVEXT(v);
}

void OSMesaDriver::nfglSecondaryColor3f(GLfloat red, GLfloat green, GLfloat blue)
{
	D(bug("nfosmesa: glSecondaryColor3f(%f, %f, %f)", red, green, blue));
	fn.glSecondaryColor3f(red, green, blue);
}

void OSMesaDriver::nfglSecondaryColor3fEXT(GLfloat red, GLfloat green, GLfloat blue)
{
	D(bug("nfosmesa: glSecondaryColor3fEXT(%f, %f, %f)", red, green, blue));
	fn.glSecondaryColor3fEXT(red, green, blue);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColor3fv(memptr v)
#else
void OSMesaDriver::nfglSecondaryColor3fv(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glSecondaryColor3fv(" PRI_PTR ")", AtariOffset(v)));
FN_GLSECONDARYCOLOR3FV(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColor3fvEXT(memptr v)
#else
void OSMesaDriver::nfglSecondaryColor3fvEXT(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glSecondaryColor3fvEXT(" PRI_PTR ")", AtariOffset(v)));
FN_GLSECONDARYCOLOR3FVEXT(v);
}

void OSMesaDriver::nfglSecondaryColor3hNV(GLhalfNV32 red, GLhalfNV32 green, GLhalfNV32 blue)
{
	D(bug("nfosmesa: glSecondaryColor3hNV(%u, %u, %u)", red, green, blue));
	fn.glSecondaryColor3hNV(red, green, blue);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColor3hvNV(memptr v)
#else
void OSMesaDriver::nfglSecondaryColor3hvNV(const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glSecondaryColor3hvNV(" PRI_PTR ")", AtariOffset(v)));
FN_GLSECONDARYCOLOR3HVNV(v);
}

void OSMesaDriver::nfglSecondaryColor3i(GLint red, GLint green, GLint blue)
{
	D(bug("nfosmesa: glSecondaryColor3i(%d, %d, %d)", red, green, blue));
	fn.glSecondaryColor3i(red, green, blue);
}

void OSMesaDriver::nfglSecondaryColor3iEXT(GLint red, GLint green, GLint blue)
{
	D(bug("nfosmesa: glSecondaryColor3iEXT(%d, %d, %d)", red, green, blue));
	fn.glSecondaryColor3iEXT(red, green, blue);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColor3iv(memptr v)
#else
void OSMesaDriver::nfglSecondaryColor3iv(const GLint *v)
#endif
{
	D(bug("nfosmesa: glSecondaryColor3iv(" PRI_PTR ")", AtariOffset(v)));
FN_GLSECONDARYCOLOR3IV(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColor3ivEXT(memptr v)
#else
void OSMesaDriver::nfglSecondaryColor3ivEXT(const GLint *v)
#endif
{
	D(bug("nfosmesa: glSecondaryColor3ivEXT(" PRI_PTR ")", AtariOffset(v)));
FN_GLSECONDARYCOLOR3IVEXT(v);
}

void OSMesaDriver::nfglSecondaryColor3s(GLshort32 red, GLshort32 green, GLshort32 blue)
{
	D(bug("nfosmesa: glSecondaryColor3s(%d, %d, %d)", red, green, blue));
	fn.glSecondaryColor3s(red, green, blue);
}

void OSMesaDriver::nfglSecondaryColor3sEXT(GLshort32 red, GLshort32 green, GLshort32 blue)
{
	D(bug("nfosmesa: glSecondaryColor3sEXT(%d, %d, %d)", red, green, blue));
	fn.glSecondaryColor3sEXT(red, green, blue);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColor3sv(memptr v)
#else
void OSMesaDriver::nfglSecondaryColor3sv(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glSecondaryColor3sv(" PRI_PTR ")", AtariOffset(v)));
FN_GLSECONDARYCOLOR3SV(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColor3svEXT(memptr v)
#else
void OSMesaDriver::nfglSecondaryColor3svEXT(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glSecondaryColor3svEXT(" PRI_PTR ")", AtariOffset(v)));
FN_GLSECONDARYCOLOR3SVEXT(v);
}

void OSMesaDriver::nfglSecondaryColor3ub(GLubyte32 red, GLubyte32 green, GLubyte32 blue)
{
	D(bug("nfosmesa: glSecondaryColor3ub(%u, %u, %u)", red, green, blue));
	fn.glSecondaryColor3ub(red, green, blue);
}

void OSMesaDriver::nfglSecondaryColor3ubEXT(GLubyte32 red, GLubyte32 green, GLubyte32 blue)
{
	D(bug("nfosmesa: glSecondaryColor3ubEXT(%u, %u, %u)", red, green, blue));
	fn.glSecondaryColor3ubEXT(red, green, blue);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColor3ubv(memptr v)
#else
void OSMesaDriver::nfglSecondaryColor3ubv(const GLubyte *v)
#endif
{
	D(bug("nfosmesa: glSecondaryColor3ubv(" PRI_PTR ")", AtariOffset(v)));
FN_GLSECONDARYCOLOR3UBV(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColor3ubvEXT(memptr v)
#else
void OSMesaDriver::nfglSecondaryColor3ubvEXT(const GLubyte *v)
#endif
{
	D(bug("nfosmesa: glSecondaryColor3ubvEXT(" PRI_PTR ")", AtariOffset(v)));
FN_GLSECONDARYCOLOR3UBVEXT(v);
}

void OSMesaDriver::nfglSecondaryColor3ui(GLuint red, GLuint green, GLuint blue)
{
	D(bug("nfosmesa: glSecondaryColor3ui(%u, %u, %u)", red, green, blue));
	fn.glSecondaryColor3ui(red, green, blue);
}

void OSMesaDriver::nfglSecondaryColor3uiEXT(GLuint red, GLuint green, GLuint blue)
{
	D(bug("nfosmesa: glSecondaryColor3uiEXT(%u, %u, %u)", red, green, blue));
	fn.glSecondaryColor3uiEXT(red, green, blue);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColor3uiv(memptr v)
#else
void OSMesaDriver::nfglSecondaryColor3uiv(const GLuint *v)
#endif
{
	D(bug("nfosmesa: glSecondaryColor3uiv(" PRI_PTR ")", AtariOffset(v)));
FN_GLSECONDARYCOLOR3UIV(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColor3uivEXT(memptr v)
#else
void OSMesaDriver::nfglSecondaryColor3uivEXT(const GLuint *v)
#endif
{
	D(bug("nfosmesa: glSecondaryColor3uivEXT(" PRI_PTR ")", AtariOffset(v)));
FN_GLSECONDARYCOLOR3UIVEXT(v);
}

void OSMesaDriver::nfglSecondaryColor3us(GLushort32 red, GLushort32 green, GLushort32 blue)
{
	D(bug("nfosmesa: glSecondaryColor3us(%u, %u, %u)", red, green, blue));
	fn.glSecondaryColor3us(red, green, blue);
}

void OSMesaDriver::nfglSecondaryColor3usEXT(GLushort32 red, GLushort32 green, GLushort32 blue)
{
	D(bug("nfosmesa: glSecondaryColor3usEXT(%u, %u, %u)", red, green, blue));
	fn.glSecondaryColor3usEXT(red, green, blue);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColor3usv(memptr v)
#else
void OSMesaDriver::nfglSecondaryColor3usv(const GLushort *v)
#endif
{
	D(bug("nfosmesa: glSecondaryColor3usv(" PRI_PTR ")", AtariOffset(v)));
FN_GLSECONDARYCOLOR3USV(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColor3usvEXT(memptr v)
#else
void OSMesaDriver::nfglSecondaryColor3usvEXT(const GLushort *v)
#endif
{
	D(bug("nfosmesa: glSecondaryColor3usvEXT(" PRI_PTR ")", AtariOffset(v)));
FN_GLSECONDARYCOLOR3USVEXT(v);
}

void OSMesaDriver::nfglSecondaryColorFormatNV(GLint size, GLenum type, GLsizei stride)
{
	D(bug("nfosmesa: glSecondaryColorFormatNV(%d, %s, %d)", size, gl_enum_name(type), stride));
	fn.glSecondaryColorFormatNV(size, type, stride);
}

void OSMesaDriver::nfglSecondaryColorP3ui(GLenum type, GLuint color)
{
	D(bug("nfosmesa: glSecondaryColorP3ui(%s, %u)", gl_enum_name(type), color));
	fn.glSecondaryColorP3ui(type, color);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColorP3uiv(GLenum type, memptr color)
#else
void OSMesaDriver::nfglSecondaryColorP3uiv(GLenum type, const GLuint *color)
#endif
{
	D(bug("nfosmesa: glSecondaryColorP3uiv(%s, " PRI_PTR ")", gl_enum_name(type), AtariOffset(color)));
FN_GLSECONDARYCOLORP3UIV(type, color);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
#endif
{
	D(bug("nfosmesa: glSecondaryColorPointer(%d, %s, %d, " PRI_PTR ")", size, gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLSECONDARYCOLORPOINTER(size, type, stride, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColorPointerEXT(GLint size, GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglSecondaryColorPointerEXT(GLint size, GLenum type, GLsizei stride, const void *pointer)
#endif
{
	D(bug("nfosmesa: glSecondaryColorPointerEXT(%d, %s, %d, " PRI_PTR ")", size, gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLSECONDARYCOLORPOINTEREXT(size, type, stride, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSecondaryColorPointerListIBM(GLint size, GLenum type, GLint stride, memptr pointer, GLint ptrstride)
#else
void OSMesaDriver::nfglSecondaryColorPointerListIBM(GLint size, GLenum type, GLint stride, const void * *pointer, GLint ptrstride)
#endif
{
	D(bug("nfosmesa: glSecondaryColorPointerListIBM(%d, %s, %d, " PRI_PTR ", %d)", size, gl_enum_name(type), stride, AtariOffset(pointer), ptrstride));
FN_GLSECONDARYCOLORPOINTERLISTIBM(size, type, stride, pointer, ptrstride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSelectBuffer(GLsizei size, memptr buffer)
#else
void OSMesaDriver::nfglSelectBuffer(GLsizei size, GLuint *buffer)
#endif
{
	D(bug("nfosmesa: glSelectBuffer(%d, " PRI_PTR ")", size, AtariOffset(buffer)));
FN_GLSELECTBUFFER(size, buffer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSelectPerfMonitorCountersAMD(GLuint monitor, GLboolean32 enable, GLuint group, GLint numCounters, memptr counterList)
#else
void OSMesaDriver::nfglSelectPerfMonitorCountersAMD(GLuint monitor, GLboolean32 enable, GLuint group, GLint numCounters, GLuint *counterList)
#endif
{
	D(bug("nfosmesa: glSelectPerfMonitorCountersAMD(%u, %d, %u, %d, " PRI_PTR ")", monitor, enable, group, numCounters, AtariOffset(counterList)));
FN_GLSELECTPERFMONITORCOUNTERSAMD(monitor, enable, group, numCounters, counterList);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSemaphoreParameterui64vEXT(GLuint semaphore, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglSemaphoreParameterui64vEXT(GLuint semaphore, GLenum pname, const GLuint64 *params)
#endif
{
	D(bug("nfosmesa: glSemaphoreParameterui64vEXT(%u, %s, " PRI_PTR ")", semaphore, gl_enum_name(pname), AtariOffset(params)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __params_size = nfglGetNumParams(pname);
	GLuint64 __params_tmp[__params_size];
	GLuint64 *__params_ptmp = Atari2HostInt64Array(__params_size, params, __params_tmp);
	fn.glSemaphoreParameterui64vEXT(semaphore, pname, __params_ptmp);
#else
	fn.glSemaphoreParameterui64vEXT(semaphore, pname, HostAddr(params, const GLuint64 *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, memptr row, memptr column)
#else
void OSMesaDriver::nfglSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column)
#endif
{
	D(bug("nfosmesa: glSeparableFilter2D(%s, %s, %d, %d, %s, %s, " PRI_PTR ", " PRI_PTR ")", gl_enum_name(target), gl_enum_name(internalformat), width, height, gl_enum_name(format), gl_enum_name(type), AtariOffset(row), AtariOffset(column)));
FN_GLSEPARABLEFILTER2D(target, internalformat, width, height, format, type, row, column);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSeparableFilter2DEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, memptr row, memptr column)
#else
void OSMesaDriver::nfglSeparableFilter2DEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column)
#endif
{
	D(bug("nfosmesa: glSeparableFilter2DEXT(%s, %s, %d, %d, %s, %s, " PRI_PTR ", " PRI_PTR ")", gl_enum_name(target), gl_enum_name(internalformat), width, height, gl_enum_name(format), gl_enum_name(type), AtariOffset(row), AtariOffset(column)));
FN_GLSEPARABLEFILTER2DEXT(target, internalformat, width, height, format, type, row, column);
}

void OSMesaDriver::nfglSetFenceAPPLE(GLuint fence)
{
	D(bug("nfosmesa: glSetFenceAPPLE(%u)", fence));
	fn.glSetFenceAPPLE(fence);
}

void OSMesaDriver::nfglSetFenceNV(GLuint fence, GLenum condition)
{
	D(bug("nfosmesa: glSetFenceNV(%u, %s)", fence, gl_enum_name(condition)));
	fn.glSetFenceNV(fence, condition);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSetFragmentShaderConstantATI(GLuint dst, memptr value)
#else
void OSMesaDriver::nfglSetFragmentShaderConstantATI(GLuint dst, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glSetFragmentShaderConstantATI(%u, " PRI_PTR ")", dst, AtariOffset(value)));
FN_GLSETFRAGMENTSHADERCONSTANTATI(dst, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSetInvariantEXT(GLuint id, GLenum type, memptr addr)
#else
void OSMesaDriver::nfglSetInvariantEXT(GLuint id, GLenum type, const void *addr)
#endif
{
	D(bug("nfosmesa: glSetInvariantEXT(%u, %s, " PRI_PTR ")", id, gl_enum_name(type), AtariOffset(addr)));
FN_GLSETINVARIANTEXT(id, type, addr);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSetLocalConstantEXT(GLuint id, GLenum type, memptr addr)
#else
void OSMesaDriver::nfglSetLocalConstantEXT(GLuint id, GLenum type, const void *addr)
#endif
{
	D(bug("nfosmesa: glSetLocalConstantEXT(%u, %s, " PRI_PTR ")", id, gl_enum_name(type), AtariOffset(addr)));
FN_GLSETLOCALCONSTANTEXT(id, type, addr);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSetMultisamplefvAMD(GLenum pname, GLuint index, memptr val)
#else
void OSMesaDriver::nfglSetMultisamplefvAMD(GLenum pname, GLuint index, const GLfloat *val)
#endif
{
	D(bug("nfosmesa: glSetMultisamplefvAMD(%s, %u, " PRI_PTR ")", gl_enum_name(pname), index, AtariOffset(val)));
FN_GLSETMULTISAMPLEFVAMD(pname, index, val);
}

void OSMesaDriver::nfglShadeModel(GLenum mode)
{
	D(bug("nfosmesa: glShadeModel(%s)", gl_enum_name(mode)));
	fn.glShadeModel(mode);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglShaderBinary(GLsizei count, memptr shaders, GLenum binaryformat, memptr binary, GLsizei length)
#else
void OSMesaDriver::nfglShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length)
#endif
{
	D(bug("nfosmesa: glShaderBinary(%d, " PRI_PTR ", %s, " PRI_PTR ", %d)", count, AtariOffset(shaders), gl_enum_name(binaryformat), AtariOffset(binary), length));
FN_GLSHADERBINARY(count, shaders, binaryformat, binary, length);
}

void OSMesaDriver::nfglShaderOp1EXT(GLenum op, GLuint res, GLuint arg1)
{
	D(bug("nfosmesa: glShaderOp1EXT(%s, %u, %u)", gl_enum_name(op), res, arg1));
	fn.glShaderOp1EXT(op, res, arg1);
}

void OSMesaDriver::nfglShaderOp2EXT(GLenum op, GLuint res, GLuint arg1, GLuint arg2)
{
	D(bug("nfosmesa: glShaderOp2EXT(%s, %u, %u, %u)", gl_enum_name(op), res, arg1, arg2));
	fn.glShaderOp2EXT(op, res, arg1, arg2);
}

void OSMesaDriver::nfglShaderOp3EXT(GLenum op, GLuint res, GLuint arg1, GLuint arg2, GLuint arg3)
{
	D(bug("nfosmesa: glShaderOp3EXT(%s, %u, %u, %u, %u)", gl_enum_name(op), res, arg1, arg2, arg3));
	fn.glShaderOp3EXT(op, res, arg1, arg2, arg3);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglShaderSource(GLuint shader, GLsizei count, memptr string, memptr length)
#else
void OSMesaDriver::nfglShaderSource(GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length)
#endif
{
	D(bug("nfosmesa: glShaderSource(%u, %d, " PRI_PTR ", " PRI_PTR ")", shader, count, AtariOffset(string), AtariOffset(length)));
FN_GLSHADERSOURCE(shader, count, string, length);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglShaderSourceARB(GLhandleARB shaderObj, GLsizei count, memptr string, memptr length)
#else
void OSMesaDriver::nfglShaderSourceARB(GLhandleARB shaderObj, GLsizei count, const GLcharARB * *string, const GLint *length)
#endif
{
	D(bug("nfosmesa: glShaderSourceARB(%u, %d, " PRI_PTR ", " PRI_PTR ")", (unsigned int)(uintptr_t)shaderObj, count, AtariOffset(string), AtariOffset(length)));
FN_GLSHADERSOURCEARB(shaderObj, count, string, length);
}

void OSMesaDriver::nfglShaderStorageBlockBinding(GLuint program, GLuint storageBlockIndex, GLuint storageBlockBinding)
{
	D(bug("nfosmesa: glShaderStorageBlockBinding(%u, %u, %u)", program, storageBlockIndex, storageBlockBinding));
	fn.glShaderStorageBlockBinding(program, storageBlockIndex, storageBlockBinding);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSharpenTexFuncSGIS(GLenum target, GLsizei n, memptr points)
#else
void OSMesaDriver::nfglSharpenTexFuncSGIS(GLenum target, GLsizei n, const GLfloat *points)
#endif
{
	D(bug("nfosmesa: glSharpenTexFuncSGIS(%s, %d, " PRI_PTR ")", gl_enum_name(target), n, AtariOffset(points)));
FN_GLSHARPENTEXFUNCSGIS(target, n, points);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSignalSemaphoreEXT(GLuint semaphore, GLuint numBufferBarriers, memptr buffers, GLuint numTextureBarriers, memptr textures, memptr dstLayouts)
#else
void OSMesaDriver::nfglSignalSemaphoreEXT(GLuint semaphore, GLuint numBufferBarriers, const GLuint *buffers, GLuint numTextureBarriers, const GLuint *textures, const GLenum *dstLayouts)
#endif
{
	D(bug("nfosmesa: glSignalSemaphoreEXT(%u, %u, " PRI_PTR ", %u, " PRI_PTR ", " PRI_PTR ")", semaphore, numBufferBarriers, AtariOffset(buffers), numTextureBarriers, AtariOffset(textures), AtariOffset(dstLayouts)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __buffers_size = MAX(numBufferBarriers, 0);
	GLuint __buffers_tmp[__buffers_size];
	GLuint *__buffers_ptmp = Atari2HostIntArray(__buffers_size, buffers, __buffers_tmp);
	GLint const __textures_size = MAX(numTextureBarriers, 0);
	GLuint __textures_tmp[__textures_size];
	GLuint *__textures_ptmp = Atari2HostIntArray(__textures_size, textures, __textures_tmp);
	GLint const __dstLayouts_size = MAX(numTextureBarriers, 0);
	GLenum __dstLayouts_tmp[__dstLayouts_size];
	GLenum *__dstLayouts_ptmp = Atari2HostIntArray(__dstLayouts_size, dstLayouts, __dstLayouts_tmp);
	fn.glSignalSemaphoreEXT(semaphore, numBufferBarriers, __buffers_ptmp, numTextureBarriers, __textures_ptmp, __dstLayouts_ptmp);
#else
	fn.glSignalSemaphoreEXT(semaphore, numBufferBarriers, HostAddr(buffers, const GLuint *), numTextureBarriers, HostAddr(textures, const GLuint *), HostAddr(dstLayouts, const GLenum *));
#endif
}

void OSMesaDriver::nfglSignalVkFenceNV(GLuint64 vkFence)
{
	D(bug("nfosmesa: glSignalVkFenceNV(%" PRIu64 ")", vkFence));
	fn.glSignalVkFenceNV(vkFence);
}

void OSMesaDriver::nfglSignalVkSemaphoreNV(GLuint64 vkSemaphore)
{
	D(bug("nfosmesa: glSignalVkSemaphoreNV(%" PRIu64 ")", vkSemaphore));
	fn.glSignalVkSemaphoreNV(vkSemaphore);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSpecializeShader(GLuint shader, memptr pEntryPoint, GLuint numSpecializationConstants, memptr pConstantIndex, memptr pConstantValue)
#else
void OSMesaDriver::nfglSpecializeShader(GLuint shader, const GLchar *pEntryPoint, GLuint numSpecializationConstants, const GLuint *pConstantIndex, const GLuint *pConstantValue)
#endif
{
	D(bug("nfosmesa: glSpecializeShader(%u, " PRI_PTR ", %u, " PRI_PTR ", " PRI_PTR ")", shader, AtariOffset(pEntryPoint), numSpecializationConstants, AtariOffset(pConstantIndex), AtariOffset(pConstantValue)));
#if NFOSMESA_NEED_BYTE_CONV || NFOSMESA_NEED_INT_CONV
	GLint const __pEntryPoint_size = safe_strlen(pEntryPoint) + 1;
	GLchar __pEntryPoint_tmp[__pEntryPoint_size];
	GLchar *__pEntryPoint_ptmp = Atari2HostByteArray(__pEntryPoint_size, pEntryPoint, __pEntryPoint_tmp);
	GLint const __pConstantIndex_size = MAX(numSpecializationConstants, 0);
	GLuint __pConstantIndex_tmp[__pConstantIndex_size];
	GLuint *__pConstantIndex_ptmp = Atari2HostIntArray(__pConstantIndex_size, pConstantIndex, __pConstantIndex_tmp);
	GLint const __pConstantValue_size = MAX(numSpecializationConstants, 0);
	GLuint __pConstantValue_tmp[__pConstantValue_size];
	GLuint *__pConstantValue_ptmp = Atari2HostIntArray(__pConstantValue_size, pConstantValue, __pConstantValue_tmp);
	fn.glSpecializeShader(shader, __pEntryPoint_ptmp, numSpecializationConstants, __pConstantIndex_ptmp, __pConstantValue_ptmp);
#else
	fn.glSpecializeShader(shader, HostAddr(pEntryPoint, const GLchar *), numSpecializationConstants, HostAddr(pConstantIndex, const GLuint *), HostAddr(pConstantValue, const GLuint *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSpecializeShaderARB(GLuint shader, memptr pEntryPoint, GLuint numSpecializationConstants, memptr pConstantIndex, memptr pConstantValue)
#else
void OSMesaDriver::nfglSpecializeShaderARB(GLuint shader, const GLchar *pEntryPoint, GLuint numSpecializationConstants, const GLuint *pConstantIndex, const GLuint *pConstantValue)
#endif
{
	D(bug("nfosmesa: glSpecializeShaderARB(%u, " PRI_PTR ", %u, " PRI_PTR ", " PRI_PTR ")", shader, AtariOffset(pEntryPoint), numSpecializationConstants, AtariOffset(pConstantIndex), AtariOffset(pConstantValue)));
#if NFOSMESA_NEED_BYTE_CONV || NFOSMESA_NEED_INT_CONV
	GLint const __pEntryPoint_size = safe_strlen(pEntryPoint) + 1;
	GLchar __pEntryPoint_tmp[__pEntryPoint_size];
	GLchar *__pEntryPoint_ptmp = Atari2HostByteArray(__pEntryPoint_size, pEntryPoint, __pEntryPoint_tmp);
	GLint const __pConstantIndex_size = MAX(numSpecializationConstants, 0);
	GLuint __pConstantIndex_tmp[__pConstantIndex_size];
	GLuint *__pConstantIndex_ptmp = Atari2HostIntArray(__pConstantIndex_size, pConstantIndex, __pConstantIndex_tmp);
	GLint const __pConstantValue_size = MAX(numSpecializationConstants, 0);
	GLuint __pConstantValue_tmp[__pConstantValue_size];
	GLuint *__pConstantValue_ptmp = Atari2HostIntArray(__pConstantValue_size, pConstantValue, __pConstantValue_tmp);
	fn.glSpecializeShaderARB(shader, __pEntryPoint_ptmp, numSpecializationConstants, __pConstantIndex_ptmp, __pConstantValue_ptmp);
#else
	fn.glSpecializeShaderARB(shader, HostAddr(pEntryPoint, const GLchar *), numSpecializationConstants, HostAddr(pConstantIndex, const GLuint *), HostAddr(pConstantValue, const GLuint *));
#endif
}

void OSMesaDriver::nfglSpriteParameterfSGIX(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glSpriteParameterfSGIX(%s, %f)", gl_enum_name(pname), param));
	fn.glSpriteParameterfSGIX(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSpriteParameterfvSGIX(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglSpriteParameterfvSGIX(GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glSpriteParameterfvSGIX(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLSPRITEPARAMETERFVSGIX(pname, params);
}

void OSMesaDriver::nfglSpriteParameteriSGIX(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glSpriteParameteriSGIX(%s, %d)", gl_enum_name(pname), param));
	fn.glSpriteParameteriSGIX(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglSpriteParameterivSGIX(GLenum pname, memptr params)
#else
void OSMesaDriver::nfglSpriteParameterivSGIX(GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glSpriteParameterivSGIX(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(params)));
FN_GLSPRITEPARAMETERIVSGIX(pname, params);
}

void OSMesaDriver::nfglStartInstrumentsSGIX(void)
{
	D(bug("nfosmesa: glStartInstrumentsSGIX()"));
	fn.glStartInstrumentsSGIX();
}

void OSMesaDriver::nfglStateCaptureNV(GLuint state, GLenum mode)
{
	D(bug("nfosmesa: glStateCaptureNV(%u, %s)", state, gl_enum_name(mode)));
	fn.glStateCaptureNV(state, mode);
}

void OSMesaDriver::nfglStencilClearTagEXT(GLsizei stencilTagBits, GLuint stencilClearTag)
{
	D(bug("nfosmesa: glStencilClearTagEXT(%d, %u)", stencilTagBits, stencilClearTag));
	fn.glStencilClearTagEXT(stencilTagBits, stencilClearTag);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglStencilFillPathInstancedNV(GLsizei numPaths, GLenum pathNameType, memptr paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum transformType, memptr transformValues)
#else
void OSMesaDriver::nfglStencilFillPathInstancedNV(GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum transformType, const GLfloat *transformValues)
#endif
{
	D(bug("nfosmesa: glStencilFillPathInstancedNV(%d, %s, " PRI_PTR ", %u, %s, %u, %s, " PRI_PTR ")", numPaths, gl_enum_name(pathNameType), AtariOffset(paths), pathBase, gl_enum_name(fillMode), mask, gl_enum_name(transformType), AtariOffset(transformValues)));
FN_GLSTENCILFILLPATHINSTANCEDNV(numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues);
}

void OSMesaDriver::nfglStencilFillPathNV(GLuint path, GLenum fillMode, GLuint mask)
{
	D(bug("nfosmesa: glStencilFillPathNV(%u, %s, %u)", path, gl_enum_name(fillMode), mask));
	fn.glStencilFillPathNV(path, fillMode, mask);
}

void OSMesaDriver::nfglStencilFunc(GLenum func, GLint ref, GLuint mask)
{
	D(bug("nfosmesa: glStencilFunc(%s, %d, %u)", gl_enum_name(func), ref, mask));
	fn.glStencilFunc(func, ref, mask);
}

void OSMesaDriver::nfglStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
{
	D(bug("nfosmesa: glStencilFuncSeparate(%s, %s, %d, %u)", gl_enum_name(face), gl_enum_name(func), ref, mask));
	fn.glStencilFuncSeparate(face, func, ref, mask);
}

void OSMesaDriver::nfglStencilFuncSeparateATI(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask)
{
	D(bug("nfosmesa: glStencilFuncSeparateATI(%s, %s, %d, %u)", gl_enum_name(frontfunc), gl_enum_name(backfunc), ref, mask));
	fn.glStencilFuncSeparateATI(frontfunc, backfunc, ref, mask);
}

void OSMesaDriver::nfglStencilMask(GLuint mask)
{
	D(bug("nfosmesa: glStencilMask(%u)", mask));
	fn.glStencilMask(mask);
}

void OSMesaDriver::nfglStencilMaskSeparate(GLenum face, GLuint mask)
{
	D(bug("nfosmesa: glStencilMaskSeparate(%s, %u)", gl_enum_name(face), mask));
	fn.glStencilMaskSeparate(face, mask);
}

void OSMesaDriver::nfglStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
{
	D(bug("nfosmesa: glStencilOp(%s, %s, %s)", gl_enum_name(fail), gl_enum_name(zfail), gl_enum_name(zpass)));
	fn.glStencilOp(fail, zfail, zpass);
}

void OSMesaDriver::nfglStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
{
	D(bug("nfosmesa: glStencilOpSeparate(%s, %s, %s, %s)", gl_enum_name(face), gl_enum_name(sfail), gl_enum_name(dpfail), gl_enum_name(dppass)));
	fn.glStencilOpSeparate(face, sfail, dpfail, dppass);
}

void OSMesaDriver::nfglStencilOpSeparateATI(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
{
	D(bug("nfosmesa: glStencilOpSeparateATI(%s, %s, %s, %s)", gl_enum_name(face), gl_enum_name(sfail), gl_enum_name(dpfail), gl_enum_name(dppass)));
	fn.glStencilOpSeparateATI(face, sfail, dpfail, dppass);
}

void OSMesaDriver::nfglStencilOpValueAMD(GLenum face, GLuint value)
{
	D(bug("nfosmesa: glStencilOpValueAMD(%s, %u)", gl_enum_name(face), value));
	fn.glStencilOpValueAMD(face, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglStencilStrokePathInstancedNV(GLsizei numPaths, GLenum pathNameType, memptr paths, GLuint pathBase, GLint reference, GLuint mask, GLenum transformType, memptr transformValues)
#else
void OSMesaDriver::nfglStencilStrokePathInstancedNV(GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLint reference, GLuint mask, GLenum transformType, const GLfloat *transformValues)
#endif
{
	D(bug("nfosmesa: glStencilStrokePathInstancedNV(%d, %s, " PRI_PTR ", %u, %d, %u, %s, " PRI_PTR ")", numPaths, gl_enum_name(pathNameType), AtariOffset(paths), pathBase, reference, mask, gl_enum_name(transformType), AtariOffset(transformValues)));
FN_GLSTENCILSTROKEPATHINSTANCEDNV(numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues);
}

void OSMesaDriver::nfglStencilStrokePathNV(GLuint path, GLint reference, GLuint mask)
{
	D(bug("nfosmesa: glStencilStrokePathNV(%u, %d, %u)", path, reference, mask));
	fn.glStencilStrokePathNV(path, reference, mask);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglStencilThenCoverFillPathInstancedNV(GLsizei numPaths, GLenum pathNameType, memptr paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum coverMode, GLenum transformType, memptr transformValues)
#else
void OSMesaDriver::nfglStencilThenCoverFillPathInstancedNV(GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat *transformValues)
#endif
{
	D(bug("nfosmesa: glStencilThenCoverFillPathInstancedNV(%d, %s, " PRI_PTR ", %u, %s, %u, %s, %s, " PRI_PTR ")", numPaths, gl_enum_name(pathNameType), AtariOffset(paths), pathBase, gl_enum_name(fillMode), mask, gl_enum_name(coverMode), gl_enum_name(transformType), AtariOffset(transformValues)));
FN_GLSTENCILTHENCOVERFILLPATHINSTANCEDNV(numPaths, pathNameType, paths, pathBase, fillMode, mask, coverMode, transformType, transformValues);
}

void OSMesaDriver::nfglStencilThenCoverFillPathNV(GLuint path, GLenum fillMode, GLuint mask, GLenum coverMode)
{
	D(bug("nfosmesa: glStencilThenCoverFillPathNV(%u, %s, %u, %s)", path, gl_enum_name(fillMode), mask, gl_enum_name(coverMode)));
	fn.glStencilThenCoverFillPathNV(path, fillMode, mask, coverMode);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglStencilThenCoverStrokePathInstancedNV(GLsizei numPaths, GLenum pathNameType, memptr paths, GLuint pathBase, GLint reference, GLuint mask, GLenum coverMode, GLenum transformType, memptr transformValues)
#else
void OSMesaDriver::nfglStencilThenCoverStrokePathInstancedNV(GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLint reference, GLuint mask, GLenum coverMode, GLenum transformType, const GLfloat *transformValues)
#endif
{
	D(bug("nfosmesa: glStencilThenCoverStrokePathInstancedNV(%d, %s, " PRI_PTR ", %u, %d, %u, %s, %s, " PRI_PTR ")", numPaths, gl_enum_name(pathNameType), AtariOffset(paths), pathBase, reference, mask, gl_enum_name(coverMode), gl_enum_name(transformType), AtariOffset(transformValues)));
FN_GLSTENCILTHENCOVERSTROKEPATHINSTANCEDNV(numPaths, pathNameType, paths, pathBase, reference, mask, coverMode, transformType, transformValues);
}

void OSMesaDriver::nfglStencilThenCoverStrokePathNV(GLuint path, GLint reference, GLuint mask, GLenum coverMode)
{
	D(bug("nfosmesa: glStencilThenCoverStrokePathNV(%u, %d, %u, %s)", path, reference, mask, gl_enum_name(coverMode)));
	fn.glStencilThenCoverStrokePathNV(path, reference, mask, coverMode);
}

void OSMesaDriver::nfglStopInstrumentsSGIX(GLint marker)
{
	D(bug("nfosmesa: glStopInstrumentsSGIX(%d)", marker));
	fn.glStopInstrumentsSGIX(marker);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglStringMarkerGREMEDY(GLsizei len, memptr string)
#else
void OSMesaDriver::nfglStringMarkerGREMEDY(GLsizei len, const void *string)
#endif
{
	D(bug("nfosmesa: glStringMarkerGREMEDY(%d, " PRI_PTR ")", len, AtariOffset(string)));
FN_GLSTRINGMARKERGREMEDY(len, string);
}

void OSMesaDriver::nfglSubpixelPrecisionBiasNV(GLuint xbits, GLuint ybits)
{
	D(bug("nfosmesa: glSubpixelPrecisionBiasNV(%u, %u)", xbits, ybits));
	fn.glSubpixelPrecisionBiasNV(xbits, ybits);
}

void OSMesaDriver::nfglSwapAPPLE(void)
{
	D(bug("nfosmesa: glSwapAPPLE()"));
	fn.glSwapAPPLE();
}

void OSMesaDriver::nfglSwizzleEXT(GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW)
{
	D(bug("nfosmesa: glSwizzleEXT(%u, %u, %s, %s, %s, %s)", res, in, gl_enum_name(outX), gl_enum_name(outY), gl_enum_name(outZ), gl_enum_name(outW)));
	fn.glSwizzleEXT(res, in, outX, outY, outZ, outW);
}

void OSMesaDriver::nfglSyncTextureINTEL(GLuint texture)
{
	D(bug("nfosmesa: glSyncTextureINTEL(%u)", texture));
	fn.glSyncTextureINTEL(texture);
}

void OSMesaDriver::nfglTagSampleBufferSGIX(void)
{
	D(bug("nfosmesa: glTagSampleBufferSGIX()"));
	fn.glTagSampleBufferSGIX();
}

void OSMesaDriver::nfglTangent3bEXT(GLbyte32 tx, GLbyte32 ty, GLbyte32 tz)
{
	D(bug("nfosmesa: glTangent3bEXT(%d, %d, %d)", tx, ty, tz));
	fn.glTangent3bEXT(tx, ty, tz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTangent3bvEXT(memptr v)
#else
void OSMesaDriver::nfglTangent3bvEXT(const GLbyte *v)
#endif
{
	D(bug("nfosmesa: glTangent3bvEXT(" PRI_PTR ")", AtariOffset(v)));
FN_GLTANGENT3BVEXT(v);
}

void OSMesaDriver::nfglTangent3dEXT(GLdouble tx, GLdouble ty, GLdouble tz)
{
	D(bug("nfosmesa: glTangent3dEXT(%f, %f, %f)", tx, ty, tz));
	fn.glTangent3dEXT(tx, ty, tz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTangent3dvEXT(memptr v)
#else
void OSMesaDriver::nfglTangent3dvEXT(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glTangent3dvEXT(" PRI_PTR ")", AtariOffset(v)));
FN_GLTANGENT3DVEXT(v);
}

void OSMesaDriver::nfglTangent3fEXT(GLfloat tx, GLfloat ty, GLfloat tz)
{
	D(bug("nfosmesa: glTangent3fEXT(%f, %f, %f)", tx, ty, tz));
	fn.glTangent3fEXT(tx, ty, tz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTangent3fvEXT(memptr v)
#else
void OSMesaDriver::nfglTangent3fvEXT(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glTangent3fvEXT(" PRI_PTR ")", AtariOffset(v)));
FN_GLTANGENT3FVEXT(v);
}

void OSMesaDriver::nfglTangent3iEXT(GLint tx, GLint ty, GLint tz)
{
	D(bug("nfosmesa: glTangent3iEXT(%d, %d, %d)", tx, ty, tz));
	fn.glTangent3iEXT(tx, ty, tz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTangent3ivEXT(memptr v)
#else
void OSMesaDriver::nfglTangent3ivEXT(const GLint *v)
#endif
{
	D(bug("nfosmesa: glTangent3ivEXT(" PRI_PTR ")", AtariOffset(v)));
FN_GLTANGENT3IVEXT(v);
}

void OSMesaDriver::nfglTangent3sEXT(GLshort32 tx, GLshort32 ty, GLshort32 tz)
{
	D(bug("nfosmesa: glTangent3sEXT(%d, %d, %d)", tx, ty, tz));
	fn.glTangent3sEXT(tx, ty, tz);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTangent3svEXT(memptr v)
#else
void OSMesaDriver::nfglTangent3svEXT(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glTangent3svEXT(" PRI_PTR ")", AtariOffset(v)));
FN_GLTANGENT3SVEXT(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTangentPointerEXT(GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglTangentPointerEXT(GLenum type, GLsizei stride, const void *pointer)
#endif
{
	D(bug("nfosmesa: glTangentPointerEXT(%s, %d, " PRI_PTR ")", gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLTANGENTPOINTEREXT(type, stride, pointer);
}

void OSMesaDriver::nfglTbufferMask3DFX(GLuint mask)
{
	D(bug("nfosmesa: glTbufferMask3DFX(%u)", mask));
	fn.glTbufferMask3DFX(mask);
}

void OSMesaDriver::nfglTessellationFactorAMD(GLfloat factor)
{
	D(bug("nfosmesa: glTessellationFactorAMD(%f)", factor));
	fn.glTessellationFactorAMD(factor);
}

void OSMesaDriver::nfglTessellationModeAMD(GLenum mode)
{
	D(bug("nfosmesa: glTessellationModeAMD(%s)", gl_enum_name(mode)));
	fn.glTessellationModeAMD(mode);
}

GLboolean OSMesaDriver::nfglTestFenceAPPLE(GLuint fence)
{
	D(bug("nfosmesa: glTestFenceAPPLE(%u)", fence));
	GLboolean __ret = fn.glTestFenceAPPLE(fence);
	return __ret;
}

GLboolean OSMesaDriver::nfglTestFenceNV(GLuint fence)
{
	D(bug("nfosmesa: glTestFenceNV(%u)", fence));
	GLboolean __ret = fn.glTestFenceNV(fence);
	return __ret;
}

GLboolean OSMesaDriver::nfglTestObjectAPPLE(GLenum object, GLuint name)
{
	D(bug("nfosmesa: glTestObjectAPPLE(%s, %u)", gl_enum_name(object), name));
	GLboolean __ret = fn.glTestObjectAPPLE(object, name);
	return __ret;
}

void OSMesaDriver::nfglTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
{
	D(bug("nfosmesa: glTexBuffer(%s, %s, %u)", gl_enum_name(target), gl_enum_name(internalformat), buffer));
	fn.glTexBuffer(target, internalformat, buffer);
}

void OSMesaDriver::nfglTexBufferARB(GLenum target, GLenum internalformat, GLuint buffer)
{
	D(bug("nfosmesa: glTexBufferARB(%s, %s, %u)", gl_enum_name(target), gl_enum_name(internalformat), buffer));
	fn.glTexBufferARB(target, internalformat, buffer);
}

void OSMesaDriver::nfglTexBufferEXT(GLenum target, GLenum internalformat, GLuint buffer)
{
	D(bug("nfosmesa: glTexBufferEXT(%s, %s, %u)", gl_enum_name(target), gl_enum_name(internalformat), buffer));
	fn.glTexBufferEXT(target, internalformat, buffer);
}

void OSMesaDriver::nfglTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
	D(bug("nfosmesa: glTexBufferRange(%s, %s, %u, %" PRI_IPTR ", %" PRI_IPTR ")", gl_enum_name(target), gl_enum_name(internalformat), buffer, offset, size));
	fn.glTexBufferRange(target, internalformat, buffer, offset, size);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexBumpParameterfvATI(GLenum pname, memptr param)
#else
void OSMesaDriver::nfglTexBumpParameterfvATI(GLenum pname, const GLfloat *param)
#endif
{
	D(bug("nfosmesa: glTexBumpParameterfvATI(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(param)));
FN_GLTEXBUMPPARAMETERFVATI(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexBumpParameterivATI(GLenum pname, memptr param)
#else
void OSMesaDriver::nfglTexBumpParameterivATI(GLenum pname, const GLint *param)
#endif
{
	D(bug("nfosmesa: glTexBumpParameterivATI(%s, " PRI_PTR ")", gl_enum_name(pname), AtariOffset(param)));
FN_GLTEXBUMPPARAMETERIVATI(pname, param);
}

void OSMesaDriver::nfglTexCoord1bOES(GLbyte32 s)
{
	D(bug("nfosmesa: glTexCoord1bOES(%d)", s));
	fn.glTexCoord1bOES(s);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord1bvOES(memptr coords)
#else
void OSMesaDriver::nfglTexCoord1bvOES(const GLbyte *coords)
#endif
{
	D(bug("nfosmesa: glTexCoord1bvOES(" PRI_PTR ")", AtariOffset(coords)));
FN_GLTEXCOORD1BVOES(coords);
}

void OSMesaDriver::nfglTexCoord1d(GLdouble s)
{
	D(bug("nfosmesa: glTexCoord1d(%f)", s));
	fn.glTexCoord1d(s);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord1dv(memptr v)
#else
void OSMesaDriver::nfglTexCoord1dv(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glTexCoord1dv(" PRI_PTR ")", AtariOffset(v)));
FN_GLTEXCOORD1DV(v);
}

void OSMesaDriver::nfglTexCoord1f(GLfloat s)
{
	D(bug("nfosmesa: glTexCoord1f(%f)", s));
	fn.glTexCoord1f(s);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord1fv(memptr v)
#else
void OSMesaDriver::nfglTexCoord1fv(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glTexCoord1fv(" PRI_PTR ")", AtariOffset(v)));
FN_GLTEXCOORD1FV(v);
}

void OSMesaDriver::nfglTexCoord1hNV(GLhalfNV32 s)
{
	D(bug("nfosmesa: glTexCoord1hNV(%u)", s));
	fn.glTexCoord1hNV(s);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord1hvNV(memptr v)
#else
void OSMesaDriver::nfglTexCoord1hvNV(const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glTexCoord1hvNV(" PRI_PTR ")", AtariOffset(v)));
FN_GLTEXCOORD1HVNV(v);
}

void OSMesaDriver::nfglTexCoord1i(GLint s)
{
	D(bug("nfosmesa: glTexCoord1i(%d)", s));
	fn.glTexCoord1i(s);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord1iv(memptr v)
#else
void OSMesaDriver::nfglTexCoord1iv(const GLint *v)
#endif
{
	D(bug("nfosmesa: glTexCoord1iv(" PRI_PTR ")", AtariOffset(v)));
FN_GLTEXCOORD1IV(v);
}

void OSMesaDriver::nfglTexCoord1s(GLshort32 s)
{
	D(bug("nfosmesa: glTexCoord1s(%d)", s));
	fn.glTexCoord1s(s);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord1sv(memptr v)
#else
void OSMesaDriver::nfglTexCoord1sv(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glTexCoord1sv(" PRI_PTR ")", AtariOffset(v)));
FN_GLTEXCOORD1SV(v);
}

void OSMesaDriver::nfglTexCoord1xOES(GLfixed s)
{
	D(bug("nfosmesa: glTexCoord1xOES(0x%x)", s));
	fn.glTexCoord1xOES(s);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord1xvOES(memptr coords)
#else
void OSMesaDriver::nfglTexCoord1xvOES(const GLfixed *coords)
#endif
{
	D(bug("nfosmesa: glTexCoord1xvOES(" PRI_PTR ")", AtariOffset(coords)));
FN_GLTEXCOORD1XVOES(coords);
}

void OSMesaDriver::nfglTexCoord2bOES(GLbyte32 s, GLbyte32 t)
{
	D(bug("nfosmesa: glTexCoord2bOES(%d, %d)", s, t));
	fn.glTexCoord2bOES(s, t);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord2bvOES(memptr coords)
#else
void OSMesaDriver::nfglTexCoord2bvOES(const GLbyte *coords)
#endif
{
	D(bug("nfosmesa: glTexCoord2bvOES(" PRI_PTR ")", AtariOffset(coords)));
FN_GLTEXCOORD2BVOES(coords);
}

void OSMesaDriver::nfglTexCoord2d(GLdouble s, GLdouble t)
{
	D(bug("nfosmesa: glTexCoord2d(%f, %f)", s, t));
	fn.glTexCoord2d(s, t);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord2dv(memptr v)
#else
void OSMesaDriver::nfglTexCoord2dv(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glTexCoord2dv(" PRI_PTR ")", AtariOffset(v)));
FN_GLTEXCOORD2DV(v);
}

void OSMesaDriver::nfglTexCoord2f(GLfloat s, GLfloat t)
{
	D(bug("nfosmesa: glTexCoord2f(%f, %f)", s, t));
	fn.glTexCoord2f(s, t);
}

void OSMesaDriver::nfglTexCoord2fColor3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glTexCoord2fColor3fVertex3fSUN(%f, %f, %f, %f, %f, %f, %f, %f)", s, t, r, g, b, x, y, z));
	fn.glTexCoord2fColor3fVertex3fSUN(s, t, r, g, b, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord2fColor3fVertex3fvSUN(memptr tc, memptr c, memptr v)
#else
void OSMesaDriver::nfglTexCoord2fColor3fVertex3fvSUN(const GLfloat *tc, const GLfloat *c, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glTexCoord2fColor3fVertex3fvSUN(" PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", AtariOffset(tc), AtariOffset(c), AtariOffset(v)));
FN_GLTEXCOORD2FCOLOR3FVERTEX3FVSUN(tc, c, v);
}

void OSMesaDriver::nfglTexCoord2fColor4fNormal3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glTexCoord2fColor4fNormal3fVertex3fSUN(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)", s, t, r, g, b, a, nx, ny, nz, x, y, z));
	fn.glTexCoord2fColor4fNormal3fVertex3fSUN(s, t, r, g, b, a, nx, ny, nz, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord2fColor4fNormal3fVertex3fvSUN(memptr tc, memptr c, memptr n, memptr v)
#else
void OSMesaDriver::nfglTexCoord2fColor4fNormal3fVertex3fvSUN(const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glTexCoord2fColor4fNormal3fVertex3fvSUN(" PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", AtariOffset(tc), AtariOffset(c), AtariOffset(n), AtariOffset(v)));
FN_GLTEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUN(tc, c, n, v);
}

void OSMesaDriver::nfglTexCoord2fColor4ubVertex3fSUN(GLfloat s, GLfloat t, GLubyte32 r, GLubyte32 g, GLubyte32 b, GLubyte32 a, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glTexCoord2fColor4ubVertex3fSUN(%f, %f, %u, %u, %u, %u, %f, %f, %f)", s, t, r, g, b, a, x, y, z));
	fn.glTexCoord2fColor4ubVertex3fSUN(s, t, r, g, b, a, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord2fColor4ubVertex3fvSUN(memptr tc, memptr c, memptr v)
#else
void OSMesaDriver::nfglTexCoord2fColor4ubVertex3fvSUN(const GLfloat *tc, const GLubyte *c, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glTexCoord2fColor4ubVertex3fvSUN(" PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", AtariOffset(tc), AtariOffset(c), AtariOffset(v)));
FN_GLTEXCOORD2FCOLOR4UBVERTEX3FVSUN(tc, c, v);
}

void OSMesaDriver::nfglTexCoord2fNormal3fVertex3fSUN(GLfloat s, GLfloat t, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glTexCoord2fNormal3fVertex3fSUN(%f, %f, %f, %f, %f, %f, %f, %f)", s, t, nx, ny, nz, x, y, z));
	fn.glTexCoord2fNormal3fVertex3fSUN(s, t, nx, ny, nz, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord2fNormal3fVertex3fvSUN(memptr tc, memptr n, memptr v)
#else
void OSMesaDriver::nfglTexCoord2fNormal3fVertex3fvSUN(const GLfloat *tc, const GLfloat *n, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glTexCoord2fNormal3fVertex3fvSUN(" PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", AtariOffset(tc), AtariOffset(n), AtariOffset(v)));
FN_GLTEXCOORD2FNORMAL3FVERTEX3FVSUN(tc, n, v);
}

void OSMesaDriver::nfglTexCoord2fVertex3fSUN(GLfloat s, GLfloat t, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glTexCoord2fVertex3fSUN(%f, %f, %f, %f, %f)", s, t, x, y, z));
	fn.glTexCoord2fVertex3fSUN(s, t, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord2fVertex3fvSUN(memptr tc, memptr v)
#else
void OSMesaDriver::nfglTexCoord2fVertex3fvSUN(const GLfloat *tc, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glTexCoord2fVertex3fvSUN(" PRI_PTR ", " PRI_PTR ")", AtariOffset(tc), AtariOffset(v)));
FN_GLTEXCOORD2FVERTEX3FVSUN(tc, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord2fv(memptr v)
#else
void OSMesaDriver::nfglTexCoord2fv(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glTexCoord2fv(" PRI_PTR ")", AtariOffset(v)));
FN_GLTEXCOORD2FV(v);
}

void OSMesaDriver::nfglTexCoord2hNV(GLhalfNV32 s, GLhalfNV32 t)
{
	D(bug("nfosmesa: glTexCoord2hNV(%u, %u)", s, t));
	fn.glTexCoord2hNV(s, t);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord2hvNV(memptr v)
#else
void OSMesaDriver::nfglTexCoord2hvNV(const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glTexCoord2hvNV(" PRI_PTR ")", AtariOffset(v)));
FN_GLTEXCOORD2HVNV(v);
}

void OSMesaDriver::nfglTexCoord2i(GLint s, GLint t)
{
	D(bug("nfosmesa: glTexCoord2i(%d, %d)", s, t));
	fn.glTexCoord2i(s, t);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord2iv(memptr v)
#else
void OSMesaDriver::nfglTexCoord2iv(const GLint *v)
#endif
{
	D(bug("nfosmesa: glTexCoord2iv(" PRI_PTR ")", AtariOffset(v)));
FN_GLTEXCOORD2IV(v);
}

void OSMesaDriver::nfglTexCoord2s(GLshort32 s, GLshort32 t)
{
	D(bug("nfosmesa: glTexCoord2s(%d, %d)", s, t));
	fn.glTexCoord2s(s, t);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord2sv(memptr v)
#else
void OSMesaDriver::nfglTexCoord2sv(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glTexCoord2sv(" PRI_PTR ")", AtariOffset(v)));
FN_GLTEXCOORD2SV(v);
}

void OSMesaDriver::nfglTexCoord2xOES(GLfixed s, GLfixed t)
{
	D(bug("nfosmesa: glTexCoord2xOES(0x%x, 0x%x)", s, t));
	fn.glTexCoord2xOES(s, t);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord2xvOES(memptr coords)
#else
void OSMesaDriver::nfglTexCoord2xvOES(const GLfixed *coords)
#endif
{
	D(bug("nfosmesa: glTexCoord2xvOES(" PRI_PTR ")", AtariOffset(coords)));
FN_GLTEXCOORD2XVOES(coords);
}

void OSMesaDriver::nfglTexCoord3bOES(GLbyte32 s, GLbyte32 t, GLbyte32 r)
{
	D(bug("nfosmesa: glTexCoord3bOES(%d, %d, %d)", s, t, r));
	fn.glTexCoord3bOES(s, t, r);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord3bvOES(memptr coords)
#else
void OSMesaDriver::nfglTexCoord3bvOES(const GLbyte *coords)
#endif
{
	D(bug("nfosmesa: glTexCoord3bvOES(" PRI_PTR ")", AtariOffset(coords)));
FN_GLTEXCOORD3BVOES(coords);
}

void OSMesaDriver::nfglTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
{
	D(bug("nfosmesa: glTexCoord3d(%f, %f, %f)", s, t, r));
	fn.glTexCoord3d(s, t, r);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord3dv(memptr v)
#else
void OSMesaDriver::nfglTexCoord3dv(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glTexCoord3dv(" PRI_PTR ")", AtariOffset(v)));
FN_GLTEXCOORD3DV(v);
}

void OSMesaDriver::nfglTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
{
	D(bug("nfosmesa: glTexCoord3f(%f, %f, %f)", s, t, r));
	fn.glTexCoord3f(s, t, r);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord3fv(memptr v)
#else
void OSMesaDriver::nfglTexCoord3fv(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glTexCoord3fv(" PRI_PTR ")", AtariOffset(v)));
FN_GLTEXCOORD3FV(v);
}

void OSMesaDriver::nfglTexCoord3hNV(GLhalfNV32 s, GLhalfNV32 t, GLhalfNV32 r)
{
	D(bug("nfosmesa: glTexCoord3hNV(%u, %u, %u)", s, t, r));
	fn.glTexCoord3hNV(s, t, r);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord3hvNV(memptr v)
#else
void OSMesaDriver::nfglTexCoord3hvNV(const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glTexCoord3hvNV(" PRI_PTR ")", AtariOffset(v)));
FN_GLTEXCOORD3HVNV(v);
}

void OSMesaDriver::nfglTexCoord3i(GLint s, GLint t, GLint r)
{
	D(bug("nfosmesa: glTexCoord3i(%d, %d, %d)", s, t, r));
	fn.glTexCoord3i(s, t, r);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord3iv(memptr v)
#else
void OSMesaDriver::nfglTexCoord3iv(const GLint *v)
#endif
{
	D(bug("nfosmesa: glTexCoord3iv(" PRI_PTR ")", AtariOffset(v)));
FN_GLTEXCOORD3IV(v);
}

void OSMesaDriver::nfglTexCoord3s(GLshort32 s, GLshort32 t, GLshort32 r)
{
	D(bug("nfosmesa: glTexCoord3s(%d, %d, %d)", s, t, r));
	fn.glTexCoord3s(s, t, r);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord3sv(memptr v)
#else
void OSMesaDriver::nfglTexCoord3sv(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glTexCoord3sv(" PRI_PTR ")", AtariOffset(v)));
FN_GLTEXCOORD3SV(v);
}

void OSMesaDriver::nfglTexCoord3xOES(GLfixed s, GLfixed t, GLfixed r)
{
	D(bug("nfosmesa: glTexCoord3xOES(0x%x, 0x%x, 0x%x)", s, t, r));
	fn.glTexCoord3xOES(s, t, r);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord3xvOES(memptr coords)
#else
void OSMesaDriver::nfglTexCoord3xvOES(const GLfixed *coords)
#endif
{
	D(bug("nfosmesa: glTexCoord3xvOES(" PRI_PTR ")", AtariOffset(coords)));
FN_GLTEXCOORD3XVOES(coords);
}

void OSMesaDriver::nfglTexCoord4bOES(GLbyte32 s, GLbyte32 t, GLbyte32 r, GLbyte32 q)
{
	D(bug("nfosmesa: glTexCoord4bOES(%d, %d, %d, %d)", s, t, r, q));
	fn.glTexCoord4bOES(s, t, r, q);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord4bvOES(memptr coords)
#else
void OSMesaDriver::nfglTexCoord4bvOES(const GLbyte *coords)
#endif
{
	D(bug("nfosmesa: glTexCoord4bvOES(" PRI_PTR ")", AtariOffset(coords)));
FN_GLTEXCOORD4BVOES(coords);
}

void OSMesaDriver::nfglTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
{
	D(bug("nfosmesa: glTexCoord4d(%f, %f, %f, %f)", s, t, r, q));
	fn.glTexCoord4d(s, t, r, q);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord4dv(memptr v)
#else
void OSMesaDriver::nfglTexCoord4dv(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glTexCoord4dv(" PRI_PTR ")", AtariOffset(v)));
FN_GLTEXCOORD4DV(v);
}

void OSMesaDriver::nfglTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
	D(bug("nfosmesa: glTexCoord4f(%f, %f, %f, %f)", s, t, r, q));
	fn.glTexCoord4f(s, t, r, q);
}

void OSMesaDriver::nfglTexCoord4fColor4fNormal3fVertex4fSUN(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat r, GLfloat g, GLfloat b, GLfloat a, GLfloat nx, GLfloat ny, GLfloat nz, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	D(bug("nfosmesa: glTexCoord4fColor4fNormal3fVertex4fSUN(%f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f, %f)", s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w));
	fn.glTexCoord4fColor4fNormal3fVertex4fSUN(s, t, p, q, r, g, b, a, nx, ny, nz, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord4fColor4fNormal3fVertex4fvSUN(memptr tc, memptr c, memptr n, memptr v)
#else
void OSMesaDriver::nfglTexCoord4fColor4fNormal3fVertex4fvSUN(const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glTexCoord4fColor4fNormal3fVertex4fvSUN(" PRI_PTR ", " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", AtariOffset(tc), AtariOffset(c), AtariOffset(n), AtariOffset(v)));
FN_GLTEXCOORD4FCOLOR4FNORMAL3FVERTEX4FVSUN(tc, c, n, v);
}

void OSMesaDriver::nfglTexCoord4fVertex4fSUN(GLfloat s, GLfloat t, GLfloat p, GLfloat q, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	D(bug("nfosmesa: glTexCoord4fVertex4fSUN(%f, %f, %f, %f, %f, %f, %f, %f)", s, t, p, q, x, y, z, w));
	fn.glTexCoord4fVertex4fSUN(s, t, p, q, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord4fVertex4fvSUN(memptr tc, memptr v)
#else
void OSMesaDriver::nfglTexCoord4fVertex4fvSUN(const GLfloat *tc, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glTexCoord4fVertex4fvSUN(" PRI_PTR ", " PRI_PTR ")", AtariOffset(tc), AtariOffset(v)));
FN_GLTEXCOORD4FVERTEX4FVSUN(tc, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord4fv(memptr v)
#else
void OSMesaDriver::nfglTexCoord4fv(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glTexCoord4fv(" PRI_PTR ")", AtariOffset(v)));
FN_GLTEXCOORD4FV(v);
}

void OSMesaDriver::nfglTexCoord4hNV(GLhalfNV32 s, GLhalfNV32 t, GLhalfNV32 r, GLhalfNV32 q)
{
	D(bug("nfosmesa: glTexCoord4hNV(%u, %u, %u, %u)", s, t, r, q));
	fn.glTexCoord4hNV(s, t, r, q);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord4hvNV(memptr v)
#else
void OSMesaDriver::nfglTexCoord4hvNV(const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glTexCoord4hvNV(" PRI_PTR ")", AtariOffset(v)));
FN_GLTEXCOORD4HVNV(v);
}

void OSMesaDriver::nfglTexCoord4i(GLint s, GLint t, GLint r, GLint q)
{
	D(bug("nfosmesa: glTexCoord4i(%d, %d, %d, %d)", s, t, r, q));
	fn.glTexCoord4i(s, t, r, q);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord4iv(memptr v)
#else
void OSMesaDriver::nfglTexCoord4iv(const GLint *v)
#endif
{
	D(bug("nfosmesa: glTexCoord4iv(" PRI_PTR ")", AtariOffset(v)));
FN_GLTEXCOORD4IV(v);
}

void OSMesaDriver::nfglTexCoord4s(GLshort32 s, GLshort32 t, GLshort32 r, GLshort32 q)
{
	D(bug("nfosmesa: glTexCoord4s(%d, %d, %d, %d)", s, t, r, q));
	fn.glTexCoord4s(s, t, r, q);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord4sv(memptr v)
#else
void OSMesaDriver::nfglTexCoord4sv(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glTexCoord4sv(" PRI_PTR ")", AtariOffset(v)));
FN_GLTEXCOORD4SV(v);
}

void OSMesaDriver::nfglTexCoord4xOES(GLfixed s, GLfixed t, GLfixed r, GLfixed q)
{
	D(bug("nfosmesa: glTexCoord4xOES(0x%x, 0x%x, 0x%x, 0x%x)", s, t, r, q));
	fn.glTexCoord4xOES(s, t, r, q);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoord4xvOES(memptr coords)
#else
void OSMesaDriver::nfglTexCoord4xvOES(const GLfixed *coords)
#endif
{
	D(bug("nfosmesa: glTexCoord4xvOES(" PRI_PTR ")", AtariOffset(coords)));
FN_GLTEXCOORD4XVOES(coords);
}

void OSMesaDriver::nfglTexCoordFormatNV(GLint size, GLenum type, GLsizei stride)
{
	D(bug("nfosmesa: glTexCoordFormatNV(%d, %s, %d)", size, gl_enum_name(type), stride));
	fn.glTexCoordFormatNV(size, type, stride);
}

void OSMesaDriver::nfglTexCoordP1ui(GLenum type, GLuint coords)
{
	D(bug("nfosmesa: glTexCoordP1ui(%s, %u)", gl_enum_name(type), coords));
	fn.glTexCoordP1ui(type, coords);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoordP1uiv(GLenum type, memptr coords)
#else
void OSMesaDriver::nfglTexCoordP1uiv(GLenum type, const GLuint *coords)
#endif
{
	D(bug("nfosmesa: glTexCoordP1uiv(%s, " PRI_PTR ")", gl_enum_name(type), AtariOffset(coords)));
FN_GLTEXCOORDP1UIV(type, coords);
}

void OSMesaDriver::nfglTexCoordP2ui(GLenum type, GLuint coords)
{
	D(bug("nfosmesa: glTexCoordP2ui(%s, %u)", gl_enum_name(type), coords));
	fn.glTexCoordP2ui(type, coords);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoordP2uiv(GLenum type, memptr coords)
#else
void OSMesaDriver::nfglTexCoordP2uiv(GLenum type, const GLuint *coords)
#endif
{
	D(bug("nfosmesa: glTexCoordP2uiv(%s, " PRI_PTR ")", gl_enum_name(type), AtariOffset(coords)));
FN_GLTEXCOORDP2UIV(type, coords);
}

void OSMesaDriver::nfglTexCoordP3ui(GLenum type, GLuint coords)
{
	D(bug("nfosmesa: glTexCoordP3ui(%s, %u)", gl_enum_name(type), coords));
	fn.glTexCoordP3ui(type, coords);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoordP3uiv(GLenum type, memptr coords)
#else
void OSMesaDriver::nfglTexCoordP3uiv(GLenum type, const GLuint *coords)
#endif
{
	D(bug("nfosmesa: glTexCoordP3uiv(%s, " PRI_PTR ")", gl_enum_name(type), AtariOffset(coords)));
FN_GLTEXCOORDP3UIV(type, coords);
}

void OSMesaDriver::nfglTexCoordP4ui(GLenum type, GLuint coords)
{
	D(bug("nfosmesa: glTexCoordP4ui(%s, %u)", gl_enum_name(type), coords));
	fn.glTexCoordP4ui(type, coords);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoordP4uiv(GLenum type, memptr coords)
#else
void OSMesaDriver::nfglTexCoordP4uiv(GLenum type, const GLuint *coords)
#endif
{
	D(bug("nfosmesa: glTexCoordP4uiv(%s, " PRI_PTR ")", gl_enum_name(type), AtariOffset(coords)));
FN_GLTEXCOORDP4UIV(type, coords);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoordPointer(GLint size, GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
#endif
{
	D(bug("nfosmesa: glTexCoordPointer(%d, %s, %d, " PRI_PTR ")", size, gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLTEXCOORDPOINTER(size, type, stride, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, memptr pointer)
#else
void OSMesaDriver::nfglTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer)
#endif
{
	D(bug("nfosmesa: glTexCoordPointerEXT(%d, %s, %d, %d, " PRI_PTR ")", size, gl_enum_name(type), stride, count, AtariOffset(pointer)));
FN_GLTEXCOORDPOINTEREXT(size, type, stride, count, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoordPointerListIBM(GLint size, GLenum type, GLint stride, memptr pointer, GLint ptrstride)
#else
void OSMesaDriver::nfglTexCoordPointerListIBM(GLint size, GLenum type, GLint stride, const void * *pointer, GLint ptrstride)
#endif
{
	D(bug("nfosmesa: glTexCoordPointerListIBM(%d, %s, %d, " PRI_PTR ", %d)", size, gl_enum_name(type), stride, AtariOffset(pointer), ptrstride));
FN_GLTEXCOORDPOINTERLISTIBM(size, type, stride, pointer, ptrstride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexCoordPointervINTEL(GLint size, GLenum type, memptr pointer)
#else
void OSMesaDriver::nfglTexCoordPointervINTEL(GLint size, GLenum type, const void * *pointer)
#endif
{
	D(bug("nfosmesa: glTexCoordPointervINTEL(%d, %s, " PRI_PTR ")", size, gl_enum_name(type), AtariOffset(pointer)));
FN_GLTEXCOORDPOINTERVINTEL(size, type, pointer);
}

void OSMesaDriver::nfglTexEnvf(GLenum target, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glTexEnvf(%s, %s, %f)", gl_enum_name(target), gl_enum_name(pname), param));
	fn.glTexEnvf(target, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexEnvfv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glTexEnvfv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLTEXENVFV(target, pname, params);
}

void OSMesaDriver::nfglTexEnvi(GLenum target, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glTexEnvi(%s, %s, %d)", gl_enum_name(target), gl_enum_name(pname), param));
	fn.glTexEnvi(target, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexEnviv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglTexEnviv(GLenum target, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glTexEnviv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLTEXENVIV(target, pname, params);
}

void OSMesaDriver::nfglTexEnvxOES(GLenum target, GLenum pname, GLfixed param)
{
	D(bug("nfosmesa: glTexEnvxOES(%s, %s, 0x%x)", gl_enum_name(target), gl_enum_name(pname), param));
	fn.glTexEnvxOES(target, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexEnvxvOES(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglTexEnvxvOES(GLenum target, GLenum pname, const GLfixed *params)
#endif
{
	D(bug("nfosmesa: glTexEnvxvOES(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLTEXENVXVOES(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexFilterFuncSGIS(GLenum target, GLenum filter, GLsizei n, memptr weights)
#else
void OSMesaDriver::nfglTexFilterFuncSGIS(GLenum target, GLenum filter, GLsizei n, const GLfloat *weights)
#endif
{
	D(bug("nfosmesa: glTexFilterFuncSGIS(%s, %s, %d, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(filter), n, AtariOffset(weights)));
FN_GLTEXFILTERFUNCSGIS(target, filter, n, weights);
}

void OSMesaDriver::nfglTexGend(GLenum coord, GLenum pname, GLdouble param)
{
	D(bug("nfosmesa: glTexGend(%s, %s, %f)", gl_enum_name(coord), gl_enum_name(pname), param));
	fn.glTexGend(coord, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexGendv(GLenum coord, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
#endif
{
	D(bug("nfosmesa: glTexGendv(%s, %s, " PRI_PTR ")", gl_enum_name(coord), gl_enum_name(pname), AtariOffset(params)));
FN_GLTEXGENDV(coord, pname, params);
}

void OSMesaDriver::nfglTexGenf(GLenum coord, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glTexGenf(%s, %s, %f)", gl_enum_name(coord), gl_enum_name(pname), param));
	fn.glTexGenf(coord, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexGenfv(GLenum coord, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glTexGenfv(%s, %s, " PRI_PTR ")", gl_enum_name(coord), gl_enum_name(pname), AtariOffset(params)));
FN_GLTEXGENFV(coord, pname, params);
}

void OSMesaDriver::nfglTexGeni(GLenum coord, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glTexGeni(%s, %s, %d)", gl_enum_name(coord), gl_enum_name(pname), param));
	fn.glTexGeni(coord, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexGeniv(GLenum coord, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglTexGeniv(GLenum coord, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glTexGeniv(%s, %s, " PRI_PTR ")", gl_enum_name(coord), gl_enum_name(pname), AtariOffset(params)));
FN_GLTEXGENIV(coord, pname, params);
}

void OSMesaDriver::nfglTexGenxOES(GLenum coord, GLenum pname, GLfixed param)
{
	D(bug("nfosmesa: glTexGenxOES(%s, %s, 0x%x)", gl_enum_name(coord), gl_enum_name(pname), param));
	fn.glTexGenxOES(coord, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexGenxvOES(GLenum coord, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglTexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params)
#endif
{
	D(bug("nfosmesa: glTexGenxvOES(%s, %s, " PRI_PTR ")", gl_enum_name(coord), gl_enum_name(pname), AtariOffset(params)));
FN_GLTEXGENXVOES(coord, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
#endif
{
	D(bug("nfosmesa: glTexImage1D(%s, %d, %d, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), level, internalformat, width, border, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXIMAGE1D(target, level, internalformat, width, border, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
#endif
{
	D(bug("nfosmesa: glTexImage2D(%s, %d, %d, %d, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), level, internalformat, width, height, border, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXIMAGE2D(target, level, internalformat, width, height, border, format, type, pixels);
}

void OSMesaDriver::nfglTexImage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean32 fixedsamplelocations)
{
	D(bug("nfosmesa: glTexImage2DMultisample(%s, %d, %s, %d, %d, %d)", gl_enum_name(target), samples, gl_enum_name(internalformat), width, height, fixedsamplelocations));
	fn.glTexImage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
}

void OSMesaDriver::nfglTexImage2DMultisampleCoverageNV(GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean32 fixedSampleLocations)
{
	D(bug("nfosmesa: glTexImage2DMultisampleCoverageNV(%s, %d, %d, %d, %d, %d, %d)", gl_enum_name(target), coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations));
	fn.glTexImage2DMultisampleCoverageNV(target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glTexImage3D(%s, %d, %d, %d, %d, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), level, internalformat, width, height, depth, border, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXIMAGE3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexImage3DEXT(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTexImage3DEXT(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glTexImage3DEXT(%s, %d, %s, %d, %d, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), level, gl_enum_name(internalformat), width, height, depth, border, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXIMAGE3DEXT(target, level, internalformat, width, height, depth, border, format, type, pixels);
}

void OSMesaDriver::nfglTexImage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean32 fixedsamplelocations)
{
	D(bug("nfosmesa: glTexImage3DMultisample(%s, %d, %s, %d, %d, %d, %d)", gl_enum_name(target), samples, gl_enum_name(internalformat), width, height, depth, fixedsamplelocations));
	fn.glTexImage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
}

void OSMesaDriver::nfglTexImage3DMultisampleCoverageNV(GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean32 fixedSampleLocations)
{
	D(bug("nfosmesa: glTexImage3DMultisampleCoverageNV(%s, %d, %d, %d, %d, %d, %d, %d)", gl_enum_name(target), coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations));
	fn.glTexImage3DMultisampleCoverageNV(target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexImage4DSGIS(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTexImage4DSGIS(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLint border, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glTexImage4DSGIS(%s, %d, %s, %d, %d, %d, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), level, gl_enum_name(internalformat), width, height, depth, size4d, border, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXIMAGE4DSGIS(target, level, internalformat, width, height, depth, size4d, border, format, type, pixels);
}

void OSMesaDriver::nfglTexPageCommitmentARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean32 commit)
{
	D(bug("nfosmesa: glTexPageCommitmentARB(%s, %d, %d, %d, %d, %d, %d, %d, %d)", gl_enum_name(target), level, xoffset, yoffset, zoffset, width, height, depth, commit));
	fn.glTexPageCommitmentARB(target, level, xoffset, yoffset, zoffset, width, height, depth, commit);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexParameterIiv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glTexParameterIiv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLTEXPARAMETERIIV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexParameterIivEXT(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglTexParameterIivEXT(GLenum target, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glTexParameterIivEXT(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLTEXPARAMETERIIVEXT(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexParameterIuiv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
#endif
{
	D(bug("nfosmesa: glTexParameterIuiv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLTEXPARAMETERIUIV(target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexParameterIuivEXT(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglTexParameterIuivEXT(GLenum target, GLenum pname, const GLuint *params)
#endif
{
	D(bug("nfosmesa: glTexParameterIuivEXT(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLTEXPARAMETERIUIVEXT(target, pname, params);
}

void OSMesaDriver::nfglTexParameterf(GLenum target, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glTexParameterf(%s, %s, %f)", gl_enum_name(target), gl_enum_name(pname), param));
	fn.glTexParameterf(target, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexParameterfv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glTexParameterfv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLTEXPARAMETERFV(target, pname, params);
}

void OSMesaDriver::nfglTexParameteri(GLenum target, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glTexParameteri(%s, %s, %d)", gl_enum_name(target), gl_enum_name(pname), param));
	fn.glTexParameteri(target, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexParameteriv(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglTexParameteriv(GLenum target, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glTexParameteriv(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLTEXPARAMETERIV(target, pname, params);
}

void OSMesaDriver::nfglTexParameterxOES(GLenum target, GLenum pname, GLfixed param)
{
	D(bug("nfosmesa: glTexParameterxOES(%s, %s, 0x%x)", gl_enum_name(target), gl_enum_name(pname), param));
	fn.glTexParameterxOES(target, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexParameterxvOES(GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglTexParameterxvOES(GLenum target, GLenum pname, const GLfixed *params)
#endif
{
	D(bug("nfosmesa: glTexParameterxvOES(%s, %s, " PRI_PTR ")", gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLTEXPARAMETERXVOES(target, pname, params);
}

void OSMesaDriver::nfglTexRenderbufferNV(GLenum target, GLuint renderbuffer)
{
	D(bug("nfosmesa: glTexRenderbufferNV(%s, %u)", gl_enum_name(target), renderbuffer));
	fn.glTexRenderbufferNV(target, renderbuffer);
}

void OSMesaDriver::nfglTexScissorFuncINTEL(GLenum target, GLenum lfunc, GLenum hfunc)
{
	D(bug("nfosmesa: glTexScissorFuncINTEL(%s, %s, %s)", gl_enum_name(target), gl_enum_name(lfunc), gl_enum_name(hfunc)));
	fn.glTexScissorFuncINTEL(target, lfunc, hfunc);
}

void OSMesaDriver::nfglTexScissorINTEL(GLenum target, GLclampf tlow, GLclampf thigh)
{
	D(bug("nfosmesa: glTexScissorINTEL(%s, %f, %f)", gl_enum_name(target), tlow, thigh));
	fn.glTexScissorINTEL(target, tlow, thigh);
}

void OSMesaDriver::nfglTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
{
	D(bug("nfosmesa: glTexStorage1D(%s, %d, %s, %d)", gl_enum_name(target), levels, gl_enum_name(internalformat), width));
	fn.glTexStorage1D(target, levels, internalformat, width);
}

void OSMesaDriver::nfglTexStorage2D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glTexStorage2D(%s, %d, %s, %d, %d)", gl_enum_name(target), levels, gl_enum_name(internalformat), width, height));
	fn.glTexStorage2D(target, levels, internalformat, width, height);
}

void OSMesaDriver::nfglTexStorage2DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean32 fixedsamplelocations)
{
	D(bug("nfosmesa: glTexStorage2DMultisample(%s, %d, %s, %d, %d, %d)", gl_enum_name(target), samples, gl_enum_name(internalformat), width, height, fixedsamplelocations));
	fn.glTexStorage2DMultisample(target, samples, internalformat, width, height, fixedsamplelocations);
}

void OSMesaDriver::nfglTexStorage3D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
{
	D(bug("nfosmesa: glTexStorage3D(%s, %d, %s, %d, %d, %d)", gl_enum_name(target), levels, gl_enum_name(internalformat), width, height, depth));
	fn.glTexStorage3D(target, levels, internalformat, width, height, depth);
}

void OSMesaDriver::nfglTexStorage3DMultisample(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean32 fixedsamplelocations)
{
	D(bug("nfosmesa: glTexStorage3DMultisample(%s, %d, %s, %d, %d, %d, %d)", gl_enum_name(target), samples, gl_enum_name(internalformat), width, height, depth, fixedsamplelocations));
	fn.glTexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
}

void OSMesaDriver::nfglTexStorageMem1DEXT(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLuint memory, GLuint64 offset)
{
	D(bug("nfosmesa: glTexStorageMem1DEXT(%s, %d, %s, %d, %u, %" PRIu64 ")", gl_enum_name(target), levels, gl_enum_name(internalFormat), width, memory, offset));
	fn.glTexStorageMem1DEXT(target, levels, internalFormat, width, memory, offset);
}

void OSMesaDriver::nfglTexStorageMem2DEXT(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLuint memory, GLuint64 offset)
{
	D(bug("nfosmesa: glTexStorageMem2DEXT(%s, %d, %s, %d, %d, %u, %" PRIu64 ")", gl_enum_name(target), levels, gl_enum_name(internalFormat), width, height, memory, offset));
	fn.glTexStorageMem2DEXT(target, levels, internalFormat, width, height, memory, offset);
}

void OSMesaDriver::nfglTexStorageMem2DMultisampleEXT(GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean32 fixedSampleLocations, GLuint memory, GLuint64 offset)
{
	D(bug("nfosmesa: glTexStorageMem2DMultisampleEXT(%s, %d, %s, %d, %d, %d, %u, %" PRIu64 ")", gl_enum_name(target), samples, gl_enum_name(internalFormat), width, height, fixedSampleLocations, memory, offset));
	fn.glTexStorageMem2DMultisampleEXT(target, samples, internalFormat, width, height, fixedSampleLocations, memory, offset);
}

void OSMesaDriver::nfglTexStorageMem3DEXT(GLenum target, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset)
{
	D(bug("nfosmesa: glTexStorageMem3DEXT(%s, %d, %s, %d, %d, %d, %u, %" PRIu64 ")", gl_enum_name(target), levels, gl_enum_name(internalFormat), width, height, depth, memory, offset));
	fn.glTexStorageMem3DEXT(target, levels, internalFormat, width, height, depth, memory, offset);
}

void OSMesaDriver::nfglTexStorageMem3DMultisampleEXT(GLenum target, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean32 fixedSampleLocations, GLuint memory, GLuint64 offset)
{
	D(bug("nfosmesa: glTexStorageMem3DMultisampleEXT(%s, %d, %s, %d, %d, %d, %d, %u, %" PRIu64 ")", gl_enum_name(target), samples, gl_enum_name(internalFormat), width, height, depth, fixedSampleLocations, memory, offset));
	fn.glTexStorageMem3DMultisampleEXT(target, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, offset);
}

void OSMesaDriver::nfglTexStorageSparseAMD(GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei layers, GLbitfield flags)
{
	D(bug("nfosmesa: glTexStorageSparseAMD(%s, %s, %d, %d, %d, %d, 0x%x)", gl_enum_name(target), gl_enum_name(internalFormat), width, height, depth, layers, flags));
	fn.glTexStorageSparseAMD(target, internalFormat, width, height, depth, layers, flags);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
#endif
{
	D(bug("nfosmesa: glTexSubImage1D(%s, %d, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), level, xoffset, width, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXSUBIMAGE1D(target, level, xoffset, width, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glTexSubImage1DEXT(%s, %d, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), level, xoffset, width, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXSUBIMAGE1DEXT(target, level, xoffset, width, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
#endif
{
	D(bug("nfosmesa: glTexSubImage2D(%s, %d, %d, %d, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), level, xoffset, yoffset, width, height, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXSUBIMAGE2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glTexSubImage2DEXT(%s, %d, %d, %d, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), level, xoffset, yoffset, width, height, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXSUBIMAGE2DEXT(target, level, xoffset, yoffset, width, height, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glTexSubImage3D(%s, %d, %d, %d, %d, %d, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), level, xoffset, yoffset, zoffset, width, height, depth, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXSUBIMAGE3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTexSubImage3DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glTexSubImage3DEXT(%s, %d, %d, %d, %d, %d, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), level, xoffset, yoffset, zoffset, width, height, depth, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXSUBIMAGE3DEXT(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTexSubImage4DSGIS(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTexSubImage4DSGIS(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint woffset, GLsizei width, GLsizei height, GLsizei depth, GLsizei size4d, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glTexSubImage4DSGIS(%s, %d, %d, %d, %d, %d, %d, %d, %d, %d, %s, %s, " PRI_PTR ")", gl_enum_name(target), level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXSUBIMAGE4DSGIS(target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels);
}

void OSMesaDriver::nfglTextureBarrier(void)
{
	D(bug("nfosmesa: glTextureBarrier()"));
	fn.glTextureBarrier();
}

void OSMesaDriver::nfglTextureBarrierNV(void)
{
	D(bug("nfosmesa: glTextureBarrierNV()"));
	fn.glTextureBarrierNV();
}

void OSMesaDriver::nfglTextureBuffer(GLuint texture, GLenum internalformat, GLuint buffer)
{
	D(bug("nfosmesa: glTextureBuffer(%u, %s, %u)", texture, gl_enum_name(internalformat), buffer));
	fn.glTextureBuffer(texture, internalformat, buffer);
}

void OSMesaDriver::nfglTextureBufferEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer)
{
	D(bug("nfosmesa: glTextureBufferEXT(%u, %s, %s, %u)", texture, gl_enum_name(target), gl_enum_name(internalformat), buffer));
	fn.glTextureBufferEXT(texture, target, internalformat, buffer);
}

void OSMesaDriver::nfglTextureBufferRange(GLuint texture, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
	D(bug("nfosmesa: glTextureBufferRange(%u, %s, %u, %" PRI_IPTR ", %" PRI_IPTR ")", texture, gl_enum_name(internalformat), buffer, offset, size));
	fn.glTextureBufferRange(texture, internalformat, buffer, offset, size);
}

void OSMesaDriver::nfglTextureBufferRangeEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
	D(bug("nfosmesa: glTextureBufferRangeEXT(%u, %s, %s, %u, %" PRI_IPTR ", %" PRI_IPTR ")", texture, gl_enum_name(target), gl_enum_name(internalformat), buffer, offset, size));
	fn.glTextureBufferRangeEXT(texture, target, internalformat, buffer, offset, size);
}

void OSMesaDriver::nfglTextureColorMaskSGIS(GLboolean32 red, GLboolean32 green, GLboolean32 blue, GLboolean32 alpha)
{
	D(bug("nfosmesa: glTextureColorMaskSGIS(%d, %d, %d, %d)", red, green, blue, alpha));
	fn.glTextureColorMaskSGIS(red, green, blue, alpha);
}

void OSMesaDriver::nfglTextureFogSGIX(GLenum pname)
{
	D(bug("nfosmesa: glTextureFogSGIX(%s)", gl_enum_name(pname)));
	fn.glTextureFogSGIX(pname);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glTextureImage1DEXT(%u, %s, %d, %s, %d, %d, %s, %s, " PRI_PTR ")", texture, gl_enum_name(target), level, gl_enum_name(internalformat), width, border, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXTUREIMAGE1DEXT(texture, target, level, internalformat, width, border, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glTextureImage2DEXT(%u, %s, %d, %s, %d, %d, %d, %s, %s, " PRI_PTR ")", texture, gl_enum_name(target), level, gl_enum_name(internalformat), width, height, border, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXTUREIMAGE2DEXT(texture, target, level, internalformat, width, height, border, format, type, pixels);
}

void OSMesaDriver::nfglTextureImage2DMultisampleCoverageNV(GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean32 fixedSampleLocations)
{
	D(bug("nfosmesa: glTextureImage2DMultisampleCoverageNV(%u, %s, %d, %d, %d, %d, %d, %d)", texture, gl_enum_name(target), coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations));
	fn.glTextureImage2DMultisampleCoverageNV(texture, target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations);
}

void OSMesaDriver::nfglTextureImage2DMultisampleNV(GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLboolean32 fixedSampleLocations)
{
	D(bug("nfosmesa: glTextureImage2DMultisampleNV(%u, %s, %d, %d, %d, %d, %d)", texture, gl_enum_name(target), samples, internalFormat, width, height, fixedSampleLocations));
	fn.glTextureImage2DMultisampleNV(texture, target, samples, internalFormat, width, height, fixedSampleLocations);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glTextureImage3DEXT(%u, %s, %d, %s, %d, %d, %d, %d, %s, %s, " PRI_PTR ")", texture, gl_enum_name(target), level, gl_enum_name(internalformat), width, height, depth, border, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXTUREIMAGE3DEXT(texture, target, level, internalformat, width, height, depth, border, format, type, pixels);
}

void OSMesaDriver::nfglTextureImage3DMultisampleCoverageNV(GLuint texture, GLenum target, GLsizei coverageSamples, GLsizei colorSamples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean32 fixedSampleLocations)
{
	D(bug("nfosmesa: glTextureImage3DMultisampleCoverageNV(%u, %s, %d, %d, %d, %d, %d, %d, %d)", texture, gl_enum_name(target), coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations));
	fn.glTextureImage3DMultisampleCoverageNV(texture, target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations);
}

void OSMesaDriver::nfglTextureImage3DMultisampleNV(GLuint texture, GLenum target, GLsizei samples, GLint internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean32 fixedSampleLocations)
{
	D(bug("nfosmesa: glTextureImage3DMultisampleNV(%u, %s, %d, %d, %d, %d, %d, %d)", texture, gl_enum_name(target), samples, internalFormat, width, height, depth, fixedSampleLocations));
	fn.glTextureImage3DMultisampleNV(texture, target, samples, internalFormat, width, height, depth, fixedSampleLocations);
}

void OSMesaDriver::nfglTextureLightEXT(GLenum pname)
{
	D(bug("nfosmesa: glTextureLightEXT(%s)", gl_enum_name(pname)));
	fn.glTextureLightEXT(pname);
}

void OSMesaDriver::nfglTextureMaterialEXT(GLenum face, GLenum mode)
{
	D(bug("nfosmesa: glTextureMaterialEXT(%s, %s)", gl_enum_name(face), gl_enum_name(mode)));
	fn.glTextureMaterialEXT(face, mode);
}

void OSMesaDriver::nfglTextureNormalEXT(GLenum mode)
{
	D(bug("nfosmesa: glTextureNormalEXT(%s)", gl_enum_name(mode)));
	fn.glTextureNormalEXT(mode);
}

void OSMesaDriver::nfglTexturePageCommitmentEXT(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean32 commit)
{
	D(bug("nfosmesa: glTexturePageCommitmentEXT(%u, %d, %d, %d, %d, %d, %d, %d, %d)", texture, level, xoffset, yoffset, zoffset, width, height, depth, commit));
	fn.glTexturePageCommitmentEXT(texture, level, xoffset, yoffset, zoffset, width, height, depth, commit);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTextureParameterIiv(GLuint texture, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglTextureParameterIiv(GLuint texture, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glTextureParameterIiv(%u, %s, " PRI_PTR ")", texture, gl_enum_name(pname), AtariOffset(params)));
FN_GLTEXTUREPARAMETERIIV(texture, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTextureParameterIivEXT(GLuint texture, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglTextureParameterIivEXT(GLuint texture, GLenum target, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glTextureParameterIivEXT(%u, %s, %s, " PRI_PTR ")", texture, gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLTEXTUREPARAMETERIIVEXT(texture, target, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTextureParameterIuiv(GLuint texture, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglTextureParameterIuiv(GLuint texture, GLenum pname, const GLuint *params)
#endif
{
	D(bug("nfosmesa: glTextureParameterIuiv(%u, %s, " PRI_PTR ")", texture, gl_enum_name(pname), AtariOffset(params)));
FN_GLTEXTUREPARAMETERIUIV(texture, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTextureParameterIuivEXT(GLuint texture, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglTextureParameterIuivEXT(GLuint texture, GLenum target, GLenum pname, const GLuint *params)
#endif
{
	D(bug("nfosmesa: glTextureParameterIuivEXT(%u, %s, %s, " PRI_PTR ")", texture, gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLTEXTUREPARAMETERIUIVEXT(texture, target, pname, params);
}

void OSMesaDriver::nfglTextureParameterf(GLuint texture, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glTextureParameterf(%u, %s, %f)", texture, gl_enum_name(pname), param));
	fn.glTextureParameterf(texture, pname, param);
}

void OSMesaDriver::nfglTextureParameterfEXT(GLuint texture, GLenum target, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glTextureParameterfEXT(%u, %s, %s, %f)", texture, gl_enum_name(target), gl_enum_name(pname), param));
	fn.glTextureParameterfEXT(texture, target, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTextureParameterfv(GLuint texture, GLenum pname, memptr param)
#else
void OSMesaDriver::nfglTextureParameterfv(GLuint texture, GLenum pname, const GLfloat *param)
#endif
{
	D(bug("nfosmesa: glTextureParameterfv(%u, %s, " PRI_PTR ")", texture, gl_enum_name(pname), AtariOffset(param)));
FN_GLTEXTUREPARAMETERFV(texture, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glTextureParameterfvEXT(%u, %s, %s, " PRI_PTR ")", texture, gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLTEXTUREPARAMETERFVEXT(texture, target, pname, params);
}

void OSMesaDriver::nfglTextureParameteri(GLuint texture, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glTextureParameteri(%u, %s, %d)", texture, gl_enum_name(pname), param));
	fn.glTextureParameteri(texture, pname, param);
}

void OSMesaDriver::nfglTextureParameteriEXT(GLuint texture, GLenum target, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glTextureParameteriEXT(%u, %s, %s, %d)", texture, gl_enum_name(target), gl_enum_name(pname), param));
	fn.glTextureParameteriEXT(texture, target, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTextureParameteriv(GLuint texture, GLenum pname, memptr param)
#else
void OSMesaDriver::nfglTextureParameteriv(GLuint texture, GLenum pname, const GLint *param)
#endif
{
	D(bug("nfosmesa: glTextureParameteriv(%u, %s, " PRI_PTR ")", texture, gl_enum_name(pname), AtariOffset(param)));
FN_GLTEXTUREPARAMETERIV(texture, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glTextureParameterivEXT(%u, %s, %s, " PRI_PTR ")", texture, gl_enum_name(target), gl_enum_name(pname), AtariOffset(params)));
FN_GLTEXTUREPARAMETERIVEXT(texture, target, pname, params);
}

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTextureRangeAPPLE(GLenum target, GLsizei length, memptr pointer)
#else
void OSMesaDriver::nfglTextureRangeAPPLE(GLenum target, GLsizei length, const void *pointer)
#endif
{
	D(bug("nfosmesa: glTextureRangeAPPLE(%s, %d, " PRI_PTR ")", gl_enum_name(target), length, AtariOffset(pointer)));
FN_GLTEXTURERANGEAPPLE(target, length, pointer);
}
#endif

void OSMesaDriver::nfglTextureRenderbufferEXT(GLuint texture, GLenum target, GLuint renderbuffer)
{
	D(bug("nfosmesa: glTextureRenderbufferEXT(%u, %s, %u)", texture, gl_enum_name(target), renderbuffer));
	fn.glTextureRenderbufferEXT(texture, target, renderbuffer);
}

void OSMesaDriver::nfglTextureStorage1D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width)
{
	D(bug("nfosmesa: glTextureStorage1D(%u, %d, %s, %d)", texture, levels, gl_enum_name(internalformat), width));
	fn.glTextureStorage1D(texture, levels, internalformat, width);
}

void OSMesaDriver::nfglTextureStorage1DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
{
	D(bug("nfosmesa: glTextureStorage1DEXT(%u, %s, %d, %s, %d)", texture, gl_enum_name(target), levels, gl_enum_name(internalformat), width));
	fn.glTextureStorage1DEXT(texture, target, levels, internalformat, width);
}

void OSMesaDriver::nfglTextureStorage2D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glTextureStorage2D(%u, %d, %s, %d, %d)", texture, levels, gl_enum_name(internalformat), width, height));
	fn.glTextureStorage2D(texture, levels, internalformat, width, height);
}

void OSMesaDriver::nfglTextureStorage2DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glTextureStorage2DEXT(%u, %s, %d, %s, %d, %d)", texture, gl_enum_name(target), levels, gl_enum_name(internalformat), width, height));
	fn.glTextureStorage2DEXT(texture, target, levels, internalformat, width, height);
}

void OSMesaDriver::nfglTextureStorage2DMultisample(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean32 fixedsamplelocations)
{
	D(bug("nfosmesa: glTextureStorage2DMultisample(%u, %d, %s, %d, %d, %d)", texture, samples, gl_enum_name(internalformat), width, height, fixedsamplelocations));
	fn.glTextureStorage2DMultisample(texture, samples, internalformat, width, height, fixedsamplelocations);
}

void OSMesaDriver::nfglTextureStorage2DMultisampleEXT(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean32 fixedsamplelocations)
{
	D(bug("nfosmesa: glTextureStorage2DMultisampleEXT(%u, %s, %d, %s, %d, %d, %d)", texture, gl_enum_name(target), samples, gl_enum_name(internalformat), width, height, fixedsamplelocations));
	fn.glTextureStorage2DMultisampleEXT(texture, target, samples, internalformat, width, height, fixedsamplelocations);
}

void OSMesaDriver::nfglTextureStorage3D(GLuint texture, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
{
	D(bug("nfosmesa: glTextureStorage3D(%u, %d, %s, %d, %d, %d)", texture, levels, gl_enum_name(internalformat), width, height, depth));
	fn.glTextureStorage3D(texture, levels, internalformat, width, height, depth);
}

void OSMesaDriver::nfglTextureStorage3DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
{
	D(bug("nfosmesa: glTextureStorage3DEXT(%u, %s, %d, %s, %d, %d, %d)", texture, gl_enum_name(target), levels, gl_enum_name(internalformat), width, height, depth));
	fn.glTextureStorage3DEXT(texture, target, levels, internalformat, width, height, depth);
}

void OSMesaDriver::nfglTextureStorage3DMultisample(GLuint texture, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean32 fixedsamplelocations)
{
	D(bug("nfosmesa: glTextureStorage3DMultisample(%u, %d, %s, %d, %d, %d, %d)", texture, samples, gl_enum_name(internalformat), width, height, depth, fixedsamplelocations));
	fn.glTextureStorage3DMultisample(texture, samples, internalformat, width, height, depth, fixedsamplelocations);
}

void OSMesaDriver::nfglTextureStorage3DMultisampleEXT(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean32 fixedsamplelocations)
{
	D(bug("nfosmesa: glTextureStorage3DMultisampleEXT(%u, %s, %d, %s, %d, %d, %d, %d)", texture, gl_enum_name(target), samples, gl_enum_name(internalformat), width, height, depth, fixedsamplelocations));
	fn.glTextureStorage3DMultisampleEXT(texture, target, samples, internalformat, width, height, depth, fixedsamplelocations);
}

void OSMesaDriver::nfglTextureStorageMem1DEXT(GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLuint memory, GLuint64 offset)
{
	D(bug("nfosmesa: glTextureStorageMem1DEXT(%u, %d, %s, %d, %u, %" PRIu64 ")", texture, levels, gl_enum_name(internalFormat), width, memory, offset));
	fn.glTextureStorageMem1DEXT(texture, levels, internalFormat, width, memory, offset);
}

void OSMesaDriver::nfglTextureStorageMem2DEXT(GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLuint memory, GLuint64 offset)
{
	D(bug("nfosmesa: glTextureStorageMem2DEXT(%u, %d, %s, %d, %d, %u, %" PRIu64 ")", texture, levels, gl_enum_name(internalFormat), width, height, memory, offset));
	fn.glTextureStorageMem2DEXT(texture, levels, internalFormat, width, height, memory, offset);
}

void OSMesaDriver::nfglTextureStorageMem2DMultisampleEXT(GLuint texture, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLboolean32 fixedSampleLocations, GLuint memory, GLuint64 offset)
{
	D(bug("nfosmesa: glTextureStorageMem2DMultisampleEXT(%u, %d, %s, %d, %d, %d, %u, %" PRIu64 ")", texture, samples, gl_enum_name(internalFormat), width, height, fixedSampleLocations, memory, offset));
	fn.glTextureStorageMem2DMultisampleEXT(texture, samples, internalFormat, width, height, fixedSampleLocations, memory, offset);
}

void OSMesaDriver::nfglTextureStorageMem3DEXT(GLuint texture, GLsizei levels, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLuint memory, GLuint64 offset)
{
	D(bug("nfosmesa: glTextureStorageMem3DEXT(%u, %d, %s, %d, %d, %d, %u, %" PRIu64 ")", texture, levels, gl_enum_name(internalFormat), width, height, depth, memory, offset));
	fn.glTextureStorageMem3DEXT(texture, levels, internalFormat, width, height, depth, memory, offset);
}

void OSMesaDriver::nfglTextureStorageMem3DMultisampleEXT(GLuint texture, GLsizei samples, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLboolean32 fixedSampleLocations, GLuint memory, GLuint64 offset)
{
	D(bug("nfosmesa: glTextureStorageMem3DMultisampleEXT(%u, %d, %s, %d, %d, %d, %d, %u, %" PRIu64 ")", texture, samples, gl_enum_name(internalFormat), width, height, depth, fixedSampleLocations, memory, offset));
	fn.glTextureStorageMem3DMultisampleEXT(texture, samples, internalFormat, width, height, depth, fixedSampleLocations, memory, offset);
}

void OSMesaDriver::nfglTextureStorageSparseAMD(GLuint texture, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei layers, GLbitfield flags)
{
	D(bug("nfosmesa: glTextureStorageSparseAMD(%u, %s, %s, %d, %d, %d, %d, 0x%x)", texture, gl_enum_name(target), gl_enum_name(internalFormat), width, height, depth, layers, flags));
	fn.glTextureStorageSparseAMD(texture, target, internalFormat, width, height, depth, layers, flags);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTextureSubImage1D(GLuint texture, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glTextureSubImage1D(%u, %d, %d, %d, %s, %s, " PRI_PTR ")", texture, level, xoffset, width, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXTURESUBIMAGE1D(texture, level, xoffset, width, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glTextureSubImage1DEXT(%u, %s, %d, %d, %d, %s, %s, " PRI_PTR ")", texture, gl_enum_name(target), level, xoffset, width, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXTURESUBIMAGE1DEXT(texture, target, level, xoffset, width, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTextureSubImage2D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glTextureSubImage2D(%u, %d, %d, %d, %d, %d, %s, %s, " PRI_PTR ")", texture, level, xoffset, yoffset, width, height, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXTURESUBIMAGE2D(texture, level, xoffset, yoffset, width, height, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glTextureSubImage2DEXT(%u, %s, %d, %d, %d, %d, %d, %s, %s, " PRI_PTR ")", texture, gl_enum_name(target), level, xoffset, yoffset, width, height, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXTURESUBIMAGE2DEXT(texture, target, level, xoffset, yoffset, width, height, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTextureSubImage3D(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glTextureSubImage3D(%u, %d, %d, %d, %d, %d, %d, %d, %s, %s, " PRI_PTR ")", texture, level, xoffset, yoffset, zoffset, width, height, depth, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXTURESUBIMAGE3D(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, memptr pixels)
#else
void OSMesaDriver::nfglTextureSubImage3DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, const void *pixels)
#endif
{
	D(bug("nfosmesa: glTextureSubImage3DEXT(%u, %s, %d, %d, %d, %d, %d, %d, %d, %s, %s, " PRI_PTR ")", texture, gl_enum_name(target), level, xoffset, yoffset, zoffset, width, height, depth, gl_enum_name(format), gl_enum_name(type), AtariOffset(pixels)));
FN_GLTEXTURESUBIMAGE3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
}

void OSMesaDriver::nfglTextureView(GLuint texture, GLenum target, GLuint origtexture, GLenum internalformat, GLuint minlevel, GLuint numlevels, GLuint minlayer, GLuint numlayers)
{
	D(bug("nfosmesa: glTextureView(%u, %s, %u, %s, %u, %u, %u, %u)", texture, gl_enum_name(target), origtexture, gl_enum_name(internalformat), minlevel, numlevels, minlayer, numlayers));
	fn.glTextureView(texture, target, origtexture, internalformat, minlevel, numlevels, minlayer, numlayers);
}

void OSMesaDriver::nfglTraceAssertAttribMESA(GLbitfield attribMask)
{
	D(bug("nfosmesa: glTraceAssertAttribMESA(0x%x)", attribMask));
	fn.glTraceAssertAttribMESA(attribMask);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTraceCommentMESA(memptr comment)
#else
void OSMesaDriver::nfglTraceCommentMESA(const GLubyte *comment)
#endif
{
	D(bug("nfosmesa: glTraceCommentMESA(" PRI_PTR ")", AtariOffset(comment)));
FN_GLTRACECOMMENTMESA(comment);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTraceListMESA(GLuint name, memptr comment)
#else
void OSMesaDriver::nfglTraceListMESA(GLuint name, const GLubyte *comment)
#endif
{
	D(bug("nfosmesa: glTraceListMESA(%u, " PRI_PTR ")", name, AtariOffset(comment)));
FN_GLTRACELISTMESA(name, comment);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTracePointerMESA(memptr pointer, memptr comment)
#else
void OSMesaDriver::nfglTracePointerMESA(GLvoid *pointer, const GLubyte *comment)
#endif
{
	D(bug("nfosmesa: glTracePointerMESA(" PRI_PTR ", " PRI_PTR ")", AtariOffset(pointer), AtariOffset(comment)));
FN_GLTRACEPOINTERMESA(pointer, comment);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTracePointerRangeMESA(memptr first, memptr last, memptr comment)
#else
void OSMesaDriver::nfglTracePointerRangeMESA(const GLvoid *first, const GLvoid *last, const GLubyte *comment)
#endif
{
	D(bug("nfosmesa: glTracePointerRangeMESA(" PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", AtariOffset(first), AtariOffset(last), AtariOffset(comment)));
FN_GLTRACEPOINTERRANGEMESA(first, last, comment);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTraceTextureMESA(GLuint name, memptr comment)
#else
void OSMesaDriver::nfglTraceTextureMESA(GLuint name, const GLubyte *comment)
#endif
{
	D(bug("nfosmesa: glTraceTextureMESA(%u, " PRI_PTR ")", name, AtariOffset(comment)));
FN_GLTRACETEXTUREMESA(name, comment);
}

void OSMesaDriver::nfglTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform)
{
	D(bug("nfosmesa: glTrackMatrixNV(%s, %u, %s, %s)", gl_enum_name(target), address, gl_enum_name(matrix), gl_enum_name(transform)));
	fn.glTrackMatrixNV(target, address, matrix, transform);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTransformFeedbackAttribsNV(GLsizei count, memptr attribs, GLenum bufferMode)
#else
void OSMesaDriver::nfglTransformFeedbackAttribsNV(GLsizei count, const GLint *attribs, GLenum bufferMode)
#endif
{
	D(bug("nfosmesa: glTransformFeedbackAttribsNV(%d, " PRI_PTR ", %s)", count, AtariOffset(attribs), gl_enum_name(bufferMode)));
FN_GLTRANSFORMFEEDBACKATTRIBSNV(count, attribs, bufferMode);
}

void OSMesaDriver::nfglTransformFeedbackBufferBase(GLuint xfb, GLuint index, GLuint buffer)
{
	D(bug("nfosmesa: glTransformFeedbackBufferBase(%u, %u, %u)", xfb, index, buffer));
	fn.glTransformFeedbackBufferBase(xfb, index, buffer);
}

void OSMesaDriver::nfglTransformFeedbackBufferRange(GLuint xfb, GLuint index, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
	D(bug("nfosmesa: glTransformFeedbackBufferRange(%u, %u, %u, %" PRI_IPTR ", %" PRI_IPTR ")", xfb, index, buffer, offset, size));
	fn.glTransformFeedbackBufferRange(xfb, index, buffer, offset, size);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTransformFeedbackStreamAttribsNV(GLsizei count, memptr attribs, GLsizei nbuffers, memptr bufstreams, GLenum bufferMode)
#else
void OSMesaDriver::nfglTransformFeedbackStreamAttribsNV(GLsizei count, const GLint *attribs, GLsizei nbuffers, const GLint *bufstreams, GLenum bufferMode)
#endif
{
	D(bug("nfosmesa: glTransformFeedbackStreamAttribsNV(%d, " PRI_PTR ", %d, " PRI_PTR ", %s)", count, AtariOffset(attribs), nbuffers, AtariOffset(bufstreams), gl_enum_name(bufferMode)));
FN_GLTRANSFORMFEEDBACKSTREAMATTRIBSNV(count, attribs, nbuffers, bufstreams, bufferMode);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTransformFeedbackVaryings(GLuint program, GLsizei count, memptr varyings, GLenum bufferMode)
#else
void OSMesaDriver::nfglTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const *varyings, GLenum bufferMode)
#endif
{
	D(bug("nfosmesa: glTransformFeedbackVaryings(%u, %d, " PRI_PTR ", %s)", program, count, AtariOffset(varyings), gl_enum_name(bufferMode)));
FN_GLTRANSFORMFEEDBACKVARYINGS(program, count, varyings, bufferMode);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTransformFeedbackVaryingsEXT(GLuint program, GLsizei count, memptr varyings, GLenum bufferMode)
#else
void OSMesaDriver::nfglTransformFeedbackVaryingsEXT(GLuint program, GLsizei count, const GLchar *const *varyings, GLenum bufferMode)
#endif
{
	D(bug("nfosmesa: glTransformFeedbackVaryingsEXT(%u, %d, " PRI_PTR ", %s)", program, count, AtariOffset(varyings), gl_enum_name(bufferMode)));
FN_GLTRANSFORMFEEDBACKVARYINGSEXT(program, count, varyings, bufferMode);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTransformFeedbackVaryingsNV(GLuint program, GLsizei count, memptr locations, GLenum bufferMode)
#else
void OSMesaDriver::nfglTransformFeedbackVaryingsNV(GLuint program, GLsizei count, const GLint *locations, GLenum bufferMode)
#endif
{
	D(bug("nfosmesa: glTransformFeedbackVaryingsNV(%u, %d, " PRI_PTR ", %s)", program, count, AtariOffset(locations), gl_enum_name(bufferMode)));
FN_GLTRANSFORMFEEDBACKVARYINGSNV(program, count, locations, bufferMode);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglTransformPathNV(GLuint resultPath, GLuint srcPath, GLenum transformType, memptr transformValues)
#else
void OSMesaDriver::nfglTransformPathNV(GLuint resultPath, GLuint srcPath, GLenum transformType, const GLfloat *transformValues)
#endif
{
	D(bug("nfosmesa: glTransformPathNV(%u, %u, %s, " PRI_PTR ")", resultPath, srcPath, gl_enum_name(transformType), AtariOffset(transformValues)));
FN_GLTRANSFORMPATHNV(resultPath, srcPath, transformType, transformValues);
}

void OSMesaDriver::nfglTranslated(GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glTranslated(%f, %f, %f)", x, y, z));
	fn.glTranslated(x, y, z);
}

void OSMesaDriver::nfglTranslatef(GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glTranslatef(%f, %f, %f)", x, y, z));
	fn.glTranslatef(x, y, z);
}

void OSMesaDriver::nfglTranslatexOES(GLfixed x, GLfixed y, GLfixed z)
{
	D(bug("nfosmesa: glTranslatexOES(0x%x, 0x%x, 0x%x)", x, y, z));
	fn.glTranslatexOES(x, y, z);
}

void OSMesaDriver::nfglUniform1d(GLint location, GLdouble x)
{
	D(bug("nfosmesa: glUniform1d(%d, %f)", location, x));
	fn.glUniform1d(location, x);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform1dv(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform1dv(GLint location, GLsizei count, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glUniform1dv(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORM1DV(location, count, value);
}

void OSMesaDriver::nfglUniform1f(GLint location, GLfloat v0)
{
	D(bug("nfosmesa: glUniform1f(%d, %f)", location, v0));
	fn.glUniform1f(location, v0);
}

void OSMesaDriver::nfglUniform1fARB(GLint location, GLfloat v0)
{
	D(bug("nfosmesa: glUniform1fARB(%d, %f)", location, v0));
	fn.glUniform1fARB(location, v0);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform1fv(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform1fv(GLint location, GLsizei count, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glUniform1fv(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORM1FV(location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform1fvARB(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform1fvARB(GLint location, GLsizei count, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glUniform1fvARB(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __value_size = MAX(1 * count, 0);
	GLfloat __value_tmp[__value_size];
	GLfloat *__value_ptmp = Atari2HostFloatArray(__value_size, value, __value_tmp);
	fn.glUniform1fvARB(location, count, __value_ptmp);
#else
	fn.glUniform1fvARB(location, count, HostAddr(value, const GLfloat *));
#endif
}

void OSMesaDriver::nfglUniform1i(GLint location, GLint v0)
{
	D(bug("nfosmesa: glUniform1i(%d, %d)", location, v0));
	fn.glUniform1i(location, v0);
}

void OSMesaDriver::nfglUniform1i64ARB(GLint location, GLint64 x)
{
	D(bug("nfosmesa: glUniform1i64ARB(%d, %" PRId64 ")", location, x));
	fn.glUniform1i64ARB(location, x);
}

void OSMesaDriver::nfglUniform1i64NV(GLint location, GLint64EXT x)
{
	D(bug("nfosmesa: glUniform1i64NV(%d, %" PRId64 ")", location, x));
	fn.glUniform1i64NV(location, x);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform1i64vARB(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform1i64vARB(GLint location, GLsizei count, const GLint64 *value)
#endif
{
	D(bug("nfosmesa: glUniform1i64vARB(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(1 * count, 0);
	GLint64 __value_tmp[__value_size];
	GLint64 *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glUniform1i64vARB(location, count, __value_ptmp);
#else
	fn.glUniform1i64vARB(location, count, HostAddr(value, const GLint64 *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform1i64vNV(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform1i64vNV(GLint location, GLsizei count, const GLint64EXT *value)
#endif
{
	D(bug("nfosmesa: glUniform1i64vNV(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(1 * count, 0);
	GLint64EXT __value_tmp[__value_size];
	GLint64EXT *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glUniform1i64vNV(location, count, __value_ptmp);
#else
	fn.glUniform1i64vNV(location, count, HostAddr(value, const GLint64EXT *));
#endif
}

void OSMesaDriver::nfglUniform1iARB(GLint location, GLint v0)
{
	D(bug("nfosmesa: glUniform1iARB(%d, %d)", location, v0));
	fn.glUniform1iARB(location, v0);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform1iv(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform1iv(GLint location, GLsizei count, const GLint *value)
#endif
{
	D(bug("nfosmesa: glUniform1iv(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORM1IV(location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform1ivARB(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform1ivARB(GLint location, GLsizei count, const GLint *value)
#endif
{
	D(bug("nfosmesa: glUniform1ivARB(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(1 * count, 0);
	GLint __value_tmp[__value_size];
	GLint *__value_ptmp = Atari2HostIntArray(__value_size, value, __value_tmp);
	fn.glUniform1ivARB(location, count, __value_ptmp);
#else
	fn.glUniform1ivARB(location, count, HostAddr(value, const GLint *));
#endif
}

void OSMesaDriver::nfglUniform1ui(GLint location, GLuint v0)
{
	D(bug("nfosmesa: glUniform1ui(%d, %u)", location, v0));
	fn.glUniform1ui(location, v0);
}

void OSMesaDriver::nfglUniform1ui64ARB(GLint location, GLuint64 x)
{
	D(bug("nfosmesa: glUniform1ui64ARB(%d, %" PRIu64 ")", location, x));
	fn.glUniform1ui64ARB(location, x);
}

void OSMesaDriver::nfglUniform1ui64NV(GLint location, GLuint64EXT x)
{
	D(bug("nfosmesa: glUniform1ui64NV(%d, %" PRIu64 ")", location, x));
	fn.glUniform1ui64NV(location, x);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform1ui64vARB(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform1ui64vARB(GLint location, GLsizei count, const GLuint64 *value)
#endif
{
	D(bug("nfosmesa: glUniform1ui64vARB(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(1 * count, 0);
	GLuint64 __value_tmp[__value_size];
	GLuint64 *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glUniform1ui64vARB(location, count, __value_ptmp);
#else
	fn.glUniform1ui64vARB(location, count, HostAddr(value, const GLuint64 *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform1ui64vNV(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform1ui64vNV(GLint location, GLsizei count, const GLuint64EXT *value)
#endif
{
	D(bug("nfosmesa: glUniform1ui64vNV(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(1 * count, 0);
	GLuint64EXT __value_tmp[__value_size];
	GLuint64EXT *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glUniform1ui64vNV(location, count, __value_ptmp);
#else
	fn.glUniform1ui64vNV(location, count, HostAddr(value, const GLuint64EXT *));
#endif
}

void OSMesaDriver::nfglUniform1uiEXT(GLint location, GLuint v0)
{
	D(bug("nfosmesa: glUniform1uiEXT(%d, %u)", location, v0));
	fn.glUniform1uiEXT(location, v0);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform1uiv(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform1uiv(GLint location, GLsizei count, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glUniform1uiv(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORM1UIV(location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform1uivEXT(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform1uivEXT(GLint location, GLsizei count, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glUniform1uivEXT(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORM1UIVEXT(location, count, value);
}

void OSMesaDriver::nfglUniform2d(GLint location, GLdouble x, GLdouble y)
{
	D(bug("nfosmesa: glUniform2d(%d, %f, %f)", location, x, y));
	fn.glUniform2d(location, x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform2dv(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform2dv(GLint location, GLsizei count, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glUniform2dv(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORM2DV(location, count, value);
}

void OSMesaDriver::nfglUniform2f(GLint location, GLfloat v0, GLfloat v1)
{
	D(bug("nfosmesa: glUniform2f(%d, %f, %f)", location, v0, v1));
	fn.glUniform2f(location, v0, v1);
}

void OSMesaDriver::nfglUniform2fARB(GLint location, GLfloat v0, GLfloat v1)
{
	D(bug("nfosmesa: glUniform2fARB(%d, %f, %f)", location, v0, v1));
	fn.glUniform2fARB(location, v0, v1);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform2fv(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform2fv(GLint location, GLsizei count, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glUniform2fv(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORM2FV(location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform2fvARB(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform2fvARB(GLint location, GLsizei count, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glUniform2fvARB(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __value_size = MAX(2 * count, 0);
	GLfloat __value_tmp[__value_size];
	GLfloat *__value_ptmp = Atari2HostFloatArray(__value_size, value, __value_tmp);
	fn.glUniform2fvARB(location, count, __value_ptmp);
#else
	fn.glUniform2fvARB(location, count, HostAddr(value, const GLfloat *));
#endif
}

void OSMesaDriver::nfglUniform2i(GLint location, GLint v0, GLint v1)
{
	D(bug("nfosmesa: glUniform2i(%d, %d, %d)", location, v0, v1));
	fn.glUniform2i(location, v0, v1);
}

void OSMesaDriver::nfglUniform2i64ARB(GLint location, GLint64 x, GLint64 y)
{
	D(bug("nfosmesa: glUniform2i64ARB(%d, %" PRId64 ", %" PRId64 ")", location, x, y));
	fn.glUniform2i64ARB(location, x, y);
}

void OSMesaDriver::nfglUniform2i64NV(GLint location, GLint64EXT x, GLint64EXT y)
{
	D(bug("nfosmesa: glUniform2i64NV(%d, %" PRId64 ", %" PRId64 ")", location, x, y));
	fn.glUniform2i64NV(location, x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform2i64vARB(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform2i64vARB(GLint location, GLsizei count, const GLint64 *value)
#endif
{
	D(bug("nfosmesa: glUniform2i64vARB(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(2 * count, 0);
	GLint64 __value_tmp[__value_size];
	GLint64 *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glUniform2i64vARB(location, count, __value_ptmp);
#else
	fn.glUniform2i64vARB(location, count, HostAddr(value, const GLint64 *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform2i64vNV(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform2i64vNV(GLint location, GLsizei count, const GLint64EXT *value)
#endif
{
	D(bug("nfosmesa: glUniform2i64vNV(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(2 * count, 0);
	GLint64EXT __value_tmp[__value_size];
	GLint64EXT *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glUniform2i64vNV(location, count, __value_ptmp);
#else
	fn.glUniform2i64vNV(location, count, HostAddr(value, const GLint64EXT *));
#endif
}

void OSMesaDriver::nfglUniform2iARB(GLint location, GLint v0, GLint v1)
{
	D(bug("nfosmesa: glUniform2iARB(%d, %d, %d)", location, v0, v1));
	fn.glUniform2iARB(location, v0, v1);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform2iv(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform2iv(GLint location, GLsizei count, const GLint *value)
#endif
{
	D(bug("nfosmesa: glUniform2iv(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORM2IV(location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform2ivARB(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform2ivARB(GLint location, GLsizei count, const GLint *value)
#endif
{
	D(bug("nfosmesa: glUniform2ivARB(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(2 * count, 0);
	GLint __value_tmp[__value_size];
	GLint *__value_ptmp = Atari2HostIntArray(__value_size, value, __value_tmp);
	fn.glUniform2ivARB(location, count, __value_ptmp);
#else
	fn.glUniform2ivARB(location, count, HostAddr(value, const GLint *));
#endif
}

void OSMesaDriver::nfglUniform2ui(GLint location, GLuint v0, GLuint v1)
{
	D(bug("nfosmesa: glUniform2ui(%d, %u, %u)", location, v0, v1));
	fn.glUniform2ui(location, v0, v1);
}

void OSMesaDriver::nfglUniform2ui64ARB(GLint location, GLuint64 x, GLuint64 y)
{
	D(bug("nfosmesa: glUniform2ui64ARB(%d, %" PRIu64 ", %" PRIu64 ")", location, x, y));
	fn.glUniform2ui64ARB(location, x, y);
}

void OSMesaDriver::nfglUniform2ui64NV(GLint location, GLuint64EXT x, GLuint64EXT y)
{
	D(bug("nfosmesa: glUniform2ui64NV(%d, %" PRIu64 ", %" PRIu64 ")", location, x, y));
	fn.glUniform2ui64NV(location, x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform2ui64vARB(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform2ui64vARB(GLint location, GLsizei count, const GLuint64 *value)
#endif
{
	D(bug("nfosmesa: glUniform2ui64vARB(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(2 * count, 0);
	GLuint64 __value_tmp[__value_size];
	GLuint64 *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glUniform2ui64vARB(location, count, __value_ptmp);
#else
	fn.glUniform2ui64vARB(location, count, HostAddr(value, const GLuint64 *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform2ui64vNV(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform2ui64vNV(GLint location, GLsizei count, const GLuint64EXT *value)
#endif
{
	D(bug("nfosmesa: glUniform2ui64vNV(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(2 * count, 0);
	GLuint64EXT __value_tmp[__value_size];
	GLuint64EXT *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glUniform2ui64vNV(location, count, __value_ptmp);
#else
	fn.glUniform2ui64vNV(location, count, HostAddr(value, const GLuint64EXT *));
#endif
}

void OSMesaDriver::nfglUniform2uiEXT(GLint location, GLuint v0, GLuint v1)
{
	D(bug("nfosmesa: glUniform2uiEXT(%d, %u, %u)", location, v0, v1));
	fn.glUniform2uiEXT(location, v0, v1);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform2uiv(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform2uiv(GLint location, GLsizei count, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glUniform2uiv(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORM2UIV(location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform2uivEXT(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform2uivEXT(GLint location, GLsizei count, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glUniform2uivEXT(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORM2UIVEXT(location, count, value);
}

void OSMesaDriver::nfglUniform3d(GLint location, GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glUniform3d(%d, %f, %f, %f)", location, x, y, z));
	fn.glUniform3d(location, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform3dv(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform3dv(GLint location, GLsizei count, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glUniform3dv(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORM3DV(location, count, value);
}

void OSMesaDriver::nfglUniform3f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
{
	D(bug("nfosmesa: glUniform3f(%d, %f, %f, %f)", location, v0, v1, v2));
	fn.glUniform3f(location, v0, v1, v2);
}

void OSMesaDriver::nfglUniform3fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2)
{
	D(bug("nfosmesa: glUniform3fARB(%d, %f, %f, %f)", location, v0, v1, v2));
	fn.glUniform3fARB(location, v0, v1, v2);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform3fv(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform3fv(GLint location, GLsizei count, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glUniform3fv(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORM3FV(location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform3fvARB(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform3fvARB(GLint location, GLsizei count, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glUniform3fvARB(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __value_size = MAX(3 * count, 0);
	GLfloat __value_tmp[__value_size];
	GLfloat *__value_ptmp = Atari2HostFloatArray(__value_size, value, __value_tmp);
	fn.glUniform3fvARB(location, count, __value_ptmp);
#else
	fn.glUniform3fvARB(location, count, HostAddr(value, const GLfloat *));
#endif
}

void OSMesaDriver::nfglUniform3i(GLint location, GLint v0, GLint v1, GLint v2)
{
	D(bug("nfosmesa: glUniform3i(%d, %d, %d, %d)", location, v0, v1, v2));
	fn.glUniform3i(location, v0, v1, v2);
}

void OSMesaDriver::nfglUniform3i64ARB(GLint location, GLint64 x, GLint64 y, GLint64 z)
{
	D(bug("nfosmesa: glUniform3i64ARB(%d, %" PRId64 ", %" PRId64 ", %" PRId64 ")", location, x, y, z));
	fn.glUniform3i64ARB(location, x, y, z);
}

void OSMesaDriver::nfglUniform3i64NV(GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z)
{
	D(bug("nfosmesa: glUniform3i64NV(%d, %" PRId64 ", %" PRId64 ", %" PRId64 ")", location, x, y, z));
	fn.glUniform3i64NV(location, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform3i64vARB(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform3i64vARB(GLint location, GLsizei count, const GLint64 *value)
#endif
{
	D(bug("nfosmesa: glUniform3i64vARB(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(3 * count, 0);
	GLint64 __value_tmp[__value_size];
	GLint64 *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glUniform3i64vARB(location, count, __value_ptmp);
#else
	fn.glUniform3i64vARB(location, count, HostAddr(value, const GLint64 *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform3i64vNV(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform3i64vNV(GLint location, GLsizei count, const GLint64EXT *value)
#endif
{
	D(bug("nfosmesa: glUniform3i64vNV(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(3 * count, 0);
	GLint64EXT __value_tmp[__value_size];
	GLint64EXT *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glUniform3i64vNV(location, count, __value_ptmp);
#else
	fn.glUniform3i64vNV(location, count, HostAddr(value, const GLint64EXT *));
#endif
}

void OSMesaDriver::nfglUniform3iARB(GLint location, GLint v0, GLint v1, GLint v2)
{
	D(bug("nfosmesa: glUniform3iARB(%d, %d, %d, %d)", location, v0, v1, v2));
	fn.glUniform3iARB(location, v0, v1, v2);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform3iv(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform3iv(GLint location, GLsizei count, const GLint *value)
#endif
{
	D(bug("nfosmesa: glUniform3iv(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORM3IV(location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform3ivARB(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform3ivARB(GLint location, GLsizei count, const GLint *value)
#endif
{
	D(bug("nfosmesa: glUniform3ivARB(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(3 * count, 0);
	GLint __value_tmp[__value_size];
	GLint *__value_ptmp = Atari2HostIntArray(__value_size, value, __value_tmp);
	fn.glUniform3ivARB(location, count, __value_ptmp);
#else
	fn.glUniform3ivARB(location, count, HostAddr(value, const GLint *));
#endif
}

void OSMesaDriver::nfglUniform3ui(GLint location, GLuint v0, GLuint v1, GLuint v2)
{
	D(bug("nfosmesa: glUniform3ui(%d, %u, %u, %u)", location, v0, v1, v2));
	fn.glUniform3ui(location, v0, v1, v2);
}

void OSMesaDriver::nfglUniform3ui64ARB(GLint location, GLuint64 x, GLuint64 y, GLuint64 z)
{
	D(bug("nfosmesa: glUniform3ui64ARB(%d, %" PRIu64 ", %" PRIu64 ", %" PRIu64 ")", location, x, y, z));
	fn.glUniform3ui64ARB(location, x, y, z);
}

void OSMesaDriver::nfglUniform3ui64NV(GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z)
{
	D(bug("nfosmesa: glUniform3ui64NV(%d, %" PRIu64 ", %" PRIu64 ", %" PRIu64 ")", location, x, y, z));
	fn.glUniform3ui64NV(location, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform3ui64vARB(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform3ui64vARB(GLint location, GLsizei count, const GLuint64 *value)
#endif
{
	D(bug("nfosmesa: glUniform3ui64vARB(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(3 * count, 0);
	GLuint64 __value_tmp[__value_size];
	GLuint64 *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glUniform3ui64vARB(location, count, __value_ptmp);
#else
	fn.glUniform3ui64vARB(location, count, HostAddr(value, const GLuint64 *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform3ui64vNV(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform3ui64vNV(GLint location, GLsizei count, const GLuint64EXT *value)
#endif
{
	D(bug("nfosmesa: glUniform3ui64vNV(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(3 * count, 0);
	GLuint64EXT __value_tmp[__value_size];
	GLuint64EXT *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glUniform3ui64vNV(location, count, __value_ptmp);
#else
	fn.glUniform3ui64vNV(location, count, HostAddr(value, const GLuint64EXT *));
#endif
}

void OSMesaDriver::nfglUniform3uiEXT(GLint location, GLuint v0, GLuint v1, GLuint v2)
{
	D(bug("nfosmesa: glUniform3uiEXT(%d, %u, %u, %u)", location, v0, v1, v2));
	fn.glUniform3uiEXT(location, v0, v1, v2);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform3uiv(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform3uiv(GLint location, GLsizei count, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glUniform3uiv(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORM3UIV(location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform3uivEXT(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform3uivEXT(GLint location, GLsizei count, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glUniform3uivEXT(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORM3UIVEXT(location, count, value);
}

void OSMesaDriver::nfglUniform4d(GLint location, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	D(bug("nfosmesa: glUniform4d(%d, %f, %f, %f, %f)", location, x, y, z, w));
	fn.glUniform4d(location, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform4dv(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform4dv(GLint location, GLsizei count, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glUniform4dv(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORM4DV(location, count, value);
}

void OSMesaDriver::nfglUniform4f(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
{
	D(bug("nfosmesa: glUniform4f(%d, %f, %f, %f, %f)", location, v0, v1, v2, v3));
	fn.glUniform4f(location, v0, v1, v2, v3);
}

void OSMesaDriver::nfglUniform4fARB(GLint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3)
{
	D(bug("nfosmesa: glUniform4fARB(%d, %f, %f, %f, %f)", location, v0, v1, v2, v3));
	fn.glUniform4fARB(location, v0, v1, v2, v3);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform4fv(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform4fv(GLint location, GLsizei count, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glUniform4fv(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORM4FV(location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform4fvARB(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform4fvARB(GLint location, GLsizei count, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glUniform4fvARB(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __value_size = MAX(4 * count, 0);
	GLfloat __value_tmp[__value_size];
	GLfloat *__value_ptmp = Atari2HostFloatArray(__value_size, value, __value_tmp);
	fn.glUniform4fvARB(location, count, __value_ptmp);
#else
	fn.glUniform4fvARB(location, count, HostAddr(value, const GLfloat *));
#endif
}

void OSMesaDriver::nfglUniform4i(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
{
	D(bug("nfosmesa: glUniform4i(%d, %d, %d, %d, %d)", location, v0, v1, v2, v3));
	fn.glUniform4i(location, v0, v1, v2, v3);
}

void OSMesaDriver::nfglUniform4i64ARB(GLint location, GLint64 x, GLint64 y, GLint64 z, GLint64 w)
{
	D(bug("nfosmesa: glUniform4i64ARB(%d, %" PRId64 ", %" PRId64 ", %" PRId64 ", %" PRId64 ")", location, x, y, z, w));
	fn.glUniform4i64ARB(location, x, y, z, w);
}

void OSMesaDriver::nfglUniform4i64NV(GLint location, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w)
{
	D(bug("nfosmesa: glUniform4i64NV(%d, %" PRId64 ", %" PRId64 ", %" PRId64 ", %" PRId64 ")", location, x, y, z, w));
	fn.glUniform4i64NV(location, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform4i64vARB(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform4i64vARB(GLint location, GLsizei count, const GLint64 *value)
#endif
{
	D(bug("nfosmesa: glUniform4i64vARB(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(4 * count, 0);
	GLint64 __value_tmp[__value_size];
	GLint64 *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glUniform4i64vARB(location, count, __value_ptmp);
#else
	fn.glUniform4i64vARB(location, count, HostAddr(value, const GLint64 *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform4i64vNV(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform4i64vNV(GLint location, GLsizei count, const GLint64EXT *value)
#endif
{
	D(bug("nfosmesa: glUniform4i64vNV(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(4 * count, 0);
	GLint64EXT __value_tmp[__value_size];
	GLint64EXT *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glUniform4i64vNV(location, count, __value_ptmp);
#else
	fn.glUniform4i64vNV(location, count, HostAddr(value, const GLint64EXT *));
#endif
}

void OSMesaDriver::nfglUniform4iARB(GLint location, GLint v0, GLint v1, GLint v2, GLint v3)
{
	D(bug("nfosmesa: glUniform4iARB(%d, %d, %d, %d, %d)", location, v0, v1, v2, v3));
	fn.glUniform4iARB(location, v0, v1, v2, v3);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform4iv(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform4iv(GLint location, GLsizei count, const GLint *value)
#endif
{
	D(bug("nfosmesa: glUniform4iv(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORM4IV(location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform4ivARB(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform4ivARB(GLint location, GLsizei count, const GLint *value)
#endif
{
	D(bug("nfosmesa: glUniform4ivARB(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(4 * count, 0);
	GLint __value_tmp[__value_size];
	GLint *__value_ptmp = Atari2HostIntArray(__value_size, value, __value_tmp);
	fn.glUniform4ivARB(location, count, __value_ptmp);
#else
	fn.glUniform4ivARB(location, count, HostAddr(value, const GLint *));
#endif
}

void OSMesaDriver::nfglUniform4ui(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
{
	D(bug("nfosmesa: glUniform4ui(%d, %u, %u, %u, %u)", location, v0, v1, v2, v3));
	fn.glUniform4ui(location, v0, v1, v2, v3);
}

void OSMesaDriver::nfglUniform4ui64ARB(GLint location, GLuint64 x, GLuint64 y, GLuint64 z, GLuint64 w)
{
	D(bug("nfosmesa: glUniform4ui64ARB(%d, %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ")", location, x, y, z, w));
	fn.glUniform4ui64ARB(location, x, y, z, w);
}

void OSMesaDriver::nfglUniform4ui64NV(GLint location, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w)
{
	D(bug("nfosmesa: glUniform4ui64NV(%d, %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ")", location, x, y, z, w));
	fn.glUniform4ui64NV(location, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform4ui64vARB(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform4ui64vARB(GLint location, GLsizei count, const GLuint64 *value)
#endif
{
	D(bug("nfosmesa: glUniform4ui64vARB(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(4 * count, 0);
	GLuint64 __value_tmp[__value_size];
	GLuint64 *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glUniform4ui64vARB(location, count, __value_ptmp);
#else
	fn.glUniform4ui64vARB(location, count, HostAddr(value, const GLuint64 *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform4ui64vNV(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform4ui64vNV(GLint location, GLsizei count, const GLuint64EXT *value)
#endif
{
	D(bug("nfosmesa: glUniform4ui64vNV(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __value_size = MAX(4 * count, 0);
	GLuint64EXT __value_tmp[__value_size];
	GLuint64EXT *__value_ptmp = Atari2HostInt64Array(__value_size, value, __value_tmp);
	fn.glUniform4ui64vNV(location, count, __value_ptmp);
#else
	fn.glUniform4ui64vNV(location, count, HostAddr(value, const GLuint64EXT *));
#endif
}

void OSMesaDriver::nfglUniform4uiEXT(GLint location, GLuint v0, GLuint v1, GLuint v2, GLuint v3)
{
	D(bug("nfosmesa: glUniform4uiEXT(%d, %u, %u, %u, %u)", location, v0, v1, v2, v3));
	fn.glUniform4uiEXT(location, v0, v1, v2, v3);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform4uiv(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform4uiv(GLint location, GLsizei count, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glUniform4uiv(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORM4UIV(location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniform4uivEXT(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniform4uivEXT(GLint location, GLsizei count, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glUniform4uivEXT(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORM4UIVEXT(location, count, value);
}

void OSMesaDriver::nfglUniformBlockBinding(GLuint program, GLuint uniformBlockIndex, GLuint uniformBlockBinding)
{
	D(bug("nfosmesa: glUniformBlockBinding(%u, %u, %u)", program, uniformBlockIndex, uniformBlockBinding));
	fn.glUniformBlockBinding(program, uniformBlockIndex, uniformBlockBinding);
}

void OSMesaDriver::nfglUniformBufferEXT(GLuint program, GLint location, GLuint buffer)
{
	D(bug("nfosmesa: glUniformBufferEXT(%u, %d, %u)", program, location, buffer));
	fn.glUniformBufferEXT(program, location, buffer);
}

void OSMesaDriver::nfglUniformHandleui64ARB(GLint location, GLuint64 value)
{
	D(bug("nfosmesa: glUniformHandleui64ARB(%d, %" PRIu64 ")", location, value));
	fn.glUniformHandleui64ARB(location, value);
}

void OSMesaDriver::nfglUniformHandleui64NV(GLint location, GLuint64 value)
{
	D(bug("nfosmesa: glUniformHandleui64NV(%d, %" PRIu64 ")", location, value));
	fn.glUniformHandleui64NV(location, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformHandleui64vARB(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniformHandleui64vARB(GLint location, GLsizei count, const GLuint64 *value)
#endif
{
	D(bug("nfosmesa: glUniformHandleui64vARB(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORMHANDLEUI64VARB(location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformHandleui64vNV(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniformHandleui64vNV(GLint location, GLsizei count, const GLuint64 *value)
#endif
{
	D(bug("nfosmesa: glUniformHandleui64vNV(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORMHANDLEUI64VNV(location, count, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix2dv(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix2dv(GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix2dv(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
FN_GLUNIFORMMATRIX2DV(location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix2fv(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix2fv(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix2fv(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
FN_GLUNIFORMMATRIX2FV(location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix2fvARB(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix2fvARB(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix2fvARB(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __value_size = MAX(4 * count, 0);
	GLfloat __value_tmp[__value_size];
	GLfloat *__value_ptmp = Atari2HostFloatArray(__value_size, value, __value_tmp);
	fn.glUniformMatrix2fvARB(location, count, transpose, __value_ptmp);
#else
	fn.glUniformMatrix2fvARB(location, count, transpose, HostAddr(value, const GLfloat *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix2x3dv(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
FN_GLUNIFORMMATRIX2X3DV(location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix2x3fv(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
FN_GLUNIFORMMATRIX2X3FV(location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix2x4dv(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
FN_GLUNIFORMMATRIX2X4DV(location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix2x4fv(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
FN_GLUNIFORMMATRIX2X4FV(location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix3dv(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix3dv(GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix3dv(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
FN_GLUNIFORMMATRIX3DV(location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix3fv(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix3fv(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix3fv(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
FN_GLUNIFORMMATRIX3FV(location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix3fvARB(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix3fvARB(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix3fvARB(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __value_size = MAX(9 * count, 0);
	GLfloat __value_tmp[__value_size];
	GLfloat *__value_ptmp = Atari2HostFloatArray(__value_size, value, __value_tmp);
	fn.glUniformMatrix3fvARB(location, count, transpose, __value_ptmp);
#else
	fn.glUniformMatrix3fvARB(location, count, transpose, HostAddr(value, const GLfloat *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix3x2dv(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
FN_GLUNIFORMMATRIX3X2DV(location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix3x2fv(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
FN_GLUNIFORMMATRIX3X2FV(location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix3x4dv(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
FN_GLUNIFORMMATRIX3X4DV(location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix3x4fv(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
FN_GLUNIFORMMATRIX3X4FV(location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix4dv(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix4dv(GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix4dv(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
FN_GLUNIFORMMATRIX4DV(location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix4fv(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix4fv(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix4fv(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
FN_GLUNIFORMMATRIX4FV(location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix4fvARB(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix4fvARB(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix4fvARB(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
#if NFOSMESA_NEED_FLOAT_CONV
	GLint const __value_size = MAX(16 * count, 0);
	GLfloat __value_tmp[__value_size];
	GLfloat *__value_ptmp = Atari2HostFloatArray(__value_size, value, __value_tmp);
	fn.glUniformMatrix4fvARB(location, count, transpose, __value_ptmp);
#else
	fn.glUniformMatrix4fvARB(location, count, transpose, HostAddr(value, const GLfloat *));
#endif
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix4x2dv(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
FN_GLUNIFORMMATRIX4X2DV(location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix4x2fv(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
FN_GLUNIFORMMATRIX4X2FV(location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix4x3dv(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
FN_GLUNIFORMMATRIX4X3DV(location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean32 transpose, memptr value)
#else
void OSMesaDriver::nfglUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
#endif
{
	D(bug("nfosmesa: glUniformMatrix4x3fv(%d, %d, %d, " PRI_PTR ")", location, count, transpose, AtariOffset(value)));
FN_GLUNIFORMMATRIX4X3FV(location, count, transpose, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformSubroutinesuiv(GLenum shadertype, GLsizei count, memptr indices)
#else
void OSMesaDriver::nfglUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
#endif
{
	D(bug("nfosmesa: glUniformSubroutinesuiv(%s, %d, " PRI_PTR ")", gl_enum_name(shadertype), count, AtariOffset(indices)));
FN_GLUNIFORMSUBROUTINESUIV(shadertype, count, indices);
}

void OSMesaDriver::nfglUniformui64NV(GLint location, GLuint64EXT value)
{
	D(bug("nfosmesa: glUniformui64NV(%d, %" PRIu64 ")", location, value));
	fn.glUniformui64NV(location, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUniformui64vNV(GLint location, GLsizei count, memptr value)
#else
void OSMesaDriver::nfglUniformui64vNV(GLint location, GLsizei count, const GLuint64EXT *value)
#endif
{
	D(bug("nfosmesa: glUniformui64vNV(%d, %d, " PRI_PTR ")", location, count, AtariOffset(value)));
FN_GLUNIFORMUI64VNV(location, count, value);
}

void OSMesaDriver::nfglUnlockArraysEXT(void)
{
	D(bug("nfosmesa: glUnlockArraysEXT()"));
	fn.glUnlockArraysEXT();
}

GLboolean OSMesaDriver::nfglUnmapBuffer(GLenum target)
{
	D(bug("nfosmesa: glUnmapBuffer(%s)", gl_enum_name(target)));
	GLboolean __ret = fn.glUnmapBuffer(target);
	return __ret;
}

GLboolean OSMesaDriver::nfglUnmapBufferARB(GLenum target)
{
	D(bug("nfosmesa: glUnmapBufferARB(%s)", gl_enum_name(target)));
	GLboolean __ret = fn.glUnmapBufferARB(target);
	return __ret;
}

GLboolean OSMesaDriver::nfglUnmapNamedBuffer(GLuint buffer)
{
	D(bug("nfosmesa: glUnmapNamedBuffer(%u)", buffer));
	GLboolean __ret = fn.glUnmapNamedBuffer(buffer);
	return __ret;
}

GLboolean OSMesaDriver::nfglUnmapNamedBufferEXT(GLuint buffer)
{
	D(bug("nfosmesa: glUnmapNamedBufferEXT(%u)", buffer));
	GLboolean __ret = fn.glUnmapNamedBufferEXT(buffer);
	return __ret;
}

void OSMesaDriver::nfglUnmapObjectBufferATI(GLuint buffer)
{
	D(bug("nfosmesa: glUnmapObjectBufferATI(%u)", buffer));
	fn.glUnmapObjectBufferATI(buffer);
}

void OSMesaDriver::nfglUnmapTexture2DINTEL(GLuint texture, GLint level)
{
	D(bug("nfosmesa: glUnmapTexture2DINTEL(%u, %d)", texture, level));
	fn.glUnmapTexture2DINTEL(texture, level);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglUpdateObjectBufferATI(GLuint buffer, GLuint offset, GLsizei size, memptr pointer, GLenum preserve)
#else
void OSMesaDriver::nfglUpdateObjectBufferATI(GLuint buffer, GLuint offset, GLsizei size, const void *pointer, GLenum preserve)
#endif
{
	D(bug("nfosmesa: glUpdateObjectBufferATI(%u, %u, %d, " PRI_PTR ", %s)", buffer, offset, size, AtariOffset(pointer), gl_enum_name(preserve)));
FN_GLUPDATEOBJECTBUFFERATI(buffer, offset, size, pointer, preserve);
}

void OSMesaDriver::nfglUseProgram(GLuint program)
{
	D(bug("nfosmesa: glUseProgram(%u)", program));
	fn.glUseProgram(program);
}

void OSMesaDriver::nfglUseProgramObjectARB(GLhandleARB programObj)
{
	D(bug("nfosmesa: glUseProgramObjectARB(%u)", (unsigned int)(uintptr_t)programObj));
	fn.glUseProgramObjectARB(programObj);
}

void OSMesaDriver::nfglUseProgramStages(GLuint pipeline, GLbitfield stages, GLuint program)
{
	D(bug("nfosmesa: glUseProgramStages(%u, 0x%x, %u)", pipeline, stages, program));
	fn.glUseProgramStages(pipeline, stages, program);
}

void OSMesaDriver::nfglUseShaderProgramEXT(GLenum type, GLuint program)
{
	D(bug("nfosmesa: glUseShaderProgramEXT(%s, %u)", gl_enum_name(type), program));
	fn.glUseShaderProgramEXT(type, program);
}

#if 0
void OSMesaDriver::nfglVDPAUFiniNV(void)
{
	D(bug("nfosmesa: glVDPAUFiniNV()"));
FN_GLVDPAUFININV();
}
#endif

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVDPAUGetSurfaceivNV(GLvdpauSurfaceNV surface, GLenum pname, GLsizei bufSize, memptr length, memptr values)
#else
void OSMesaDriver::nfglVDPAUGetSurfaceivNV(GLvdpauSurfaceNV surface, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
#endif
{
	D(bug("nfosmesa: glVDPAUGetSurfaceivNV(" PRI_IPTR ", %s, %d, " PRI_PTR ", " PRI_PTR ")", surface, gl_enum_name(pname), bufSize, AtariOffset(length), AtariOffset(values)));
FN_GLVDPAUGETSURFACEIVNV(surface, pname, bufSize, length, values);
}
#endif

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVDPAUInitNV(memptr vdpDevice, memptr getProcAddress)
#else
void OSMesaDriver::nfglVDPAUInitNV(const void *vdpDevice, const void *getProcAddress)
#endif
{
	D(bug("nfosmesa: glVDPAUInitNV(" PRI_PTR ", " PRI_PTR ")", AtariOffset(vdpDevice), AtariOffset(getProcAddress)));
FN_GLVDPAUINITNV(vdpDevice, getProcAddress);
}
#endif

#if 0
GLboolean OSMesaDriver::nfglVDPAUIsSurfaceNV(GLvdpauSurfaceNV surface)
{
	D(bug("nfosmesa: glVDPAUIsSurfaceNV(" PRI_IPTR ")", surface));
FN_GLVDPAUISSURFACENV(surface);
}
#endif

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVDPAUMapSurfacesNV(GLsizei numSurfaces, memptr surfaces)
#else
void OSMesaDriver::nfglVDPAUMapSurfacesNV(GLsizei numSurfaces, const GLvdpauSurfaceNV *surfaces)
#endif
{
	D(bug("nfosmesa: glVDPAUMapSurfacesNV(%d, " PRI_PTR ")", numSurfaces, AtariOffset(surfaces)));
FN_GLVDPAUMAPSURFACESNV(numSurfaces, surfaces);
}
#endif

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
GLvdpauSurfaceNV OSMesaDriver::nfglVDPAURegisterOutputSurfaceNV(memptr vdpSurface, GLenum target, GLsizei numTextureNames, memptr textureNames)
#else
GLvdpauSurfaceNV OSMesaDriver::nfglVDPAURegisterOutputSurfaceNV(const void *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames)
#endif
{
	D(bug("nfosmesa: glVDPAURegisterOutputSurfaceNV(" PRI_PTR ", %s, %d, " PRI_PTR ")", AtariOffset(vdpSurface), gl_enum_name(target), numTextureNames, AtariOffset(textureNames)));
FN_GLVDPAUREGISTEROUTPUTSURFACENV(vdpSurface, target, numTextureNames, textureNames);
}
#endif

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
GLvdpauSurfaceNV OSMesaDriver::nfglVDPAURegisterVideoSurfaceNV(memptr vdpSurface, GLenum target, GLsizei numTextureNames, memptr textureNames)
#else
GLvdpauSurfaceNV OSMesaDriver::nfglVDPAURegisterVideoSurfaceNV(const void *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames)
#endif
{
	D(bug("nfosmesa: glVDPAURegisterVideoSurfaceNV(" PRI_PTR ", %s, %d, " PRI_PTR ")", AtariOffset(vdpSurface), gl_enum_name(target), numTextureNames, AtariOffset(textureNames)));
FN_GLVDPAUREGISTERVIDEOSURFACENV(vdpSurface, target, numTextureNames, textureNames);
}
#endif

#if 0
void OSMesaDriver::nfglVDPAUSurfaceAccessNV(GLvdpauSurfaceNV surface, GLenum access)
{
	D(bug("nfosmesa: glVDPAUSurfaceAccessNV(" PRI_IPTR ", %s)", surface, gl_enum_name(access)));
FN_GLVDPAUSURFACEACCESSNV(surface, access);
}
#endif

#if 0
#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVDPAUUnmapSurfacesNV(GLsizei numSurface, memptr surfaces)
#else
void OSMesaDriver::nfglVDPAUUnmapSurfacesNV(GLsizei numSurface, const GLvdpauSurfaceNV *surfaces)
#endif
{
	D(bug("nfosmesa: glVDPAUUnmapSurfacesNV(%d, " PRI_PTR ")", numSurface, AtariOffset(surfaces)));
FN_GLVDPAUUNMAPSURFACESNV(numSurface, surfaces);
}
#endif

#if 0
void OSMesaDriver::nfglVDPAUUnregisterSurfaceNV(GLvdpauSurfaceNV surface)
{
	D(bug("nfosmesa: glVDPAUUnregisterSurfaceNV(" PRI_IPTR ")", surface));
FN_GLVDPAUUNREGISTERSURFACENV(surface);
}
#endif

void OSMesaDriver::nfglValidateProgram(GLuint program)
{
	D(bug("nfosmesa: glValidateProgram(%u)", program));
	fn.glValidateProgram(program);
}

void OSMesaDriver::nfglValidateProgramARB(GLhandleARB programObj)
{
	D(bug("nfosmesa: glValidateProgramARB(%u)", (unsigned int)(uintptr_t)programObj));
	fn.glValidateProgramARB(programObj);
}

void OSMesaDriver::nfglValidateProgramPipeline(GLuint pipeline)
{
	D(bug("nfosmesa: glValidateProgramPipeline(%u)", pipeline));
	fn.glValidateProgramPipeline(pipeline);
}

void OSMesaDriver::nfglVariantArrayObjectATI(GLuint id, GLenum type, GLsizei stride, GLuint buffer, GLuint offset)
{
	D(bug("nfosmesa: glVariantArrayObjectATI(%u, %s, %d, %u, %u)", id, gl_enum_name(type), stride, buffer, offset));
	fn.glVariantArrayObjectATI(id, type, stride, buffer, offset);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVariantPointerEXT(GLuint id, GLenum type, GLuint stride, memptr addr)
#else
void OSMesaDriver::nfglVariantPointerEXT(GLuint id, GLenum type, GLuint stride, const void *addr)
#endif
{
	D(bug("nfosmesa: glVariantPointerEXT(%u, %s, %u, " PRI_PTR ")", id, gl_enum_name(type), stride, AtariOffset(addr)));
FN_GLVARIANTPOINTEREXT(id, type, stride, addr);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVariantbvEXT(GLuint id, memptr addr)
#else
void OSMesaDriver::nfglVariantbvEXT(GLuint id, const GLbyte *addr)
#endif
{
	D(bug("nfosmesa: glVariantbvEXT(%u, " PRI_PTR ")", id, AtariOffset(addr)));
FN_GLVARIANTBVEXT(id, addr);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVariantdvEXT(GLuint id, memptr addr)
#else
void OSMesaDriver::nfglVariantdvEXT(GLuint id, const GLdouble *addr)
#endif
{
	D(bug("nfosmesa: glVariantdvEXT(%u, " PRI_PTR ")", id, AtariOffset(addr)));
FN_GLVARIANTDVEXT(id, addr);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVariantfvEXT(GLuint id, memptr addr)
#else
void OSMesaDriver::nfglVariantfvEXT(GLuint id, const GLfloat *addr)
#endif
{
	D(bug("nfosmesa: glVariantfvEXT(%u, " PRI_PTR ")", id, AtariOffset(addr)));
FN_GLVARIANTFVEXT(id, addr);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVariantivEXT(GLuint id, memptr addr)
#else
void OSMesaDriver::nfglVariantivEXT(GLuint id, const GLint *addr)
#endif
{
	D(bug("nfosmesa: glVariantivEXT(%u, " PRI_PTR ")", id, AtariOffset(addr)));
FN_GLVARIANTIVEXT(id, addr);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVariantsvEXT(GLuint id, memptr addr)
#else
void OSMesaDriver::nfglVariantsvEXT(GLuint id, const GLshort *addr)
#endif
{
	D(bug("nfosmesa: glVariantsvEXT(%u, " PRI_PTR ")", id, AtariOffset(addr)));
FN_GLVARIANTSVEXT(id, addr);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVariantubvEXT(GLuint id, memptr addr)
#else
void OSMesaDriver::nfglVariantubvEXT(GLuint id, const GLubyte *addr)
#endif
{
	D(bug("nfosmesa: glVariantubvEXT(%u, " PRI_PTR ")", id, AtariOffset(addr)));
FN_GLVARIANTUBVEXT(id, addr);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVariantuivEXT(GLuint id, memptr addr)
#else
void OSMesaDriver::nfglVariantuivEXT(GLuint id, const GLuint *addr)
#endif
{
	D(bug("nfosmesa: glVariantuivEXT(%u, " PRI_PTR ")", id, AtariOffset(addr)));
FN_GLVARIANTUIVEXT(id, addr);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVariantusvEXT(GLuint id, memptr addr)
#else
void OSMesaDriver::nfglVariantusvEXT(GLuint id, const GLushort *addr)
#endif
{
	D(bug("nfosmesa: glVariantusvEXT(%u, " PRI_PTR ")", id, AtariOffset(addr)));
FN_GLVARIANTUSVEXT(id, addr);
}

void OSMesaDriver::nfglVertex2bOES(GLbyte32 x, GLbyte32 y)
{
	D(bug("nfosmesa: glVertex2bOES(%d, %d)", x, y));
	fn.glVertex2bOES(x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex2bvOES(memptr coords)
#else
void OSMesaDriver::nfglVertex2bvOES(const GLbyte *coords)
#endif
{
	D(bug("nfosmesa: glVertex2bvOES(" PRI_PTR ")", AtariOffset(coords)));
FN_GLVERTEX2BVOES(coords);
}

void OSMesaDriver::nfglVertex2d(GLdouble x, GLdouble y)
{
	D(bug("nfosmesa: glVertex2d(%f, %f)", x, y));
	fn.glVertex2d(x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex2dv(memptr v)
#else
void OSMesaDriver::nfglVertex2dv(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertex2dv(" PRI_PTR ")", AtariOffset(v)));
FN_GLVERTEX2DV(v);
}

void OSMesaDriver::nfglVertex2f(GLfloat x, GLfloat y)
{
	D(bug("nfosmesa: glVertex2f(%f, %f)", x, y));
	fn.glVertex2f(x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex2fv(memptr v)
#else
void OSMesaDriver::nfglVertex2fv(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glVertex2fv(" PRI_PTR ")", AtariOffset(v)));
FN_GLVERTEX2FV(v);
}

void OSMesaDriver::nfglVertex2hNV(GLhalfNV32 x, GLhalfNV32 y)
{
	D(bug("nfosmesa: glVertex2hNV(%u, %u)", x, y));
	fn.glVertex2hNV(x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex2hvNV(memptr v)
#else
void OSMesaDriver::nfglVertex2hvNV(const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glVertex2hvNV(" PRI_PTR ")", AtariOffset(v)));
FN_GLVERTEX2HVNV(v);
}

void OSMesaDriver::nfglVertex2i(GLint x, GLint y)
{
	D(bug("nfosmesa: glVertex2i(%d, %d)", x, y));
	fn.glVertex2i(x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex2iv(memptr v)
#else
void OSMesaDriver::nfglVertex2iv(const GLint *v)
#endif
{
	D(bug("nfosmesa: glVertex2iv(" PRI_PTR ")", AtariOffset(v)));
FN_GLVERTEX2IV(v);
}

void OSMesaDriver::nfglVertex2s(GLshort32 x, GLshort32 y)
{
	D(bug("nfosmesa: glVertex2s(%d, %d)", x, y));
	fn.glVertex2s(x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex2sv(memptr v)
#else
void OSMesaDriver::nfglVertex2sv(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertex2sv(" PRI_PTR ")", AtariOffset(v)));
FN_GLVERTEX2SV(v);
}

void OSMesaDriver::nfglVertex2xOES(GLfixed x)
{
	D(bug("nfosmesa: glVertex2xOES(0x%x)", x));
	fn.glVertex2xOES(x);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex2xvOES(memptr coords)
#else
void OSMesaDriver::nfglVertex2xvOES(const GLfixed *coords)
#endif
{
	D(bug("nfosmesa: glVertex2xvOES(" PRI_PTR ")", AtariOffset(coords)));
FN_GLVERTEX2XVOES(coords);
}

void OSMesaDriver::nfglVertex3bOES(GLbyte32 x, GLbyte32 y, GLbyte32 z)
{
	D(bug("nfosmesa: glVertex3bOES(%d, %d, %d)", x, y, z));
	fn.glVertex3bOES(x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex3bvOES(memptr coords)
#else
void OSMesaDriver::nfglVertex3bvOES(const GLbyte *coords)
#endif
{
	D(bug("nfosmesa: glVertex3bvOES(" PRI_PTR ")", AtariOffset(coords)));
FN_GLVERTEX3BVOES(coords);
}

void OSMesaDriver::nfglVertex3d(GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glVertex3d(%f, %f, %f)", x, y, z));
	fn.glVertex3d(x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex3dv(memptr v)
#else
void OSMesaDriver::nfglVertex3dv(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertex3dv(" PRI_PTR ")", AtariOffset(v)));
FN_GLVERTEX3DV(v);
}

void OSMesaDriver::nfglVertex3f(GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glVertex3f(%f, %f, %f)", x, y, z));
	fn.glVertex3f(x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex3fv(memptr v)
#else
void OSMesaDriver::nfglVertex3fv(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glVertex3fv(" PRI_PTR ")", AtariOffset(v)));
FN_GLVERTEX3FV(v);
}

void OSMesaDriver::nfglVertex3hNV(GLhalfNV32 x, GLhalfNV32 y, GLhalfNV32 z)
{
	D(bug("nfosmesa: glVertex3hNV(%u, %u, %u)", x, y, z));
	fn.glVertex3hNV(x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex3hvNV(memptr v)
#else
void OSMesaDriver::nfglVertex3hvNV(const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glVertex3hvNV(" PRI_PTR ")", AtariOffset(v)));
FN_GLVERTEX3HVNV(v);
}

void OSMesaDriver::nfglVertex3i(GLint x, GLint y, GLint z)
{
	D(bug("nfosmesa: glVertex3i(%d, %d, %d)", x, y, z));
	fn.glVertex3i(x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex3iv(memptr v)
#else
void OSMesaDriver::nfglVertex3iv(const GLint *v)
#endif
{
	D(bug("nfosmesa: glVertex3iv(" PRI_PTR ")", AtariOffset(v)));
FN_GLVERTEX3IV(v);
}

void OSMesaDriver::nfglVertex3s(GLshort32 x, GLshort32 y, GLshort32 z)
{
	D(bug("nfosmesa: glVertex3s(%d, %d, %d)", x, y, z));
	fn.glVertex3s(x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex3sv(memptr v)
#else
void OSMesaDriver::nfglVertex3sv(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertex3sv(" PRI_PTR ")", AtariOffset(v)));
FN_GLVERTEX3SV(v);
}

void OSMesaDriver::nfglVertex3xOES(GLfixed x, GLfixed y)
{
	D(bug("nfosmesa: glVertex3xOES(0x%x, 0x%x)", x, y));
	fn.glVertex3xOES(x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex3xvOES(memptr coords)
#else
void OSMesaDriver::nfglVertex3xvOES(const GLfixed *coords)
#endif
{
	D(bug("nfosmesa: glVertex3xvOES(" PRI_PTR ")", AtariOffset(coords)));
FN_GLVERTEX3XVOES(coords);
}

void OSMesaDriver::nfglVertex4bOES(GLbyte32 x, GLbyte32 y, GLbyte32 z, GLbyte32 w)
{
	D(bug("nfosmesa: glVertex4bOES(%d, %d, %d, %d)", x, y, z, w));
	fn.glVertex4bOES(x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex4bvOES(memptr coords)
#else
void OSMesaDriver::nfglVertex4bvOES(const GLbyte *coords)
#endif
{
	D(bug("nfosmesa: glVertex4bvOES(" PRI_PTR ")", AtariOffset(coords)));
FN_GLVERTEX4BVOES(coords);
}

void OSMesaDriver::nfglVertex4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	D(bug("nfosmesa: glVertex4d(%f, %f, %f, %f)", x, y, z, w));
	fn.glVertex4d(x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex4dv(memptr v)
#else
void OSMesaDriver::nfglVertex4dv(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertex4dv(" PRI_PTR ")", AtariOffset(v)));
FN_GLVERTEX4DV(v);
}

void OSMesaDriver::nfglVertex4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	D(bug("nfosmesa: glVertex4f(%f, %f, %f, %f)", x, y, z, w));
	fn.glVertex4f(x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex4fv(memptr v)
#else
void OSMesaDriver::nfglVertex4fv(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glVertex4fv(" PRI_PTR ")", AtariOffset(v)));
FN_GLVERTEX4FV(v);
}

void OSMesaDriver::nfglVertex4hNV(GLhalfNV32 x, GLhalfNV32 y, GLhalfNV32 z, GLhalfNV32 w)
{
	D(bug("nfosmesa: glVertex4hNV(%u, %u, %u, %u)", x, y, z, w));
	fn.glVertex4hNV(x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex4hvNV(memptr v)
#else
void OSMesaDriver::nfglVertex4hvNV(const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glVertex4hvNV(" PRI_PTR ")", AtariOffset(v)));
FN_GLVERTEX4HVNV(v);
}

void OSMesaDriver::nfglVertex4i(GLint x, GLint y, GLint z, GLint w)
{
	D(bug("nfosmesa: glVertex4i(%d, %d, %d, %d)", x, y, z, w));
	fn.glVertex4i(x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex4iv(memptr v)
#else
void OSMesaDriver::nfglVertex4iv(const GLint *v)
#endif
{
	D(bug("nfosmesa: glVertex4iv(" PRI_PTR ")", AtariOffset(v)));
FN_GLVERTEX4IV(v);
}

void OSMesaDriver::nfglVertex4s(GLshort32 x, GLshort32 y, GLshort32 z, GLshort32 w)
{
	D(bug("nfosmesa: glVertex4s(%d, %d, %d, %d)", x, y, z, w));
	fn.glVertex4s(x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex4sv(memptr v)
#else
void OSMesaDriver::nfglVertex4sv(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertex4sv(" PRI_PTR ")", AtariOffset(v)));
FN_GLVERTEX4SV(v);
}

void OSMesaDriver::nfglVertex4xOES(GLfixed x, GLfixed y, GLfixed z)
{
	D(bug("nfosmesa: glVertex4xOES(0x%x, 0x%x, 0x%x)", x, y, z));
	fn.glVertex4xOES(x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertex4xvOES(memptr coords)
#else
void OSMesaDriver::nfglVertex4xvOES(const GLfixed *coords)
#endif
{
	D(bug("nfosmesa: glVertex4xvOES(" PRI_PTR ")", AtariOffset(coords)));
FN_GLVERTEX4XVOES(coords);
}

void OSMesaDriver::nfglVertexArrayAttribBinding(GLuint vaobj, GLuint attribindex, GLuint bindingindex)
{
	D(bug("nfosmesa: glVertexArrayAttribBinding(%u, %u, %u)", vaobj, attribindex, bindingindex));
	fn.glVertexArrayAttribBinding(vaobj, attribindex, bindingindex);
}

void OSMesaDriver::nfglVertexArrayAttribFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean32 normalized, GLuint relativeoffset)
{
	D(bug("nfosmesa: glVertexArrayAttribFormat(%u, %u, %d, %s, %d, %u)", vaobj, attribindex, size, gl_enum_name(type), normalized, relativeoffset));
	fn.glVertexArrayAttribFormat(vaobj, attribindex, size, type, normalized, relativeoffset);
}

void OSMesaDriver::nfglVertexArrayAttribIFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
{
	D(bug("nfosmesa: glVertexArrayAttribIFormat(%u, %u, %d, %s, %u)", vaobj, attribindex, size, gl_enum_name(type), relativeoffset));
	fn.glVertexArrayAttribIFormat(vaobj, attribindex, size, type, relativeoffset);
}

void OSMesaDriver::nfglVertexArrayAttribLFormat(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
{
	D(bug("nfosmesa: glVertexArrayAttribLFormat(%u, %u, %d, %s, %u)", vaobj, attribindex, size, gl_enum_name(type), relativeoffset));
	fn.glVertexArrayAttribLFormat(vaobj, attribindex, size, type, relativeoffset);
}

void OSMesaDriver::nfglVertexArrayBindVertexBufferEXT(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
{
	D(bug("nfosmesa: glVertexArrayBindVertexBufferEXT(%u, %u, %u, %" PRI_IPTR ", %d)", vaobj, bindingindex, buffer, offset, stride));
	fn.glVertexArrayBindVertexBufferEXT(vaobj, bindingindex, buffer, offset, stride);
}

void OSMesaDriver::nfglVertexArrayBindingDivisor(GLuint vaobj, GLuint bindingindex, GLuint divisor)
{
	D(bug("nfosmesa: glVertexArrayBindingDivisor(%u, %u, %u)", vaobj, bindingindex, divisor));
	fn.glVertexArrayBindingDivisor(vaobj, bindingindex, divisor);
}

void OSMesaDriver::nfglVertexArrayColorOffsetEXT(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset)
{
	D(bug("nfosmesa: glVertexArrayColorOffsetEXT(%u, %u, %d, %s, %d, %" PRI_IPTR ")", vaobj, buffer, size, gl_enum_name(type), stride, offset));
	fn.glVertexArrayColorOffsetEXT(vaobj, buffer, size, type, stride, offset);
}

void OSMesaDriver::nfglVertexArrayEdgeFlagOffsetEXT(GLuint vaobj, GLuint buffer, GLsizei stride, GLintptr offset)
{
	D(bug("nfosmesa: glVertexArrayEdgeFlagOffsetEXT(%u, %u, %d, %" PRI_IPTR ")", vaobj, buffer, stride, offset));
	fn.glVertexArrayEdgeFlagOffsetEXT(vaobj, buffer, stride, offset);
}

void OSMesaDriver::nfglVertexArrayElementBuffer(GLuint vaobj, GLuint buffer)
{
	D(bug("nfosmesa: glVertexArrayElementBuffer(%u, %u)", vaobj, buffer));
	fn.glVertexArrayElementBuffer(vaobj, buffer);
}

void OSMesaDriver::nfglVertexArrayFogCoordOffsetEXT(GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset)
{
	D(bug("nfosmesa: glVertexArrayFogCoordOffsetEXT(%u, %u, %s, %d, %" PRI_IPTR ")", vaobj, buffer, gl_enum_name(type), stride, offset));
	fn.glVertexArrayFogCoordOffsetEXT(vaobj, buffer, type, stride, offset);
}

void OSMesaDriver::nfglVertexArrayIndexOffsetEXT(GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset)
{
	D(bug("nfosmesa: glVertexArrayIndexOffsetEXT(%u, %u, %s, %d, %" PRI_IPTR ")", vaobj, buffer, gl_enum_name(type), stride, offset));
	fn.glVertexArrayIndexOffsetEXT(vaobj, buffer, type, stride, offset);
}

void OSMesaDriver::nfglVertexArrayMultiTexCoordOffsetEXT(GLuint vaobj, GLuint buffer, GLenum texunit, GLint size, GLenum type, GLsizei stride, GLintptr offset)
{
	D(bug("nfosmesa: glVertexArrayMultiTexCoordOffsetEXT(%u, %u, %s, %d, %s, %d, %" PRI_IPTR ")", vaobj, buffer, gl_enum_name(texunit), size, gl_enum_name(type), stride, offset));
	fn.glVertexArrayMultiTexCoordOffsetEXT(vaobj, buffer, texunit, size, type, stride, offset);
}

void OSMesaDriver::nfglVertexArrayNormalOffsetEXT(GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset)
{
	D(bug("nfosmesa: glVertexArrayNormalOffsetEXT(%u, %u, %s, %d, %" PRI_IPTR ")", vaobj, buffer, gl_enum_name(type), stride, offset));
	fn.glVertexArrayNormalOffsetEXT(vaobj, buffer, type, stride, offset);
}

void OSMesaDriver::nfglVertexArrayParameteriAPPLE(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glVertexArrayParameteriAPPLE(%s, %d)", gl_enum_name(pname), param));
	fn.glVertexArrayParameteriAPPLE(pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexArrayRangeAPPLE(GLsizei length, memptr pointer)
#else
void OSMesaDriver::nfglVertexArrayRangeAPPLE(GLsizei length, void *pointer)
#endif
{
	D(bug("nfosmesa: glVertexArrayRangeAPPLE(%d, " PRI_PTR ")", length, AtariOffset(pointer)));
FN_GLVERTEXARRAYRANGEAPPLE(length, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexArrayRangeNV(GLsizei length, memptr pointer)
#else
void OSMesaDriver::nfglVertexArrayRangeNV(GLsizei length, const void *pointer)
#endif
{
	D(bug("nfosmesa: glVertexArrayRangeNV(%d, " PRI_PTR ")", length, AtariOffset(pointer)));
FN_GLVERTEXARRAYRANGENV(length, pointer);
}

void OSMesaDriver::nfglVertexArraySecondaryColorOffsetEXT(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset)
{
	D(bug("nfosmesa: glVertexArraySecondaryColorOffsetEXT(%u, %u, %d, %s, %d, %" PRI_IPTR ")", vaobj, buffer, size, gl_enum_name(type), stride, offset));
	fn.glVertexArraySecondaryColorOffsetEXT(vaobj, buffer, size, type, stride, offset);
}

void OSMesaDriver::nfglVertexArrayTexCoordOffsetEXT(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset)
{
	D(bug("nfosmesa: glVertexArrayTexCoordOffsetEXT(%u, %u, %d, %s, %d, %" PRI_IPTR ")", vaobj, buffer, size, gl_enum_name(type), stride, offset));
	fn.glVertexArrayTexCoordOffsetEXT(vaobj, buffer, size, type, stride, offset);
}

void OSMesaDriver::nfglVertexArrayVertexAttribBindingEXT(GLuint vaobj, GLuint attribindex, GLuint bindingindex)
{
	D(bug("nfosmesa: glVertexArrayVertexAttribBindingEXT(%u, %u, %u)", vaobj, attribindex, bindingindex));
	fn.glVertexArrayVertexAttribBindingEXT(vaobj, attribindex, bindingindex);
}

void OSMesaDriver::nfglVertexArrayVertexAttribDivisorEXT(GLuint vaobj, GLuint index, GLuint divisor)
{
	D(bug("nfosmesa: glVertexArrayVertexAttribDivisorEXT(%u, %u, %u)", vaobj, index, divisor));
	fn.glVertexArrayVertexAttribDivisorEXT(vaobj, index, divisor);
}

void OSMesaDriver::nfglVertexArrayVertexAttribFormatEXT(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLboolean32 normalized, GLuint relativeoffset)
{
	D(bug("nfosmesa: glVertexArrayVertexAttribFormatEXT(%u, %u, %d, %s, %d, %u)", vaobj, attribindex, size, gl_enum_name(type), normalized, relativeoffset));
	fn.glVertexArrayVertexAttribFormatEXT(vaobj, attribindex, size, type, normalized, relativeoffset);
}

void OSMesaDriver::nfglVertexArrayVertexAttribIFormatEXT(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
{
	D(bug("nfosmesa: glVertexArrayVertexAttribIFormatEXT(%u, %u, %d, %s, %u)", vaobj, attribindex, size, gl_enum_name(type), relativeoffset));
	fn.glVertexArrayVertexAttribIFormatEXT(vaobj, attribindex, size, type, relativeoffset);
}

void OSMesaDriver::nfglVertexArrayVertexAttribIOffsetEXT(GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset)
{
	D(bug("nfosmesa: glVertexArrayVertexAttribIOffsetEXT(%u, %u, %u, %d, %s, %d, %" PRI_IPTR ")", vaobj, buffer, index, size, gl_enum_name(type), stride, offset));
	fn.glVertexArrayVertexAttribIOffsetEXT(vaobj, buffer, index, size, type, stride, offset);
}

void OSMesaDriver::nfglVertexArrayVertexAttribLFormatEXT(GLuint vaobj, GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
{
	D(bug("nfosmesa: glVertexArrayVertexAttribLFormatEXT(%u, %u, %d, %s, %u)", vaobj, attribindex, size, gl_enum_name(type), relativeoffset));
	fn.glVertexArrayVertexAttribLFormatEXT(vaobj, attribindex, size, type, relativeoffset);
}

void OSMesaDriver::nfglVertexArrayVertexAttribLOffsetEXT(GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLsizei stride, GLintptr offset)
{
	D(bug("nfosmesa: glVertexArrayVertexAttribLOffsetEXT(%u, %u, %u, %d, %s, %d, %" PRI_IPTR ")", vaobj, buffer, index, size, gl_enum_name(type), stride, offset));
	fn.glVertexArrayVertexAttribLOffsetEXT(vaobj, buffer, index, size, type, stride, offset);
}

void OSMesaDriver::nfglVertexArrayVertexAttribOffsetEXT(GLuint vaobj, GLuint buffer, GLuint index, GLint size, GLenum type, GLboolean32 normalized, GLsizei stride, GLintptr offset)
{
	D(bug("nfosmesa: glVertexArrayVertexAttribOffsetEXT(%u, %u, %u, %d, %s, %d, %d, %" PRI_IPTR ")", vaobj, buffer, index, size, gl_enum_name(type), normalized, stride, offset));
	fn.glVertexArrayVertexAttribOffsetEXT(vaobj, buffer, index, size, type, normalized, stride, offset);
}

void OSMesaDriver::nfglVertexArrayVertexBindingDivisorEXT(GLuint vaobj, GLuint bindingindex, GLuint divisor)
{
	D(bug("nfosmesa: glVertexArrayVertexBindingDivisorEXT(%u, %u, %u)", vaobj, bindingindex, divisor));
	fn.glVertexArrayVertexBindingDivisorEXT(vaobj, bindingindex, divisor);
}

void OSMesaDriver::nfglVertexArrayVertexBuffer(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
{
	D(bug("nfosmesa: glVertexArrayVertexBuffer(%u, %u, %u, %" PRI_IPTR ", %d)", vaobj, bindingindex, buffer, offset, stride));
	fn.glVertexArrayVertexBuffer(vaobj, bindingindex, buffer, offset, stride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexArrayVertexBuffers(GLuint vaobj, GLuint first, GLsizei count, memptr buffers, memptr offsets, memptr strides)
#else
void OSMesaDriver::nfglVertexArrayVertexBuffers(GLuint vaobj, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
#endif
{
	D(bug("nfosmesa: glVertexArrayVertexBuffers(%u, %u, %d, " PRI_PTR ", " PRI_PTR ", " PRI_PTR ")", vaobj, first, count, AtariOffset(buffers), AtariOffset(offsets), AtariOffset(strides)));
FN_GLVERTEXARRAYVERTEXBUFFERS(vaobj, first, count, buffers, offsets, strides);
}

void OSMesaDriver::nfglVertexArrayVertexOffsetEXT(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset)
{
	D(bug("nfosmesa: glVertexArrayVertexOffsetEXT(%u, %u, %d, %s, %d, %" PRI_IPTR ")", vaobj, buffer, size, gl_enum_name(type), stride, offset));
	fn.glVertexArrayVertexOffsetEXT(vaobj, buffer, size, type, stride, offset);
}

void OSMesaDriver::nfglVertexAttrib1d(GLuint index, GLdouble x)
{
	D(bug("nfosmesa: glVertexAttrib1d(%u, %f)", index, x));
	fn.glVertexAttrib1d(index, x);
}

void OSMesaDriver::nfglVertexAttrib1dARB(GLuint index, GLdouble x)
{
	D(bug("nfosmesa: glVertexAttrib1dARB(%u, %f)", index, x));
	fn.glVertexAttrib1dARB(index, x);
}

void OSMesaDriver::nfglVertexAttrib1dNV(GLuint index, GLdouble x)
{
	D(bug("nfosmesa: glVertexAttrib1dNV(%u, %f)", index, x));
	fn.glVertexAttrib1dNV(index, x);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib1dv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib1dv(GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib1dv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB1DV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib1dvARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib1dvARB(GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib1dvARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB1DVARB(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib1dvNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib1dvNV(GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib1dvNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB1DVNV(index, v);
}

void OSMesaDriver::nfglVertexAttrib1f(GLuint index, GLfloat x)
{
	D(bug("nfosmesa: glVertexAttrib1f(%u, %f)", index, x));
	fn.glVertexAttrib1f(index, x);
}

void OSMesaDriver::nfglVertexAttrib1fARB(GLuint index, GLfloat x)
{
	D(bug("nfosmesa: glVertexAttrib1fARB(%u, %f)", index, x));
	fn.glVertexAttrib1fARB(index, x);
}

void OSMesaDriver::nfglVertexAttrib1fNV(GLuint index, GLfloat x)
{
	D(bug("nfosmesa: glVertexAttrib1fNV(%u, %f)", index, x));
	fn.glVertexAttrib1fNV(index, x);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib1fv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib1fv(GLuint index, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib1fv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB1FV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib1fvARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib1fvARB(GLuint index, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib1fvARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB1FVARB(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib1fvNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib1fvNV(GLuint index, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib1fvNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB1FVNV(index, v);
}

void OSMesaDriver::nfglVertexAttrib1hNV(GLuint index, GLhalfNV32 x)
{
	D(bug("nfosmesa: glVertexAttrib1hNV(%u, %u)", index, x));
	fn.glVertexAttrib1hNV(index, x);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib1hvNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib1hvNV(GLuint index, const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib1hvNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB1HVNV(index, v);
}

void OSMesaDriver::nfglVertexAttrib1s(GLuint index, GLshort32 x)
{
	D(bug("nfosmesa: glVertexAttrib1s(%u, %d)", index, x));
	fn.glVertexAttrib1s(index, x);
}

void OSMesaDriver::nfglVertexAttrib1sARB(GLuint index, GLshort32 x)
{
	D(bug("nfosmesa: glVertexAttrib1sARB(%u, %d)", index, x));
	fn.glVertexAttrib1sARB(index, x);
}

void OSMesaDriver::nfglVertexAttrib1sNV(GLuint index, GLshort32 x)
{
	D(bug("nfosmesa: glVertexAttrib1sNV(%u, %d)", index, x));
	fn.glVertexAttrib1sNV(index, x);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib1sv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib1sv(GLuint index, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib1sv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB1SV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib1svARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib1svARB(GLuint index, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib1svARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB1SVARB(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib1svNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib1svNV(GLuint index, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib1svNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB1SVNV(index, v);
}

void OSMesaDriver::nfglVertexAttrib2d(GLuint index, GLdouble x, GLdouble y)
{
	D(bug("nfosmesa: glVertexAttrib2d(%u, %f, %f)", index, x, y));
	fn.glVertexAttrib2d(index, x, y);
}

void OSMesaDriver::nfglVertexAttrib2dARB(GLuint index, GLdouble x, GLdouble y)
{
	D(bug("nfosmesa: glVertexAttrib2dARB(%u, %f, %f)", index, x, y));
	fn.glVertexAttrib2dARB(index, x, y);
}

void OSMesaDriver::nfglVertexAttrib2dNV(GLuint index, GLdouble x, GLdouble y)
{
	D(bug("nfosmesa: glVertexAttrib2dNV(%u, %f, %f)", index, x, y));
	fn.glVertexAttrib2dNV(index, x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib2dv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib2dv(GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib2dv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB2DV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib2dvARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib2dvARB(GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib2dvARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB2DVARB(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib2dvNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib2dvNV(GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib2dvNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB2DVNV(index, v);
}

void OSMesaDriver::nfglVertexAttrib2f(GLuint index, GLfloat x, GLfloat y)
{
	D(bug("nfosmesa: glVertexAttrib2f(%u, %f, %f)", index, x, y));
	fn.glVertexAttrib2f(index, x, y);
}

void OSMesaDriver::nfglVertexAttrib2fARB(GLuint index, GLfloat x, GLfloat y)
{
	D(bug("nfosmesa: glVertexAttrib2fARB(%u, %f, %f)", index, x, y));
	fn.glVertexAttrib2fARB(index, x, y);
}

void OSMesaDriver::nfglVertexAttrib2fNV(GLuint index, GLfloat x, GLfloat y)
{
	D(bug("nfosmesa: glVertexAttrib2fNV(%u, %f, %f)", index, x, y));
	fn.glVertexAttrib2fNV(index, x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib2fv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib2fv(GLuint index, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib2fv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB2FV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib2fvARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib2fvARB(GLuint index, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib2fvARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB2FVARB(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib2fvNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib2fvNV(GLuint index, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib2fvNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB2FVNV(index, v);
}

void OSMesaDriver::nfglVertexAttrib2hNV(GLuint index, GLhalfNV32 x, GLhalfNV32 y)
{
	D(bug("nfosmesa: glVertexAttrib2hNV(%u, %u, %u)", index, x, y));
	fn.glVertexAttrib2hNV(index, x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib2hvNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib2hvNV(GLuint index, const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib2hvNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB2HVNV(index, v);
}

void OSMesaDriver::nfglVertexAttrib2s(GLuint index, GLshort32 x, GLshort32 y)
{
	D(bug("nfosmesa: glVertexAttrib2s(%u, %d, %d)", index, x, y));
	fn.glVertexAttrib2s(index, x, y);
}

void OSMesaDriver::nfglVertexAttrib2sARB(GLuint index, GLshort32 x, GLshort32 y)
{
	D(bug("nfosmesa: glVertexAttrib2sARB(%u, %d, %d)", index, x, y));
	fn.glVertexAttrib2sARB(index, x, y);
}

void OSMesaDriver::nfglVertexAttrib2sNV(GLuint index, GLshort32 x, GLshort32 y)
{
	D(bug("nfosmesa: glVertexAttrib2sNV(%u, %d, %d)", index, x, y));
	fn.glVertexAttrib2sNV(index, x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib2sv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib2sv(GLuint index, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib2sv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB2SV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib2svARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib2svARB(GLuint index, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib2svARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB2SVARB(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib2svNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib2svNV(GLuint index, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib2svNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB2SVNV(index, v);
}

void OSMesaDriver::nfglVertexAttrib3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glVertexAttrib3d(%u, %f, %f, %f)", index, x, y, z));
	fn.glVertexAttrib3d(index, x, y, z);
}

void OSMesaDriver::nfglVertexAttrib3dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glVertexAttrib3dARB(%u, %f, %f, %f)", index, x, y, z));
	fn.glVertexAttrib3dARB(index, x, y, z);
}

void OSMesaDriver::nfglVertexAttrib3dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glVertexAttrib3dNV(%u, %f, %f, %f)", index, x, y, z));
	fn.glVertexAttrib3dNV(index, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib3dv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib3dv(GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib3dv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB3DV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib3dvARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib3dvARB(GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib3dvARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB3DVARB(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib3dvNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib3dvNV(GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib3dvNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB3DVNV(index, v);
}

void OSMesaDriver::nfglVertexAttrib3f(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glVertexAttrib3f(%u, %f, %f, %f)", index, x, y, z));
	fn.glVertexAttrib3f(index, x, y, z);
}

void OSMesaDriver::nfglVertexAttrib3fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glVertexAttrib3fARB(%u, %f, %f, %f)", index, x, y, z));
	fn.glVertexAttrib3fARB(index, x, y, z);
}

void OSMesaDriver::nfglVertexAttrib3fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glVertexAttrib3fNV(%u, %f, %f, %f)", index, x, y, z));
	fn.glVertexAttrib3fNV(index, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib3fv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib3fv(GLuint index, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib3fv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB3FV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib3fvARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib3fvARB(GLuint index, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib3fvARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB3FVARB(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib3fvNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib3fvNV(GLuint index, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib3fvNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB3FVNV(index, v);
}

void OSMesaDriver::nfglVertexAttrib3hNV(GLuint index, GLhalfNV32 x, GLhalfNV32 y, GLhalfNV32 z)
{
	D(bug("nfosmesa: glVertexAttrib3hNV(%u, %u, %u, %u)", index, x, y, z));
	fn.glVertexAttrib3hNV(index, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib3hvNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib3hvNV(GLuint index, const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib3hvNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB3HVNV(index, v);
}

void OSMesaDriver::nfglVertexAttrib3s(GLuint index, GLshort32 x, GLshort32 y, GLshort32 z)
{
	D(bug("nfosmesa: glVertexAttrib3s(%u, %d, %d, %d)", index, x, y, z));
	fn.glVertexAttrib3s(index, x, y, z);
}

void OSMesaDriver::nfglVertexAttrib3sARB(GLuint index, GLshort32 x, GLshort32 y, GLshort32 z)
{
	D(bug("nfosmesa: glVertexAttrib3sARB(%u, %d, %d, %d)", index, x, y, z));
	fn.glVertexAttrib3sARB(index, x, y, z);
}

void OSMesaDriver::nfglVertexAttrib3sNV(GLuint index, GLshort32 x, GLshort32 y, GLshort32 z)
{
	D(bug("nfosmesa: glVertexAttrib3sNV(%u, %d, %d, %d)", index, x, y, z));
	fn.glVertexAttrib3sNV(index, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib3sv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib3sv(GLuint index, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib3sv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB3SV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib3svARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib3svARB(GLuint index, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib3svARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB3SVARB(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib3svNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib3svNV(GLuint index, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib3svNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB3SVNV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4Nbv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4Nbv(GLuint index, const GLbyte *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4Nbv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4NBV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4NbvARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4NbvARB(GLuint index, const GLbyte *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4NbvARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4NBVARB(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4Niv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4Niv(GLuint index, const GLint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4Niv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4NIV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4NivARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4NivARB(GLuint index, const GLint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4NivARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4NIVARB(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4Nsv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4Nsv(GLuint index, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4Nsv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4NSV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4NsvARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4NsvARB(GLuint index, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4NsvARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4NSVARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib4Nub(GLuint index, GLubyte32 x, GLubyte32 y, GLubyte32 z, GLubyte32 w)
{
	D(bug("nfosmesa: glVertexAttrib4Nub(%u, %u, %u, %u, %u)", index, x, y, z, w));
	fn.glVertexAttrib4Nub(index, x, y, z, w);
}

void OSMesaDriver::nfglVertexAttrib4NubARB(GLuint index, GLubyte32 x, GLubyte32 y, GLubyte32 z, GLubyte32 w)
{
	D(bug("nfosmesa: glVertexAttrib4NubARB(%u, %u, %u, %u, %u)", index, x, y, z, w));
	fn.glVertexAttrib4NubARB(index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4Nubv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4Nubv(GLuint index, const GLubyte *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4Nubv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4NUBV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4NubvARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4NubvARB(GLuint index, const GLubyte *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4NubvARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4NUBVARB(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4Nuiv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4Nuiv(GLuint index, const GLuint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4Nuiv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4NUIV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4NuivARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4NuivARB(GLuint index, const GLuint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4NuivARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4NUIVARB(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4Nusv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4Nusv(GLuint index, const GLushort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4Nusv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4NUSV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4NusvARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4NusvARB(GLuint index, const GLushort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4NusvARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4NUSVARB(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4bv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4bv(GLuint index, const GLbyte *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4bv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4BV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4bvARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4bvARB(GLuint index, const GLbyte *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4bvARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4BVARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	D(bug("nfosmesa: glVertexAttrib4d(%u, %f, %f, %f, %f)", index, x, y, z, w));
	fn.glVertexAttrib4d(index, x, y, z, w);
}

void OSMesaDriver::nfglVertexAttrib4dARB(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	D(bug("nfosmesa: glVertexAttrib4dARB(%u, %f, %f, %f, %f)", index, x, y, z, w));
	fn.glVertexAttrib4dARB(index, x, y, z, w);
}

void OSMesaDriver::nfglVertexAttrib4dNV(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	D(bug("nfosmesa: glVertexAttrib4dNV(%u, %f, %f, %f, %f)", index, x, y, z, w));
	fn.glVertexAttrib4dNV(index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4dv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4dv(GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4dv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4DV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4dvARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4dvARB(GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4dvARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4DVARB(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4dvNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4dvNV(GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4dvNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4DVNV(index, v);
}

void OSMesaDriver::nfglVertexAttrib4f(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	D(bug("nfosmesa: glVertexAttrib4f(%u, %f, %f, %f, %f)", index, x, y, z, w));
	fn.glVertexAttrib4f(index, x, y, z, w);
}

void OSMesaDriver::nfglVertexAttrib4fARB(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	D(bug("nfosmesa: glVertexAttrib4fARB(%u, %f, %f, %f, %f)", index, x, y, z, w));
	fn.glVertexAttrib4fARB(index, x, y, z, w);
}

void OSMesaDriver::nfglVertexAttrib4fNV(GLuint index, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	D(bug("nfosmesa: glVertexAttrib4fNV(%u, %f, %f, %f, %f)", index, x, y, z, w));
	fn.glVertexAttrib4fNV(index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4fv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4fv(GLuint index, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4fv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4FV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4fvARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4fvARB(GLuint index, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4fvARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4FVARB(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4fvNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4fvNV(GLuint index, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4fvNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4FVNV(index, v);
}

void OSMesaDriver::nfglVertexAttrib4hNV(GLuint index, GLhalfNV32 x, GLhalfNV32 y, GLhalfNV32 z, GLhalfNV32 w)
{
	D(bug("nfosmesa: glVertexAttrib4hNV(%u, %u, %u, %u, %u)", index, x, y, z, w));
	fn.glVertexAttrib4hNV(index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4hvNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4hvNV(GLuint index, const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4hvNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4HVNV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4iv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4iv(GLuint index, const GLint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4iv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4IV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4ivARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4ivARB(GLuint index, const GLint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4ivARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4IVARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib4s(GLuint index, GLshort32 x, GLshort32 y, GLshort32 z, GLshort32 w)
{
	D(bug("nfosmesa: glVertexAttrib4s(%u, %d, %d, %d, %d)", index, x, y, z, w));
	fn.glVertexAttrib4s(index, x, y, z, w);
}

void OSMesaDriver::nfglVertexAttrib4sARB(GLuint index, GLshort32 x, GLshort32 y, GLshort32 z, GLshort32 w)
{
	D(bug("nfosmesa: glVertexAttrib4sARB(%u, %d, %d, %d, %d)", index, x, y, z, w));
	fn.glVertexAttrib4sARB(index, x, y, z, w);
}

void OSMesaDriver::nfglVertexAttrib4sNV(GLuint index, GLshort32 x, GLshort32 y, GLshort32 z, GLshort32 w)
{
	D(bug("nfosmesa: glVertexAttrib4sNV(%u, %d, %d, %d, %d)", index, x, y, z, w));
	fn.glVertexAttrib4sNV(index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4sv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4sv(GLuint index, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4sv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4SV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4svARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4svARB(GLuint index, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4svARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4SVARB(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4svNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4svNV(GLuint index, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4svNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4SVNV(index, v);
}

void OSMesaDriver::nfglVertexAttrib4ubNV(GLuint index, GLubyte32 x, GLubyte32 y, GLubyte32 z, GLubyte32 w)
{
	D(bug("nfosmesa: glVertexAttrib4ubNV(%u, %u, %u, %u, %u)", index, x, y, z, w));
	fn.glVertexAttrib4ubNV(index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4ubv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4ubv(GLuint index, const GLubyte *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4ubv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4UBV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4ubvARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4ubvARB(GLuint index, const GLubyte *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4ubvARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4UBVARB(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4ubvNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4ubvNV(GLuint index, const GLubyte *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4ubvNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4UBVNV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4uiv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4uiv(GLuint index, const GLuint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4uiv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4UIV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4uivARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4uivARB(GLuint index, const GLuint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4uivARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4UIVARB(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4usv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4usv(GLuint index, const GLushort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4usv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4USV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttrib4usvARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttrib4usvARB(GLuint index, const GLushort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttrib4usvARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIB4USVARB(index, v);
}

void OSMesaDriver::nfglVertexAttribArrayObjectATI(GLuint index, GLint size, GLenum type, GLboolean32 normalized, GLsizei stride, GLuint buffer, GLuint offset)
{
	D(bug("nfosmesa: glVertexAttribArrayObjectATI(%u, %d, %s, %d, %d, %u, %u)", index, size, gl_enum_name(type), normalized, stride, buffer, offset));
FN_GLVERTEXATTRIBARRAYOBJECTATI(index, size, type, normalized, stride, buffer, offset);
}

void OSMesaDriver::nfglVertexAttribBinding(GLuint attribindex, GLuint bindingindex)
{
	D(bug("nfosmesa: glVertexAttribBinding(%u, %u)", attribindex, bindingindex));
	fn.glVertexAttribBinding(attribindex, bindingindex);
}

void OSMesaDriver::nfglVertexAttribDivisor(GLuint index, GLuint divisor)
{
	D(bug("nfosmesa: glVertexAttribDivisor(%u, %u)", index, divisor));
	fn.glVertexAttribDivisor(index, divisor);
}

void OSMesaDriver::nfglVertexAttribDivisorARB(GLuint index, GLuint divisor)
{
	D(bug("nfosmesa: glVertexAttribDivisorARB(%u, %u)", index, divisor));
	fn.glVertexAttribDivisorARB(index, divisor);
}

void OSMesaDriver::nfglVertexAttribFormat(GLuint attribindex, GLint size, GLenum type, GLboolean32 normalized, GLuint relativeoffset)
{
	D(bug("nfosmesa: glVertexAttribFormat(%u, %d, %s, %d, %u)", attribindex, size, gl_enum_name(type), normalized, relativeoffset));
	fn.glVertexAttribFormat(attribindex, size, type, normalized, relativeoffset);
}

void OSMesaDriver::nfglVertexAttribFormatNV(GLuint index, GLint size, GLenum type, GLboolean32 normalized, GLsizei stride)
{
	D(bug("nfosmesa: glVertexAttribFormatNV(%u, %d, %s, %d, %d)", index, size, gl_enum_name(type), normalized, stride));
	fn.glVertexAttribFormatNV(index, size, type, normalized, stride);
}

void OSMesaDriver::nfglVertexAttribI1i(GLuint index, GLint x)
{
	D(bug("nfosmesa: glVertexAttribI1i(%u, %d)", index, x));
	fn.glVertexAttribI1i(index, x);
}

void OSMesaDriver::nfglVertexAttribI1iEXT(GLuint index, GLint x)
{
	D(bug("nfosmesa: glVertexAttribI1iEXT(%u, %d)", index, x));
	fn.glVertexAttribI1iEXT(index, x);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI1iv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI1iv(GLuint index, const GLint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI1iv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI1IV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI1ivEXT(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI1ivEXT(GLuint index, const GLint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI1ivEXT(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI1IVEXT(index, v);
}

void OSMesaDriver::nfglVertexAttribI1ui(GLuint index, GLuint x)
{
	D(bug("nfosmesa: glVertexAttribI1ui(%u, %u)", index, x));
	fn.glVertexAttribI1ui(index, x);
}

void OSMesaDriver::nfglVertexAttribI1uiEXT(GLuint index, GLuint x)
{
	D(bug("nfosmesa: glVertexAttribI1uiEXT(%u, %u)", index, x));
	fn.glVertexAttribI1uiEXT(index, x);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI1uiv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI1uiv(GLuint index, const GLuint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI1uiv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI1UIV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI1uivEXT(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI1uivEXT(GLuint index, const GLuint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI1uivEXT(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI1UIVEXT(index, v);
}

void OSMesaDriver::nfglVertexAttribI2i(GLuint index, GLint x, GLint y)
{
	D(bug("nfosmesa: glVertexAttribI2i(%u, %d, %d)", index, x, y));
	fn.glVertexAttribI2i(index, x, y);
}

void OSMesaDriver::nfglVertexAttribI2iEXT(GLuint index, GLint x, GLint y)
{
	D(bug("nfosmesa: glVertexAttribI2iEXT(%u, %d, %d)", index, x, y));
	fn.glVertexAttribI2iEXT(index, x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI2iv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI2iv(GLuint index, const GLint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI2iv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI2IV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI2ivEXT(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI2ivEXT(GLuint index, const GLint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI2ivEXT(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI2IVEXT(index, v);
}

void OSMesaDriver::nfglVertexAttribI2ui(GLuint index, GLuint x, GLuint y)
{
	D(bug("nfosmesa: glVertexAttribI2ui(%u, %u, %u)", index, x, y));
	fn.glVertexAttribI2ui(index, x, y);
}

void OSMesaDriver::nfglVertexAttribI2uiEXT(GLuint index, GLuint x, GLuint y)
{
	D(bug("nfosmesa: glVertexAttribI2uiEXT(%u, %u, %u)", index, x, y));
	fn.glVertexAttribI2uiEXT(index, x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI2uiv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI2uiv(GLuint index, const GLuint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI2uiv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI2UIV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI2uivEXT(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI2uivEXT(GLuint index, const GLuint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI2uivEXT(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI2UIVEXT(index, v);
}

void OSMesaDriver::nfglVertexAttribI3i(GLuint index, GLint x, GLint y, GLint z)
{
	D(bug("nfosmesa: glVertexAttribI3i(%u, %d, %d, %d)", index, x, y, z));
	fn.glVertexAttribI3i(index, x, y, z);
}

void OSMesaDriver::nfglVertexAttribI3iEXT(GLuint index, GLint x, GLint y, GLint z)
{
	D(bug("nfosmesa: glVertexAttribI3iEXT(%u, %d, %d, %d)", index, x, y, z));
	fn.glVertexAttribI3iEXT(index, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI3iv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI3iv(GLuint index, const GLint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI3iv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI3IV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI3ivEXT(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI3ivEXT(GLuint index, const GLint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI3ivEXT(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI3IVEXT(index, v);
}

void OSMesaDriver::nfglVertexAttribI3ui(GLuint index, GLuint x, GLuint y, GLuint z)
{
	D(bug("nfosmesa: glVertexAttribI3ui(%u, %u, %u, %u)", index, x, y, z));
	fn.glVertexAttribI3ui(index, x, y, z);
}

void OSMesaDriver::nfglVertexAttribI3uiEXT(GLuint index, GLuint x, GLuint y, GLuint z)
{
	D(bug("nfosmesa: glVertexAttribI3uiEXT(%u, %u, %u, %u)", index, x, y, z));
	fn.glVertexAttribI3uiEXT(index, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI3uiv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI3uiv(GLuint index, const GLuint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI3uiv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI3UIV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI3uivEXT(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI3uivEXT(GLuint index, const GLuint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI3uivEXT(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI3UIVEXT(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI4bv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI4bv(GLuint index, const GLbyte *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI4bv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI4BV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI4bvEXT(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI4bvEXT(GLuint index, const GLbyte *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI4bvEXT(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI4BVEXT(index, v);
}

void OSMesaDriver::nfglVertexAttribI4i(GLuint index, GLint x, GLint y, GLint z, GLint w)
{
	D(bug("nfosmesa: glVertexAttribI4i(%u, %d, %d, %d, %d)", index, x, y, z, w));
	fn.glVertexAttribI4i(index, x, y, z, w);
}

void OSMesaDriver::nfglVertexAttribI4iEXT(GLuint index, GLint x, GLint y, GLint z, GLint w)
{
	D(bug("nfosmesa: glVertexAttribI4iEXT(%u, %d, %d, %d, %d)", index, x, y, z, w));
	fn.glVertexAttribI4iEXT(index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI4iv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI4iv(GLuint index, const GLint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI4iv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI4IV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI4ivEXT(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI4ivEXT(GLuint index, const GLint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI4ivEXT(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI4IVEXT(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI4sv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI4sv(GLuint index, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI4sv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI4SV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI4svEXT(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI4svEXT(GLuint index, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI4svEXT(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI4SVEXT(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI4ubv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI4ubv(GLuint index, const GLubyte *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI4ubv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI4UBV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI4ubvEXT(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI4ubvEXT(GLuint index, const GLubyte *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI4ubvEXT(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI4UBVEXT(index, v);
}

void OSMesaDriver::nfglVertexAttribI4ui(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
	D(bug("nfosmesa: glVertexAttribI4ui(%u, %u, %u, %u, %u)", index, x, y, z, w));
	fn.glVertexAttribI4ui(index, x, y, z, w);
}

void OSMesaDriver::nfglVertexAttribI4uiEXT(GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
	D(bug("nfosmesa: glVertexAttribI4uiEXT(%u, %u, %u, %u, %u)", index, x, y, z, w));
	fn.glVertexAttribI4uiEXT(index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI4uiv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI4uiv(GLuint index, const GLuint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI4uiv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI4UIV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI4uivEXT(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI4uivEXT(GLuint index, const GLuint *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI4uivEXT(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI4UIVEXT(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI4usv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI4usv(GLuint index, const GLushort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI4usv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI4USV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribI4usvEXT(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribI4usvEXT(GLuint index, const GLushort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribI4usvEXT(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBI4USVEXT(index, v);
}

void OSMesaDriver::nfglVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
{
	D(bug("nfosmesa: glVertexAttribIFormat(%u, %d, %s, %u)", attribindex, size, gl_enum_name(type), relativeoffset));
	fn.glVertexAttribIFormat(attribindex, size, type, relativeoffset);
}

void OSMesaDriver::nfglVertexAttribIFormatNV(GLuint index, GLint size, GLenum type, GLsizei stride)
{
	D(bug("nfosmesa: glVertexAttribIFormatNV(%u, %d, %s, %d)", index, size, gl_enum_name(type), stride));
	fn.glVertexAttribIFormatNV(index, size, type, stride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
#endif
{
	D(bug("nfosmesa: glVertexAttribIPointer(%u, %d, %s, %d, " PRI_PTR ")", index, size, gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLVERTEXATTRIBIPOINTER(index, size, type, stride, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribIPointerEXT(GLuint index, GLint size, GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglVertexAttribIPointerEXT(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
#endif
{
	D(bug("nfosmesa: glVertexAttribIPointerEXT(%u, %d, %s, %d, " PRI_PTR ")", index, size, gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLVERTEXATTRIBIPOINTEREXT(index, size, type, stride, pointer);
}

void OSMesaDriver::nfglVertexAttribL1d(GLuint index, GLdouble x)
{
	D(bug("nfosmesa: glVertexAttribL1d(%u, %f)", index, x));
	fn.glVertexAttribL1d(index, x);
}

void OSMesaDriver::nfglVertexAttribL1dEXT(GLuint index, GLdouble x)
{
	D(bug("nfosmesa: glVertexAttribL1dEXT(%u, %f)", index, x));
	fn.glVertexAttribL1dEXT(index, x);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribL1dv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribL1dv(GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribL1dv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBL1DV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribL1dvEXT(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribL1dvEXT(GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribL1dvEXT(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBL1DVEXT(index, v);
}

void OSMesaDriver::nfglVertexAttribL1i64NV(GLuint index, GLint64EXT x)
{
	D(bug("nfosmesa: glVertexAttribL1i64NV(%u, %" PRId64 ")", index, x));
	fn.glVertexAttribL1i64NV(index, x);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribL1i64vNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribL1i64vNV(GLuint index, const GLint64EXT *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribL1i64vNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBL1I64VNV(index, v);
}

void OSMesaDriver::nfglVertexAttribL1ui64ARB(GLuint index, GLuint64EXT x)
{
	D(bug("nfosmesa: glVertexAttribL1ui64ARB(%u, %" PRIu64 ")", index, x));
	fn.glVertexAttribL1ui64ARB(index, x);
}

void OSMesaDriver::nfglVertexAttribL1ui64NV(GLuint index, GLuint64EXT x)
{
	D(bug("nfosmesa: glVertexAttribL1ui64NV(%u, %" PRIu64 ")", index, x));
	fn.glVertexAttribL1ui64NV(index, x);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribL1ui64vARB(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribL1ui64vARB(GLuint index, const GLuint64EXT *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribL1ui64vARB(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBL1UI64VARB(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribL1ui64vNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribL1ui64vNV(GLuint index, const GLuint64EXT *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribL1ui64vNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBL1UI64VNV(index, v);
}

void OSMesaDriver::nfglVertexAttribL2d(GLuint index, GLdouble x, GLdouble y)
{
	D(bug("nfosmesa: glVertexAttribL2d(%u, %f, %f)", index, x, y));
	fn.glVertexAttribL2d(index, x, y);
}

void OSMesaDriver::nfglVertexAttribL2dEXT(GLuint index, GLdouble x, GLdouble y)
{
	D(bug("nfosmesa: glVertexAttribL2dEXT(%u, %f, %f)", index, x, y));
	fn.glVertexAttribL2dEXT(index, x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribL2dv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribL2dv(GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribL2dv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBL2DV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribL2dvEXT(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribL2dvEXT(GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribL2dvEXT(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBL2DVEXT(index, v);
}

void OSMesaDriver::nfglVertexAttribL2i64NV(GLuint index, GLint64EXT x, GLint64EXT y)
{
	D(bug("nfosmesa: glVertexAttribL2i64NV(%u, %" PRId64 ", %" PRId64 ")", index, x, y));
	fn.glVertexAttribL2i64NV(index, x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribL2i64vNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribL2i64vNV(GLuint index, const GLint64EXT *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribL2i64vNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBL2I64VNV(index, v);
}

void OSMesaDriver::nfglVertexAttribL2ui64NV(GLuint index, GLuint64EXT x, GLuint64EXT y)
{
	D(bug("nfosmesa: glVertexAttribL2ui64NV(%u, %" PRIu64 ", %" PRIu64 ")", index, x, y));
	fn.glVertexAttribL2ui64NV(index, x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribL2ui64vNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribL2ui64vNV(GLuint index, const GLuint64EXT *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribL2ui64vNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBL2UI64VNV(index, v);
}

void OSMesaDriver::nfglVertexAttribL3d(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glVertexAttribL3d(%u, %f, %f, %f)", index, x, y, z));
	fn.glVertexAttribL3d(index, x, y, z);
}

void OSMesaDriver::nfglVertexAttribL3dEXT(GLuint index, GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glVertexAttribL3dEXT(%u, %f, %f, %f)", index, x, y, z));
	fn.glVertexAttribL3dEXT(index, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribL3dv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribL3dv(GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribL3dv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBL3DV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribL3dvEXT(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribL3dvEXT(GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribL3dvEXT(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBL3DVEXT(index, v);
}

void OSMesaDriver::nfglVertexAttribL3i64NV(GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z)
{
	D(bug("nfosmesa: glVertexAttribL3i64NV(%u, %" PRId64 ", %" PRId64 ", %" PRId64 ")", index, x, y, z));
	fn.glVertexAttribL3i64NV(index, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribL3i64vNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribL3i64vNV(GLuint index, const GLint64EXT *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribL3i64vNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBL3I64VNV(index, v);
}

void OSMesaDriver::nfglVertexAttribL3ui64NV(GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z)
{
	D(bug("nfosmesa: glVertexAttribL3ui64NV(%u, %" PRIu64 ", %" PRIu64 ", %" PRIu64 ")", index, x, y, z));
	fn.glVertexAttribL3ui64NV(index, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribL3ui64vNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribL3ui64vNV(GLuint index, const GLuint64EXT *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribL3ui64vNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBL3UI64VNV(index, v);
}

void OSMesaDriver::nfglVertexAttribL4d(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	D(bug("nfosmesa: glVertexAttribL4d(%u, %f, %f, %f, %f)", index, x, y, z, w));
	fn.glVertexAttribL4d(index, x, y, z, w);
}

void OSMesaDriver::nfglVertexAttribL4dEXT(GLuint index, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	D(bug("nfosmesa: glVertexAttribL4dEXT(%u, %f, %f, %f, %f)", index, x, y, z, w));
	fn.glVertexAttribL4dEXT(index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribL4dv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribL4dv(GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribL4dv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBL4DV(index, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribL4dvEXT(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribL4dvEXT(GLuint index, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribL4dvEXT(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBL4DVEXT(index, v);
}

void OSMesaDriver::nfglVertexAttribL4i64NV(GLuint index, GLint64EXT x, GLint64EXT y, GLint64EXT z, GLint64EXT w)
{
	D(bug("nfosmesa: glVertexAttribL4i64NV(%u, %" PRId64 ", %" PRId64 ", %" PRId64 ", %" PRId64 ")", index, x, y, z, w));
	fn.glVertexAttribL4i64NV(index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribL4i64vNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribL4i64vNV(GLuint index, const GLint64EXT *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribL4i64vNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBL4I64VNV(index, v);
}

void OSMesaDriver::nfglVertexAttribL4ui64NV(GLuint index, GLuint64EXT x, GLuint64EXT y, GLuint64EXT z, GLuint64EXT w)
{
	D(bug("nfosmesa: glVertexAttribL4ui64NV(%u, %" PRIu64 ", %" PRIu64 ", %" PRIu64 ", %" PRIu64 ")", index, x, y, z, w));
	fn.glVertexAttribL4ui64NV(index, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribL4ui64vNV(GLuint index, memptr v)
#else
void OSMesaDriver::nfglVertexAttribL4ui64vNV(GLuint index, const GLuint64EXT *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribL4ui64vNV(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVERTEXATTRIBL4UI64VNV(index, v);
}

void OSMesaDriver::nfglVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
{
	D(bug("nfosmesa: glVertexAttribLFormat(%u, %d, %s, %u)", attribindex, size, gl_enum_name(type), relativeoffset));
	fn.glVertexAttribLFormat(attribindex, size, type, relativeoffset);
}

void OSMesaDriver::nfglVertexAttribLFormatNV(GLuint index, GLint size, GLenum type, GLsizei stride)
{
	D(bug("nfosmesa: glVertexAttribLFormatNV(%u, %d, %s, %d)", index, size, gl_enum_name(type), stride));
	fn.glVertexAttribLFormatNV(index, size, type, stride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
#endif
{
	D(bug("nfosmesa: glVertexAttribLPointer(%u, %d, %s, %d, " PRI_PTR ")", index, size, gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLVERTEXATTRIBLPOINTER(index, size, type, stride, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribLPointerEXT(GLuint index, GLint size, GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglVertexAttribLPointerEXT(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
#endif
{
	D(bug("nfosmesa: glVertexAttribLPointerEXT(%u, %d, %s, %d, " PRI_PTR ")", index, size, gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLVERTEXATTRIBLPOINTEREXT(index, size, type, stride, pointer);
}

void OSMesaDriver::nfglVertexAttribP1ui(GLuint index, GLenum type, GLboolean32 normalized, GLuint value)
{
	D(bug("nfosmesa: glVertexAttribP1ui(%u, %s, %d, %u)", index, gl_enum_name(type), normalized, value));
	fn.glVertexAttribP1ui(index, type, normalized, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribP1uiv(GLuint index, GLenum type, GLboolean32 normalized, memptr value)
#else
void OSMesaDriver::nfglVertexAttribP1uiv(GLuint index, GLenum type, GLboolean32 normalized, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glVertexAttribP1uiv(%u, %s, %d, " PRI_PTR ")", index, gl_enum_name(type), normalized, AtariOffset(value)));
FN_GLVERTEXATTRIBP1UIV(index, type, normalized, value);
}

void OSMesaDriver::nfglVertexAttribP2ui(GLuint index, GLenum type, GLboolean32 normalized, GLuint value)
{
	D(bug("nfosmesa: glVertexAttribP2ui(%u, %s, %d, %u)", index, gl_enum_name(type), normalized, value));
	fn.glVertexAttribP2ui(index, type, normalized, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribP2uiv(GLuint index, GLenum type, GLboolean32 normalized, memptr value)
#else
void OSMesaDriver::nfglVertexAttribP2uiv(GLuint index, GLenum type, GLboolean32 normalized, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glVertexAttribP2uiv(%u, %s, %d, " PRI_PTR ")", index, gl_enum_name(type), normalized, AtariOffset(value)));
FN_GLVERTEXATTRIBP2UIV(index, type, normalized, value);
}

void OSMesaDriver::nfglVertexAttribP3ui(GLuint index, GLenum type, GLboolean32 normalized, GLuint value)
{
	D(bug("nfosmesa: glVertexAttribP3ui(%u, %s, %d, %u)", index, gl_enum_name(type), normalized, value));
	fn.glVertexAttribP3ui(index, type, normalized, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribP3uiv(GLuint index, GLenum type, GLboolean32 normalized, memptr value)
#else
void OSMesaDriver::nfglVertexAttribP3uiv(GLuint index, GLenum type, GLboolean32 normalized, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glVertexAttribP3uiv(%u, %s, %d, " PRI_PTR ")", index, gl_enum_name(type), normalized, AtariOffset(value)));
FN_GLVERTEXATTRIBP3UIV(index, type, normalized, value);
}

void OSMesaDriver::nfglVertexAttribP4ui(GLuint index, GLenum type, GLboolean32 normalized, GLuint value)
{
	D(bug("nfosmesa: glVertexAttribP4ui(%u, %s, %d, %u)", index, gl_enum_name(type), normalized, value));
	fn.glVertexAttribP4ui(index, type, normalized, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribP4uiv(GLuint index, GLenum type, GLboolean32 normalized, memptr value)
#else
void OSMesaDriver::nfglVertexAttribP4uiv(GLuint index, GLenum type, GLboolean32 normalized, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glVertexAttribP4uiv(%u, %s, %d, " PRI_PTR ")", index, gl_enum_name(type), normalized, AtariOffset(value)));
FN_GLVERTEXATTRIBP4UIV(index, type, normalized, value);
}

void OSMesaDriver::nfglVertexAttribParameteriAMD(GLuint index, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glVertexAttribParameteriAMD(%u, %s, %d)", index, gl_enum_name(pname), param));
	fn.glVertexAttribParameteriAMD(index, pname, param);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean32 normalized, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean32 normalized, GLsizei stride, const void *pointer)
#endif
{
	D(bug("nfosmesa: glVertexAttribPointer(%u, %d, %s, %d, %d, " PRI_PTR ")", index, size, gl_enum_name(type), normalized, stride, AtariOffset(pointer)));
FN_GLVERTEXATTRIBPOINTER(index, size, type, normalized, stride, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean32 normalized, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglVertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean32 normalized, GLsizei stride, const void *pointer)
#endif
{
	D(bug("nfosmesa: glVertexAttribPointerARB(%u, %d, %s, %d, %d, " PRI_PTR ")", index, size, gl_enum_name(type), normalized, stride, AtariOffset(pointer)));
FN_GLVERTEXATTRIBPOINTERARB(index, size, type, normalized, stride, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglVertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, const void *pointer)
#endif
{
	D(bug("nfosmesa: glVertexAttribPointerNV(%u, %d, %s, %d, " PRI_PTR ")", index, fsize, gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLVERTEXATTRIBPOINTERNV(index, fsize, type, stride, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribs1dvNV(GLuint index, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglVertexAttribs1dvNV(GLuint index, GLsizei count, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribs1dvNV(%u, %d, " PRI_PTR ")", index, count, AtariOffset(v)));
FN_GLVERTEXATTRIBS1DVNV(index, count, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribs1fvNV(GLuint index, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglVertexAttribs1fvNV(GLuint index, GLsizei count, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribs1fvNV(%u, %d, " PRI_PTR ")", index, count, AtariOffset(v)));
FN_GLVERTEXATTRIBS1FVNV(index, count, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribs1hvNV(GLuint index, GLsizei n, memptr v)
#else
void OSMesaDriver::nfglVertexAttribs1hvNV(GLuint index, GLsizei n, const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribs1hvNV(%u, %d, " PRI_PTR ")", index, n, AtariOffset(v)));
FN_GLVERTEXATTRIBS1HVNV(index, n, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribs1svNV(GLuint index, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglVertexAttribs1svNV(GLuint index, GLsizei count, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribs1svNV(%u, %d, " PRI_PTR ")", index, count, AtariOffset(v)));
FN_GLVERTEXATTRIBS1SVNV(index, count, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribs2dvNV(GLuint index, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglVertexAttribs2dvNV(GLuint index, GLsizei count, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribs2dvNV(%u, %d, " PRI_PTR ")", index, count, AtariOffset(v)));
FN_GLVERTEXATTRIBS2DVNV(index, count, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribs2fvNV(GLuint index, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglVertexAttribs2fvNV(GLuint index, GLsizei count, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribs2fvNV(%u, %d, " PRI_PTR ")", index, count, AtariOffset(v)));
FN_GLVERTEXATTRIBS2FVNV(index, count, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribs2hvNV(GLuint index, GLsizei n, memptr v)
#else
void OSMesaDriver::nfglVertexAttribs2hvNV(GLuint index, GLsizei n, const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribs2hvNV(%u, %d, " PRI_PTR ")", index, n, AtariOffset(v)));
FN_GLVERTEXATTRIBS2HVNV(index, n, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribs2svNV(GLuint index, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglVertexAttribs2svNV(GLuint index, GLsizei count, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribs2svNV(%u, %d, " PRI_PTR ")", index, count, AtariOffset(v)));
FN_GLVERTEXATTRIBS2SVNV(index, count, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribs3dvNV(GLuint index, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglVertexAttribs3dvNV(GLuint index, GLsizei count, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribs3dvNV(%u, %d, " PRI_PTR ")", index, count, AtariOffset(v)));
FN_GLVERTEXATTRIBS3DVNV(index, count, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribs3fvNV(GLuint index, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglVertexAttribs3fvNV(GLuint index, GLsizei count, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribs3fvNV(%u, %d, " PRI_PTR ")", index, count, AtariOffset(v)));
FN_GLVERTEXATTRIBS3FVNV(index, count, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribs3hvNV(GLuint index, GLsizei n, memptr v)
#else
void OSMesaDriver::nfglVertexAttribs3hvNV(GLuint index, GLsizei n, const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribs3hvNV(%u, %d, " PRI_PTR ")", index, n, AtariOffset(v)));
FN_GLVERTEXATTRIBS3HVNV(index, n, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribs3svNV(GLuint index, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglVertexAttribs3svNV(GLuint index, GLsizei count, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribs3svNV(%u, %d, " PRI_PTR ")", index, count, AtariOffset(v)));
FN_GLVERTEXATTRIBS3SVNV(index, count, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribs4dvNV(GLuint index, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglVertexAttribs4dvNV(GLuint index, GLsizei count, const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribs4dvNV(%u, %d, " PRI_PTR ")", index, count, AtariOffset(v)));
FN_GLVERTEXATTRIBS4DVNV(index, count, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribs4fvNV(GLuint index, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglVertexAttribs4fvNV(GLuint index, GLsizei count, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribs4fvNV(%u, %d, " PRI_PTR ")", index, count, AtariOffset(v)));
FN_GLVERTEXATTRIBS4FVNV(index, count, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribs4hvNV(GLuint index, GLsizei n, memptr v)
#else
void OSMesaDriver::nfglVertexAttribs4hvNV(GLuint index, GLsizei n, const GLhalfNV *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribs4hvNV(%u, %d, " PRI_PTR ")", index, n, AtariOffset(v)));
FN_GLVERTEXATTRIBS4HVNV(index, n, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribs4svNV(GLuint index, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglVertexAttribs4svNV(GLuint index, GLsizei count, const GLshort *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribs4svNV(%u, %d, " PRI_PTR ")", index, count, AtariOffset(v)));
FN_GLVERTEXATTRIBS4SVNV(index, count, v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexAttribs4ubvNV(GLuint index, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglVertexAttribs4ubvNV(GLuint index, GLsizei count, const GLubyte *v)
#endif
{
	D(bug("nfosmesa: glVertexAttribs4ubvNV(%u, %d, " PRI_PTR ")", index, count, AtariOffset(v)));
FN_GLVERTEXATTRIBS4UBVNV(index, count, v);
}

void OSMesaDriver::nfglVertexBindingDivisor(GLuint bindingindex, GLuint divisor)
{
	D(bug("nfosmesa: glVertexBindingDivisor(%u, %u)", bindingindex, divisor));
	fn.glVertexBindingDivisor(bindingindex, divisor);
}

void OSMesaDriver::nfglVertexBlendARB(GLint count)
{
	D(bug("nfosmesa: glVertexBlendARB(%d)", count));
	fn.glVertexBlendARB(count);
}

void OSMesaDriver::nfglVertexBlendEnvfATI(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glVertexBlendEnvfATI(%s, %f)", gl_enum_name(pname), param));
	fn.glVertexBlendEnvfATI(pname, param);
}

void OSMesaDriver::nfglVertexBlendEnviATI(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glVertexBlendEnviATI(%s, %d)", gl_enum_name(pname), param));
	fn.glVertexBlendEnviATI(pname, param);
}

void OSMesaDriver::nfglVertexFormatNV(GLint size, GLenum type, GLsizei stride)
{
	D(bug("nfosmesa: glVertexFormatNV(%d, %s, %d)", size, gl_enum_name(type), stride));
	fn.glVertexFormatNV(size, type, stride);
}

void OSMesaDriver::nfglVertexP2ui(GLenum type, GLuint value)
{
	D(bug("nfosmesa: glVertexP2ui(%s, %u)", gl_enum_name(type), value));
	fn.glVertexP2ui(type, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexP2uiv(GLenum type, memptr value)
#else
void OSMesaDriver::nfglVertexP2uiv(GLenum type, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glVertexP2uiv(%s, " PRI_PTR ")", gl_enum_name(type), AtariOffset(value)));
FN_GLVERTEXP2UIV(type, value);
}

void OSMesaDriver::nfglVertexP3ui(GLenum type, GLuint value)
{
	D(bug("nfosmesa: glVertexP3ui(%s, %u)", gl_enum_name(type), value));
	fn.glVertexP3ui(type, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexP3uiv(GLenum type, memptr value)
#else
void OSMesaDriver::nfglVertexP3uiv(GLenum type, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glVertexP3uiv(%s, " PRI_PTR ")", gl_enum_name(type), AtariOffset(value)));
FN_GLVERTEXP3UIV(type, value);
}

void OSMesaDriver::nfglVertexP4ui(GLenum type, GLuint value)
{
	D(bug("nfosmesa: glVertexP4ui(%s, %u)", gl_enum_name(type), value));
	fn.glVertexP4ui(type, value);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexP4uiv(GLenum type, memptr value)
#else
void OSMesaDriver::nfglVertexP4uiv(GLenum type, const GLuint *value)
#endif
{
	D(bug("nfosmesa: glVertexP4uiv(%s, " PRI_PTR ")", gl_enum_name(type), AtariOffset(value)));
FN_GLVERTEXP4UIV(type, value);
}

void OSMesaDriver::nfglVertexPointSizefAPPLE(GLfloat size)
{
	D(bug("nfosmesa: glVertexPointSizefAPPLE(%f)", size));
	fn.glVertexPointSizefAPPLE(size);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexPointer(GLint size, GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
#endif
{
	D(bug("nfosmesa: glVertexPointer(%d, %s, %d, " PRI_PTR ")", size, gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLVERTEXPOINTER(size, type, stride, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, memptr pointer)
#else
void OSMesaDriver::nfglVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer)
#endif
{
	D(bug("nfosmesa: glVertexPointerEXT(%d, %s, %d, %d, " PRI_PTR ")", size, gl_enum_name(type), stride, count, AtariOffset(pointer)));
FN_GLVERTEXPOINTEREXT(size, type, stride, count, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexPointerListIBM(GLint size, GLenum type, GLint stride, memptr pointer, GLint ptrstride)
#else
void OSMesaDriver::nfglVertexPointerListIBM(GLint size, GLenum type, GLint stride, const void * *pointer, GLint ptrstride)
#endif
{
	D(bug("nfosmesa: glVertexPointerListIBM(%d, %s, %d, " PRI_PTR ", %d)", size, gl_enum_name(type), stride, AtariOffset(pointer), ptrstride));
FN_GLVERTEXPOINTERLISTIBM(size, type, stride, pointer, ptrstride);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexPointervINTEL(GLint size, GLenum type, memptr pointer)
#else
void OSMesaDriver::nfglVertexPointervINTEL(GLint size, GLenum type, const void * *pointer)
#endif
{
	D(bug("nfosmesa: glVertexPointervINTEL(%d, %s, " PRI_PTR ")", size, gl_enum_name(type), AtariOffset(pointer)));
FN_GLVERTEXPOINTERVINTEL(size, type, pointer);
}

void OSMesaDriver::nfglVertexStream1dATI(GLenum stream, GLdouble x)
{
	D(bug("nfosmesa: glVertexStream1dATI(%s, %f)", gl_enum_name(stream), x));
	fn.glVertexStream1dATI(stream, x);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexStream1dvATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglVertexStream1dvATI(GLenum stream, const GLdouble *coords)
#endif
{
	D(bug("nfosmesa: glVertexStream1dvATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLVERTEXSTREAM1DVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream1fATI(GLenum stream, GLfloat x)
{
	D(bug("nfosmesa: glVertexStream1fATI(%s, %f)", gl_enum_name(stream), x));
	fn.glVertexStream1fATI(stream, x);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexStream1fvATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglVertexStream1fvATI(GLenum stream, const GLfloat *coords)
#endif
{
	D(bug("nfosmesa: glVertexStream1fvATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLVERTEXSTREAM1FVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream1iATI(GLenum stream, GLint x)
{
	D(bug("nfosmesa: glVertexStream1iATI(%s, %d)", gl_enum_name(stream), x));
	fn.glVertexStream1iATI(stream, x);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexStream1ivATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglVertexStream1ivATI(GLenum stream, const GLint *coords)
#endif
{
	D(bug("nfosmesa: glVertexStream1ivATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLVERTEXSTREAM1IVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream1sATI(GLenum stream, GLshort32 x)
{
	D(bug("nfosmesa: glVertexStream1sATI(%s, %d)", gl_enum_name(stream), x));
	fn.glVertexStream1sATI(stream, x);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexStream1svATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglVertexStream1svATI(GLenum stream, const GLshort *coords)
#endif
{
	D(bug("nfosmesa: glVertexStream1svATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLVERTEXSTREAM1SVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream2dATI(GLenum stream, GLdouble x, GLdouble y)
{
	D(bug("nfosmesa: glVertexStream2dATI(%s, %f, %f)", gl_enum_name(stream), x, y));
	fn.glVertexStream2dATI(stream, x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexStream2dvATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglVertexStream2dvATI(GLenum stream, const GLdouble *coords)
#endif
{
	D(bug("nfosmesa: glVertexStream2dvATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLVERTEXSTREAM2DVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream2fATI(GLenum stream, GLfloat x, GLfloat y)
{
	D(bug("nfosmesa: glVertexStream2fATI(%s, %f, %f)", gl_enum_name(stream), x, y));
	fn.glVertexStream2fATI(stream, x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexStream2fvATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglVertexStream2fvATI(GLenum stream, const GLfloat *coords)
#endif
{
	D(bug("nfosmesa: glVertexStream2fvATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLVERTEXSTREAM2FVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream2iATI(GLenum stream, GLint x, GLint y)
{
	D(bug("nfosmesa: glVertexStream2iATI(%s, %d, %d)", gl_enum_name(stream), x, y));
	fn.glVertexStream2iATI(stream, x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexStream2ivATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglVertexStream2ivATI(GLenum stream, const GLint *coords)
#endif
{
	D(bug("nfosmesa: glVertexStream2ivATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLVERTEXSTREAM2IVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream2sATI(GLenum stream, GLshort32 x, GLshort32 y)
{
	D(bug("nfosmesa: glVertexStream2sATI(%s, %d, %d)", gl_enum_name(stream), x, y));
	fn.glVertexStream2sATI(stream, x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexStream2svATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglVertexStream2svATI(GLenum stream, const GLshort *coords)
#endif
{
	D(bug("nfosmesa: glVertexStream2svATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLVERTEXSTREAM2SVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream3dATI(GLenum stream, GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glVertexStream3dATI(%s, %f, %f, %f)", gl_enum_name(stream), x, y, z));
	fn.glVertexStream3dATI(stream, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexStream3dvATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglVertexStream3dvATI(GLenum stream, const GLdouble *coords)
#endif
{
	D(bug("nfosmesa: glVertexStream3dvATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLVERTEXSTREAM3DVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream3fATI(GLenum stream, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glVertexStream3fATI(%s, %f, %f, %f)", gl_enum_name(stream), x, y, z));
	fn.glVertexStream3fATI(stream, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexStream3fvATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglVertexStream3fvATI(GLenum stream, const GLfloat *coords)
#endif
{
	D(bug("nfosmesa: glVertexStream3fvATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLVERTEXSTREAM3FVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream3iATI(GLenum stream, GLint x, GLint y, GLint z)
{
	D(bug("nfosmesa: glVertexStream3iATI(%s, %d, %d, %d)", gl_enum_name(stream), x, y, z));
	fn.glVertexStream3iATI(stream, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexStream3ivATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglVertexStream3ivATI(GLenum stream, const GLint *coords)
#endif
{
	D(bug("nfosmesa: glVertexStream3ivATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLVERTEXSTREAM3IVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream3sATI(GLenum stream, GLshort32 x, GLshort32 y, GLshort32 z)
{
	D(bug("nfosmesa: glVertexStream3sATI(%s, %d, %d, %d)", gl_enum_name(stream), x, y, z));
	fn.glVertexStream3sATI(stream, x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexStream3svATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglVertexStream3svATI(GLenum stream, const GLshort *coords)
#endif
{
	D(bug("nfosmesa: glVertexStream3svATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLVERTEXSTREAM3SVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream4dATI(GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	D(bug("nfosmesa: glVertexStream4dATI(%s, %f, %f, %f, %f)", gl_enum_name(stream), x, y, z, w));
	fn.glVertexStream4dATI(stream, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexStream4dvATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglVertexStream4dvATI(GLenum stream, const GLdouble *coords)
#endif
{
	D(bug("nfosmesa: glVertexStream4dvATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLVERTEXSTREAM4DVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream4fATI(GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	D(bug("nfosmesa: glVertexStream4fATI(%s, %f, %f, %f, %f)", gl_enum_name(stream), x, y, z, w));
	fn.glVertexStream4fATI(stream, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexStream4fvATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglVertexStream4fvATI(GLenum stream, const GLfloat *coords)
#endif
{
	D(bug("nfosmesa: glVertexStream4fvATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLVERTEXSTREAM4FVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream4iATI(GLenum stream, GLint x, GLint y, GLint z, GLint w)
{
	D(bug("nfosmesa: glVertexStream4iATI(%s, %d, %d, %d, %d)", gl_enum_name(stream), x, y, z, w));
	fn.glVertexStream4iATI(stream, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexStream4ivATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglVertexStream4ivATI(GLenum stream, const GLint *coords)
#endif
{
	D(bug("nfosmesa: glVertexStream4ivATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLVERTEXSTREAM4IVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream4sATI(GLenum stream, GLshort32 x, GLshort32 y, GLshort32 z, GLshort32 w)
{
	D(bug("nfosmesa: glVertexStream4sATI(%s, %d, %d, %d, %d)", gl_enum_name(stream), x, y, z, w));
	fn.glVertexStream4sATI(stream, x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexStream4svATI(GLenum stream, memptr coords)
#else
void OSMesaDriver::nfglVertexStream4svATI(GLenum stream, const GLshort *coords)
#endif
{
	D(bug("nfosmesa: glVertexStream4svATI(%s, " PRI_PTR ")", gl_enum_name(stream), AtariOffset(coords)));
FN_GLVERTEXSTREAM4SVATI(stream, coords);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexWeightPointerEXT(GLint size, GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglVertexWeightPointerEXT(GLint size, GLenum type, GLsizei stride, const void *pointer)
#endif
{
	D(bug("nfosmesa: glVertexWeightPointerEXT(%d, %s, %d, " PRI_PTR ")", size, gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLVERTEXWEIGHTPOINTEREXT(size, type, stride, pointer);
}

void OSMesaDriver::nfglVertexWeightfEXT(GLfloat weight)
{
	D(bug("nfosmesa: glVertexWeightfEXT(%f)", weight));
	fn.glVertexWeightfEXT(weight);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexWeightfvEXT(memptr weight)
#else
void OSMesaDriver::nfglVertexWeightfvEXT(const GLfloat *weight)
#endif
{
	D(bug("nfosmesa: glVertexWeightfvEXT(" PRI_PTR ")", AtariOffset(weight)));
FN_GLVERTEXWEIGHTFVEXT(weight);
}

void OSMesaDriver::nfglVertexWeighthNV(GLhalfNV32 weight)
{
	D(bug("nfosmesa: glVertexWeighthNV(%u)", weight));
	fn.glVertexWeighthNV(weight);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVertexWeighthvNV(memptr weight)
#else
void OSMesaDriver::nfglVertexWeighthvNV(const GLhalfNV *weight)
#endif
{
	D(bug("nfosmesa: glVertexWeighthvNV(" PRI_PTR ")", AtariOffset(weight)));
FN_GLVERTEXWEIGHTHVNV(weight);
}

#if NFOSMESA_POINTER_AS_MEMARG
GLenum OSMesaDriver::nfglVideoCaptureNV(GLuint video_capture_slot, memptr sequence_num, memptr capture_time)
#else
GLenum OSMesaDriver::nfglVideoCaptureNV(GLuint video_capture_slot, GLuint *sequence_num, GLuint64EXT *capture_time)
#endif
{
	D(bug("nfosmesa: glVideoCaptureNV(%u, " PRI_PTR ", " PRI_PTR ")", video_capture_slot, AtariOffset(sequence_num), AtariOffset(capture_time)));
FN_GLVIDEOCAPTURENV(video_capture_slot, sequence_num, capture_time);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVideoCaptureStreamParameterdvNV(GLuint video_capture_slot, GLuint stream, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglVideoCaptureStreamParameterdvNV(GLuint video_capture_slot, GLuint stream, GLenum pname, const GLdouble *params)
#endif
{
	D(bug("nfosmesa: glVideoCaptureStreamParameterdvNV(%u, %u, %s, " PRI_PTR ")", video_capture_slot, stream, gl_enum_name(pname), AtariOffset(params)));
FN_GLVIDEOCAPTURESTREAMPARAMETERDVNV(video_capture_slot, stream, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVideoCaptureStreamParameterfvNV(GLuint video_capture_slot, GLuint stream, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglVideoCaptureStreamParameterfvNV(GLuint video_capture_slot, GLuint stream, GLenum pname, const GLfloat *params)
#endif
{
	D(bug("nfosmesa: glVideoCaptureStreamParameterfvNV(%u, %u, %s, " PRI_PTR ")", video_capture_slot, stream, gl_enum_name(pname), AtariOffset(params)));
FN_GLVIDEOCAPTURESTREAMPARAMETERFVNV(video_capture_slot, stream, pname, params);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglVideoCaptureStreamParameterivNV(GLuint video_capture_slot, GLuint stream, GLenum pname, memptr params)
#else
void OSMesaDriver::nfglVideoCaptureStreamParameterivNV(GLuint video_capture_slot, GLuint stream, GLenum pname, const GLint *params)
#endif
{
	D(bug("nfosmesa: glVideoCaptureStreamParameterivNV(%u, %u, %s, " PRI_PTR ")", video_capture_slot, stream, gl_enum_name(pname), AtariOffset(params)));
FN_GLVIDEOCAPTURESTREAMPARAMETERIVNV(video_capture_slot, stream, pname, params);
}

void OSMesaDriver::nfglViewport(GLint x, GLint y, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glViewport(%d, %d, %d, %d)", x, y, width, height));
	fn.glViewport(x, y, width, height);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglViewportArrayv(GLuint first, GLsizei count, memptr v)
#else
void OSMesaDriver::nfglViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glViewportArrayv(%u, %d, " PRI_PTR ")", first, count, AtariOffset(v)));
FN_GLVIEWPORTARRAYV(first, count, v);
}

void OSMesaDriver::nfglViewportIndexedf(GLuint index, GLfloat x, GLfloat y, GLfloat w, GLfloat h)
{
	D(bug("nfosmesa: glViewportIndexedf(%u, %f, %f, %f, %f)", index, x, y, w, h));
	fn.glViewportIndexedf(index, x, y, w, h);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglViewportIndexedfv(GLuint index, memptr v)
#else
void OSMesaDriver::nfglViewportIndexedfv(GLuint index, const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glViewportIndexedfv(%u, " PRI_PTR ")", index, AtariOffset(v)));
FN_GLVIEWPORTINDEXEDFV(index, v);
}

void OSMesaDriver::nfglViewportPositionWScaleNV(GLuint index, GLfloat xcoeff, GLfloat ycoeff)
{
	D(bug("nfosmesa: glViewportPositionWScaleNV(%u, %f, %f)", index, xcoeff, ycoeff));
	fn.glViewportPositionWScaleNV(index, xcoeff, ycoeff);
}

void OSMesaDriver::nfglViewportSwizzleNV(GLuint index, GLenum swizzlex, GLenum swizzley, GLenum swizzlez, GLenum swizzlew)
{
	D(bug("nfosmesa: glViewportSwizzleNV(%u, %s, %s, %s, %s)", index, gl_enum_name(swizzlex), gl_enum_name(swizzley), gl_enum_name(swizzlez), gl_enum_name(swizzlew)));
	fn.glViewportSwizzleNV(index, swizzlex, swizzley, swizzlez, swizzlew);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWaitSemaphoreEXT(GLuint semaphore, GLuint numBufferBarriers, memptr buffers, GLuint numTextureBarriers, memptr textures, memptr srcLayouts)
#else
void OSMesaDriver::nfglWaitSemaphoreEXT(GLuint semaphore, GLuint numBufferBarriers, const GLuint *buffers, GLuint numTextureBarriers, const GLuint *textures, const GLenum *srcLayouts)
#endif
{
	D(bug("nfosmesa: glWaitSemaphoreEXT(%u, %u, " PRI_PTR ", %u, " PRI_PTR ", " PRI_PTR ")", semaphore, numBufferBarriers, AtariOffset(buffers), numTextureBarriers, AtariOffset(textures), AtariOffset(srcLayouts)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __buffers_size = MAX(numBufferBarriers, 0);
	GLuint __buffers_tmp[__buffers_size];
	GLuint *__buffers_ptmp = Atari2HostIntArray(__buffers_size, buffers, __buffers_tmp);
	GLint const __textures_size = MAX(numTextureBarriers, 0);
	GLuint __textures_tmp[__textures_size];
	GLuint *__textures_ptmp = Atari2HostIntArray(__textures_size, textures, __textures_tmp);
	GLint const __srcLayouts_size = MAX(numTextureBarriers, 0);
	GLenum __srcLayouts_tmp[__srcLayouts_size];
	GLenum *__srcLayouts_ptmp = Atari2HostIntArray(__srcLayouts_size, srcLayouts, __srcLayouts_tmp);
	fn.glWaitSemaphoreEXT(semaphore, numBufferBarriers, __buffers_ptmp, numTextureBarriers, __textures_ptmp, __srcLayouts_ptmp);
#else
	fn.glWaitSemaphoreEXT(semaphore, numBufferBarriers, HostAddr(buffers, const GLuint *), numTextureBarriers, HostAddr(textures, const GLuint *), HostAddr(srcLayouts, const GLenum *));
#endif
}

void OSMesaDriver::nfglWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
{
	D(bug("nfosmesa: glWaitSync(" PRI_PTR ", 0x%x, %" PRIu64 ")", (unsigned int)(uintptr_t)sync, flags, timeout));
	fn.glWaitSync(sync, flags, timeout);
}

void OSMesaDriver::nfglWaitVkSemaphoreNV(GLuint64 vkSemaphore)
{
	D(bug("nfosmesa: glWaitVkSemaphoreNV(%" PRIu64 ")", vkSemaphore));
	fn.glWaitVkSemaphoreNV(vkSemaphore);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWeightPathsNV(GLuint resultPath, GLsizei numPaths, memptr paths, memptr weights)
#else
void OSMesaDriver::nfglWeightPathsNV(GLuint resultPath, GLsizei numPaths, const GLuint *paths, const GLfloat *weights)
#endif
{
	D(bug("nfosmesa: glWeightPathsNV(%u, %d, " PRI_PTR ", " PRI_PTR ")", resultPath, numPaths, AtariOffset(paths), AtariOffset(weights)));
FN_GLWEIGHTPATHSNV(resultPath, numPaths, paths, weights);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWeightPointerARB(GLint size, GLenum type, GLsizei stride, memptr pointer)
#else
void OSMesaDriver::nfglWeightPointerARB(GLint size, GLenum type, GLsizei stride, const void *pointer)
#endif
{
	D(bug("nfosmesa: glWeightPointerARB(%d, %s, %d, " PRI_PTR ")", size, gl_enum_name(type), stride, AtariOffset(pointer)));
FN_GLWEIGHTPOINTERARB(size, type, stride, pointer);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWeightbvARB(GLint size, memptr weights)
#else
void OSMesaDriver::nfglWeightbvARB(GLint size, const GLbyte *weights)
#endif
{
	D(bug("nfosmesa: glWeightbvARB(%d, " PRI_PTR ")", size, AtariOffset(weights)));
FN_GLWEIGHTBVARB(size, weights);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWeightdvARB(GLint size, memptr weights)
#else
void OSMesaDriver::nfglWeightdvARB(GLint size, const GLdouble *weights)
#endif
{
	D(bug("nfosmesa: glWeightdvARB(%d, " PRI_PTR ")", size, AtariOffset(weights)));
FN_GLWEIGHTDVARB(size, weights);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWeightfvARB(GLint size, memptr weights)
#else
void OSMesaDriver::nfglWeightfvARB(GLint size, const GLfloat *weights)
#endif
{
	D(bug("nfosmesa: glWeightfvARB(%d, " PRI_PTR ")", size, AtariOffset(weights)));
FN_GLWEIGHTFVARB(size, weights);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWeightivARB(GLint size, memptr weights)
#else
void OSMesaDriver::nfglWeightivARB(GLint size, const GLint *weights)
#endif
{
	D(bug("nfosmesa: glWeightivARB(%d, " PRI_PTR ")", size, AtariOffset(weights)));
FN_GLWEIGHTIVARB(size, weights);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWeightsvARB(GLint size, memptr weights)
#else
void OSMesaDriver::nfglWeightsvARB(GLint size, const GLshort *weights)
#endif
{
	D(bug("nfosmesa: glWeightsvARB(%d, " PRI_PTR ")", size, AtariOffset(weights)));
FN_GLWEIGHTSVARB(size, weights);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWeightubvARB(GLint size, memptr weights)
#else
void OSMesaDriver::nfglWeightubvARB(GLint size, const GLubyte *weights)
#endif
{
	D(bug("nfosmesa: glWeightubvARB(%d, " PRI_PTR ")", size, AtariOffset(weights)));
FN_GLWEIGHTUBVARB(size, weights);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWeightuivARB(GLint size, memptr weights)
#else
void OSMesaDriver::nfglWeightuivARB(GLint size, const GLuint *weights)
#endif
{
	D(bug("nfosmesa: glWeightuivARB(%d, " PRI_PTR ")", size, AtariOffset(weights)));
FN_GLWEIGHTUIVARB(size, weights);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWeightusvARB(GLint size, memptr weights)
#else
void OSMesaDriver::nfglWeightusvARB(GLint size, const GLushort *weights)
#endif
{
	D(bug("nfosmesa: glWeightusvARB(%d, " PRI_PTR ")", size, AtariOffset(weights)));
FN_GLWEIGHTUSVARB(size, weights);
}

void OSMesaDriver::nfglWindowPos2d(GLdouble x, GLdouble y)
{
	D(bug("nfosmesa: glWindowPos2d(%f, %f)", x, y));
	fn.glWindowPos2d(x, y);
}

void OSMesaDriver::nfglWindowPos2dARB(GLdouble x, GLdouble y)
{
	D(bug("nfosmesa: glWindowPos2dARB(%f, %f)", x, y));
	fn.glWindowPos2dARB(x, y);
}

void OSMesaDriver::nfglWindowPos2dMESA(GLdouble x, GLdouble y)
{
	D(bug("nfosmesa: glWindowPos2dMESA(%f, %f)", x, y));
	fn.glWindowPos2dMESA(x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos2dv(memptr v)
#else
void OSMesaDriver::nfglWindowPos2dv(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glWindowPos2dv(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS2DV(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos2dvARB(memptr v)
#else
void OSMesaDriver::nfglWindowPos2dvARB(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glWindowPos2dvARB(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS2DVARB(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos2dvMESA(memptr v)
#else
void OSMesaDriver::nfglWindowPos2dvMESA(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glWindowPos2dvMESA(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS2DVMESA(v);
}

void OSMesaDriver::nfglWindowPos2f(GLfloat x, GLfloat y)
{
	D(bug("nfosmesa: glWindowPos2f(%f, %f)", x, y));
	fn.glWindowPos2f(x, y);
}

void OSMesaDriver::nfglWindowPos2fARB(GLfloat x, GLfloat y)
{
	D(bug("nfosmesa: glWindowPos2fARB(%f, %f)", x, y));
	fn.glWindowPos2fARB(x, y);
}

void OSMesaDriver::nfglWindowPos2fMESA(GLfloat x, GLfloat y)
{
	D(bug("nfosmesa: glWindowPos2fMESA(%f, %f)", x, y));
	fn.glWindowPos2fMESA(x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos2fv(memptr v)
#else
void OSMesaDriver::nfglWindowPos2fv(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glWindowPos2fv(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS2FV(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos2fvARB(memptr v)
#else
void OSMesaDriver::nfglWindowPos2fvARB(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glWindowPos2fvARB(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS2FVARB(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos2fvMESA(memptr v)
#else
void OSMesaDriver::nfglWindowPos2fvMESA(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glWindowPos2fvMESA(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS2FVMESA(v);
}

void OSMesaDriver::nfglWindowPos2i(GLint x, GLint y)
{
	D(bug("nfosmesa: glWindowPos2i(%d, %d)", x, y));
	fn.glWindowPos2i(x, y);
}

void OSMesaDriver::nfglWindowPos2iARB(GLint x, GLint y)
{
	D(bug("nfosmesa: glWindowPos2iARB(%d, %d)", x, y));
	fn.glWindowPos2iARB(x, y);
}

void OSMesaDriver::nfglWindowPos2iMESA(GLint x, GLint y)
{
	D(bug("nfosmesa: glWindowPos2iMESA(%d, %d)", x, y));
	fn.glWindowPos2iMESA(x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos2iv(memptr v)
#else
void OSMesaDriver::nfglWindowPos2iv(const GLint *v)
#endif
{
	D(bug("nfosmesa: glWindowPos2iv(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS2IV(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos2ivARB(memptr v)
#else
void OSMesaDriver::nfglWindowPos2ivARB(const GLint *v)
#endif
{
	D(bug("nfosmesa: glWindowPos2ivARB(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS2IVARB(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos2ivMESA(memptr v)
#else
void OSMesaDriver::nfglWindowPos2ivMESA(const GLint *v)
#endif
{
	D(bug("nfosmesa: glWindowPos2ivMESA(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS2IVMESA(v);
}

void OSMesaDriver::nfglWindowPos2s(GLshort32 x, GLshort32 y)
{
	D(bug("nfosmesa: glWindowPos2s(%d, %d)", x, y));
	fn.glWindowPos2s(x, y);
}

void OSMesaDriver::nfglWindowPos2sARB(GLshort32 x, GLshort32 y)
{
	D(bug("nfosmesa: glWindowPos2sARB(%d, %d)", x, y));
	fn.glWindowPos2sARB(x, y);
}

void OSMesaDriver::nfglWindowPos2sMESA(GLshort32 x, GLshort32 y)
{
	D(bug("nfosmesa: glWindowPos2sMESA(%d, %d)", x, y));
	fn.glWindowPos2sMESA(x, y);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos2sv(memptr v)
#else
void OSMesaDriver::nfglWindowPos2sv(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glWindowPos2sv(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS2SV(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos2svARB(memptr v)
#else
void OSMesaDriver::nfglWindowPos2svARB(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glWindowPos2svARB(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS2SVARB(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos2svMESA(memptr v)
#else
void OSMesaDriver::nfglWindowPos2svMESA(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glWindowPos2svMESA(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS2SVMESA(v);
}

void OSMesaDriver::nfglWindowPos3d(GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glWindowPos3d(%f, %f, %f)", x, y, z));
	fn.glWindowPos3d(x, y, z);
}

void OSMesaDriver::nfglWindowPos3dARB(GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glWindowPos3dARB(%f, %f, %f)", x, y, z));
	fn.glWindowPos3dARB(x, y, z);
}

void OSMesaDriver::nfglWindowPos3dMESA(GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glWindowPos3dMESA(%f, %f, %f)", x, y, z));
	fn.glWindowPos3dMESA(x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos3dv(memptr v)
#else
void OSMesaDriver::nfglWindowPos3dv(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glWindowPos3dv(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS3DV(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos3dvARB(memptr v)
#else
void OSMesaDriver::nfglWindowPos3dvARB(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glWindowPos3dvARB(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS3DVARB(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos3dvMESA(memptr v)
#else
void OSMesaDriver::nfglWindowPos3dvMESA(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glWindowPos3dvMESA(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS3DVMESA(v);
}

void OSMesaDriver::nfglWindowPos3f(GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glWindowPos3f(%f, %f, %f)", x, y, z));
	fn.glWindowPos3f(x, y, z);
}

void OSMesaDriver::nfglWindowPos3fARB(GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glWindowPos3fARB(%f, %f, %f)", x, y, z));
	fn.glWindowPos3fARB(x, y, z);
}

void OSMesaDriver::nfglWindowPos3fMESA(GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glWindowPos3fMESA(%f, %f, %f)", x, y, z));
	fn.glWindowPos3fMESA(x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos3fv(memptr v)
#else
void OSMesaDriver::nfglWindowPos3fv(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glWindowPos3fv(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS3FV(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos3fvARB(memptr v)
#else
void OSMesaDriver::nfglWindowPos3fvARB(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glWindowPos3fvARB(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS3FVARB(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos3fvMESA(memptr v)
#else
void OSMesaDriver::nfglWindowPos3fvMESA(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glWindowPos3fvMESA(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS3FVMESA(v);
}

void OSMesaDriver::nfglWindowPos3i(GLint x, GLint y, GLint z)
{
	D(bug("nfosmesa: glWindowPos3i(%d, %d, %d)", x, y, z));
	fn.glWindowPos3i(x, y, z);
}

void OSMesaDriver::nfglWindowPos3iARB(GLint x, GLint y, GLint z)
{
	D(bug("nfosmesa: glWindowPos3iARB(%d, %d, %d)", x, y, z));
	fn.glWindowPos3iARB(x, y, z);
}

void OSMesaDriver::nfglWindowPos3iMESA(GLint x, GLint y, GLint z)
{
	D(bug("nfosmesa: glWindowPos3iMESA(%d, %d, %d)", x, y, z));
	fn.glWindowPos3iMESA(x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos3iv(memptr v)
#else
void OSMesaDriver::nfglWindowPos3iv(const GLint *v)
#endif
{
	D(bug("nfosmesa: glWindowPos3iv(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS3IV(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos3ivARB(memptr v)
#else
void OSMesaDriver::nfglWindowPos3ivARB(const GLint *v)
#endif
{
	D(bug("nfosmesa: glWindowPos3ivARB(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS3IVARB(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos3ivMESA(memptr v)
#else
void OSMesaDriver::nfglWindowPos3ivMESA(const GLint *v)
#endif
{
	D(bug("nfosmesa: glWindowPos3ivMESA(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS3IVMESA(v);
}

void OSMesaDriver::nfglWindowPos3s(GLshort32 x, GLshort32 y, GLshort32 z)
{
	D(bug("nfosmesa: glWindowPos3s(%d, %d, %d)", x, y, z));
	fn.glWindowPos3s(x, y, z);
}

void OSMesaDriver::nfglWindowPos3sARB(GLshort32 x, GLshort32 y, GLshort32 z)
{
	D(bug("nfosmesa: glWindowPos3sARB(%d, %d, %d)", x, y, z));
	fn.glWindowPos3sARB(x, y, z);
}

void OSMesaDriver::nfglWindowPos3sMESA(GLshort32 x, GLshort32 y, GLshort32 z)
{
	D(bug("nfosmesa: glWindowPos3sMESA(%d, %d, %d)", x, y, z));
	fn.glWindowPos3sMESA(x, y, z);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos3sv(memptr v)
#else
void OSMesaDriver::nfglWindowPos3sv(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glWindowPos3sv(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS3SV(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos3svARB(memptr v)
#else
void OSMesaDriver::nfglWindowPos3svARB(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glWindowPos3svARB(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS3SVARB(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos3svMESA(memptr v)
#else
void OSMesaDriver::nfglWindowPos3svMESA(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glWindowPos3svMESA(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS3SVMESA(v);
}

void OSMesaDriver::nfglWindowPos4dMESA(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	D(bug("nfosmesa: glWindowPos4dMESA(%f, %f, %f, %f)", x, y, z, w));
	fn.glWindowPos4dMESA(x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos4dvMESA(memptr v)
#else
void OSMesaDriver::nfglWindowPos4dvMESA(const GLdouble *v)
#endif
{
	D(bug("nfosmesa: glWindowPos4dvMESA(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS4DVMESA(v);
}

void OSMesaDriver::nfglWindowPos4fMESA(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	D(bug("nfosmesa: glWindowPos4fMESA(%f, %f, %f, %f)", x, y, z, w));
	fn.glWindowPos4fMESA(x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos4fvMESA(memptr v)
#else
void OSMesaDriver::nfglWindowPos4fvMESA(const GLfloat *v)
#endif
{
	D(bug("nfosmesa: glWindowPos4fvMESA(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS4FVMESA(v);
}

void OSMesaDriver::nfglWindowPos4iMESA(GLint x, GLint y, GLint z, GLint w)
{
	D(bug("nfosmesa: glWindowPos4iMESA(%d, %d, %d, %d)", x, y, z, w));
	fn.glWindowPos4iMESA(x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos4ivMESA(memptr v)
#else
void OSMesaDriver::nfglWindowPos4ivMESA(const GLint *v)
#endif
{
	D(bug("nfosmesa: glWindowPos4ivMESA(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS4IVMESA(v);
}

void OSMesaDriver::nfglWindowPos4sMESA(GLshort32 x, GLshort32 y, GLshort32 z, GLshort32 w)
{
	D(bug("nfosmesa: glWindowPos4sMESA(%d, %d, %d, %d)", x, y, z, w));
	fn.glWindowPos4sMESA(x, y, z, w);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowPos4svMESA(memptr v)
#else
void OSMesaDriver::nfglWindowPos4svMESA(const GLshort *v)
#endif
{
	D(bug("nfosmesa: glWindowPos4svMESA(" PRI_PTR ")", AtariOffset(v)));
FN_GLWINDOWPOS4SVMESA(v);
}

#if NFOSMESA_POINTER_AS_MEMARG
void OSMesaDriver::nfglWindowRectanglesEXT(GLenum mode, GLsizei count, memptr box)
#else
void OSMesaDriver::nfglWindowRectanglesEXT(GLenum mode, GLsizei count, const GLint *box)
#endif
{
	D(bug("nfosmesa: glWindowRectanglesEXT(%s, %d, " PRI_PTR ")", gl_enum_name(mode), count, AtariOffset(box)));
#if NFOSMESA_NEED_INT_CONV
	GLint const __box_size = MAX(4 * count, 0);
	GLint __box_tmp[__box_size];
	GLint *__box_ptmp = Atari2HostIntArray(__box_size, box, __box_tmp);
	fn.glWindowRectanglesEXT(mode, count, __box_ptmp);
#else
	fn.glWindowRectanglesEXT(mode, count, HostAddr(box, const GLint *));
#endif
}

void OSMesaDriver::nfglWriteMaskEXT(GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW)
{
	D(bug("nfosmesa: glWriteMaskEXT(%u, %u, %s, %s, %s, %s)", res, in, gl_enum_name(outX), gl_enum_name(outY), gl_enum_name(outZ), gl_enum_name(outW)));
	fn.glWriteMaskEXT(res, in, outX, outY, outZ, outW);
}

#if 0
void OSMesaDriver::nfgluLookAt(GLdouble eyeX, GLdouble eyeY, GLdouble eyeZ, GLdouble centerX, GLdouble centerY, GLdouble centerZ, GLdouble upX, GLdouble upY, GLdouble upZ)
{
	D(bug("nfosmesa: gluLookAt(%f, %f, %f, %f, %f, %f, %f, %f, %f)", eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ));
	fn.gluLookAt(eyeX, eyeY, eyeZ, centerX, centerY, centerZ, upX, upY, upZ);
}
#endif


/* Functions generated: 2954 GL + 1 GLU */
/* Automatically generated: 130 */
