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

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

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

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(0x%x)", face));
	fn.glActiveStencilFaceEXT(face);
}

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

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

void OSMesaDriver::nfglActiveVaryingNV(GLuint program, const GLchar *name)
{
	D(bug("nfosmesa: glActiveVaryingNV(%u, %p)", program, name));
	/* TODO: NFOSMESA_GLACTIVEVARYINGNV may need conversion */
	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(0x%x, %u, %u, %u, %u, %u)", 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(0x%x, %u, %u, %u, %u, %u, %u, %u, %u)", 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(0x%x, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u)", 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(0x%x, %f)", func, ref));
	fn.glAlphaFunc(func, ref);
}

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

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

GLboolean OSMesaDriver::nfglAreProgramsResidentNV(GLsizei n, const GLuint *programs, GLboolean *residences)
{
	D(bug("nfosmesa: glAreProgramsResidentNV(%d, %p, %p)", n, programs, residences));
	/* TODO: NFOSMESA_GLAREPROGRAMSRESIDENTNV may need conversion */
	return fn.glAreProgramsResidentNV(n, programs, residences);
}

GLboolean OSMesaDriver::nfglAreTexturesResident(GLsizei n, const GLuint *textures, GLboolean *residences)
{
	D(bug("nfosmesa: glAreTexturesResident(%d, %p, %p)", n, textures, residences));
FN_GLARETEXTURESRESIDENT(n, textures, residences);
}

GLboolean OSMesaDriver::nfglAreTexturesResidentEXT(GLsizei n, const GLuint *textures, GLboolean *residences)
{
	D(bug("nfosmesa: glAreTexturesResidentEXT(%d, %p, %p)", n, textures, 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(0x%x, %d, 0x%x, %d, %u, %u)", array, size, 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)", containerObj, 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(0x%x)", mode));
	fn.glBegin(mode);
}

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

void OSMesaDriver::nfglBeginConditionalRenderNV(GLuint id, GLenum mode)
{
	D(bug("nfosmesa: glBeginConditionalRenderNV(%u, 0x%x)", id, 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(0x%x, %u)", target, id));
	fn.glBeginQuery(target, id);
}

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

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

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

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

void OSMesaDriver::nfglBeginTransformFeedbackNV(GLenum primitiveMode)
{
	D(bug("nfosmesa: glBeginTransformFeedbackNV(0x%x)", 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);
}

void OSMesaDriver::nfglBindAttribLocation(GLuint program, GLuint index, const GLchar *name)
{
	D(bug("nfosmesa: glBindAttribLocation(%u, %u, %p)", program, index, name));
	/* TODO: NFOSMESA_GLBINDATTRIBLOCATION may need conversion */
	fn.glBindAttribLocation(program, index, name);
}

void OSMesaDriver::nfglBindAttribLocationARB(GLhandleARB programObj, GLuint index, const GLcharARB *name)
{
	D(bug("nfosmesa: glBindAttribLocationARB(%u, %u, %p)", programObj, index, name));
	/* TODO: NFOSMESA_GLBINDATTRIBLOCATIONARB may need conversion */
	fn.glBindAttribLocationARB(programObj, index, name);
}

void OSMesaDriver::nfglBindBuffer(GLenum target, GLuint buffer)
{
	D(bug("nfosmesa: glBindBuffer(0x%x, %u)", target, buffer));
	fn.glBindBuffer(target, buffer);
}

void OSMesaDriver::nfglBindBufferARB(GLenum target, GLuint buffer)
{
	D(bug("nfosmesa: glBindBufferARB(0x%x, %u)", target, buffer));
	fn.glBindBufferARB(target, buffer);
}

void OSMesaDriver::nfglBindBufferBase(GLenum target, GLuint index, GLuint buffer)
{
	D(bug("nfosmesa: glBindBufferBase(0x%x, %u, %u)", target, index, buffer));
	fn.glBindBufferBase(target, index, buffer);
}

void OSMesaDriver::nfglBindBufferBaseEXT(GLenum target, GLuint index, GLuint buffer)
{
	D(bug("nfosmesa: glBindBufferBaseEXT(0x%x, %u, %u)", target, index, buffer));
	fn.glBindBufferBaseEXT(target, index, buffer);
}

void OSMesaDriver::nfglBindBufferBaseNV(GLenum target, GLuint index, GLuint buffer)
{
	D(bug("nfosmesa: glBindBufferBaseNV(0x%x, %u, %u)", target, index, buffer));
	fn.glBindBufferBaseNV(target, index, buffer);
}

void OSMesaDriver::nfglBindBufferOffsetEXT(GLenum target, GLuint index, GLuint buffer, GLintptr offset)
{
	D(bug("nfosmesa: glBindBufferOffsetEXT(0x%x, %u, %u, %ld)", 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(0x%x, %u, %u, %ld)", 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(0x%x, %u, %u, %ld, %ld)", 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(0x%x, %u, %u, %ld, %ld)", 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(0x%x, %u, %u, %ld, %ld)", target, index, buffer, offset, size));
	fn.glBindBufferRangeNV(target, index, buffer, offset, size);
}

void OSMesaDriver::nfglBindBuffersBase(GLenum target, GLuint first, GLsizei count, const GLuint *buffers)
{
	D(bug("nfosmesa: glBindBuffersBase(0x%x, %u, %d, %p)", target, first, count, buffers));
	/* TODO: NFOSMESA_GLBINDBUFFERSBASE may need conversion */
	fn.glBindBuffersBase(target, first, count, buffers);
}

void OSMesaDriver::nfglBindBuffersRange(GLenum target, GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizeiptr *sizes)
{
	D(bug("nfosmesa: glBindBuffersRange(0x%x, %u, %d, %p, %p, %p)", target, first, count, buffers, offsets, sizes));
	/* TODO: NFOSMESA_GLBINDBUFFERSRANGE may need conversion */
	fn.glBindBuffersRange(target, first, count, buffers, offsets, sizes);
}

void OSMesaDriver::nfglBindFragDataLocation(GLuint program, GLuint color, const GLchar *name)
{
	D(bug("nfosmesa: glBindFragDataLocation(%u, %u, %p)", program, color, name));
	/* TODO: NFOSMESA_GLBINDFRAGDATALOCATION may need conversion */
	fn.glBindFragDataLocation(program, color, name);
}

void OSMesaDriver::nfglBindFragDataLocationEXT(GLuint program, GLuint color, const GLchar *name)
{
	D(bug("nfosmesa: glBindFragDataLocationEXT(%u, %u, %p)", program, color, name));
	/* TODO: NFOSMESA_GLBINDFRAGDATALOCATIONEXT may need conversion */
	fn.glBindFragDataLocationEXT(program, color, name);
}

void OSMesaDriver::nfglBindFragDataLocationIndexed(GLuint program, GLuint colorNumber, GLuint index, const GLchar *name)
{
	D(bug("nfosmesa: glBindFragDataLocationIndexed(%u, %u, %u, %p)", program, colorNumber, index, name));
	/* TODO: NFOSMESA_GLBINDFRAGDATALOCATIONINDEXED may need conversion */
	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(0x%x, %u)", target, framebuffer));
	fn.glBindFramebuffer(target, framebuffer);
}

void OSMesaDriver::nfglBindFramebufferEXT(GLenum target, GLuint framebuffer)
{
	D(bug("nfosmesa: glBindFramebufferEXT(0x%x, %u)", 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, 0x%x, 0x%x)", unit, texture, level, layered, layer, access, 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, 0x%x, %d)", index, texture, level, layered, layer, access, format));
	fn.glBindImageTextureEXT(index, texture, level, layered, layer, access, format);
}

void OSMesaDriver::nfglBindImageTextures(GLuint first, GLsizei count, const GLuint *textures)
{
	D(bug("nfosmesa: glBindImageTextures(%u, %d, %p)", first, count, textures));
	/* TODO: NFOSMESA_GLBINDIMAGETEXTURES may need conversion */
	fn.glBindImageTextures(first, count, textures);
}

GLuint OSMesaDriver::nfglBindLightParameterEXT(GLenum light, GLenum value)
{
	D(bug("nfosmesa: glBindLightParameterEXT(0x%x, 0x%x)", light, value));
	return fn.glBindLightParameterEXT(light, value);
}

GLuint OSMesaDriver::nfglBindMaterialParameterEXT(GLenum face, GLenum value)
{
	D(bug("nfosmesa: glBindMaterialParameterEXT(0x%x, 0x%x)", face, value));
	return fn.glBindMaterialParameterEXT(face, value);
}

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

GLuint OSMesaDriver::nfglBindParameterEXT(GLenum value)
{
	D(bug("nfosmesa: glBindParameterEXT(0x%x)", value));
	return fn.glBindParameterEXT(value);
}

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

void OSMesaDriver::nfglBindProgramNV(GLenum target, GLuint id)
{
	D(bug("nfosmesa: glBindProgramNV(0x%x, %u)", 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(0x%x, %u)", target, renderbuffer));
	fn.glBindRenderbuffer(target, renderbuffer);
}

void OSMesaDriver::nfglBindRenderbufferEXT(GLenum target, GLuint renderbuffer)
{
	D(bug("nfosmesa: glBindRenderbufferEXT(0x%x, %u)", 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);
}

void OSMesaDriver::nfglBindSamplers(GLuint first, GLsizei count, const GLuint *samplers)
{
	D(bug("nfosmesa: glBindSamplers(%u, %d, %p)", first, count, samplers));
	/* TODO: NFOSMESA_GLBINDSAMPLERS may need conversion */
	fn.glBindSamplers(first, count, samplers);
}

GLuint OSMesaDriver::nfglBindTexGenParameterEXT(GLenum unit, GLenum coord, GLenum value)
{
	D(bug("nfosmesa: glBindTexGenParameterEXT(0x%x, 0x%x, 0x%x)", unit, coord, value));
	return fn.glBindTexGenParameterEXT(unit, coord, value);
}

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

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

GLuint OSMesaDriver::nfglBindTextureUnitParameterEXT(GLenum unit, GLenum value)
{
	D(bug("nfosmesa: glBindTextureUnitParameterEXT(0x%x, 0x%x)", unit, value));
	return fn.glBindTextureUnitParameterEXT(unit, value);
}

void OSMesaDriver::nfglBindTextures(GLuint first, GLsizei count, const GLuint *textures)
{
	D(bug("nfosmesa: glBindTextures(%u, %d, %p)", first, count, textures));
	/* TODO: NFOSMESA_GLBINDTEXTURES may need conversion */
	fn.glBindTextures(first, count, textures);
}

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

void OSMesaDriver::nfglBindTransformFeedbackNV(GLenum target, GLuint id)
{
	D(bug("nfosmesa: glBindTransformFeedbackNV(0x%x, %u)", 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, %ld, %d)", bindingindex, buffer, offset, stride));
	fn.glBindVertexBuffer(bindingindex, buffer, offset, stride);
}

void OSMesaDriver::nfglBindVertexBuffers(GLuint first, GLsizei count, const GLuint *buffers, const GLintptr *offsets, const GLsizei *strides)
{
	D(bug("nfosmesa: glBindVertexBuffers(%u, %d, %p, %p, %p)", first, count, buffers, offsets, strides));
	/* TODO: NFOSMESA_GLBINDVERTEXBUFFERS may need conversion */
	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, 0x%x, %ld)", video_capture_slot, stream, 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, 0x%x, 0x%x, %u)", video_capture_slot, stream, frame_region, 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);
}

void OSMesaDriver::nfglBinormal3bvEXT(const GLbyte *v)
{
	D(bug("nfosmesa: glBinormal3bvEXT(%p)", v));
	/* TODO: NFOSMESA_GLBINORMAL3BVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglBinormal3dvEXT(const GLdouble *v)
{
	D(bug("nfosmesa: glBinormal3dvEXT(%p)", 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);
}

void OSMesaDriver::nfglBinormal3fvEXT(const GLfloat *v)
{
	D(bug("nfosmesa: glBinormal3fvEXT(%p)", 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);
}

void OSMesaDriver::nfglBinormal3ivEXT(const GLint *v)
{
	D(bug("nfosmesa: glBinormal3ivEXT(%p)", 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);
}

void OSMesaDriver::nfglBinormal3svEXT(const GLshort *v)
{
	D(bug("nfosmesa: glBinormal3svEXT(%p)", v));
FN_GLBINORMAL3SVEXT(v);
}

void OSMesaDriver::nfglBinormalPointerEXT(GLenum type, GLsizei stride, const void *pointer)
{
	D(bug("nfosmesa: glBinormalPointerEXT(0x%x, %d, %p)", type, stride, pointer));
	/* TODO: NFOSMESA_GLBINORMALPOINTEREXT may need conversion */
	fn.glBinormalPointerEXT(type, stride, pointer);
}

void OSMesaDriver::nfglBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
{
	D(bug("nfosmesa: glBitmap(%d, %d, %f, %f, %f, %f, %p)", width, height, xorig, yorig, xmove, ymove, bitmap));
	/* TODO: NFOSMESA_GLBITMAP may need conversion */
	fn.glBitmap(width, height, xorig, yorig, xmove, ymove, bitmap);
}

void OSMesaDriver::nfglBitmapxOES(GLsizei width, GLsizei height, GLfixed xorig, GLfixed yorig, GLfixed xmove, GLfixed ymove, const GLubyte *bitmap)
{
	D(bug("nfosmesa: glBitmapxOES(%d, %d, 0x%x, 0x%x, 0x%x, 0x%x, %p)", width, height, xorig, yorig, xmove, ymove, bitmap));
	/* TODO: NFOSMESA_GLBITMAPXOES may need conversion */
	fn.glBitmapxOES(width, height, xorig, yorig, xmove, ymove, bitmap);
}

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(0x%x)", mode));
	fn.glBlendEquation(mode);
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

void OSMesaDriver::nfglBlendFuncSeparateINGR(GLenum sfactorRGB, GLenum dfactorRGB, GLenum sfactorAlpha, GLenum dfactorAlpha)
{
	D(bug("nfosmesa: glBlendFuncSeparateINGR(0x%x, 0x%x, 0x%x, 0x%x)", sfactorRGB, dfactorRGB, sfactorAlpha, 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, 0x%x, 0x%x, 0x%x, 0x%x)", buf, srcRGB, dstRGB, srcAlpha, 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, 0x%x, 0x%x, 0x%x, 0x%x)", buf, srcRGB, dstRGB, srcAlpha, 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, 0x%x, 0x%x, 0x%x, 0x%x)", buf, srcRGB, dstRGB, srcAlpha, dstAlpha));
	fn.glBlendFuncSeparateiARB(buf, srcRGB, dstRGB, srcAlpha, dstAlpha);
}

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

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

void OSMesaDriver::nfglBlendParameteriNV(GLenum pname, GLint value)
{
	D(bug("nfosmesa: glBlendParameteriNV(0x%x, %d)", 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, 0x%x)", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, 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, 0x%x)", srcX0, srcY0, srcX1, srcY1, dstX0, dstY0, dstX1, dstY1, mask, filter));
	fn.glBlitFramebufferEXT(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(0x%x, %u, %" PRIu64 ", %ld)", pname, index, address, length));
	fn.glBufferAddressRangeNV(pname, index, address, length);
}

void OSMesaDriver::nfglBufferData(GLenum target, GLsizeiptr size, const void *data, GLenum usage)
{
	D(bug("nfosmesa: glBufferData(0x%x, %ld, %p, 0x%x)", target, size, data, usage));
	/* TODO: NFOSMESA_GLBUFFERDATA may need conversion */
	fn.glBufferData(target, size, data, usage);
}

void OSMesaDriver::nfglBufferDataARB(GLenum target, GLsizeiptrARB size, const void *data, GLenum usage)
{
	D(bug("nfosmesa: glBufferDataARB(0x%x, %ld, %p, 0x%x)", target, size, data, usage));
	/* TODO: NFOSMESA_GLBUFFERDATAARB may need conversion */
	fn.glBufferDataARB(target, size, data, usage);
}

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

void OSMesaDriver::nfglBufferStorage(GLenum target, GLsizeiptr size, const void *data, GLbitfield flags)
{
	D(bug("nfosmesa: glBufferStorage(0x%x, %ld, %p, 0x%x)", target, size, data, flags));
	/* TODO: NFOSMESA_GLBUFFERSTORAGE may need conversion */
	fn.glBufferStorage(target, size, data, flags);
}

void OSMesaDriver::nfglBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const void *data)
{
	D(bug("nfosmesa: glBufferSubData(0x%x, %ld, %ld, %p)", target, offset, size, data));
	/* TODO: NFOSMESA_GLBUFFERSUBDATA may need conversion */
	fn.glBufferSubData(target, offset, size, data);
}

void OSMesaDriver::nfglBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, const void *data)
{
	D(bug("nfosmesa: glBufferSubDataARB(0x%x, %ld, %ld, %p)", target, offset, size, data));
	/* TODO: NFOSMESA_GLBUFFERSUBDATAARB may need conversion */
	fn.glBufferSubDataARB(target, offset, size, data);
}

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

void OSMesaDriver::nfglCallLists(GLsizei n, GLenum type, const GLvoid *lists)
{
	D(bug("nfosmesa: glCallLists(%d, 0x%x, %p)", n, type, lists));
FN_GLCALLLISTS(n, type, lists);
}

GLenum OSMesaDriver::nfglCheckFramebufferStatus(GLenum target)
{
	D(bug("nfosmesa: glCheckFramebufferStatus(0x%x)", target));
	return fn.glCheckFramebufferStatus(target);
}

GLenum OSMesaDriver::nfglCheckFramebufferStatusEXT(GLenum target)
{
	D(bug("nfosmesa: glCheckFramebufferStatusEXT(0x%x)", target));
	return fn.glCheckFramebufferStatusEXT(target);
}

GLenum OSMesaDriver::nfglCheckNamedFramebufferStatusEXT(GLuint framebuffer, GLenum target)
{
	D(bug("nfosmesa: glCheckNamedFramebufferStatusEXT(%u, 0x%x)", framebuffer, target));
	return fn.glCheckNamedFramebufferStatusEXT(framebuffer, target);
}

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

void OSMesaDriver::nfglClampColorARB(GLenum target, GLenum clamp)
{
	D(bug("nfosmesa: glClampColorARB(0x%x, 0x%x)", target, 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);
}

void OSMesaDriver::nfglClearBufferData(GLenum target, GLenum internalformat, GLenum format, GLenum type, const void *data)
{
	D(bug("nfosmesa: glClearBufferData(0x%x, 0x%x, 0x%x, 0x%x, %p)", target, internalformat, format, type, data));
	/* TODO: NFOSMESA_GLCLEARBUFFERDATA may need conversion */
	fn.glClearBufferData(target, internalformat, format, type, data);
}

void OSMesaDriver::nfglClearBufferSubData(GLenum target, GLenum internalformat, GLintptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
{
	D(bug("nfosmesa: glClearBufferSubData(0x%x, 0x%x, %ld, %ld, 0x%x, 0x%x, %p)", target, internalformat, offset, size, format, type, data));
	/* TODO: NFOSMESA_GLCLEARBUFFERSUBDATA may need conversion */
	fn.glClearBufferSubData(target, internalformat, offset, size, format, type, data);
}

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

void OSMesaDriver::nfglClearBufferfv(GLenum buffer, GLint drawbuffer, const GLfloat *value)
{
	D(bug("nfosmesa: glClearBufferfv(0x%x, %d, %p)", buffer, drawbuffer, value));
	/* TODO: NFOSMESA_GLCLEARBUFFERFV may need conversion */
	fn.glClearBufferfv(buffer, drawbuffer, value);
}

void OSMesaDriver::nfglClearBufferiv(GLenum buffer, GLint drawbuffer, const GLint *value)
{
	D(bug("nfosmesa: glClearBufferiv(0x%x, %d, %p)", buffer, drawbuffer, value));
	/* TODO: NFOSMESA_GLCLEARBUFFERIV may need conversion */
	fn.glClearBufferiv(buffer, drawbuffer, value);
}

void OSMesaDriver::nfglClearBufferuiv(GLenum buffer, GLint drawbuffer, const GLuint *value)
{
	D(bug("nfosmesa: glClearBufferuiv(0x%x, %d, %p)", buffer, drawbuffer, value));
	/* TODO: NFOSMESA_GLCLEARBUFFERUIV may need conversion */
	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, 0x%x, 0x%x)", obj, logType, 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);
}

void OSMesaDriver::nfglClearNamedBufferDataEXT(GLuint buffer, GLenum internalformat, GLenum format, GLenum type, const void *data)
{
	D(bug("nfosmesa: glClearNamedBufferDataEXT(%u, 0x%x, 0x%x, 0x%x, %p)", buffer, internalformat, format, type, data));
	/* TODO: NFOSMESA_GLCLEARNAMEDBUFFERDATAEXT may need conversion */
	fn.glClearNamedBufferDataEXT(buffer, internalformat, format, type, data);
}

void OSMesaDriver::nfglClearNamedBufferSubDataEXT(GLuint buffer, GLenum internalformat, GLsizeiptr offset, GLsizeiptr size, GLenum format, GLenum type, const void *data)
{
	D(bug("nfosmesa: glClearNamedBufferSubDataEXT(%u, 0x%x, %ld, %ld, 0x%x, 0x%x, %p)", buffer, internalformat, offset, size, format, type, data));
	/* TODO: NFOSMESA_GLCLEARNAMEDBUFFERSUBDATAEXT may need conversion */
	fn.glClearNamedBufferSubDataEXT(buffer, internalformat, offset, size, format, type, data);
}

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

void OSMesaDriver::nfglClearTexImage(GLuint texture, GLint level, GLenum format, GLenum type, const void *data)
{
	D(bug("nfosmesa: glClearTexImage(%u, %d, 0x%x, 0x%x, %p)", texture, level, format, type, data));
	/* TODO: NFOSMESA_GLCLEARTEXIMAGE may need conversion */
	fn.glClearTexImage(texture, level, format, type, data);
}

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)
{
	D(bug("nfosmesa: glClearTexSubImage(%u, %d, %d, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p)", texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data));
	/* TODO: NFOSMESA_GLCLEARTEXSUBIMAGE may need conversion */
	fn.glClearTexSubImage(texture, level, xoffset, yoffset, zoffset, width, height, depth, format, type, data);
}

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

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

void OSMesaDriver::nfglClientActiveVertexStreamATI(GLenum stream)
{
	D(bug("nfosmesa: glClientActiveVertexStreamATI(0x%x)", 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(%p, 0x%x, %" PRIu64 ")", sync, flags, timeout));
	return fn.glClientWaitSync(sync, flags, timeout);
}

void OSMesaDriver::nfglClipPlane(GLenum plane, const GLdouble *equation)
{
	D(bug("nfosmesa: glClipPlane(0x%x, %p)", plane, equation));
FN_GLCLIPPLANE(plane, equation);
}

void OSMesaDriver::nfglClipPlanefOES(GLenum plane, const GLfloat *equation)
{
	D(bug("nfosmesa: glClipPlanefOES(0x%x, %p)", plane, equation));
FN_GLCLIPPLANEFOES(plane, equation);
}

void OSMesaDriver::nfglClipPlanexOES(GLenum plane, const GLfixed *equation)
{
	D(bug("nfosmesa: glClipPlanexOES(0x%x, %p)", plane, 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);
}

void OSMesaDriver::nfglColor3bv(const GLbyte *v)
{
	D(bug("nfosmesa: glColor3bv(%p)", v));
	/* TODO: NFOSMESA_GLCOLOR3BV may need conversion */
	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);
}

void OSMesaDriver::nfglColor3dv(const GLdouble *v)
{
	D(bug("nfosmesa: glColor3dv(%p)", 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);
}

void OSMesaDriver::nfglColor3fVertex3fvSUN(const GLfloat *c, const GLfloat *v)
{
	D(bug("nfosmesa: glColor3fVertex3fvSUN(%p, %p)", c, v));
FN_GLCOLOR3FVERTEX3FVSUN(c, v);
}

void OSMesaDriver::nfglColor3fv(const GLfloat *v)
{
	D(bug("nfosmesa: glColor3fv(%p)", 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);
}

void OSMesaDriver::nfglColor3hvNV(const GLhalfNV *v)
{
	D(bug("nfosmesa: glColor3hvNV(%p)", 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);
}

void OSMesaDriver::nfglColor3iv(const GLint *v)
{
	D(bug("nfosmesa: glColor3iv(%p)", 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);
}

void OSMesaDriver::nfglColor3sv(const GLshort *v)
{
	D(bug("nfosmesa: glColor3sv(%p)", 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);
}

void OSMesaDriver::nfglColor3ubv(const GLubyte *v)
{
	D(bug("nfosmesa: glColor3ubv(%p)", v));
	/* TODO: NFOSMESA_GLCOLOR3UBV may need conversion */
	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);
}

void OSMesaDriver::nfglColor3uiv(const GLuint *v)
{
	D(bug("nfosmesa: glColor3uiv(%p)", 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);
}

void OSMesaDriver::nfglColor3usv(const GLushort *v)
{
	D(bug("nfosmesa: glColor3usv(%p)", 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);
}

void OSMesaDriver::nfglColor3xvOES(const GLfixed *components)
{
	D(bug("nfosmesa: glColor3xvOES(%p)", 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);
}

void OSMesaDriver::nfglColor4bv(const GLbyte *v)
{
	D(bug("nfosmesa: glColor4bv(%p)", v));
	/* TODO: NFOSMESA_GLCOLOR4BV may need conversion */
	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);
}

void OSMesaDriver::nfglColor4dv(const GLdouble *v)
{
	D(bug("nfosmesa: glColor4dv(%p)", 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);
}

void OSMesaDriver::nfglColor4fNormal3fVertex3fvSUN(const GLfloat *c, const GLfloat *n, const GLfloat *v)
{
	D(bug("nfosmesa: glColor4fNormal3fVertex3fvSUN(%p, %p, %p)", c, n, v));
FN_GLCOLOR4FNORMAL3FVERTEX3FVSUN(c, n, v);
}

void OSMesaDriver::nfglColor4fv(const GLfloat *v)
{
	D(bug("nfosmesa: glColor4fv(%p)", 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);
}

void OSMesaDriver::nfglColor4hvNV(const GLhalfNV *v)
{
	D(bug("nfosmesa: glColor4hvNV(%p)", 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);
}

void OSMesaDriver::nfglColor4iv(const GLint *v)
{
	D(bug("nfosmesa: glColor4iv(%p)", 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);
}

void OSMesaDriver::nfglColor4sv(const GLshort *v)
{
	D(bug("nfosmesa: glColor4sv(%p)", 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);
}

void OSMesaDriver::nfglColor4ubVertex2fvSUN(const GLubyte *c, const GLfloat *v)
{
	D(bug("nfosmesa: glColor4ubVertex2fvSUN(%p, %p)", c, 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);
}

void OSMesaDriver::nfglColor4ubVertex3fvSUN(const GLubyte *c, const GLfloat *v)
{
	D(bug("nfosmesa: glColor4ubVertex3fvSUN(%p, %p)", c, v));
FN_GLCOLOR4UBVERTEX3FVSUN(c, v);
}

void OSMesaDriver::nfglColor4ubv(const GLubyte *v)
{
	D(bug("nfosmesa: glColor4ubv(%p)", v));
	/* TODO: NFOSMESA_GLCOLOR4UBV may need conversion */
	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);
}

void OSMesaDriver::nfglColor4uiv(const GLuint *v)
{
	D(bug("nfosmesa: glColor4uiv(%p)", 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);
}

void OSMesaDriver::nfglColor4usv(const GLushort *v)
{
	D(bug("nfosmesa: glColor4usv(%p)", 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);
}

void OSMesaDriver::nfglColor4xvOES(const GLfixed *components)
{
	D(bug("nfosmesa: glColor4xvOES(%p)", components));
FN_GLCOLOR4XVOES(components);
}

void OSMesaDriver::nfglColorFormatNV(GLint size, GLenum type, GLsizei stride)
{
	D(bug("nfosmesa: glColorFormatNV(%d, 0x%x, %d)", size, 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(0x%x, %u, %u, %u, %u, %u, %u)", 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(0x%x, %u, %u, %u, %u, %u, %u, %u, %u, %u)", 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(0x%x, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u, %u)", 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(0x%x, 0x%x)", face, mode));
	fn.glColorMaterial(face, mode);
}

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

void OSMesaDriver::nfglColorP3uiv(GLenum type, const GLuint *color)
{
	D(bug("nfosmesa: glColorP3uiv(0x%x, %p)", type, color));
FN_GLCOLORP3UIV(type, color);
}

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

void OSMesaDriver::nfglColorP4uiv(GLenum type, const GLuint *color)
{
	D(bug("nfosmesa: glColorP4uiv(0x%x, %p)", type, color));
FN_GLCOLORP4UIV(type, color);
}

void OSMesaDriver::nfglColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
	D(bug("nfosmesa: glColorPointer(%d, 0x%x, %d, %p)", size, type, stride, pointer));
FN_GLCOLORPOINTER(size, type, stride, pointer);
}

void OSMesaDriver::nfglColorPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer)
{
	D(bug("nfosmesa: glColorPointerEXT(%d, 0x%x, %d, %d, %p)", size, type, stride, count, pointer));
FN_GLCOLORPOINTEREXT(size, type, stride, count, pointer);
}

void OSMesaDriver::nfglColorPointerListIBM(GLint size, GLenum type, GLint stride, const void * *pointer, GLint ptrstride)
{
	D(bug("nfosmesa: glColorPointerListIBM(%d, 0x%x, %d, %p, %d)", size, type, stride, pointer, ptrstride));
	/* TODO: NFOSMESA_GLCOLORPOINTERLISTIBM may need conversion */
	fn.glColorPointerListIBM(size, type, stride, pointer, ptrstride);
}

void OSMesaDriver::nfglColorPointervINTEL(GLint size, GLenum type, const void * *pointer)
{
	D(bug("nfosmesa: glColorPointervINTEL(%d, 0x%x, %p)", size, type, pointer));
	/* TODO: NFOSMESA_GLCOLORPOINTERVINTEL may need conversion */
	fn.glColorPointervINTEL(size, type, pointer);
}

void OSMesaDriver::nfglColorSubTable(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data)
{
	D(bug("nfosmesa: glColorSubTable(0x%x, %d, %d, 0x%x, 0x%x, %p)", target, start, count, format, type, data));
FN_GLCOLORSUBTABLE(target, start, count, format, type, data);
}

void OSMesaDriver::nfglColorSubTableEXT(GLenum target, GLsizei start, GLsizei count, GLenum format, GLenum type, const void *data)
{
	D(bug("nfosmesa: glColorSubTableEXT(0x%x, %d, %d, 0x%x, 0x%x, %p)", target, start, count, format, type, data));
	/* TODO: NFOSMESA_GLCOLORSUBTABLEEXT may need conversion */
	fn.glColorSubTableEXT(target, start, count, format, type, data);
}

void OSMesaDriver::nfglColorTable(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table)
{
	D(bug("nfosmesa: glColorTable(0x%x, 0x%x, %d, 0x%x, 0x%x, %p)", target, internalformat, width, format, type, table));
FN_GLCOLORTABLE(target, internalformat, width, format, type, table);
}

void OSMesaDriver::nfglColorTableEXT(GLenum target, GLenum internalFormat, GLsizei width, GLenum format, GLenum type, const void *table)
{
	D(bug("nfosmesa: glColorTableEXT(0x%x, 0x%x, %d, 0x%x, 0x%x, %p)", target, internalFormat, width, format, type, table));
	/* TODO: NFOSMESA_GLCOLORTABLEEXT may need conversion */
	fn.glColorTableEXT(target, internalFormat, width, format, type, table);
}

void OSMesaDriver::nfglColorTableParameterfv(GLenum target, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glColorTableParameterfv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLCOLORTABLEPARAMETERFV may need conversion */
	fn.glColorTableParameterfv(target, pname, params);
}

void OSMesaDriver::nfglColorTableParameterfvSGI(GLenum target, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glColorTableParameterfvSGI(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLCOLORTABLEPARAMETERFVSGI may need conversion */
	fn.glColorTableParameterfvSGI(target, pname, params);
}

void OSMesaDriver::nfglColorTableParameteriv(GLenum target, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glColorTableParameteriv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLCOLORTABLEPARAMETERIV may need conversion */
	fn.glColorTableParameteriv(target, pname, params);
}

void OSMesaDriver::nfglColorTableParameterivSGI(GLenum target, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glColorTableParameterivSGI(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLCOLORTABLEPARAMETERIVSGI may need conversion */
	fn.glColorTableParameterivSGI(target, pname, params);
}

void OSMesaDriver::nfglColorTableSGI(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *table)
{
	D(bug("nfosmesa: glColorTableSGI(0x%x, 0x%x, %d, 0x%x, 0x%x, %p)", target, internalformat, width, format, type, table));
	/* TODO: NFOSMESA_GLCOLORTABLESGI may need conversion */
	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(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x)", stage, portion, variable, input, mapping, 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(0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, 0x%x, %d, %d, %d)", stage, portion, abOutput, cdOutput, sumOutput, scale, 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(0x%x, %f)", pname, param));
	fn.glCombinerParameterfNV(pname, param);
}

void OSMesaDriver::nfglCombinerParameterfvNV(GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glCombinerParameterfvNV(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLCOMBINERPARAMETERFVNV may need conversion */
	fn.glCombinerParameterfvNV(pname, params);
}

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

void OSMesaDriver::nfglCombinerParameterivNV(GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glCombinerParameterivNV(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLCOMBINERPARAMETERIVNV may need conversion */
	fn.glCombinerParameterivNV(pname, params);
}

void OSMesaDriver::nfglCombinerStageParameterfvNV(GLenum stage, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glCombinerStageParameterfvNV(0x%x, 0x%x, %p)", stage, pname, params));
	/* TODO: NFOSMESA_GLCOMBINERSTAGEPARAMETERFVNV may need conversion */
	fn.glCombinerStageParameterfvNV(stage, pname, params);
}

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

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

void OSMesaDriver::nfglCompileShaderIncludeARB(GLuint shader, GLsizei count, const GLchar *const *path, const GLint *length)
{
	D(bug("nfosmesa: glCompileShaderIncludeARB(%u, %d, %p, %p)", shader, count, path, length));
	/* TODO: NFOSMESA_GLCOMPILESHADERINCLUDEARB may need conversion */
	fn.glCompileShaderIncludeARB(shader, count, path, length);
}

void OSMesaDriver::nfglCompressedMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits)
{
	D(bug("nfosmesa: glCompressedMultiTexImage1DEXT(0x%x, 0x%x, %d, 0x%x, %d, %d, %d, %p)", texunit, target, level, internalformat, width, border, imageSize, bits));
	/* TODO: NFOSMESA_GLCOMPRESSEDMULTITEXIMAGE1DEXT may need conversion */
	fn.glCompressedMultiTexImage1DEXT(texunit, target, level, internalformat, width, border, imageSize, bits);
}

void OSMesaDriver::nfglCompressedMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits)
{
	D(bug("nfosmesa: glCompressedMultiTexImage2DEXT(0x%x, 0x%x, %d, 0x%x, %d, %d, %d, %d, %p)", texunit, target, level, internalformat, width, height, border, imageSize, bits));
	/* TODO: NFOSMESA_GLCOMPRESSEDMULTITEXIMAGE2DEXT may need conversion */
	fn.glCompressedMultiTexImage2DEXT(texunit, target, level, internalformat, width, height, border, imageSize, bits);
}

void OSMesaDriver::nfglCompressedMultiTexImage3DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits)
{
	D(bug("nfosmesa: glCompressedMultiTexImage3DEXT(0x%x, 0x%x, %d, 0x%x, %d, %d, %d, %d, %d, %p)", texunit, target, level, internalformat, width, height, depth, border, imageSize, bits));
	/* TODO: NFOSMESA_GLCOMPRESSEDMULTITEXIMAGE3DEXT may need conversion */
	fn.glCompressedMultiTexImage3DEXT(texunit, target, level, internalformat, width, height, depth, border, imageSize, bits);
}

void OSMesaDriver::nfglCompressedMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits)
{
	D(bug("nfosmesa: glCompressedMultiTexSubImage1DEXT(0x%x, 0x%x, %d, %d, %d, 0x%x, %d, %p)", texunit, target, level, xoffset, width, format, imageSize, bits));
	/* TODO: NFOSMESA_GLCOMPRESSEDMULTITEXSUBIMAGE1DEXT may need conversion */
	fn.glCompressedMultiTexSubImage1DEXT(texunit, target, level, xoffset, width, format, imageSize, bits);
}

void OSMesaDriver::nfglCompressedMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits)
{
	D(bug("nfosmesa: glCompressedMultiTexSubImage2DEXT(0x%x, 0x%x, %d, %d, %d, %d, %d, 0x%x, %d, %p)", texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits));
	/* TODO: NFOSMESA_GLCOMPRESSEDMULTITEXSUBIMAGE2DEXT may need conversion */
	fn.glCompressedMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, imageSize, bits);
}

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)
{
	D(bug("nfosmesa: glCompressedMultiTexSubImage3DEXT(0x%x, 0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, %d, %p)", texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits));
	/* TODO: NFOSMESA_GLCOMPRESSEDMULTITEXSUBIMAGE3DEXT may need conversion */
	fn.glCompressedMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
}

void OSMesaDriver::nfglCompressedTexImage1D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data)
{
	D(bug("nfosmesa: glCompressedTexImage1D(0x%x, %d, 0x%x, %d, %d, %d, %p)", target, level, internalformat, width, border, imageSize, data));
	/* TODO: NFOSMESA_GLCOMPRESSEDTEXIMAGE1D may need conversion */
	fn.glCompressedTexImage1D(target, level, internalformat, width, border, imageSize, data);
}

void OSMesaDriver::nfglCompressedTexImage1DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *data)
{
	D(bug("nfosmesa: glCompressedTexImage1DARB(0x%x, %d, 0x%x, %d, %d, %d, %p)", target, level, internalformat, width, border, imageSize, data));
	/* TODO: NFOSMESA_GLCOMPRESSEDTEXIMAGE1DARB may need conversion */
	fn.glCompressedTexImage1DARB(target, level, internalformat, width, border, imageSize, data);
}

void OSMesaDriver::nfglCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data)
{
	D(bug("nfosmesa: glCompressedTexImage2D(0x%x, %d, 0x%x, %d, %d, %d, %d, %p)", target, level, internalformat, width, height, border, imageSize, data));
	/* TODO: NFOSMESA_GLCOMPRESSEDTEXIMAGE2D may need conversion */
	fn.glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data);
}

void OSMesaDriver::nfglCompressedTexImage2DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *data)
{
	D(bug("nfosmesa: glCompressedTexImage2DARB(0x%x, %d, 0x%x, %d, %d, %d, %d, %p)", target, level, internalformat, width, height, border, imageSize, data));
	/* TODO: NFOSMESA_GLCOMPRESSEDTEXIMAGE2DARB may need conversion */
	fn.glCompressedTexImage2DARB(target, level, internalformat, width, height, border, imageSize, data);
}

void OSMesaDriver::nfglCompressedTexImage3D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data)
{
	D(bug("nfosmesa: glCompressedTexImage3D(0x%x, %d, 0x%x, %d, %d, %d, %d, %d, %p)", target, level, internalformat, width, height, depth, border, imageSize, data));
	/* TODO: NFOSMESA_GLCOMPRESSEDTEXIMAGE3D may need conversion */
	fn.glCompressedTexImage3D(target, level, internalformat, width, height, depth, border, imageSize, data);
}

void OSMesaDriver::nfglCompressedTexImage3DARB(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *data)
{
	D(bug("nfosmesa: glCompressedTexImage3DARB(0x%x, %d, 0x%x, %d, %d, %d, %d, %d, %p)", target, level, internalformat, width, height, depth, border, imageSize, data));
	/* TODO: NFOSMESA_GLCOMPRESSEDTEXIMAGE3DARB may need conversion */
	fn.glCompressedTexImage3DARB(target, level, internalformat, width, height, depth, border, imageSize, data);
}

void OSMesaDriver::nfglCompressedTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
{
	D(bug("nfosmesa: glCompressedTexSubImage1D(0x%x, %d, %d, %d, 0x%x, %d, %p)", target, level, xoffset, width, format, imageSize, data));
	/* TODO: NFOSMESA_GLCOMPRESSEDTEXSUBIMAGE1D may need conversion */
	fn.glCompressedTexSubImage1D(target, level, xoffset, width, format, imageSize, data);
}

void OSMesaDriver::nfglCompressedTexSubImage1DARB(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *data)
{
	D(bug("nfosmesa: glCompressedTexSubImage1DARB(0x%x, %d, %d, %d, 0x%x, %d, %p)", target, level, xoffset, width, format, imageSize, data));
	/* TODO: NFOSMESA_GLCOMPRESSEDTEXSUBIMAGE1DARB may need conversion */
	fn.glCompressedTexSubImage1DARB(target, level, xoffset, width, format, imageSize, data);
}

void OSMesaDriver::nfglCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
{
	D(bug("nfosmesa: glCompressedTexSubImage2D(0x%x, %d, %d, %d, %d, %d, 0x%x, %d, %p)", target, level, xoffset, yoffset, width, height, format, imageSize, data));
	/* TODO: NFOSMESA_GLCOMPRESSEDTEXSUBIMAGE2D may need conversion */
	fn.glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}

void OSMesaDriver::nfglCompressedTexSubImage2DARB(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *data)
{
	D(bug("nfosmesa: glCompressedTexSubImage2DARB(0x%x, %d, %d, %d, %d, %d, 0x%x, %d, %p)", target, level, xoffset, yoffset, width, height, format, imageSize, data));
	/* TODO: NFOSMESA_GLCOMPRESSEDTEXSUBIMAGE2DARB may need conversion */
	fn.glCompressedTexSubImage2DARB(target, level, xoffset, yoffset, width, height, format, imageSize, data);
}

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)
{
	D(bug("nfosmesa: glCompressedTexSubImage3D(0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, %d, %p)", target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data));
	/* TODO: NFOSMESA_GLCOMPRESSEDTEXSUBIMAGE3D may need conversion */
	fn.glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}

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)
{
	D(bug("nfosmesa: glCompressedTexSubImage3DARB(0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, %d, %p)", target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data));
	/* TODO: NFOSMESA_GLCOMPRESSEDTEXSUBIMAGE3DARB may need conversion */
	fn.glCompressedTexSubImage3DARB(target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, data);
}

void OSMesaDriver::nfglCompressedTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLsizei imageSize, const void *bits)
{
	D(bug("nfosmesa: glCompressedTextureImage1DEXT(%u, 0x%x, %d, 0x%x, %d, %d, %d, %p)", texture, target, level, internalformat, width, border, imageSize, bits));
	/* TODO: NFOSMESA_GLCOMPRESSEDTEXTUREIMAGE1DEXT may need conversion */
	fn.glCompressedTextureImage1DEXT(texture, target, level, internalformat, width, border, imageSize, bits);
}

void OSMesaDriver::nfglCompressedTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const void *bits)
{
	D(bug("nfosmesa: glCompressedTextureImage2DEXT(%u, 0x%x, %d, 0x%x, %d, %d, %d, %d, %p)", texture, target, level, internalformat, width, height, border, imageSize, bits));
	/* TODO: NFOSMESA_GLCOMPRESSEDTEXTUREIMAGE2DEXT may need conversion */
	fn.glCompressedTextureImage2DEXT(texture, target, level, internalformat, width, height, border, imageSize, bits);
}

void OSMesaDriver::nfglCompressedTextureImage3DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLsizei imageSize, const void *bits)
{
	D(bug("nfosmesa: glCompressedTextureImage3DEXT(%u, 0x%x, %d, 0x%x, %d, %d, %d, %d, %d, %p)", texture, target, level, internalformat, width, height, depth, border, imageSize, bits));
	/* TODO: NFOSMESA_GLCOMPRESSEDTEXTUREIMAGE3DEXT may need conversion */
	fn.glCompressedTextureImage3DEXT(texture, target, level, internalformat, width, height, depth, border, imageSize, bits);
}

void OSMesaDriver::nfglCompressedTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLsizei imageSize, const void *bits)
{
	D(bug("nfosmesa: glCompressedTextureSubImage1DEXT(%u, 0x%x, %d, %d, %d, 0x%x, %d, %p)", texture, target, level, xoffset, width, format, imageSize, bits));
	/* TODO: NFOSMESA_GLCOMPRESSEDTEXTURESUBIMAGE1DEXT may need conversion */
	fn.glCompressedTextureSubImage1DEXT(texture, target, level, xoffset, width, format, imageSize, bits);
}

void OSMesaDriver::nfglCompressedTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const void *bits)
{
	D(bug("nfosmesa: glCompressedTextureSubImage2DEXT(%u, 0x%x, %d, %d, %d, %d, %d, 0x%x, %d, %p)", texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits));
	/* TODO: NFOSMESA_GLCOMPRESSEDTEXTURESUBIMAGE2DEXT may need conversion */
	fn.glCompressedTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, imageSize, bits);
}

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)
{
	D(bug("nfosmesa: glCompressedTextureSubImage3DEXT(%u, 0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, %d, %p)", texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits));
	/* TODO: NFOSMESA_GLCOMPRESSEDTEXTURESUBIMAGE3DEXT may need conversion */
	fn.glCompressedTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, imageSize, bits);
}

void OSMesaDriver::nfglConvolutionFilter1D(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image)
{
	D(bug("nfosmesa: glConvolutionFilter1D(0x%x, 0x%x, %d, 0x%x, 0x%x, %p)", target, internalformat, width, format, type, image));
	/* TODO: NFOSMESA_GLCONVOLUTIONFILTER1D may need conversion */
	fn.glConvolutionFilter1D(target, internalformat, width, format, type, image);
}

void OSMesaDriver::nfglConvolutionFilter1DEXT(GLenum target, GLenum internalformat, GLsizei width, GLenum format, GLenum type, const void *image)
{
	D(bug("nfosmesa: glConvolutionFilter1DEXT(0x%x, 0x%x, %d, 0x%x, 0x%x, %p)", target, internalformat, width, format, type, image));
	/* TODO: NFOSMESA_GLCONVOLUTIONFILTER1DEXT may need conversion */
	fn.glConvolutionFilter1DEXT(target, internalformat, width, format, type, image);
}

void OSMesaDriver::nfglConvolutionFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image)
{
	D(bug("nfosmesa: glConvolutionFilter2D(0x%x, 0x%x, %d, %d, 0x%x, 0x%x, %p)", target, internalformat, width, height, format, type, image));
	/* TODO: NFOSMESA_GLCONVOLUTIONFILTER2D may need conversion */
	fn.glConvolutionFilter2D(target, internalformat, width, height, format, type, image);
}

void OSMesaDriver::nfglConvolutionFilter2DEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *image)
{
	D(bug("nfosmesa: glConvolutionFilter2DEXT(0x%x, 0x%x, %d, %d, 0x%x, 0x%x, %p)", target, internalformat, width, height, format, type, image));
	/* TODO: NFOSMESA_GLCONVOLUTIONFILTER2DEXT may need conversion */
	fn.glConvolutionFilter2DEXT(target, internalformat, width, height, format, type, image);
}

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

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

void OSMesaDriver::nfglConvolutionParameterfv(GLenum target, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glConvolutionParameterfv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLCONVOLUTIONPARAMETERFV may need conversion */
	fn.glConvolutionParameterfv(target, pname, params);
}

void OSMesaDriver::nfglConvolutionParameterfvEXT(GLenum target, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glConvolutionParameterfvEXT(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLCONVOLUTIONPARAMETERFVEXT may need conversion */
	fn.glConvolutionParameterfvEXT(target, pname, params);
}

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

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

void OSMesaDriver::nfglConvolutionParameteriv(GLenum target, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glConvolutionParameteriv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLCONVOLUTIONPARAMETERIV may need conversion */
	fn.glConvolutionParameteriv(target, pname, params);
}

void OSMesaDriver::nfglConvolutionParameterivEXT(GLenum target, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glConvolutionParameterivEXT(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLCONVOLUTIONPARAMETERIVEXT may need conversion */
	fn.glConvolutionParameterivEXT(target, pname, params);
}

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

void OSMesaDriver::nfglConvolutionParameterxvOES(GLenum target, GLenum pname, const GLfixed *params)
{
	D(bug("nfosmesa: glConvolutionParameterxvOES(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLCONVOLUTIONPARAMETERXVOES may need conversion */
	fn.glConvolutionParameterxvOES(target, pname, params);
}

void OSMesaDriver::nfglCopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size)
{
	D(bug("nfosmesa: glCopyBufferSubData(0x%x, 0x%x, %ld, %ld, %ld)", readTarget, 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(0x%x, %d, %d, %d, %d)", 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(0x%x, %d, %d, %d, %d)", 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(0x%x, 0x%x, %d, %d, %d)", target, 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(0x%x, 0x%x, %d, %d, %d)", target, 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(0x%x, 0x%x, %d, %d, %d)", target, 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(0x%x, 0x%x, %d, %d, %d)", target, 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(0x%x, 0x%x, %d, %d, %d, %d)", target, 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(0x%x, 0x%x, %d, %d, %d, %d)", target, 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, 0x%x, %d, %d, %d, %d, %u, 0x%x, %d, %d, %d, %d, %d, %d, %d)", srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, 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, 0x%x, %d, %d, %d, %d, %u, 0x%x, %d, %d, %d, %d, %d, %d, %d)", srcName, srcTarget, srcLevel, srcX, srcY, srcZ, dstName, 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(0x%x, 0x%x, %d, 0x%x, %d, %d, %d, %d)", texunit, target, level, 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(0x%x, 0x%x, %d, 0x%x, %d, %d, %d, %d, %d)", texunit, target, level, 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(0x%x, 0x%x, %d, %d, %d, %d, %d)", texunit, 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(0x%x, 0x%x, %d, %d, %d, %d, %d, %d, %d)", texunit, 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(0x%x, 0x%x, %d, %d, %d, %d, %d, %d, %d, %d)", texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height));
	fn.glCopyMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, x, y, width, height);
}

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, 0x%x)", x, y, width, height, 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(0x%x, %d, 0x%x, %d, %d, %d, %d)", target, level, 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(0x%x, %d, 0x%x, %d, %d, %d, %d)", target, level, 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(0x%x, %d, 0x%x, %d, %d, %d, %d, %d)", target, level, 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(0x%x, %d, 0x%x, %d, %d, %d, %d, %d)", target, level, 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(0x%x, %d, %d, %d, %d, %d)", 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(0x%x, %d, %d, %d, %d, %d)", 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(0x%x, %d, %d, %d, %d, %d, %d, %d)", 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(0x%x, %d, %d, %d, %d, %d, %d, %d)", 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(0x%x, %d, %d, %d, %d, %d, %d, %d, %d)", 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(0x%x, %d, %d, %d, %d, %d, %d, %d, %d)", 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, 0x%x, %d, 0x%x, %d, %d, %d, %d)", texture, target, level, 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, 0x%x, %d, 0x%x, %d, %d, %d, %d, %d)", texture, target, level, internalformat, x, y, width, height, border));
	fn.glCopyTextureImage2DEXT(texture, target, level, internalformat, x, y, width, height, border);
}

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

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, 0x%x, %d, %d, %d, %d, %d, %d, %d)", texture, target, level, xoffset, yoffset, x, y, width, height));
	fn.glCopyTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, 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, 0x%x, %d, %d, %d, %d, %d, %d, %d, %d)", texture, target, level, xoffset, yoffset, zoffset, x, y, width, height));
	fn.glCopyTextureSubImage3DEXT(texture, target, level, xoffset, yoffset, zoffset, x, y, width, height);
}

void OSMesaDriver::nfglCoverFillPathInstancedNV(GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat *transformValues)
{
	D(bug("nfosmesa: glCoverFillPathInstancedNV(%d, 0x%x, %p, %u, 0x%x, 0x%x, %p)", numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues));
	/* TODO: NFOSMESA_GLCOVERFILLPATHINSTANCEDNV may need conversion */
	fn.glCoverFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
}

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

void OSMesaDriver::nfglCoverStrokePathInstancedNV(GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum coverMode, GLenum transformType, const GLfloat *transformValues)
{
	D(bug("nfosmesa: glCoverStrokePathInstancedNV(%d, 0x%x, %p, %u, 0x%x, 0x%x, %p)", numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues));
	/* TODO: NFOSMESA_GLCOVERSTROKEPATHINSTANCEDNV may need conversion */
	fn.glCoverStrokePathInstancedNV(numPaths, pathNameType, paths, pathBase, coverMode, transformType, transformValues);
}

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

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

void OSMesaDriver::nfglCreatePerfQueryINTEL(GLuint queryId, GLuint *queryHandle)
{
	D(bug("nfosmesa: glCreatePerfQueryINTEL(%u, %p)", queryId, queryHandle));
	/* TODO: NFOSMESA_GLCREATEPERFQUERYINTEL may need conversion */
	fn.glCreatePerfQueryINTEL(queryId, queryHandle);
}

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

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

GLuint OSMesaDriver::nfglCreateShader(GLenum type)
{
	D(bug("nfosmesa: glCreateShader(0x%x)", type));
	return fn.glCreateShader(type);
}

GLhandleARB OSMesaDriver::nfglCreateShaderObjectARB(GLenum shaderType)
{
	D(bug("nfosmesa: glCreateShaderObjectARB(0x%x)", shaderType));
	return fn.glCreateShaderObjectARB(shaderType);
}

GLuint OSMesaDriver::nfglCreateShaderProgramEXT(GLenum type, const GLchar *string)
{
	D(bug("nfosmesa: glCreateShaderProgramEXT(0x%x, %p)", type, string));
	/* TODO: NFOSMESA_GLCREATESHADERPROGRAMEXT may need conversion */
	return fn.glCreateShaderProgramEXT(type, string);
}

GLuint OSMesaDriver::nfglCreateShaderProgramv(GLenum type, GLsizei count, const GLchar *const *strings)
{
	D(bug("nfosmesa: glCreateShaderProgramv(0x%x, %d, %p)", type, count, strings));
	/* TODO: NFOSMESA_GLCREATESHADERPROGRAMV may need conversion */
	return fn.glCreateShaderProgramv(type, count, strings);
}

#if 0
GLsync OSMesaDriver::nfglCreateSyncFromCLeventARB(struct _cl_context *context, struct _cl_event *event, GLbitfield flags)
{
	D(bug("nfosmesa: glCreateSyncFromCLeventARB(%p, %p, 0x%x)", context, event, flags));
	/* TODO: NFOSMESA_GLCREATESYNCFROMCLEVENTARB may need conversion */
	return fn.glCreateSyncFromCLeventARB(context, event, flags);
}
#endif

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

void OSMesaDriver::nfglCullParameterdvEXT(GLenum pname, GLdouble *params)
{
	D(bug("nfosmesa: glCullParameterdvEXT(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLCULLPARAMETERDVEXT may need conversion */
	fn.glCullParameterdvEXT(pname, params);
}

void OSMesaDriver::nfglCullParameterfvEXT(GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glCullParameterfvEXT(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLCULLPARAMETERFVEXT may need conversion */
	fn.glCullParameterfvEXT(pname, params);
}

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

#if 0
void OSMesaDriver::nfglDebugMessageCallback(GLDEBUGPROC callback, const void *userParam)
{
	D(bug("nfosmesa: glDebugMessageCallback(%p, %p)", callback, userParam));
	/* TODO: NFOSMESA_GLDEBUGMESSAGECALLBACK may need conversion */
	fn.glDebugMessageCallback(callback, userParam);
}
#endif

#if 0
void OSMesaDriver::nfglDebugMessageCallbackAMD(GLDEBUGPROCAMD callback, void *userParam)
{
	D(bug("nfosmesa: glDebugMessageCallbackAMD(%p, %p)", callback, userParam));
	/* TODO: NFOSMESA_GLDEBUGMESSAGECALLBACKAMD may need conversion */
	fn.glDebugMessageCallbackAMD(callback, userParam);
}
#endif

#if 0
void OSMesaDriver::nfglDebugMessageCallbackARB(GLDEBUGPROCARB callback, const void *userParam)
{
	D(bug("nfosmesa: glDebugMessageCallbackARB(%p, %p)", callback, userParam));
	/* TODO: NFOSMESA_GLDEBUGMESSAGECALLBACKARB may need conversion */
	fn.glDebugMessageCallbackARB(callback, userParam);
}
#endif

void OSMesaDriver::nfglDebugMessageControl(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean32 enabled)
{
	D(bug("nfosmesa: glDebugMessageControl(0x%x, 0x%x, 0x%x, %d, %p, %d)", source, type, severity, count, ids, enabled));
	/* TODO: NFOSMESA_GLDEBUGMESSAGECONTROL may need conversion */
	fn.glDebugMessageControl(source, type, severity, count, ids, enabled);
}

void OSMesaDriver::nfglDebugMessageControlARB(GLenum source, GLenum type, GLenum severity, GLsizei count, const GLuint *ids, GLboolean32 enabled)
{
	D(bug("nfosmesa: glDebugMessageControlARB(0x%x, 0x%x, 0x%x, %d, %p, %d)", source, type, severity, count, ids, enabled));
	/* TODO: NFOSMESA_GLDEBUGMESSAGECONTROLARB may need conversion */
	fn.glDebugMessageControlARB(source, type, severity, count, ids, enabled);
}

void OSMesaDriver::nfglDebugMessageEnableAMD(GLenum category, GLenum severity, GLsizei count, const GLuint *ids, GLboolean32 enabled)
{
	D(bug("nfosmesa: glDebugMessageEnableAMD(0x%x, 0x%x, %d, %p, %d)", category, severity, count, ids, enabled));
	/* TODO: NFOSMESA_GLDEBUGMESSAGEENABLEAMD may need conversion */
	fn.glDebugMessageEnableAMD(category, severity, count, ids, enabled);
}

void OSMesaDriver::nfglDebugMessageInsert(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)
{
	D(bug("nfosmesa: glDebugMessageInsert(0x%x, 0x%x, %u, 0x%x, %d, %p)", source, type, id, severity, length, buf));
	/* TODO: NFOSMESA_GLDEBUGMESSAGEINSERT may need conversion */
	fn.glDebugMessageInsert(source, type, id, severity, length, buf);
}

void OSMesaDriver::nfglDebugMessageInsertAMD(GLenum category, GLenum severity, GLuint id, GLsizei length, const GLchar *buf)
{
	D(bug("nfosmesa: glDebugMessageInsertAMD(0x%x, 0x%x, %u, %d, %p)", category, severity, id, length, buf));
	/* TODO: NFOSMESA_GLDEBUGMESSAGEINSERTAMD may need conversion */
	fn.glDebugMessageInsertAMD(category, severity, id, length, buf);
}

void OSMesaDriver::nfglDebugMessageInsertARB(GLenum source, GLenum type, GLuint id, GLenum severity, GLsizei length, const GLchar *buf)
{
	D(bug("nfosmesa: glDebugMessageInsertARB(0x%x, 0x%x, %u, 0x%x, %d, %p)", source, type, id, severity, length, buf));
	/* TODO: NFOSMESA_GLDEBUGMESSAGEINSERTARB may need conversion */
	fn.glDebugMessageInsertARB(source, type, id, severity, length, buf);
}

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

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)
{
	D(bug("nfosmesa: glDeformationMap3dSGIX(0x%x, %f, %f, %d, %d, %f, %f, %d, %d, %f, %f, %d, %d, %p)", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points));
	/* TODO: NFOSMESA_GLDEFORMATIONMAP3DSGIX may need conversion */
	fn.glDeformationMap3dSGIX(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points);
}

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)
{
	D(bug("nfosmesa: glDeformationMap3fSGIX(0x%x, %f, %f, %d, %d, %f, %f, %d, %d, %f, %f, %d, %d, %p)", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, w1, w2, wstride, worder, points));
	/* TODO: NFOSMESA_GLDEFORMATIONMAP3FSGIX may need conversion */
	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);
}

void OSMesaDriver::nfglDeleteBuffers(GLsizei n, const GLuint *buffers)
{
	D(bug("nfosmesa: glDeleteBuffers(%d, %p)", n, buffers));
	/* TODO: NFOSMESA_GLDELETEBUFFERS may need conversion */
	fn.glDeleteBuffers(n, buffers);
}

void OSMesaDriver::nfglDeleteBuffersARB(GLsizei n, const GLuint *buffers)
{
	D(bug("nfosmesa: glDeleteBuffersARB(%d, %p)", n, buffers));
	/* TODO: NFOSMESA_GLDELETEBUFFERSARB may need conversion */
	fn.glDeleteBuffersARB(n, buffers);
}

void OSMesaDriver::nfglDeleteFencesAPPLE(GLsizei n, const GLuint *fences)
{
	D(bug("nfosmesa: glDeleteFencesAPPLE(%d, %p)", n, fences));
	/* TODO: NFOSMESA_GLDELETEFENCESAPPLE may need conversion */
	fn.glDeleteFencesAPPLE(n, fences);
}

void OSMesaDriver::nfglDeleteFencesNV(GLsizei n, const GLuint *fences)
{
	D(bug("nfosmesa: glDeleteFencesNV(%d, %p)", n, fences));
	/* TODO: NFOSMESA_GLDELETEFENCESNV may need conversion */
	fn.glDeleteFencesNV(n, fences);
}

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

void OSMesaDriver::nfglDeleteFramebuffers(GLsizei n, const GLuint *framebuffers)
{
	D(bug("nfosmesa: glDeleteFramebuffers(%d, %p)", n, framebuffers));
	/* TODO: NFOSMESA_GLDELETEFRAMEBUFFERS may need conversion */
	fn.glDeleteFramebuffers(n, framebuffers);
}

void OSMesaDriver::nfglDeleteFramebuffersEXT(GLsizei n, const GLuint *framebuffers)
{
	D(bug("nfosmesa: glDeleteFramebuffersEXT(%d, %p)", n, framebuffers));
	/* TODO: NFOSMESA_GLDELETEFRAMEBUFFERSEXT may need conversion */
	fn.glDeleteFramebuffersEXT(n, framebuffers);
}

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

void OSMesaDriver::nfglDeleteNamedStringARB(GLint namelen, const GLchar *name)
{
	D(bug("nfosmesa: glDeleteNamedStringARB(%d, %p)", namelen, name));
	/* TODO: NFOSMESA_GLDELETENAMEDSTRINGARB may need conversion */
	fn.glDeleteNamedStringARB(namelen, name);
}

void OSMesaDriver::nfglDeleteNamesAMD(GLenum identifier, GLuint num, const GLuint *names)
{
	D(bug("nfosmesa: glDeleteNamesAMD(0x%x, %u, %p)", identifier, num, names));
	/* TODO: NFOSMESA_GLDELETENAMESAMD may need conversion */
	fn.glDeleteNamesAMD(identifier, num, names);
}

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

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

void OSMesaDriver::nfglDeleteOcclusionQueriesNV(GLsizei n, const GLuint *ids)
{
	D(bug("nfosmesa: glDeleteOcclusionQueriesNV(%d, %p)", n, ids));
	/* TODO: NFOSMESA_GLDELETEOCCLUSIONQUERIESNV may need conversion */
	fn.glDeleteOcclusionQueriesNV(n, ids);
}

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

void OSMesaDriver::nfglDeletePerfMonitorsAMD(GLsizei n, GLuint *monitors)
{
	D(bug("nfosmesa: glDeletePerfMonitorsAMD(%d, %p)", n, monitors));
	/* TODO: NFOSMESA_GLDELETEPERFMONITORSAMD may need conversion */
	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);
}

void OSMesaDriver::nfglDeleteProgramPipelines(GLsizei n, const GLuint *pipelines)
{
	D(bug("nfosmesa: glDeleteProgramPipelines(%d, %p)", n, pipelines));
	/* TODO: NFOSMESA_GLDELETEPROGRAMPIPELINES may need conversion */
	fn.glDeleteProgramPipelines(n, pipelines);
}

void OSMesaDriver::nfglDeleteProgramsARB(GLsizei n, const GLuint *programs)
{
	D(bug("nfosmesa: glDeleteProgramsARB(%d, %p)", n, programs));
	/* TODO: NFOSMESA_GLDELETEPROGRAMSARB may need conversion */
	fn.glDeleteProgramsARB(n, programs);
}

void OSMesaDriver::nfglDeleteProgramsNV(GLsizei n, const GLuint *programs)
{
	D(bug("nfosmesa: glDeleteProgramsNV(%d, %p)", n, programs));
	/* TODO: NFOSMESA_GLDELETEPROGRAMSNV may need conversion */
	fn.glDeleteProgramsNV(n, programs);
}

void OSMesaDriver::nfglDeleteQueries(GLsizei n, const GLuint *ids)
{
	D(bug("nfosmesa: glDeleteQueries(%d, %p)", n, ids));
	/* TODO: NFOSMESA_GLDELETEQUERIES may need conversion */
	fn.glDeleteQueries(n, ids);
}

void OSMesaDriver::nfglDeleteQueriesARB(GLsizei n, const GLuint *ids)
{
	D(bug("nfosmesa: glDeleteQueriesARB(%d, %p)", n, ids));
	/* TODO: NFOSMESA_GLDELETEQUERIESARB may need conversion */
	fn.glDeleteQueriesARB(n, ids);
}

void OSMesaDriver::nfglDeleteRenderbuffers(GLsizei n, const GLuint *renderbuffers)
{
	D(bug("nfosmesa: glDeleteRenderbuffers(%d, %p)", n, renderbuffers));
	/* TODO: NFOSMESA_GLDELETERENDERBUFFERS may need conversion */
	fn.glDeleteRenderbuffers(n, renderbuffers);
}

void OSMesaDriver::nfglDeleteRenderbuffersEXT(GLsizei n, const GLuint *renderbuffers)
{
	D(bug("nfosmesa: glDeleteRenderbuffersEXT(%d, %p)", n, renderbuffers));
	/* TODO: NFOSMESA_GLDELETERENDERBUFFERSEXT may need conversion */
	fn.glDeleteRenderbuffersEXT(n, renderbuffers);
}

void OSMesaDriver::nfglDeleteSamplers(GLsizei count, const GLuint *samplers)
{
	D(bug("nfosmesa: glDeleteSamplers(%d, %p)", count, samplers));
	/* TODO: NFOSMESA_GLDELETESAMPLERS may need conversion */
	fn.glDeleteSamplers(count, samplers);
}

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

void OSMesaDriver::nfglDeleteSync(GLsync sync)
{
	D(bug("nfosmesa: glDeleteSync(%p)", sync));
	fn.glDeleteSync(sync);
}

void OSMesaDriver::nfglDeleteTextures(GLsizei n, const GLuint *textures)
{
	D(bug("nfosmesa: glDeleteTextures(%d, %p)", n, textures));
FN_GLDELETETEXTURES(n, textures);
}

void OSMesaDriver::nfglDeleteTexturesEXT(GLsizei n, const GLuint *textures)
{
	D(bug("nfosmesa: glDeleteTexturesEXT(%d, %p)", n, textures));
FN_GLDELETETEXTURESEXT(n, textures);
}

void OSMesaDriver::nfglDeleteTransformFeedbacks(GLsizei n, const GLuint *ids)
{
	D(bug("nfosmesa: glDeleteTransformFeedbacks(%d, %p)", n, ids));
	/* TODO: NFOSMESA_GLDELETETRANSFORMFEEDBACKS may need conversion */
	fn.glDeleteTransformFeedbacks(n, ids);
}

void OSMesaDriver::nfglDeleteTransformFeedbacksNV(GLsizei n, const GLuint *ids)
{
	D(bug("nfosmesa: glDeleteTransformFeedbacksNV(%d, %p)", n, ids));
	/* TODO: NFOSMESA_GLDELETETRANSFORMFEEDBACKSNV may need conversion */
	fn.glDeleteTransformFeedbacksNV(n, ids);
}

void OSMesaDriver::nfglDeleteVertexArrays(GLsizei n, const GLuint *arrays)
{
	D(bug("nfosmesa: glDeleteVertexArrays(%d, %p)", n, arrays));
	/* TODO: NFOSMESA_GLDELETEVERTEXARRAYS may need conversion */
	fn.glDeleteVertexArrays(n, arrays);
}

void OSMesaDriver::nfglDeleteVertexArraysAPPLE(GLsizei n, const GLuint *arrays)
{
	D(bug("nfosmesa: glDeleteVertexArraysAPPLE(%d, %p)", n, arrays));
	/* TODO: NFOSMESA_GLDELETEVERTEXARRAYSAPPLE may need conversion */
	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(0x%x)", 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);
}

void OSMesaDriver::nfglDepthRangeArrayv(GLuint first, GLsizei count, const GLdouble *v)
{
	D(bug("nfosmesa: glDepthRangeArrayv(%u, %d, %p)", first, count, v));
	/* TODO: NFOSMESA_GLDEPTHRANGEARRAYV may need conversion */
	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)", containerObj, attachedObj));
	fn.glDetachObjectARB(containerObj, attachedObj);
}

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

void OSMesaDriver::nfglDetailTexFuncSGIS(GLenum target, GLsizei n, const GLfloat *points)
{
	D(bug("nfosmesa: glDetailTexFuncSGIS(0x%x, %d, %p)", target, n, points));
	/* TODO: NFOSMESA_GLDETAILTEXFUNCSGIS may need conversion */
	fn.glDetailTexFuncSGIS(target, n, points);
}

void OSMesaDriver::nfglDisable(GLenum cap)
{
	D(bug("nfosmesa: glDisable(0x%x)", cap));
	fn.glDisable(cap);
}

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

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

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

void OSMesaDriver::nfglDisableIndexedEXT(GLenum target, GLuint index)
{
	D(bug("nfosmesa: glDisableIndexedEXT(0x%x, %u)", 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::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, 0x%x)", vaobj, array));
	fn.glDisableVertexArrayEXT(vaobj, array);
}

void OSMesaDriver::nfglDisableVertexAttribAPPLE(GLuint index, GLenum pname)
{
	D(bug("nfosmesa: glDisableVertexAttribAPPLE(%u, 0x%x)", index, 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(0x%x, %u)", 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(%ld)", indirect));
	fn.glDispatchComputeIndirect(indirect);
}

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

void OSMesaDriver::nfglDrawArraysEXT(GLenum mode, GLint first, GLsizei count)
{
	D(bug("nfosmesa: glDrawArraysEXT(0x%x, %d, %d)", mode, first, count));
	fn.glDrawArraysEXT(mode, first, count);
}

void OSMesaDriver::nfglDrawArraysIndirect(GLenum mode, const void *indirect)
{
	D(bug("nfosmesa: glDrawArraysIndirect(0x%x, %p)", mode, indirect));
	/* TODO: NFOSMESA_GLDRAWARRAYSINDIRECT may need conversion */
	fn.glDrawArraysIndirect(mode, indirect);
}

void OSMesaDriver::nfglDrawArraysInstanced(GLenum mode, GLint first, GLsizei count, GLsizei instancecount)
{
	D(bug("nfosmesa: glDrawArraysInstanced(0x%x, %d, %d, %d)", 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(0x%x, %d, %d, %d)", 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(0x%x, %d, %d, %d, %u)", 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(0x%x, %d, %d, %d)", mode, start, count, primcount));
	fn.glDrawArraysInstancedEXT(mode, start, count, primcount);
}

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

void OSMesaDriver::nfglDrawBuffers(GLsizei n, const GLenum *bufs)
{
	D(bug("nfosmesa: glDrawBuffers(%d, %p)", n, bufs));
	/* TODO: NFOSMESA_GLDRAWBUFFERS may need conversion */
	fn.glDrawBuffers(n, bufs);
}

void OSMesaDriver::nfglDrawBuffersARB(GLsizei n, const GLenum *bufs)
{
	D(bug("nfosmesa: glDrawBuffersARB(%d, %p)", n, bufs));
	/* TODO: NFOSMESA_GLDRAWBUFFERSARB may need conversion */
	fn.glDrawBuffersARB(n, bufs);
}

void OSMesaDriver::nfglDrawBuffersATI(GLsizei n, const GLenum *bufs)
{
	D(bug("nfosmesa: glDrawBuffersATI(%d, %p)", n, bufs));
	/* TODO: NFOSMESA_GLDRAWBUFFERSATI may need conversion */
	fn.glDrawBuffersATI(n, bufs);
}

void OSMesaDriver::nfglDrawElementArrayAPPLE(GLenum mode, GLint first, GLsizei count)
{
	D(bug("nfosmesa: glDrawElementArrayAPPLE(0x%x, %d, %d)", mode, first, count));
	fn.glDrawElementArrayAPPLE(mode, first, count);
}

void OSMesaDriver::nfglDrawElementArrayATI(GLenum mode, GLsizei count)
{
	D(bug("nfosmesa: glDrawElementArrayATI(0x%x, %d)", mode, count));
	fn.glDrawElementArrayATI(mode, count);
}

void OSMesaDriver::nfglDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
{
	D(bug("nfosmesa: glDrawElements(0x%x, %d, 0x%x, %p)", mode, count, type, indices));
FN_GLDRAWELEMENTS(mode, count, type, indices);
}

void OSMesaDriver::nfglDrawElementsBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLint basevertex)
{
	D(bug("nfosmesa: glDrawElementsBaseVertex(0x%x, %d, 0x%x, %p, %d)", mode, count, type, indices, basevertex));
	/* TODO: NFOSMESA_GLDRAWELEMENTSBASEVERTEX may need conversion */
	fn.glDrawElementsBaseVertex(mode, count, type, indices, basevertex);
}

void OSMesaDriver::nfglDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect)
{
	D(bug("nfosmesa: glDrawElementsIndirect(0x%x, 0x%x, %p)", mode, type, indirect));
	/* TODO: NFOSMESA_GLDRAWELEMENTSINDIRECT may need conversion */
	fn.glDrawElementsIndirect(mode, type, indirect);
}

void OSMesaDriver::nfglDrawElementsInstanced(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount)
{
	D(bug("nfosmesa: glDrawElementsInstanced(0x%x, %d, 0x%x, %p, %d)", mode, count, type, indices, instancecount));
	/* TODO: NFOSMESA_GLDRAWELEMENTSINSTANCED may need conversion */
	fn.glDrawElementsInstanced(mode, count, type, indices, instancecount);
}

void OSMesaDriver::nfglDrawElementsInstancedARB(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount)
{
	D(bug("nfosmesa: glDrawElementsInstancedARB(0x%x, %d, 0x%x, %p, %d)", mode, count, type, indices, primcount));
	/* TODO: NFOSMESA_GLDRAWELEMENTSINSTANCEDARB may need conversion */
	fn.glDrawElementsInstancedARB(mode, count, type, indices, primcount);
}

void OSMesaDriver::nfglDrawElementsInstancedBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLuint baseinstance)
{
	D(bug("nfosmesa: glDrawElementsInstancedBaseInstance(0x%x, %d, 0x%x, %p, %d, %u)", mode, count, type, indices, instancecount, baseinstance));
	/* TODO: NFOSMESA_GLDRAWELEMENTSINSTANCEDBASEINSTANCE may need conversion */
	fn.glDrawElementsInstancedBaseInstance(mode, count, type, indices, instancecount, baseinstance);
}

void OSMesaDriver::nfglDrawElementsInstancedBaseVertex(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex)
{
	D(bug("nfosmesa: glDrawElementsInstancedBaseVertex(0x%x, %d, 0x%x, %p, %d, %d)", mode, count, type, indices, instancecount, basevertex));
	/* TODO: NFOSMESA_GLDRAWELEMENTSINSTANCEDBASEVERTEX may need conversion */
	fn.glDrawElementsInstancedBaseVertex(mode, count, type, indices, instancecount, basevertex);
}

void OSMesaDriver::nfglDrawElementsInstancedBaseVertexBaseInstance(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei instancecount, GLint basevertex, GLuint baseinstance)
{
	D(bug("nfosmesa: glDrawElementsInstancedBaseVertexBaseInstance(0x%x, %d, 0x%x, %p, %d, %d, %u)", mode, count, type, indices, instancecount, basevertex, baseinstance));
	/* TODO: NFOSMESA_GLDRAWELEMENTSINSTANCEDBASEVERTEXBASEINSTANCE may need conversion */
	fn.glDrawElementsInstancedBaseVertexBaseInstance(mode, count, type, indices, instancecount, basevertex, baseinstance);
}

void OSMesaDriver::nfglDrawElementsInstancedEXT(GLenum mode, GLsizei count, GLenum type, const void *indices, GLsizei primcount)
{
	D(bug("nfosmesa: glDrawElementsInstancedEXT(0x%x, %d, 0x%x, %p, %d)", mode, count, type, indices, primcount));
	/* TODO: NFOSMESA_GLDRAWELEMENTSINSTANCEDEXT may need conversion */
	fn.glDrawElementsInstancedEXT(mode, count, type, indices, primcount);
}

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

void OSMesaDriver::nfglDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
{
	D(bug("nfosmesa: glDrawPixels(%d, %d, 0x%x, 0x%x, %p)", width, height, format, type, pixels));
	/* TODO: NFOSMESA_GLDRAWPIXELS may need conversion */
	fn.glDrawPixels(width, height, format, type, pixels);
}

void OSMesaDriver::nfglDrawRangeElementArrayAPPLE(GLenum mode, GLuint start, GLuint end, GLint first, GLsizei count)
{
	D(bug("nfosmesa: glDrawRangeElementArrayAPPLE(0x%x, %u, %u, %d, %d)", 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(0x%x, %u, %u, %d)", mode, start, end, count));
	fn.glDrawRangeElementArrayATI(mode, start, end, count);
}

void OSMesaDriver::nfglDrawRangeElements(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices)
{
	D(bug("nfosmesa: glDrawRangeElements(0x%x, %u, %u, %d, 0x%x, %p)", mode, start, end, count, type, indices));
FN_GLDRAWRANGEELEMENTS(mode, start, end, count, type, indices);
}

void OSMesaDriver::nfglDrawRangeElementsBaseVertex(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices, GLint basevertex)
{
	D(bug("nfosmesa: glDrawRangeElementsBaseVertex(0x%x, %u, %u, %d, 0x%x, %p, %d)", mode, start, end, count, type, indices, basevertex));
	/* TODO: NFOSMESA_GLDRAWRANGEELEMENTSBASEVERTEX may need conversion */
	fn.glDrawRangeElementsBaseVertex(mode, start, end, count, type, indices, basevertex);
}

void OSMesaDriver::nfglDrawRangeElementsEXT(GLenum mode, GLuint start, GLuint end, GLsizei count, GLenum type, const void *indices)
{
	D(bug("nfosmesa: glDrawRangeElementsEXT(0x%x, %u, %u, %d, 0x%x, %p)", mode, start, end, count, type, indices));
	/* TODO: NFOSMESA_GLDRAWRANGEELEMENTSEXT may need conversion */
	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(0x%x, %u)", mode, id));
	fn.glDrawTransformFeedback(mode, id);
}

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

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

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

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

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);
}

void OSMesaDriver::nfglEdgeFlagPointer(GLsizei stride, const GLvoid *pointer)
{
	D(bug("nfosmesa: glEdgeFlagPointer(%d, %p)", stride, pointer));
FN_GLEDGEFLAGPOINTER(stride, pointer);
}

void OSMesaDriver::nfglEdgeFlagPointerEXT(GLsizei stride, GLsizei count, const GLboolean *pointer)
{
	D(bug("nfosmesa: glEdgeFlagPointerEXT(%d, %d, %p)", stride, count, pointer));
	/* TODO: NFOSMESA_GLEDGEFLAGPOINTEREXT may need conversion */
	fn.glEdgeFlagPointerEXT(stride, count, pointer);
}

void OSMesaDriver::nfglEdgeFlagPointerListIBM(GLint stride, const GLboolean * *pointer, GLint ptrstride)
{
	D(bug("nfosmesa: glEdgeFlagPointerListIBM(%d, %p, %d)", stride, pointer, ptrstride));
	/* TODO: NFOSMESA_GLEDGEFLAGPOINTERLISTIBM may need conversion */
	fn.glEdgeFlagPointerListIBM(stride, pointer, ptrstride);
}

void OSMesaDriver::nfglEdgeFlagv(const GLboolean *flag)
{
	D(bug("nfosmesa: glEdgeFlagv(%p)", flag));
	/* TODO: NFOSMESA_GLEDGEFLAGV may need conversion */
	fn.glEdgeFlagv(flag);
}

void OSMesaDriver::nfglElementPointerAPPLE(GLenum type, const void *pointer)
{
	D(bug("nfosmesa: glElementPointerAPPLE(0x%x, %p)", type, pointer));
	/* TODO: NFOSMESA_GLELEMENTPOINTERAPPLE may need conversion */
	fn.glElementPointerAPPLE(type, pointer);
}

void OSMesaDriver::nfglElementPointerATI(GLenum type, const void *pointer)
{
	D(bug("nfosmesa: glElementPointerATI(0x%x, %p)", type, pointer));
	/* TODO: NFOSMESA_GLELEMENTPOINTERATI may need conversion */
	fn.glElementPointerATI(type, pointer);
}

void OSMesaDriver::nfglEnable(GLenum cap)
{
	D(bug("nfosmesa: glEnable(0x%x)", cap));
	fn.glEnable(cap);
}

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

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

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

void OSMesaDriver::nfglEnableIndexedEXT(GLenum target, GLuint index)
{
	D(bug("nfosmesa: glEnableIndexedEXT(0x%x, %u)", 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::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, 0x%x)", vaobj, array));
	fn.glEnableVertexArrayEXT(vaobj, array);
}

void OSMesaDriver::nfglEnableVertexAttribAPPLE(GLuint index, GLenum pname)
{
	D(bug("nfosmesa: glEnableVertexAttribAPPLE(%u, 0x%x)", index, 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(0x%x, %u)", 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(0x%x)", target));
	fn.glEndQuery(target);
}

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

void OSMesaDriver::nfglEndQueryIndexed(GLenum target, GLuint index)
{
	D(bug("nfosmesa: glEndQueryIndexed(0x%x, %u)", 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);
}

void OSMesaDriver::nfglEvalCoord1dv(const GLdouble *u)
{
	D(bug("nfosmesa: glEvalCoord1dv(%p)", u));
FN_GLEVALCOORD1DV(u);
}

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

void OSMesaDriver::nfglEvalCoord1fv(const GLfloat *u)
{
	D(bug("nfosmesa: glEvalCoord1fv(%p)", u));
FN_GLEVALCOORD1FV(u);
}

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

void OSMesaDriver::nfglEvalCoord1xvOES(const GLfixed *coords)
{
	D(bug("nfosmesa: glEvalCoord1xvOES(%p)", coords));
	/* TODO: NFOSMESA_GLEVALCOORD1XVOES may need conversion */
	fn.glEvalCoord1xvOES(coords);
}

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

void OSMesaDriver::nfglEvalCoord2dv(const GLdouble *u)
{
	D(bug("nfosmesa: glEvalCoord2dv(%p)", u));
FN_GLEVALCOORD2DV(u);
}

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

void OSMesaDriver::nfglEvalCoord2fv(const GLfloat *u)
{
	D(bug("nfosmesa: glEvalCoord2fv(%p)", 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);
}

void OSMesaDriver::nfglEvalCoord2xvOES(const GLfixed *coords)
{
	D(bug("nfosmesa: glEvalCoord2xvOES(%p)", coords));
	/* TODO: NFOSMESA_GLEVALCOORD2XVOES may need conversion */
	fn.glEvalCoord2xvOES(coords);
}

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

void OSMesaDriver::nfglEvalMesh1(GLenum mode, GLint i1, GLint i2)
{
	D(bug("nfosmesa: glEvalMesh1(0x%x, %d, %d)", 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(0x%x, %d, %d, %d, %d)", 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::nfglExecuteProgramNV(GLenum target, GLuint id, const GLfloat *params)
{
	D(bug("nfosmesa: glExecuteProgramNV(0x%x, %u, %p)", target, id, params));
	/* TODO: NFOSMESA_GLEXECUTEPROGRAMNV may need conversion */
	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);
}

void OSMesaDriver::nfglFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
{
	D(bug("nfosmesa: glFeedbackBuffer(%d, 0x%x, %p)", size, type, buffer));
	/* TODO: NFOSMESA_GLFEEDBACKBUFFER may need conversion */
	fn.glFeedbackBuffer(size, type, buffer);
}

void OSMesaDriver::nfglFeedbackBufferxOES(GLsizei n, GLenum type, const GLfixed *buffer)
{
	D(bug("nfosmesa: glFeedbackBufferxOES(%d, 0x%x, %p)", n, type, buffer));
	/* TODO: NFOSMESA_GLFEEDBACKBUFFERXOES may need conversion */
	fn.glFeedbackBufferxOES(n, type, buffer);
}

#if 0
GLsync OSMesaDriver::nfglFenceSync(GLenum condition, GLbitfield flags)
{
	D(bug("nfosmesa: glFenceSync(0x%x, 0x%x)", condition, flags));
	return fn.glFenceSync(condition, flags);
}
#endif

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

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

GLint OSMesaDriver::nfglFinishAsyncSGIX(GLuint *markerp)
{
	D(bug("nfosmesa: glFinishAsyncSGIX(%p)", markerp));
	/* TODO: NFOSMESA_GLFINISHASYNCSGIX may need conversion */
	return 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(0x%x, %u)", 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(0x%x, %ld, %ld)", target, offset, length));
	fn.glFlushMappedBufferRange(target, offset, length);
}

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

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

void OSMesaDriver::nfglFlushPixelDataRangeNV(GLenum target)
{
	D(bug("nfosmesa: glFlushPixelDataRangeNV(0x%x)", 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(0x%x)", target));
	fn.glFlushStaticDataIBM(target);
}

void OSMesaDriver::nfglFlushVertexArrayRangeAPPLE(GLsizei length, void *pointer)
{
	D(bug("nfosmesa: glFlushVertexArrayRangeAPPLE(%d, %p)", length, pointer));
	/* TODO: NFOSMESA_GLFLUSHVERTEXARRAYRANGEAPPLE may need conversion */
	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(0x%x, %d)", type, stride));
	fn.glFogCoordFormatNV(type, stride);
}

void OSMesaDriver::nfglFogCoordPointer(GLenum type, GLsizei stride, const void *pointer)
{
	D(bug("nfosmesa: glFogCoordPointer(0x%x, %d, %p)", type, stride, pointer));
	/* TODO: NFOSMESA_GLFOGCOORDPOINTER may need conversion */
	fn.glFogCoordPointer(type, stride, pointer);
}

void OSMesaDriver::nfglFogCoordPointerEXT(GLenum type, GLsizei stride, const void *pointer)
{
	D(bug("nfosmesa: glFogCoordPointerEXT(0x%x, %d, %p)", type, stride, pointer));
	/* TODO: NFOSMESA_GLFOGCOORDPOINTEREXT may need conversion */
	fn.glFogCoordPointerEXT(type, stride, pointer);
}

void OSMesaDriver::nfglFogCoordPointerListIBM(GLenum type, GLint stride, const void * *pointer, GLint ptrstride)
{
	D(bug("nfosmesa: glFogCoordPointerListIBM(0x%x, %d, %p, %d)", type, stride, pointer, ptrstride));
	/* TODO: NFOSMESA_GLFOGCOORDPOINTERLISTIBM may need conversion */
	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);
}

void OSMesaDriver::nfglFogCoorddv(const GLdouble *coord)
{
	D(bug("nfosmesa: glFogCoorddv(%p)", coord));
	/* TODO: NFOSMESA_GLFOGCOORDDV may need conversion */
	fn.glFogCoorddv(coord);
}

void OSMesaDriver::nfglFogCoorddvEXT(const GLdouble *coord)
{
	D(bug("nfosmesa: glFogCoorddvEXT(%p)", coord));
	/* TODO: NFOSMESA_GLFOGCOORDDVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglFogCoordfv(const GLfloat *coord)
{
	D(bug("nfosmesa: glFogCoordfv(%p)", coord));
	/* TODO: NFOSMESA_GLFOGCOORDFV may need conversion */
	fn.glFogCoordfv(coord);
}

void OSMesaDriver::nfglFogCoordfvEXT(const GLfloat *coord)
{
	D(bug("nfosmesa: glFogCoordfvEXT(%p)", coord));
	/* TODO: NFOSMESA_GLFOGCOORDFVEXT may need conversion */
	fn.glFogCoordfvEXT(coord);
}

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

void OSMesaDriver::nfglFogCoordhvNV(const GLhalfNV *fog)
{
	D(bug("nfosmesa: glFogCoordhvNV(%p)", fog));
FN_GLFOGCOORDHVNV(fog);
}

void OSMesaDriver::nfglFogFuncSGIS(GLsizei n, const GLfloat *points)
{
	D(bug("nfosmesa: glFogFuncSGIS(%d, %p)", n, points));
	/* TODO: NFOSMESA_GLFOGFUNCSGIS may need conversion */
	fn.glFogFuncSGIS(n, points);
}

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

void OSMesaDriver::nfglFogfv(GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glFogfv(0x%x, %p)", pname, params));
FN_GLFOGFV(pname, params);
}

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

void OSMesaDriver::nfglFogiv(GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glFogiv(0x%x, %p)", pname, params));
FN_GLFOGIV(pname, params);
}

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

void OSMesaDriver::nfglFogxvOES(GLenum pname, const GLfixed *param)
{
	D(bug("nfosmesa: glFogxvOES(0x%x, %p)", pname, param));
	/* TODO: NFOSMESA_GLFOGXVOES may need conversion */
	fn.glFogxvOES(pname, param);
}

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

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

void OSMesaDriver::nfglFragmentLightModelfvSGIX(GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glFragmentLightModelfvSGIX(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLFRAGMENTLIGHTMODELFVSGIX may need conversion */
	fn.glFragmentLightModelfvSGIX(pname, params);
}

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

void OSMesaDriver::nfglFragmentLightModelivSGIX(GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glFragmentLightModelivSGIX(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLFRAGMENTLIGHTMODELIVSGIX may need conversion */
	fn.glFragmentLightModelivSGIX(pname, params);
}

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

void OSMesaDriver::nfglFragmentLightfvSGIX(GLenum light, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glFragmentLightfvSGIX(0x%x, 0x%x, %p)", light, pname, params));
	/* TODO: NFOSMESA_GLFRAGMENTLIGHTFVSGIX may need conversion */
	fn.glFragmentLightfvSGIX(light, pname, params);
}

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

void OSMesaDriver::nfglFragmentLightivSGIX(GLenum light, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glFragmentLightivSGIX(0x%x, 0x%x, %p)", light, pname, params));
	/* TODO: NFOSMESA_GLFRAGMENTLIGHTIVSGIX may need conversion */
	fn.glFragmentLightivSGIX(light, pname, params);
}

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

void OSMesaDriver::nfglFragmentMaterialfvSGIX(GLenum face, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glFragmentMaterialfvSGIX(0x%x, 0x%x, %p)", face, pname, params));
	/* TODO: NFOSMESA_GLFRAGMENTMATERIALFVSGIX may need conversion */
	fn.glFragmentMaterialfvSGIX(face, pname, params);
}

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

void OSMesaDriver::nfglFragmentMaterialivSGIX(GLenum face, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glFragmentMaterialivSGIX(0x%x, 0x%x, %p)", face, pname, params));
	/* TODO: NFOSMESA_GLFRAGMENTMATERIALIVSGIX may need conversion */
	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, 0x%x)", framebuffer, mode));
	fn.glFramebufferDrawBufferEXT(framebuffer, mode);
}

void OSMesaDriver::nfglFramebufferDrawBuffersEXT(GLuint framebuffer, GLsizei n, const GLenum *bufs)
{
	D(bug("nfosmesa: glFramebufferDrawBuffersEXT(%u, %d, %p)", framebuffer, n, bufs));
	/* TODO: NFOSMESA_GLFRAMEBUFFERDRAWBUFFERSEXT may need conversion */
	fn.glFramebufferDrawBuffersEXT(framebuffer, n, bufs);
}

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

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

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

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

void OSMesaDriver::nfglFramebufferTexture(GLenum target, GLenum attachment, GLuint texture, GLint level)
{
	D(bug("nfosmesa: glFramebufferTexture(0x%x, 0x%x, %u, %d)", target, 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(0x%x, 0x%x, 0x%x, %u, %d)", target, attachment, 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(0x%x, 0x%x, 0x%x, %u, %d)", target, attachment, 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(0x%x, 0x%x, 0x%x, %u, %d)", target, attachment, 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(0x%x, 0x%x, 0x%x, %u, %d)", target, attachment, 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(0x%x, 0x%x, 0x%x, %u, %d, %d)", target, attachment, 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(0x%x, 0x%x, 0x%x, %u, %d, %d)", target, attachment, 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(0x%x, 0x%x, %u, %d)", target, attachment, texture, level));
	fn.glFramebufferTextureARB(target, attachment, texture, level);
}

void OSMesaDriver::nfglFramebufferTextureEXT(GLenum target, GLenum attachment, GLuint texture, GLint level)
{
	D(bug("nfosmesa: glFramebufferTextureEXT(0x%x, 0x%x, %u, %d)", target, 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(0x%x, 0x%x, %u, %d, 0x%x)", target, attachment, texture, level, 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(0x%x, 0x%x, %u, %d, 0x%x)", target, attachment, texture, level, 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(0x%x, 0x%x, %u, %d, %d)", target, 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(0x%x, 0x%x, %u, %d, %d)", target, 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(0x%x, 0x%x, %u, %d, %d)", target, attachment, texture, level, layer));
	fn.glFramebufferTextureLayerEXT(target, attachment, texture, level, layer);
}

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

void OSMesaDriver::nfglFrontFace(GLenum mode)
{
	D(bug("nfosmesa: glFrontFace(0x%x)", 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));
	return fn.glGenAsyncMarkersSGIX(range);
}

void OSMesaDriver::nfglGenBuffers(GLsizei n, GLuint *buffers)
{
	D(bug("nfosmesa: glGenBuffers(%d, %p)", n, buffers));
	/* TODO: NFOSMESA_GLGENBUFFERS may need conversion */
	fn.glGenBuffers(n, buffers);
}

void OSMesaDriver::nfglGenBuffersARB(GLsizei n, GLuint *buffers)
{
	D(bug("nfosmesa: glGenBuffersARB(%d, %p)", n, buffers));
	/* TODO: NFOSMESA_GLGENBUFFERSARB may need conversion */
	fn.glGenBuffersARB(n, buffers);
}

void OSMesaDriver::nfglGenFencesAPPLE(GLsizei n, GLuint *fences)
{
	D(bug("nfosmesa: glGenFencesAPPLE(%d, %p)", n, fences));
	/* TODO: NFOSMESA_GLGENFENCESAPPLE may need conversion */
	fn.glGenFencesAPPLE(n, fences);
}

void OSMesaDriver::nfglGenFencesNV(GLsizei n, GLuint *fences)
{
	D(bug("nfosmesa: glGenFencesNV(%d, %p)", n, fences));
	/* TODO: NFOSMESA_GLGENFENCESNV may need conversion */
	fn.glGenFencesNV(n, fences);
}

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

void OSMesaDriver::nfglGenFramebuffers(GLsizei n, GLuint *framebuffers)
{
	D(bug("nfosmesa: glGenFramebuffers(%d, %p)", n, framebuffers));
	/* TODO: NFOSMESA_GLGENFRAMEBUFFERS may need conversion */
	fn.glGenFramebuffers(n, framebuffers);
}

void OSMesaDriver::nfglGenFramebuffersEXT(GLsizei n, GLuint *framebuffers)
{
	D(bug("nfosmesa: glGenFramebuffersEXT(%d, %p)", n, framebuffers));
	/* TODO: NFOSMESA_GLGENFRAMEBUFFERSEXT may need conversion */
	fn.glGenFramebuffersEXT(n, framebuffers);
}

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

void OSMesaDriver::nfglGenNamesAMD(GLenum identifier, GLuint num, GLuint *names)
{
	D(bug("nfosmesa: glGenNamesAMD(0x%x, %u, %p)", identifier, num, names));
	/* TODO: NFOSMESA_GLGENNAMESAMD may need conversion */
	fn.glGenNamesAMD(identifier, num, names);
}

void OSMesaDriver::nfglGenOcclusionQueriesNV(GLsizei n, GLuint *ids)
{
	D(bug("nfosmesa: glGenOcclusionQueriesNV(%d, %p)", n, ids));
	/* TODO: NFOSMESA_GLGENOCCLUSIONQUERIESNV may need conversion */
	fn.glGenOcclusionQueriesNV(n, ids);
}

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

void OSMesaDriver::nfglGenPerfMonitorsAMD(GLsizei n, GLuint *monitors)
{
	D(bug("nfosmesa: glGenPerfMonitorsAMD(%d, %p)", n, monitors));
	/* TODO: NFOSMESA_GLGENPERFMONITORSAMD may need conversion */
	fn.glGenPerfMonitorsAMD(n, monitors);
}

void OSMesaDriver::nfglGenProgramPipelines(GLsizei n, GLuint *pipelines)
{
	D(bug("nfosmesa: glGenProgramPipelines(%d, %p)", n, pipelines));
	/* TODO: NFOSMESA_GLGENPROGRAMPIPELINES may need conversion */
	fn.glGenProgramPipelines(n, pipelines);
}

void OSMesaDriver::nfglGenProgramsARB(GLsizei n, GLuint *programs)
{
	D(bug("nfosmesa: glGenProgramsARB(%d, %p)", n, programs));
	/* TODO: NFOSMESA_GLGENPROGRAMSARB may need conversion */
	fn.glGenProgramsARB(n, programs);
}

void OSMesaDriver::nfglGenProgramsNV(GLsizei n, GLuint *programs)
{
	D(bug("nfosmesa: glGenProgramsNV(%d, %p)", n, programs));
	/* TODO: NFOSMESA_GLGENPROGRAMSNV may need conversion */
	fn.glGenProgramsNV(n, programs);
}

void OSMesaDriver::nfglGenQueries(GLsizei n, GLuint *ids)
{
	D(bug("nfosmesa: glGenQueries(%d, %p)", n, ids));
	/* TODO: NFOSMESA_GLGENQUERIES may need conversion */
	fn.glGenQueries(n, ids);
}

void OSMesaDriver::nfglGenQueriesARB(GLsizei n, GLuint *ids)
{
	D(bug("nfosmesa: glGenQueriesARB(%d, %p)", n, ids));
	/* TODO: NFOSMESA_GLGENQUERIESARB may need conversion */
	fn.glGenQueriesARB(n, ids);
}

void OSMesaDriver::nfglGenRenderbuffers(GLsizei n, GLuint *renderbuffers)
{
	D(bug("nfosmesa: glGenRenderbuffers(%d, %p)", n, renderbuffers));
	/* TODO: NFOSMESA_GLGENRENDERBUFFERS may need conversion */
	fn.glGenRenderbuffers(n, renderbuffers);
}

void OSMesaDriver::nfglGenRenderbuffersEXT(GLsizei n, GLuint *renderbuffers)
{
	D(bug("nfosmesa: glGenRenderbuffersEXT(%d, %p)", n, renderbuffers));
	/* TODO: NFOSMESA_GLGENRENDERBUFFERSEXT may need conversion */
	fn.glGenRenderbuffersEXT(n, renderbuffers);
}

void OSMesaDriver::nfglGenSamplers(GLsizei count, GLuint *samplers)
{
	D(bug("nfosmesa: glGenSamplers(%d, %p)", count, samplers));
	/* TODO: NFOSMESA_GLGENSAMPLERS may need conversion */
	fn.glGenSamplers(count, samplers);
}

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

void OSMesaDriver::nfglGenTextures(GLsizei n, GLuint *textures)
{
	D(bug("nfosmesa: glGenTextures(%d, %p)", n, textures));
FN_GLGENTEXTURES(n, textures);
}

void OSMesaDriver::nfglGenTexturesEXT(GLsizei n, GLuint *textures)
{
	D(bug("nfosmesa: glGenTexturesEXT(%d, %p)", n, textures));
	/* TODO: NFOSMESA_GLGENTEXTURESEXT may need conversion */
	fn.glGenTexturesEXT(n, textures);
}

void OSMesaDriver::nfglGenTransformFeedbacks(GLsizei n, GLuint *ids)
{
	D(bug("nfosmesa: glGenTransformFeedbacks(%d, %p)", n, ids));
	/* TODO: NFOSMESA_GLGENTRANSFORMFEEDBACKS may need conversion */
	fn.glGenTransformFeedbacks(n, ids);
}

void OSMesaDriver::nfglGenTransformFeedbacksNV(GLsizei n, GLuint *ids)
{
	D(bug("nfosmesa: glGenTransformFeedbacksNV(%d, %p)", n, ids));
	/* TODO: NFOSMESA_GLGENTRANSFORMFEEDBACKSNV may need conversion */
	fn.glGenTransformFeedbacksNV(n, ids);
}

void OSMesaDriver::nfglGenVertexArrays(GLsizei n, GLuint *arrays)
{
	D(bug("nfosmesa: glGenVertexArrays(%d, %p)", n, arrays));
	/* TODO: NFOSMESA_GLGENVERTEXARRAYS may need conversion */
	fn.glGenVertexArrays(n, arrays);
}

void OSMesaDriver::nfglGenVertexArraysAPPLE(GLsizei n, GLuint *arrays)
{
	D(bug("nfosmesa: glGenVertexArraysAPPLE(%d, %p)", n, arrays));
	/* TODO: NFOSMESA_GLGENVERTEXARRAYSAPPLE may need conversion */
	fn.glGenVertexArraysAPPLE(n, arrays);
}

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

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

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

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

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

void OSMesaDriver::nfglGetActiveAtomicCounterBufferiv(GLuint program, GLuint bufferIndex, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetActiveAtomicCounterBufferiv(%u, %u, 0x%x, %p)", program, bufferIndex, pname, params));
	/* TODO: NFOSMESA_GLGETACTIVEATOMICCOUNTERBUFFERIV may need conversion */
	fn.glGetActiveAtomicCounterBufferiv(program, bufferIndex, pname, params);
}

void OSMesaDriver::nfglGetActiveAttrib(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
{
	D(bug("nfosmesa: glGetActiveAttrib(%u, %u, %d, %p, %p, %p, %p)", program, index, bufSize, length, size, type, name));
	/* TODO: NFOSMESA_GLGETACTIVEATTRIB may need conversion */
	fn.glGetActiveAttrib(program, index, bufSize, length, size, type, name);
}

void OSMesaDriver::nfglGetActiveAttribARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name)
{
	D(bug("nfosmesa: glGetActiveAttribARB(%u, %u, %d, %p, %p, %p, %p)", programObj, index, maxLength, length, size, type, name));
	/* TODO: NFOSMESA_GLGETACTIVEATTRIBARB may need conversion */
	fn.glGetActiveAttribARB(programObj, index, maxLength, length, size, type, name);
}

void OSMesaDriver::nfglGetActiveSubroutineName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
{
	D(bug("nfosmesa: glGetActiveSubroutineName(%u, 0x%x, %u, %d, %p, %p)", program, shadertype, index, bufsize, length, name));
	/* TODO: NFOSMESA_GLGETACTIVESUBROUTINENAME may need conversion */
	fn.glGetActiveSubroutineName(program, shadertype, index, bufsize, length, name);
}

void OSMesaDriver::nfglGetActiveSubroutineUniformName(GLuint program, GLenum shadertype, GLuint index, GLsizei bufsize, GLsizei *length, GLchar *name)
{
	D(bug("nfosmesa: glGetActiveSubroutineUniformName(%u, 0x%x, %u, %d, %p, %p)", program, shadertype, index, bufsize, length, name));
	/* TODO: NFOSMESA_GLGETACTIVESUBROUTINEUNIFORMNAME may need conversion */
	fn.glGetActiveSubroutineUniformName(program, shadertype, index, bufsize, length, name);
}

void OSMesaDriver::nfglGetActiveSubroutineUniformiv(GLuint program, GLenum shadertype, GLuint index, GLenum pname, GLint *values)
{
	D(bug("nfosmesa: glGetActiveSubroutineUniformiv(%u, 0x%x, %u, 0x%x, %p)", program, shadertype, index, pname, values));
	/* TODO: NFOSMESA_GLGETACTIVESUBROUTINEUNIFORMIV may need conversion */
	fn.glGetActiveSubroutineUniformiv(program, shadertype, index, pname, values);
}

void OSMesaDriver::nfglGetActiveUniform(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLint *size, GLenum *type, GLchar *name)
{
	D(bug("nfosmesa: glGetActiveUniform(%u, %u, %d, %p, %p, %p, %p)", program, index, bufSize, length, size, type, name));
	/* TODO: NFOSMESA_GLGETACTIVEUNIFORM may need conversion */
	fn.glGetActiveUniform(program, index, bufSize, length, size, type, name);
}

void OSMesaDriver::nfglGetActiveUniformARB(GLhandleARB programObj, GLuint index, GLsizei maxLength, GLsizei *length, GLint *size, GLenum *type, GLcharARB *name)
{
	D(bug("nfosmesa: glGetActiveUniformARB(%u, %u, %d, %p, %p, %p, %p)", programObj, index, maxLength, length, size, type, name));
	/* TODO: NFOSMESA_GLGETACTIVEUNIFORMARB may need conversion */
	fn.glGetActiveUniformARB(programObj, index, maxLength, length, size, type, name);
}

GLuint OSMesaDriver::nfglGetActiveUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
{
	D(bug("nfosmesa: glGetActiveUniformBlockIndex(%u, %p)", program, uniformBlockName));
	/* TODO: NFOSMESA_GLGETACTIVEUNIFORMBLOCKINDEX may need conversion */
	return fn.glGetActiveUniformBlockIndex(program, uniformBlockName);
}

void OSMesaDriver::nfglGetActiveUniformBlockName(GLuint program, GLuint uniformBlockIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformBlockName)
{
	D(bug("nfosmesa: glGetActiveUniformBlockName(%u, %u, %d, %p, %p)", program, uniformBlockIndex, bufSize, length, uniformBlockName));
	/* TODO: NFOSMESA_GLGETACTIVEUNIFORMBLOCKNAME may need conversion */
	fn.glGetActiveUniformBlockName(program, uniformBlockIndex, bufSize, length, uniformBlockName);
}

void OSMesaDriver::nfglGetActiveUniformBlockiv(GLuint program, GLuint uniformBlockIndex, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetActiveUniformBlockiv(%u, %u, 0x%x, %p)", program, uniformBlockIndex, pname, params));
	/* TODO: NFOSMESA_GLGETACTIVEUNIFORMBLOCKIV may need conversion */
	fn.glGetActiveUniformBlockiv(program, uniformBlockIndex, pname, params);
}

void OSMesaDriver::nfglGetActiveUniformName(GLuint program, GLuint uniformIndex, GLsizei bufSize, GLsizei *length, GLchar *uniformName)
{
	D(bug("nfosmesa: glGetActiveUniformName(%u, %u, %d, %p, %p)", program, uniformIndex, bufSize, length, uniformName));
	/* TODO: NFOSMESA_GLGETACTIVEUNIFORMNAME may need conversion */
	fn.glGetActiveUniformName(program, uniformIndex, bufSize, length, uniformName);
}

void OSMesaDriver::nfglGetActiveUniformsiv(GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetActiveUniformsiv(%u, %d, %p, 0x%x, %p)", program, uniformCount, uniformIndices, pname, params));
	/* TODO: NFOSMESA_GLGETACTIVEUNIFORMSIV may need conversion */
	fn.glGetActiveUniformsiv(program, uniformCount, uniformIndices, pname, params);
}

void OSMesaDriver::nfglGetActiveVaryingNV(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
{
	D(bug("nfosmesa: glGetActiveVaryingNV(%u, %u, %d, %p, %p, %p, %p)", program, index, bufSize, length, size, type, name));
	/* TODO: NFOSMESA_GLGETACTIVEVARYINGNV may need conversion */
	fn.glGetActiveVaryingNV(program, index, bufSize, length, size, type, name);
}

void OSMesaDriver::nfglGetArrayObjectfvATI(GLenum array, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetArrayObjectfvATI(0x%x, 0x%x, %p)", array, pname, params));
	/* TODO: NFOSMESA_GLGETARRAYOBJECTFVATI may need conversion */
	fn.glGetArrayObjectfvATI(array, pname, params);
}

void OSMesaDriver::nfglGetArrayObjectivATI(GLenum array, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetArrayObjectivATI(0x%x, 0x%x, %p)", array, pname, params));
	/* TODO: NFOSMESA_GLGETARRAYOBJECTIVATI may need conversion */
	fn.glGetArrayObjectivATI(array, pname, params);
}

void OSMesaDriver::nfglGetAttachedObjectsARB(GLhandleARB containerObj, GLsizei maxCount, GLsizei *count, GLhandleARB *obj)
{
	D(bug("nfosmesa: glGetAttachedObjectsARB(%u, %d, %p, %p)", containerObj, maxCount, count, obj));
	/* TODO: NFOSMESA_GLGETATTACHEDOBJECTSARB may need conversion */
	fn.glGetAttachedObjectsARB(containerObj, maxCount, count, obj);
}

void OSMesaDriver::nfglGetAttachedShaders(GLuint program, GLsizei maxCount, GLsizei *count, GLuint *shaders)
{
	D(bug("nfosmesa: glGetAttachedShaders(%u, %d, %p, %p)", program, maxCount, count, shaders));
	/* TODO: NFOSMESA_GLGETATTACHEDSHADERS may need conversion */
	fn.glGetAttachedShaders(program, maxCount, count, shaders);
}

GLint OSMesaDriver::nfglGetAttribLocation(GLuint program, const GLchar *name)
{
	D(bug("nfosmesa: glGetAttribLocation(%u, %p)", program, name));
	/* TODO: NFOSMESA_GLGETATTRIBLOCATION may need conversion */
	return fn.glGetAttribLocation(program, name);
}

GLint OSMesaDriver::nfglGetAttribLocationARB(GLhandleARB programObj, const GLcharARB *name)
{
	D(bug("nfosmesa: glGetAttribLocationARB(%u, %p)", programObj, name));
	/* TODO: NFOSMESA_GLGETATTRIBLOCATIONARB may need conversion */
	return fn.glGetAttribLocationARB(programObj, name);
}

void OSMesaDriver::nfglGetBooleanIndexedvEXT(GLenum target, GLuint index, GLboolean *data)
{
	D(bug("nfosmesa: glGetBooleanIndexedvEXT(0x%x, %u, %p)", target, index, data));
	fn.glGetBooleanIndexedvEXT(target, index, data);
}

void OSMesaDriver::nfglGetBooleani_v(GLenum target, GLuint index, GLboolean *data)
{
	D(bug("nfosmesa: glGetBooleani_v(0x%x, %u, %p)", target, index, data));
	fn.glGetBooleani_v(target, index, data);
}

void OSMesaDriver::nfglGetBooleanv(GLenum pname, GLboolean *params)
{
	D(bug("nfosmesa: glGetBooleanv(0x%x, %p)", pname, params));
	fn.glGetBooleanv(pname, params);
}

void OSMesaDriver::nfglGetBufferParameteri64v(GLenum target, GLenum pname, GLint64 *params)
{
	D(bug("nfosmesa: glGetBufferParameteri64v(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETBUFFERPARAMETERI64V may need conversion */
	fn.glGetBufferParameteri64v(target, pname, params);
}

void OSMesaDriver::nfglGetBufferParameteriv(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetBufferParameteriv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETBUFFERPARAMETERIV may need conversion */
	fn.glGetBufferParameteriv(target, pname, params);
}

void OSMesaDriver::nfglGetBufferParameterivARB(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetBufferParameterivARB(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETBUFFERPARAMETERIVARB may need conversion */
	fn.glGetBufferParameterivARB(target, pname, params);
}

void OSMesaDriver::nfglGetBufferParameterui64vNV(GLenum target, GLenum pname, GLuint64EXT *params)
{
	D(bug("nfosmesa: glGetBufferParameterui64vNV(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETBUFFERPARAMETERUI64VNV may need conversion */
	fn.glGetBufferParameterui64vNV(target, pname, params);
}

void OSMesaDriver::nfglGetBufferPointerv(GLenum target, GLenum pname, void * *params)
{
	D(bug("nfosmesa: glGetBufferPointerv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETBUFFERPOINTERV may need conversion */
	fn.glGetBufferPointerv(target, pname, params);
}

void OSMesaDriver::nfglGetBufferPointervARB(GLenum target, GLenum pname, void * *params)
{
	D(bug("nfosmesa: glGetBufferPointervARB(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETBUFFERPOINTERVARB may need conversion */
	fn.glGetBufferPointervARB(target, pname, params);
}

void OSMesaDriver::nfglGetBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, void *data)
{
	D(bug("nfosmesa: glGetBufferSubData(0x%x, %ld, %ld, %p)", target, offset, size, data));
	/* TODO: NFOSMESA_GLGETBUFFERSUBDATA may need conversion */
	fn.glGetBufferSubData(target, offset, size, data);
}

void OSMesaDriver::nfglGetBufferSubDataARB(GLenum target, GLintptrARB offset, GLsizeiptrARB size, void *data)
{
	D(bug("nfosmesa: glGetBufferSubDataARB(0x%x, %ld, %ld, %p)", target, offset, size, data));
	/* TODO: NFOSMESA_GLGETBUFFERSUBDATAARB may need conversion */
	fn.glGetBufferSubDataARB(target, offset, size, data);
}

void OSMesaDriver::nfglGetClipPlane(GLenum plane, GLdouble *equation)
{
	D(bug("nfosmesa: glGetClipPlane(0x%x, %p)", plane, equation));
	/* TODO: NFOSMESA_GLGETCLIPPLANE may need conversion */
	fn.glGetClipPlane(plane, equation);
}

void OSMesaDriver::nfglGetClipPlanefOES(GLenum plane, GLfloat *equation)
{
	D(bug("nfosmesa: glGetClipPlanefOES(0x%x, %p)", plane, equation));
	/* TODO: NFOSMESA_GLGETCLIPPLANEFOES may need conversion */
	fn.glGetClipPlanefOES(plane, equation);
}

void OSMesaDriver::nfglGetClipPlanexOES(GLenum plane, GLfixed *equation)
{
	D(bug("nfosmesa: glGetClipPlanexOES(0x%x, %p)", plane, equation));
	/* TODO: NFOSMESA_GLGETCLIPPLANEXOES may need conversion */
	fn.glGetClipPlanexOES(plane, equation);
}

void OSMesaDriver::nfglGetColorTable(GLenum target, GLenum format, GLenum type, void *table)
{
	D(bug("nfosmesa: glGetColorTable(0x%x, 0x%x, 0x%x, %p)", target, format, type, table));
	/* TODO: NFOSMESA_GLGETCOLORTABLE may need conversion */
	fn.glGetColorTable(target, format, type, table);
}

void OSMesaDriver::nfglGetColorTableEXT(GLenum target, GLenum format, GLenum type, void *data)
{
	D(bug("nfosmesa: glGetColorTableEXT(0x%x, 0x%x, 0x%x, %p)", target, format, type, data));
	/* TODO: NFOSMESA_GLGETCOLORTABLEEXT may need conversion */
	fn.glGetColorTableEXT(target, format, type, data);
}

void OSMesaDriver::nfglGetColorTableParameterfv(GLenum target, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetColorTableParameterfv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETCOLORTABLEPARAMETERFV may need conversion */
	fn.glGetColorTableParameterfv(target, pname, params);
}

void OSMesaDriver::nfglGetColorTableParameterfvEXT(GLenum target, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetColorTableParameterfvEXT(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETCOLORTABLEPARAMETERFVEXT may need conversion */
	fn.glGetColorTableParameterfvEXT(target, pname, params);
}

void OSMesaDriver::nfglGetColorTableParameterfvSGI(GLenum target, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetColorTableParameterfvSGI(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETCOLORTABLEPARAMETERFVSGI may need conversion */
	fn.glGetColorTableParameterfvSGI(target, pname, params);
}

void OSMesaDriver::nfglGetColorTableParameteriv(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetColorTableParameteriv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETCOLORTABLEPARAMETERIV may need conversion */
	fn.glGetColorTableParameteriv(target, pname, params);
}

void OSMesaDriver::nfglGetColorTableParameterivEXT(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetColorTableParameterivEXT(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETCOLORTABLEPARAMETERIVEXT may need conversion */
	fn.glGetColorTableParameterivEXT(target, pname, params);
}

void OSMesaDriver::nfglGetColorTableParameterivSGI(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetColorTableParameterivSGI(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETCOLORTABLEPARAMETERIVSGI may need conversion */
	fn.glGetColorTableParameterivSGI(target, pname, params);
}

void OSMesaDriver::nfglGetColorTableSGI(GLenum target, GLenum format, GLenum type, void *table)
{
	D(bug("nfosmesa: glGetColorTableSGI(0x%x, 0x%x, 0x%x, %p)", target, format, type, table));
	/* TODO: NFOSMESA_GLGETCOLORTABLESGI may need conversion */
	fn.glGetColorTableSGI(target, format, type, table);
}

void OSMesaDriver::nfglGetCombinerInputParameterfvNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetCombinerInputParameterfvNV(0x%x, 0x%x, 0x%x, 0x%x, %p)", stage, portion, variable, pname, params));
	/* TODO: NFOSMESA_GLGETCOMBINERINPUTPARAMETERFVNV may need conversion */
	fn.glGetCombinerInputParameterfvNV(stage, portion, variable, pname, params);
}

void OSMesaDriver::nfglGetCombinerInputParameterivNV(GLenum stage, GLenum portion, GLenum variable, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetCombinerInputParameterivNV(0x%x, 0x%x, 0x%x, 0x%x, %p)", stage, portion, variable, pname, params));
	/* TODO: NFOSMESA_GLGETCOMBINERINPUTPARAMETERIVNV may need conversion */
	fn.glGetCombinerInputParameterivNV(stage, portion, variable, pname, params);
}

void OSMesaDriver::nfglGetCombinerOutputParameterfvNV(GLenum stage, GLenum portion, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetCombinerOutputParameterfvNV(0x%x, 0x%x, 0x%x, %p)", stage, portion, pname, params));
	/* TODO: NFOSMESA_GLGETCOMBINEROUTPUTPARAMETERFVNV may need conversion */
	fn.glGetCombinerOutputParameterfvNV(stage, portion, pname, params);
}

void OSMesaDriver::nfglGetCombinerOutputParameterivNV(GLenum stage, GLenum portion, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetCombinerOutputParameterivNV(0x%x, 0x%x, 0x%x, %p)", stage, portion, pname, params));
	/* TODO: NFOSMESA_GLGETCOMBINEROUTPUTPARAMETERIVNV may need conversion */
	fn.glGetCombinerOutputParameterivNV(stage, portion, pname, params);
}

void OSMesaDriver::nfglGetCombinerStageParameterfvNV(GLenum stage, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetCombinerStageParameterfvNV(0x%x, 0x%x, %p)", stage, pname, params));
	/* TODO: NFOSMESA_GLGETCOMBINERSTAGEPARAMETERFVNV may need conversion */
	fn.glGetCombinerStageParameterfvNV(stage, pname, params);
}

void OSMesaDriver::nfglGetCompressedMultiTexImageEXT(GLenum texunit, GLenum target, GLint lod, void *img)
{
	D(bug("nfosmesa: glGetCompressedMultiTexImageEXT(0x%x, 0x%x, %d, %p)", texunit, target, lod, img));
	/* TODO: NFOSMESA_GLGETCOMPRESSEDMULTITEXIMAGEEXT may need conversion */
	fn.glGetCompressedMultiTexImageEXT(texunit, target, lod, img);
}

void OSMesaDriver::nfglGetCompressedTexImage(GLenum target, GLint level, void *img)
{
	D(bug("nfosmesa: glGetCompressedTexImage(0x%x, %d, %p)", target, level, img));
	/* TODO: NFOSMESA_GLGETCOMPRESSEDTEXIMAGE may need conversion */
	fn.glGetCompressedTexImage(target, level, img);
}

void OSMesaDriver::nfglGetCompressedTexImageARB(GLenum target, GLint level, void *img)
{
	D(bug("nfosmesa: glGetCompressedTexImageARB(0x%x, %d, %p)", target, level, img));
	/* TODO: NFOSMESA_GLGETCOMPRESSEDTEXIMAGEARB may need conversion */
	fn.glGetCompressedTexImageARB(target, level, img);
}

void OSMesaDriver::nfglGetCompressedTextureImageEXT(GLuint texture, GLenum target, GLint lod, void *img)
{
	D(bug("nfosmesa: glGetCompressedTextureImageEXT(%u, 0x%x, %d, %p)", texture, target, lod, img));
	/* TODO: NFOSMESA_GLGETCOMPRESSEDTEXTUREIMAGEEXT may need conversion */
	fn.glGetCompressedTextureImageEXT(texture, target, lod, img);
}

void OSMesaDriver::nfglGetConvolutionFilter(GLenum target, GLenum format, GLenum type, void *image)
{
	D(bug("nfosmesa: glGetConvolutionFilter(0x%x, 0x%x, 0x%x, %p)", target, format, type, image));
	/* TODO: NFOSMESA_GLGETCONVOLUTIONFILTER may need conversion */
	fn.glGetConvolutionFilter(target, format, type, image);
}

void OSMesaDriver::nfglGetConvolutionFilterEXT(GLenum target, GLenum format, GLenum type, void *image)
{
	D(bug("nfosmesa: glGetConvolutionFilterEXT(0x%x, 0x%x, 0x%x, %p)", target, format, type, image));
	/* TODO: NFOSMESA_GLGETCONVOLUTIONFILTEREXT may need conversion */
	fn.glGetConvolutionFilterEXT(target, format, type, image);
}

void OSMesaDriver::nfglGetConvolutionParameterfv(GLenum target, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetConvolutionParameterfv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETCONVOLUTIONPARAMETERFV may need conversion */
	fn.glGetConvolutionParameterfv(target, pname, params);
}

void OSMesaDriver::nfglGetConvolutionParameterfvEXT(GLenum target, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetConvolutionParameterfvEXT(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETCONVOLUTIONPARAMETERFVEXT may need conversion */
	fn.glGetConvolutionParameterfvEXT(target, pname, params);
}

void OSMesaDriver::nfglGetConvolutionParameteriv(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetConvolutionParameteriv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETCONVOLUTIONPARAMETERIV may need conversion */
	fn.glGetConvolutionParameteriv(target, pname, params);
}

void OSMesaDriver::nfglGetConvolutionParameterivEXT(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetConvolutionParameterivEXT(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETCONVOLUTIONPARAMETERIVEXT may need conversion */
	fn.glGetConvolutionParameterivEXT(target, pname, params);
}

void OSMesaDriver::nfglGetConvolutionParameterxvOES(GLenum target, GLenum pname, GLfixed *params)
{
	D(bug("nfosmesa: glGetConvolutionParameterxvOES(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETCONVOLUTIONPARAMETERXVOES may need conversion */
	fn.glGetConvolutionParameterxvOES(target, pname, params);
}

GLsizei OSMesaDriver::nfglGetDebugLogLengthMESA(GLhandleARB obj, GLenum logType, GLenum shaderType)
{
	D(bug("nfosmesa: glGetDebugLogLengthMESA(%u, 0x%x, 0x%x)", obj, logType, shaderType));
	return fn.glGetDebugLogLengthMESA(obj, logType, shaderType);
}

void OSMesaDriver::nfglGetDebugLogMESA(GLhandleARB obj, GLenum logType, GLenum shaderType, GLsizei maxLength, GLsizei *length, GLcharARB *debugLog)
{
	D(bug("nfosmesa: glGetDebugLogMESA(%u, 0x%x, 0x%x, %d, %p, %p)", obj, logType, shaderType, maxLength, length, debugLog));
	/* TODO: NFOSMESA_GLGETDEBUGLOGMESA may need conversion */
	fn.glGetDebugLogMESA(obj, logType, shaderType, maxLength, length, debugLog);
}

GLuint OSMesaDriver::nfglGetDebugMessageLog(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
{
	D(bug("nfosmesa: glGetDebugMessageLog(%u, %d, %p, %p, %p, %p, %p, %p)", count, bufSize, sources, types, ids, severities, lengths, messageLog));
	/* TODO: NFOSMESA_GLGETDEBUGMESSAGELOG may need conversion */
	return fn.glGetDebugMessageLog(count, bufSize, sources, types, ids, severities, lengths, messageLog);
}

GLuint OSMesaDriver::nfglGetDebugMessageLogAMD(GLuint count, GLsizei bufsize, GLenum *categories, GLuint *severities, GLuint *ids, GLsizei *lengths, GLchar *message)
{
	D(bug("nfosmesa: glGetDebugMessageLogAMD(%u, %d, %p, %p, %p, %p, %p)", count, bufsize, categories, severities, ids, lengths, message));
	/* TODO: NFOSMESA_GLGETDEBUGMESSAGELOGAMD may need conversion */
	return fn.glGetDebugMessageLogAMD(count, bufsize, categories, severities, ids, lengths, message);
}

GLuint OSMesaDriver::nfglGetDebugMessageLogARB(GLuint count, GLsizei bufSize, GLenum *sources, GLenum *types, GLuint *ids, GLenum *severities, GLsizei *lengths, GLchar *messageLog)
{
	D(bug("nfosmesa: glGetDebugMessageLogARB(%u, %d, %p, %p, %p, %p, %p, %p)", count, bufSize, sources, types, ids, severities, lengths, messageLog));
	/* TODO: NFOSMESA_GLGETDEBUGMESSAGELOGARB may need conversion */
	return fn.glGetDebugMessageLogARB(count, bufSize, sources, types, ids, severities, lengths, messageLog);
}

void OSMesaDriver::nfglGetDetailTexFuncSGIS(GLenum target, GLfloat *points)
{
	D(bug("nfosmesa: glGetDetailTexFuncSGIS(0x%x, %p)", target, points));
	/* TODO: NFOSMESA_GLGETDETAILTEXFUNCSGIS may need conversion */
	fn.glGetDetailTexFuncSGIS(target, points);
}

void OSMesaDriver::nfglGetDoubleIndexedvEXT(GLenum target, GLuint index, GLdouble *data)
{
	D(bug("nfosmesa: glGetDoubleIndexedvEXT(0x%x, %u, %p)", target, index, data));
	/* TODO: NFOSMESA_GLGETDOUBLEINDEXEDVEXT may need conversion */
	fn.glGetDoubleIndexedvEXT(target, index, data);
}

void OSMesaDriver::nfglGetDoublei_v(GLenum target, GLuint index, GLdouble *data)
{
	D(bug("nfosmesa: glGetDoublei_v(0x%x, %u, %p)", target, index, data));
	/* TODO: NFOSMESA_GLGETDOUBLEI_V may need conversion */
	fn.glGetDoublei_v(target, index, data);
}

void OSMesaDriver::nfglGetDoublei_vEXT(GLenum pname, GLuint index, GLdouble *params)
{
	D(bug("nfosmesa: glGetDoublei_vEXT(0x%x, %u, %p)", pname, index, params));
	/* TODO: NFOSMESA_GLGETDOUBLEI_VEXT may need conversion */
	fn.glGetDoublei_vEXT(pname, index, params);
}

void OSMesaDriver::nfglGetDoublev(GLenum pname, GLdouble *params)
{
	D(bug("nfosmesa: glGetDoublev(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLGETDOUBLEV may need conversion */
	fn.glGetDoublev(pname, params);
}

GLenum OSMesaDriver::nfglGetError(void)
{
	D(bug("nfosmesa: glGetError()"));
	return fn.glGetError();
}

void OSMesaDriver::nfglGetFenceivNV(GLuint fence, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetFenceivNV(%u, 0x%x, %p)", fence, pname, params));
	/* TODO: NFOSMESA_GLGETFENCEIVNV may need conversion */
	fn.glGetFenceivNV(fence, pname, params);
}

void OSMesaDriver::nfglGetFinalCombinerInputParameterfvNV(GLenum variable, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetFinalCombinerInputParameterfvNV(0x%x, 0x%x, %p)", variable, pname, params));
	/* TODO: NFOSMESA_GLGETFINALCOMBINERINPUTPARAMETERFVNV may need conversion */
	fn.glGetFinalCombinerInputParameterfvNV(variable, pname, params);
}

void OSMesaDriver::nfglGetFinalCombinerInputParameterivNV(GLenum variable, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetFinalCombinerInputParameterivNV(0x%x, 0x%x, %p)", variable, pname, params));
	/* TODO: NFOSMESA_GLGETFINALCOMBINERINPUTPARAMETERIVNV may need conversion */
	fn.glGetFinalCombinerInputParameterivNV(variable, pname, params);
}

void OSMesaDriver::nfglGetFirstPerfQueryIdINTEL(GLuint *queryId)
{
	D(bug("nfosmesa: glGetFirstPerfQueryIdINTEL(%p)", queryId));
	/* TODO: NFOSMESA_GLGETFIRSTPERFQUERYIDINTEL may need conversion */
	fn.glGetFirstPerfQueryIdINTEL(queryId);
}

void OSMesaDriver::nfglGetFixedvOES(GLenum pname, GLfixed *params)
{
	D(bug("nfosmesa: glGetFixedvOES(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLGETFIXEDVOES may need conversion */
	fn.glGetFixedvOES(pname, params);
}

void OSMesaDriver::nfglGetFloatIndexedvEXT(GLenum target, GLuint index, GLfloat *data)
{
	D(bug("nfosmesa: glGetFloatIndexedvEXT(0x%x, %u, %p)", target, index, data));
	/* TODO: NFOSMESA_GLGETFLOATINDEXEDVEXT may need conversion */
	fn.glGetFloatIndexedvEXT(target, index, data);
}

void OSMesaDriver::nfglGetFloati_v(GLenum target, GLuint index, GLfloat *data)
{
	D(bug("nfosmesa: glGetFloati_v(0x%x, %u, %p)", target, index, data));
	/* TODO: NFOSMESA_GLGETFLOATI_V may need conversion */
	fn.glGetFloati_v(target, index, data);
}

void OSMesaDriver::nfglGetFloati_vEXT(GLenum pname, GLuint index, GLfloat *params)
{
	D(bug("nfosmesa: glGetFloati_vEXT(0x%x, %u, %p)", pname, index, params));
	/* TODO: NFOSMESA_GLGETFLOATI_VEXT may need conversion */
	fn.glGetFloati_vEXT(pname, index, params);
}

void OSMesaDriver::nfglGetFloatv(GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetFloatv(0x%x, %p)", pname, params));
FN_GLGETFLOATV(pname, params);
}

void OSMesaDriver::nfglGetFogFuncSGIS(GLfloat *points)
{
	D(bug("nfosmesa: glGetFogFuncSGIS(%p)", points));
	/* TODO: NFOSMESA_GLGETFOGFUNCSGIS may need conversion */
	fn.glGetFogFuncSGIS(points);
}

GLint OSMesaDriver::nfglGetFragDataIndex(GLuint program, const GLchar *name)
{
	D(bug("nfosmesa: glGetFragDataIndex(%u, %p)", program, name));
	/* TODO: NFOSMESA_GLGETFRAGDATAINDEX may need conversion */
	return fn.glGetFragDataIndex(program, name);
}

GLint OSMesaDriver::nfglGetFragDataLocation(GLuint program, const GLchar *name)
{
	D(bug("nfosmesa: glGetFragDataLocation(%u, %p)", program, name));
	/* TODO: NFOSMESA_GLGETFRAGDATALOCATION may need conversion */
	return fn.glGetFragDataLocation(program, name);
}

GLint OSMesaDriver::nfglGetFragDataLocationEXT(GLuint program, const GLchar *name)
{
	D(bug("nfosmesa: glGetFragDataLocationEXT(%u, %p)", program, name));
	/* TODO: NFOSMESA_GLGETFRAGDATALOCATIONEXT may need conversion */
	return fn.glGetFragDataLocationEXT(program, name);
}

void OSMesaDriver::nfglGetFragmentLightfvSGIX(GLenum light, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetFragmentLightfvSGIX(0x%x, 0x%x, %p)", light, pname, params));
	/* TODO: NFOSMESA_GLGETFRAGMENTLIGHTFVSGIX may need conversion */
	fn.glGetFragmentLightfvSGIX(light, pname, params);
}

void OSMesaDriver::nfglGetFragmentLightivSGIX(GLenum light, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetFragmentLightivSGIX(0x%x, 0x%x, %p)", light, pname, params));
	/* TODO: NFOSMESA_GLGETFRAGMENTLIGHTIVSGIX may need conversion */
	fn.glGetFragmentLightivSGIX(light, pname, params);
}

void OSMesaDriver::nfglGetFragmentMaterialfvSGIX(GLenum face, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetFragmentMaterialfvSGIX(0x%x, 0x%x, %p)", face, pname, params));
	/* TODO: NFOSMESA_GLGETFRAGMENTMATERIALFVSGIX may need conversion */
	fn.glGetFragmentMaterialfvSGIX(face, pname, params);
}

void OSMesaDriver::nfglGetFragmentMaterialivSGIX(GLenum face, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetFragmentMaterialivSGIX(0x%x, 0x%x, %p)", face, pname, params));
	/* TODO: NFOSMESA_GLGETFRAGMENTMATERIALIVSGIX may need conversion */
	fn.glGetFragmentMaterialivSGIX(face, pname, params);
}

void OSMesaDriver::nfglGetFramebufferAttachmentParameteriv(GLenum target, GLenum attachment, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetFramebufferAttachmentParameteriv(0x%x, 0x%x, 0x%x, %p)", target, attachment, pname, params));
	/* TODO: NFOSMESA_GLGETFRAMEBUFFERATTACHMENTPARAMETERIV may need conversion */
	fn.glGetFramebufferAttachmentParameteriv(target, attachment, pname, params);
}

void OSMesaDriver::nfglGetFramebufferAttachmentParameterivEXT(GLenum target, GLenum attachment, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetFramebufferAttachmentParameterivEXT(0x%x, 0x%x, 0x%x, %p)", target, attachment, pname, params));
	/* TODO: NFOSMESA_GLGETFRAMEBUFFERATTACHMENTPARAMETERIVEXT may need conversion */
	fn.glGetFramebufferAttachmentParameterivEXT(target, attachment, pname, params);
}

void OSMesaDriver::nfglGetFramebufferParameteriv(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetFramebufferParameteriv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETFRAMEBUFFERPARAMETERIV may need conversion */
	fn.glGetFramebufferParameteriv(target, pname, params);
}

void OSMesaDriver::nfglGetFramebufferParameterivEXT(GLuint framebuffer, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetFramebufferParameterivEXT(%u, 0x%x, %p)", framebuffer, pname, params));
	/* TODO: NFOSMESA_GLGETFRAMEBUFFERPARAMETERIVEXT may need conversion */
	fn.glGetFramebufferParameterivEXT(framebuffer, pname, params);
}

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

GLhandleARB OSMesaDriver::nfglGetHandleARB(GLenum pname)
{
	D(bug("nfosmesa: glGetHandleARB(0x%x)", pname));
	return fn.glGetHandleARB(pname);
}

void OSMesaDriver::nfglGetHistogram(GLenum target, GLboolean32 reset, GLenum format, GLenum type, void *values)
{
	D(bug("nfosmesa: glGetHistogram(0x%x, %d, 0x%x, 0x%x, %p)", target, reset, format, type, values));
	/* TODO: NFOSMESA_GLGETHISTOGRAM may need conversion */
	fn.glGetHistogram(target, reset, format, type, values);
}

void OSMesaDriver::nfglGetHistogramEXT(GLenum target, GLboolean32 reset, GLenum format, GLenum type, void *values)
{
	D(bug("nfosmesa: glGetHistogramEXT(0x%x, %d, 0x%x, 0x%x, %p)", target, reset, format, type, values));
	/* TODO: NFOSMESA_GLGETHISTOGRAMEXT may need conversion */
	fn.glGetHistogramEXT(target, reset, format, type, values);
}

void OSMesaDriver::nfglGetHistogramParameterfv(GLenum target, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetHistogramParameterfv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETHISTOGRAMPARAMETERFV may need conversion */
	fn.glGetHistogramParameterfv(target, pname, params);
}

void OSMesaDriver::nfglGetHistogramParameterfvEXT(GLenum target, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetHistogramParameterfvEXT(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETHISTOGRAMPARAMETERFVEXT may need conversion */
	fn.glGetHistogramParameterfvEXT(target, pname, params);
}

void OSMesaDriver::nfglGetHistogramParameteriv(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetHistogramParameteriv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETHISTOGRAMPARAMETERIV may need conversion */
	fn.glGetHistogramParameteriv(target, pname, params);
}

void OSMesaDriver::nfglGetHistogramParameterivEXT(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetHistogramParameterivEXT(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETHISTOGRAMPARAMETERIVEXT may need conversion */
	fn.glGetHistogramParameterivEXT(target, pname, params);
}

void OSMesaDriver::nfglGetHistogramParameterxvOES(GLenum target, GLenum pname, GLfixed *params)
{
	D(bug("nfosmesa: glGetHistogramParameterxvOES(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETHISTOGRAMPARAMETERXVOES may need conversion */
	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, 0x%x)", texture, level, layered, layer, format));
	return 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, 0x%x)", texture, level, layered, layer, format));
	return fn.glGetImageHandleNV(texture, level, layered, layer, format);
}

void OSMesaDriver::nfglGetImageTransformParameterfvHP(GLenum target, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetImageTransformParameterfvHP(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETIMAGETRANSFORMPARAMETERFVHP may need conversion */
	fn.glGetImageTransformParameterfvHP(target, pname, params);
}

void OSMesaDriver::nfglGetImageTransformParameterivHP(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetImageTransformParameterivHP(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETIMAGETRANSFORMPARAMETERIVHP may need conversion */
	fn.glGetImageTransformParameterivHP(target, pname, params);
}

void OSMesaDriver::nfglGetInfoLogARB(GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *infoLog)
{
	D(bug("nfosmesa: glGetInfoLogARB(%u, %d, %p, %p)", obj, maxLength, length, infoLog));
	/* TODO: NFOSMESA_GLGETINFOLOGARB may need conversion */
	fn.glGetInfoLogARB(obj, maxLength, length, infoLog);
}

GLint OSMesaDriver::nfglGetInstrumentsSGIX(void)
{
	D(bug("nfosmesa: glGetInstrumentsSGIX()"));
	return fn.glGetInstrumentsSGIX();
}

void OSMesaDriver::nfglGetInteger64i_v(GLenum target, GLuint index, GLint64 *data)
{
	D(bug("nfosmesa: glGetInteger64i_v(0x%x, %u, %p)", target, index, data));
	/* TODO: NFOSMESA_GLGETINTEGER64I_V may need conversion */
	fn.glGetInteger64i_v(target, index, data);
}

void OSMesaDriver::nfglGetInteger64v(GLenum pname, GLint64 *data)
{
	D(bug("nfosmesa: glGetInteger64v(0x%x, %p)", pname, data));
	/* TODO: NFOSMESA_GLGETINTEGER64V may need conversion */
	fn.glGetInteger64v(pname, data);
}

void OSMesaDriver::nfglGetIntegerIndexedvEXT(GLenum target, GLuint index, GLint *data)
{
	D(bug("nfosmesa: glGetIntegerIndexedvEXT(0x%x, %u, %p)", target, index, data));
	/* TODO: NFOSMESA_GLGETINTEGERINDEXEDVEXT may need conversion */
	fn.glGetIntegerIndexedvEXT(target, index, data);
}

void OSMesaDriver::nfglGetIntegeri_v(GLenum target, GLuint index, GLint *data)
{
	D(bug("nfosmesa: glGetIntegeri_v(0x%x, %u, %p)", target, index, data));
	/* TODO: NFOSMESA_GLGETINTEGERI_V may need conversion */
	fn.glGetIntegeri_v(target, index, data);
}

void OSMesaDriver::nfglGetIntegerui64i_vNV(GLenum value, GLuint index, GLuint64EXT *result)
{
	D(bug("nfosmesa: glGetIntegerui64i_vNV(0x%x, %u, %p)", value, index, result));
	/* TODO: NFOSMESA_GLGETINTEGERUI64I_VNV may need conversion */
	fn.glGetIntegerui64i_vNV(value, index, result);
}

void OSMesaDriver::nfglGetIntegerui64vNV(GLenum value, GLuint64EXT *result)
{
	D(bug("nfosmesa: glGetIntegerui64vNV(0x%x, %p)", value, result));
	/* TODO: NFOSMESA_GLGETINTEGERUI64VNV may need conversion */
	fn.glGetIntegerui64vNV(value, result);
}

void OSMesaDriver::nfglGetIntegerv(GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetIntegerv(0x%x, %p)", pname, params));
FN_GLGETINTEGERV(pname, params);
}

void OSMesaDriver::nfglGetInternalformati64v(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint64 *params)
{
	D(bug("nfosmesa: glGetInternalformati64v(0x%x, 0x%x, 0x%x, %d, %p)", target, internalformat, pname, bufSize, params));
	/* TODO: NFOSMESA_GLGETINTERNALFORMATI64V may need conversion */
	fn.glGetInternalformati64v(target, internalformat, pname, bufSize, params);
}

void OSMesaDriver::nfglGetInternalformativ(GLenum target, GLenum internalformat, GLenum pname, GLsizei bufSize, GLint *params)
{
	D(bug("nfosmesa: glGetInternalformativ(0x%x, 0x%x, 0x%x, %d, %p)", target, internalformat, pname, bufSize, params));
	/* TODO: NFOSMESA_GLGETINTERNALFORMATIV may need conversion */
	fn.glGetInternalformativ(target, internalformat, pname, bufSize, params);
}

void OSMesaDriver::nfglGetInvariantBooleanvEXT(GLuint id, GLenum value, GLboolean *data)
{
	D(bug("nfosmesa: glGetInvariantBooleanvEXT(%u, 0x%x, %p)", id, value, data));
	fn.glGetInvariantBooleanvEXT(id, value, data);
}

void OSMesaDriver::nfglGetInvariantFloatvEXT(GLuint id, GLenum value, GLfloat *data)
{
	D(bug("nfosmesa: glGetInvariantFloatvEXT(%u, 0x%x, %p)", id, value, data));
	/* TODO: NFOSMESA_GLGETINVARIANTFLOATVEXT may need conversion */
	fn.glGetInvariantFloatvEXT(id, value, data);
}

void OSMesaDriver::nfglGetInvariantIntegervEXT(GLuint id, GLenum value, GLint *data)
{
	D(bug("nfosmesa: glGetInvariantIntegervEXT(%u, 0x%x, %p)", id, value, data));
	/* TODO: NFOSMESA_GLGETINVARIANTINTEGERVEXT may need conversion */
	fn.glGetInvariantIntegervEXT(id, value, data);
}

void OSMesaDriver::nfglGetLightfv(GLenum light, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetLightfv(0x%x, 0x%x, %p)", light, pname, params));
	/* TODO: NFOSMESA_GLGETLIGHTFV may need conversion */
	fn.glGetLightfv(light, pname, params);
}

void OSMesaDriver::nfglGetLightiv(GLenum light, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetLightiv(0x%x, 0x%x, %p)", light, pname, params));
	/* TODO: NFOSMESA_GLGETLIGHTIV may need conversion */
	fn.glGetLightiv(light, pname, params);
}

void OSMesaDriver::nfglGetLightxOES(GLenum light, GLenum pname, GLfixed *params)
{
	D(bug("nfosmesa: glGetLightxOES(0x%x, 0x%x, %p)", light, pname, params));
	/* TODO: NFOSMESA_GLGETLIGHTXOES may need conversion */
	fn.glGetLightxOES(light, pname, params);
}

void OSMesaDriver::nfglGetListParameterfvSGIX(GLuint list, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetListParameterfvSGIX(%u, 0x%x, %p)", list, pname, params));
	/* TODO: NFOSMESA_GLGETLISTPARAMETERFVSGIX may need conversion */
	fn.glGetListParameterfvSGIX(list, pname, params);
}

void OSMesaDriver::nfglGetListParameterivSGIX(GLuint list, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetListParameterivSGIX(%u, 0x%x, %p)", list, pname, params));
	/* TODO: NFOSMESA_GLGETLISTPARAMETERIVSGIX may need conversion */
	fn.glGetListParameterivSGIX(list, pname, params);
}

void OSMesaDriver::nfglGetLocalConstantBooleanvEXT(GLuint id, GLenum value, GLboolean *data)
{
	D(bug("nfosmesa: glGetLocalConstantBooleanvEXT(%u, 0x%x, %p)", id, value, data));
	fn.glGetLocalConstantBooleanvEXT(id, value, data);
}

void OSMesaDriver::nfglGetLocalConstantFloatvEXT(GLuint id, GLenum value, GLfloat *data)
{
	D(bug("nfosmesa: glGetLocalConstantFloatvEXT(%u, 0x%x, %p)", id, value, data));
	/* TODO: NFOSMESA_GLGETLOCALCONSTANTFLOATVEXT may need conversion */
	fn.glGetLocalConstantFloatvEXT(id, value, data);
}

void OSMesaDriver::nfglGetLocalConstantIntegervEXT(GLuint id, GLenum value, GLint *data)
{
	D(bug("nfosmesa: glGetLocalConstantIntegervEXT(%u, 0x%x, %p)", id, value, data));
	/* TODO: NFOSMESA_GLGETLOCALCONSTANTINTEGERVEXT may need conversion */
	fn.glGetLocalConstantIntegervEXT(id, value, data);
}

void OSMesaDriver::nfglGetMapAttribParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetMapAttribParameterfvNV(0x%x, %u, 0x%x, %p)", target, index, pname, params));
	/* TODO: NFOSMESA_GLGETMAPATTRIBPARAMETERFVNV may need conversion */
	fn.glGetMapAttribParameterfvNV(target, index, pname, params);
}

void OSMesaDriver::nfglGetMapAttribParameterivNV(GLenum target, GLuint index, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetMapAttribParameterivNV(0x%x, %u, 0x%x, %p)", target, index, pname, params));
	/* TODO: NFOSMESA_GLGETMAPATTRIBPARAMETERIVNV may need conversion */
	fn.glGetMapAttribParameterivNV(target, index, pname, params);
}

void OSMesaDriver::nfglGetMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLboolean32 packed, void *points)
{
	D(bug("nfosmesa: glGetMapControlPointsNV(0x%x, %u, 0x%x, %d, %d, %d, %p)", target, index, type, ustride, vstride, packed, points));
	/* TODO: NFOSMESA_GLGETMAPCONTROLPOINTSNV may need conversion */
	fn.glGetMapControlPointsNV(target, index, type, ustride, vstride, packed, points);
}

void OSMesaDriver::nfglGetMapParameterfvNV(GLenum target, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetMapParameterfvNV(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETMAPPARAMETERFVNV may need conversion */
	fn.glGetMapParameterfvNV(target, pname, params);
}

void OSMesaDriver::nfglGetMapParameterivNV(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetMapParameterivNV(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETMAPPARAMETERIVNV may need conversion */
	fn.glGetMapParameterivNV(target, pname, params);
}

void OSMesaDriver::nfglGetMapdv(GLenum target, GLenum query, GLdouble *v)
{
	D(bug("nfosmesa: glGetMapdv(0x%x, 0x%x, %p)", target, query, v));
	/* TODO: NFOSMESA_GLGETMAPDV may need conversion */
	fn.glGetMapdv(target, query, v);
}

void OSMesaDriver::nfglGetMapfv(GLenum target, GLenum query, GLfloat *v)
{
	D(bug("nfosmesa: glGetMapfv(0x%x, 0x%x, %p)", target, query, v));
	/* TODO: NFOSMESA_GLGETMAPFV may need conversion */
	fn.glGetMapfv(target, query, v);
}

void OSMesaDriver::nfglGetMapiv(GLenum target, GLenum query, GLint *v)
{
	D(bug("nfosmesa: glGetMapiv(0x%x, 0x%x, %p)", target, query, v));
	/* TODO: NFOSMESA_GLGETMAPIV may need conversion */
	fn.glGetMapiv(target, query, v);
}

void OSMesaDriver::nfglGetMapxvOES(GLenum target, GLenum query, GLfixed *v)
{
	D(bug("nfosmesa: glGetMapxvOES(0x%x, 0x%x, %p)", target, query, v));
	/* TODO: NFOSMESA_GLGETMAPXVOES may need conversion */
	fn.glGetMapxvOES(target, query, v);
}

void OSMesaDriver::nfglGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetMaterialfv(0x%x, 0x%x, %p)", face, pname, params));
	/* TODO: NFOSMESA_GLGETMATERIALFV may need conversion */
	fn.glGetMaterialfv(face, pname, params);
}

void OSMesaDriver::nfglGetMaterialiv(GLenum face, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetMaterialiv(0x%x, 0x%x, %p)", face, pname, params));
	/* TODO: NFOSMESA_GLGETMATERIALIV may need conversion */
	fn.glGetMaterialiv(face, pname, params);
}

void OSMesaDriver::nfglGetMaterialxOES(GLenum face, GLenum pname, GLfixed param)
{
	D(bug("nfosmesa: glGetMaterialxOES(0x%x, 0x%x, 0x%x)", face, pname, param));
	fn.glGetMaterialxOES(face, pname, param);
}

void OSMesaDriver::nfglGetMinmax(GLenum target, GLboolean32 reset, GLenum format, GLenum type, void *values)
{
	D(bug("nfosmesa: glGetMinmax(0x%x, %d, 0x%x, 0x%x, %p)", target, reset, format, type, values));
	/* TODO: NFOSMESA_GLGETMINMAX may need conversion */
	fn.glGetMinmax(target, reset, format, type, values);
}

void OSMesaDriver::nfglGetMinmaxEXT(GLenum target, GLboolean32 reset, GLenum format, GLenum type, void *values)
{
	D(bug("nfosmesa: glGetMinmaxEXT(0x%x, %d, 0x%x, 0x%x, %p)", target, reset, format, type, values));
	/* TODO: NFOSMESA_GLGETMINMAXEXT may need conversion */
	fn.glGetMinmaxEXT(target, reset, format, type, values);
}

void OSMesaDriver::nfglGetMinmaxParameterfv(GLenum target, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetMinmaxParameterfv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETMINMAXPARAMETERFV may need conversion */
	fn.glGetMinmaxParameterfv(target, pname, params);
}

void OSMesaDriver::nfglGetMinmaxParameterfvEXT(GLenum target, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetMinmaxParameterfvEXT(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETMINMAXPARAMETERFVEXT may need conversion */
	fn.glGetMinmaxParameterfvEXT(target, pname, params);
}

void OSMesaDriver::nfglGetMinmaxParameteriv(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetMinmaxParameteriv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETMINMAXPARAMETERIV may need conversion */
	fn.glGetMinmaxParameteriv(target, pname, params);
}

void OSMesaDriver::nfglGetMinmaxParameterivEXT(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetMinmaxParameterivEXT(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETMINMAXPARAMETERIVEXT may need conversion */
	fn.glGetMinmaxParameterivEXT(target, pname, params);
}

void OSMesaDriver::nfglGetMultiTexEnvfvEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetMultiTexEnvfvEXT(0x%x, 0x%x, 0x%x, %p)", texunit, target, pname, params));
	/* TODO: NFOSMESA_GLGETMULTITEXENVFVEXT may need conversion */
	fn.glGetMultiTexEnvfvEXT(texunit, target, pname, params);
}

void OSMesaDriver::nfglGetMultiTexEnvivEXT(GLenum texunit, GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetMultiTexEnvivEXT(0x%x, 0x%x, 0x%x, %p)", texunit, target, pname, params));
	/* TODO: NFOSMESA_GLGETMULTITEXENVIVEXT may need conversion */
	fn.glGetMultiTexEnvivEXT(texunit, target, pname, params);
}

void OSMesaDriver::nfglGetMultiTexGendvEXT(GLenum texunit, GLenum coord, GLenum pname, GLdouble *params)
{
	D(bug("nfosmesa: glGetMultiTexGendvEXT(0x%x, 0x%x, 0x%x, %p)", texunit, coord, pname, params));
	/* TODO: NFOSMESA_GLGETMULTITEXGENDVEXT may need conversion */
	fn.glGetMultiTexGendvEXT(texunit, coord, pname, params);
}

void OSMesaDriver::nfglGetMultiTexGenfvEXT(GLenum texunit, GLenum coord, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetMultiTexGenfvEXT(0x%x, 0x%x, 0x%x, %p)", texunit, coord, pname, params));
	/* TODO: NFOSMESA_GLGETMULTITEXGENFVEXT may need conversion */
	fn.glGetMultiTexGenfvEXT(texunit, coord, pname, params);
}

void OSMesaDriver::nfglGetMultiTexGenivEXT(GLenum texunit, GLenum coord, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetMultiTexGenivEXT(0x%x, 0x%x, 0x%x, %p)", texunit, coord, pname, params));
	/* TODO: NFOSMESA_GLGETMULTITEXGENIVEXT may need conversion */
	fn.glGetMultiTexGenivEXT(texunit, coord, pname, params);
}

void OSMesaDriver::nfglGetMultiTexImageEXT(GLenum texunit, GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
{
	D(bug("nfosmesa: glGetMultiTexImageEXT(0x%x, 0x%x, %d, 0x%x, 0x%x, %p)", texunit, target, level, format, type, pixels));
	/* TODO: NFOSMESA_GLGETMULTITEXIMAGEEXT may need conversion */
	fn.glGetMultiTexImageEXT(texunit, target, level, format, type, pixels);
}

void OSMesaDriver::nfglGetMultiTexLevelParameterfvEXT(GLenum texunit, GLenum target, GLint level, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetMultiTexLevelParameterfvEXT(0x%x, 0x%x, %d, 0x%x, %p)", texunit, target, level, pname, params));
	/* TODO: NFOSMESA_GLGETMULTITEXLEVELPARAMETERFVEXT may need conversion */
	fn.glGetMultiTexLevelParameterfvEXT(texunit, target, level, pname, params);
}

void OSMesaDriver::nfglGetMultiTexLevelParameterivEXT(GLenum texunit, GLenum target, GLint level, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetMultiTexLevelParameterivEXT(0x%x, 0x%x, %d, 0x%x, %p)", texunit, target, level, pname, params));
	/* TODO: NFOSMESA_GLGETMULTITEXLEVELPARAMETERIVEXT may need conversion */
	fn.glGetMultiTexLevelParameterivEXT(texunit, target, level, pname, params);
}

void OSMesaDriver::nfglGetMultiTexParameterIivEXT(GLenum texunit, GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetMultiTexParameterIivEXT(0x%x, 0x%x, 0x%x, %p)", texunit, target, pname, params));
	/* TODO: NFOSMESA_GLGETMULTITEXPARAMETERIIVEXT may need conversion */
	fn.glGetMultiTexParameterIivEXT(texunit, target, pname, params);
}

void OSMesaDriver::nfglGetMultiTexParameterIuivEXT(GLenum texunit, GLenum target, GLenum pname, GLuint *params)
{
	D(bug("nfosmesa: glGetMultiTexParameterIuivEXT(0x%x, 0x%x, 0x%x, %p)", texunit, target, pname, params));
	/* TODO: NFOSMESA_GLGETMULTITEXPARAMETERIUIVEXT may need conversion */
	fn.glGetMultiTexParameterIuivEXT(texunit, target, pname, params);
}

void OSMesaDriver::nfglGetMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetMultiTexParameterfvEXT(0x%x, 0x%x, 0x%x, %p)", texunit, target, pname, params));
	/* TODO: NFOSMESA_GLGETMULTITEXPARAMETERFVEXT may need conversion */
	fn.glGetMultiTexParameterfvEXT(texunit, target, pname, params);
}

void OSMesaDriver::nfglGetMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetMultiTexParameterivEXT(0x%x, 0x%x, 0x%x, %p)", texunit, target, pname, params));
	/* TODO: NFOSMESA_GLGETMULTITEXPARAMETERIVEXT may need conversion */
	fn.glGetMultiTexParameterivEXT(texunit, target, pname, params);
}

void OSMesaDriver::nfglGetMultisamplefv(GLenum pname, GLuint index, GLfloat *val)
{
	D(bug("nfosmesa: glGetMultisamplefv(0x%x, %u, %p)", pname, index, val));
	/* TODO: NFOSMESA_GLGETMULTISAMPLEFV may need conversion */
	fn.glGetMultisamplefv(pname, index, val);
}

void OSMesaDriver::nfglGetMultisamplefvNV(GLenum pname, GLuint index, GLfloat *val)
{
	D(bug("nfosmesa: glGetMultisamplefvNV(0x%x, %u, %p)", pname, index, val));
	/* TODO: NFOSMESA_GLGETMULTISAMPLEFVNV may need conversion */
	fn.glGetMultisamplefvNV(pname, index, val);
}

void OSMesaDriver::nfglGetNamedBufferParameterivEXT(GLuint buffer, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetNamedBufferParameterivEXT(%u, 0x%x, %p)", buffer, pname, params));
	/* TODO: NFOSMESA_GLGETNAMEDBUFFERPARAMETERIVEXT may need conversion */
	fn.glGetNamedBufferParameterivEXT(buffer, pname, params);
}

void OSMesaDriver::nfglGetNamedBufferParameterui64vNV(GLuint buffer, GLenum pname, GLuint64EXT *params)
{
	D(bug("nfosmesa: glGetNamedBufferParameterui64vNV(%u, 0x%x, %p)", buffer, pname, params));
	/* TODO: NFOSMESA_GLGETNAMEDBUFFERPARAMETERUI64VNV may need conversion */
	fn.glGetNamedBufferParameterui64vNV(buffer, pname, params);
}

void OSMesaDriver::nfglGetNamedBufferPointervEXT(GLuint buffer, GLenum pname, void * *params)
{
	D(bug("nfosmesa: glGetNamedBufferPointervEXT(%u, 0x%x, %p)", buffer, pname, params));
	/* TODO: NFOSMESA_GLGETNAMEDBUFFERPOINTERVEXT may need conversion */
	fn.glGetNamedBufferPointervEXT(buffer, pname, params);
}

void OSMesaDriver::nfglGetNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, void *data)
{
	D(bug("nfosmesa: glGetNamedBufferSubDataEXT(%u, %ld, %ld, %p)", buffer, offset, size, data));
	/* TODO: NFOSMESA_GLGETNAMEDBUFFERSUBDATAEXT may need conversion */
	fn.glGetNamedBufferSubDataEXT(buffer, offset, size, data);
}

void OSMesaDriver::nfglGetNamedFramebufferAttachmentParameterivEXT(GLuint framebuffer, GLenum attachment, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetNamedFramebufferAttachmentParameterivEXT(%u, 0x%x, 0x%x, %p)", framebuffer, attachment, pname, params));
	/* TODO: NFOSMESA_GLGETNAMEDFRAMEBUFFERATTACHMENTPARAMETERIVEXT may need conversion */
	fn.glGetNamedFramebufferAttachmentParameterivEXT(framebuffer, attachment, pname, params);
}

void OSMesaDriver::nfglGetNamedFramebufferParameterivEXT(GLuint framebuffer, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetNamedFramebufferParameterivEXT(%u, 0x%x, %p)", framebuffer, pname, params));
	/* TODO: NFOSMESA_GLGETNAMEDFRAMEBUFFERPARAMETERIVEXT may need conversion */
	fn.glGetNamedFramebufferParameterivEXT(framebuffer, pname, params);
}

void OSMesaDriver::nfglGetNamedProgramLocalParameterIivEXT(GLuint program, GLenum target, GLuint index, GLint *params)
{
	D(bug("nfosmesa: glGetNamedProgramLocalParameterIivEXT(%u, 0x%x, %u, %p)", program, target, index, params));
	/* TODO: NFOSMESA_GLGETNAMEDPROGRAMLOCALPARAMETERIIVEXT may need conversion */
	fn.glGetNamedProgramLocalParameterIivEXT(program, target, index, params);
}

void OSMesaDriver::nfglGetNamedProgramLocalParameterIuivEXT(GLuint program, GLenum target, GLuint index, GLuint *params)
{
	D(bug("nfosmesa: glGetNamedProgramLocalParameterIuivEXT(%u, 0x%x, %u, %p)", program, target, index, params));
	/* TODO: NFOSMESA_GLGETNAMEDPROGRAMLOCALPARAMETERIUIVEXT may need conversion */
	fn.glGetNamedProgramLocalParameterIuivEXT(program, target, index, params);
}

void OSMesaDriver::nfglGetNamedProgramLocalParameterdvEXT(GLuint program, GLenum target, GLuint index, GLdouble *params)
{
	D(bug("nfosmesa: glGetNamedProgramLocalParameterdvEXT(%u, 0x%x, %u, %p)", program, target, index, params));
	/* TODO: NFOSMESA_GLGETNAMEDPROGRAMLOCALPARAMETERDVEXT may need conversion */
	fn.glGetNamedProgramLocalParameterdvEXT(program, target, index, params);
}

void OSMesaDriver::nfglGetNamedProgramLocalParameterfvEXT(GLuint program, GLenum target, GLuint index, GLfloat *params)
{
	D(bug("nfosmesa: glGetNamedProgramLocalParameterfvEXT(%u, 0x%x, %u, %p)", program, target, index, params));
	/* TODO: NFOSMESA_GLGETNAMEDPROGRAMLOCALPARAMETERFVEXT may need conversion */
	fn.glGetNamedProgramLocalParameterfvEXT(program, target, index, params);
}

void OSMesaDriver::nfglGetNamedProgramStringEXT(GLuint program, GLenum target, GLenum pname, void *string)
{
	D(bug("nfosmesa: glGetNamedProgramStringEXT(%u, 0x%x, 0x%x, %p)", program, target, pname, string));
	/* TODO: NFOSMESA_GLGETNAMEDPROGRAMSTRINGEXT may need conversion */
	fn.glGetNamedProgramStringEXT(program, target, pname, string);
}

void OSMesaDriver::nfglGetNamedProgramivEXT(GLuint program, GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetNamedProgramivEXT(%u, 0x%x, 0x%x, %p)", program, target, pname, params));
	/* TODO: NFOSMESA_GLGETNAMEDPROGRAMIVEXT may need conversion */
	fn.glGetNamedProgramivEXT(program, target, pname, params);
}

void OSMesaDriver::nfglGetNamedRenderbufferParameterivEXT(GLuint renderbuffer, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetNamedRenderbufferParameterivEXT(%u, 0x%x, %p)", renderbuffer, pname, params));
	/* TODO: NFOSMESA_GLGETNAMEDRENDERBUFFERPARAMETERIVEXT may need conversion */
	fn.glGetNamedRenderbufferParameterivEXT(renderbuffer, pname, params);
}

void OSMesaDriver::nfglGetNamedStringARB(GLint namelen, const GLchar *name, GLsizei bufSize, GLint *stringlen, GLchar *string)
{
	D(bug("nfosmesa: glGetNamedStringARB(%d, %p, %d, %p, %p)", namelen, name, bufSize, stringlen, string));
	/* TODO: NFOSMESA_GLGETNAMEDSTRINGARB may need conversion */
	fn.glGetNamedStringARB(namelen, name, bufSize, stringlen, string);
}

void OSMesaDriver::nfglGetNamedStringivARB(GLint namelen, const GLchar *name, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetNamedStringivARB(%d, %p, 0x%x, %p)", namelen, name, pname, params));
	/* TODO: NFOSMESA_GLGETNAMEDSTRINGIVARB may need conversion */
	fn.glGetNamedStringivARB(namelen, name, pname, params);
}

void OSMesaDriver::nfglGetNextPerfQueryIdINTEL(GLuint queryId, GLuint *nextQueryId)
{
	D(bug("nfosmesa: glGetNextPerfQueryIdINTEL(%u, %p)", queryId, nextQueryId));
	/* TODO: NFOSMESA_GLGETNEXTPERFQUERYIDINTEL may need conversion */
	fn.glGetNextPerfQueryIdINTEL(queryId, nextQueryId);
}

void OSMesaDriver::nfglGetObjectBufferfvATI(GLuint buffer, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetObjectBufferfvATI(%u, 0x%x, %p)", buffer, pname, params));
	/* TODO: NFOSMESA_GLGETOBJECTBUFFERFVATI may need conversion */
	fn.glGetObjectBufferfvATI(buffer, pname, params);
}

void OSMesaDriver::nfglGetObjectBufferivATI(GLuint buffer, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetObjectBufferivATI(%u, 0x%x, %p)", buffer, pname, params));
	/* TODO: NFOSMESA_GLGETOBJECTBUFFERIVATI may need conversion */
	fn.glGetObjectBufferivATI(buffer, pname, params);
}

void OSMesaDriver::nfglGetObjectLabel(GLenum identifier, GLuint name, GLsizei bufSize, GLsizei *length, GLchar *label)
{
	D(bug("nfosmesa: glGetObjectLabel(0x%x, %u, %d, %p, %p)", identifier, name, bufSize, length, label));
	/* TODO: NFOSMESA_GLGETOBJECTLABEL may need conversion */
	fn.glGetObjectLabel(identifier, name, bufSize, length, label);
}

void OSMesaDriver::nfglGetObjectLabelEXT(GLenum type, GLuint object, GLsizei bufSize, GLsizei *length, GLchar *label)
{
	D(bug("nfosmesa: glGetObjectLabelEXT(0x%x, %u, %d, %p, %p)", type, object, bufSize, length, label));
	/* TODO: NFOSMESA_GLGETOBJECTLABELEXT may need conversion */
	fn.glGetObjectLabelEXT(type, object, bufSize, length, label);
}

void OSMesaDriver::nfglGetObjectParameterfvARB(GLhandleARB obj, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetObjectParameterfvARB(%u, 0x%x, %p)", obj, pname, params));
	/* TODO: NFOSMESA_GLGETOBJECTPARAMETERFVARB may need conversion */
	fn.glGetObjectParameterfvARB(obj, pname, params);
}

void OSMesaDriver::nfglGetObjectParameterivAPPLE(GLenum objectType, GLuint name, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetObjectParameterivAPPLE(0x%x, %u, 0x%x, %p)", objectType, name, pname, params));
	/* TODO: NFOSMESA_GLGETOBJECTPARAMETERIVAPPLE may need conversion */
	fn.glGetObjectParameterivAPPLE(objectType, name, pname, params);
}

void OSMesaDriver::nfglGetObjectParameterivARB(GLhandleARB obj, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetObjectParameterivARB(%u, 0x%x, %p)", obj, pname, params));
	/* TODO: NFOSMESA_GLGETOBJECTPARAMETERIVARB may need conversion */
	fn.glGetObjectParameterivARB(obj, pname, params);
}

void OSMesaDriver::nfglGetObjectPtrLabel(const void *ptr, GLsizei bufSize, GLsizei *length, GLchar *label)
{
	D(bug("nfosmesa: glGetObjectPtrLabel(%p, %d, %p, %p)", ptr, bufSize, length, label));
	/* TODO: NFOSMESA_GLGETOBJECTPTRLABEL may need conversion */
	fn.glGetObjectPtrLabel(ptr, bufSize, length, label);
}

void OSMesaDriver::nfglGetOcclusionQueryivNV(GLuint id, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetOcclusionQueryivNV(%u, 0x%x, %p)", id, pname, params));
	/* TODO: NFOSMESA_GLGETOCCLUSIONQUERYIVNV may need conversion */
	fn.glGetOcclusionQueryivNV(id, pname, params);
}

void OSMesaDriver::nfglGetOcclusionQueryuivNV(GLuint id, GLenum pname, GLuint *params)
{
	D(bug("nfosmesa: glGetOcclusionQueryuivNV(%u, 0x%x, %p)", id, pname, params));
	/* TODO: NFOSMESA_GLGETOCCLUSIONQUERYUIVNV may need conversion */
	fn.glGetOcclusionQueryuivNV(id, pname, params);
}

void OSMesaDriver::nfglGetPathColorGenfvNV(GLenum color, GLenum pname, GLfloat *value)
{
	D(bug("nfosmesa: glGetPathColorGenfvNV(0x%x, 0x%x, %p)", color, pname, value));
	/* TODO: NFOSMESA_GLGETPATHCOLORGENFVNV may need conversion */
	fn.glGetPathColorGenfvNV(color, pname, value);
}

void OSMesaDriver::nfglGetPathColorGenivNV(GLenum color, GLenum pname, GLint *value)
{
	D(bug("nfosmesa: glGetPathColorGenivNV(0x%x, 0x%x, %p)", color, pname, value));
	/* TODO: NFOSMESA_GLGETPATHCOLORGENIVNV may need conversion */
	fn.glGetPathColorGenivNV(color, pname, value);
}

void OSMesaDriver::nfglGetPathCommandsNV(GLuint path, GLubyte *commands)
{
	D(bug("nfosmesa: glGetPathCommandsNV(%u, %p)", path, commands));
	fn.glGetPathCommandsNV(path, commands);
}

void OSMesaDriver::nfglGetPathCoordsNV(GLuint path, GLfloat *coords)
{
	D(bug("nfosmesa: glGetPathCoordsNV(%u, %p)", path, coords));
	/* TODO: NFOSMESA_GLGETPATHCOORDSNV may need conversion */
	fn.glGetPathCoordsNV(path, coords);
}

void OSMesaDriver::nfglGetPathDashArrayNV(GLuint path, GLfloat *dashArray)
{
	D(bug("nfosmesa: glGetPathDashArrayNV(%u, %p)", path, dashArray));
	/* TODO: NFOSMESA_GLGETPATHDASHARRAYNV may need conversion */
	fn.glGetPathDashArrayNV(path, dashArray);
}

GLfloat OSMesaDriver::nfglGetPathLengthNV(GLuint path, GLsizei startSegment, GLsizei numSegments)
{
	D(bug("nfosmesa: glGetPathLengthNV(%u, %d, %d)", path, startSegment, numSegments));
	return fn.glGetPathLengthNV(path, startSegment, numSegments);
}

void OSMesaDriver::nfglGetPathMetricRangeNV(GLbitfield metricQueryMask, GLuint firstPathName, GLsizei numPaths, GLsizei stride, GLfloat *metrics)
{
	D(bug("nfosmesa: glGetPathMetricRangeNV(0x%x, %u, %d, %d, %p)", metricQueryMask, firstPathName, numPaths, stride, metrics));
	/* TODO: NFOSMESA_GLGETPATHMETRICRANGENV may need conversion */
	fn.glGetPathMetricRangeNV(metricQueryMask, firstPathName, numPaths, stride, metrics);
}

void OSMesaDriver::nfglGetPathMetricsNV(GLbitfield metricQueryMask, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLsizei stride, GLfloat *metrics)
{
	D(bug("nfosmesa: glGetPathMetricsNV(0x%x, %d, 0x%x, %p, %u, %d, %p)", metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics));
	/* TODO: NFOSMESA_GLGETPATHMETRICSNV may need conversion */
	fn.glGetPathMetricsNV(metricQueryMask, numPaths, pathNameType, paths, pathBase, stride, metrics);
}

void OSMesaDriver::nfglGetPathParameterfvNV(GLuint path, GLenum pname, GLfloat *value)
{
	D(bug("nfosmesa: glGetPathParameterfvNV(%u, 0x%x, %p)", path, pname, value));
	/* TODO: NFOSMESA_GLGETPATHPARAMETERFVNV may need conversion */
	fn.glGetPathParameterfvNV(path, pname, value);
}

void OSMesaDriver::nfglGetPathParameterivNV(GLuint path, GLenum pname, GLint *value)
{
	D(bug("nfosmesa: glGetPathParameterivNV(%u, 0x%x, %p)", path, pname, value));
	/* TODO: NFOSMESA_GLGETPATHPARAMETERIVNV may need conversion */
	fn.glGetPathParameterivNV(path, pname, value);
}

void OSMesaDriver::nfglGetPathSpacingNV(GLenum pathListMode, GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLfloat advanceScale, GLfloat kerningScale, GLenum transformType, GLfloat *returnedSpacing)
{
	D(bug("nfosmesa: glGetPathSpacingNV(0x%x, %d, 0x%x, %p, %u, %f, %f, 0x%x, %p)", pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing));
	/* TODO: NFOSMESA_GLGETPATHSPACINGNV may need conversion */
	fn.glGetPathSpacingNV(pathListMode, numPaths, pathNameType, paths, pathBase, advanceScale, kerningScale, transformType, returnedSpacing);
}

void OSMesaDriver::nfglGetPathTexGenfvNV(GLenum texCoordSet, GLenum pname, GLfloat *value)
{
	D(bug("nfosmesa: glGetPathTexGenfvNV(0x%x, 0x%x, %p)", texCoordSet, pname, value));
	/* TODO: NFOSMESA_GLGETPATHTEXGENFVNV may need conversion */
	fn.glGetPathTexGenfvNV(texCoordSet, pname, value);
}

void OSMesaDriver::nfglGetPathTexGenivNV(GLenum texCoordSet, GLenum pname, GLint *value)
{
	D(bug("nfosmesa: glGetPathTexGenivNV(0x%x, 0x%x, %p)", texCoordSet, pname, value));
	/* TODO: NFOSMESA_GLGETPATHTEXGENIVNV may need conversion */
	fn.glGetPathTexGenivNV(texCoordSet, pname, value);
}

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)
{
	D(bug("nfosmesa: glGetPerfCounterInfoINTEL(%u, %u, %u, %p, %u, %p, %p, %p, %p, %p, %p)", queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue));
	/* TODO: NFOSMESA_GLGETPERFCOUNTERINFOINTEL may need conversion */
	fn.glGetPerfCounterInfoINTEL(queryId, counterId, counterNameLength, counterName, counterDescLength, counterDesc, counterOffset, counterDataSize, counterTypeEnum, counterDataTypeEnum, rawCounterMaxValue);
}

void OSMesaDriver::nfglGetPerfMonitorCounterDataAMD(GLuint monitor, GLenum pname, GLsizei dataSize, GLuint *data, GLint *bytesWritten)
{
	D(bug("nfosmesa: glGetPerfMonitorCounterDataAMD(%u, 0x%x, %d, %p, %p)", monitor, pname, dataSize, data, bytesWritten));
	/* TODO: NFOSMESA_GLGETPERFMONITORCOUNTERDATAAMD may need conversion */
	fn.glGetPerfMonitorCounterDataAMD(monitor, pname, dataSize, data, bytesWritten);
}

void OSMesaDriver::nfglGetPerfMonitorCounterInfoAMD(GLuint group, GLuint counter, GLenum pname, void *data)
{
	D(bug("nfosmesa: glGetPerfMonitorCounterInfoAMD(%u, %u, 0x%x, %p)", group, counter, pname, data));
	/* TODO: NFOSMESA_GLGETPERFMONITORCOUNTERINFOAMD may need conversion */
	fn.glGetPerfMonitorCounterInfoAMD(group, counter, pname, data);
}

void OSMesaDriver::nfglGetPerfMonitorCounterStringAMD(GLuint group, GLuint counter, GLsizei bufSize, GLsizei *length, GLchar *counterString)
{
	D(bug("nfosmesa: glGetPerfMonitorCounterStringAMD(%u, %u, %d, %p, %p)", group, counter, bufSize, length, counterString));
	/* TODO: NFOSMESA_GLGETPERFMONITORCOUNTERSTRINGAMD may need conversion */
	fn.glGetPerfMonitorCounterStringAMD(group, counter, bufSize, length, counterString);
}

void OSMesaDriver::nfglGetPerfMonitorCountersAMD(GLuint group, GLint *numCounters, GLint *maxActiveCounters, GLsizei counterSize, GLuint *counters)
{
	D(bug("nfosmesa: glGetPerfMonitorCountersAMD(%u, %p, %p, %d, %p)", group, numCounters, maxActiveCounters, counterSize, counters));
	/* TODO: NFOSMESA_GLGETPERFMONITORCOUNTERSAMD may need conversion */
	fn.glGetPerfMonitorCountersAMD(group, numCounters, maxActiveCounters, counterSize, counters);
}

void OSMesaDriver::nfglGetPerfMonitorGroupStringAMD(GLuint group, GLsizei bufSize, GLsizei *length, GLchar *groupString)
{
	D(bug("nfosmesa: glGetPerfMonitorGroupStringAMD(%u, %d, %p, %p)", group, bufSize, length, groupString));
	/* TODO: NFOSMESA_GLGETPERFMONITORGROUPSTRINGAMD may need conversion */
	fn.glGetPerfMonitorGroupStringAMD(group, bufSize, length, groupString);
}

void OSMesaDriver::nfglGetPerfMonitorGroupsAMD(GLint *numGroups, GLsizei groupsSize, GLuint *groups)
{
	D(bug("nfosmesa: glGetPerfMonitorGroupsAMD(%p, %d, %p)", numGroups, groupsSize, groups));
	/* TODO: NFOSMESA_GLGETPERFMONITORGROUPSAMD may need conversion */
	fn.glGetPerfMonitorGroupsAMD(numGroups, groupsSize, groups);
}

void OSMesaDriver::nfglGetPerfQueryDataINTEL(GLuint queryHandle, GLuint flags, GLsizei dataSize, GLvoid *data, GLuint *bytesWritten)
{
	D(bug("nfosmesa: glGetPerfQueryDataINTEL(%u, %u, %d, %p, %p)", queryHandle, flags, dataSize, data, bytesWritten));
	/* TODO: NFOSMESA_GLGETPERFQUERYDATAINTEL may need conversion */
	fn.glGetPerfQueryDataINTEL(queryHandle, flags, dataSize, data, bytesWritten);
}

void OSMesaDriver::nfglGetPerfQueryIdByNameINTEL(GLchar *queryName, GLuint *queryId)
{
	D(bug("nfosmesa: glGetPerfQueryIdByNameINTEL(%p, %p)", queryName, queryId));
	/* TODO: NFOSMESA_GLGETPERFQUERYIDBYNAMEINTEL may need conversion */
	fn.glGetPerfQueryIdByNameINTEL(queryName, queryId);
}

void OSMesaDriver::nfglGetPerfQueryInfoINTEL(GLuint queryId, GLuint queryNameLength, GLchar *queryName, GLuint *dataSize, GLuint *noCounters, GLuint *noInstances, GLuint *capsMask)
{
	D(bug("nfosmesa: glGetPerfQueryInfoINTEL(%u, %u, %p, %p, %p, %p, %p)", queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask));
	/* TODO: NFOSMESA_GLGETPERFQUERYINFOINTEL may need conversion */
	fn.glGetPerfQueryInfoINTEL(queryId, queryNameLength, queryName, dataSize, noCounters, noInstances, capsMask);
}

void OSMesaDriver::nfglGetPixelMapfv(GLenum map, GLfloat *values)
{
	D(bug("nfosmesa: glGetPixelMapfv(0x%x, %p)", map, values));
	/* TODO: NFOSMESA_GLGETPIXELMAPFV may need conversion */
	fn.glGetPixelMapfv(map, values);
}

void OSMesaDriver::nfglGetPixelMapuiv(GLenum map, GLuint *values)
{
	D(bug("nfosmesa: glGetPixelMapuiv(0x%x, %p)", map, values));
	/* TODO: NFOSMESA_GLGETPIXELMAPUIV may need conversion */
	fn.glGetPixelMapuiv(map, values);
}

void OSMesaDriver::nfglGetPixelMapusv(GLenum map, GLushort *values)
{
	D(bug("nfosmesa: glGetPixelMapusv(0x%x, %p)", map, values));
	/* TODO: NFOSMESA_GLGETPIXELMAPUSV may need conversion */
	fn.glGetPixelMapusv(map, values);
}

void OSMesaDriver::nfglGetPixelMapxv(GLenum map, GLint size, GLfixed *values)
{
	D(bug("nfosmesa: glGetPixelMapxv(0x%x, %d, %p)", map, size, values));
	/* TODO: NFOSMESA_GLGETPIXELMAPXV may need conversion */
	fn.glGetPixelMapxv(map, size, values);
}

void OSMesaDriver::nfglGetPixelTexGenParameterfvSGIS(GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetPixelTexGenParameterfvSGIS(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLGETPIXELTEXGENPARAMETERFVSGIS may need conversion */
	fn.glGetPixelTexGenParameterfvSGIS(pname, params);
}

void OSMesaDriver::nfglGetPixelTexGenParameterivSGIS(GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetPixelTexGenParameterivSGIS(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLGETPIXELTEXGENPARAMETERIVSGIS may need conversion */
	fn.glGetPixelTexGenParameterivSGIS(pname, params);
}

void OSMesaDriver::nfglGetPixelTransformParameterfvEXT(GLenum target, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetPixelTransformParameterfvEXT(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETPIXELTRANSFORMPARAMETERFVEXT may need conversion */
	fn.glGetPixelTransformParameterfvEXT(target, pname, params);
}

void OSMesaDriver::nfglGetPixelTransformParameterivEXT(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetPixelTransformParameterivEXT(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETPIXELTRANSFORMPARAMETERIVEXT may need conversion */
	fn.glGetPixelTransformParameterivEXT(target, pname, params);
}

void OSMesaDriver::nfglGetPointerIndexedvEXT(GLenum target, GLuint index, void * *data)
{
	D(bug("nfosmesa: glGetPointerIndexedvEXT(0x%x, %u, %p)", target, index, data));
	/* TODO: NFOSMESA_GLGETPOINTERINDEXEDVEXT may need conversion */
	fn.glGetPointerIndexedvEXT(target, index, data);
}

void OSMesaDriver::nfglGetPointeri_vEXT(GLenum pname, GLuint index, void * *params)
{
	D(bug("nfosmesa: glGetPointeri_vEXT(0x%x, %u, %p)", pname, index, params));
	/* TODO: NFOSMESA_GLGETPOINTERI_VEXT may need conversion */
	fn.glGetPointeri_vEXT(pname, index, params);
}

void OSMesaDriver::nfglGetPointerv(GLenum pname, GLvoid* *params)
{
	D(bug("nfosmesa: glGetPointerv(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLGETPOINTERV may need conversion */
	fn.glGetPointerv(pname, params);
}

void OSMesaDriver::nfglGetPointervEXT(GLenum pname, void * *params)
{
	D(bug("nfosmesa: glGetPointervEXT(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLGETPOINTERVEXT may need conversion */
	fn.glGetPointervEXT(pname, params);
}

void OSMesaDriver::nfglGetPolygonStipple(GLubyte *mask)
{
	D(bug("nfosmesa: glGetPolygonStipple(%p)", mask));
	fn.glGetPolygonStipple(mask);
}

void OSMesaDriver::nfglGetProgramBinary(GLuint program, GLsizei bufSize, GLsizei *length, GLenum *binaryFormat, void *binary)
{
	D(bug("nfosmesa: glGetProgramBinary(%u, %d, %p, %p, %p)", program, bufSize, length, binaryFormat, binary));
	/* TODO: NFOSMESA_GLGETPROGRAMBINARY may need conversion */
	fn.glGetProgramBinary(program, bufSize, length, binaryFormat, binary);
}

void OSMesaDriver::nfglGetProgramEnvParameterIivNV(GLenum target, GLuint index, GLint *params)
{
	D(bug("nfosmesa: glGetProgramEnvParameterIivNV(0x%x, %u, %p)", target, index, params));
	/* TODO: NFOSMESA_GLGETPROGRAMENVPARAMETERIIVNV may need conversion */
	fn.glGetProgramEnvParameterIivNV(target, index, params);
}

void OSMesaDriver::nfglGetProgramEnvParameterIuivNV(GLenum target, GLuint index, GLuint *params)
{
	D(bug("nfosmesa: glGetProgramEnvParameterIuivNV(0x%x, %u, %p)", target, index, params));
	/* TODO: NFOSMESA_GLGETPROGRAMENVPARAMETERIUIVNV may need conversion */
	fn.glGetProgramEnvParameterIuivNV(target, index, params);
}

void OSMesaDriver::nfglGetProgramEnvParameterdvARB(GLenum target, GLuint index, GLdouble *params)
{
	D(bug("nfosmesa: glGetProgramEnvParameterdvARB(0x%x, %u, %p)", target, index, params));
	/* TODO: NFOSMESA_GLGETPROGRAMENVPARAMETERDVARB may need conversion */
	fn.glGetProgramEnvParameterdvARB(target, index, params);
}

void OSMesaDriver::nfglGetProgramEnvParameterfvARB(GLenum target, GLuint index, GLfloat *params)
{
	D(bug("nfosmesa: glGetProgramEnvParameterfvARB(0x%x, %u, %p)", target, index, params));
	/* TODO: NFOSMESA_GLGETPROGRAMENVPARAMETERFVARB may need conversion */
	fn.glGetProgramEnvParameterfvARB(target, index, params);
}

void OSMesaDriver::nfglGetProgramInfoLog(GLuint program, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
{
	D(bug("nfosmesa: glGetProgramInfoLog(%u, %d, %p, %p)", program, bufSize, length, infoLog));
	/* TODO: NFOSMESA_GLGETPROGRAMINFOLOG may need conversion */
	fn.glGetProgramInfoLog(program, bufSize, length, infoLog);
}

void OSMesaDriver::nfglGetProgramInterfaceiv(GLuint program, GLenum programInterface, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetProgramInterfaceiv(%u, 0x%x, 0x%x, %p)", program, programInterface, pname, params));
	/* TODO: NFOSMESA_GLGETPROGRAMINTERFACEIV may need conversion */
	fn.glGetProgramInterfaceiv(program, programInterface, pname, params);
}

void OSMesaDriver::nfglGetProgramLocalParameterIivNV(GLenum target, GLuint index, GLint *params)
{
	D(bug("nfosmesa: glGetProgramLocalParameterIivNV(0x%x, %u, %p)", target, index, params));
	/* TODO: NFOSMESA_GLGETPROGRAMLOCALPARAMETERIIVNV may need conversion */
	fn.glGetProgramLocalParameterIivNV(target, index, params);
}

void OSMesaDriver::nfglGetProgramLocalParameterIuivNV(GLenum target, GLuint index, GLuint *params)
{
	D(bug("nfosmesa: glGetProgramLocalParameterIuivNV(0x%x, %u, %p)", target, index, params));
	/* TODO: NFOSMESA_GLGETPROGRAMLOCALPARAMETERIUIVNV may need conversion */
	fn.glGetProgramLocalParameterIuivNV(target, index, params);
}

void OSMesaDriver::nfglGetProgramLocalParameterdvARB(GLenum target, GLuint index, GLdouble *params)
{
	D(bug("nfosmesa: glGetProgramLocalParameterdvARB(0x%x, %u, %p)", target, index, params));
	/* TODO: NFOSMESA_GLGETPROGRAMLOCALPARAMETERDVARB may need conversion */
	fn.glGetProgramLocalParameterdvARB(target, index, params);
}

void OSMesaDriver::nfglGetProgramLocalParameterfvARB(GLenum target, GLuint index, GLfloat *params)
{
	D(bug("nfosmesa: glGetProgramLocalParameterfvARB(0x%x, %u, %p)", target, index, params));
	/* TODO: NFOSMESA_GLGETPROGRAMLOCALPARAMETERFVARB may need conversion */
	fn.glGetProgramLocalParameterfvARB(target, index, params);
}

void OSMesaDriver::nfglGetProgramNamedParameterdvNV(GLuint id, GLsizei len, const GLubyte *name, GLdouble *params)
{
	D(bug("nfosmesa: glGetProgramNamedParameterdvNV(%u, %d, %p, %p)", id, len, name, params));
	/* TODO: NFOSMESA_GLGETPROGRAMNAMEDPARAMETERDVNV may need conversion */
	fn.glGetProgramNamedParameterdvNV(id, len, name, params);
}

void OSMesaDriver::nfglGetProgramNamedParameterfvNV(GLuint id, GLsizei len, const GLubyte *name, GLfloat *params)
{
	D(bug("nfosmesa: glGetProgramNamedParameterfvNV(%u, %d, %p, %p)", id, len, name, params));
	/* TODO: NFOSMESA_GLGETPROGRAMNAMEDPARAMETERFVNV may need conversion */
	fn.glGetProgramNamedParameterfvNV(id, len, name, params);
}

void OSMesaDriver::nfglGetProgramParameterdvNV(GLenum target, GLuint index, GLenum pname, GLdouble *params)
{
	D(bug("nfosmesa: glGetProgramParameterdvNV(0x%x, %u, 0x%x, %p)", target, index, pname, params));
	/* TODO: NFOSMESA_GLGETPROGRAMPARAMETERDVNV may need conversion */
	fn.glGetProgramParameterdvNV(target, index, pname, params);
}

void OSMesaDriver::nfglGetProgramParameterfvNV(GLenum target, GLuint index, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetProgramParameterfvNV(0x%x, %u, 0x%x, %p)", target, index, pname, params));
	/* TODO: NFOSMESA_GLGETPROGRAMPARAMETERFVNV may need conversion */
	fn.glGetProgramParameterfvNV(target, index, pname, params);
}

void OSMesaDriver::nfglGetProgramPipelineInfoLog(GLuint pipeline, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
{
	D(bug("nfosmesa: glGetProgramPipelineInfoLog(%u, %d, %p, %p)", pipeline, bufSize, length, infoLog));
	/* TODO: NFOSMESA_GLGETPROGRAMPIPELINEINFOLOG may need conversion */
	fn.glGetProgramPipelineInfoLog(pipeline, bufSize, length, infoLog);
}

void OSMesaDriver::nfglGetProgramPipelineiv(GLuint pipeline, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetProgramPipelineiv(%u, 0x%x, %p)", pipeline, pname, params));
	/* TODO: NFOSMESA_GLGETPROGRAMPIPELINEIV may need conversion */
	fn.glGetProgramPipelineiv(pipeline, pname, params);
}

void OSMesaDriver::nfglGetProgramRegisterfvMESA(GLenum target, GLsizei len, const GLubyte *name, GLfloat *v)
{
	D(bug("nfosmesa: glGetProgramRegisterfvMESA(0x%x, %d, %p, %p)", target, len, name, v));
	/* TODO: NFOSMESA_GLGETPROGRAMREGISTERFVMESA may need conversion */
	fn.glGetProgramRegisterfvMESA(target, len, name, v);
}

GLuint OSMesaDriver::nfglGetProgramResourceIndex(GLuint program, GLenum programInterface, const GLchar *name)
{
	D(bug("nfosmesa: glGetProgramResourceIndex(%u, 0x%x, %p)", program, programInterface, name));
	/* TODO: NFOSMESA_GLGETPROGRAMRESOURCEINDEX may need conversion */
	return fn.glGetProgramResourceIndex(program, programInterface, name);
}

GLint OSMesaDriver::nfglGetProgramResourceLocation(GLuint program, GLenum programInterface, const GLchar *name)
{
	D(bug("nfosmesa: glGetProgramResourceLocation(%u, 0x%x, %p)", program, programInterface, name));
	/* TODO: NFOSMESA_GLGETPROGRAMRESOURCELOCATION may need conversion */
	return fn.glGetProgramResourceLocation(program, programInterface, name);
}

GLint OSMesaDriver::nfglGetProgramResourceLocationIndex(GLuint program, GLenum programInterface, const GLchar *name)
{
	D(bug("nfosmesa: glGetProgramResourceLocationIndex(%u, 0x%x, %p)", program, programInterface, name));
	/* TODO: NFOSMESA_GLGETPROGRAMRESOURCELOCATIONINDEX may need conversion */
	return fn.glGetProgramResourceLocationIndex(program, programInterface, name);
}

void OSMesaDriver::nfglGetProgramResourceName(GLuint program, GLenum programInterface, GLuint index, GLsizei bufSize, GLsizei *length, GLchar *name)
{
	D(bug("nfosmesa: glGetProgramResourceName(%u, 0x%x, %u, %d, %p, %p)", program, programInterface, index, bufSize, length, name));
	/* TODO: NFOSMESA_GLGETPROGRAMRESOURCENAME may need conversion */
	fn.glGetProgramResourceName(program, programInterface, index, bufSize, length, name);
}

void OSMesaDriver::nfglGetProgramResourceiv(GLuint program, GLenum programInterface, GLuint index, GLsizei propCount, const GLenum *props, GLsizei bufSize, GLsizei *length, GLint *params)
{
	D(bug("nfosmesa: glGetProgramResourceiv(%u, 0x%x, %u, %d, %p, %d, %p, %p)", program, programInterface, index, propCount, props, bufSize, length, params));
	/* TODO: NFOSMESA_GLGETPROGRAMRESOURCEIV may need conversion */
	fn.glGetProgramResourceiv(program, programInterface, index, propCount, props, bufSize, length, params);
}

void OSMesaDriver::nfglGetProgramStageiv(GLuint program, GLenum shadertype, GLenum pname, GLint *values)
{
	D(bug("nfosmesa: glGetProgramStageiv(%u, 0x%x, 0x%x, %p)", program, shadertype, pname, values));
	/* TODO: NFOSMESA_GLGETPROGRAMSTAGEIV may need conversion */
	fn.glGetProgramStageiv(program, shadertype, pname, values);
}

void OSMesaDriver::nfglGetProgramStringARB(GLenum target, GLenum pname, void *string)
{
	D(bug("nfosmesa: glGetProgramStringARB(0x%x, 0x%x, %p)", target, pname, string));
	/* TODO: NFOSMESA_GLGETPROGRAMSTRINGARB may need conversion */
	fn.glGetProgramStringARB(target, pname, string);
}

void OSMesaDriver::nfglGetProgramStringNV(GLuint id, GLenum pname, GLubyte *program)
{
	D(bug("nfosmesa: glGetProgramStringNV(%u, 0x%x, %p)", id, pname, program));
	fn.glGetProgramStringNV(id, pname, program);
}

void OSMesaDriver::nfglGetProgramSubroutineParameteruivNV(GLenum target, GLuint index, GLuint *param)
{
	D(bug("nfosmesa: glGetProgramSubroutineParameteruivNV(0x%x, %u, %p)", target, index, param));
	/* TODO: NFOSMESA_GLGETPROGRAMSUBROUTINEPARAMETERUIVNV may need conversion */
	fn.glGetProgramSubroutineParameteruivNV(target, index, param);
}

void OSMesaDriver::nfglGetProgramiv(GLuint program, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetProgramiv(%u, 0x%x, %p)", program, pname, params));
	/* TODO: NFOSMESA_GLGETPROGRAMIV may need conversion */
	fn.glGetProgramiv(program, pname, params);
}

void OSMesaDriver::nfglGetProgramivARB(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetProgramivARB(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETPROGRAMIVARB may need conversion */
	fn.glGetProgramivARB(target, pname, params);
}

void OSMesaDriver::nfglGetProgramivNV(GLuint id, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetProgramivNV(%u, 0x%x, %p)", id, pname, params));
	/* TODO: NFOSMESA_GLGETPROGRAMIVNV may need conversion */
	fn.glGetProgramivNV(id, pname, params);
}

void OSMesaDriver::nfglGetQueryIndexediv(GLenum target, GLuint index, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetQueryIndexediv(0x%x, %u, 0x%x, %p)", target, index, pname, params));
	/* TODO: NFOSMESA_GLGETQUERYINDEXEDIV may need conversion */
	fn.glGetQueryIndexediv(target, index, pname, params);
}

void OSMesaDriver::nfglGetQueryObjecti64v(GLuint id, GLenum pname, GLint64 *params)
{
	D(bug("nfosmesa: glGetQueryObjecti64v(%u, 0x%x, %p)", id, pname, params));
	/* TODO: NFOSMESA_GLGETQUERYOBJECTI64V may need conversion */
	fn.glGetQueryObjecti64v(id, pname, params);
}

void OSMesaDriver::nfglGetQueryObjecti64vEXT(GLuint id, GLenum pname, GLint64 *params)
{
	D(bug("nfosmesa: glGetQueryObjecti64vEXT(%u, 0x%x, %p)", id, pname, params));
	/* TODO: NFOSMESA_GLGETQUERYOBJECTI64VEXT may need conversion */
	fn.glGetQueryObjecti64vEXT(id, pname, params);
}

void OSMesaDriver::nfglGetQueryObjectiv(GLuint id, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetQueryObjectiv(%u, 0x%x, %p)", id, pname, params));
	/* TODO: NFOSMESA_GLGETQUERYOBJECTIV may need conversion */
	fn.glGetQueryObjectiv(id, pname, params);
}

void OSMesaDriver::nfglGetQueryObjectivARB(GLuint id, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetQueryObjectivARB(%u, 0x%x, %p)", id, pname, params));
	/* TODO: NFOSMESA_GLGETQUERYOBJECTIVARB may need conversion */
	fn.glGetQueryObjectivARB(id, pname, params);
}

void OSMesaDriver::nfglGetQueryObjectui64v(GLuint id, GLenum pname, GLuint64 *params)
{
	D(bug("nfosmesa: glGetQueryObjectui64v(%u, 0x%x, %p)", id, pname, params));
	/* TODO: NFOSMESA_GLGETQUERYOBJECTUI64V may need conversion */
	fn.glGetQueryObjectui64v(id, pname, params);
}

void OSMesaDriver::nfglGetQueryObjectui64vEXT(GLuint id, GLenum pname, GLuint64 *params)
{
	D(bug("nfosmesa: glGetQueryObjectui64vEXT(%u, 0x%x, %p)", id, pname, params));
	/* TODO: NFOSMESA_GLGETQUERYOBJECTUI64VEXT may need conversion */
	fn.glGetQueryObjectui64vEXT(id, pname, params);
}

void OSMesaDriver::nfglGetQueryObjectuiv(GLuint id, GLenum pname, GLuint *params)
{
	D(bug("nfosmesa: glGetQueryObjectuiv(%u, 0x%x, %p)", id, pname, params));
	/* TODO: NFOSMESA_GLGETQUERYOBJECTUIV may need conversion */
	fn.glGetQueryObjectuiv(id, pname, params);
}

void OSMesaDriver::nfglGetQueryObjectuivARB(GLuint id, GLenum pname, GLuint *params)
{
	D(bug("nfosmesa: glGetQueryObjectuivARB(%u, 0x%x, %p)", id, pname, params));
	/* TODO: NFOSMESA_GLGETQUERYOBJECTUIVARB may need conversion */
	fn.glGetQueryObjectuivARB(id, pname, params);
}

void OSMesaDriver::nfglGetQueryiv(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetQueryiv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETQUERYIV may need conversion */
	fn.glGetQueryiv(target, pname, params);
}

void OSMesaDriver::nfglGetQueryivARB(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetQueryivARB(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETQUERYIVARB may need conversion */
	fn.glGetQueryivARB(target, pname, params);
}

void OSMesaDriver::nfglGetRenderbufferParameteriv(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetRenderbufferParameteriv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETRENDERBUFFERPARAMETERIV may need conversion */
	fn.glGetRenderbufferParameteriv(target, pname, params);
}

void OSMesaDriver::nfglGetRenderbufferParameterivEXT(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetRenderbufferParameterivEXT(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETRENDERBUFFERPARAMETERIVEXT may need conversion */
	fn.glGetRenderbufferParameterivEXT(target, pname, params);
}

void OSMesaDriver::nfglGetSamplerParameterIiv(GLuint sampler, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetSamplerParameterIiv(%u, 0x%x, %p)", sampler, pname, params));
	/* TODO: NFOSMESA_GLGETSAMPLERPARAMETERIIV may need conversion */
	fn.glGetSamplerParameterIiv(sampler, pname, params);
}

void OSMesaDriver::nfglGetSamplerParameterIuiv(GLuint sampler, GLenum pname, GLuint *params)
{
	D(bug("nfosmesa: glGetSamplerParameterIuiv(%u, 0x%x, %p)", sampler, pname, params));
	/* TODO: NFOSMESA_GLGETSAMPLERPARAMETERIUIV may need conversion */
	fn.glGetSamplerParameterIuiv(sampler, pname, params);
}

void OSMesaDriver::nfglGetSamplerParameterfv(GLuint sampler, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetSamplerParameterfv(%u, 0x%x, %p)", sampler, pname, params));
	/* TODO: NFOSMESA_GLGETSAMPLERPARAMETERFV may need conversion */
	fn.glGetSamplerParameterfv(sampler, pname, params);
}

void OSMesaDriver::nfglGetSamplerParameteriv(GLuint sampler, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetSamplerParameteriv(%u, 0x%x, %p)", sampler, pname, params));
	/* TODO: NFOSMESA_GLGETSAMPLERPARAMETERIV may need conversion */
	fn.glGetSamplerParameteriv(sampler, pname, params);
}

void OSMesaDriver::nfglGetSeparableFilter(GLenum target, GLenum format, GLenum type, void *row, void *column, void *span)
{
	D(bug("nfosmesa: glGetSeparableFilter(0x%x, 0x%x, 0x%x, %p, %p, %p)", target, format, type, row, column, span));
	/* TODO: NFOSMESA_GLGETSEPARABLEFILTER may need conversion */
	fn.glGetSeparableFilter(target, format, type, row, column, span);
}

void OSMesaDriver::nfglGetSeparableFilterEXT(GLenum target, GLenum format, GLenum type, void *row, void *column, void *span)
{
	D(bug("nfosmesa: glGetSeparableFilterEXT(0x%x, 0x%x, 0x%x, %p, %p, %p)", target, format, type, row, column, span));
	/* TODO: NFOSMESA_GLGETSEPARABLEFILTEREXT may need conversion */
	fn.glGetSeparableFilterEXT(target, format, type, row, column, span);
}

void OSMesaDriver::nfglGetShaderInfoLog(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)
{
	D(bug("nfosmesa: glGetShaderInfoLog(%u, %d, %p, %p)", shader, bufSize, length, infoLog));
	/* TODO: NFOSMESA_GLGETSHADERINFOLOG may need conversion */
	fn.glGetShaderInfoLog(shader, bufSize, length, infoLog);
}

void OSMesaDriver::nfglGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
{
	D(bug("nfosmesa: glGetShaderPrecisionFormat(0x%x, 0x%x, %p, %p)", shadertype, precisiontype, range, precision));
	/* TODO: NFOSMESA_GLGETSHADERPRECISIONFORMAT may need conversion */
	fn.glGetShaderPrecisionFormat(shadertype, precisiontype, range, precision);
}

void OSMesaDriver::nfglGetShaderSource(GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *source)
{
	D(bug("nfosmesa: glGetShaderSource(%u, %d, %p, %p)", shader, bufSize, length, source));
	/* TODO: NFOSMESA_GLGETSHADERSOURCE may need conversion */
	fn.glGetShaderSource(shader, bufSize, length, source);
}

void OSMesaDriver::nfglGetShaderSourceARB(GLhandleARB obj, GLsizei maxLength, GLsizei *length, GLcharARB *source)
{
	D(bug("nfosmesa: glGetShaderSourceARB(%u, %d, %p, %p)", obj, maxLength, length, source));
	/* TODO: NFOSMESA_GLGETSHADERSOURCEARB may need conversion */
	fn.glGetShaderSourceARB(obj, maxLength, length, source);
}

void OSMesaDriver::nfglGetShaderiv(GLuint shader, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetShaderiv(%u, 0x%x, %p)", shader, pname, params));
	/* TODO: NFOSMESA_GLGETSHADERIV may need conversion */
	fn.glGetShaderiv(shader, pname, params);
}

void OSMesaDriver::nfglGetSharpenTexFuncSGIS(GLenum target, GLfloat *points)
{
	D(bug("nfosmesa: glGetSharpenTexFuncSGIS(0x%x, %p)", target, points));
	/* TODO: NFOSMESA_GLGETSHARPENTEXFUNCSGIS may need conversion */
	fn.glGetSharpenTexFuncSGIS(target, points);
}

#if 0
const GLubyte * OSMesaDriver::nfglGetString(GLenum name)
{
	D(bug("nfosmesa: glGetString(0x%x)", name));
	return fn.glGetString(name);
}
#endif

#if 0
const GLubyte * OSMesaDriver::nfglGetStringi(GLenum name, GLuint index)
{
	D(bug("nfosmesa: glGetStringi(0x%x, %u)", name, index));
	return fn.glGetStringi(name, index);
}
#endif

GLuint OSMesaDriver::nfglGetSubroutineIndex(GLuint program, GLenum shadertype, const GLchar *name)
{
	D(bug("nfosmesa: glGetSubroutineIndex(%u, 0x%x, %p)", program, shadertype, name));
	/* TODO: NFOSMESA_GLGETSUBROUTINEINDEX may need conversion */
	return fn.glGetSubroutineIndex(program, shadertype, name);
}

GLint OSMesaDriver::nfglGetSubroutineUniformLocation(GLuint program, GLenum shadertype, const GLchar *name)
{
	D(bug("nfosmesa: glGetSubroutineUniformLocation(%u, 0x%x, %p)", program, shadertype, name));
	/* TODO: NFOSMESA_GLGETSUBROUTINEUNIFORMLOCATION may need conversion */
	return fn.glGetSubroutineUniformLocation(program, shadertype, name);
}

void OSMesaDriver::nfglGetSynciv(GLsync sync, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
{
	D(bug("nfosmesa: glGetSynciv(%p, 0x%x, %d, %p, %p)", sync, pname, bufSize, length, values));
	/* TODO: NFOSMESA_GLGETSYNCIV may need conversion */
	fn.glGetSynciv(sync, pname, bufSize, length, values);
}

void OSMesaDriver::nfglGetTexBumpParameterfvATI(GLenum pname, GLfloat *param)
{
	D(bug("nfosmesa: glGetTexBumpParameterfvATI(0x%x, %p)", pname, param));
	/* TODO: NFOSMESA_GLGETTEXBUMPPARAMETERFVATI may need conversion */
	fn.glGetTexBumpParameterfvATI(pname, param);
}

void OSMesaDriver::nfglGetTexBumpParameterivATI(GLenum pname, GLint *param)
{
	D(bug("nfosmesa: glGetTexBumpParameterivATI(0x%x, %p)", pname, param));
	/* TODO: NFOSMESA_GLGETTEXBUMPPARAMETERIVATI may need conversion */
	fn.glGetTexBumpParameterivATI(pname, param);
}

void OSMesaDriver::nfglGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetTexEnvfv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETTEXENVFV may need conversion */
	fn.glGetTexEnvfv(target, pname, params);
}

void OSMesaDriver::nfglGetTexEnviv(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetTexEnviv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETTEXENVIV may need conversion */
	fn.glGetTexEnviv(target, pname, params);
}

void OSMesaDriver::nfglGetTexEnvxvOES(GLenum target, GLenum pname, GLfixed *params)
{
	D(bug("nfosmesa: glGetTexEnvxvOES(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETTEXENVXVOES may need conversion */
	fn.glGetTexEnvxvOES(target, pname, params);
}

void OSMesaDriver::nfglGetTexFilterFuncSGIS(GLenum target, GLenum filter, GLfloat *weights)
{
	D(bug("nfosmesa: glGetTexFilterFuncSGIS(0x%x, 0x%x, %p)", target, filter, weights));
	/* TODO: NFOSMESA_GLGETTEXFILTERFUNCSGIS may need conversion */
	fn.glGetTexFilterFuncSGIS(target, filter, weights);
}

void OSMesaDriver::nfglGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
{
	D(bug("nfosmesa: glGetTexGendv(0x%x, 0x%x, %p)", coord, pname, params));
	/* TODO: NFOSMESA_GLGETTEXGENDV may need conversion */
	fn.glGetTexGendv(coord, pname, params);
}

void OSMesaDriver::nfglGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetTexGenfv(0x%x, 0x%x, %p)", coord, pname, params));
	/* TODO: NFOSMESA_GLGETTEXGENFV may need conversion */
	fn.glGetTexGenfv(coord, pname, params);
}

void OSMesaDriver::nfglGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetTexGeniv(0x%x, 0x%x, %p)", coord, pname, params));
	/* TODO: NFOSMESA_GLGETTEXGENIV may need conversion */
	fn.glGetTexGeniv(coord, pname, params);
}

void OSMesaDriver::nfglGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params)
{
	D(bug("nfosmesa: glGetTexGenxvOES(0x%x, 0x%x, %p)", coord, pname, params));
	/* TODO: NFOSMESA_GLGETTEXGENXVOES may need conversion */
	fn.glGetTexGenxvOES(coord, pname, params);
}

void OSMesaDriver::nfglGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
{
	D(bug("nfosmesa: glGetTexImage(0x%x, %d, 0x%x, 0x%x, %p)", target, level, format, type, pixels));
	/* TODO: NFOSMESA_GLGETTEXIMAGE may need conversion */
	fn.glGetTexImage(target, level, format, type, pixels);
}

void OSMesaDriver::nfglGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetTexLevelParameterfv(0x%x, %d, 0x%x, %p)", target, level, pname, params));
	/* TODO: NFOSMESA_GLGETTEXLEVELPARAMETERFV may need conversion */
	fn.glGetTexLevelParameterfv(target, level, pname, params);
}

void OSMesaDriver::nfglGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetTexLevelParameteriv(0x%x, %d, 0x%x, %p)", target, level, pname, params));
	/* TODO: NFOSMESA_GLGETTEXLEVELPARAMETERIV may need conversion */
	fn.glGetTexLevelParameteriv(target, level, pname, params);
}

void OSMesaDriver::nfglGetTexLevelParameterxvOES(GLenum target, GLint level, GLenum pname, GLfixed *params)
{
	D(bug("nfosmesa: glGetTexLevelParameterxvOES(0x%x, %d, 0x%x, %p)", target, level, pname, params));
	/* TODO: NFOSMESA_GLGETTEXLEVELPARAMETERXVOES may need conversion */
	fn.glGetTexLevelParameterxvOES(target, level, pname, params);
}

void OSMesaDriver::nfglGetTexParameterIiv(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetTexParameterIiv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETTEXPARAMETERIIV may need conversion */
	fn.glGetTexParameterIiv(target, pname, params);
}

void OSMesaDriver::nfglGetTexParameterIivEXT(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetTexParameterIivEXT(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETTEXPARAMETERIIVEXT may need conversion */
	fn.glGetTexParameterIivEXT(target, pname, params);
}

void OSMesaDriver::nfglGetTexParameterIuiv(GLenum target, GLenum pname, GLuint *params)
{
	D(bug("nfosmesa: glGetTexParameterIuiv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETTEXPARAMETERIUIV may need conversion */
	fn.glGetTexParameterIuiv(target, pname, params);
}

void OSMesaDriver::nfglGetTexParameterIuivEXT(GLenum target, GLenum pname, GLuint *params)
{
	D(bug("nfosmesa: glGetTexParameterIuivEXT(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETTEXPARAMETERIUIVEXT may need conversion */
	fn.glGetTexParameterIuivEXT(target, pname, params);
}

void OSMesaDriver::nfglGetTexParameterPointervAPPLE(GLenum target, GLenum pname, void * *params)
{
	D(bug("nfosmesa: glGetTexParameterPointervAPPLE(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETTEXPARAMETERPOINTERVAPPLE may need conversion */
	fn.glGetTexParameterPointervAPPLE(target, pname, params);
}

void OSMesaDriver::nfglGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetTexParameterfv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETTEXPARAMETERFV may need conversion */
	fn.glGetTexParameterfv(target, pname, params);
}

void OSMesaDriver::nfglGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetTexParameteriv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETTEXPARAMETERIV may need conversion */
	fn.glGetTexParameteriv(target, pname, params);
}

void OSMesaDriver::nfglGetTexParameterxvOES(GLenum target, GLenum pname, GLfixed *params)
{
	D(bug("nfosmesa: glGetTexParameterxvOES(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLGETTEXPARAMETERXVOES may need conversion */
	fn.glGetTexParameterxvOES(target, pname, params);
}

GLuint64 OSMesaDriver::nfglGetTextureHandleARB(GLuint texture)
{
	D(bug("nfosmesa: glGetTextureHandleARB(%u)", texture));
	return fn.glGetTextureHandleARB(texture);
}

GLuint64 OSMesaDriver::nfglGetTextureHandleNV(GLuint texture)
{
	D(bug("nfosmesa: glGetTextureHandleNV(%u)", texture));
	return fn.glGetTextureHandleNV(texture);
}

void OSMesaDriver::nfglGetTextureImageEXT(GLuint texture, GLenum target, GLint level, GLenum format, GLenum type, void *pixels)
{
	D(bug("nfosmesa: glGetTextureImageEXT(%u, 0x%x, %d, 0x%x, 0x%x, %p)", texture, target, level, format, type, pixels));
	/* TODO: NFOSMESA_GLGETTEXTUREIMAGEEXT may need conversion */
	fn.glGetTextureImageEXT(texture, target, level, format, type, pixels);
}

void OSMesaDriver::nfglGetTextureLevelParameterfvEXT(GLuint texture, GLenum target, GLint level, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetTextureLevelParameterfvEXT(%u, 0x%x, %d, 0x%x, %p)", texture, target, level, pname, params));
	/* TODO: NFOSMESA_GLGETTEXTURELEVELPARAMETERFVEXT may need conversion */
	fn.glGetTextureLevelParameterfvEXT(texture, target, level, pname, params);
}

void OSMesaDriver::nfglGetTextureLevelParameterivEXT(GLuint texture, GLenum target, GLint level, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetTextureLevelParameterivEXT(%u, 0x%x, %d, 0x%x, %p)", texture, target, level, pname, params));
	/* TODO: NFOSMESA_GLGETTEXTURELEVELPARAMETERIVEXT may need conversion */
	fn.glGetTextureLevelParameterivEXT(texture, target, level, pname, params);
}

void OSMesaDriver::nfglGetTextureParameterIivEXT(GLuint texture, GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetTextureParameterIivEXT(%u, 0x%x, 0x%x, %p)", texture, target, pname, params));
	/* TODO: NFOSMESA_GLGETTEXTUREPARAMETERIIVEXT may need conversion */
	fn.glGetTextureParameterIivEXT(texture, target, pname, params);
}

void OSMesaDriver::nfglGetTextureParameterIuivEXT(GLuint texture, GLenum target, GLenum pname, GLuint *params)
{
	D(bug("nfosmesa: glGetTextureParameterIuivEXT(%u, 0x%x, 0x%x, %p)", texture, target, pname, params));
	/* TODO: NFOSMESA_GLGETTEXTUREPARAMETERIUIVEXT may need conversion */
	fn.glGetTextureParameterIuivEXT(texture, target, pname, params);
}

void OSMesaDriver::nfglGetTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetTextureParameterfvEXT(%u, 0x%x, 0x%x, %p)", texture, target, pname, params));
	/* TODO: NFOSMESA_GLGETTEXTUREPARAMETERFVEXT may need conversion */
	fn.glGetTextureParameterfvEXT(texture, target, pname, params);
}

void OSMesaDriver::nfglGetTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetTextureParameterivEXT(%u, 0x%x, 0x%x, %p)", texture, target, pname, params));
	/* TODO: NFOSMESA_GLGETTEXTUREPARAMETERIVEXT may need conversion */
	fn.glGetTextureParameterivEXT(texture, target, pname, params);
}

GLuint64 OSMesaDriver::nfglGetTextureSamplerHandleARB(GLuint texture, GLuint sampler)
{
	D(bug("nfosmesa: glGetTextureSamplerHandleARB(%u, %u)", texture, sampler));
	return fn.glGetTextureSamplerHandleARB(texture, sampler);
}

GLuint64 OSMesaDriver::nfglGetTextureSamplerHandleNV(GLuint texture, GLuint sampler)
{
	D(bug("nfosmesa: glGetTextureSamplerHandleNV(%u, %u)", texture, sampler));
	return fn.glGetTextureSamplerHandleNV(texture, sampler);
}

void OSMesaDriver::nfglGetTrackMatrixivNV(GLenum target, GLuint address, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetTrackMatrixivNV(0x%x, %u, 0x%x, %p)", target, address, pname, params));
	/* TODO: NFOSMESA_GLGETTRACKMATRIXIVNV may need conversion */
	fn.glGetTrackMatrixivNV(target, address, pname, params);
}

void OSMesaDriver::nfglGetTransformFeedbackVarying(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
{
	D(bug("nfosmesa: glGetTransformFeedbackVarying(%u, %u, %d, %p, %p, %p, %p)", program, index, bufSize, length, size, type, name));
	/* TODO: NFOSMESA_GLGETTRANSFORMFEEDBACKVARYING may need conversion */
	fn.glGetTransformFeedbackVarying(program, index, bufSize, length, size, type, name);
}

void OSMesaDriver::nfglGetTransformFeedbackVaryingEXT(GLuint program, GLuint index, GLsizei bufSize, GLsizei *length, GLsizei *size, GLenum *type, GLchar *name)
{
	D(bug("nfosmesa: glGetTransformFeedbackVaryingEXT(%u, %u, %d, %p, %p, %p, %p)", program, index, bufSize, length, size, type, name));
	/* TODO: NFOSMESA_GLGETTRANSFORMFEEDBACKVARYINGEXT may need conversion */
	fn.glGetTransformFeedbackVaryingEXT(program, index, bufSize, length, size, type, name);
}

void OSMesaDriver::nfglGetTransformFeedbackVaryingNV(GLuint program, GLuint index, GLint *location)
{
	D(bug("nfosmesa: glGetTransformFeedbackVaryingNV(%u, %u, %p)", program, index, location));
	/* TODO: NFOSMESA_GLGETTRANSFORMFEEDBACKVARYINGNV may need conversion */
	fn.glGetTransformFeedbackVaryingNV(program, index, location);
}

GLuint OSMesaDriver::nfglGetUniformBlockIndex(GLuint program, const GLchar *uniformBlockName)
{
	D(bug("nfosmesa: glGetUniformBlockIndex(%u, %p)", program, uniformBlockName));
	/* TODO: NFOSMESA_GLGETUNIFORMBLOCKINDEX may need conversion */
	return fn.glGetUniformBlockIndex(program, uniformBlockName);
}

GLint OSMesaDriver::nfglGetUniformBufferSizeEXT(GLuint program, GLint location)
{
	D(bug("nfosmesa: glGetUniformBufferSizeEXT(%u, %d)", program, location));
	return fn.glGetUniformBufferSizeEXT(program, location);
}

void OSMesaDriver::nfglGetUniformIndices(GLuint program, GLsizei uniformCount, const GLchar *const *uniformNames, GLuint *uniformIndices)
{
	D(bug("nfosmesa: glGetUniformIndices(%u, %d, %p, %p)", program, uniformCount, uniformNames, uniformIndices));
	/* TODO: NFOSMESA_GLGETUNIFORMINDICES may need conversion */
	fn.glGetUniformIndices(program, uniformCount, uniformNames, uniformIndices);
}

GLint OSMesaDriver::nfglGetUniformLocation(GLuint program, const GLchar *name)
{
	D(bug("nfosmesa: glGetUniformLocation(%u, %p)", program, name));
	/* TODO: NFOSMESA_GLGETUNIFORMLOCATION may need conversion */
	return fn.glGetUniformLocation(program, name);
}

GLint OSMesaDriver::nfglGetUniformLocationARB(GLhandleARB programObj, const GLcharARB *name)
{
	D(bug("nfosmesa: glGetUniformLocationARB(%u, %p)", programObj, name));
	/* TODO: NFOSMESA_GLGETUNIFORMLOCATIONARB may need conversion */
	return fn.glGetUniformLocationARB(programObj, name);
}

GLintptr OSMesaDriver::nfglGetUniformOffsetEXT(GLuint program, GLint location)
{
	D(bug("nfosmesa: glGetUniformOffsetEXT(%u, %d)", program, location));
	return fn.glGetUniformOffsetEXT(program, location);
}

void OSMesaDriver::nfglGetUniformSubroutineuiv(GLenum shadertype, GLint location, GLuint *params)
{
	D(bug("nfosmesa: glGetUniformSubroutineuiv(0x%x, %d, %p)", shadertype, location, params));
	/* TODO: NFOSMESA_GLGETUNIFORMSUBROUTINEUIV may need conversion */
	fn.glGetUniformSubroutineuiv(shadertype, location, params);
}

void OSMesaDriver::nfglGetUniformdv(GLuint program, GLint location, GLdouble *params)
{
	D(bug("nfosmesa: glGetUniformdv(%u, %d, %p)", program, location, params));
	/* TODO: NFOSMESA_GLGETUNIFORMDV may need conversion */
	fn.glGetUniformdv(program, location, params);
}

void OSMesaDriver::nfglGetUniformfv(GLuint program, GLint location, GLfloat *params)
{
	D(bug("nfosmesa: glGetUniformfv(%u, %d, %p)", program, location, params));
	/* TODO: NFOSMESA_GLGETUNIFORMFV may need conversion */
	fn.glGetUniformfv(program, location, params);
}

void OSMesaDriver::nfglGetUniformfvARB(GLhandleARB programObj, GLint location, GLfloat *params)
{
	D(bug("nfosmesa: glGetUniformfvARB(%u, %d, %p)", programObj, location, params));
	/* TODO: NFOSMESA_GLGETUNIFORMFVARB may need conversion */
	fn.glGetUniformfvARB(programObj, location, params);
}

void OSMesaDriver::nfglGetUniformi64vNV(GLuint program, GLint location, GLint64EXT *params)
{
	D(bug("nfosmesa: glGetUniformi64vNV(%u, %d, %p)", program, location, params));
	/* TODO: NFOSMESA_GLGETUNIFORMI64VNV may need conversion */
	fn.glGetUniformi64vNV(program, location, params);
}

void OSMesaDriver::nfglGetUniformiv(GLuint program, GLint location, GLint *params)
{
	D(bug("nfosmesa: glGetUniformiv(%u, %d, %p)", program, location, params));
	/* TODO: NFOSMESA_GLGETUNIFORMIV may need conversion */
	fn.glGetUniformiv(program, location, params);
}

void OSMesaDriver::nfglGetUniformivARB(GLhandleARB programObj, GLint location, GLint *params)
{
	D(bug("nfosmesa: glGetUniformivARB(%u, %d, %p)", programObj, location, params));
	/* TODO: NFOSMESA_GLGETUNIFORMIVARB may need conversion */
	fn.glGetUniformivARB(programObj, location, params);
}

void OSMesaDriver::nfglGetUniformui64vNV(GLuint program, GLint location, GLuint64EXT *params)
{
	D(bug("nfosmesa: glGetUniformui64vNV(%u, %d, %p)", program, location, params));
	/* TODO: NFOSMESA_GLGETUNIFORMUI64VNV may need conversion */
	fn.glGetUniformui64vNV(program, location, params);
}

void OSMesaDriver::nfglGetUniformuiv(GLuint program, GLint location, GLuint *params)
{
	D(bug("nfosmesa: glGetUniformuiv(%u, %d, %p)", program, location, params));
	/* TODO: NFOSMESA_GLGETUNIFORMUIV may need conversion */
	fn.glGetUniformuiv(program, location, params);
}

void OSMesaDriver::nfglGetUniformuivEXT(GLuint program, GLint location, GLuint *params)
{
	D(bug("nfosmesa: glGetUniformuivEXT(%u, %d, %p)", program, location, params));
	/* TODO: NFOSMESA_GLGETUNIFORMUIVEXT may need conversion */
	fn.glGetUniformuivEXT(program, location, params);
}

void OSMesaDriver::nfglGetVariantArrayObjectfvATI(GLuint id, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetVariantArrayObjectfvATI(%u, 0x%x, %p)", id, pname, params));
	/* TODO: NFOSMESA_GLGETVARIANTARRAYOBJECTFVATI may need conversion */
	fn.glGetVariantArrayObjectfvATI(id, pname, params);
}

void OSMesaDriver::nfglGetVariantArrayObjectivATI(GLuint id, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetVariantArrayObjectivATI(%u, 0x%x, %p)", id, pname, params));
	/* TODO: NFOSMESA_GLGETVARIANTARRAYOBJECTIVATI may need conversion */
	fn.glGetVariantArrayObjectivATI(id, pname, params);
}

void OSMesaDriver::nfglGetVariantBooleanvEXT(GLuint id, GLenum value, GLboolean *data)
{
	D(bug("nfosmesa: glGetVariantBooleanvEXT(%u, 0x%x, %p)", id, value, data));
	fn.glGetVariantBooleanvEXT(id, value, data);
}

void OSMesaDriver::nfglGetVariantFloatvEXT(GLuint id, GLenum value, GLfloat *data)
{
	D(bug("nfosmesa: glGetVariantFloatvEXT(%u, 0x%x, %p)", id, value, data));
	/* TODO: NFOSMESA_GLGETVARIANTFLOATVEXT may need conversion */
	fn.glGetVariantFloatvEXT(id, value, data);
}

void OSMesaDriver::nfglGetVariantIntegervEXT(GLuint id, GLenum value, GLint *data)
{
	D(bug("nfosmesa: glGetVariantIntegervEXT(%u, 0x%x, %p)", id, value, data));
	/* TODO: NFOSMESA_GLGETVARIANTINTEGERVEXT may need conversion */
	fn.glGetVariantIntegervEXT(id, value, data);
}

void OSMesaDriver::nfglGetVariantPointervEXT(GLuint id, GLenum value, void * *data)
{
	D(bug("nfosmesa: glGetVariantPointervEXT(%u, 0x%x, %p)", id, value, data));
	/* TODO: NFOSMESA_GLGETVARIANTPOINTERVEXT may need conversion */
	fn.glGetVariantPointervEXT(id, value, data);
}

GLint OSMesaDriver::nfglGetVaryingLocationNV(GLuint program, const GLchar *name)
{
	D(bug("nfosmesa: glGetVaryingLocationNV(%u, %p)", program, name));
	/* TODO: NFOSMESA_GLGETVARYINGLOCATIONNV may need conversion */
	return fn.glGetVaryingLocationNV(program, name);
}

void OSMesaDriver::nfglGetVertexArrayIntegeri_vEXT(GLuint vaobj, GLuint index, GLenum pname, GLint *param)
{
	D(bug("nfosmesa: glGetVertexArrayIntegeri_vEXT(%u, %u, 0x%x, %p)", vaobj, index, pname, param));
	/* TODO: NFOSMESA_GLGETVERTEXARRAYINTEGERI_VEXT may need conversion */
	fn.glGetVertexArrayIntegeri_vEXT(vaobj, index, pname, param);
}

void OSMesaDriver::nfglGetVertexArrayIntegervEXT(GLuint vaobj, GLenum pname, GLint *param)
{
	D(bug("nfosmesa: glGetVertexArrayIntegervEXT(%u, 0x%x, %p)", vaobj, pname, param));
	/* TODO: NFOSMESA_GLGETVERTEXARRAYINTEGERVEXT may need conversion */
	fn.glGetVertexArrayIntegervEXT(vaobj, pname, param);
}

void OSMesaDriver::nfglGetVertexArrayPointeri_vEXT(GLuint vaobj, GLuint index, GLenum pname, void * *param)
{
	D(bug("nfosmesa: glGetVertexArrayPointeri_vEXT(%u, %u, 0x%x, %p)", vaobj, index, pname, param));
	/* TODO: NFOSMESA_GLGETVERTEXARRAYPOINTERI_VEXT may need conversion */
	fn.glGetVertexArrayPointeri_vEXT(vaobj, index, pname, param);
}

void OSMesaDriver::nfglGetVertexArrayPointervEXT(GLuint vaobj, GLenum pname, void * *param)
{
	D(bug("nfosmesa: glGetVertexArrayPointervEXT(%u, 0x%x, %p)", vaobj, pname, param));
	/* TODO: NFOSMESA_GLGETVERTEXARRAYPOINTERVEXT may need conversion */
	fn.glGetVertexArrayPointervEXT(vaobj, pname, param);
}

void OSMesaDriver::nfglGetVertexAttribArrayObjectfvATI(GLuint index, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetVertexAttribArrayObjectfvATI(%u, 0x%x, %p)", index, pname, params));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBARRAYOBJECTFVATI may need conversion */
	fn.glGetVertexAttribArrayObjectfvATI(index, pname, params);
}

void OSMesaDriver::nfglGetVertexAttribArrayObjectivATI(GLuint index, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetVertexAttribArrayObjectivATI(%u, 0x%x, %p)", index, pname, params));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBARRAYOBJECTIVATI may need conversion */
	fn.glGetVertexAttribArrayObjectivATI(index, pname, params);
}

void OSMesaDriver::nfglGetVertexAttribIiv(GLuint index, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetVertexAttribIiv(%u, 0x%x, %p)", index, pname, params));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBIIV may need conversion */
	fn.glGetVertexAttribIiv(index, pname, params);
}

void OSMesaDriver::nfglGetVertexAttribIivEXT(GLuint index, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetVertexAttribIivEXT(%u, 0x%x, %p)", index, pname, params));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBIIVEXT may need conversion */
	fn.glGetVertexAttribIivEXT(index, pname, params);
}

void OSMesaDriver::nfglGetVertexAttribIuiv(GLuint index, GLenum pname, GLuint *params)
{
	D(bug("nfosmesa: glGetVertexAttribIuiv(%u, 0x%x, %p)", index, pname, params));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBIUIV may need conversion */
	fn.glGetVertexAttribIuiv(index, pname, params);
}

void OSMesaDriver::nfglGetVertexAttribIuivEXT(GLuint index, GLenum pname, GLuint *params)
{
	D(bug("nfosmesa: glGetVertexAttribIuivEXT(%u, 0x%x, %p)", index, pname, params));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBIUIVEXT may need conversion */
	fn.glGetVertexAttribIuivEXT(index, pname, params);
}

void OSMesaDriver::nfglGetVertexAttribLdv(GLuint index, GLenum pname, GLdouble *params)
{
	D(bug("nfosmesa: glGetVertexAttribLdv(%u, 0x%x, %p)", index, pname, params));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBLDV may need conversion */
	fn.glGetVertexAttribLdv(index, pname, params);
}

void OSMesaDriver::nfglGetVertexAttribLdvEXT(GLuint index, GLenum pname, GLdouble *params)
{
	D(bug("nfosmesa: glGetVertexAttribLdvEXT(%u, 0x%x, %p)", index, pname, params));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBLDVEXT may need conversion */
	fn.glGetVertexAttribLdvEXT(index, pname, params);
}

void OSMesaDriver::nfglGetVertexAttribLi64vNV(GLuint index, GLenum pname, GLint64EXT *params)
{
	D(bug("nfosmesa: glGetVertexAttribLi64vNV(%u, 0x%x, %p)", index, pname, params));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBLI64VNV may need conversion */
	fn.glGetVertexAttribLi64vNV(index, pname, params);
}

void OSMesaDriver::nfglGetVertexAttribLui64vARB(GLuint index, GLenum pname, GLuint64EXT *params)
{
	D(bug("nfosmesa: glGetVertexAttribLui64vARB(%u, 0x%x, %p)", index, pname, params));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBLUI64VARB may need conversion */
	fn.glGetVertexAttribLui64vARB(index, pname, params);
}

void OSMesaDriver::nfglGetVertexAttribLui64vNV(GLuint index, GLenum pname, GLuint64EXT *params)
{
	D(bug("nfosmesa: glGetVertexAttribLui64vNV(%u, 0x%x, %p)", index, pname, params));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBLUI64VNV may need conversion */
	fn.glGetVertexAttribLui64vNV(index, pname, params);
}

void OSMesaDriver::nfglGetVertexAttribPointerv(GLuint index, GLenum pname, void * *pointer)
{
	D(bug("nfosmesa: glGetVertexAttribPointerv(%u, 0x%x, %p)", index, pname, pointer));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBPOINTERV may need conversion */
	fn.glGetVertexAttribPointerv(index, pname, pointer);
}

void OSMesaDriver::nfglGetVertexAttribPointervARB(GLuint index, GLenum pname, void * *pointer)
{
	D(bug("nfosmesa: glGetVertexAttribPointervARB(%u, 0x%x, %p)", index, pname, pointer));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBPOINTERVARB may need conversion */
	fn.glGetVertexAttribPointervARB(index, pname, pointer);
}

void OSMesaDriver::nfglGetVertexAttribPointervNV(GLuint index, GLenum pname, void * *pointer)
{
	D(bug("nfosmesa: glGetVertexAttribPointervNV(%u, 0x%x, %p)", index, pname, pointer));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBPOINTERVNV may need conversion */
	fn.glGetVertexAttribPointervNV(index, pname, pointer);
}

void OSMesaDriver::nfglGetVertexAttribdv(GLuint index, GLenum pname, GLdouble *params)
{
	D(bug("nfosmesa: glGetVertexAttribdv(%u, 0x%x, %p)", index, pname, params));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBDV may need conversion */
	fn.glGetVertexAttribdv(index, pname, params);
}

void OSMesaDriver::nfglGetVertexAttribdvARB(GLuint index, GLenum pname, GLdouble *params)
{
	D(bug("nfosmesa: glGetVertexAttribdvARB(%u, 0x%x, %p)", index, pname, params));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBDVARB may need conversion */
	fn.glGetVertexAttribdvARB(index, pname, params);
}

void OSMesaDriver::nfglGetVertexAttribdvNV(GLuint index, GLenum pname, GLdouble *params)
{
	D(bug("nfosmesa: glGetVertexAttribdvNV(%u, 0x%x, %p)", index, pname, params));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBDVNV may need conversion */
	fn.glGetVertexAttribdvNV(index, pname, params);
}

void OSMesaDriver::nfglGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetVertexAttribfv(%u, 0x%x, %p)", index, pname, params));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBFV may need conversion */
	fn.glGetVertexAttribfv(index, pname, params);
}

void OSMesaDriver::nfglGetVertexAttribfvARB(GLuint index, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetVertexAttribfvARB(%u, 0x%x, %p)", index, pname, params));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBFVARB may need conversion */
	fn.glGetVertexAttribfvARB(index, pname, params);
}

void OSMesaDriver::nfglGetVertexAttribfvNV(GLuint index, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetVertexAttribfvNV(%u, 0x%x, %p)", index, pname, params));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBFVNV may need conversion */
	fn.glGetVertexAttribfvNV(index, pname, params);
}

void OSMesaDriver::nfglGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetVertexAttribiv(%u, 0x%x, %p)", index, pname, params));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBIV may need conversion */
	fn.glGetVertexAttribiv(index, pname, params);
}

void OSMesaDriver::nfglGetVertexAttribivARB(GLuint index, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetVertexAttribivARB(%u, 0x%x, %p)", index, pname, params));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBIVARB may need conversion */
	fn.glGetVertexAttribivARB(index, pname, params);
}

void OSMesaDriver::nfglGetVertexAttribivNV(GLuint index, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetVertexAttribivNV(%u, 0x%x, %p)", index, pname, params));
	/* TODO: NFOSMESA_GLGETVERTEXATTRIBIVNV may need conversion */
	fn.glGetVertexAttribivNV(index, pname, params);
}

void OSMesaDriver::nfglGetVideoCaptureStreamdvNV(GLuint video_capture_slot, GLuint stream, GLenum pname, GLdouble *params)
{
	D(bug("nfosmesa: glGetVideoCaptureStreamdvNV(%u, %u, 0x%x, %p)", video_capture_slot, stream, pname, params));
	/* TODO: NFOSMESA_GLGETVIDEOCAPTURESTREAMDVNV may need conversion */
	fn.glGetVideoCaptureStreamdvNV(video_capture_slot, stream, pname, params);
}

void OSMesaDriver::nfglGetVideoCaptureStreamfvNV(GLuint video_capture_slot, GLuint stream, GLenum pname, GLfloat *params)
{
	D(bug("nfosmesa: glGetVideoCaptureStreamfvNV(%u, %u, 0x%x, %p)", video_capture_slot, stream, pname, params));
	/* TODO: NFOSMESA_GLGETVIDEOCAPTURESTREAMFVNV may need conversion */
	fn.glGetVideoCaptureStreamfvNV(video_capture_slot, stream, pname, params);
}

void OSMesaDriver::nfglGetVideoCaptureStreamivNV(GLuint video_capture_slot, GLuint stream, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetVideoCaptureStreamivNV(%u, %u, 0x%x, %p)", video_capture_slot, stream, pname, params));
	/* TODO: NFOSMESA_GLGETVIDEOCAPTURESTREAMIVNV may need conversion */
	fn.glGetVideoCaptureStreamivNV(video_capture_slot, stream, pname, params);
}

void OSMesaDriver::nfglGetVideoCaptureivNV(GLuint video_capture_slot, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetVideoCaptureivNV(%u, 0x%x, %p)", video_capture_slot, pname, params));
	/* TODO: NFOSMESA_GLGETVIDEOCAPTUREIVNV may need conversion */
	fn.glGetVideoCaptureivNV(video_capture_slot, pname, params);
}

void OSMesaDriver::nfglGetVideoi64vNV(GLuint video_slot, GLenum pname, GLint64EXT *params)
{
	D(bug("nfosmesa: glGetVideoi64vNV(%u, 0x%x, %p)", video_slot, pname, params));
	/* TODO: NFOSMESA_GLGETVIDEOI64VNV may need conversion */
	fn.glGetVideoi64vNV(video_slot, pname, params);
}

void OSMesaDriver::nfglGetVideoivNV(GLuint video_slot, GLenum pname, GLint *params)
{
	D(bug("nfosmesa: glGetVideoivNV(%u, 0x%x, %p)", video_slot, pname, params));
	/* TODO: NFOSMESA_GLGETVIDEOIVNV may need conversion */
	fn.glGetVideoivNV(video_slot, pname, params);
}

void OSMesaDriver::nfglGetVideoui64vNV(GLuint video_slot, GLenum pname, GLuint64EXT *params)
{
	D(bug("nfosmesa: glGetVideoui64vNV(%u, 0x%x, %p)", video_slot, pname, params));
	/* TODO: NFOSMESA_GLGETVIDEOUI64VNV may need conversion */
	fn.glGetVideoui64vNV(video_slot, pname, params);
}

void OSMesaDriver::nfglGetVideouivNV(GLuint video_slot, GLenum pname, GLuint *params)
{
	D(bug("nfosmesa: glGetVideouivNV(%u, 0x%x, %p)", video_slot, pname, params));
	/* TODO: NFOSMESA_GLGETVIDEOUIVNV may need conversion */
	fn.glGetVideouivNV(video_slot, pname, params);
}

void OSMesaDriver::nfglGetnColorTableARB(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *table)
{
	D(bug("nfosmesa: glGetnColorTableARB(0x%x, 0x%x, 0x%x, %d, %p)", target, format, type, bufSize, table));
	/* TODO: NFOSMESA_GLGETNCOLORTABLEARB may need conversion */
	fn.glGetnColorTableARB(target, format, type, bufSize, table);
}

void OSMesaDriver::nfglGetnCompressedTexImageARB(GLenum target, GLint lod, GLsizei bufSize, void *img)
{
	D(bug("nfosmesa: glGetnCompressedTexImageARB(0x%x, %d, %d, %p)", target, lod, bufSize, img));
	/* TODO: NFOSMESA_GLGETNCOMPRESSEDTEXIMAGEARB may need conversion */
	fn.glGetnCompressedTexImageARB(target, lod, bufSize, img);
}

void OSMesaDriver::nfglGetnConvolutionFilterARB(GLenum target, GLenum format, GLenum type, GLsizei bufSize, void *image)
{
	D(bug("nfosmesa: glGetnConvolutionFilterARB(0x%x, 0x%x, 0x%x, %d, %p)", target, format, type, bufSize, image));
	/* TODO: NFOSMESA_GLGETNCONVOLUTIONFILTERARB may need conversion */
	fn.glGetnConvolutionFilterARB(target, format, type, bufSize, image);
}

void OSMesaDriver::nfglGetnHistogramARB(GLenum target, GLboolean32 reset, GLenum format, GLenum type, GLsizei bufSize, void *values)
{
	D(bug("nfosmesa: glGetnHistogramARB(0x%x, %d, 0x%x, 0x%x, %d, %p)", target, reset, format, type, bufSize, values));
	/* TODO: NFOSMESA_GLGETNHISTOGRAMARB may need conversion */
	fn.glGetnHistogramARB(target, reset, format, type, bufSize, values);
}

void OSMesaDriver::nfglGetnMapdvARB(GLenum target, GLenum query, GLsizei bufSize, GLdouble *v)
{
	D(bug("nfosmesa: glGetnMapdvARB(0x%x, 0x%x, %d, %p)", target, query, bufSize, v));
	/* TODO: NFOSMESA_GLGETNMAPDVARB may need conversion */
	fn.glGetnMapdvARB(target, query, bufSize, v);
}

void OSMesaDriver::nfglGetnMapfvARB(GLenum target, GLenum query, GLsizei bufSize, GLfloat *v)
{
	D(bug("nfosmesa: glGetnMapfvARB(0x%x, 0x%x, %d, %p)", target, query, bufSize, v));
	/* TODO: NFOSMESA_GLGETNMAPFVARB may need conversion */
	fn.glGetnMapfvARB(target, query, bufSize, v);
}

void OSMesaDriver::nfglGetnMapivARB(GLenum target, GLenum query, GLsizei bufSize, GLint *v)
{
	D(bug("nfosmesa: glGetnMapivARB(0x%x, 0x%x, %d, %p)", target, query, bufSize, v));
	/* TODO: NFOSMESA_GLGETNMAPIVARB may need conversion */
	fn.glGetnMapivARB(target, query, bufSize, v);
}

void OSMesaDriver::nfglGetnMinmaxARB(GLenum target, GLboolean32 reset, GLenum format, GLenum type, GLsizei bufSize, void *values)
{
	D(bug("nfosmesa: glGetnMinmaxARB(0x%x, %d, 0x%x, 0x%x, %d, %p)", target, reset, format, type, bufSize, values));
	/* TODO: NFOSMESA_GLGETNMINMAXARB may need conversion */
	fn.glGetnMinmaxARB(target, reset, format, type, bufSize, values);
}

void OSMesaDriver::nfglGetnPixelMapfvARB(GLenum map, GLsizei bufSize, GLfloat *values)
{
	D(bug("nfosmesa: glGetnPixelMapfvARB(0x%x, %d, %p)", map, bufSize, values));
	/* TODO: NFOSMESA_GLGETNPIXELMAPFVARB may need conversion */
	fn.glGetnPixelMapfvARB(map, bufSize, values);
}

void OSMesaDriver::nfglGetnPixelMapuivARB(GLenum map, GLsizei bufSize, GLuint *values)
{
	D(bug("nfosmesa: glGetnPixelMapuivARB(0x%x, %d, %p)", map, bufSize, values));
	/* TODO: NFOSMESA_GLGETNPIXELMAPUIVARB may need conversion */
	fn.glGetnPixelMapuivARB(map, bufSize, values);
}

void OSMesaDriver::nfglGetnPixelMapusvARB(GLenum map, GLsizei bufSize, GLushort *values)
{
	D(bug("nfosmesa: glGetnPixelMapusvARB(0x%x, %d, %p)", map, bufSize, values));
	/* TODO: NFOSMESA_GLGETNPIXELMAPUSVARB may need conversion */
	fn.glGetnPixelMapusvARB(map, bufSize, values);
}

void OSMesaDriver::nfglGetnPolygonStippleARB(GLsizei bufSize, GLubyte *pattern)
{
	D(bug("nfosmesa: glGetnPolygonStippleARB(%d, %p)", bufSize, pattern));
	fn.glGetnPolygonStippleARB(bufSize, pattern);
}

void OSMesaDriver::nfglGetnSeparableFilterARB(GLenum target, GLenum format, GLenum type, GLsizei rowBufSize, void *row, GLsizei columnBufSize, void *column, void *span)
{
	D(bug("nfosmesa: glGetnSeparableFilterARB(0x%x, 0x%x, 0x%x, %d, %p, %d, %p, %p)", target, format, type, rowBufSize, row, columnBufSize, column, span));
	/* TODO: NFOSMESA_GLGETNSEPARABLEFILTERARB may need conversion */
	fn.glGetnSeparableFilterARB(target, format, type, rowBufSize, row, columnBufSize, column, span);
}

void OSMesaDriver::nfglGetnTexImageARB(GLenum target, GLint level, GLenum format, GLenum type, GLsizei bufSize, void *img)
{
	D(bug("nfosmesa: glGetnTexImageARB(0x%x, %d, 0x%x, 0x%x, %d, %p)", target, level, format, type, bufSize, img));
	/* TODO: NFOSMESA_GLGETNTEXIMAGEARB may need conversion */
	fn.glGetnTexImageARB(target, level, format, type, bufSize, img);
}

void OSMesaDriver::nfglGetnUniformdvARB(GLuint program, GLint location, GLsizei bufSize, GLdouble *params)
{
	D(bug("nfosmesa: glGetnUniformdvARB(%u, %d, %d, %p)", program, location, bufSize, params));
	/* TODO: NFOSMESA_GLGETNUNIFORMDVARB may need conversion */
	fn.glGetnUniformdvARB(program, location, bufSize, params);
}

void OSMesaDriver::nfglGetnUniformfvARB(GLuint program, GLint location, GLsizei bufSize, GLfloat *params)
{
	D(bug("nfosmesa: glGetnUniformfvARB(%u, %d, %d, %p)", program, location, bufSize, params));
	/* TODO: NFOSMESA_GLGETNUNIFORMFVARB may need conversion */
	fn.glGetnUniformfvARB(program, location, bufSize, params);
}

void OSMesaDriver::nfglGetnUniformivARB(GLuint program, GLint location, GLsizei bufSize, GLint *params)
{
	D(bug("nfosmesa: glGetnUniformivARB(%u, %d, %d, %p)", program, location, bufSize, params));
	/* TODO: NFOSMESA_GLGETNUNIFORMIVARB may need conversion */
	fn.glGetnUniformivARB(program, location, bufSize, params);
}

void OSMesaDriver::nfglGetnUniformuivARB(GLuint program, GLint location, GLsizei bufSize, GLuint *params)
{
	D(bug("nfosmesa: glGetnUniformuivARB(%u, %d, %d, %p)", program, location, bufSize, params));
	/* TODO: NFOSMESA_GLGETNUNIFORMUIVARB may need conversion */
	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(0x%x, 0x%x)", target, mode));
	fn.glHint(target, mode);
}

void OSMesaDriver::nfglHintPGI(GLenum target, GLint mode)
{
	D(bug("nfosmesa: glHintPGI(0x%x, %d)", target, mode));
	fn.glHintPGI(target, mode);
}

void OSMesaDriver::nfglHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean32 sink)
{
	D(bug("nfosmesa: glHistogram(0x%x, %d, 0x%x, %d)", target, width, internalformat, sink));
	fn.glHistogram(target, width, internalformat, sink);
}

void OSMesaDriver::nfglHistogramEXT(GLenum target, GLsizei width, GLenum internalformat, GLboolean32 sink)
{
	D(bug("nfosmesa: glHistogramEXT(0x%x, %d, 0x%x, %d)", target, width, internalformat, sink));
	fn.glHistogramEXT(target, width, internalformat, sink);
}

void OSMesaDriver::nfglIglooInterfaceSGIX(GLenum pname, const void *params)
{
	D(bug("nfosmesa: glIglooInterfaceSGIX(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLIGLOOINTERFACESGIX may need conversion */
	fn.glIglooInterfaceSGIX(pname, params);
}

void OSMesaDriver::nfglImageTransformParameterfHP(GLenum target, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glImageTransformParameterfHP(0x%x, 0x%x, %f)", target, pname, param));
	fn.glImageTransformParameterfHP(target, pname, param);
}

void OSMesaDriver::nfglImageTransformParameterfvHP(GLenum target, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glImageTransformParameterfvHP(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLIMAGETRANSFORMPARAMETERFVHP may need conversion */
	fn.glImageTransformParameterfvHP(target, pname, params);
}

void OSMesaDriver::nfglImageTransformParameteriHP(GLenum target, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glImageTransformParameteriHP(0x%x, 0x%x, %d)", target, pname, param));
	fn.glImageTransformParameteriHP(target, pname, param);
}

void OSMesaDriver::nfglImageTransformParameterivHP(GLenum target, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glImageTransformParameterivHP(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLIMAGETRANSFORMPARAMETERIVHP may need conversion */
	fn.glImageTransformParameterivHP(target, pname, params);
}

#if 0
GLsync OSMesaDriver::nfglImportSyncEXT(GLenum external_sync_type, GLintptr external_sync, GLbitfield flags)
{
	D(bug("nfosmesa: glImportSyncEXT(0x%x, %ld, 0x%x)", external_sync_type, external_sync, flags));
	return fn.glImportSyncEXT(external_sync_type, external_sync, flags);
}
#endif

void OSMesaDriver::nfglIndexFormatNV(GLenum type, GLsizei stride)
{
	D(bug("nfosmesa: glIndexFormatNV(0x%x, %d)", type, stride));
	fn.glIndexFormatNV(type, stride);
}

void OSMesaDriver::nfglIndexFuncEXT(GLenum func, GLclampf ref)
{
	D(bug("nfosmesa: glIndexFuncEXT(0x%x, %f)", 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(0x%x, 0x%x)", face, mode));
	fn.glIndexMaterialEXT(face, mode);
}

void OSMesaDriver::nfglIndexPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
{
	D(bug("nfosmesa: glIndexPointer(0x%x, %d, %p)", type, stride, pointer));
FN_GLINDEXPOINTER(type, stride, pointer);
}

void OSMesaDriver::nfglIndexPointerEXT(GLenum type, GLsizei stride, GLsizei count, const void *pointer)
{
	D(bug("nfosmesa: glIndexPointerEXT(0x%x, %d, %d, %p)", type, stride, count, pointer));
	/* TODO: NFOSMESA_GLINDEXPOINTEREXT may need conversion */
	fn.glIndexPointerEXT(type, stride, count, pointer);
}

void OSMesaDriver::nfglIndexPointerListIBM(GLenum type, GLint stride, const void * *pointer, GLint ptrstride)
{
	D(bug("nfosmesa: glIndexPointerListIBM(0x%x, %d, %p, %d)", type, stride, pointer, ptrstride));
	/* TODO: NFOSMESA_GLINDEXPOINTERLISTIBM may need conversion */
	fn.glIndexPointerListIBM(type, stride, pointer, ptrstride);
}

void OSMesaDriver::nfglIndexd(GLdouble c)
{
	D(bug("nfosmesa: glIndexd(%f)", c));
	fn.glIndexd(c);
}

void OSMesaDriver::nfglIndexdv(const GLdouble *c)
{
	D(bug("nfosmesa: glIndexdv(%p)", c));
FN_GLINDEXDV(c);
}

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

void OSMesaDriver::nfglIndexfv(const GLfloat *c)
{
	D(bug("nfosmesa: glIndexfv(%p)", c));
FN_GLINDEXFV(c);
}

void OSMesaDriver::nfglIndexi(GLint c)
{
	D(bug("nfosmesa: glIndexi(%d)", c));
	fn.glIndexi(c);
}

void OSMesaDriver::nfglIndexiv(const GLint *c)
{
	D(bug("nfosmesa: glIndexiv(%p)", c));
FN_GLINDEXIV(c);
}

void OSMesaDriver::nfglIndexs(GLshort32 c)
{
	D(bug("nfosmesa: glIndexs(%d)", c));
	fn.glIndexs(c);
}

void OSMesaDriver::nfglIndexsv(const GLshort *c)
{
	D(bug("nfosmesa: glIndexsv(%p)", c));
FN_GLINDEXSV(c);
}

void OSMesaDriver::nfglIndexub(GLubyte32 c)
{
	D(bug("nfosmesa: glIndexub(%u)", c));
	fn.glIndexub(c);
}

void OSMesaDriver::nfglIndexubv(const GLubyte *c)
{
	D(bug("nfosmesa: glIndexubv(%p)", c));
	/* TODO: NFOSMESA_GLINDEXUBV may need conversion */
	fn.glIndexubv(c);
}

void OSMesaDriver::nfglIndexxOES(GLfixed component)
{
	D(bug("nfosmesa: glIndexxOES(0x%x)", component));
	fn.glIndexxOES(component);
}

void OSMesaDriver::nfglIndexxvOES(const GLfixed *component)
{
	D(bug("nfosmesa: glIndexxvOES(%p)", component));
	/* TODO: NFOSMESA_GLINDEXXVOES may need conversion */
	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);
}

void OSMesaDriver::nfglInsertEventMarkerEXT(GLsizei length, const GLchar *marker)
{
	D(bug("nfosmesa: glInsertEventMarkerEXT(%d, %p)", length, marker));
	/* TODO: NFOSMESA_GLINSERTEVENTMARKEREXT may need conversion */
	fn.glInsertEventMarkerEXT(length, marker);
}

void OSMesaDriver::nfglInstrumentsBufferSGIX(GLsizei size, GLint *buffer)
{
	D(bug("nfosmesa: glInstrumentsBufferSGIX(%d, %p)", size, buffer));
	/* TODO: NFOSMESA_GLINSTRUMENTSBUFFERSGIX may need conversion */
	fn.glInstrumentsBufferSGIX(size, buffer);
}

void OSMesaDriver::nfglInterleavedArrays(GLenum format, GLsizei stride, const GLvoid *pointer)
{
	D(bug("nfosmesa: glInterleavedArrays(0x%x, %d, %p)", format, stride, 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, %ld, %ld)", buffer, offset, length));
	fn.glInvalidateBufferSubData(buffer, offset, length);
}

void OSMesaDriver::nfglInvalidateFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments)
{
	D(bug("nfosmesa: glInvalidateFramebuffer(0x%x, %d, %p)", target, numAttachments, attachments));
	/* TODO: NFOSMESA_GLINVALIDATEFRAMEBUFFER may need conversion */
	fn.glInvalidateFramebuffer(target, numAttachments, attachments);
}

void OSMesaDriver::nfglInvalidateSubFramebuffer(GLenum target, GLsizei numAttachments, const GLenum *attachments, GLint x, GLint y, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glInvalidateSubFramebuffer(0x%x, %d, %p, %d, %d, %d, %d)", target, numAttachments, attachments, x, y, width, height));
	/* TODO: NFOSMESA_GLINVALIDATESUBFRAMEBUFFER may need conversion */
	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));
	return fn.glIsAsyncMarkerSGIX(marker);
}

GLboolean OSMesaDriver::nfglIsBuffer(GLuint buffer)
{
	D(bug("nfosmesa: glIsBuffer(%u)", buffer));
	return fn.glIsBuffer(buffer);
}

GLboolean OSMesaDriver::nfglIsBufferARB(GLuint buffer)
{
	D(bug("nfosmesa: glIsBufferARB(%u)", buffer));
	return fn.glIsBufferARB(buffer);
}

GLboolean OSMesaDriver::nfglIsBufferResidentNV(GLenum target)
{
	D(bug("nfosmesa: glIsBufferResidentNV(0x%x)", target));
	return fn.glIsBufferResidentNV(target);
}

GLboolean OSMesaDriver::nfglIsEnabled(GLenum cap)
{
	D(bug("nfosmesa: glIsEnabled(0x%x)", cap));
	return fn.glIsEnabled(cap);
}

GLboolean OSMesaDriver::nfglIsEnabledIndexedEXT(GLenum target, GLuint index)
{
	D(bug("nfosmesa: glIsEnabledIndexedEXT(0x%x, %u)", target, index));
	return fn.glIsEnabledIndexedEXT(target, index);
}

GLboolean OSMesaDriver::nfglIsEnabledi(GLenum target, GLuint index)
{
	D(bug("nfosmesa: glIsEnabledi(0x%x, %u)", target, index));
	return fn.glIsEnabledi(target, index);
}

GLboolean OSMesaDriver::nfglIsFenceAPPLE(GLuint fence)
{
	D(bug("nfosmesa: glIsFenceAPPLE(%u)", fence));
	return fn.glIsFenceAPPLE(fence);
}

GLboolean OSMesaDriver::nfglIsFenceNV(GLuint fence)
{
	D(bug("nfosmesa: glIsFenceNV(%u)", fence));
	return fn.glIsFenceNV(fence);
}

GLboolean OSMesaDriver::nfglIsFramebuffer(GLuint framebuffer)
{
	D(bug("nfosmesa: glIsFramebuffer(%u)", framebuffer));
	return fn.glIsFramebuffer(framebuffer);
}

GLboolean OSMesaDriver::nfglIsFramebufferEXT(GLuint framebuffer)
{
	D(bug("nfosmesa: glIsFramebufferEXT(%u)", framebuffer));
	return fn.glIsFramebufferEXT(framebuffer);
}

GLboolean OSMesaDriver::nfglIsImageHandleResidentARB(GLuint64 handle)
{
	D(bug("nfosmesa: glIsImageHandleResidentARB(%" PRIu64 ")", handle));
	return fn.glIsImageHandleResidentARB(handle);
}

GLboolean OSMesaDriver::nfglIsImageHandleResidentNV(GLuint64 handle)
{
	D(bug("nfosmesa: glIsImageHandleResidentNV(%" PRIu64 ")", handle));
	return fn.glIsImageHandleResidentNV(handle);
}

GLboolean OSMesaDriver::nfglIsList(GLuint list)
{
	D(bug("nfosmesa: glIsList(%u)", list));
	return fn.glIsList(list);
}

GLboolean OSMesaDriver::nfglIsNameAMD(GLenum identifier, GLuint name)
{
	D(bug("nfosmesa: glIsNameAMD(0x%x, %u)", identifier, name));
	return fn.glIsNameAMD(identifier, name);
}

GLboolean OSMesaDriver::nfglIsNamedBufferResidentNV(GLuint buffer)
{
	D(bug("nfosmesa: glIsNamedBufferResidentNV(%u)", buffer));
	return fn.glIsNamedBufferResidentNV(buffer);
}

GLboolean OSMesaDriver::nfglIsNamedStringARB(GLint namelen, const GLchar *name)
{
	D(bug("nfosmesa: glIsNamedStringARB(%d, %p)", namelen, name));
	/* TODO: NFOSMESA_GLISNAMEDSTRINGARB may need conversion */
	return fn.glIsNamedStringARB(namelen, name);
}

GLboolean OSMesaDriver::nfglIsObjectBufferATI(GLuint buffer)
{
	D(bug("nfosmesa: glIsObjectBufferATI(%u)", buffer));
	return fn.glIsObjectBufferATI(buffer);
}

GLboolean OSMesaDriver::nfglIsOcclusionQueryNV(GLuint id)
{
	D(bug("nfosmesa: glIsOcclusionQueryNV(%u)", id));
	return fn.glIsOcclusionQueryNV(id);
}

GLboolean OSMesaDriver::nfglIsPathNV(GLuint path)
{
	D(bug("nfosmesa: glIsPathNV(%u)", path));
	return fn.glIsPathNV(path);
}

GLboolean OSMesaDriver::nfglIsPointInFillPathNV(GLuint path, GLuint mask, GLfloat x, GLfloat y)
{
	D(bug("nfosmesa: glIsPointInFillPathNV(%u, %u, %f, %f)", path, mask, x, y));
	return fn.glIsPointInFillPathNV(path, mask, x, y);
}

GLboolean OSMesaDriver::nfglIsPointInStrokePathNV(GLuint path, GLfloat x, GLfloat y)
{
	D(bug("nfosmesa: glIsPointInStrokePathNV(%u, %f, %f)", path, x, y));
	return fn.glIsPointInStrokePathNV(path, x, y);
}

GLboolean OSMesaDriver::nfglIsProgram(GLuint program)
{
	D(bug("nfosmesa: glIsProgram(%u)", program));
	return fn.glIsProgram(program);
}

GLboolean OSMesaDriver::nfglIsProgramARB(GLuint program)
{
	D(bug("nfosmesa: glIsProgramARB(%u)", program));
	return fn.glIsProgramARB(program);
}

GLboolean OSMesaDriver::nfglIsProgramNV(GLuint id)
{
	D(bug("nfosmesa: glIsProgramNV(%u)", id));
	return fn.glIsProgramNV(id);
}

GLboolean OSMesaDriver::nfglIsProgramPipeline(GLuint pipeline)
{
	D(bug("nfosmesa: glIsProgramPipeline(%u)", pipeline));
	return fn.glIsProgramPipeline(pipeline);
}

GLboolean OSMesaDriver::nfglIsQuery(GLuint id)
{
	D(bug("nfosmesa: glIsQuery(%u)", id));
	return fn.glIsQuery(id);
}

GLboolean OSMesaDriver::nfglIsQueryARB(GLuint id)
{
	D(bug("nfosmesa: glIsQueryARB(%u)", id));
	return fn.glIsQueryARB(id);
}

GLboolean OSMesaDriver::nfglIsRenderbuffer(GLuint renderbuffer)
{
	D(bug("nfosmesa: glIsRenderbuffer(%u)", renderbuffer));
	return fn.glIsRenderbuffer(renderbuffer);
}

GLboolean OSMesaDriver::nfglIsRenderbufferEXT(GLuint renderbuffer)
{
	D(bug("nfosmesa: glIsRenderbufferEXT(%u)", renderbuffer));
	return fn.glIsRenderbufferEXT(renderbuffer);
}

GLboolean OSMesaDriver::nfglIsSampler(GLuint sampler)
{
	D(bug("nfosmesa: glIsSampler(%u)", sampler));
	return fn.glIsSampler(sampler);
}

GLboolean OSMesaDriver::nfglIsShader(GLuint shader)
{
	D(bug("nfosmesa: glIsShader(%u)", shader));
	return fn.glIsShader(shader);
}

GLboolean OSMesaDriver::nfglIsSync(GLsync sync)
{
	D(bug("nfosmesa: glIsSync(%p)", sync));
	return fn.glIsSync(sync);
}

GLboolean OSMesaDriver::nfglIsTexture(GLuint texture)
{
	D(bug("nfosmesa: glIsTexture(%u)", texture));
	return fn.glIsTexture(texture);
}

GLboolean OSMesaDriver::nfglIsTextureEXT(GLuint texture)
{
	D(bug("nfosmesa: glIsTextureEXT(%u)", texture));
	return fn.glIsTextureEXT(texture);
}

GLboolean OSMesaDriver::nfglIsTextureHandleResidentARB(GLuint64 handle)
{
	D(bug("nfosmesa: glIsTextureHandleResidentARB(%" PRIu64 ")", handle));
	return fn.glIsTextureHandleResidentARB(handle);
}

GLboolean OSMesaDriver::nfglIsTextureHandleResidentNV(GLuint64 handle)
{
	D(bug("nfosmesa: glIsTextureHandleResidentNV(%" PRIu64 ")", handle));
	return fn.glIsTextureHandleResidentNV(handle);
}

GLboolean OSMesaDriver::nfglIsTransformFeedback(GLuint id)
{
	D(bug("nfosmesa: glIsTransformFeedback(%u)", id));
	return fn.glIsTransformFeedback(id);
}

GLboolean OSMesaDriver::nfglIsTransformFeedbackNV(GLuint id)
{
	D(bug("nfosmesa: glIsTransformFeedbackNV(%u)", id));
	return fn.glIsTransformFeedbackNV(id);
}

GLboolean OSMesaDriver::nfglIsVariantEnabledEXT(GLuint id, GLenum cap)
{
	D(bug("nfosmesa: glIsVariantEnabledEXT(%u, 0x%x)", id, cap));
	return fn.glIsVariantEnabledEXT(id, cap);
}

GLboolean OSMesaDriver::nfglIsVertexArray(GLuint array)
{
	D(bug("nfosmesa: glIsVertexArray(%u)", array));
	return fn.glIsVertexArray(array);
}

GLboolean OSMesaDriver::nfglIsVertexArrayAPPLE(GLuint array)
{
	D(bug("nfosmesa: glIsVertexArrayAPPLE(%u)", array));
	return fn.glIsVertexArrayAPPLE(array);
}

GLboolean OSMesaDriver::nfglIsVertexAttribEnabledAPPLE(GLuint index, GLenum pname)
{
	D(bug("nfosmesa: glIsVertexAttribEnabledAPPLE(%u, 0x%x)", index, pname));
	return fn.glIsVertexAttribEnabledAPPLE(index, pname);
}

void OSMesaDriver::nfglLabelObjectEXT(GLenum type, GLuint object, GLsizei length, const GLchar *label)
{
	D(bug("nfosmesa: glLabelObjectEXT(0x%x, %u, %d, %p)", type, object, length, label));
	/* TODO: NFOSMESA_GLLABELOBJECTEXT may need conversion */
	fn.glLabelObjectEXT(type, object, length, label);
}

void OSMesaDriver::nfglLightEnviSGIX(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glLightEnviSGIX(0x%x, %d)", pname, param));
	fn.glLightEnviSGIX(pname, param);
}

void OSMesaDriver::nfglLightModelf(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glLightModelf(0x%x, %f)", pname, param));
	fn.glLightModelf(pname, param);
}

void OSMesaDriver::nfglLightModelfv(GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glLightModelfv(0x%x, %p)", pname, params));
FN_GLLIGHTMODELFV(pname, params);
}

void OSMesaDriver::nfglLightModeli(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glLightModeli(0x%x, %d)", pname, param));
	fn.glLightModeli(pname, param);
}

void OSMesaDriver::nfglLightModeliv(GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glLightModeliv(0x%x, %p)", pname, params));
FN_GLLIGHTMODELIV(pname, params);
}

void OSMesaDriver::nfglLightModelxOES(GLenum pname, GLfixed param)
{
	D(bug("nfosmesa: glLightModelxOES(0x%x, 0x%x)", pname, param));
	fn.glLightModelxOES(pname, param);
}

void OSMesaDriver::nfglLightModelxvOES(GLenum pname, const GLfixed *param)
{
	D(bug("nfosmesa: glLightModelxvOES(0x%x, %p)", pname, param));
	/* TODO: NFOSMESA_GLLIGHTMODELXVOES may need conversion */
	fn.glLightModelxvOES(pname, param);
}

void OSMesaDriver::nfglLightf(GLenum light, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glLightf(0x%x, 0x%x, %f)", light, pname, param));
	fn.glLightf(light, pname, param);
}

void OSMesaDriver::nfglLightfv(GLenum light, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glLightfv(0x%x, 0x%x, %p)", light, pname, params));
FN_GLLIGHTFV(light, pname, params);
}

void OSMesaDriver::nfglLighti(GLenum light, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glLighti(0x%x, 0x%x, %d)", light, pname, param));
	fn.glLighti(light, pname, param);
}

void OSMesaDriver::nfglLightiv(GLenum light, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glLightiv(0x%x, 0x%x, %p)", light, pname, params));
FN_GLLIGHTIV(light, pname, params);
}

void OSMesaDriver::nfglLightxOES(GLenum light, GLenum pname, GLfixed param)
{
	D(bug("nfosmesa: glLightxOES(0x%x, 0x%x, 0x%x)", light, pname, param));
	fn.glLightxOES(light, pname, param);
}

void OSMesaDriver::nfglLightxvOES(GLenum light, GLenum pname, const GLfixed *params)
{
	D(bug("nfosmesa: glLightxvOES(0x%x, 0x%x, %p)", light, pname, params));
	/* TODO: NFOSMESA_GLLIGHTXVOES may need conversion */
	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)", programObj));
	fn.glLinkProgramARB(programObj);
}

void OSMesaDriver::nfglListBase(GLuint base)
{
	D(bug("nfosmesa: glListBase(%u)", base));
	fn.glListBase(base);
}

void OSMesaDriver::nfglListParameterfSGIX(GLuint list, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glListParameterfSGIX(%u, 0x%x, %f)", list, pname, param));
	fn.glListParameterfSGIX(list, pname, param);
}

void OSMesaDriver::nfglListParameterfvSGIX(GLuint list, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glListParameterfvSGIX(%u, 0x%x, %p)", list, pname, params));
	/* TODO: NFOSMESA_GLLISTPARAMETERFVSGIX may need conversion */
	fn.glListParameterfvSGIX(list, pname, params);
}

void OSMesaDriver::nfglListParameteriSGIX(GLuint list, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glListParameteriSGIX(%u, 0x%x, %d)", list, pname, param));
	fn.glListParameteriSGIX(list, pname, param);
}

void OSMesaDriver::nfglListParameterivSGIX(GLuint list, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glListParameterivSGIX(%u, 0x%x, %p)", list, pname, params));
	/* TODO: NFOSMESA_GLLISTPARAMETERIVSGIX may need conversion */
	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);
}

void OSMesaDriver::nfglLoadMatrixd(const GLdouble *m)
{
	D(bug("nfosmesa: glLoadMatrixd(%p)", m));
FN_GLLOADMATRIXD(m);
}

void OSMesaDriver::nfglLoadMatrixf(const GLfloat *m)
{
	D(bug("nfosmesa: glLoadMatrixf(%p)", m));
FN_GLLOADMATRIXF(m);
}

void OSMesaDriver::nfglLoadMatrixxOES(const GLfixed *m)
{
	D(bug("nfosmesa: glLoadMatrixxOES(%p)", m));
	/* TODO: NFOSMESA_GLLOADMATRIXXOES may need conversion */
	fn.glLoadMatrixxOES(m);
}

void OSMesaDriver::nfglLoadName(GLuint name)
{
	D(bug("nfosmesa: glLoadName(%u)", name));
	fn.glLoadName(name);
}

void OSMesaDriver::nfglLoadProgramNV(GLenum target, GLuint id, GLsizei len, const GLubyte *program)
{
	D(bug("nfosmesa: glLoadProgramNV(0x%x, %u, %d, %p)", target, id, len, program));
	/* TODO: NFOSMESA_GLLOADPROGRAMNV may need conversion */
	fn.glLoadProgramNV(target, id, len, program);
}

void OSMesaDriver::nfglLoadTransposeMatrixd(const GLdouble *m)
{
	D(bug("nfosmesa: glLoadTransposeMatrixd(%p)", m));
FN_GLLOADTRANSPOSEMATRIXD(m);
}

void OSMesaDriver::nfglLoadTransposeMatrixdARB(const GLdouble *m)
{
	D(bug("nfosmesa: glLoadTransposeMatrixdARB(%p)", m));
FN_GLLOADTRANSPOSEMATRIXDARB(m);
}

void OSMesaDriver::nfglLoadTransposeMatrixf(const GLfloat *m)
{
	D(bug("nfosmesa: glLoadTransposeMatrixf(%p)", m));
FN_GLLOADTRANSPOSEMATRIXF(m);
}

void OSMesaDriver::nfglLoadTransposeMatrixfARB(const GLfloat *m)
{
	D(bug("nfosmesa: glLoadTransposeMatrixfARB(%p)", m));
FN_GLLOADTRANSPOSEMATRIXFARB(m);
}

void OSMesaDriver::nfglLoadTransposeMatrixxOES(const GLfixed *m)
{
	D(bug("nfosmesa: glLoadTransposeMatrixxOES(%p)", m));
	/* TODO: NFOSMESA_GLLOADTRANSPOSEMATRIXXOES may need conversion */
	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(0x%x)", opcode));
	fn.glLogicOp(opcode);
}

void OSMesaDriver::nfglMakeBufferNonResidentNV(GLenum target)
{
	D(bug("nfosmesa: glMakeBufferNonResidentNV(0x%x)", target));
	fn.glMakeBufferNonResidentNV(target);
}

void OSMesaDriver::nfglMakeBufferResidentNV(GLenum target, GLenum access)
{
	D(bug("nfosmesa: glMakeBufferResidentNV(0x%x, 0x%x)", target, 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 ", 0x%x)", handle, access));
	fn.glMakeImageHandleResidentARB(handle, access);
}

void OSMesaDriver::nfglMakeImageHandleResidentNV(GLuint64 handle, GLenum access)
{
	D(bug("nfosmesa: glMakeImageHandleResidentNV(%" PRIu64 ", 0x%x)", handle, 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, 0x%x)", buffer, 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);
}

void OSMesaDriver::nfglMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
{
	D(bug("nfosmesa: glMap1d(0x%x, %f, %f, %d, %d, %p)", target, u1, u2, stride, order, points));
FN_GLMAP1D(target, u1, u2, stride, order, points);
}

void OSMesaDriver::nfglMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
{
	D(bug("nfosmesa: glMap1f(0x%x, %f, %f, %d, %d, %p)", target, u1, u2, stride, order, 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(0x%x, 0x%x, 0x%x, %d, %d, 0x%x)", target, u1, u2, stride, order, points));
	fn.glMap1xOES(target, u1, u2, stride, order, points);
}

void OSMesaDriver::nfglMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
{
	D(bug("nfosmesa: glMap2d(0x%x, %f, %f, %d, %d, %f, %f, %d, %d, %p)", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points));
FN_GLMAP2D(target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
}

void OSMesaDriver::nfglMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
{
	D(bug("nfosmesa: glMap2f(0x%x, %f, %f, %d, %d, %f, %f, %d, %d, %p)", target, u1, u2, ustride, uorder, v1, v2, vstride, vorder, 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(0x%x, 0x%x, 0x%x, %d, %d, 0x%x, 0x%x, %d, %d, 0x%x)", 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(0x%x, 0x%x)", target, access));
	return fn.glMapBuffer(target, access);
}
#endif

#if 0
void * OSMesaDriver::nfglMapBufferARB(GLenum target, GLenum access)
{
	D(bug("nfosmesa: glMapBufferARB(0x%x, 0x%x)", target, access));
	return fn.glMapBufferARB(target, access);
}
#endif

#if 0
void * OSMesaDriver::nfglMapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access)
{
	D(bug("nfosmesa: glMapBufferRange(0x%x, %ld, %ld, 0x%x)", target, offset, length, access));
	return fn.glMapBufferRange(target, offset, length, access);
}
#endif

void OSMesaDriver::nfglMapControlPointsNV(GLenum target, GLuint index, GLenum type, GLsizei ustride, GLsizei vstride, GLint uorder, GLint vorder, GLboolean32 packed, const void *points)
{
	D(bug("nfosmesa: glMapControlPointsNV(0x%x, %u, 0x%x, %d, %d, %d, %d, %d, %p)", target, index, type, ustride, vstride, uorder, vorder, packed, points));
	/* TODO: NFOSMESA_GLMAPCONTROLPOINTSNV may need conversion */
	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::nfglMapNamedBufferEXT(GLuint buffer, GLenum access)
{
	D(bug("nfosmesa: glMapNamedBufferEXT(%u, 0x%x)", buffer, access));
	return fn.glMapNamedBufferEXT(buffer, access);
}
#endif

#if 0
void * OSMesaDriver::nfglMapNamedBufferRangeEXT(GLuint buffer, GLintptr offset, GLsizeiptr length, GLbitfield access)
{
	D(bug("nfosmesa: glMapNamedBufferRangeEXT(%u, %ld, %ld, 0x%x)", buffer, offset, length, access));
	return fn.glMapNamedBufferRangeEXT(buffer, offset, length, access);
}
#endif

#if 0
void * OSMesaDriver::nfglMapObjectBufferATI(GLuint buffer)
{
	D(bug("nfosmesa: glMapObjectBufferATI(%u)", buffer));
	return fn.glMapObjectBufferATI(buffer);
}
#endif

void OSMesaDriver::nfglMapParameterfvNV(GLenum target, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glMapParameterfvNV(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLMAPPARAMETERFVNV may need conversion */
	fn.glMapParameterfvNV(target, pname, params);
}

void OSMesaDriver::nfglMapParameterivNV(GLenum target, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glMapParameterivNV(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLMAPPARAMETERIVNV may need conversion */
	fn.glMapParameterivNV(target, pname, params);
}

#if 0
void * OSMesaDriver::nfglMapTexture2DINTEL(GLuint texture, GLint level, GLbitfield access, const GLint *stride, const GLenum *layout)
{
	D(bug("nfosmesa: glMapTexture2DINTEL(%u, %d, 0x%x, %p, %p)", texture, level, access, stride, layout));
	/* TODO: NFOSMESA_GLMAPTEXTURE2DINTEL may need conversion */
	return fn.glMapTexture2DINTEL(texture, level, access, stride, layout);
}
#endif

void OSMesaDriver::nfglMapVertexAttrib1dAPPLE(GLuint index, GLuint size, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
{
	D(bug("nfosmesa: glMapVertexAttrib1dAPPLE(%u, %u, %f, %f, %d, %d, %p)", index, size, u1, u2, stride, order, points));
	/* TODO: NFOSMESA_GLMAPVERTEXATTRIB1DAPPLE may need conversion */
	fn.glMapVertexAttrib1dAPPLE(index, size, u1, u2, stride, order, points);
}

void OSMesaDriver::nfglMapVertexAttrib1fAPPLE(GLuint index, GLuint size, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
{
	D(bug("nfosmesa: glMapVertexAttrib1fAPPLE(%u, %u, %f, %f, %d, %d, %p)", index, size, u1, u2, stride, order, points));
	/* TODO: NFOSMESA_GLMAPVERTEXATTRIB1FAPPLE may need conversion */
	fn.glMapVertexAttrib1fAPPLE(index, size, u1, u2, stride, order, points);
}

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)
{
	D(bug("nfosmesa: glMapVertexAttrib2dAPPLE(%u, %u, %f, %f, %d, %d, %f, %f, %d, %d, %p)", index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points));
	/* TODO: NFOSMESA_GLMAPVERTEXATTRIB2DAPPLE may need conversion */
	fn.glMapVertexAttrib2dAPPLE(index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points);
}

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)
{
	D(bug("nfosmesa: glMapVertexAttrib2fAPPLE(%u, %u, %f, %f, %d, %d, %f, %f, %d, %d, %p)", index, size, u1, u2, ustride, uorder, v1, v2, vstride, vorder, points));
	/* TODO: NFOSMESA_GLMAPVERTEXATTRIB2FAPPLE may need conversion */
	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(0x%x, 0x%x, %f)", face, pname, param));
	fn.glMaterialf(face, pname, param);
}

void OSMesaDriver::nfglMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glMaterialfv(0x%x, 0x%x, %p)", face, pname, params));
FN_GLMATERIALFV(face, pname, params);
}

void OSMesaDriver::nfglMateriali(GLenum face, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glMateriali(0x%x, 0x%x, %d)", face, pname, param));
	fn.glMateriali(face, pname, param);
}

void OSMesaDriver::nfglMaterialiv(GLenum face, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glMaterialiv(0x%x, 0x%x, %p)", face, pname, params));
FN_GLMATERIALIV(face, pname, params);
}

void OSMesaDriver::nfglMaterialxOES(GLenum face, GLenum pname, GLfixed param)
{
	D(bug("nfosmesa: glMaterialxOES(0x%x, 0x%x, 0x%x)", face, pname, param));
	fn.glMaterialxOES(face, pname, param);
}

void OSMesaDriver::nfglMaterialxvOES(GLenum face, GLenum pname, const GLfixed *param)
{
	D(bug("nfosmesa: glMaterialxvOES(0x%x, 0x%x, %p)", face, pname, param));
	/* TODO: NFOSMESA_GLMATERIALXVOES may need conversion */
	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(0x%x, %f, %f, %f, %f, %f, %f)", mode, left, right, bottom, top, zNear, zFar));
	fn.glMatrixFrustumEXT(mode, left, right, bottom, top, zNear, zFar);
}

void OSMesaDriver::nfglMatrixIndexPointerARB(GLint size, GLenum type, GLsizei stride, const void *pointer)
{
	D(bug("nfosmesa: glMatrixIndexPointerARB(%d, 0x%x, %d, %p)", size, type, stride, pointer));
	/* TODO: NFOSMESA_GLMATRIXINDEXPOINTERARB may need conversion */
	fn.glMatrixIndexPointerARB(size, type, stride, pointer);
}

void OSMesaDriver::nfglMatrixIndexubvARB(GLint size, const GLubyte *indices)
{
	D(bug("nfosmesa: glMatrixIndexubvARB(%d, %p)", size, indices));
	/* TODO: NFOSMESA_GLMATRIXINDEXUBVARB may need conversion */
	fn.glMatrixIndexubvARB(size, indices);
}

void OSMesaDriver::nfglMatrixIndexuivARB(GLint size, const GLuint *indices)
{
	D(bug("nfosmesa: glMatrixIndexuivARB(%d, %p)", size, indices));
	/* TODO: NFOSMESA_GLMATRIXINDEXUIVARB may need conversion */
	fn.glMatrixIndexuivARB(size, indices);
}

void OSMesaDriver::nfglMatrixIndexusvARB(GLint size, const GLushort *indices)
{
	D(bug("nfosmesa: glMatrixIndexusvARB(%d, %p)", size, indices));
	/* TODO: NFOSMESA_GLMATRIXINDEXUSVARB may need conversion */
	fn.glMatrixIndexusvARB(size, indices);
}

void OSMesaDriver::nfglMatrixLoadIdentityEXT(GLenum mode)
{
	D(bug("nfosmesa: glMatrixLoadIdentityEXT(0x%x)", mode));
	fn.glMatrixLoadIdentityEXT(mode);
}

void OSMesaDriver::nfglMatrixLoadTransposedEXT(GLenum mode, const GLdouble *m)
{
	D(bug("nfosmesa: glMatrixLoadTransposedEXT(0x%x, %p)", mode, m));
	/* TODO: NFOSMESA_GLMATRIXLOADTRANSPOSEDEXT may need conversion */
	fn.glMatrixLoadTransposedEXT(mode, m);
}

void OSMesaDriver::nfglMatrixLoadTransposefEXT(GLenum mode, const GLfloat *m)
{
	D(bug("nfosmesa: glMatrixLoadTransposefEXT(0x%x, %p)", mode, m));
	/* TODO: NFOSMESA_GLMATRIXLOADTRANSPOSEFEXT may need conversion */
	fn.glMatrixLoadTransposefEXT(mode, m);
}

void OSMesaDriver::nfglMatrixLoaddEXT(GLenum mode, const GLdouble *m)
{
	D(bug("nfosmesa: glMatrixLoaddEXT(0x%x, %p)", mode, m));
	/* TODO: NFOSMESA_GLMATRIXLOADDEXT may need conversion */
	fn.glMatrixLoaddEXT(mode, m);
}

void OSMesaDriver::nfglMatrixLoadfEXT(GLenum mode, const GLfloat *m)
{
	D(bug("nfosmesa: glMatrixLoadfEXT(0x%x, %p)", mode, m));
	/* TODO: NFOSMESA_GLMATRIXLOADFEXT may need conversion */
	fn.glMatrixLoadfEXT(mode, m);
}

void OSMesaDriver::nfglMatrixMode(GLenum mode)
{
	D(bug("nfosmesa: glMatrixMode(0x%x)", mode));
	fn.glMatrixMode(mode);
}

void OSMesaDriver::nfglMatrixMultTransposedEXT(GLenum mode, const GLdouble *m)
{
	D(bug("nfosmesa: glMatrixMultTransposedEXT(0x%x, %p)", mode, m));
	/* TODO: NFOSMESA_GLMATRIXMULTTRANSPOSEDEXT may need conversion */
	fn.glMatrixMultTransposedEXT(mode, m);
}

void OSMesaDriver::nfglMatrixMultTransposefEXT(GLenum mode, const GLfloat *m)
{
	D(bug("nfosmesa: glMatrixMultTransposefEXT(0x%x, %p)", mode, m));
	/* TODO: NFOSMESA_GLMATRIXMULTTRANSPOSEFEXT may need conversion */
	fn.glMatrixMultTransposefEXT(mode, m);
}

void OSMesaDriver::nfglMatrixMultdEXT(GLenum mode, const GLdouble *m)
{
	D(bug("nfosmesa: glMatrixMultdEXT(0x%x, %p)", mode, m));
	/* TODO: NFOSMESA_GLMATRIXMULTDEXT may need conversion */
	fn.glMatrixMultdEXT(mode, m);
}

void OSMesaDriver::nfglMatrixMultfEXT(GLenum mode, const GLfloat *m)
{
	D(bug("nfosmesa: glMatrixMultfEXT(0x%x, %p)", mode, m));
	/* TODO: NFOSMESA_GLMATRIXMULTFEXT may need conversion */
	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(0x%x, %f, %f, %f, %f, %f, %f)", 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(0x%x)", mode));
	fn.glMatrixPopEXT(mode);
}

void OSMesaDriver::nfglMatrixPushEXT(GLenum mode)
{
	D(bug("nfosmesa: glMatrixPushEXT(0x%x)", mode));
	fn.glMatrixPushEXT(mode);
}

void OSMesaDriver::nfglMatrixRotatedEXT(GLenum mode, GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glMatrixRotatedEXT(0x%x, %f, %f, %f, %f)", 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(0x%x, %f, %f, %f, %f)", 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(0x%x, %f, %f, %f)", 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(0x%x, %f, %f, %f)", 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(0x%x, %f, %f, %f)", 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(0x%x, %f, %f, %f)", mode, x, y, z));
	fn.glMatrixTranslatefEXT(mode, x, y, z);
}

void OSMesaDriver::nfglMemoryBarrier(GLbitfield barriers)
{
	D(bug("nfosmesa: glMemoryBarrier(0x%x)", barriers));
	fn.glMemoryBarrier(barriers);
}

void OSMesaDriver::nfglMemoryBarrierEXT(GLbitfield barriers)
{
	D(bug("nfosmesa: glMemoryBarrierEXT(0x%x)", barriers));
	fn.glMemoryBarrierEXT(barriers);
}

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(0x%x, 0x%x, %d)", target, internalformat, sink));
	fn.glMinmax(target, internalformat, sink);
}

void OSMesaDriver::nfglMinmaxEXT(GLenum target, GLenum internalformat, GLboolean32 sink)
{
	D(bug("nfosmesa: glMinmaxEXT(0x%x, 0x%x, %d)", target, internalformat, sink));
	fn.glMinmaxEXT(target, internalformat, sink);
}

void OSMesaDriver::nfglMultMatrixd(const GLdouble *m)
{
	D(bug("nfosmesa: glMultMatrixd(%p)", m));
FN_GLMULTMATRIXD(m);
}

void OSMesaDriver::nfglMultMatrixf(const GLfloat *m)
{
	D(bug("nfosmesa: glMultMatrixf(%p)", m));
FN_GLMULTMATRIXF(m);
}

void OSMesaDriver::nfglMultMatrixxOES(const GLfixed *m)
{
	D(bug("nfosmesa: glMultMatrixxOES(%p)", m));
	/* TODO: NFOSMESA_GLMULTMATRIXXOES may need conversion */
	fn.glMultMatrixxOES(m);
}

void OSMesaDriver::nfglMultTransposeMatrixd(const GLdouble *m)
{
	D(bug("nfosmesa: glMultTransposeMatrixd(%p)", m));
FN_GLMULTTRANSPOSEMATRIXD(m);
}

void OSMesaDriver::nfglMultTransposeMatrixdARB(const GLdouble *m)
{
	D(bug("nfosmesa: glMultTransposeMatrixdARB(%p)", m));
FN_GLMULTTRANSPOSEMATRIXDARB(m);
}

void OSMesaDriver::nfglMultTransposeMatrixf(const GLfloat *m)
{
	D(bug("nfosmesa: glMultTransposeMatrixf(%p)", m));
FN_GLMULTTRANSPOSEMATRIXF(m);
}

void OSMesaDriver::nfglMultTransposeMatrixfARB(const GLfloat *m)
{
	D(bug("nfosmesa: glMultTransposeMatrixfARB(%p)", m));
FN_GLMULTTRANSPOSEMATRIXFARB(m);
}

void OSMesaDriver::nfglMultTransposeMatrixxOES(const GLfixed *m)
{
	D(bug("nfosmesa: glMultTransposeMatrixxOES(%p)", m));
	/* TODO: NFOSMESA_GLMULTTRANSPOSEMATRIXXOES may need conversion */
	fn.glMultTransposeMatrixxOES(m);
}

void OSMesaDriver::nfglMultiDrawArrays(GLenum mode, const GLint *first, const GLsizei *count, GLsizei drawcount)
{
	D(bug("nfosmesa: glMultiDrawArrays(0x%x, %p, %p, %d)", mode, first, count, drawcount));
	/* TODO: NFOSMESA_GLMULTIDRAWARRAYS may need conversion */
	fn.glMultiDrawArrays(mode, first, count, drawcount);
}

void OSMesaDriver::nfglMultiDrawArraysEXT(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount)
{
	D(bug("nfosmesa: glMultiDrawArraysEXT(0x%x, %p, %p, %d)", mode, first, count, primcount));
	/* TODO: NFOSMESA_GLMULTIDRAWARRAYSEXT may need conversion */
	fn.glMultiDrawArraysEXT(mode, first, count, primcount);
}

void OSMesaDriver::nfglMultiDrawArraysIndirect(GLenum mode, const void *indirect, GLsizei drawcount, GLsizei stride)
{
	D(bug("nfosmesa: glMultiDrawArraysIndirect(0x%x, %p, %d, %d)", mode, indirect, drawcount, stride));
	/* TODO: NFOSMESA_GLMULTIDRAWARRAYSINDIRECT may need conversion */
	fn.glMultiDrawArraysIndirect(mode, indirect, drawcount, stride);
}

void OSMesaDriver::nfglMultiDrawArraysIndirectAMD(GLenum mode, const void *indirect, GLsizei primcount, GLsizei stride)
{
	D(bug("nfosmesa: glMultiDrawArraysIndirectAMD(0x%x, %p, %d, %d)", mode, indirect, primcount, stride));
	/* TODO: NFOSMESA_GLMULTIDRAWARRAYSINDIRECTAMD may need conversion */
	fn.glMultiDrawArraysIndirectAMD(mode, indirect, primcount, stride);
}

void OSMesaDriver::nfglMultiDrawArraysIndirectBindlessNV(GLenum mode, const void *indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount)
{
	D(bug("nfosmesa: glMultiDrawArraysIndirectBindlessNV(0x%x, %p, %d, %d, %d)", mode, indirect, drawCount, stride, vertexBufferCount));
	/* TODO: NFOSMESA_GLMULTIDRAWARRAYSINDIRECTBINDLESSNV may need conversion */
	fn.glMultiDrawArraysIndirectBindlessNV(mode, indirect, drawCount, stride, vertexBufferCount);
}

void OSMesaDriver::nfglMultiDrawArraysIndirectCountARB(GLenum mode, GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride)
{
	D(bug("nfosmesa: glMultiDrawArraysIndirectCountARB(0x%x, %ld, %ld, %d, %d)", mode, indirect, drawcount, maxdrawcount, stride));
	fn.glMultiDrawArraysIndirectCountARB(mode, indirect, drawcount, maxdrawcount, stride);
}

void OSMesaDriver::nfglMultiDrawElementArrayAPPLE(GLenum mode, const GLint *first, const GLsizei *count, GLsizei primcount)
{
	D(bug("nfosmesa: glMultiDrawElementArrayAPPLE(0x%x, %p, %p, %d)", mode, first, count, primcount));
	/* TODO: NFOSMESA_GLMULTIDRAWELEMENTARRAYAPPLE may need conversion */
	fn.glMultiDrawElementArrayAPPLE(mode, first, count, primcount);
}

void OSMesaDriver::nfglMultiDrawElements(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount)
{
	D(bug("nfosmesa: glMultiDrawElements(0x%x, %p, 0x%x, %p, %d)", mode, count, type, indices, drawcount));
	/* TODO: NFOSMESA_GLMULTIDRAWELEMENTS may need conversion */
	fn.glMultiDrawElements(mode, count, type, indices, drawcount);
}

void OSMesaDriver::nfglMultiDrawElementsBaseVertex(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei drawcount, const GLint *basevertex)
{
	D(bug("nfosmesa: glMultiDrawElementsBaseVertex(0x%x, %p, 0x%x, %p, %d, %p)", mode, count, type, indices, drawcount, basevertex));
	/* TODO: NFOSMESA_GLMULTIDRAWELEMENTSBASEVERTEX may need conversion */
	fn.glMultiDrawElementsBaseVertex(mode, count, type, indices, drawcount, basevertex);
}

void OSMesaDriver::nfglMultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei primcount)
{
	D(bug("nfosmesa: glMultiDrawElementsEXT(0x%x, %p, 0x%x, %p, %d)", mode, count, type, indices, primcount));
	/* TODO: NFOSMESA_GLMULTIDRAWELEMENTSEXT may need conversion */
	fn.glMultiDrawElementsEXT(mode, count, type, indices, primcount);
}

void OSMesaDriver::nfglMultiDrawElementsIndirect(GLenum mode, GLenum type, const void *indirect, GLsizei drawcount, GLsizei stride)
{
	D(bug("nfosmesa: glMultiDrawElementsIndirect(0x%x, 0x%x, %p, %d, %d)", mode, type, indirect, drawcount, stride));
	/* TODO: NFOSMESA_GLMULTIDRAWELEMENTSINDIRECT may need conversion */
	fn.glMultiDrawElementsIndirect(mode, type, indirect, drawcount, stride);
}

void OSMesaDriver::nfglMultiDrawElementsIndirectAMD(GLenum mode, GLenum type, const void *indirect, GLsizei primcount, GLsizei stride)
{
	D(bug("nfosmesa: glMultiDrawElementsIndirectAMD(0x%x, 0x%x, %p, %d, %d)", mode, type, indirect, primcount, stride));
	/* TODO: NFOSMESA_GLMULTIDRAWELEMENTSINDIRECTAMD may need conversion */
	fn.glMultiDrawElementsIndirectAMD(mode, type, indirect, primcount, stride);
}

void OSMesaDriver::nfglMultiDrawElementsIndirectBindlessNV(GLenum mode, GLenum type, const void *indirect, GLsizei drawCount, GLsizei stride, GLint vertexBufferCount)
{
	D(bug("nfosmesa: glMultiDrawElementsIndirectBindlessNV(0x%x, 0x%x, %p, %d, %d, %d)", mode, type, indirect, drawCount, stride, vertexBufferCount));
	/* TODO: NFOSMESA_GLMULTIDRAWELEMENTSINDIRECTBINDLESSNV may need conversion */
	fn.glMultiDrawElementsIndirectBindlessNV(mode, type, indirect, drawCount, stride, vertexBufferCount);
}

void OSMesaDriver::nfglMultiDrawElementsIndirectCountARB(GLenum mode, GLenum type, GLintptr indirect, GLintptr drawcount, GLsizei maxdrawcount, GLsizei stride)
{
	D(bug("nfosmesa: glMultiDrawElementsIndirectCountARB(0x%x, 0x%x, %ld, %ld, %d, %d)", mode, type, indirect, drawcount, maxdrawcount, stride));
	fn.glMultiDrawElementsIndirectCountARB(mode, type, indirect, drawcount, maxdrawcount, stride);
}

void OSMesaDriver::nfglMultiDrawRangeElementArrayAPPLE(GLenum mode, GLuint start, GLuint end, const GLint *first, const GLsizei *count, GLsizei primcount)
{
	D(bug("nfosmesa: glMultiDrawRangeElementArrayAPPLE(0x%x, %u, %u, %p, %p, %d)", mode, start, end, first, count, primcount));
	/* TODO: NFOSMESA_GLMULTIDRAWRANGEELEMENTARRAYAPPLE may need conversion */
	fn.glMultiDrawRangeElementArrayAPPLE(mode, start, end, first, count, primcount);
}

void OSMesaDriver::nfglMultiModeDrawArraysIBM(const GLenum *mode, const GLint *first, const GLsizei *count, GLsizei primcount, GLint modestride)
{
	D(bug("nfosmesa: glMultiModeDrawArraysIBM(%p, %p, %p, %d, %d)", mode, first, count, primcount, modestride));
	/* TODO: NFOSMESA_GLMULTIMODEDRAWARRAYSIBM may need conversion */
	fn.glMultiModeDrawArraysIBM(mode, first, count, primcount, modestride);
}

void OSMesaDriver::nfglMultiModeDrawElementsIBM(const GLenum *mode, const GLsizei *count, GLenum type, const void *const *indices, GLsizei primcount, GLint modestride)
{
	D(bug("nfosmesa: glMultiModeDrawElementsIBM(%p, %p, 0x%x, %p, %d, %d)", mode, count, type, indices, primcount, modestride));
	/* TODO: NFOSMESA_GLMULTIMODEDRAWELEMENTSIBM may need conversion */
	fn.glMultiModeDrawElementsIBM(mode, count, type, indices, primcount, modestride);
}

void OSMesaDriver::nfglMultiTexBufferEXT(GLenum texunit, GLenum target, GLenum internalformat, GLuint buffer)
{
	D(bug("nfosmesa: glMultiTexBufferEXT(0x%x, 0x%x, 0x%x, %u)", texunit, target, internalformat, buffer));
	fn.glMultiTexBufferEXT(texunit, target, internalformat, buffer);
}

void OSMesaDriver::nfglMultiTexCoord1bOES(GLenum texture, GLbyte32 s)
{
	D(bug("nfosmesa: glMultiTexCoord1bOES(0x%x, %d)", texture, s));
	fn.glMultiTexCoord1bOES(texture, s);
}

void OSMesaDriver::nfglMultiTexCoord1bvOES(GLenum texture, const GLbyte *coords)
{
	D(bug("nfosmesa: glMultiTexCoord1bvOES(0x%x, %p)", texture, coords));
	/* TODO: NFOSMESA_GLMULTITEXCOORD1BVOES may need conversion */
	fn.glMultiTexCoord1bvOES(texture, coords);
}

void OSMesaDriver::nfglMultiTexCoord1d(GLenum target, GLdouble s)
{
	D(bug("nfosmesa: glMultiTexCoord1d(0x%x, %f)", target, s));
	fn.glMultiTexCoord1d(target, s);
}

void OSMesaDriver::nfglMultiTexCoord1dARB(GLenum target, GLdouble s)
{
	D(bug("nfosmesa: glMultiTexCoord1dARB(0x%x, %f)", target, s));
	fn.glMultiTexCoord1dARB(target, s);
}

void OSMesaDriver::nfglMultiTexCoord1dv(GLenum target, const GLdouble *v)
{
	D(bug("nfosmesa: glMultiTexCoord1dv(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD1DV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord1dvARB(GLenum target, const GLdouble *v)
{
	D(bug("nfosmesa: glMultiTexCoord1dvARB(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD1DVARB(target, v);
}

void OSMesaDriver::nfglMultiTexCoord1f(GLenum target, GLfloat s)
{
	D(bug("nfosmesa: glMultiTexCoord1f(0x%x, %f)", target, s));
	fn.glMultiTexCoord1f(target, s);
}

void OSMesaDriver::nfglMultiTexCoord1fARB(GLenum target, GLfloat s)
{
	D(bug("nfosmesa: glMultiTexCoord1fARB(0x%x, %f)", target, s));
	fn.glMultiTexCoord1fARB(target, s);
}

void OSMesaDriver::nfglMultiTexCoord1fv(GLenum target, const GLfloat *v)
{
	D(bug("nfosmesa: glMultiTexCoord1fv(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD1FV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord1fvARB(GLenum target, const GLfloat *v)
{
	D(bug("nfosmesa: glMultiTexCoord1fvARB(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD1FVARB(target, v);
}

void OSMesaDriver::nfglMultiTexCoord1hNV(GLenum target, GLhalfNV32 s)
{
	D(bug("nfosmesa: glMultiTexCoord1hNV(0x%x, %u)", target, s));
	fn.glMultiTexCoord1hNV(target, s);
}

void OSMesaDriver::nfglMultiTexCoord1hvNV(GLenum target, const GLhalfNV *v)
{
	D(bug("nfosmesa: glMultiTexCoord1hvNV(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD1HVNV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord1i(GLenum target, GLint s)
{
	D(bug("nfosmesa: glMultiTexCoord1i(0x%x, %d)", target, s));
	fn.glMultiTexCoord1i(target, s);
}

void OSMesaDriver::nfglMultiTexCoord1iARB(GLenum target, GLint s)
{
	D(bug("nfosmesa: glMultiTexCoord1iARB(0x%x, %d)", target, s));
	fn.glMultiTexCoord1iARB(target, s);
}

void OSMesaDriver::nfglMultiTexCoord1iv(GLenum target, const GLint *v)
{
	D(bug("nfosmesa: glMultiTexCoord1iv(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD1IV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord1ivARB(GLenum target, const GLint *v)
{
	D(bug("nfosmesa: glMultiTexCoord1ivARB(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD1IVARB(target, v);
}

void OSMesaDriver::nfglMultiTexCoord1s(GLenum target, GLshort32 s)
{
	D(bug("nfosmesa: glMultiTexCoord1s(0x%x, %d)", target, s));
	fn.glMultiTexCoord1s(target, s);
}

void OSMesaDriver::nfglMultiTexCoord1sARB(GLenum target, GLshort32 s)
{
	D(bug("nfosmesa: glMultiTexCoord1sARB(0x%x, %d)", target, s));
	fn.glMultiTexCoord1sARB(target, s);
}

void OSMesaDriver::nfglMultiTexCoord1sv(GLenum target, const GLshort *v)
{
	D(bug("nfosmesa: glMultiTexCoord1sv(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD1SV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord1svARB(GLenum target, const GLshort *v)
{
	D(bug("nfosmesa: glMultiTexCoord1svARB(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD1SVARB(target, v);
}

void OSMesaDriver::nfglMultiTexCoord1xOES(GLenum texture, GLfixed s)
{
	D(bug("nfosmesa: glMultiTexCoord1xOES(0x%x, 0x%x)", texture, s));
	fn.glMultiTexCoord1xOES(texture, s);
}

void OSMesaDriver::nfglMultiTexCoord1xvOES(GLenum texture, const GLfixed *coords)
{
	D(bug("nfosmesa: glMultiTexCoord1xvOES(0x%x, %p)", texture, coords));
	/* TODO: NFOSMESA_GLMULTITEXCOORD1XVOES may need conversion */
	fn.glMultiTexCoord1xvOES(texture, coords);
}

void OSMesaDriver::nfglMultiTexCoord2bOES(GLenum texture, GLbyte32 s, GLbyte32 t)
{
	D(bug("nfosmesa: glMultiTexCoord2bOES(0x%x, %d, %d)", texture, s, t));
	fn.glMultiTexCoord2bOES(texture, s, t);
}

void OSMesaDriver::nfglMultiTexCoord2bvOES(GLenum texture, const GLbyte *coords)
{
	D(bug("nfosmesa: glMultiTexCoord2bvOES(0x%x, %p)", texture, coords));
	/* TODO: NFOSMESA_GLMULTITEXCOORD2BVOES may need conversion */
	fn.glMultiTexCoord2bvOES(texture, coords);
}

void OSMesaDriver::nfglMultiTexCoord2d(GLenum target, GLdouble s, GLdouble t)
{
	D(bug("nfosmesa: glMultiTexCoord2d(0x%x, %f, %f)", target, s, t));
	fn.glMultiTexCoord2d(target, s, t);
}

void OSMesaDriver::nfglMultiTexCoord2dARB(GLenum target, GLdouble s, GLdouble t)
{
	D(bug("nfosmesa: glMultiTexCoord2dARB(0x%x, %f, %f)", target, s, t));
	fn.glMultiTexCoord2dARB(target, s, t);
}

void OSMesaDriver::nfglMultiTexCoord2dv(GLenum target, const GLdouble *v)
{
	D(bug("nfosmesa: glMultiTexCoord2dv(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD2DV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord2dvARB(GLenum target, const GLdouble *v)
{
	D(bug("nfosmesa: glMultiTexCoord2dvARB(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD2DVARB(target, v);
}

void OSMesaDriver::nfglMultiTexCoord2f(GLenum target, GLfloat s, GLfloat t)
{
	D(bug("nfosmesa: glMultiTexCoord2f(0x%x, %f, %f)", target, s, t));
	fn.glMultiTexCoord2f(target, s, t);
}

void OSMesaDriver::nfglMultiTexCoord2fARB(GLenum target, GLfloat s, GLfloat t)
{
	D(bug("nfosmesa: glMultiTexCoord2fARB(0x%x, %f, %f)", target, s, t));
	fn.glMultiTexCoord2fARB(target, s, t);
}

void OSMesaDriver::nfglMultiTexCoord2fv(GLenum target, const GLfloat *v)
{
	D(bug("nfosmesa: glMultiTexCoord2fv(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD2FV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord2fvARB(GLenum target, const GLfloat *v)
{
	D(bug("nfosmesa: glMultiTexCoord2fvARB(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD2FVARB(target, v);
}

void OSMesaDriver::nfglMultiTexCoord2hNV(GLenum target, GLhalfNV32 s, GLhalfNV32 t)
{
	D(bug("nfosmesa: glMultiTexCoord2hNV(0x%x, %u, %u)", target, s, t));
	fn.glMultiTexCoord2hNV(target, s, t);
}

void OSMesaDriver::nfglMultiTexCoord2hvNV(GLenum target, const GLhalfNV *v)
{
	D(bug("nfosmesa: glMultiTexCoord2hvNV(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD2HVNV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord2i(GLenum target, GLint s, GLint t)
{
	D(bug("nfosmesa: glMultiTexCoord2i(0x%x, %d, %d)", target, s, t));
	fn.glMultiTexCoord2i(target, s, t);
}

void OSMesaDriver::nfglMultiTexCoord2iARB(GLenum target, GLint s, GLint t)
{
	D(bug("nfosmesa: glMultiTexCoord2iARB(0x%x, %d, %d)", target, s, t));
	fn.glMultiTexCoord2iARB(target, s, t);
}

void OSMesaDriver::nfglMultiTexCoord2iv(GLenum target, const GLint *v)
{
	D(bug("nfosmesa: glMultiTexCoord2iv(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD2IV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord2ivARB(GLenum target, const GLint *v)
{
	D(bug("nfosmesa: glMultiTexCoord2ivARB(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD2IVARB(target, v);
}

void OSMesaDriver::nfglMultiTexCoord2s(GLenum target, GLshort32 s, GLshort32 t)
{
	D(bug("nfosmesa: glMultiTexCoord2s(0x%x, %d, %d)", target, s, t));
	fn.glMultiTexCoord2s(target, s, t);
}

void OSMesaDriver::nfglMultiTexCoord2sARB(GLenum target, GLshort32 s, GLshort32 t)
{
	D(bug("nfosmesa: glMultiTexCoord2sARB(0x%x, %d, %d)", target, s, t));
	fn.glMultiTexCoord2sARB(target, s, t);
}

void OSMesaDriver::nfglMultiTexCoord2sv(GLenum target, const GLshort *v)
{
	D(bug("nfosmesa: glMultiTexCoord2sv(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD2SV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord2svARB(GLenum target, const GLshort *v)
{
	D(bug("nfosmesa: glMultiTexCoord2svARB(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD2SVARB(target, v);
}

void OSMesaDriver::nfglMultiTexCoord2xOES(GLenum texture, GLfixed s, GLfixed t)
{
	D(bug("nfosmesa: glMultiTexCoord2xOES(0x%x, 0x%x, 0x%x)", texture, s, t));
	fn.glMultiTexCoord2xOES(texture, s, t);
}

void OSMesaDriver::nfglMultiTexCoord2xvOES(GLenum texture, const GLfixed *coords)
{
	D(bug("nfosmesa: glMultiTexCoord2xvOES(0x%x, %p)", texture, coords));
	/* TODO: NFOSMESA_GLMULTITEXCOORD2XVOES may need conversion */
	fn.glMultiTexCoord2xvOES(texture, coords);
}

void OSMesaDriver::nfglMultiTexCoord3bOES(GLenum texture, GLbyte32 s, GLbyte32 t, GLbyte32 r)
{
	D(bug("nfosmesa: glMultiTexCoord3bOES(0x%x, %d, %d, %d)", texture, s, t, r));
	fn.glMultiTexCoord3bOES(texture, s, t, r);
}

void OSMesaDriver::nfglMultiTexCoord3bvOES(GLenum texture, const GLbyte *coords)
{
	D(bug("nfosmesa: glMultiTexCoord3bvOES(0x%x, %p)", texture, coords));
	/* TODO: NFOSMESA_GLMULTITEXCOORD3BVOES may need conversion */
	fn.glMultiTexCoord3bvOES(texture, coords);
}

void OSMesaDriver::nfglMultiTexCoord3d(GLenum target, GLdouble s, GLdouble t, GLdouble r)
{
	D(bug("nfosmesa: glMultiTexCoord3d(0x%x, %f, %f, %f)", 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(0x%x, %f, %f, %f)", target, s, t, r));
	fn.glMultiTexCoord3dARB(target, s, t, r);
}

void OSMesaDriver::nfglMultiTexCoord3dv(GLenum target, const GLdouble *v)
{
	D(bug("nfosmesa: glMultiTexCoord3dv(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD3DV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord3dvARB(GLenum target, const GLdouble *v)
{
	D(bug("nfosmesa: glMultiTexCoord3dvARB(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD3DVARB(target, v);
}

void OSMesaDriver::nfglMultiTexCoord3f(GLenum target, GLfloat s, GLfloat t, GLfloat r)
{
	D(bug("nfosmesa: glMultiTexCoord3f(0x%x, %f, %f, %f)", 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(0x%x, %f, %f, %f)", target, s, t, r));
	fn.glMultiTexCoord3fARB(target, s, t, r);
}

void OSMesaDriver::nfglMultiTexCoord3fv(GLenum target, const GLfloat *v)
{
	D(bug("nfosmesa: glMultiTexCoord3fv(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD3FV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord3fvARB(GLenum target, const GLfloat *v)
{
	D(bug("nfosmesa: glMultiTexCoord3fvARB(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD3FVARB(target, v);
}

void OSMesaDriver::nfglMultiTexCoord3hNV(GLenum target, GLhalfNV32 s, GLhalfNV32 t, GLhalfNV32 r)
{
	D(bug("nfosmesa: glMultiTexCoord3hNV(0x%x, %u, %u, %u)", target, s, t, r));
	fn.glMultiTexCoord3hNV(target, s, t, r);
}

void OSMesaDriver::nfglMultiTexCoord3hvNV(GLenum target, const GLhalfNV *v)
{
	D(bug("nfosmesa: glMultiTexCoord3hvNV(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD3HVNV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord3i(GLenum target, GLint s, GLint t, GLint r)
{
	D(bug("nfosmesa: glMultiTexCoord3i(0x%x, %d, %d, %d)", 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(0x%x, %d, %d, %d)", target, s, t, r));
	fn.glMultiTexCoord3iARB(target, s, t, r);
}

void OSMesaDriver::nfglMultiTexCoord3iv(GLenum target, const GLint *v)
{
	D(bug("nfosmesa: glMultiTexCoord3iv(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD3IV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord3ivARB(GLenum target, const GLint *v)
{
	D(bug("nfosmesa: glMultiTexCoord3ivARB(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD3IVARB(target, v);
}

void OSMesaDriver::nfglMultiTexCoord3s(GLenum target, GLshort32 s, GLshort32 t, GLshort32 r)
{
	D(bug("nfosmesa: glMultiTexCoord3s(0x%x, %d, %d, %d)", 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(0x%x, %d, %d, %d)", target, s, t, r));
	fn.glMultiTexCoord3sARB(target, s, t, r);
}

void OSMesaDriver::nfglMultiTexCoord3sv(GLenum target, const GLshort *v)
{
	D(bug("nfosmesa: glMultiTexCoord3sv(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD3SV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord3svARB(GLenum target, const GLshort *v)
{
	D(bug("nfosmesa: glMultiTexCoord3svARB(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD3SVARB(target, v);
}

void OSMesaDriver::nfglMultiTexCoord3xOES(GLenum texture, GLfixed s, GLfixed t, GLfixed r)
{
	D(bug("nfosmesa: glMultiTexCoord3xOES(0x%x, 0x%x, 0x%x, 0x%x)", texture, s, t, r));
	fn.glMultiTexCoord3xOES(texture, s, t, r);
}

void OSMesaDriver::nfglMultiTexCoord3xvOES(GLenum texture, const GLfixed *coords)
{
	D(bug("nfosmesa: glMultiTexCoord3xvOES(0x%x, %p)", texture, coords));
	/* TODO: NFOSMESA_GLMULTITEXCOORD3XVOES may need conversion */
	fn.glMultiTexCoord3xvOES(texture, coords);
}

void OSMesaDriver::nfglMultiTexCoord4bOES(GLenum texture, GLbyte32 s, GLbyte32 t, GLbyte32 r, GLbyte32 q)
{
	D(bug("nfosmesa: glMultiTexCoord4bOES(0x%x, %d, %d, %d, %d)", texture, s, t, r, q));
	fn.glMultiTexCoord4bOES(texture, s, t, r, q);
}

void OSMesaDriver::nfglMultiTexCoord4bvOES(GLenum texture, const GLbyte *coords)
{
	D(bug("nfosmesa: glMultiTexCoord4bvOES(0x%x, %p)", texture, coords));
	/* TODO: NFOSMESA_GLMULTITEXCOORD4BVOES may need conversion */
	fn.glMultiTexCoord4bvOES(texture, coords);
}

void OSMesaDriver::nfglMultiTexCoord4d(GLenum target, GLdouble s, GLdouble t, GLdouble r, GLdouble q)
{
	D(bug("nfosmesa: glMultiTexCoord4d(0x%x, %f, %f, %f, %f)", 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(0x%x, %f, %f, %f, %f)", target, s, t, r, q));
	fn.glMultiTexCoord4dARB(target, s, t, r, q);
}

void OSMesaDriver::nfglMultiTexCoord4dv(GLenum target, const GLdouble *v)
{
	D(bug("nfosmesa: glMultiTexCoord4dv(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD4DV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord4dvARB(GLenum target, const GLdouble *v)
{
	D(bug("nfosmesa: glMultiTexCoord4dvARB(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD4DVARB(target, v);
}

void OSMesaDriver::nfglMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
	D(bug("nfosmesa: glMultiTexCoord4f(0x%x, %f, %f, %f, %f)", 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(0x%x, %f, %f, %f, %f)", target, s, t, r, q));
	fn.glMultiTexCoord4fARB(target, s, t, r, q);
}

void OSMesaDriver::nfglMultiTexCoord4fv(GLenum target, const GLfloat *v)
{
	D(bug("nfosmesa: glMultiTexCoord4fv(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD4FV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord4fvARB(GLenum target, const GLfloat *v)
{
	D(bug("nfosmesa: glMultiTexCoord4fvARB(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD4FVARB(target, v);
}

void OSMesaDriver::nfglMultiTexCoord4hNV(GLenum target, GLhalfNV32 s, GLhalfNV32 t, GLhalfNV32 r, GLhalfNV32 q)
{
	D(bug("nfosmesa: glMultiTexCoord4hNV(0x%x, %u, %u, %u, %u)", target, s, t, r, q));
	fn.glMultiTexCoord4hNV(target, s, t, r, q);
}

void OSMesaDriver::nfglMultiTexCoord4hvNV(GLenum target, const GLhalfNV *v)
{
	D(bug("nfosmesa: glMultiTexCoord4hvNV(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD4HVNV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord4i(GLenum target, GLint s, GLint t, GLint r, GLint q)
{
	D(bug("nfosmesa: glMultiTexCoord4i(0x%x, %d, %d, %d, %d)", 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(0x%x, %d, %d, %d, %d)", target, s, t, r, q));
	fn.glMultiTexCoord4iARB(target, s, t, r, q);
}

void OSMesaDriver::nfglMultiTexCoord4iv(GLenum target, const GLint *v)
{
	D(bug("nfosmesa: glMultiTexCoord4iv(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD4IV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord4ivARB(GLenum target, const GLint *v)
{
	D(bug("nfosmesa: glMultiTexCoord4ivARB(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD4IVARB(target, v);
}

void OSMesaDriver::nfglMultiTexCoord4s(GLenum target, GLshort32 s, GLshort32 t, GLshort32 r, GLshort32 q)
{
	D(bug("nfosmesa: glMultiTexCoord4s(0x%x, %d, %d, %d, %d)", 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(0x%x, %d, %d, %d, %d)", target, s, t, r, q));
	fn.glMultiTexCoord4sARB(target, s, t, r, q);
}

void OSMesaDriver::nfglMultiTexCoord4sv(GLenum target, const GLshort *v)
{
	D(bug("nfosmesa: glMultiTexCoord4sv(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD4SV(target, v);
}

void OSMesaDriver::nfglMultiTexCoord4svARB(GLenum target, const GLshort *v)
{
	D(bug("nfosmesa: glMultiTexCoord4svARB(0x%x, %p)", target, v));
FN_GLMULTITEXCOORD4SVARB(target, v);
}

void OSMesaDriver::nfglMultiTexCoord4xOES(GLenum texture, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
{
	D(bug("nfosmesa: glMultiTexCoord4xOES(0x%x, 0x%x, 0x%x, 0x%x, 0x%x)", texture, s, t, r, q));
	fn.glMultiTexCoord4xOES(texture, s, t, r, q);
}

void OSMesaDriver::nfglMultiTexCoord4xvOES(GLenum texture, const GLfixed *coords)
{
	D(bug("nfosmesa: glMultiTexCoord4xvOES(0x%x, %p)", texture, coords));
	/* TODO: NFOSMESA_GLMULTITEXCOORD4XVOES may need conversion */
	fn.glMultiTexCoord4xvOES(texture, coords);
}

void OSMesaDriver::nfglMultiTexCoordP1ui(GLenum texture, GLenum type, GLuint coords)
{
	D(bug("nfosmesa: glMultiTexCoordP1ui(0x%x, 0x%x, %u)", texture, type, coords));
	fn.glMultiTexCoordP1ui(texture, type, coords);
}

void OSMesaDriver::nfglMultiTexCoordP1uiv(GLenum texture, GLenum type, const GLuint *coords)
{
	D(bug("nfosmesa: glMultiTexCoordP1uiv(0x%x, 0x%x, %p)", texture, type, coords));
	/* TODO: NFOSMESA_GLMULTITEXCOORDP1UIV may need conversion */
	fn.glMultiTexCoordP1uiv(texture, type, coords);
}

void OSMesaDriver::nfglMultiTexCoordP2ui(GLenum texture, GLenum type, GLuint coords)
{
	D(bug("nfosmesa: glMultiTexCoordP2ui(0x%x, 0x%x, %u)", texture, type, coords));
	fn.glMultiTexCoordP2ui(texture, type, coords);
}

void OSMesaDriver::nfglMultiTexCoordP2uiv(GLenum texture, GLenum type, const GLuint *coords)
{
	D(bug("nfosmesa: glMultiTexCoordP2uiv(0x%x, 0x%x, %p)", texture, type, coords));
	/* TODO: NFOSMESA_GLMULTITEXCOORDP2UIV may need conversion */
	fn.glMultiTexCoordP2uiv(texture, type, coords);
}

void OSMesaDriver::nfglMultiTexCoordP3ui(GLenum texture, GLenum type, GLuint coords)
{
	D(bug("nfosmesa: glMultiTexCoordP3ui(0x%x, 0x%x, %u)", texture, type, coords));
	fn.glMultiTexCoordP3ui(texture, type, coords);
}

void OSMesaDriver::nfglMultiTexCoordP3uiv(GLenum texture, GLenum type, const GLuint *coords)
{
	D(bug("nfosmesa: glMultiTexCoordP3uiv(0x%x, 0x%x, %p)", texture, type, coords));
	/* TODO: NFOSMESA_GLMULTITEXCOORDP3UIV may need conversion */
	fn.glMultiTexCoordP3uiv(texture, type, coords);
}

void OSMesaDriver::nfglMultiTexCoordP4ui(GLenum texture, GLenum type, GLuint coords)
{
	D(bug("nfosmesa: glMultiTexCoordP4ui(0x%x, 0x%x, %u)", texture, type, coords));
	fn.glMultiTexCoordP4ui(texture, type, coords);
}

void OSMesaDriver::nfglMultiTexCoordP4uiv(GLenum texture, GLenum type, const GLuint *coords)
{
	D(bug("nfosmesa: glMultiTexCoordP4uiv(0x%x, 0x%x, %p)", texture, type, coords));
	/* TODO: NFOSMESA_GLMULTITEXCOORDP4UIV may need conversion */
	fn.glMultiTexCoordP4uiv(texture, type, coords);
}

void OSMesaDriver::nfglMultiTexCoordPointerEXT(GLenum texunit, GLint size, GLenum type, GLsizei stride, const void *pointer)
{
	D(bug("nfosmesa: glMultiTexCoordPointerEXT(0x%x, %d, 0x%x, %d, %p)", texunit, size, type, stride, pointer));
	/* TODO: NFOSMESA_GLMULTITEXCOORDPOINTEREXT may need conversion */
	fn.glMultiTexCoordPointerEXT(texunit, size, type, stride, pointer);
}

void OSMesaDriver::nfglMultiTexEnvfEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glMultiTexEnvfEXT(0x%x, 0x%x, 0x%x, %f)", texunit, target, pname, param));
	fn.glMultiTexEnvfEXT(texunit, target, pname, param);
}

void OSMesaDriver::nfglMultiTexEnvfvEXT(GLenum texunit, GLenum target, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glMultiTexEnvfvEXT(0x%x, 0x%x, 0x%x, %p)", texunit, target, pname, params));
	/* TODO: NFOSMESA_GLMULTITEXENVFVEXT may need conversion */
	fn.glMultiTexEnvfvEXT(texunit, target, pname, params);
}

void OSMesaDriver::nfglMultiTexEnviEXT(GLenum texunit, GLenum target, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glMultiTexEnviEXT(0x%x, 0x%x, 0x%x, %d)", texunit, target, pname, param));
	fn.glMultiTexEnviEXT(texunit, target, pname, param);
}

void OSMesaDriver::nfglMultiTexEnvivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glMultiTexEnvivEXT(0x%x, 0x%x, 0x%x, %p)", texunit, target, pname, params));
	/* TODO: NFOSMESA_GLMULTITEXENVIVEXT may need conversion */
	fn.glMultiTexEnvivEXT(texunit, target, pname, params);
}

void OSMesaDriver::nfglMultiTexGendEXT(GLenum texunit, GLenum coord, GLenum pname, GLdouble param)
{
	D(bug("nfosmesa: glMultiTexGendEXT(0x%x, 0x%x, 0x%x, %f)", texunit, coord, pname, param));
	fn.glMultiTexGendEXT(texunit, coord, pname, param);
}

void OSMesaDriver::nfglMultiTexGendvEXT(GLenum texunit, GLenum coord, GLenum pname, const GLdouble *params)
{
	D(bug("nfosmesa: glMultiTexGendvEXT(0x%x, 0x%x, 0x%x, %p)", texunit, coord, pname, params));
	/* TODO: NFOSMESA_GLMULTITEXGENDVEXT may need conversion */
	fn.glMultiTexGendvEXT(texunit, coord, pname, params);
}

void OSMesaDriver::nfglMultiTexGenfEXT(GLenum texunit, GLenum coord, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glMultiTexGenfEXT(0x%x, 0x%x, 0x%x, %f)", texunit, coord, pname, param));
	fn.glMultiTexGenfEXT(texunit, coord, pname, param);
}

void OSMesaDriver::nfglMultiTexGenfvEXT(GLenum texunit, GLenum coord, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glMultiTexGenfvEXT(0x%x, 0x%x, 0x%x, %p)", texunit, coord, pname, params));
	/* TODO: NFOSMESA_GLMULTITEXGENFVEXT may need conversion */
	fn.glMultiTexGenfvEXT(texunit, coord, pname, params);
}

void OSMesaDriver::nfglMultiTexGeniEXT(GLenum texunit, GLenum coord, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glMultiTexGeniEXT(0x%x, 0x%x, 0x%x, %d)", texunit, coord, pname, param));
	fn.glMultiTexGeniEXT(texunit, coord, pname, param);
}

void OSMesaDriver::nfglMultiTexGenivEXT(GLenum texunit, GLenum coord, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glMultiTexGenivEXT(0x%x, 0x%x, 0x%x, %p)", texunit, coord, pname, params));
	/* TODO: NFOSMESA_GLMULTITEXGENIVEXT may need conversion */
	fn.glMultiTexGenivEXT(texunit, coord, pname, params);
}

void OSMesaDriver::nfglMultiTexImage1DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
{
	D(bug("nfosmesa: glMultiTexImage1DEXT(0x%x, 0x%x, %d, 0x%x, %d, %d, 0x%x, 0x%x, %p)", texunit, target, level, internalformat, width, border, format, type, pixels));
	/* TODO: NFOSMESA_GLMULTITEXIMAGE1DEXT may need conversion */
	fn.glMultiTexImage1DEXT(texunit, target, level, internalformat, width, border, format, type, pixels);
}

void OSMesaDriver::nfglMultiTexImage2DEXT(GLenum texunit, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
{
	D(bug("nfosmesa: glMultiTexImage2DEXT(0x%x, 0x%x, %d, 0x%x, %d, %d, %d, 0x%x, 0x%x, %p)", texunit, target, level, internalformat, width, height, border, format, type, pixels));
	/* TODO: NFOSMESA_GLMULTITEXIMAGE2DEXT may need conversion */
	fn.glMultiTexImage2DEXT(texunit, target, level, internalformat, width, height, border, format, type, pixels);
}

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)
{
	D(bug("nfosmesa: glMultiTexImage3DEXT(0x%x, 0x%x, %d, 0x%x, %d, %d, %d, %d, 0x%x, 0x%x, %p)", texunit, target, level, internalformat, width, height, depth, border, format, type, pixels));
	/* TODO: NFOSMESA_GLMULTITEXIMAGE3DEXT may need conversion */
	fn.glMultiTexImage3DEXT(texunit, target, level, internalformat, width, height, depth, border, format, type, pixels);
}

void OSMesaDriver::nfglMultiTexParameterIivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glMultiTexParameterIivEXT(0x%x, 0x%x, 0x%x, %p)", texunit, target, pname, params));
	/* TODO: NFOSMESA_GLMULTITEXPARAMETERIIVEXT may need conversion */
	fn.glMultiTexParameterIivEXT(texunit, target, pname, params);
}

void OSMesaDriver::nfglMultiTexParameterIuivEXT(GLenum texunit, GLenum target, GLenum pname, const GLuint *params)
{
	D(bug("nfosmesa: glMultiTexParameterIuivEXT(0x%x, 0x%x, 0x%x, %p)", texunit, target, pname, params));
	/* TODO: NFOSMESA_GLMULTITEXPARAMETERIUIVEXT may need conversion */
	fn.glMultiTexParameterIuivEXT(texunit, target, pname, params);
}

void OSMesaDriver::nfglMultiTexParameterfEXT(GLenum texunit, GLenum target, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glMultiTexParameterfEXT(0x%x, 0x%x, 0x%x, %f)", texunit, target, pname, param));
	fn.glMultiTexParameterfEXT(texunit, target, pname, param);
}

void OSMesaDriver::nfglMultiTexParameterfvEXT(GLenum texunit, GLenum target, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glMultiTexParameterfvEXT(0x%x, 0x%x, 0x%x, %p)", texunit, target, pname, params));
	/* TODO: NFOSMESA_GLMULTITEXPARAMETERFVEXT may need conversion */
	fn.glMultiTexParameterfvEXT(texunit, target, pname, params);
}

void OSMesaDriver::nfglMultiTexParameteriEXT(GLenum texunit, GLenum target, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glMultiTexParameteriEXT(0x%x, 0x%x, 0x%x, %d)", texunit, target, pname, param));
	fn.glMultiTexParameteriEXT(texunit, target, pname, param);
}

void OSMesaDriver::nfglMultiTexParameterivEXT(GLenum texunit, GLenum target, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glMultiTexParameterivEXT(0x%x, 0x%x, 0x%x, %p)", texunit, target, pname, params));
	/* TODO: NFOSMESA_GLMULTITEXPARAMETERIVEXT may need conversion */
	fn.glMultiTexParameterivEXT(texunit, target, pname, params);
}

void OSMesaDriver::nfglMultiTexRenderbufferEXT(GLenum texunit, GLenum target, GLuint renderbuffer)
{
	D(bug("nfosmesa: glMultiTexRenderbufferEXT(0x%x, 0x%x, %u)", texunit, target, renderbuffer));
	fn.glMultiTexRenderbufferEXT(texunit, target, renderbuffer);
}

void OSMesaDriver::nfglMultiTexSubImage1DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
{
	D(bug("nfosmesa: glMultiTexSubImage1DEXT(0x%x, 0x%x, %d, %d, %d, 0x%x, 0x%x, %p)", texunit, target, level, xoffset, width, format, type, pixels));
	/* TODO: NFOSMESA_GLMULTITEXSUBIMAGE1DEXT may need conversion */
	fn.glMultiTexSubImage1DEXT(texunit, target, level, xoffset, width, format, type, pixels);
}

void OSMesaDriver::nfglMultiTexSubImage2DEXT(GLenum texunit, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
{
	D(bug("nfosmesa: glMultiTexSubImage2DEXT(0x%x, 0x%x, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p)", texunit, target, level, xoffset, yoffset, width, height, format, type, pixels));
	/* TODO: NFOSMESA_GLMULTITEXSUBIMAGE2DEXT may need conversion */
	fn.glMultiTexSubImage2DEXT(texunit, target, level, xoffset, yoffset, width, height, format, type, pixels);
}

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)
{
	D(bug("nfosmesa: glMultiTexSubImage3DEXT(0x%x, 0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p)", texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels));
	/* TODO: NFOSMESA_GLMULTITEXSUBIMAGE3DEXT may need conversion */
	fn.glMultiTexSubImage3DEXT(texunit, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
}

void OSMesaDriver::nfglNamedBufferDataEXT(GLuint buffer, GLsizeiptr size, const void *data, GLenum usage)
{
	D(bug("nfosmesa: glNamedBufferDataEXT(%u, %ld, %p, 0x%x)", buffer, size, data, usage));
	/* TODO: NFOSMESA_GLNAMEDBUFFERDATAEXT may need conversion */
	fn.glNamedBufferDataEXT(buffer, size, data, usage);
}

void OSMesaDriver::nfglNamedBufferStorageEXT(GLuint buffer, GLsizeiptr size, const void *data, GLbitfield flags)
{
	D(bug("nfosmesa: glNamedBufferStorageEXT(%u, %ld, %p, 0x%x)", buffer, size, data, flags));
	/* TODO: NFOSMESA_GLNAMEDBUFFERSTORAGEEXT may need conversion */
	fn.glNamedBufferStorageEXT(buffer, size, data, flags);
}

void OSMesaDriver::nfglNamedBufferSubDataEXT(GLuint buffer, GLintptr offset, GLsizeiptr size, const void *data)
{
	D(bug("nfosmesa: glNamedBufferSubDataEXT(%u, %ld, %ld, %p)", buffer, offset, size, data));
	/* TODO: NFOSMESA_GLNAMEDBUFFERSUBDATAEXT may need conversion */
	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, %ld, %ld, %ld)", readBuffer, writeBuffer, readOffset, writeOffset, size));
	fn.glNamedCopyBufferSubDataEXT(readBuffer, writeBuffer, readOffset, writeOffset, size);
}

void OSMesaDriver::nfglNamedFramebufferParameteriEXT(GLuint framebuffer, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glNamedFramebufferParameteriEXT(%u, 0x%x, %d)", framebuffer, pname, param));
	fn.glNamedFramebufferParameteriEXT(framebuffer, pname, param);
}

void OSMesaDriver::nfglNamedFramebufferRenderbufferEXT(GLuint framebuffer, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer)
{
	D(bug("nfosmesa: glNamedFramebufferRenderbufferEXT(%u, 0x%x, 0x%x, %u)", framebuffer, attachment, renderbuffertarget, renderbuffer));
	fn.glNamedFramebufferRenderbufferEXT(framebuffer, attachment, renderbuffertarget, renderbuffer);
}

void OSMesaDriver::nfglNamedFramebufferTexture1DEXT(GLuint framebuffer, GLenum attachment, GLenum textarget, GLuint texture, GLint level)
{
	D(bug("nfosmesa: glNamedFramebufferTexture1DEXT(%u, 0x%x, 0x%x, %u, %d)", framebuffer, attachment, 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, 0x%x, 0x%x, %u, %d)", framebuffer, attachment, 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, 0x%x, 0x%x, %u, %d, %d)", framebuffer, attachment, 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, 0x%x, %u, %d)", framebuffer, 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, 0x%x, %u, %d, 0x%x)", framebuffer, attachment, texture, level, face));
	fn.glNamedFramebufferTextureFaceEXT(framebuffer, attachment, texture, level, face);
}

void OSMesaDriver::nfglNamedFramebufferTextureLayerEXT(GLuint framebuffer, GLenum attachment, GLuint texture, GLint level, GLint layer)
{
	D(bug("nfosmesa: glNamedFramebufferTextureLayerEXT(%u, 0x%x, %u, %d, %d)", framebuffer, 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, 0x%x, %u, %f, %f, %f, %f)", program, target, index, x, y, z, w));
	fn.glNamedProgramLocalParameter4dEXT(program, target, index, x, y, z, w);
}

void OSMesaDriver::nfglNamedProgramLocalParameter4dvEXT(GLuint program, GLenum target, GLuint index, const GLdouble *params)
{
	D(bug("nfosmesa: glNamedProgramLocalParameter4dvEXT(%u, 0x%x, %u, %p)", program, target, index, params));
	/* TODO: NFOSMESA_GLNAMEDPROGRAMLOCALPARAMETER4DVEXT may need conversion */
	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, 0x%x, %u, %f, %f, %f, %f)", program, target, index, x, y, z, w));
	fn.glNamedProgramLocalParameter4fEXT(program, target, index, x, y, z, w);
}

void OSMesaDriver::nfglNamedProgramLocalParameter4fvEXT(GLuint program, GLenum target, GLuint index, const GLfloat *params)
{
	D(bug("nfosmesa: glNamedProgramLocalParameter4fvEXT(%u, 0x%x, %u, %p)", program, target, index, params));
	/* TODO: NFOSMESA_GLNAMEDPROGRAMLOCALPARAMETER4FVEXT may need conversion */
	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, 0x%x, %u, %d, %d, %d, %d)", program, target, index, x, y, z, w));
	fn.glNamedProgramLocalParameterI4iEXT(program, target, index, x, y, z, w);
}

void OSMesaDriver::nfglNamedProgramLocalParameterI4ivEXT(GLuint program, GLenum target, GLuint index, const GLint *params)
{
	D(bug("nfosmesa: glNamedProgramLocalParameterI4ivEXT(%u, 0x%x, %u, %p)", program, target, index, params));
	/* TODO: NFOSMESA_GLNAMEDPROGRAMLOCALPARAMETERI4IVEXT may need conversion */
	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, 0x%x, %u, %u, %u, %u, %u)", program, target, index, x, y, z, w));
	fn.glNamedProgramLocalParameterI4uiEXT(program, target, index, x, y, z, w);
}

void OSMesaDriver::nfglNamedProgramLocalParameterI4uivEXT(GLuint program, GLenum target, GLuint index, const GLuint *params)
{
	D(bug("nfosmesa: glNamedProgramLocalParameterI4uivEXT(%u, 0x%x, %u, %p)", program, target, index, params));
	/* TODO: NFOSMESA_GLNAMEDPROGRAMLOCALPARAMETERI4UIVEXT may need conversion */
	fn.glNamedProgramLocalParameterI4uivEXT(program, target, index, params);
}

void OSMesaDriver::nfglNamedProgramLocalParameters4fvEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLfloat *params)
{
	D(bug("nfosmesa: glNamedProgramLocalParameters4fvEXT(%u, 0x%x, %u, %d, %p)", program, target, index, count, params));
	/* TODO: NFOSMESA_GLNAMEDPROGRAMLOCALPARAMETERS4FVEXT may need conversion */
	fn.glNamedProgramLocalParameters4fvEXT(program, target, index, count, params);
}

void OSMesaDriver::nfglNamedProgramLocalParametersI4ivEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLint *params)
{
	D(bug("nfosmesa: glNamedProgramLocalParametersI4ivEXT(%u, 0x%x, %u, %d, %p)", program, target, index, count, params));
	/* TODO: NFOSMESA_GLNAMEDPROGRAMLOCALPARAMETERSI4IVEXT may need conversion */
	fn.glNamedProgramLocalParametersI4ivEXT(program, target, index, count, params);
}

void OSMesaDriver::nfglNamedProgramLocalParametersI4uivEXT(GLuint program, GLenum target, GLuint index, GLsizei count, const GLuint *params)
{
	D(bug("nfosmesa: glNamedProgramLocalParametersI4uivEXT(%u, 0x%x, %u, %d, %p)", program, target, index, count, params));
	/* TODO: NFOSMESA_GLNAMEDPROGRAMLOCALPARAMETERSI4UIVEXT may need conversion */
	fn.glNamedProgramLocalParametersI4uivEXT(program, target, index, count, params);
}

void OSMesaDriver::nfglNamedProgramStringEXT(GLuint program, GLenum target, GLenum format, GLsizei len, const void *string)
{
	D(bug("nfosmesa: glNamedProgramStringEXT(%u, 0x%x, 0x%x, %d, %p)", program, target, format, len, string));
	/* TODO: NFOSMESA_GLNAMEDPROGRAMSTRINGEXT may need conversion */
	fn.glNamedProgramStringEXT(program, target, format, len, string);
}

void OSMesaDriver::nfglNamedRenderbufferStorageEXT(GLuint renderbuffer, GLenum internalformat, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glNamedRenderbufferStorageEXT(%u, 0x%x, %d, %d)", renderbuffer, internalformat, width, height));
	fn.glNamedRenderbufferStorageEXT(renderbuffer, 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, 0x%x, %d, %d)", renderbuffer, coverageSamples, colorSamples, 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, 0x%x, %d, %d)", renderbuffer, samples, internalformat, width, height));
	fn.glNamedRenderbufferStorageMultisampleEXT(renderbuffer, samples, internalformat, width, height);
}

void OSMesaDriver::nfglNamedStringARB(GLenum type, GLint namelen, const GLchar *name, GLint stringlen, const GLchar *string)
{
	D(bug("nfosmesa: glNamedStringARB(0x%x, %d, %p, %d, %p)", type, namelen, name, stringlen, string));
	/* TODO: NFOSMESA_GLNAMEDSTRINGARB may need conversion */
	fn.glNamedStringARB(type, namelen, name, stringlen, string);
}

void OSMesaDriver::nfglNewList(GLuint list, GLenum mode)
{
	D(bug("nfosmesa: glNewList(%u, 0x%x)", list, mode));
	fn.glNewList(list, mode);
}

GLuint OSMesaDriver::nfglNewObjectBufferATI(GLsizei size, const void *pointer, GLenum usage)
{
	D(bug("nfosmesa: glNewObjectBufferATI(%d, %p, 0x%x)", size, pointer, usage));
	/* TODO: NFOSMESA_GLNEWOBJECTBUFFERATI may need conversion */
	return fn.glNewObjectBufferATI(size, pointer, usage);
}

void OSMesaDriver::nfglNewTraceMESA(GLbitfield mask, const GLubyte *traceName)
{
	D(bug("nfosmesa: glNewTraceMESA(0x%x, %p)", mask, traceName));
	/* TODO: NFOSMESA_GLNEWTRACEMESA may need conversion */
	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);
}

void OSMesaDriver::nfglNormal3bv(const GLbyte *v)
{
	D(bug("nfosmesa: glNormal3bv(%p)", v));
	/* TODO: NFOSMESA_GLNORMAL3BV may need conversion */
	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);
}

void OSMesaDriver::nfglNormal3dv(const GLdouble *v)
{
	D(bug("nfosmesa: glNormal3dv(%p)", 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);
}

void OSMesaDriver::nfglNormal3fVertex3fvSUN(const GLfloat *n, const GLfloat *v)
{
	D(bug("nfosmesa: glNormal3fVertex3fvSUN(%p, %p)", n, v));
FN_GLNORMAL3FVERTEX3FVSUN(n, v);
}

void OSMesaDriver::nfglNormal3fv(const GLfloat *v)
{
	D(bug("nfosmesa: glNormal3fv(%p)", 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);
}

void OSMesaDriver::nfglNormal3hvNV(const GLhalfNV *v)
{
	D(bug("nfosmesa: glNormal3hvNV(%p)", 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);
}

void OSMesaDriver::nfglNormal3iv(const GLint *v)
{
	D(bug("nfosmesa: glNormal3iv(%p)", 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);
}

void OSMesaDriver::nfglNormal3sv(const GLshort *v)
{
	D(bug("nfosmesa: glNormal3sv(%p)", 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);
}

void OSMesaDriver::nfglNormal3xvOES(const GLfixed *coords)
{
	D(bug("nfosmesa: glNormal3xvOES(%p)", coords));
	/* TODO: NFOSMESA_GLNORMAL3XVOES may need conversion */
	fn.glNormal3xvOES(coords);
}

void OSMesaDriver::nfglNormalFormatNV(GLenum type, GLsizei stride)
{
	D(bug("nfosmesa: glNormalFormatNV(0x%x, %d)", type, stride));
	fn.glNormalFormatNV(type, stride);
}

void OSMesaDriver::nfglNormalP3ui(GLenum type, GLuint coords)
{
	D(bug("nfosmesa: glNormalP3ui(0x%x, %u)", type, coords));
	fn.glNormalP3ui(type, coords);
}

void OSMesaDriver::nfglNormalP3uiv(GLenum type, const GLuint *coords)
{
	D(bug("nfosmesa: glNormalP3uiv(0x%x, %p)", type, coords));
	/* TODO: NFOSMESA_GLNORMALP3UIV may need conversion */
	fn.glNormalP3uiv(type, coords);
}

void OSMesaDriver::nfglNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer)
{
	D(bug("nfosmesa: glNormalPointer(0x%x, %d, %p)", type, stride, pointer));
FN_GLNORMALPOINTER(type, stride, pointer);
}

void OSMesaDriver::nfglNormalPointerEXT(GLenum type, GLsizei stride, GLsizei count, const void *pointer)
{
	D(bug("nfosmesa: glNormalPointerEXT(0x%x, %d, %d, %p)", type, stride, count, pointer));
FN_GLNORMALPOINTEREXT(type, stride, count, pointer);
}

void OSMesaDriver::nfglNormalPointerListIBM(GLenum type, GLint stride, const void * *pointer, GLint ptrstride)
{
	D(bug("nfosmesa: glNormalPointerListIBM(0x%x, %d, %p, %d)", type, stride, pointer, ptrstride));
	/* TODO: NFOSMESA_GLNORMALPOINTERLISTIBM may need conversion */
	fn.glNormalPointerListIBM(type, stride, pointer, ptrstride);
}

void OSMesaDriver::nfglNormalPointervINTEL(GLenum type, const void * *pointer)
{
	D(bug("nfosmesa: glNormalPointervINTEL(0x%x, %p)", type, pointer));
	/* TODO: NFOSMESA_GLNORMALPOINTERVINTEL may need conversion */
	fn.glNormalPointervINTEL(type, pointer);
}

void OSMesaDriver::nfglNormalStream3bATI(GLenum stream, GLbyte32 nx, GLbyte32 ny, GLbyte32 nz)
{
	D(bug("nfosmesa: glNormalStream3bATI(0x%x, %d, %d, %d)", stream, nx, ny, nz));
	fn.glNormalStream3bATI(stream, nx, ny, nz);
}

void OSMesaDriver::nfglNormalStream3bvATI(GLenum stream, const GLbyte *coords)
{
	D(bug("nfosmesa: glNormalStream3bvATI(0x%x, %p)", stream, coords));
	/* TODO: NFOSMESA_GLNORMALSTREAM3BVATI may need conversion */
	fn.glNormalStream3bvATI(stream, coords);
}

void OSMesaDriver::nfglNormalStream3dATI(GLenum stream, GLdouble nx, GLdouble ny, GLdouble nz)
{
	D(bug("nfosmesa: glNormalStream3dATI(0x%x, %f, %f, %f)", stream, nx, ny, nz));
	fn.glNormalStream3dATI(stream, nx, ny, nz);
}

void OSMesaDriver::nfglNormalStream3dvATI(GLenum stream, const GLdouble *coords)
{
	D(bug("nfosmesa: glNormalStream3dvATI(0x%x, %p)", stream, coords));
FN_GLNORMALSTREAM3DVATI(stream, coords);
}

void OSMesaDriver::nfglNormalStream3fATI(GLenum stream, GLfloat nx, GLfloat ny, GLfloat nz)
{
	D(bug("nfosmesa: glNormalStream3fATI(0x%x, %f, %f, %f)", stream, nx, ny, nz));
	fn.glNormalStream3fATI(stream, nx, ny, nz);
}

void OSMesaDriver::nfglNormalStream3fvATI(GLenum stream, const GLfloat *coords)
{
	D(bug("nfosmesa: glNormalStream3fvATI(0x%x, %p)", stream, coords));
FN_GLNORMALSTREAM3FVATI(stream, coords);
}

void OSMesaDriver::nfglNormalStream3iATI(GLenum stream, GLint nx, GLint ny, GLint nz)
{
	D(bug("nfosmesa: glNormalStream3iATI(0x%x, %d, %d, %d)", stream, nx, ny, nz));
	fn.glNormalStream3iATI(stream, nx, ny, nz);
}

void OSMesaDriver::nfglNormalStream3ivATI(GLenum stream, const GLint *coords)
{
	D(bug("nfosmesa: glNormalStream3ivATI(0x%x, %p)", stream, coords));
FN_GLNORMALSTREAM3IVATI(stream, coords);
}

void OSMesaDriver::nfglNormalStream3sATI(GLenum stream, GLshort32 nx, GLshort32 ny, GLshort32 nz)
{
	D(bug("nfosmesa: glNormalStream3sATI(0x%x, %d, %d, %d)", stream, nx, ny, nz));
	fn.glNormalStream3sATI(stream, nx, ny, nz);
}

void OSMesaDriver::nfglNormalStream3svATI(GLenum stream, const GLshort *coords)
{
	D(bug("nfosmesa: glNormalStream3svATI(0x%x, %p)", stream, coords));
FN_GLNORMALSTREAM3SVATI(stream, coords);
}

void OSMesaDriver::nfglObjectLabel(GLenum identifier, GLuint name, GLsizei length, const GLchar *label)
{
	D(bug("nfosmesa: glObjectLabel(0x%x, %u, %d, %p)", identifier, name, length, label));
	/* TODO: NFOSMESA_GLOBJECTLABEL may need conversion */
	fn.glObjectLabel(identifier, name, length, label);
}

void OSMesaDriver::nfglObjectPtrLabel(const void *ptr, GLsizei length, const GLchar *label)
{
	D(bug("nfosmesa: glObjectPtrLabel(%p, %d, %p)", ptr, length, label));
	/* TODO: NFOSMESA_GLOBJECTPTRLABEL may need conversion */
	fn.glObjectPtrLabel(ptr, length, label);
}

GLenum OSMesaDriver::nfglObjectPurgeableAPPLE(GLenum objectType, GLuint name, GLenum option)
{
	D(bug("nfosmesa: glObjectPurgeableAPPLE(0x%x, %u, 0x%x)", objectType, name, option));
	return fn.glObjectPurgeableAPPLE(objectType, name, option);
}

GLenum OSMesaDriver::nfglObjectUnpurgeableAPPLE(GLenum objectType, GLuint name, GLenum option)
{
	D(bug("nfosmesa: glObjectUnpurgeableAPPLE(0x%x, %u, 0x%x)", objectType, name, option));
	return fn.glObjectUnpurgeableAPPLE(objectType, name, option);
}

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(0x%x, %f)", pname, param));
	fn.glPNTrianglesfATI(pname, param);
}

void OSMesaDriver::nfglPNTrianglesiATI(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glPNTrianglesiATI(0x%x, %d)", pname, param));
	fn.glPNTrianglesiATI(pname, param);
}

void OSMesaDriver::nfglPassTexCoordATI(GLuint dst, GLuint coord, GLenum swizzle)
{
	D(bug("nfosmesa: glPassTexCoordATI(%u, %u, 0x%x)", dst, coord, 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);
}

void OSMesaDriver::nfglPatchParameterfv(GLenum pname, const GLfloat *values)
{
	D(bug("nfosmesa: glPatchParameterfv(0x%x, %p)", pname, values));
	/* TODO: NFOSMESA_GLPATCHPARAMETERFV may need conversion */
	fn.glPatchParameterfv(pname, values);
}

void OSMesaDriver::nfglPatchParameteri(GLenum pname, GLint value)
{
	D(bug("nfosmesa: glPatchParameteri(0x%x, %d)", pname, value));
	fn.glPatchParameteri(pname, value);
}

void OSMesaDriver::nfglPathColorGenNV(GLenum color, GLenum genMode, GLenum colorFormat, const GLfloat *coeffs)
{
	D(bug("nfosmesa: glPathColorGenNV(0x%x, 0x%x, 0x%x, %p)", color, genMode, colorFormat, coeffs));
	/* TODO: NFOSMESA_GLPATHCOLORGENNV may need conversion */
	fn.glPathColorGenNV(color, genMode, colorFormat, coeffs);
}

void OSMesaDriver::nfglPathCommandsNV(GLuint path, GLsizei numCommands, const GLubyte *commands, GLsizei numCoords, GLenum coordType, const void *coords)
{
	D(bug("nfosmesa: glPathCommandsNV(%u, %d, %p, %d, 0x%x, %p)", path, numCommands, commands, numCoords, coordType, coords));
	/* TODO: NFOSMESA_GLPATHCOMMANDSNV may need conversion */
	fn.glPathCommandsNV(path, numCommands, commands, numCoords, coordType, coords);
}

void OSMesaDriver::nfglPathCoordsNV(GLuint path, GLsizei numCoords, GLenum coordType, const void *coords)
{
	D(bug("nfosmesa: glPathCoordsNV(%u, %d, 0x%x, %p)", path, numCoords, coordType, coords));
	/* TODO: NFOSMESA_GLPATHCOORDSNV may need conversion */
	fn.glPathCoordsNV(path, numCoords, coordType, coords);
}

void OSMesaDriver::nfglPathCoverDepthFuncNV(GLenum func)
{
	D(bug("nfosmesa: glPathCoverDepthFuncNV(0x%x)", func));
	fn.glPathCoverDepthFuncNV(func);
}

void OSMesaDriver::nfglPathDashArrayNV(GLuint path, GLsizei dashCount, const GLfloat *dashArray)
{
	D(bug("nfosmesa: glPathDashArrayNV(%u, %d, %p)", path, dashCount, dashArray));
	/* TODO: NFOSMESA_GLPATHDASHARRAYNV may need conversion */
	fn.glPathDashArrayNV(path, dashCount, dashArray);
}

void OSMesaDriver::nfglPathFogGenNV(GLenum genMode)
{
	D(bug("nfosmesa: glPathFogGenNV(0x%x)", genMode));
	fn.glPathFogGenNV(genMode);
}

void OSMesaDriver::nfglPathGlyphRangeNV(GLuint firstPathName, GLenum fontTarget, const void *fontName, GLbitfield fontStyle, GLuint firstGlyph, GLsizei numGlyphs, GLenum handleMissingGlyphs, GLuint pathParameterTemplate, GLfloat emScale)
{
	D(bug("nfosmesa: glPathGlyphRangeNV(%u, 0x%x, %p, 0x%x, %u, %d, 0x%x, %u, %f)", firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale));
	/* TODO: NFOSMESA_GLPATHGLYPHRANGENV may need conversion */
	fn.glPathGlyphRangeNV(firstPathName, fontTarget, fontName, fontStyle, firstGlyph, numGlyphs, handleMissingGlyphs, pathParameterTemplate, emScale);
}

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)
{
	D(bug("nfosmesa: glPathGlyphsNV(%u, 0x%x, %p, 0x%x, %d, 0x%x, %p, 0x%x, %u, %f)", firstPathName, fontTarget, fontName, fontStyle, numGlyphs, type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale));
	/* TODO: NFOSMESA_GLPATHGLYPHSNV may need conversion */
	fn.glPathGlyphsNV(firstPathName, fontTarget, fontName, fontStyle, numGlyphs, type, charcodes, handleMissingGlyphs, pathParameterTemplate, emScale);
}

void OSMesaDriver::nfglPathParameterfNV(GLuint path, GLenum pname, GLfloat value)
{
	D(bug("nfosmesa: glPathParameterfNV(%u, 0x%x, %f)", path, pname, value));
	fn.glPathParameterfNV(path, pname, value);
}

void OSMesaDriver::nfglPathParameterfvNV(GLuint path, GLenum pname, const GLfloat *value)
{
	D(bug("nfosmesa: glPathParameterfvNV(%u, 0x%x, %p)", path, pname, value));
	/* TODO: NFOSMESA_GLPATHPARAMETERFVNV may need conversion */
	fn.glPathParameterfvNV(path, pname, value);
}

void OSMesaDriver::nfglPathParameteriNV(GLuint path, GLenum pname, GLint value)
{
	D(bug("nfosmesa: glPathParameteriNV(%u, 0x%x, %d)", path, pname, value));
	fn.glPathParameteriNV(path, pname, value);
}

void OSMesaDriver::nfglPathParameterivNV(GLuint path, GLenum pname, const GLint *value)
{
	D(bug("nfosmesa: glPathParameterivNV(%u, 0x%x, %p)", path, pname, value));
	/* TODO: NFOSMESA_GLPATHPARAMETERIVNV may need conversion */
	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(0x%x, %d, %u)", func, ref, mask));
	fn.glPathStencilFuncNV(func, ref, mask);
}

void OSMesaDriver::nfglPathStringNV(GLuint path, GLenum format, GLsizei length, const void *pathString)
{
	D(bug("nfosmesa: glPathStringNV(%u, 0x%x, %d, %p)", path, format, length, pathString));
	/* TODO: NFOSMESA_GLPATHSTRINGNV may need conversion */
	fn.glPathStringNV(path, format, length, pathString);
}

void OSMesaDriver::nfglPathSubCommandsNV(GLuint path, GLsizei commandStart, GLsizei commandsToDelete, GLsizei numCommands, const GLubyte *commands, GLsizei numCoords, GLenum coordType, const void *coords)
{
	D(bug("nfosmesa: glPathSubCommandsNV(%u, %d, %d, %d, %p, %d, 0x%x, %p)", path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords));
	/* TODO: NFOSMESA_GLPATHSUBCOMMANDSNV may need conversion */
	fn.glPathSubCommandsNV(path, commandStart, commandsToDelete, numCommands, commands, numCoords, coordType, coords);
}

void OSMesaDriver::nfglPathSubCoordsNV(GLuint path, GLsizei coordStart, GLsizei numCoords, GLenum coordType, const void *coords)
{
	D(bug("nfosmesa: glPathSubCoordsNV(%u, %d, %d, 0x%x, %p)", path, coordStart, numCoords, coordType, coords));
	/* TODO: NFOSMESA_GLPATHSUBCOORDSNV may need conversion */
	fn.glPathSubCoordsNV(path, coordStart, numCoords, coordType, coords);
}

void OSMesaDriver::nfglPathTexGenNV(GLenum texCoordSet, GLenum genMode, GLint components, const GLfloat *coeffs)
{
	D(bug("nfosmesa: glPathTexGenNV(0x%x, 0x%x, %d, %p)", texCoordSet, genMode, components, coeffs));
	/* TODO: NFOSMESA_GLPATHTEXGENNV may need conversion */
	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();
}

void OSMesaDriver::nfglPixelDataRangeNV(GLenum target, GLsizei length, const void *pointer)
{
	D(bug("nfosmesa: glPixelDataRangeNV(0x%x, %d, %p)", target, length, pointer));
	/* TODO: NFOSMESA_GLPIXELDATARANGENV may need conversion */
	fn.glPixelDataRangeNV(target, length, pointer);
}

void OSMesaDriver::nfglPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
{
	D(bug("nfosmesa: glPixelMapfv(0x%x, %d, %p)", map, mapsize, values));
FN_GLPIXELMAPFV(map, mapsize, values);
}

void OSMesaDriver::nfglPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
{
	D(bug("nfosmesa: glPixelMapuiv(0x%x, %d, %p)", map, mapsize, values));
FN_GLPIXELMAPUIV(map, mapsize, values);
}

void OSMesaDriver::nfglPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
{
	D(bug("nfosmesa: glPixelMapusv(0x%x, %d, %p)", map, mapsize, values));
FN_GLPIXELMAPUSV(map, mapsize, values);
}

void OSMesaDriver::nfglPixelMapx(GLenum map, GLint size, const GLfixed *values)
{
	D(bug("nfosmesa: glPixelMapx(0x%x, %d, %p)", map, size, values));
	/* TODO: NFOSMESA_GLPIXELMAPX may need conversion */
	fn.glPixelMapx(map, size, values);
}

void OSMesaDriver::nfglPixelStoref(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glPixelStoref(0x%x, %f)", pname, param));
	fn.glPixelStoref(pname, param);
}

void OSMesaDriver::nfglPixelStorei(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glPixelStorei(0x%x, %d)", pname, param));
	fn.glPixelStorei(pname, param);
}

void OSMesaDriver::nfglPixelStorex(GLenum pname, GLfixed param)
{
	D(bug("nfosmesa: glPixelStorex(0x%x, 0x%x)", pname, param));
	fn.glPixelStorex(pname, param);
}

void OSMesaDriver::nfglPixelTexGenParameterfSGIS(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glPixelTexGenParameterfSGIS(0x%x, %f)", pname, param));
	fn.glPixelTexGenParameterfSGIS(pname, param);
}

void OSMesaDriver::nfglPixelTexGenParameterfvSGIS(GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glPixelTexGenParameterfvSGIS(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLPIXELTEXGENPARAMETERFVSGIS may need conversion */
	fn.glPixelTexGenParameterfvSGIS(pname, params);
}

void OSMesaDriver::nfglPixelTexGenParameteriSGIS(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glPixelTexGenParameteriSGIS(0x%x, %d)", pname, param));
	fn.glPixelTexGenParameteriSGIS(pname, param);
}

void OSMesaDriver::nfglPixelTexGenParameterivSGIS(GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glPixelTexGenParameterivSGIS(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLPIXELTEXGENPARAMETERIVSGIS may need conversion */
	fn.glPixelTexGenParameterivSGIS(pname, params);
}

void OSMesaDriver::nfglPixelTexGenSGIX(GLenum mode)
{
	D(bug("nfosmesa: glPixelTexGenSGIX(0x%x)", mode));
	fn.glPixelTexGenSGIX(mode);
}

void OSMesaDriver::nfglPixelTransferf(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glPixelTransferf(0x%x, %f)", pname, param));
	fn.glPixelTransferf(pname, param);
}

void OSMesaDriver::nfglPixelTransferi(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glPixelTransferi(0x%x, %d)", pname, param));
	fn.glPixelTransferi(pname, param);
}

void OSMesaDriver::nfglPixelTransferxOES(GLenum pname, GLfixed param)
{
	D(bug("nfosmesa: glPixelTransferxOES(0x%x, 0x%x)", pname, param));
	fn.glPixelTransferxOES(pname, param);
}

void OSMesaDriver::nfglPixelTransformParameterfEXT(GLenum target, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glPixelTransformParameterfEXT(0x%x, 0x%x, %f)", target, pname, param));
	fn.glPixelTransformParameterfEXT(target, pname, param);
}

void OSMesaDriver::nfglPixelTransformParameterfvEXT(GLenum target, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glPixelTransformParameterfvEXT(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLPIXELTRANSFORMPARAMETERFVEXT may need conversion */
	fn.glPixelTransformParameterfvEXT(target, pname, params);
}

void OSMesaDriver::nfglPixelTransformParameteriEXT(GLenum target, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glPixelTransformParameteriEXT(0x%x, 0x%x, %d)", target, pname, param));
	fn.glPixelTransformParameteriEXT(target, pname, param);
}

void OSMesaDriver::nfglPixelTransformParameterivEXT(GLenum target, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glPixelTransformParameterivEXT(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLPIXELTRANSFORMPARAMETERIVEXT may need conversion */
	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);
}

GLboolean OSMesaDriver::nfglPointAlongPathNV(GLuint path, GLsizei startSegment, GLsizei numSegments, GLfloat distance, GLfloat *x, GLfloat *y, GLfloat *tangentX, GLfloat *tangentY)
{
	D(bug("nfosmesa: glPointAlongPathNV(%u, %d, %d, %f, %p, %p, %p, %p)", path, startSegment, numSegments, distance, x, y, tangentX, tangentY));
	/* TODO: NFOSMESA_GLPOINTALONGPATHNV may need conversion */
	return fn.glPointAlongPathNV(path, startSegment, numSegments, distance, x, y, tangentX, tangentY);
}

void OSMesaDriver::nfglPointParameterf(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glPointParameterf(0x%x, %f)", pname, param));
	fn.glPointParameterf(pname, param);
}

void OSMesaDriver::nfglPointParameterfARB(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glPointParameterfARB(0x%x, %f)", pname, param));
	fn.glPointParameterfARB(pname, param);
}

void OSMesaDriver::nfglPointParameterfEXT(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glPointParameterfEXT(0x%x, %f)", pname, param));
	fn.glPointParameterfEXT(pname, param);
}

void OSMesaDriver::nfglPointParameterfSGIS(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glPointParameterfSGIS(0x%x, %f)", pname, param));
	fn.glPointParameterfSGIS(pname, param);
}

void OSMesaDriver::nfglPointParameterfv(GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glPointParameterfv(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLPOINTPARAMETERFV may need conversion */
	fn.glPointParameterfv(pname, params);
}

void OSMesaDriver::nfglPointParameterfvARB(GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glPointParameterfvARB(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLPOINTPARAMETERFVARB may need conversion */
	fn.glPointParameterfvARB(pname, params);
}

void OSMesaDriver::nfglPointParameterfvEXT(GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glPointParameterfvEXT(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLPOINTPARAMETERFVEXT may need conversion */
	fn.glPointParameterfvEXT(pname, params);
}

void OSMesaDriver::nfglPointParameterfvSGIS(GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glPointParameterfvSGIS(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLPOINTPARAMETERFVSGIS may need conversion */
	fn.glPointParameterfvSGIS(pname, params);
}

void OSMesaDriver::nfglPointParameteri(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glPointParameteri(0x%x, %d)", pname, param));
	fn.glPointParameteri(pname, param);
}

void OSMesaDriver::nfglPointParameteriNV(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glPointParameteriNV(0x%x, %d)", pname, param));
	fn.glPointParameteriNV(pname, param);
}

void OSMesaDriver::nfglPointParameteriv(GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glPointParameteriv(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLPOINTPARAMETERIV may need conversion */
	fn.glPointParameteriv(pname, params);
}

void OSMesaDriver::nfglPointParameterivNV(GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glPointParameterivNV(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLPOINTPARAMETERIVNV may need conversion */
	fn.glPointParameterivNV(pname, params);
}

void OSMesaDriver::nfglPointParameterxvOES(GLenum pname, const GLfixed *params)
{
	D(bug("nfosmesa: glPointParameterxvOES(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLPOINTPARAMETERXVOES may need conversion */
	fn.glPointParameterxvOES(pname, params);
}

void OSMesaDriver::nfglPointSize(GLfloat size)
{
	D(bug("nfosmesa: glPointSize(%f)", size));
	fn.glPointSize(size);
}

void OSMesaDriver::nfglPointSizePointerAPPLE(GLenum type, GLsizei stride, const GLvoid *pointer)
{
	D(bug("nfosmesa: glPointSizePointerAPPLE(0x%x, %d, %p)", type, stride, pointer));
	/* TODO: NFOSMESA_GLPOINTSIZEPOINTERAPPLE may need conversion */
	fn.glPointSizePointerAPPLE(type, stride, pointer);
}

void OSMesaDriver::nfglPointSizexOES(GLfixed size)
{
	D(bug("nfosmesa: glPointSizexOES(0x%x)", size));
	fn.glPointSizexOES(size);
}

GLint OSMesaDriver::nfglPollAsyncSGIX(GLuint *markerp)
{
	D(bug("nfosmesa: glPollAsyncSGIX(%p)", markerp));
	/* TODO: NFOSMESA_GLPOLLASYNCSGIX may need conversion */
	return fn.glPollAsyncSGIX(markerp);
}

GLint OSMesaDriver::nfglPollInstrumentsSGIX(GLint *marker_p)
{
	D(bug("nfosmesa: glPollInstrumentsSGIX(%p)", marker_p));
	/* TODO: NFOSMESA_GLPOLLINSTRUMENTSSGIX may need conversion */
	return fn.glPollInstrumentsSGIX(marker_p);
}

void OSMesaDriver::nfglPolygonMode(GLenum face, GLenum mode)
{
	D(bug("nfosmesa: glPolygonMode(0x%x, 0x%x)", face, 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::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);
}

void OSMesaDriver::nfglPolygonStipple(const GLubyte *mask)
{
	D(bug("nfosmesa: glPolygonStipple(%p)", mask));
	/* TODO: NFOSMESA_GLPOLYGONSTIPPLE may need conversion */
	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, 0x%x, 0x%x, %u, 0x%x, %u, 0x%x, %u, 0x%x, %u)", video_slot, minPresentTime, beginPresentTimeId, presentDurationId, type, target0, fill0, target1, fill1, target2, fill2, 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, 0x%x, 0x%x, %u, %u, 0x%x, %u, %u)", video_slot, minPresentTime, beginPresentTimeId, presentDurationId, type, target0, fill0, key0, target1, fill1, key1));
	fn.glPresentFrameKeyedNV(video_slot, minPresentTime, beginPresentTimeId, presentDurationId, type, target0, fill0, key0, target1, fill1, key1);
}

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();
}

void OSMesaDriver::nfglPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities)
{
	D(bug("nfosmesa: glPrioritizeTextures(%d, %p, %p)", n, textures, priorities));
FN_GLPRIORITIZETEXTURES(n, textures, priorities);
}

void OSMesaDriver::nfglPrioritizeTexturesEXT(GLsizei n, const GLuint *textures, const GLclampf *priorities)
{
	D(bug("nfosmesa: glPrioritizeTexturesEXT(%d, %p, %p)", n, textures, priorities));
FN_GLPRIORITIZETEXTURESEXT(n, textures, priorities);
}

void OSMesaDriver::nfglPrioritizeTexturesxOES(GLsizei n, const GLuint *textures, const GLfixed *priorities)
{
	D(bug("nfosmesa: glPrioritizeTexturesxOES(%d, %p, %p)", n, textures, priorities));
	/* TODO: NFOSMESA_GLPRIORITIZETEXTURESXOES may need conversion */
	fn.glPrioritizeTexturesxOES(n, textures, priorities);
}

void OSMesaDriver::nfglProgramBinary(GLuint program, GLenum binaryFormat, const void *binary, GLsizei length)
{
	D(bug("nfosmesa: glProgramBinary(%u, 0x%x, %p, %d)", program, binaryFormat, binary, length));
	/* TODO: NFOSMESA_GLPROGRAMBINARY may need conversion */
	fn.glProgramBinary(program, binaryFormat, binary, length);
}

void OSMesaDriver::nfglProgramBufferParametersIivNV(GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLint *params)
{
	D(bug("nfosmesa: glProgramBufferParametersIivNV(0x%x, %u, %u, %d, %p)", target, bindingIndex, wordIndex, count, params));
	/* TODO: NFOSMESA_GLPROGRAMBUFFERPARAMETERSIIVNV may need conversion */
	fn.glProgramBufferParametersIivNV(target, bindingIndex, wordIndex, count, params);
}

void OSMesaDriver::nfglProgramBufferParametersIuivNV(GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLuint *params)
{
	D(bug("nfosmesa: glProgramBufferParametersIuivNV(0x%x, %u, %u, %d, %p)", target, bindingIndex, wordIndex, count, params));
	/* TODO: NFOSMESA_GLPROGRAMBUFFERPARAMETERSIUIVNV may need conversion */
	fn.glProgramBufferParametersIuivNV(target, bindingIndex, wordIndex, count, params);
}

void OSMesaDriver::nfglProgramBufferParametersfvNV(GLenum target, GLuint bindingIndex, GLuint wordIndex, GLsizei count, const GLfloat *params)
{
	D(bug("nfosmesa: glProgramBufferParametersfvNV(0x%x, %u, %u, %d, %p)", target, bindingIndex, wordIndex, count, params));
	/* TODO: NFOSMESA_GLPROGRAMBUFFERPARAMETERSFVNV may need conversion */
	fn.glProgramBufferParametersfvNV(target, bindingIndex, wordIndex, count, params);
}

#if 0
void OSMesaDriver::nfglProgramCallbackMESA(GLenum target, GLprogramcallbackMESA callback, GLvoid *data)
{
	D(bug("nfosmesa: glProgramCallbackMESA(0x%x, %p, %p)", target, callback, data));
	/* TODO: NFOSMESA_GLPROGRAMCALLBACKMESA may need conversion */
	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(0x%x, %u, %f, %f, %f, %f)", target, index, x, y, z, w));
	fn.glProgramEnvParameter4dARB(target, index, x, y, z, w);
}

void OSMesaDriver::nfglProgramEnvParameter4dvARB(GLenum target, GLuint index, const GLdouble *params)
{
	D(bug("nfosmesa: glProgramEnvParameter4dvARB(0x%x, %u, %p)", target, index, 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(0x%x, %u, %f, %f, %f, %f)", target, index, x, y, z, w));
	fn.glProgramEnvParameter4fARB(target, index, x, y, z, w);
}

void OSMesaDriver::nfglProgramEnvParameter4fvARB(GLenum target, GLuint index, const GLfloat *params)
{
	D(bug("nfosmesa: glProgramEnvParameter4fvARB(0x%x, %u, %p)", target, index, 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(0x%x, %u, %d, %d, %d, %d)", target, index, x, y, z, w));
	fn.glProgramEnvParameterI4iNV(target, index, x, y, z, w);
}

void OSMesaDriver::nfglProgramEnvParameterI4ivNV(GLenum target, GLuint index, const GLint *params)
{
	D(bug("nfosmesa: glProgramEnvParameterI4ivNV(0x%x, %u, %p)", target, index, params));
	/* TODO: NFOSMESA_GLPROGRAMENVPARAMETERI4IVNV may need conversion */
	fn.glProgramEnvParameterI4ivNV(target, index, params);
}

void OSMesaDriver::nfglProgramEnvParameterI4uiNV(GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
	D(bug("nfosmesa: glProgramEnvParameterI4uiNV(0x%x, %u, %u, %u, %u, %u)", target, index, x, y, z, w));
	fn.glProgramEnvParameterI4uiNV(target, index, x, y, z, w);
}

void OSMesaDriver::nfglProgramEnvParameterI4uivNV(GLenum target, GLuint index, const GLuint *params)
{
	D(bug("nfosmesa: glProgramEnvParameterI4uivNV(0x%x, %u, %p)", target, index, params));
	/* TODO: NFOSMESA_GLPROGRAMENVPARAMETERI4UIVNV may need conversion */
	fn.glProgramEnvParameterI4uivNV(target, index, params);
}

void OSMesaDriver::nfglProgramEnvParameters4fvEXT(GLenum target, GLuint index, GLsizei count, const GLfloat *params)
{
	D(bug("nfosmesa: glProgramEnvParameters4fvEXT(0x%x, %u, %d, %p)", target, index, count, params));
	/* TODO: NFOSMESA_GLPROGRAMENVPARAMETERS4FVEXT may need conversion */
	fn.glProgramEnvParameters4fvEXT(target, index, count, params);
}

void OSMesaDriver::nfglProgramEnvParametersI4ivNV(GLenum target, GLuint index, GLsizei count, const GLint *params)
{
	D(bug("nfosmesa: glProgramEnvParametersI4ivNV(0x%x, %u, %d, %p)", target, index, count, params));
	/* TODO: NFOSMESA_GLPROGRAMENVPARAMETERSI4IVNV may need conversion */
	fn.glProgramEnvParametersI4ivNV(target, index, count, params);
}

void OSMesaDriver::nfglProgramEnvParametersI4uivNV(GLenum target, GLuint index, GLsizei count, const GLuint *params)
{
	D(bug("nfosmesa: glProgramEnvParametersI4uivNV(0x%x, %u, %d, %p)", target, index, count, params));
	/* TODO: NFOSMESA_GLPROGRAMENVPARAMETERSI4UIVNV may need conversion */
	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(0x%x, %u, %f, %f, %f, %f)", target, index, x, y, z, w));
	fn.glProgramLocalParameter4dARB(target, index, x, y, z, w);
}

void OSMesaDriver::nfglProgramLocalParameter4dvARB(GLenum target, GLuint index, const GLdouble *params)
{
	D(bug("nfosmesa: glProgramLocalParameter4dvARB(0x%x, %u, %p)", target, index, 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(0x%x, %u, %f, %f, %f, %f)", target, index, x, y, z, w));
	fn.glProgramLocalParameter4fARB(target, index, x, y, z, w);
}

void OSMesaDriver::nfglProgramLocalParameter4fvARB(GLenum target, GLuint index, const GLfloat *params)
{
	D(bug("nfosmesa: glProgramLocalParameter4fvARB(0x%x, %u, %p)", target, index, 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(0x%x, %u, %d, %d, %d, %d)", target, index, x, y, z, w));
	fn.glProgramLocalParameterI4iNV(target, index, x, y, z, w);
}

void OSMesaDriver::nfglProgramLocalParameterI4ivNV(GLenum target, GLuint index, const GLint *params)
{
	D(bug("nfosmesa: glProgramLocalParameterI4ivNV(0x%x, %u, %p)", target, index, params));
	/* TODO: NFOSMESA_GLPROGRAMLOCALPARAMETERI4IVNV may need conversion */
	fn.glProgramLocalParameterI4ivNV(target, index, params);
}

void OSMesaDriver::nfglProgramLocalParameterI4uiNV(GLenum target, GLuint index, GLuint x, GLuint y, GLuint z, GLuint w)
{
	D(bug("nfosmesa: glProgramLocalParameterI4uiNV(0x%x, %u, %u, %u, %u, %u)", target, index, x, y, z, w));
	fn.glProgramLocalParameterI4uiNV(target, index, x, y, z, w);
}

void OSMesaDriver::nfglProgramLocalParameterI4uivNV(GLenum target, GLuint index, const GLuint *params)
{
	D(bug("nfosmesa: glProgramLocalParameterI4uivNV(0x%x, %u, %p)", target, index, params));
	/* TODO: NFOSMESA_GLPROGRAMLOCALPARAMETERI4UIVNV may need conversion */
	fn.glProgramLocalParameterI4uivNV(target, index, params);
}

void OSMesaDriver::nfglProgramLocalParameters4fvEXT(GLenum target, GLuint index, GLsizei count, const GLfloat *params)
{
	D(bug("nfosmesa: glProgramLocalParameters4fvEXT(0x%x, %u, %d, %p)", target, index, count, params));
	/* TODO: NFOSMESA_GLPROGRAMLOCALPARAMETERS4FVEXT may need conversion */
	fn.glProgramLocalParameters4fvEXT(target, index, count, params);
}

void OSMesaDriver::nfglProgramLocalParametersI4ivNV(GLenum target, GLuint index, GLsizei count, const GLint *params)
{
	D(bug("nfosmesa: glProgramLocalParametersI4ivNV(0x%x, %u, %d, %p)", target, index, count, params));
	/* TODO: NFOSMESA_GLPROGRAMLOCALPARAMETERSI4IVNV may need conversion */
	fn.glProgramLocalParametersI4ivNV(target, index, count, params);
}

void OSMesaDriver::nfglProgramLocalParametersI4uivNV(GLenum target, GLuint index, GLsizei count, const GLuint *params)
{
	D(bug("nfosmesa: glProgramLocalParametersI4uivNV(0x%x, %u, %d, %p)", target, index, count, params));
	/* TODO: NFOSMESA_GLPROGRAMLOCALPARAMETERSI4UIVNV may need conversion */
	fn.glProgramLocalParametersI4uivNV(target, index, count, params);
}

void OSMesaDriver::nfglProgramNamedParameter4dNV(GLuint id, GLsizei len, const GLubyte *name, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	D(bug("nfosmesa: glProgramNamedParameter4dNV(%u, %d, %p, %f, %f, %f, %f)", id, len, name, x, y, z, w));
	/* TODO: NFOSMESA_GLPROGRAMNAMEDPARAMETER4DNV may need conversion */
	fn.glProgramNamedParameter4dNV(id, len, name, x, y, z, w);
}

void OSMesaDriver::nfglProgramNamedParameter4dvNV(GLuint id, GLsizei len, const GLubyte *name, const GLdouble *v)
{
	D(bug("nfosmesa: glProgramNamedParameter4dvNV(%u, %d, %p, %p)", id, len, name, v));
FN_GLPROGRAMNAMEDPARAMETER4DVNV(id, len, name, v);
}

void OSMesaDriver::nfglProgramNamedParameter4fNV(GLuint id, GLsizei len, const GLubyte *name, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	D(bug("nfosmesa: glProgramNamedParameter4fNV(%u, %d, %p, %f, %f, %f, %f)", id, len, name, x, y, z, w));
	/* TODO: NFOSMESA_GLPROGRAMNAMEDPARAMETER4FNV may need conversion */
	fn.glProgramNamedParameter4fNV(id, len, name, x, y, z, w);
}

void OSMesaDriver::nfglProgramNamedParameter4fvNV(GLuint id, GLsizei len, const GLubyte *name, const GLfloat *v)
{
	D(bug("nfosmesa: glProgramNamedParameter4fvNV(%u, %d, %p, %p)", id, len, name, 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(0x%x, %u, %f, %f, %f, %f)", target, index, x, y, z, w));
	fn.glProgramParameter4dNV(target, index, x, y, z, w);
}

void OSMesaDriver::nfglProgramParameter4dvNV(GLenum target, GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glProgramParameter4dvNV(0x%x, %u, %p)", target, index, 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(0x%x, %u, %f, %f, %f, %f)", target, index, x, y, z, w));
	fn.glProgramParameter4fNV(target, index, x, y, z, w);
}

void OSMesaDriver::nfglProgramParameter4fvNV(GLenum target, GLuint index, const GLfloat *v)
{
	D(bug("nfosmesa: glProgramParameter4fvNV(0x%x, %u, %p)", target, index, v));
FN_GLPROGRAMPARAMETER4FVNV(target, index, v);
}

void OSMesaDriver::nfglProgramParameteri(GLuint program, GLenum pname, GLint value)
{
	D(bug("nfosmesa: glProgramParameteri(%u, 0x%x, %d)", program, pname, value));
	fn.glProgramParameteri(program, pname, value);
}

void OSMesaDriver::nfglProgramParameteriARB(GLuint program, GLenum pname, GLint value)
{
	D(bug("nfosmesa: glProgramParameteriARB(%u, 0x%x, %d)", program, pname, value));
	fn.glProgramParameteriARB(program, pname, value);
}

void OSMesaDriver::nfglProgramParameteriEXT(GLuint program, GLenum pname, GLint value)
{
	D(bug("nfosmesa: glProgramParameteriEXT(%u, 0x%x, %d)", program, pname, value));
	fn.glProgramParameteriEXT(program, pname, value);
}

void OSMesaDriver::nfglProgramParameters4dvNV(GLenum target, GLuint index, GLsizei count, const GLdouble *v)
{
	D(bug("nfosmesa: glProgramParameters4dvNV(0x%x, %u, %d, %p)", target, index, count, v));
FN_GLPROGRAMPARAMETERS4DVNV(target, index, count, v);
}

void OSMesaDriver::nfglProgramParameters4fvNV(GLenum target, GLuint index, GLsizei count, const GLfloat *v)
{
	D(bug("nfosmesa: glProgramParameters4fvNV(0x%x, %u, %d, %p)", target, index, count, v));
FN_GLPROGRAMPARAMETERS4FVNV(target, index, count, v);
}

void OSMesaDriver::nfglProgramStringARB(GLenum target, GLenum format, GLsizei len, const void *string)
{
	D(bug("nfosmesa: glProgramStringARB(0x%x, 0x%x, %d, %p)", target, format, len, string));
	/* TODO: NFOSMESA_GLPROGRAMSTRINGARB may need conversion */
	fn.glProgramStringARB(target, format, len, string);
}

void OSMesaDriver::nfglProgramSubroutineParametersuivNV(GLenum target, GLsizei count, const GLuint *params)
{
	D(bug("nfosmesa: glProgramSubroutineParametersuivNV(0x%x, %d, %p)", target, count, params));
	/* TODO: NFOSMESA_GLPROGRAMSUBROUTINEPARAMETERSUIVNV may need conversion */
	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);
}

void OSMesaDriver::nfglProgramUniform1dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniform1dv(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM1DV may need conversion */
	fn.glProgramUniform1dv(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform1dvEXT(GLuint program, GLint location, GLsizei count, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniform1dvEXT(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM1DVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglProgramUniform1fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniform1fv(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM1FV may need conversion */
	fn.glProgramUniform1fv(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform1fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniform1fvEXT(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM1FVEXT may need conversion */
	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::nfglProgramUniform1i64NV(GLuint program, GLint location, GLint64EXT x)
{
	D(bug("nfosmesa: glProgramUniform1i64NV(%u, %d, %" PRId64 ")", program, location, x));
	fn.glProgramUniform1i64NV(program, location, x);
}

void OSMesaDriver::nfglProgramUniform1i64vNV(GLuint program, GLint location, GLsizei count, const GLint64EXT *value)
{
	D(bug("nfosmesa: glProgramUniform1i64vNV(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM1I64VNV may need conversion */
	fn.glProgramUniform1i64vNV(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform1iEXT(GLuint program, GLint location, GLint v0)
{
	D(bug("nfosmesa: glProgramUniform1iEXT(%u, %d, %d)", program, location, v0));
	fn.glProgramUniform1iEXT(program, location, v0);
}

void OSMesaDriver::nfglProgramUniform1iv(GLuint program, GLint location, GLsizei count, const GLint *value)
{
	D(bug("nfosmesa: glProgramUniform1iv(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM1IV may need conversion */
	fn.glProgramUniform1iv(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform1ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value)
{
	D(bug("nfosmesa: glProgramUniform1ivEXT(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM1IVEXT may need conversion */
	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::nfglProgramUniform1ui64NV(GLuint program, GLint location, GLuint64EXT x)
{
	D(bug("nfosmesa: glProgramUniform1ui64NV(%u, %d, %" PRIu64 ")", program, location, x));
	fn.glProgramUniform1ui64NV(program, location, x);
}

void OSMesaDriver::nfglProgramUniform1ui64vNV(GLuint program, GLint location, GLsizei count, const GLuint64EXT *value)
{
	D(bug("nfosmesa: glProgramUniform1ui64vNV(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM1UI64VNV may need conversion */
	fn.glProgramUniform1ui64vNV(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform1uiEXT(GLuint program, GLint location, GLuint v0)
{
	D(bug("nfosmesa: glProgramUniform1uiEXT(%u, %d, %u)", program, location, v0));
	fn.glProgramUniform1uiEXT(program, location, v0);
}

void OSMesaDriver::nfglProgramUniform1uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
{
	D(bug("nfosmesa: glProgramUniform1uiv(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM1UIV may need conversion */
	fn.glProgramUniform1uiv(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform1uivEXT(GLuint program, GLint location, GLsizei count, const GLuint *value)
{
	D(bug("nfosmesa: glProgramUniform1uivEXT(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM1UIVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglProgramUniform2dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniform2dv(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM2DV may need conversion */
	fn.glProgramUniform2dv(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform2dvEXT(GLuint program, GLint location, GLsizei count, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniform2dvEXT(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM2DVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglProgramUniform2fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniform2fv(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM2FV may need conversion */
	fn.glProgramUniform2fv(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform2fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniform2fvEXT(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM2FVEXT may need conversion */
	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::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);
}

void OSMesaDriver::nfglProgramUniform2i64vNV(GLuint program, GLint location, GLsizei count, const GLint64EXT *value)
{
	D(bug("nfosmesa: glProgramUniform2i64vNV(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM2I64VNV may need conversion */
	fn.glProgramUniform2i64vNV(program, location, count, value);
}

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);
}

void OSMesaDriver::nfglProgramUniform2iv(GLuint program, GLint location, GLsizei count, const GLint *value)
{
	D(bug("nfosmesa: glProgramUniform2iv(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM2IV may need conversion */
	fn.glProgramUniform2iv(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform2ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value)
{
	D(bug("nfosmesa: glProgramUniform2ivEXT(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM2IVEXT may need conversion */
	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::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);
}

void OSMesaDriver::nfglProgramUniform2ui64vNV(GLuint program, GLint location, GLsizei count, const GLuint64EXT *value)
{
	D(bug("nfosmesa: glProgramUniform2ui64vNV(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM2UI64VNV may need conversion */
	fn.glProgramUniform2ui64vNV(program, location, count, value);
}

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);
}

void OSMesaDriver::nfglProgramUniform2uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
{
	D(bug("nfosmesa: glProgramUniform2uiv(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM2UIV may need conversion */
	fn.glProgramUniform2uiv(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform2uivEXT(GLuint program, GLint location, GLsizei count, const GLuint *value)
{
	D(bug("nfosmesa: glProgramUniform2uivEXT(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM2UIVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglProgramUniform3dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniform3dv(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM3DV may need conversion */
	fn.glProgramUniform3dv(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform3dvEXT(GLuint program, GLint location, GLsizei count, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniform3dvEXT(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM3DVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglProgramUniform3fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniform3fv(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM3FV may need conversion */
	fn.glProgramUniform3fv(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform3fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniform3fvEXT(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM3FVEXT may need conversion */
	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::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);
}

void OSMesaDriver::nfglProgramUniform3i64vNV(GLuint program, GLint location, GLsizei count, const GLint64EXT *value)
{
	D(bug("nfosmesa: glProgramUniform3i64vNV(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM3I64VNV may need conversion */
	fn.glProgramUniform3i64vNV(program, location, count, value);
}

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);
}

void OSMesaDriver::nfglProgramUniform3iv(GLuint program, GLint location, GLsizei count, const GLint *value)
{
	D(bug("nfosmesa: glProgramUniform3iv(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM3IV may need conversion */
	fn.glProgramUniform3iv(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform3ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value)
{
	D(bug("nfosmesa: glProgramUniform3ivEXT(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM3IVEXT may need conversion */
	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::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);
}

void OSMesaDriver::nfglProgramUniform3ui64vNV(GLuint program, GLint location, GLsizei count, const GLuint64EXT *value)
{
	D(bug("nfosmesa: glProgramUniform3ui64vNV(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM3UI64VNV may need conversion */
	fn.glProgramUniform3ui64vNV(program, location, count, value);
}

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);
}

void OSMesaDriver::nfglProgramUniform3uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
{
	D(bug("nfosmesa: glProgramUniform3uiv(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM3UIV may need conversion */
	fn.glProgramUniform3uiv(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform3uivEXT(GLuint program, GLint location, GLsizei count, const GLuint *value)
{
	D(bug("nfosmesa: glProgramUniform3uivEXT(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM3UIVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglProgramUniform4dv(GLuint program, GLint location, GLsizei count, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniform4dv(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM4DV may need conversion */
	fn.glProgramUniform4dv(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform4dvEXT(GLuint program, GLint location, GLsizei count, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniform4dvEXT(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM4DVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglProgramUniform4fv(GLuint program, GLint location, GLsizei count, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniform4fv(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM4FV may need conversion */
	fn.glProgramUniform4fv(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform4fvEXT(GLuint program, GLint location, GLsizei count, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniform4fvEXT(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM4FVEXT may need conversion */
	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::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);
}

void OSMesaDriver::nfglProgramUniform4i64vNV(GLuint program, GLint location, GLsizei count, const GLint64EXT *value)
{
	D(bug("nfosmesa: glProgramUniform4i64vNV(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM4I64VNV may need conversion */
	fn.glProgramUniform4i64vNV(program, location, count, value);
}

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);
}

void OSMesaDriver::nfglProgramUniform4iv(GLuint program, GLint location, GLsizei count, const GLint *value)
{
	D(bug("nfosmesa: glProgramUniform4iv(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM4IV may need conversion */
	fn.glProgramUniform4iv(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform4ivEXT(GLuint program, GLint location, GLsizei count, const GLint *value)
{
	D(bug("nfosmesa: glProgramUniform4ivEXT(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM4IVEXT may need conversion */
	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::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);
}

void OSMesaDriver::nfglProgramUniform4ui64vNV(GLuint program, GLint location, GLsizei count, const GLuint64EXT *value)
{
	D(bug("nfosmesa: glProgramUniform4ui64vNV(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM4UI64VNV may need conversion */
	fn.glProgramUniform4ui64vNV(program, location, count, value);
}

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);
}

void OSMesaDriver::nfglProgramUniform4uiv(GLuint program, GLint location, GLsizei count, const GLuint *value)
{
	D(bug("nfosmesa: glProgramUniform4uiv(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM4UIV may need conversion */
	fn.glProgramUniform4uiv(program, location, count, value);
}

void OSMesaDriver::nfglProgramUniform4uivEXT(GLuint program, GLint location, GLsizei count, const GLuint *value)
{
	D(bug("nfosmesa: glProgramUniform4uivEXT(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORM4UIVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglProgramUniformHandleui64vARB(GLuint program, GLint location, GLsizei count, const GLuint64 *values)
{
	D(bug("nfosmesa: glProgramUniformHandleui64vARB(%u, %d, %d, %p)", program, location, count, values));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMHANDLEUI64VARB may need conversion */
	fn.glProgramUniformHandleui64vARB(program, location, count, values);
}

void OSMesaDriver::nfglProgramUniformHandleui64vNV(GLuint program, GLint location, GLsizei count, const GLuint64 *values)
{
	D(bug("nfosmesa: glProgramUniformHandleui64vNV(%u, %d, %d, %p)", program, location, count, values));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMHANDLEUI64VNV may need conversion */
	fn.glProgramUniformHandleui64vNV(program, location, count, values);
}

void OSMesaDriver::nfglProgramUniformMatrix2dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix2dv(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX2DV may need conversion */
	fn.glProgramUniformMatrix2dv(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix2dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix2dvEXT(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX2DVEXT may need conversion */
	fn.glProgramUniformMatrix2dvEXT(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix2fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix2fv(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX2FV may need conversion */
	fn.glProgramUniformMatrix2fv(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix2fvEXT(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX2FVEXT may need conversion */
	fn.glProgramUniformMatrix2fvEXT(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix2x3dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix2x3dv(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX2X3DV may need conversion */
	fn.glProgramUniformMatrix2x3dv(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix2x3dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix2x3dvEXT(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX2X3DVEXT may need conversion */
	fn.glProgramUniformMatrix2x3dvEXT(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix2x3fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix2x3fv(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX2X3FV may need conversion */
	fn.glProgramUniformMatrix2x3fv(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix2x3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix2x3fvEXT(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX2X3FVEXT may need conversion */
	fn.glProgramUniformMatrix2x3fvEXT(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix2x4dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix2x4dv(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX2X4DV may need conversion */
	fn.glProgramUniformMatrix2x4dv(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix2x4dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix2x4dvEXT(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX2X4DVEXT may need conversion */
	fn.glProgramUniformMatrix2x4dvEXT(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix2x4fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix2x4fv(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX2X4FV may need conversion */
	fn.glProgramUniformMatrix2x4fv(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix2x4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix2x4fvEXT(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX2X4FVEXT may need conversion */
	fn.glProgramUniformMatrix2x4fvEXT(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix3dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix3dv(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX3DV may need conversion */
	fn.glProgramUniformMatrix3dv(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix3dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix3dvEXT(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX3DVEXT may need conversion */
	fn.glProgramUniformMatrix3dvEXT(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix3fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix3fv(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX3FV may need conversion */
	fn.glProgramUniformMatrix3fv(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix3fvEXT(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX3FVEXT may need conversion */
	fn.glProgramUniformMatrix3fvEXT(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix3x2dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix3x2dv(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX3X2DV may need conversion */
	fn.glProgramUniformMatrix3x2dv(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix3x2dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix3x2dvEXT(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX3X2DVEXT may need conversion */
	fn.glProgramUniformMatrix3x2dvEXT(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix3x2fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix3x2fv(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX3X2FV may need conversion */
	fn.glProgramUniformMatrix3x2fv(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix3x2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix3x2fvEXT(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX3X2FVEXT may need conversion */
	fn.glProgramUniformMatrix3x2fvEXT(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix3x4dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix3x4dv(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX3X4DV may need conversion */
	fn.glProgramUniformMatrix3x4dv(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix3x4dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix3x4dvEXT(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX3X4DVEXT may need conversion */
	fn.glProgramUniformMatrix3x4dvEXT(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix3x4fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix3x4fv(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX3X4FV may need conversion */
	fn.glProgramUniformMatrix3x4fv(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix3x4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix3x4fvEXT(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX3X4FVEXT may need conversion */
	fn.glProgramUniformMatrix3x4fvEXT(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix4dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix4dv(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX4DV may need conversion */
	fn.glProgramUniformMatrix4dv(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix4dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix4dvEXT(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX4DVEXT may need conversion */
	fn.glProgramUniformMatrix4dvEXT(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix4fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix4fv(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX4FV may need conversion */
	fn.glProgramUniformMatrix4fv(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix4fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix4fvEXT(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX4FVEXT may need conversion */
	fn.glProgramUniformMatrix4fvEXT(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix4x2dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix4x2dv(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX4X2DV may need conversion */
	fn.glProgramUniformMatrix4x2dv(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix4x2dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix4x2dvEXT(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX4X2DVEXT may need conversion */
	fn.glProgramUniformMatrix4x2dvEXT(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix4x2fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix4x2fv(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX4X2FV may need conversion */
	fn.glProgramUniformMatrix4x2fv(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix4x2fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix4x2fvEXT(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX4X2FVEXT may need conversion */
	fn.glProgramUniformMatrix4x2fvEXT(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix4x3dv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix4x3dv(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX4X3DV may need conversion */
	fn.glProgramUniformMatrix4x3dv(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix4x3dvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix4x3dvEXT(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX4X3DVEXT may need conversion */
	fn.glProgramUniformMatrix4x3dvEXT(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix4x3fv(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix4x3fv(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX4X3FV may need conversion */
	fn.glProgramUniformMatrix4x3fv(program, location, count, transpose, value);
}

void OSMesaDriver::nfglProgramUniformMatrix4x3fvEXT(GLuint program, GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glProgramUniformMatrix4x3fvEXT(%u, %d, %d, %d, %p)", program, location, count, transpose, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMMATRIX4X3FVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglProgramUniformui64vNV(GLuint program, GLint location, GLsizei count, const GLuint64EXT *value)
{
	D(bug("nfosmesa: glProgramUniformui64vNV(%u, %d, %d, %p)", program, location, count, value));
	/* TODO: NFOSMESA_GLPROGRAMUNIFORMUI64VNV may need conversion */
	fn.glProgramUniformui64vNV(program, location, count, value);
}

void OSMesaDriver::nfglProgramVertexLimitNV(GLenum target, GLint limit)
{
	D(bug("nfosmesa: glProgramVertexLimitNV(0x%x, %d)", target, limit));
	fn.glProgramVertexLimitNV(target, limit);
}

void OSMesaDriver::nfglProvokingVertex(GLenum mode)
{
	D(bug("nfosmesa: glProvokingVertex(0x%x)", mode));
	fn.glProvokingVertex(mode);
}

void OSMesaDriver::nfglProvokingVertexEXT(GLenum mode)
{
	D(bug("nfosmesa: glProvokingVertexEXT(0x%x)", 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);
}

void OSMesaDriver::nfglPushDebugGroup(GLenum source, GLuint id, GLsizei length, const GLchar *message)
{
	D(bug("nfosmesa: glPushDebugGroup(0x%x, %u, %d, %p)", source, id, length, message));
	/* TODO: NFOSMESA_GLPUSHDEBUGGROUP may need conversion */
	fn.glPushDebugGroup(source, id, length, message);
}

void OSMesaDriver::nfglPushGroupMarkerEXT(GLsizei length, const GLchar *marker)
{
	D(bug("nfosmesa: glPushGroupMarkerEXT(%d, %p)", length, marker));
	/* TODO: NFOSMESA_GLPUSHGROUPMARKEREXT may need conversion */
	fn.glPushGroupMarkerEXT(length, marker);
}

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, 0x%x)", id, target));
	fn.glQueryCounter(id, target);
}

GLbitfield OSMesaDriver::nfglQueryMatrixxOES(GLfixed *mantissa, GLint *exponent)
{
	D(bug("nfosmesa: glQueryMatrixxOES(%p, %p)", mantissa, exponent));
	/* TODO: NFOSMESA_GLQUERYMATRIXXOES may need conversion */
	return fn.glQueryMatrixxOES(mantissa, exponent);
}

void OSMesaDriver::nfglQueryObjectParameteruiAMD(GLenum target, GLuint id, GLenum pname, GLuint param)
{
	D(bug("nfosmesa: glQueryObjectParameteruiAMD(0x%x, %u, 0x%x, %u)", target, id, pname, param));
	fn.glQueryObjectParameteruiAMD(target, id, pname, param);
}

void OSMesaDriver::nfglRasterPos2d(GLdouble x, GLdouble y)
{
	D(bug("nfosmesa: glRasterPos2d(%f, %f)", x, y));
	fn.glRasterPos2d(x, y);
}

void OSMesaDriver::nfglRasterPos2dv(const GLdouble *v)
{
	D(bug("nfosmesa: glRasterPos2dv(%p)", v));
FN_GLRASTERPOS2DV(v);
}

void OSMesaDriver::nfglRasterPos2f(GLfloat x, GLfloat y)
{
	D(bug("nfosmesa: glRasterPos2f(%f, %f)", x, y));
	fn.glRasterPos2f(x, y);
}

void OSMesaDriver::nfglRasterPos2fv(const GLfloat *v)
{
	D(bug("nfosmesa: glRasterPos2fv(%p)", v));
FN_GLRASTERPOS2FV(v);
}

void OSMesaDriver::nfglRasterPos2i(GLint x, GLint y)
{
	D(bug("nfosmesa: glRasterPos2i(%d, %d)", x, y));
	fn.glRasterPos2i(x, y);
}

void OSMesaDriver::nfglRasterPos2iv(const GLint *v)
{
	D(bug("nfosmesa: glRasterPos2iv(%p)", v));
FN_GLRASTERPOS2IV(v);
}

void OSMesaDriver::nfglRasterPos2s(GLshort32 x, GLshort32 y)
{
	D(bug("nfosmesa: glRasterPos2s(%d, %d)", x, y));
	fn.glRasterPos2s(x, y);
}

void OSMesaDriver::nfglRasterPos2sv(const GLshort *v)
{
	D(bug("nfosmesa: glRasterPos2sv(%p)", 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);
}

void OSMesaDriver::nfglRasterPos2xvOES(const GLfixed *coords)
{
	D(bug("nfosmesa: glRasterPos2xvOES(%p)", coords));
	/* TODO: NFOSMESA_GLRASTERPOS2XVOES may need conversion */
	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);
}

void OSMesaDriver::nfglRasterPos3dv(const GLdouble *v)
{
	D(bug("nfosmesa: glRasterPos3dv(%p)", 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);
}

void OSMesaDriver::nfglRasterPos3fv(const GLfloat *v)
{
	D(bug("nfosmesa: glRasterPos3fv(%p)", 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);
}

void OSMesaDriver::nfglRasterPos3iv(const GLint *v)
{
	D(bug("nfosmesa: glRasterPos3iv(%p)", 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);
}

void OSMesaDriver::nfglRasterPos3sv(const GLshort *v)
{
	D(bug("nfosmesa: glRasterPos3sv(%p)", 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);
}

void OSMesaDriver::nfglRasterPos3xvOES(const GLfixed *coords)
{
	D(bug("nfosmesa: glRasterPos3xvOES(%p)", coords));
	/* TODO: NFOSMESA_GLRASTERPOS3XVOES may need conversion */
	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);
}

void OSMesaDriver::nfglRasterPos4dv(const GLdouble *v)
{
	D(bug("nfosmesa: glRasterPos4dv(%p)", 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);
}

void OSMesaDriver::nfglRasterPos4fv(const GLfloat *v)
{
	D(bug("nfosmesa: glRasterPos4fv(%p)", 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);
}

void OSMesaDriver::nfglRasterPos4iv(const GLint *v)
{
	D(bug("nfosmesa: glRasterPos4iv(%p)", 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);
}

void OSMesaDriver::nfglRasterPos4sv(const GLshort *v)
{
	D(bug("nfosmesa: glRasterPos4sv(%p)", 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);
}

void OSMesaDriver::nfglRasterPos4xvOES(const GLfixed *coords)
{
	D(bug("nfosmesa: glRasterPos4xvOES(%p)", coords));
	/* TODO: NFOSMESA_GLRASTERPOS4XVOES may need conversion */
	fn.glRasterPos4xvOES(coords);
}

void OSMesaDriver::nfglReadBuffer(GLenum mode)
{
	D(bug("nfosmesa: glReadBuffer(0x%x)", mode));
	fn.glReadBuffer(mode);
}

void OSMesaDriver::nfglReadInstrumentsSGIX(GLint marker)
{
	D(bug("nfosmesa: glReadInstrumentsSGIX(%d)", marker));
	fn.glReadInstrumentsSGIX(marker);
}

void OSMesaDriver::nfglReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
{
	D(bug("nfosmesa: glReadPixels(%d, %d, %d, %d, 0x%x, 0x%x, %p)", x, y, width, height, format, type, pixels));
	/* TODO: NFOSMESA_GLREADPIXELS may need conversion */
	fn.glReadPixels(x, y, width, height, format, type, pixels);
}

void OSMesaDriver::nfglReadnPixelsARB(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLsizei bufSize, void *data)
{
	D(bug("nfosmesa: glReadnPixelsARB(%d, %d, %d, %d, 0x%x, 0x%x, %d, %p)", x, y, width, height, format, type, bufSize, data));
	/* TODO: NFOSMESA_GLREADNPIXELSARB may need conversion */
	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);
}

void OSMesaDriver::nfglRectdv(const GLdouble *v1, const GLdouble *v2)
{
	D(bug("nfosmesa: glRectdv(%p, %p)", v1, 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);
}

void OSMesaDriver::nfglRectfv(const GLfloat *v1, const GLfloat *v2)
{
	D(bug("nfosmesa: glRectfv(%p, %p)", v1, 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);
}

void OSMesaDriver::nfglRectiv(const GLint *v1, const GLint *v2)
{
	D(bug("nfosmesa: glRectiv(%p, %p)", v1, 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);
}

void OSMesaDriver::nfglRectsv(const GLshort *v1, const GLshort *v2)
{
	D(bug("nfosmesa: glRectsv(%p, %p)", v1, 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);
}

void OSMesaDriver::nfglRectxvOES(const GLfixed *v1, const GLfixed *v2)
{
	D(bug("nfosmesa: glRectxvOES(%p, %p)", v1, v2));
	/* TODO: NFOSMESA_GLRECTXVOES may need conversion */
	fn.glRectxvOES(v1, v2);
}

void OSMesaDriver::nfglReferencePlaneSGIX(const GLdouble *equation)
{
	D(bug("nfosmesa: glReferencePlaneSGIX(%p)", equation));
	/* TODO: NFOSMESA_GLREFERENCEPLANESGIX may need conversion */
	fn.glReferencePlaneSGIX(equation);
}

void OSMesaDriver::nfglReleaseShaderCompiler(void)
{
	D(bug("nfosmesa: glReleaseShaderCompiler()"));
	fn.glReleaseShaderCompiler();
}

GLint OSMesaDriver::nfglRenderMode(GLenum mode)
{
	D(bug("nfosmesa: glRenderMode(0x%x)", mode));
	return fn.glRenderMode(mode);
}

void OSMesaDriver::nfglRenderbufferStorage(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glRenderbufferStorage(0x%x, 0x%x, %d, %d)", target, internalformat, width, height));
	fn.glRenderbufferStorage(target, internalformat, width, height);
}

void OSMesaDriver::nfglRenderbufferStorageEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glRenderbufferStorageEXT(0x%x, 0x%x, %d, %d)", target, 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(0x%x, %d, 0x%x, %d, %d)", target, samples, 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(0x%x, %d, %d, 0x%x, %d, %d)", target, coverageSamples, colorSamples, 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(0x%x, %d, 0x%x, %d, %d)", target, samples, internalformat, width, height));
	fn.glRenderbufferStorageMultisampleEXT(target, samples, internalformat, width, height);
}

void OSMesaDriver::nfglReplacementCodePointerSUN(GLenum type, GLsizei stride, const void * *pointer)
{
	D(bug("nfosmesa: glReplacementCodePointerSUN(0x%x, %d, %p)", type, stride, pointer));
	/* TODO: NFOSMESA_GLREPLACEMENTCODEPOINTERSUN may need conversion */
	fn.glReplacementCodePointerSUN(type, stride, pointer);
}

void OSMesaDriver::nfglReplacementCodeubSUN(GLubyte32 code)
{
	D(bug("nfosmesa: glReplacementCodeubSUN(%u)", code));
	fn.glReplacementCodeubSUN(code);
}

void OSMesaDriver::nfglReplacementCodeubvSUN(const GLubyte *code)
{
	D(bug("nfosmesa: glReplacementCodeubvSUN(%p)", code));
	/* TODO: NFOSMESA_GLREPLACEMENTCODEUBVSUN may need conversion */
	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);
}

void OSMesaDriver::nfglReplacementCodeuiColor3fVertex3fvSUN(const GLuint *rc, const GLfloat *c, const GLfloat *v)
{
	D(bug("nfosmesa: glReplacementCodeuiColor3fVertex3fvSUN(%p, %p, %p)", rc, c, v));
	/* TODO: NFOSMESA_GLREPLACEMENTCODEUICOLOR3FVERTEX3FVSUN may need conversion */
	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);
}

void OSMesaDriver::nfglReplacementCodeuiColor4fNormal3fVertex3fvSUN(const GLuint *rc, const GLfloat *c, const GLfloat *n, const GLfloat *v)
{
	D(bug("nfosmesa: glReplacementCodeuiColor4fNormal3fVertex3fvSUN(%p, %p, %p, %p)", rc, c, n, v));
	/* TODO: NFOSMESA_GLREPLACEMENTCODEUICOLOR4FNORMAL3FVERTEX3FVSUN may need conversion */
	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);
}

void OSMesaDriver::nfglReplacementCodeuiColor4ubVertex3fvSUN(const GLuint *rc, const GLubyte *c, const GLfloat *v)
{
	D(bug("nfosmesa: glReplacementCodeuiColor4ubVertex3fvSUN(%p, %p, %p)", rc, c, v));
	/* TODO: NFOSMESA_GLREPLACEMENTCODEUICOLOR4UBVERTEX3FVSUN may need conversion */
	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);
}

void OSMesaDriver::nfglReplacementCodeuiNormal3fVertex3fvSUN(const GLuint *rc, const GLfloat *n, const GLfloat *v)
{
	D(bug("nfosmesa: glReplacementCodeuiNormal3fVertex3fvSUN(%p, %p, %p)", rc, n, v));
	/* TODO: NFOSMESA_GLREPLACEMENTCODEUINORMAL3FVERTEX3FVSUN may need conversion */
	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);
}

void OSMesaDriver::nfglReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(const GLuint *rc, const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v)
{
	D(bug("nfosmesa: glReplacementCodeuiTexCoord2fColor4fNormal3fVertex3fvSUN(%p, %p, %p, %p, %p)", rc, tc, c, n, v));
	/* TODO: NFOSMESA_GLREPLACEMENTCODEUITEXCOORD2FCOLOR4FNORMAL3FVERTEX3FVSUN may need conversion */
	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);
}

void OSMesaDriver::nfglReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(const GLuint *rc, const GLfloat *tc, const GLfloat *n, const GLfloat *v)
{
	D(bug("nfosmesa: glReplacementCodeuiTexCoord2fNormal3fVertex3fvSUN(%p, %p, %p, %p)", rc, tc, n, v));
	/* TODO: NFOSMESA_GLREPLACEMENTCODEUITEXCOORD2FNORMAL3FVERTEX3FVSUN may need conversion */
	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);
}

void OSMesaDriver::nfglReplacementCodeuiTexCoord2fVertex3fvSUN(const GLuint *rc, const GLfloat *tc, const GLfloat *v)
{
	D(bug("nfosmesa: glReplacementCodeuiTexCoord2fVertex3fvSUN(%p, %p, %p)", rc, tc, v));
	/* TODO: NFOSMESA_GLREPLACEMENTCODEUITEXCOORD2FVERTEX3FVSUN may need conversion */
	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);
}

void OSMesaDriver::nfglReplacementCodeuiVertex3fvSUN(const GLuint *rc, const GLfloat *v)
{
	D(bug("nfosmesa: glReplacementCodeuiVertex3fvSUN(%p, %p)", rc, v));
	/* TODO: NFOSMESA_GLREPLACEMENTCODEUIVERTEX3FVSUN may need conversion */
	fn.glReplacementCodeuiVertex3fvSUN(rc, v);
}

void OSMesaDriver::nfglReplacementCodeuivSUN(const GLuint *code)
{
	D(bug("nfosmesa: glReplacementCodeuivSUN(%p)", code));
	/* TODO: NFOSMESA_GLREPLACEMENTCODEUIVSUN may need conversion */
	fn.glReplacementCodeuivSUN(code);
}

void OSMesaDriver::nfglReplacementCodeusSUN(GLushort32 code)
{
	D(bug("nfosmesa: glReplacementCodeusSUN(%u)", code));
	fn.glReplacementCodeusSUN(code);
}

void OSMesaDriver::nfglReplacementCodeusvSUN(const GLushort *code)
{
	D(bug("nfosmesa: glReplacementCodeusvSUN(%p)", code));
	/* TODO: NFOSMESA_GLREPLACEMENTCODEUSVSUN may need conversion */
	fn.glReplacementCodeusvSUN(code);
}

void OSMesaDriver::nfglRequestResidentProgramsNV(GLsizei n, const GLuint *programs)
{
	D(bug("nfosmesa: glRequestResidentProgramsNV(%d, %p)", n, programs));
	/* TODO: NFOSMESA_GLREQUESTRESIDENTPROGRAMSNV may need conversion */
	fn.glRequestResidentProgramsNV(n, programs);
}

void OSMesaDriver::nfglResetHistogram(GLenum target)
{
	D(bug("nfosmesa: glResetHistogram(0x%x)", target));
	fn.glResetHistogram(target);
}

void OSMesaDriver::nfglResetHistogramEXT(GLenum target)
{
	D(bug("nfosmesa: glResetHistogramEXT(0x%x)", target));
	fn.glResetHistogramEXT(target);
}

void OSMesaDriver::nfglResetMinmax(GLenum target)
{
	D(bug("nfosmesa: glResetMinmax(0x%x)", target));
	fn.glResetMinmax(target);
}

void OSMesaDriver::nfglResetMinmaxEXT(GLenum target)
{
	D(bug("nfosmesa: glResetMinmaxEXT(0x%x)", target));
	fn.glResetMinmaxEXT(target);
}

void OSMesaDriver::nfglResizeBuffersMESA(void)
{
	D(bug("nfosmesa: glResizeBuffersMESA()"));
	fn.glResizeBuffersMESA();
}

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, 0x%x)", dst, interp, 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(0x%x)", mode));
	fn.glSamplePass(mode);
}

void OSMesaDriver::nfglSamplePassARB(GLenum mode)
{
	D(bug("nfosmesa: glSamplePassARB(0x%x)", mode));
	fn.glSamplePassARB(mode);
}

void OSMesaDriver::nfglSamplePatternEXT(GLenum pattern)
{
	D(bug("nfosmesa: glSamplePatternEXT(0x%x)", pattern));
	fn.glSamplePatternEXT(pattern);
}

void OSMesaDriver::nfglSamplePatternSGIS(GLenum pattern)
{
	D(bug("nfosmesa: glSamplePatternSGIS(0x%x)", pattern));
	fn.glSamplePatternSGIS(pattern);
}

void OSMesaDriver::nfglSamplerParameterIiv(GLuint sampler, GLenum pname, const GLint *param)
{
	D(bug("nfosmesa: glSamplerParameterIiv(%u, 0x%x, %p)", sampler, pname, param));
	/* TODO: NFOSMESA_GLSAMPLERPARAMETERIIV may need conversion */
	fn.glSamplerParameterIiv(sampler, pname, param);
}

void OSMesaDriver::nfglSamplerParameterIuiv(GLuint sampler, GLenum pname, const GLuint *param)
{
	D(bug("nfosmesa: glSamplerParameterIuiv(%u, 0x%x, %p)", sampler, pname, param));
	/* TODO: NFOSMESA_GLSAMPLERPARAMETERIUIV may need conversion */
	fn.glSamplerParameterIuiv(sampler, pname, param);
}

void OSMesaDriver::nfglSamplerParameterf(GLuint sampler, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glSamplerParameterf(%u, 0x%x, %f)", sampler, pname, param));
	fn.glSamplerParameterf(sampler, pname, param);
}

void OSMesaDriver::nfglSamplerParameterfv(GLuint sampler, GLenum pname, const GLfloat *param)
{
	D(bug("nfosmesa: glSamplerParameterfv(%u, 0x%x, %p)", sampler, pname, param));
	/* TODO: NFOSMESA_GLSAMPLERPARAMETERFV may need conversion */
	fn.glSamplerParameterfv(sampler, pname, param);
}

void OSMesaDriver::nfglSamplerParameteri(GLuint sampler, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glSamplerParameteri(%u, 0x%x, %d)", sampler, pname, param));
	fn.glSamplerParameteri(sampler, pname, param);
}

void OSMesaDriver::nfglSamplerParameteriv(GLuint sampler, GLenum pname, const GLint *param)
{
	D(bug("nfosmesa: glSamplerParameteriv(%u, 0x%x, %p)", sampler, pname, param));
	/* TODO: NFOSMESA_GLSAMPLERPARAMETERIV may need conversion */
	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);
}

void OSMesaDriver::nfglScissorArrayv(GLuint first, GLsizei count, const GLint *v)
{
	D(bug("nfosmesa: glScissorArrayv(%u, %d, %p)", first, count, v));
	/* TODO: NFOSMESA_GLSCISSORARRAYV may need conversion */
	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);
}

void OSMesaDriver::nfglScissorIndexedv(GLuint index, const GLint *v)
{
	D(bug("nfosmesa: glScissorIndexedv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLSCISSORINDEXEDV may need conversion */
	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);
}

void OSMesaDriver::nfglSecondaryColor3bv(const GLbyte *v)
{
	D(bug("nfosmesa: glSecondaryColor3bv(%p)", v));
	/* TODO: NFOSMESA_GLSECONDARYCOLOR3BV may need conversion */
	fn.glSecondaryColor3bv(v);
}

void OSMesaDriver::nfglSecondaryColor3bvEXT(const GLbyte *v)
{
	D(bug("nfosmesa: glSecondaryColor3bvEXT(%p)", v));
	/* TODO: NFOSMESA_GLSECONDARYCOLOR3BVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglSecondaryColor3dv(const GLdouble *v)
{
	D(bug("nfosmesa: glSecondaryColor3dv(%p)", v));
FN_GLSECONDARYCOLOR3DV(v);
}

void OSMesaDriver::nfglSecondaryColor3dvEXT(const GLdouble *v)
{
	D(bug("nfosmesa: glSecondaryColor3dvEXT(%p)", 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);
}

void OSMesaDriver::nfglSecondaryColor3fv(const GLfloat *v)
{
	D(bug("nfosmesa: glSecondaryColor3fv(%p)", v));
FN_GLSECONDARYCOLOR3FV(v);
}

void OSMesaDriver::nfglSecondaryColor3fvEXT(const GLfloat *v)
{
	D(bug("nfosmesa: glSecondaryColor3fvEXT(%p)", 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);
}

void OSMesaDriver::nfglSecondaryColor3hvNV(const GLhalfNV *v)
{
	D(bug("nfosmesa: glSecondaryColor3hvNV(%p)", 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);
}

void OSMesaDriver::nfglSecondaryColor3iv(const GLint *v)
{
	D(bug("nfosmesa: glSecondaryColor3iv(%p)", v));
FN_GLSECONDARYCOLOR3IV(v);
}

void OSMesaDriver::nfglSecondaryColor3ivEXT(const GLint *v)
{
	D(bug("nfosmesa: glSecondaryColor3ivEXT(%p)", 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);
}

void OSMesaDriver::nfglSecondaryColor3sv(const GLshort *v)
{
	D(bug("nfosmesa: glSecondaryColor3sv(%p)", v));
FN_GLSECONDARYCOLOR3SV(v);
}

void OSMesaDriver::nfglSecondaryColor3svEXT(const GLshort *v)
{
	D(bug("nfosmesa: glSecondaryColor3svEXT(%p)", 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);
}

void OSMesaDriver::nfglSecondaryColor3ubv(const GLubyte *v)
{
	D(bug("nfosmesa: glSecondaryColor3ubv(%p)", v));
	/* TODO: NFOSMESA_GLSECONDARYCOLOR3UBV may need conversion */
	fn.glSecondaryColor3ubv(v);
}

void OSMesaDriver::nfglSecondaryColor3ubvEXT(const GLubyte *v)
{
	D(bug("nfosmesa: glSecondaryColor3ubvEXT(%p)", v));
	/* TODO: NFOSMESA_GLSECONDARYCOLOR3UBVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglSecondaryColor3uiv(const GLuint *v)
{
	D(bug("nfosmesa: glSecondaryColor3uiv(%p)", v));
FN_GLSECONDARYCOLOR3UIV(v);
}

void OSMesaDriver::nfglSecondaryColor3uivEXT(const GLuint *v)
{
	D(bug("nfosmesa: glSecondaryColor3uivEXT(%p)", 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);
}

void OSMesaDriver::nfglSecondaryColor3usv(const GLushort *v)
{
	D(bug("nfosmesa: glSecondaryColor3usv(%p)", v));
FN_GLSECONDARYCOLOR3USV(v);
}

void OSMesaDriver::nfglSecondaryColor3usvEXT(const GLushort *v)
{
	D(bug("nfosmesa: glSecondaryColor3usvEXT(%p)", v));
FN_GLSECONDARYCOLOR3USVEXT(v);
}

void OSMesaDriver::nfglSecondaryColorFormatNV(GLint size, GLenum type, GLsizei stride)
{
	D(bug("nfosmesa: glSecondaryColorFormatNV(%d, 0x%x, %d)", size, type, stride));
	fn.glSecondaryColorFormatNV(size, type, stride);
}

void OSMesaDriver::nfglSecondaryColorP3ui(GLenum type, GLuint color)
{
	D(bug("nfosmesa: glSecondaryColorP3ui(0x%x, %u)", type, color));
	fn.glSecondaryColorP3ui(type, color);
}

void OSMesaDriver::nfglSecondaryColorP3uiv(GLenum type, const GLuint *color)
{
	D(bug("nfosmesa: glSecondaryColorP3uiv(0x%x, %p)", type, color));
	/* TODO: NFOSMESA_GLSECONDARYCOLORP3UIV may need conversion */
	fn.glSecondaryColorP3uiv(type, color);
}

void OSMesaDriver::nfglSecondaryColorPointer(GLint size, GLenum type, GLsizei stride, const void *pointer)
{
	D(bug("nfosmesa: glSecondaryColorPointer(%d, 0x%x, %d, %p)", size, type, stride, pointer));
	/* TODO: NFOSMESA_GLSECONDARYCOLORPOINTER may need conversion */
	fn.glSecondaryColorPointer(size, type, stride, pointer);
}

void OSMesaDriver::nfglSecondaryColorPointerEXT(GLint size, GLenum type, GLsizei stride, const void *pointer)
{
	D(bug("nfosmesa: glSecondaryColorPointerEXT(%d, 0x%x, %d, %p)", size, type, stride, pointer));
	/* TODO: NFOSMESA_GLSECONDARYCOLORPOINTEREXT may need conversion */
	fn.glSecondaryColorPointerEXT(size, type, stride, pointer);
}

void OSMesaDriver::nfglSecondaryColorPointerListIBM(GLint size, GLenum type, GLint stride, const void * *pointer, GLint ptrstride)
{
	D(bug("nfosmesa: glSecondaryColorPointerListIBM(%d, 0x%x, %d, %p, %d)", size, type, stride, pointer, ptrstride));
	/* TODO: NFOSMESA_GLSECONDARYCOLORPOINTERLISTIBM may need conversion */
	fn.glSecondaryColorPointerListIBM(size, type, stride, pointer, ptrstride);
}

void OSMesaDriver::nfglSelectBuffer(GLsizei size, GLuint *buffer)
{
	D(bug("nfosmesa: glSelectBuffer(%d, %p)", size, buffer));
	/* TODO: NFOSMESA_GLSELECTBUFFER may need conversion */
	fn.glSelectBuffer(size, buffer);
}

void OSMesaDriver::nfglSelectPerfMonitorCountersAMD(GLuint monitor, GLboolean32 enable, GLuint group, GLint numCounters, GLuint *counterList)
{
	D(bug("nfosmesa: glSelectPerfMonitorCountersAMD(%u, %d, %u, %d, %p)", monitor, enable, group, numCounters, counterList));
	/* TODO: NFOSMESA_GLSELECTPERFMONITORCOUNTERSAMD may need conversion */
	fn.glSelectPerfMonitorCountersAMD(monitor, enable, group, numCounters, counterList);
}

void OSMesaDriver::nfglSeparableFilter2D(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column)
{
	D(bug("nfosmesa: glSeparableFilter2D(0x%x, 0x%x, %d, %d, 0x%x, 0x%x, %p, %p)", target, internalformat, width, height, format, type, row, column));
	/* TODO: NFOSMESA_GLSEPARABLEFILTER2D may need conversion */
	fn.glSeparableFilter2D(target, internalformat, width, height, format, type, row, column);
}

void OSMesaDriver::nfglSeparableFilter2DEXT(GLenum target, GLenum internalformat, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *row, const void *column)
{
	D(bug("nfosmesa: glSeparableFilter2DEXT(0x%x, 0x%x, %d, %d, 0x%x, 0x%x, %p, %p)", target, internalformat, width, height, format, type, row, column));
	/* TODO: NFOSMESA_GLSEPARABLEFILTER2DEXT may need conversion */
	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, 0x%x)", fence, condition));
	fn.glSetFenceNV(fence, condition);
}

void OSMesaDriver::nfglSetFragmentShaderConstantATI(GLuint dst, const GLfloat *value)
{
	D(bug("nfosmesa: glSetFragmentShaderConstantATI(%u, %p)", dst, value));
	/* TODO: NFOSMESA_GLSETFRAGMENTSHADERCONSTANTATI may need conversion */
	fn.glSetFragmentShaderConstantATI(dst, value);
}

void OSMesaDriver::nfglSetInvariantEXT(GLuint id, GLenum type, const void *addr)
{
	D(bug("nfosmesa: glSetInvariantEXT(%u, 0x%x, %p)", id, type, addr));
	/* TODO: NFOSMESA_GLSETINVARIANTEXT may need conversion */
	fn.glSetInvariantEXT(id, type, addr);
}

void OSMesaDriver::nfglSetLocalConstantEXT(GLuint id, GLenum type, const void *addr)
{
	D(bug("nfosmesa: glSetLocalConstantEXT(%u, 0x%x, %p)", id, type, addr));
	/* TODO: NFOSMESA_GLSETLOCALCONSTANTEXT may need conversion */
	fn.glSetLocalConstantEXT(id, type, addr);
}

void OSMesaDriver::nfglSetMultisamplefvAMD(GLenum pname, GLuint index, const GLfloat *val)
{
	D(bug("nfosmesa: glSetMultisamplefvAMD(0x%x, %u, %p)", pname, index, val));
	/* TODO: NFOSMESA_GLSETMULTISAMPLEFVAMD may need conversion */
	fn.glSetMultisamplefvAMD(pname, index, val);
}

void OSMesaDriver::nfglShadeModel(GLenum mode)
{
	D(bug("nfosmesa: glShadeModel(0x%x)", mode));
	fn.glShadeModel(mode);
}

void OSMesaDriver::nfglShaderBinary(GLsizei count, const GLuint *shaders, GLenum binaryformat, const void *binary, GLsizei length)
{
	D(bug("nfosmesa: glShaderBinary(%d, %p, 0x%x, %p, %d)", count, shaders, binaryformat, binary, length));
	/* TODO: NFOSMESA_GLSHADERBINARY may need conversion */
	fn.glShaderBinary(count, shaders, binaryformat, binary, length);
}

void OSMesaDriver::nfglShaderOp1EXT(GLenum op, GLuint res, GLuint arg1)
{
	D(bug("nfosmesa: glShaderOp1EXT(0x%x, %u, %u)", op, res, arg1));
	fn.glShaderOp1EXT(op, res, arg1);
}

void OSMesaDriver::nfglShaderOp2EXT(GLenum op, GLuint res, GLuint arg1, GLuint arg2)
{
	D(bug("nfosmesa: glShaderOp2EXT(0x%x, %u, %u, %u)", 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(0x%x, %u, %u, %u, %u)", op, res, arg1, arg2, arg3));
	fn.glShaderOp3EXT(op, res, arg1, arg2, arg3);
}

void OSMesaDriver::nfglShaderSource(GLuint shader, GLsizei count, const GLchar *const *string, const GLint *length)
{
	D(bug("nfosmesa: glShaderSource(%u, %d, %p, %p)", shader, count, string, length));
	/* TODO: NFOSMESA_GLSHADERSOURCE may need conversion */
	fn.glShaderSource(shader, count, string, length);
}

void OSMesaDriver::nfglShaderSourceARB(GLhandleARB shaderObj, GLsizei count, const GLcharARB * *string, const GLint *length)
{
	D(bug("nfosmesa: glShaderSourceARB(%u, %d, %p, %p)", shaderObj, count, string, length));
	/* TODO: NFOSMESA_GLSHADERSOURCEARB may need conversion */
	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);
}

void OSMesaDriver::nfglSharpenTexFuncSGIS(GLenum target, GLsizei n, const GLfloat *points)
{
	D(bug("nfosmesa: glSharpenTexFuncSGIS(0x%x, %d, %p)", target, n, points));
	/* TODO: NFOSMESA_GLSHARPENTEXFUNCSGIS may need conversion */
	fn.glSharpenTexFuncSGIS(target, n, points);
}

void OSMesaDriver::nfglSpriteParameterfSGIX(GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glSpriteParameterfSGIX(0x%x, %f)", pname, param));
	fn.glSpriteParameterfSGIX(pname, param);
}

void OSMesaDriver::nfglSpriteParameterfvSGIX(GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glSpriteParameterfvSGIX(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLSPRITEPARAMETERFVSGIX may need conversion */
	fn.glSpriteParameterfvSGIX(pname, params);
}

void OSMesaDriver::nfglSpriteParameteriSGIX(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glSpriteParameteriSGIX(0x%x, %d)", pname, param));
	fn.glSpriteParameteriSGIX(pname, param);
}

void OSMesaDriver::nfglSpriteParameterivSGIX(GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glSpriteParameterivSGIX(0x%x, %p)", pname, params));
	/* TODO: NFOSMESA_GLSPRITEPARAMETERIVSGIX may need conversion */
	fn.glSpriteParameterivSGIX(pname, params);
}

void OSMesaDriver::nfglStartInstrumentsSGIX(void)
{
	D(bug("nfosmesa: glStartInstrumentsSGIX()"));
	fn.glStartInstrumentsSGIX();
}

void OSMesaDriver::nfglStencilClearTagEXT(GLsizei stencilTagBits, GLuint stencilClearTag)
{
	D(bug("nfosmesa: glStencilClearTagEXT(%d, %u)", stencilTagBits, stencilClearTag));
	fn.glStencilClearTagEXT(stencilTagBits, stencilClearTag);
}

void OSMesaDriver::nfglStencilFillPathInstancedNV(GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLenum fillMode, GLuint mask, GLenum transformType, const GLfloat *transformValues)
{
	D(bug("nfosmesa: glStencilFillPathInstancedNV(%d, 0x%x, %p, %u, 0x%x, %u, 0x%x, %p)", numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues));
	/* TODO: NFOSMESA_GLSTENCILFILLPATHINSTANCEDNV may need conversion */
	fn.glStencilFillPathInstancedNV(numPaths, pathNameType, paths, pathBase, fillMode, mask, transformType, transformValues);
}

void OSMesaDriver::nfglStencilFillPathNV(GLuint path, GLenum fillMode, GLuint mask)
{
	D(bug("nfosmesa: glStencilFillPathNV(%u, 0x%x, %u)", path, fillMode, mask));
	fn.glStencilFillPathNV(path, fillMode, mask);
}

void OSMesaDriver::nfglStencilFunc(GLenum func, GLint ref, GLuint mask)
{
	D(bug("nfosmesa: glStencilFunc(0x%x, %d, %u)", func, ref, mask));
	fn.glStencilFunc(func, ref, mask);
}

void OSMesaDriver::nfglStencilFuncSeparate(GLenum face, GLenum func, GLint ref, GLuint mask)
{
	D(bug("nfosmesa: glStencilFuncSeparate(0x%x, 0x%x, %d, %u)", face, func, ref, mask));
	fn.glStencilFuncSeparate(face, func, ref, mask);
}

void OSMesaDriver::nfglStencilFuncSeparateATI(GLenum frontfunc, GLenum backfunc, GLint ref, GLuint mask)
{
	D(bug("nfosmesa: glStencilFuncSeparateATI(0x%x, 0x%x, %d, %u)", frontfunc, 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(0x%x, %u)", face, mask));
	fn.glStencilMaskSeparate(face, mask);
}

void OSMesaDriver::nfglStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
{
	D(bug("nfosmesa: glStencilOp(0x%x, 0x%x, 0x%x)", fail, zfail, zpass));
	fn.glStencilOp(fail, zfail, zpass);
}

void OSMesaDriver::nfglStencilOpSeparate(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
{
	D(bug("nfosmesa: glStencilOpSeparate(0x%x, 0x%x, 0x%x, 0x%x)", face, sfail, dpfail, dppass));
	fn.glStencilOpSeparate(face, sfail, dpfail, dppass);
}

void OSMesaDriver::nfglStencilOpSeparateATI(GLenum face, GLenum sfail, GLenum dpfail, GLenum dppass)
{
	D(bug("nfosmesa: glStencilOpSeparateATI(0x%x, 0x%x, 0x%x, 0x%x)", face, sfail, dpfail, dppass));
	fn.glStencilOpSeparateATI(face, sfail, dpfail, dppass);
}

void OSMesaDriver::nfglStencilOpValueAMD(GLenum face, GLuint value)
{
	D(bug("nfosmesa: glStencilOpValueAMD(0x%x, %u)", face, value));
	fn.glStencilOpValueAMD(face, value);
}

void OSMesaDriver::nfglStencilStrokePathInstancedNV(GLsizei numPaths, GLenum pathNameType, const void *paths, GLuint pathBase, GLint reference, GLuint mask, GLenum transformType, const GLfloat *transformValues)
{
	D(bug("nfosmesa: glStencilStrokePathInstancedNV(%d, 0x%x, %p, %u, %d, %u, 0x%x, %p)", numPaths, pathNameType, paths, pathBase, reference, mask, transformType, transformValues));
	/* TODO: NFOSMESA_GLSTENCILSTROKEPATHINSTANCEDNV may need conversion */
	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);
}

void OSMesaDriver::nfglStopInstrumentsSGIX(GLint marker)
{
	D(bug("nfosmesa: glStopInstrumentsSGIX(%d)", marker));
	fn.glStopInstrumentsSGIX(marker);
}

void OSMesaDriver::nfglStringMarkerGREMEDY(GLsizei len, const void *string)
{
	D(bug("nfosmesa: glStringMarkerGREMEDY(%d, %p)", len, string));
	/* TODO: NFOSMESA_GLSTRINGMARKERGREMEDY may need conversion */
	fn.glStringMarkerGREMEDY(len, string);
}

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, 0x%x, 0x%x, 0x%x, 0x%x)", res, in, outX, outY, outZ, 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);
}

void OSMesaDriver::nfglTangent3bvEXT(const GLbyte *v)
{
	D(bug("nfosmesa: glTangent3bvEXT(%p)", v));
	/* TODO: NFOSMESA_GLTANGENT3BVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglTangent3dvEXT(const GLdouble *v)
{
	D(bug("nfosmesa: glTangent3dvEXT(%p)", 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);
}

void OSMesaDriver::nfglTangent3fvEXT(const GLfloat *v)
{
	D(bug("nfosmesa: glTangent3fvEXT(%p)", 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);
}

void OSMesaDriver::nfglTangent3ivEXT(const GLint *v)
{
	D(bug("nfosmesa: glTangent3ivEXT(%p)", 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);
}

void OSMesaDriver::nfglTangent3svEXT(const GLshort *v)
{
	D(bug("nfosmesa: glTangent3svEXT(%p)", v));
FN_GLTANGENT3SVEXT(v);
}

void OSMesaDriver::nfglTangentPointerEXT(GLenum type, GLsizei stride, const void *pointer)
{
	D(bug("nfosmesa: glTangentPointerEXT(0x%x, %d, %p)", type, stride, pointer));
	/* TODO: NFOSMESA_GLTANGENTPOINTEREXT may need conversion */
	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(0x%x)", mode));
	fn.glTessellationModeAMD(mode);
}

GLboolean OSMesaDriver::nfglTestFenceAPPLE(GLuint fence)
{
	D(bug("nfosmesa: glTestFenceAPPLE(%u)", fence));
	return fn.glTestFenceAPPLE(fence);
}

GLboolean OSMesaDriver::nfglTestFenceNV(GLuint fence)
{
	D(bug("nfosmesa: glTestFenceNV(%u)", fence));
	return fn.glTestFenceNV(fence);
}

GLboolean OSMesaDriver::nfglTestObjectAPPLE(GLenum object, GLuint name)
{
	D(bug("nfosmesa: glTestObjectAPPLE(0x%x, %u)", object, name));
	return fn.glTestObjectAPPLE(object, name);
}

void OSMesaDriver::nfglTexBuffer(GLenum target, GLenum internalformat, GLuint buffer)
{
	D(bug("nfosmesa: glTexBuffer(0x%x, 0x%x, %u)", target, internalformat, buffer));
	fn.glTexBuffer(target, internalformat, buffer);
}

void OSMesaDriver::nfglTexBufferARB(GLenum target, GLenum internalformat, GLuint buffer)
{
	D(bug("nfosmesa: glTexBufferARB(0x%x, 0x%x, %u)", target, internalformat, buffer));
	fn.glTexBufferARB(target, internalformat, buffer);
}

void OSMesaDriver::nfglTexBufferEXT(GLenum target, GLenum internalformat, GLuint buffer)
{
	D(bug("nfosmesa: glTexBufferEXT(0x%x, 0x%x, %u)", target, internalformat, buffer));
	fn.glTexBufferEXT(target, internalformat, buffer);
}

void OSMesaDriver::nfglTexBufferRange(GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
	D(bug("nfosmesa: glTexBufferRange(0x%x, 0x%x, %u, %ld, %ld)", target, internalformat, buffer, offset, size));
	fn.glTexBufferRange(target, internalformat, buffer, offset, size);
}

void OSMesaDriver::nfglTexBumpParameterfvATI(GLenum pname, const GLfloat *param)
{
	D(bug("nfosmesa: glTexBumpParameterfvATI(0x%x, %p)", pname, param));
	/* TODO: NFOSMESA_GLTEXBUMPPARAMETERFVATI may need conversion */
	fn.glTexBumpParameterfvATI(pname, param);
}

void OSMesaDriver::nfglTexBumpParameterivATI(GLenum pname, const GLint *param)
{
	D(bug("nfosmesa: glTexBumpParameterivATI(0x%x, %p)", pname, param));
	/* TODO: NFOSMESA_GLTEXBUMPPARAMETERIVATI may need conversion */
	fn.glTexBumpParameterivATI(pname, param);
}

void OSMesaDriver::nfglTexCoord1bOES(GLbyte32 s)
{
	D(bug("nfosmesa: glTexCoord1bOES(%d)", s));
	fn.glTexCoord1bOES(s);
}

void OSMesaDriver::nfglTexCoord1bvOES(const GLbyte *coords)
{
	D(bug("nfosmesa: glTexCoord1bvOES(%p)", coords));
	/* TODO: NFOSMESA_GLTEXCOORD1BVOES may need conversion */
	fn.glTexCoord1bvOES(coords);
}

void OSMesaDriver::nfglTexCoord1d(GLdouble s)
{
	D(bug("nfosmesa: glTexCoord1d(%f)", s));
	fn.glTexCoord1d(s);
}

void OSMesaDriver::nfglTexCoord1dv(const GLdouble *v)
{
	D(bug("nfosmesa: glTexCoord1dv(%p)", v));
FN_GLTEXCOORD1DV(v);
}

void OSMesaDriver::nfglTexCoord1f(GLfloat s)
{
	D(bug("nfosmesa: glTexCoord1f(%f)", s));
	fn.glTexCoord1f(s);
}

void OSMesaDriver::nfglTexCoord1fv(const GLfloat *v)
{
	D(bug("nfosmesa: glTexCoord1fv(%p)", v));
FN_GLTEXCOORD1FV(v);
}

void OSMesaDriver::nfglTexCoord1hNV(GLhalfNV32 s)
{
	D(bug("nfosmesa: glTexCoord1hNV(%u)", s));
	fn.glTexCoord1hNV(s);
}

void OSMesaDriver::nfglTexCoord1hvNV(const GLhalfNV *v)
{
	D(bug("nfosmesa: glTexCoord1hvNV(%p)", v));
FN_GLTEXCOORD1HVNV(v);
}

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

void OSMesaDriver::nfglTexCoord1iv(const GLint *v)
{
	D(bug("nfosmesa: glTexCoord1iv(%p)", v));
FN_GLTEXCOORD1IV(v);
}

void OSMesaDriver::nfglTexCoord1s(GLshort32 s)
{
	D(bug("nfosmesa: glTexCoord1s(%d)", s));
	fn.glTexCoord1s(s);
}

void OSMesaDriver::nfglTexCoord1sv(const GLshort *v)
{
	D(bug("nfosmesa: glTexCoord1sv(%p)", v));
FN_GLTEXCOORD1SV(v);
}

void OSMesaDriver::nfglTexCoord1xOES(GLfixed s)
{
	D(bug("nfosmesa: glTexCoord1xOES(0x%x)", s));
	fn.glTexCoord1xOES(s);
}

void OSMesaDriver::nfglTexCoord1xvOES(const GLfixed *coords)
{
	D(bug("nfosmesa: glTexCoord1xvOES(%p)", coords));
	/* TODO: NFOSMESA_GLTEXCOORD1XVOES may need conversion */
	fn.glTexCoord1xvOES(coords);
}

void OSMesaDriver::nfglTexCoord2bOES(GLbyte32 s, GLbyte32 t)
{
	D(bug("nfosmesa: glTexCoord2bOES(%d, %d)", s, t));
	fn.glTexCoord2bOES(s, t);
}

void OSMesaDriver::nfglTexCoord2bvOES(const GLbyte *coords)
{
	D(bug("nfosmesa: glTexCoord2bvOES(%p)", coords));
	/* TODO: NFOSMESA_GLTEXCOORD2BVOES may need conversion */
	fn.glTexCoord2bvOES(coords);
}

void OSMesaDriver::nfglTexCoord2d(GLdouble s, GLdouble t)
{
	D(bug("nfosmesa: glTexCoord2d(%f, %f)", s, t));
	fn.glTexCoord2d(s, t);
}

void OSMesaDriver::nfglTexCoord2dv(const GLdouble *v)
{
	D(bug("nfosmesa: glTexCoord2dv(%p)", 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);
}

void OSMesaDriver::nfglTexCoord2fColor3fVertex3fvSUN(const GLfloat *tc, const GLfloat *c, const GLfloat *v)
{
	D(bug("nfosmesa: glTexCoord2fColor3fVertex3fvSUN(%p, %p, %p)", tc, c, 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);
}

void OSMesaDriver::nfglTexCoord2fColor4fNormal3fVertex3fvSUN(const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v)
{
	D(bug("nfosmesa: glTexCoord2fColor4fNormal3fVertex3fvSUN(%p, %p, %p, %p)", tc, c, n, 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);
}

void OSMesaDriver::nfglTexCoord2fColor4ubVertex3fvSUN(const GLfloat *tc, const GLubyte *c, const GLfloat *v)
{
	D(bug("nfosmesa: glTexCoord2fColor4ubVertex3fvSUN(%p, %p, %p)", tc, c, 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);
}

void OSMesaDriver::nfglTexCoord2fNormal3fVertex3fvSUN(const GLfloat *tc, const GLfloat *n, const GLfloat *v)
{
	D(bug("nfosmesa: glTexCoord2fNormal3fVertex3fvSUN(%p, %p, %p)", tc, n, 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);
}

void OSMesaDriver::nfglTexCoord2fVertex3fvSUN(const GLfloat *tc, const GLfloat *v)
{
	D(bug("nfosmesa: glTexCoord2fVertex3fvSUN(%p, %p)", tc, v));
FN_GLTEXCOORD2FVERTEX3FVSUN(tc, v);
}

void OSMesaDriver::nfglTexCoord2fv(const GLfloat *v)
{
	D(bug("nfosmesa: glTexCoord2fv(%p)", v));
FN_GLTEXCOORD2FV(v);
}

void OSMesaDriver::nfglTexCoord2hNV(GLhalfNV32 s, GLhalfNV32 t)
{
	D(bug("nfosmesa: glTexCoord2hNV(%u, %u)", s, t));
	fn.glTexCoord2hNV(s, t);
}

void OSMesaDriver::nfglTexCoord2hvNV(const GLhalfNV *v)
{
	D(bug("nfosmesa: glTexCoord2hvNV(%p)", v));
FN_GLTEXCOORD2HVNV(v);
}

void OSMesaDriver::nfglTexCoord2i(GLint s, GLint t)
{
	D(bug("nfosmesa: glTexCoord2i(%d, %d)", s, t));
	fn.glTexCoord2i(s, t);
}

void OSMesaDriver::nfglTexCoord2iv(const GLint *v)
{
	D(bug("nfosmesa: glTexCoord2iv(%p)", v));
FN_GLTEXCOORD2IV(v);
}

void OSMesaDriver::nfglTexCoord2s(GLshort32 s, GLshort32 t)
{
	D(bug("nfosmesa: glTexCoord2s(%d, %d)", s, t));
	fn.glTexCoord2s(s, t);
}

void OSMesaDriver::nfglTexCoord2sv(const GLshort *v)
{
	D(bug("nfosmesa: glTexCoord2sv(%p)", 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);
}

void OSMesaDriver::nfglTexCoord2xvOES(const GLfixed *coords)
{
	D(bug("nfosmesa: glTexCoord2xvOES(%p)", coords));
	/* TODO: NFOSMESA_GLTEXCOORD2XVOES may need conversion */
	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);
}

void OSMesaDriver::nfglTexCoord3bvOES(const GLbyte *coords)
{
	D(bug("nfosmesa: glTexCoord3bvOES(%p)", coords));
	/* TODO: NFOSMESA_GLTEXCOORD3BVOES may need conversion */
	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);
}

void OSMesaDriver::nfglTexCoord3dv(const GLdouble *v)
{
	D(bug("nfosmesa: glTexCoord3dv(%p)", 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);
}

void OSMesaDriver::nfglTexCoord3fv(const GLfloat *v)
{
	D(bug("nfosmesa: glTexCoord3fv(%p)", 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);
}

void OSMesaDriver::nfglTexCoord3hvNV(const GLhalfNV *v)
{
	D(bug("nfosmesa: glTexCoord3hvNV(%p)", 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);
}

void OSMesaDriver::nfglTexCoord3iv(const GLint *v)
{
	D(bug("nfosmesa: glTexCoord3iv(%p)", 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);
}

void OSMesaDriver::nfglTexCoord3sv(const GLshort *v)
{
	D(bug("nfosmesa: glTexCoord3sv(%p)", 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);
}

void OSMesaDriver::nfglTexCoord3xvOES(const GLfixed *coords)
{
	D(bug("nfosmesa: glTexCoord3xvOES(%p)", coords));
	/* TODO: NFOSMESA_GLTEXCOORD3XVOES may need conversion */
	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);
}

void OSMesaDriver::nfglTexCoord4bvOES(const GLbyte *coords)
{
	D(bug("nfosmesa: glTexCoord4bvOES(%p)", coords));
	/* TODO: NFOSMESA_GLTEXCOORD4BVOES may need conversion */
	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);
}

void OSMesaDriver::nfglTexCoord4dv(const GLdouble *v)
{
	D(bug("nfosmesa: glTexCoord4dv(%p)", 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);
}

void OSMesaDriver::nfglTexCoord4fColor4fNormal3fVertex4fvSUN(const GLfloat *tc, const GLfloat *c, const GLfloat *n, const GLfloat *v)
{
	D(bug("nfosmesa: glTexCoord4fColor4fNormal3fVertex4fvSUN(%p, %p, %p, %p)", tc, c, n, 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);
}

void OSMesaDriver::nfglTexCoord4fVertex4fvSUN(const GLfloat *tc, const GLfloat *v)
{
	D(bug("nfosmesa: glTexCoord4fVertex4fvSUN(%p, %p)", tc, v));
FN_GLTEXCOORD4FVERTEX4FVSUN(tc, v);
}

void OSMesaDriver::nfglTexCoord4fv(const GLfloat *v)
{
	D(bug("nfosmesa: glTexCoord4fv(%p)", 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);
}

void OSMesaDriver::nfglTexCoord4hvNV(const GLhalfNV *v)
{
	D(bug("nfosmesa: glTexCoord4hvNV(%p)", 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);
}

void OSMesaDriver::nfglTexCoord4iv(const GLint *v)
{
	D(bug("nfosmesa: glTexCoord4iv(%p)", 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);
}

void OSMesaDriver::nfglTexCoord4sv(const GLshort *v)
{
	D(bug("nfosmesa: glTexCoord4sv(%p)", 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);
}

void OSMesaDriver::nfglTexCoord4xvOES(const GLfixed *coords)
{
	D(bug("nfosmesa: glTexCoord4xvOES(%p)", coords));
	/* TODO: NFOSMESA_GLTEXCOORD4XVOES may need conversion */
	fn.glTexCoord4xvOES(coords);
}

void OSMesaDriver::nfglTexCoordFormatNV(GLint size, GLenum type, GLsizei stride)
{
	D(bug("nfosmesa: glTexCoordFormatNV(%d, 0x%x, %d)", size, type, stride));
	fn.glTexCoordFormatNV(size, type, stride);
}

void OSMesaDriver::nfglTexCoordP1ui(GLenum type, GLuint coords)
{
	D(bug("nfosmesa: glTexCoordP1ui(0x%x, %u)", type, coords));
	fn.glTexCoordP1ui(type, coords);
}

void OSMesaDriver::nfglTexCoordP1uiv(GLenum type, const GLuint *coords)
{
	D(bug("nfosmesa: glTexCoordP1uiv(0x%x, %p)", type, coords));
	/* TODO: NFOSMESA_GLTEXCOORDP1UIV may need conversion */
	fn.glTexCoordP1uiv(type, coords);
}

void OSMesaDriver::nfglTexCoordP2ui(GLenum type, GLuint coords)
{
	D(bug("nfosmesa: glTexCoordP2ui(0x%x, %u)", type, coords));
	fn.glTexCoordP2ui(type, coords);
}

void OSMesaDriver::nfglTexCoordP2uiv(GLenum type, const GLuint *coords)
{
	D(bug("nfosmesa: glTexCoordP2uiv(0x%x, %p)", type, coords));
	/* TODO: NFOSMESA_GLTEXCOORDP2UIV may need conversion */
	fn.glTexCoordP2uiv(type, coords);
}

void OSMesaDriver::nfglTexCoordP3ui(GLenum type, GLuint coords)
{
	D(bug("nfosmesa: glTexCoordP3ui(0x%x, %u)", type, coords));
	fn.glTexCoordP3ui(type, coords);
}

void OSMesaDriver::nfglTexCoordP3uiv(GLenum type, const GLuint *coords)
{
	D(bug("nfosmesa: glTexCoordP3uiv(0x%x, %p)", type, coords));
	/* TODO: NFOSMESA_GLTEXCOORDP3UIV may need conversion */
	fn.glTexCoordP3uiv(type, coords);
}

void OSMesaDriver::nfglTexCoordP4ui(GLenum type, GLuint coords)
{
	D(bug("nfosmesa: glTexCoordP4ui(0x%x, %u)", type, coords));
	fn.glTexCoordP4ui(type, coords);
}

void OSMesaDriver::nfglTexCoordP4uiv(GLenum type, const GLuint *coords)
{
	D(bug("nfosmesa: glTexCoordP4uiv(0x%x, %p)", type, coords));
	/* TODO: NFOSMESA_GLTEXCOORDP4UIV may need conversion */
	fn.glTexCoordP4uiv(type, coords);
}

void OSMesaDriver::nfglTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
	D(bug("nfosmesa: glTexCoordPointer(%d, 0x%x, %d, %p)", size, type, stride, pointer));
FN_GLTEXCOORDPOINTER(size, type, stride, pointer);
}

void OSMesaDriver::nfglTexCoordPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer)
{
	D(bug("nfosmesa: glTexCoordPointerEXT(%d, 0x%x, %d, %d, %p)", size, type, stride, count, pointer));
FN_GLTEXCOORDPOINTEREXT(size, type, stride, count, pointer);
}

void OSMesaDriver::nfglTexCoordPointerListIBM(GLint size, GLenum type, GLint stride, const void * *pointer, GLint ptrstride)
{
	D(bug("nfosmesa: glTexCoordPointerListIBM(%d, 0x%x, %d, %p, %d)", size, type, stride, pointer, ptrstride));
	/* TODO: NFOSMESA_GLTEXCOORDPOINTERLISTIBM may need conversion */
	fn.glTexCoordPointerListIBM(size, type, stride, pointer, ptrstride);
}

void OSMesaDriver::nfglTexCoordPointervINTEL(GLint size, GLenum type, const void * *pointer)
{
	D(bug("nfosmesa: glTexCoordPointervINTEL(%d, 0x%x, %p)", size, type, pointer));
	/* TODO: NFOSMESA_GLTEXCOORDPOINTERVINTEL may need conversion */
	fn.glTexCoordPointervINTEL(size, type, pointer);
}

void OSMesaDriver::nfglTexEnvf(GLenum target, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glTexEnvf(0x%x, 0x%x, %f)", target, pname, param));
	fn.glTexEnvf(target, pname, param);
}

void OSMesaDriver::nfglTexEnvfv(GLenum target, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glTexEnvfv(0x%x, 0x%x, %p)", target, pname, params));
FN_GLTEXENVFV(target, pname, params);
}

void OSMesaDriver::nfglTexEnvi(GLenum target, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glTexEnvi(0x%x, 0x%x, %d)", target, pname, param));
	fn.glTexEnvi(target, pname, param);
}

void OSMesaDriver::nfglTexEnviv(GLenum target, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glTexEnviv(0x%x, 0x%x, %p)", target, pname, params));
FN_GLTEXENVIV(target, pname, params);
}

void OSMesaDriver::nfglTexEnvxOES(GLenum target, GLenum pname, GLfixed param)
{
	D(bug("nfosmesa: glTexEnvxOES(0x%x, 0x%x, 0x%x)", target, pname, param));
	fn.glTexEnvxOES(target, pname, param);
}

void OSMesaDriver::nfglTexEnvxvOES(GLenum target, GLenum pname, const GLfixed *params)
{
	D(bug("nfosmesa: glTexEnvxvOES(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLTEXENVXVOES may need conversion */
	fn.glTexEnvxvOES(target, pname, params);
}

void OSMesaDriver::nfglTexFilterFuncSGIS(GLenum target, GLenum filter, GLsizei n, const GLfloat *weights)
{
	D(bug("nfosmesa: glTexFilterFuncSGIS(0x%x, 0x%x, %d, %p)", target, filter, n, weights));
	/* TODO: NFOSMESA_GLTEXFILTERFUNCSGIS may need conversion */
	fn.glTexFilterFuncSGIS(target, filter, n, weights);
}

void OSMesaDriver::nfglTexGend(GLenum coord, GLenum pname, GLdouble param)
{
	D(bug("nfosmesa: glTexGend(0x%x, 0x%x, %f)", coord, pname, param));
	fn.glTexGend(coord, pname, param);
}

void OSMesaDriver::nfglTexGendv(GLenum coord, GLenum pname, const GLdouble *params)
{
	D(bug("nfosmesa: glTexGendv(0x%x, 0x%x, %p)", coord, pname, params));
FN_GLTEXGENDV(coord, pname, params);
}

void OSMesaDriver::nfglTexGenf(GLenum coord, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glTexGenf(0x%x, 0x%x, %f)", coord, pname, param));
	fn.glTexGenf(coord, pname, param);
}

void OSMesaDriver::nfglTexGenfv(GLenum coord, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glTexGenfv(0x%x, 0x%x, %p)", coord, pname, params));
FN_GLTEXGENFV(coord, pname, params);
}

void OSMesaDriver::nfglTexGeni(GLenum coord, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glTexGeni(0x%x, 0x%x, %d)", coord, pname, param));
	fn.glTexGeni(coord, pname, param);
}

void OSMesaDriver::nfglTexGeniv(GLenum coord, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glTexGeniv(0x%x, 0x%x, %p)", coord, pname, params));
FN_GLTEXGENIV(coord, pname, params);
}

void OSMesaDriver::nfglTexGenxOES(GLenum coord, GLenum pname, GLfixed param)
{
	D(bug("nfosmesa: glTexGenxOES(0x%x, 0x%x, 0x%x)", coord, pname, param));
	fn.glTexGenxOES(coord, pname, param);
}

void OSMesaDriver::nfglTexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params)
{
	D(bug("nfosmesa: glTexGenxvOES(0x%x, 0x%x, %p)", coord, pname, params));
	/* TODO: NFOSMESA_GLTEXGENXVOES may need conversion */
	fn.glTexGenxvOES(coord, pname, params);
}

void OSMesaDriver::nfglTexImage1D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
{
	D(bug("nfosmesa: glTexImage1D(0x%x, %d, %d, %d, %d, 0x%x, 0x%x, %p)", target, level, internalformat, width, border, format, type, pixels));
	/* TODO: NFOSMESA_GLTEXIMAGE1D may need conversion */
	fn.glTexImage1D(target, level, internalformat, width, border, format, type, pixels);
}

void OSMesaDriver::nfglTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels)
{
	D(bug("nfosmesa: glTexImage2D(0x%x, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p)", target, level, internalformat, width, height, border, format, type, pixels));
	/* TODO: NFOSMESA_GLTEXIMAGE2D may need conversion */
	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(0x%x, %d, 0x%x, %d, %d, %d)", target, samples, 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(0x%x, %d, %d, %d, %d, %d, %d)", target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations));
	fn.glTexImage2DMultisampleCoverageNV(target, coverageSamples, colorSamples, internalFormat, width, height, fixedSampleLocations);
}

void OSMesaDriver::nfglTexImage3D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
{
	D(bug("nfosmesa: glTexImage3D(0x%x, %d, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p)", target, level, internalformat, width, height, depth, border, format, type, pixels));
	/* TODO: NFOSMESA_GLTEXIMAGE3D may need conversion */
	fn.glTexImage3D(target, level, internalformat, width, height, depth, border, format, type, pixels);
}

void OSMesaDriver::nfglTexImage3DEXT(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLint border, GLenum format, GLenum type, const void *pixels)
{
	D(bug("nfosmesa: glTexImage3DEXT(0x%x, %d, 0x%x, %d, %d, %d, %d, 0x%x, 0x%x, %p)", target, level, internalformat, width, height, depth, border, format, type, pixels));
	/* TODO: NFOSMESA_GLTEXIMAGE3DEXT may need conversion */
	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(0x%x, %d, 0x%x, %d, %d, %d, %d)", target, samples, 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(0x%x, %d, %d, %d, %d, %d, %d, %d)", target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations));
	fn.glTexImage3DMultisampleCoverageNV(target, coverageSamples, colorSamples, internalFormat, width, height, depth, fixedSampleLocations);
}

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)
{
	D(bug("nfosmesa: glTexImage4DSGIS(0x%x, %d, 0x%x, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p)", target, level, internalformat, width, height, depth, size4d, border, format, type, pixels));
	/* TODO: NFOSMESA_GLTEXIMAGE4DSGIS may need conversion */
	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 resident)
{
	D(bug("nfosmesa: glTexPageCommitmentARB(0x%x, %d, %d, %d, %d, %d, %d, %d, %d)", target, level, xoffset, yoffset, zoffset, width, height, depth, resident));
	fn.glTexPageCommitmentARB(target, level, xoffset, yoffset, zoffset, width, height, depth, resident);
}

void OSMesaDriver::nfglTexParameterIiv(GLenum target, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glTexParameterIiv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLTEXPARAMETERIIV may need conversion */
	fn.glTexParameterIiv(target, pname, params);
}

void OSMesaDriver::nfglTexParameterIivEXT(GLenum target, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glTexParameterIivEXT(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLTEXPARAMETERIIVEXT may need conversion */
	fn.glTexParameterIivEXT(target, pname, params);
}

void OSMesaDriver::nfglTexParameterIuiv(GLenum target, GLenum pname, const GLuint *params)
{
	D(bug("nfosmesa: glTexParameterIuiv(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLTEXPARAMETERIUIV may need conversion */
	fn.glTexParameterIuiv(target, pname, params);
}

void OSMesaDriver::nfglTexParameterIuivEXT(GLenum target, GLenum pname, const GLuint *params)
{
	D(bug("nfosmesa: glTexParameterIuivEXT(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLTEXPARAMETERIUIVEXT may need conversion */
	fn.glTexParameterIuivEXT(target, pname, params);
}

void OSMesaDriver::nfglTexParameterf(GLenum target, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glTexParameterf(0x%x, 0x%x, %f)", target, pname, param));
	fn.glTexParameterf(target, pname, param);
}

void OSMesaDriver::nfglTexParameterfv(GLenum target, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glTexParameterfv(0x%x, 0x%x, %p)", target, pname, params));
FN_GLTEXPARAMETERFV(target, pname, params);
}

void OSMesaDriver::nfglTexParameteri(GLenum target, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glTexParameteri(0x%x, 0x%x, %d)", target, pname, param));
	fn.glTexParameteri(target, pname, param);
}

void OSMesaDriver::nfglTexParameteriv(GLenum target, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glTexParameteriv(0x%x, 0x%x, %p)", target, pname, params));
FN_GLTEXPARAMETERIV(target, pname, params);
}

void OSMesaDriver::nfglTexParameterxOES(GLenum target, GLenum pname, GLfixed param)
{
	D(bug("nfosmesa: glTexParameterxOES(0x%x, 0x%x, 0x%x)", target, pname, param));
	fn.glTexParameterxOES(target, pname, param);
}

void OSMesaDriver::nfglTexParameterxvOES(GLenum target, GLenum pname, const GLfixed *params)
{
	D(bug("nfosmesa: glTexParameterxvOES(0x%x, 0x%x, %p)", target, pname, params));
	/* TODO: NFOSMESA_GLTEXPARAMETERXVOES may need conversion */
	fn.glTexParameterxvOES(target, pname, params);
}

void OSMesaDriver::nfglTexRenderbufferNV(GLenum target, GLuint renderbuffer)
{
	D(bug("nfosmesa: glTexRenderbufferNV(0x%x, %u)", target, renderbuffer));
	fn.glTexRenderbufferNV(target, renderbuffer);
}

void OSMesaDriver::nfglTexScissorFuncINTEL(GLenum target, GLenum lfunc, GLenum hfunc)
{
	D(bug("nfosmesa: glTexScissorFuncINTEL(0x%x, 0x%x, 0x%x)", target, lfunc, hfunc));
	fn.glTexScissorFuncINTEL(target, lfunc, hfunc);
}

void OSMesaDriver::nfglTexScissorINTEL(GLenum target, GLclampf tlow, GLclampf thigh)
{
	D(bug("nfosmesa: glTexScissorINTEL(0x%x, %f, %f)", target, tlow, thigh));
	fn.glTexScissorINTEL(target, tlow, thigh);
}

void OSMesaDriver::nfglTexStorage1D(GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
{
	D(bug("nfosmesa: glTexStorage1D(0x%x, %d, 0x%x, %d)", target, levels, 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(0x%x, %d, 0x%x, %d, %d)", target, levels, 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(0x%x, %d, 0x%x, %d, %d, %d)", target, samples, 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(0x%x, %d, 0x%x, %d, %d, %d)", target, levels, 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(0x%x, %d, 0x%x, %d, %d, %d, %d)", target, samples, internalformat, width, height, depth, fixedsamplelocations));
	fn.glTexStorage3DMultisample(target, samples, internalformat, width, height, depth, fixedsamplelocations);
}

void OSMesaDriver::nfglTexStorageSparseAMD(GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei layers, GLbitfield flags)
{
	D(bug("nfosmesa: glTexStorageSparseAMD(0x%x, 0x%x, %d, %d, %d, %d, 0x%x)", target, internalFormat, width, height, depth, layers, flags));
	fn.glTexStorageSparseAMD(target, internalFormat, width, height, depth, layers, flags);
}

void OSMesaDriver::nfglTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const GLvoid *pixels)
{
	D(bug("nfosmesa: glTexSubImage1D(0x%x, %d, %d, %d, 0x%x, 0x%x, %p)", target, level, xoffset, width, format, type, pixels));
	/* TODO: NFOSMESA_GLTEXSUBIMAGE1D may need conversion */
	fn.glTexSubImage1D(target, level, xoffset, width, format, type, pixels);
}

void OSMesaDriver::nfglTexSubImage1DEXT(GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
{
	D(bug("nfosmesa: glTexSubImage1DEXT(0x%x, %d, %d, %d, 0x%x, 0x%x, %p)", target, level, xoffset, width, format, type, pixels));
	/* TODO: NFOSMESA_GLTEXSUBIMAGE1DEXT may need conversion */
	fn.glTexSubImage1DEXT(target, level, xoffset, width, format, type, pixels);
}

void OSMesaDriver::nfglTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
{
	D(bug("nfosmesa: glTexSubImage2D(0x%x, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p)", target, level, xoffset, yoffset, width, height, format, type, pixels));
	/* TODO: NFOSMESA_GLTEXSUBIMAGE2D may need conversion */
	fn.glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels);
}

void OSMesaDriver::nfglTexSubImage2DEXT(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
{
	D(bug("nfosmesa: glTexSubImage2DEXT(0x%x, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p)", target, level, xoffset, yoffset, width, height, format, type, pixels));
	/* TODO: NFOSMESA_GLTEXSUBIMAGE2DEXT may need conversion */
	fn.glTexSubImage2DEXT(target, level, xoffset, yoffset, width, height, format, type, pixels);
}

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)
{
	D(bug("nfosmesa: glTexSubImage3D(0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p)", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels));
	/* TODO: NFOSMESA_GLTEXSUBIMAGE3D may need conversion */
	fn.glTexSubImage3D(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
}

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)
{
	D(bug("nfosmesa: glTexSubImage3DEXT(0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p)", target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels));
	/* TODO: NFOSMESA_GLTEXSUBIMAGE3DEXT may need conversion */
	fn.glTexSubImage3DEXT(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels);
}

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)
{
	D(bug("nfosmesa: glTexSubImage4DSGIS(0x%x, %d, %d, %d, %d, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p)", target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels));
	/* TODO: NFOSMESA_GLTEXSUBIMAGE4DSGIS may need conversion */
	fn.glTexSubImage4DSGIS(target, level, xoffset, yoffset, zoffset, woffset, width, height, depth, size4d, format, type, pixels);
}

void OSMesaDriver::nfglTextureBarrierNV(void)
{
	D(bug("nfosmesa: glTextureBarrierNV()"));
	fn.glTextureBarrierNV();
}

void OSMesaDriver::nfglTextureBufferEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer)
{
	D(bug("nfosmesa: glTextureBufferEXT(%u, 0x%x, 0x%x, %u)", texture, target, internalformat, buffer));
	fn.glTextureBufferEXT(texture, target, internalformat, buffer);
}

void OSMesaDriver::nfglTextureBufferRangeEXT(GLuint texture, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size)
{
	D(bug("nfosmesa: glTextureBufferRangeEXT(%u, 0x%x, 0x%x, %u, %ld, %ld)", texture, target, 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(0x%x)", pname));
	fn.glTextureFogSGIX(pname);
}

void OSMesaDriver::nfglTextureImage1DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLint border, GLenum format, GLenum type, const void *pixels)
{
	D(bug("nfosmesa: glTextureImage1DEXT(%u, 0x%x, %d, 0x%x, %d, %d, 0x%x, 0x%x, %p)", texture, target, level, internalformat, width, border, format, type, pixels));
	/* TODO: NFOSMESA_GLTEXTUREIMAGE1DEXT may need conversion */
	fn.glTextureImage1DEXT(texture, target, level, internalformat, width, border, format, type, pixels);
}

void OSMesaDriver::nfglTextureImage2DEXT(GLuint texture, GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const void *pixels)
{
	D(bug("nfosmesa: glTextureImage2DEXT(%u, 0x%x, %d, 0x%x, %d, %d, %d, 0x%x, 0x%x, %p)", texture, target, level, internalformat, width, height, border, format, type, pixels));
	/* TODO: NFOSMESA_GLTEXTUREIMAGE2DEXT may need conversion */
	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, 0x%x, %d, %d, %d, %d, %d, %d)", texture, 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, 0x%x, %d, %d, %d, %d, %d)", texture, target, samples, internalFormat, width, height, fixedSampleLocations));
	fn.glTextureImage2DMultisampleNV(texture, target, samples, internalFormat, width, height, fixedSampleLocations);
}

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)
{
	D(bug("nfosmesa: glTextureImage3DEXT(%u, 0x%x, %d, 0x%x, %d, %d, %d, %d, 0x%x, 0x%x, %p)", texture, target, level, internalformat, width, height, depth, border, format, type, pixels));
	/* TODO: NFOSMESA_GLTEXTUREIMAGE3DEXT may need conversion */
	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, 0x%x, %d, %d, %d, %d, %d, %d, %d)", texture, 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, 0x%x, %d, %d, %d, %d, %d, %d)", texture, 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(0x%x)", pname));
	fn.glTextureLightEXT(pname);
}

void OSMesaDriver::nfglTextureMaterialEXT(GLenum face, GLenum mode)
{
	D(bug("nfosmesa: glTextureMaterialEXT(0x%x, 0x%x)", face, mode));
	fn.glTextureMaterialEXT(face, mode);
}

void OSMesaDriver::nfglTextureNormalEXT(GLenum mode)
{
	D(bug("nfosmesa: glTextureNormalEXT(0x%x)", mode));
	fn.glTextureNormalEXT(mode);
}

void OSMesaDriver::nfglTexturePageCommitmentEXT(GLuint texture, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLboolean32 resident)
{
	D(bug("nfosmesa: glTexturePageCommitmentEXT(%u, %d, %d, %d, %d, %d, %d, %d, %d)", texture, level, xoffset, yoffset, zoffset, width, height, depth, resident));
	fn.glTexturePageCommitmentEXT(texture, level, xoffset, yoffset, zoffset, width, height, depth, resident);
}

void OSMesaDriver::nfglTextureParameterIivEXT(GLuint texture, GLenum target, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glTextureParameterIivEXT(%u, 0x%x, 0x%x, %p)", texture, target, pname, params));
	/* TODO: NFOSMESA_GLTEXTUREPARAMETERIIVEXT may need conversion */
	fn.glTextureParameterIivEXT(texture, target, pname, params);
}

void OSMesaDriver::nfglTextureParameterIuivEXT(GLuint texture, GLenum target, GLenum pname, const GLuint *params)
{
	D(bug("nfosmesa: glTextureParameterIuivEXT(%u, 0x%x, 0x%x, %p)", texture, target, pname, params));
	/* TODO: NFOSMESA_GLTEXTUREPARAMETERIUIVEXT may need conversion */
	fn.glTextureParameterIuivEXT(texture, target, pname, params);
}

void OSMesaDriver::nfglTextureParameterfEXT(GLuint texture, GLenum target, GLenum pname, GLfloat param)
{
	D(bug("nfosmesa: glTextureParameterfEXT(%u, 0x%x, 0x%x, %f)", texture, target, pname, param));
	fn.glTextureParameterfEXT(texture, target, pname, param);
}

void OSMesaDriver::nfglTextureParameterfvEXT(GLuint texture, GLenum target, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glTextureParameterfvEXT(%u, 0x%x, 0x%x, %p)", texture, target, pname, params));
	/* TODO: NFOSMESA_GLTEXTUREPARAMETERFVEXT may need conversion */
	fn.glTextureParameterfvEXT(texture, target, pname, params);
}

void OSMesaDriver::nfglTextureParameteriEXT(GLuint texture, GLenum target, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glTextureParameteriEXT(%u, 0x%x, 0x%x, %d)", texture, target, pname, param));
	fn.glTextureParameteriEXT(texture, target, pname, param);
}

void OSMesaDriver::nfglTextureParameterivEXT(GLuint texture, GLenum target, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glTextureParameterivEXT(%u, 0x%x, 0x%x, %p)", texture, target, pname, params));
	/* TODO: NFOSMESA_GLTEXTUREPARAMETERIVEXT may need conversion */
	fn.glTextureParameterivEXT(texture, target, pname, params);
}

void OSMesaDriver::nfglTextureRangeAPPLE(GLenum target, GLsizei length, const void *pointer)
{
	D(bug("nfosmesa: glTextureRangeAPPLE(0x%x, %d, %p)", target, length, pointer));
	/* TODO: NFOSMESA_GLTEXTURERANGEAPPLE may need conversion */
	fn.glTextureRangeAPPLE(target, length, pointer);
}

void OSMesaDriver::nfglTextureRenderbufferEXT(GLuint texture, GLenum target, GLuint renderbuffer)
{
	D(bug("nfosmesa: glTextureRenderbufferEXT(%u, 0x%x, %u)", texture, target, renderbuffer));
	fn.glTextureRenderbufferEXT(texture, target, renderbuffer);
}

void OSMesaDriver::nfglTextureStorage1DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width)
{
	D(bug("nfosmesa: glTextureStorage1DEXT(%u, 0x%x, %d, 0x%x, %d)", texture, target, levels, internalformat, width));
	fn.glTextureStorage1DEXT(texture, target, levels, internalformat, width);
}

void OSMesaDriver::nfglTextureStorage2DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height)
{
	D(bug("nfosmesa: glTextureStorage2DEXT(%u, 0x%x, %d, 0x%x, %d, %d)", texture, target, levels, internalformat, width, height));
	fn.glTextureStorage2DEXT(texture, target, levels, internalformat, width, height);
}

void OSMesaDriver::nfglTextureStorage2DMultisampleEXT(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLboolean32 fixedsamplelocations)
{
	D(bug("nfosmesa: glTextureStorage2DMultisampleEXT(%u, 0x%x, %d, 0x%x, %d, %d, %d)", texture, target, samples, internalformat, width, height, fixedsamplelocations));
	fn.glTextureStorage2DMultisampleEXT(texture, target, samples, internalformat, width, height, fixedsamplelocations);
}

void OSMesaDriver::nfglTextureStorage3DEXT(GLuint texture, GLenum target, GLsizei levels, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth)
{
	D(bug("nfosmesa: glTextureStorage3DEXT(%u, 0x%x, %d, 0x%x, %d, %d, %d)", texture, target, levels, internalformat, width, height, depth));
	fn.glTextureStorage3DEXT(texture, target, levels, internalformat, width, height, depth);
}

void OSMesaDriver::nfglTextureStorage3DMultisampleEXT(GLuint texture, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean32 fixedsamplelocations)
{
	D(bug("nfosmesa: glTextureStorage3DMultisampleEXT(%u, 0x%x, %d, 0x%x, %d, %d, %d, %d)", texture, target, samples, internalformat, width, height, depth, fixedsamplelocations));
	fn.glTextureStorage3DMultisampleEXT(texture, target, samples, internalformat, width, height, depth, fixedsamplelocations);
}

void OSMesaDriver::nfglTextureStorageSparseAMD(GLuint texture, GLenum target, GLenum internalFormat, GLsizei width, GLsizei height, GLsizei depth, GLsizei layers, GLbitfield flags)
{
	D(bug("nfosmesa: glTextureStorageSparseAMD(%u, 0x%x, 0x%x, %d, %d, %d, %d, 0x%x)", texture, target, internalFormat, width, height, depth, layers, flags));
	fn.glTextureStorageSparseAMD(texture, target, internalFormat, width, height, depth, layers, flags);
}

void OSMesaDriver::nfglTextureSubImage1DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLsizei width, GLenum format, GLenum type, const void *pixels)
{
	D(bug("nfosmesa: glTextureSubImage1DEXT(%u, 0x%x, %d, %d, %d, 0x%x, 0x%x, %p)", texture, target, level, xoffset, width, format, type, pixels));
	/* TODO: NFOSMESA_GLTEXTURESUBIMAGE1DEXT may need conversion */
	fn.glTextureSubImage1DEXT(texture, target, level, xoffset, width, format, type, pixels);
}

void OSMesaDriver::nfglTextureSubImage2DEXT(GLuint texture, GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const void *pixels)
{
	D(bug("nfosmesa: glTextureSubImage2DEXT(%u, 0x%x, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p)", texture, target, level, xoffset, yoffset, width, height, format, type, pixels));
	/* TODO: NFOSMESA_GLTEXTURESUBIMAGE2DEXT may need conversion */
	fn.glTextureSubImage2DEXT(texture, target, level, xoffset, yoffset, width, height, format, type, pixels);
}

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)
{
	D(bug("nfosmesa: glTextureSubImage3DEXT(%u, 0x%x, %d, %d, %d, %d, %d, %d, %d, 0x%x, 0x%x, %p)", texture, target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, pixels));
	/* TODO: NFOSMESA_GLTEXTURESUBIMAGE3DEXT may need conversion */
	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, 0x%x, %u, 0x%x, %u, %u, %u, %u)", texture, target, origtexture, 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);
}

void OSMesaDriver::nfglTraceCommentMESA(const GLubyte *comment)
{
	D(bug("nfosmesa: glTraceCommentMESA(%p)", comment));
	/* TODO: NFOSMESA_GLTRACECOMMENTMESA may need conversion */
	fn.glTraceCommentMESA(comment);
}

void OSMesaDriver::nfglTraceListMESA(GLuint name, const GLubyte *comment)
{
	D(bug("nfosmesa: glTraceListMESA(%u, %p)", name, comment));
	/* TODO: NFOSMESA_GLTRACELISTMESA may need conversion */
	fn.glTraceListMESA(name, comment);
}

void OSMesaDriver::nfglTracePointerMESA(GLvoid *pointer, const GLubyte *comment)
{
	D(bug("nfosmesa: glTracePointerMESA(%p, %p)", pointer, comment));
	/* TODO: NFOSMESA_GLTRACEPOINTERMESA may need conversion */
	fn.glTracePointerMESA(pointer, comment);
}

void OSMesaDriver::nfglTracePointerRangeMESA(const GLvoid *first, const GLvoid *last, const GLubyte *comment)
{
	D(bug("nfosmesa: glTracePointerRangeMESA(%p, %p, %p)", first, last, comment));
	/* TODO: NFOSMESA_GLTRACEPOINTERRANGEMESA may need conversion */
	fn.glTracePointerRangeMESA(first, last, comment);
}

void OSMesaDriver::nfglTraceTextureMESA(GLuint name, const GLubyte *comment)
{
	D(bug("nfosmesa: glTraceTextureMESA(%u, %p)", name, comment));
	/* TODO: NFOSMESA_GLTRACETEXTUREMESA may need conversion */
	fn.glTraceTextureMESA(name, comment);
}

void OSMesaDriver::nfglTrackMatrixNV(GLenum target, GLuint address, GLenum matrix, GLenum transform)
{
	D(bug("nfosmesa: glTrackMatrixNV(0x%x, %u, 0x%x, 0x%x)", target, address, matrix, transform));
	fn.glTrackMatrixNV(target, address, matrix, transform);
}

void OSMesaDriver::nfglTransformFeedbackAttribsNV(GLuint count, const GLint *attribs, GLenum bufferMode)
{
	D(bug("nfosmesa: glTransformFeedbackAttribsNV(%u, %p, 0x%x)", count, attribs, bufferMode));
	/* TODO: NFOSMESA_GLTRANSFORMFEEDBACKATTRIBSNV may need conversion */
	fn.glTransformFeedbackAttribsNV(count, attribs, bufferMode);
}

void OSMesaDriver::nfglTransformFeedbackStreamAttribsNV(GLsizei count, const GLint *attribs, GLsizei nbuffers, const GLint *bufstreams, GLenum bufferMode)
{
	D(bug("nfosmesa: glTransformFeedbackStreamAttribsNV(%d, %p, %d, %p, 0x%x)", count, attribs, nbuffers, bufstreams, bufferMode));
	/* TODO: NFOSMESA_GLTRANSFORMFEEDBACKSTREAMATTRIBSNV may need conversion */
	fn.glTransformFeedbackStreamAttribsNV(count, attribs, nbuffers, bufstreams, bufferMode);
}

void OSMesaDriver::nfglTransformFeedbackVaryings(GLuint program, GLsizei count, const GLchar *const *varyings, GLenum bufferMode)
{
	D(bug("nfosmesa: glTransformFeedbackVaryings(%u, %d, %p, 0x%x)", program, count, varyings, bufferMode));
	/* TODO: NFOSMESA_GLTRANSFORMFEEDBACKVARYINGS may need conversion */
	fn.glTransformFeedbackVaryings(program, count, varyings, bufferMode);
}

void OSMesaDriver::nfglTransformFeedbackVaryingsEXT(GLuint program, GLsizei count, const GLchar *const *varyings, GLenum bufferMode)
{
	D(bug("nfosmesa: glTransformFeedbackVaryingsEXT(%u, %d, %p, 0x%x)", program, count, varyings, bufferMode));
	/* TODO: NFOSMESA_GLTRANSFORMFEEDBACKVARYINGSEXT may need conversion */
	fn.glTransformFeedbackVaryingsEXT(program, count, varyings, bufferMode);
}

void OSMesaDriver::nfglTransformFeedbackVaryingsNV(GLuint program, GLsizei count, const GLint *locations, GLenum bufferMode)
{
	D(bug("nfosmesa: glTransformFeedbackVaryingsNV(%u, %d, %p, 0x%x)", program, count, locations, bufferMode));
	/* TODO: NFOSMESA_GLTRANSFORMFEEDBACKVARYINGSNV may need conversion */
	fn.glTransformFeedbackVaryingsNV(program, count, locations, bufferMode);
}

void OSMesaDriver::nfglTransformPathNV(GLuint resultPath, GLuint srcPath, GLenum transformType, const GLfloat *transformValues)
{
	D(bug("nfosmesa: glTransformPathNV(%u, %u, 0x%x, %p)", resultPath, srcPath, transformType, transformValues));
	/* TODO: NFOSMESA_GLTRANSFORMPATHNV may need conversion */
	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);
}

void OSMesaDriver::nfglUniform1dv(GLint location, GLsizei count, const GLdouble *value)
{
	D(bug("nfosmesa: glUniform1dv(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORM1DV may need conversion */
	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);
}

void OSMesaDriver::nfglUniform1fv(GLint location, GLsizei count, const GLfloat *value)
{
	D(bug("nfosmesa: glUniform1fv(%d, %d, %p)", location, count, value));
FN_GLUNIFORM1FV(location, count, value);
}

void OSMesaDriver::nfglUniform1fvARB(GLint location, GLsizei count, const GLfloat *value)
{
	D(bug("nfosmesa: glUniform1fvARB(%d, %d, %p)", location, count, value));
FN_GLUNIFORM1FVARB(location, count, value);
}

void OSMesaDriver::nfglUniform1i(GLint location, GLint v0)
{
	D(bug("nfosmesa: glUniform1i(%d, %d)", location, v0));
	fn.glUniform1i(location, v0);
}

void OSMesaDriver::nfglUniform1i64NV(GLint location, GLint64EXT x)
{
	D(bug("nfosmesa: glUniform1i64NV(%d, %" PRId64 ")", location, x));
	fn.glUniform1i64NV(location, x);
}

void OSMesaDriver::nfglUniform1i64vNV(GLint location, GLsizei count, const GLint64EXT *value)
{
	D(bug("nfosmesa: glUniform1i64vNV(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORM1I64VNV may need conversion */
	fn.glUniform1i64vNV(location, count, value);
}

void OSMesaDriver::nfglUniform1iARB(GLint location, GLint v0)
{
	D(bug("nfosmesa: glUniform1iARB(%d, %d)", location, v0));
	fn.glUniform1iARB(location, v0);
}

void OSMesaDriver::nfglUniform1iv(GLint location, GLsizei count, const GLint *value)
{
	D(bug("nfosmesa: glUniform1iv(%d, %d, %p)", location, count, value));
FN_GLUNIFORM1IV(location, count, value);
}

void OSMesaDriver::nfglUniform1ivARB(GLint location, GLsizei count, const GLint *value)
{
	D(bug("nfosmesa: glUniform1ivARB(%d, %d, %p)", location, count, value));
FN_GLUNIFORM1IVARB(location, count, value);
}

void OSMesaDriver::nfglUniform1ui(GLint location, GLuint v0)
{
	D(bug("nfosmesa: glUniform1ui(%d, %u)", location, v0));
	fn.glUniform1ui(location, v0);
}

void OSMesaDriver::nfglUniform1ui64NV(GLint location, GLuint64EXT x)
{
	D(bug("nfosmesa: glUniform1ui64NV(%d, %" PRIu64 ")", location, x));
	fn.glUniform1ui64NV(location, x);
}

void OSMesaDriver::nfglUniform1ui64vNV(GLint location, GLsizei count, const GLuint64EXT *value)
{
	D(bug("nfosmesa: glUniform1ui64vNV(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORM1UI64VNV may need conversion */
	fn.glUniform1ui64vNV(location, count, value);
}

void OSMesaDriver::nfglUniform1uiEXT(GLint location, GLuint v0)
{
	D(bug("nfosmesa: glUniform1uiEXT(%d, %u)", location, v0));
	fn.glUniform1uiEXT(location, v0);
}

void OSMesaDriver::nfglUniform1uiv(GLint location, GLsizei count, const GLuint *value)
{
	D(bug("nfosmesa: glUniform1uiv(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORM1UIV may need conversion */
	fn.glUniform1uiv(location, count, value);
}

void OSMesaDriver::nfglUniform1uivEXT(GLint location, GLsizei count, const GLuint *value)
{
	D(bug("nfosmesa: glUniform1uivEXT(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORM1UIVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglUniform2dv(GLint location, GLsizei count, const GLdouble *value)
{
	D(bug("nfosmesa: glUniform2dv(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORM2DV may need conversion */
	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);
}

void OSMesaDriver::nfglUniform2fv(GLint location, GLsizei count, const GLfloat *value)
{
	D(bug("nfosmesa: glUniform2fv(%d, %d, %p)", location, count, value));
FN_GLUNIFORM2FV(location, count, value);
}

void OSMesaDriver::nfglUniform2fvARB(GLint location, GLsizei count, const GLfloat *value)
{
	D(bug("nfosmesa: glUniform2fvARB(%d, %d, %p)", location, count, value));
FN_GLUNIFORM2FVARB(location, count, value);
}

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::nfglUniform2i64NV(GLint location, GLint64EXT x, GLint64EXT y)
{
	D(bug("nfosmesa: glUniform2i64NV(%d, %" PRId64 ", %" PRId64 ")", location, x, y));
	fn.glUniform2i64NV(location, x, y);
}

void OSMesaDriver::nfglUniform2i64vNV(GLint location, GLsizei count, const GLint64EXT *value)
{
	D(bug("nfosmesa: glUniform2i64vNV(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORM2I64VNV may need conversion */
	fn.glUniform2i64vNV(location, count, value);
}

void OSMesaDriver::nfglUniform2iARB(GLint location, GLint v0, GLint v1)
{
	D(bug("nfosmesa: glUniform2iARB(%d, %d, %d)", location, v0, v1));
	fn.glUniform2iARB(location, v0, v1);
}

void OSMesaDriver::nfglUniform2iv(GLint location, GLsizei count, const GLint *value)
{
	D(bug("nfosmesa: glUniform2iv(%d, %d, %p)", location, count, value));
FN_GLUNIFORM2IV(location, count, value);
}

void OSMesaDriver::nfglUniform2ivARB(GLint location, GLsizei count, const GLint *value)
{
	D(bug("nfosmesa: glUniform2ivARB(%d, %d, %p)", location, count, value));
FN_GLUNIFORM2IVARB(location, count, value);
}

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::nfglUniform2ui64NV(GLint location, GLuint64EXT x, GLuint64EXT y)
{
	D(bug("nfosmesa: glUniform2ui64NV(%d, %" PRIu64 ", %" PRIu64 ")", location, x, y));
	fn.glUniform2ui64NV(location, x, y);
}

void OSMesaDriver::nfglUniform2ui64vNV(GLint location, GLsizei count, const GLuint64EXT *value)
{
	D(bug("nfosmesa: glUniform2ui64vNV(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORM2UI64VNV may need conversion */
	fn.glUniform2ui64vNV(location, count, value);
}

void OSMesaDriver::nfglUniform2uiEXT(GLint location, GLuint v0, GLuint v1)
{
	D(bug("nfosmesa: glUniform2uiEXT(%d, %u, %u)", location, v0, v1));
	fn.glUniform2uiEXT(location, v0, v1);
}

void OSMesaDriver::nfglUniform2uiv(GLint location, GLsizei count, const GLuint *value)
{
	D(bug("nfosmesa: glUniform2uiv(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORM2UIV may need conversion */
	fn.glUniform2uiv(location, count, value);
}

void OSMesaDriver::nfglUniform2uivEXT(GLint location, GLsizei count, const GLuint *value)
{
	D(bug("nfosmesa: glUniform2uivEXT(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORM2UIVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglUniform3dv(GLint location, GLsizei count, const GLdouble *value)
{
	D(bug("nfosmesa: glUniform3dv(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORM3DV may need conversion */
	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);
}

void OSMesaDriver::nfglUniform3fv(GLint location, GLsizei count, const GLfloat *value)
{
	D(bug("nfosmesa: glUniform3fv(%d, %d, %p)", location, count, value));
FN_GLUNIFORM3FV(location, count, value);
}

void OSMesaDriver::nfglUniform3fvARB(GLint location, GLsizei count, const GLfloat *value)
{
	D(bug("nfosmesa: glUniform3fvARB(%d, %d, %p)", location, count, value));
FN_GLUNIFORM3FVARB(location, count, value);
}

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::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);
}

void OSMesaDriver::nfglUniform3i64vNV(GLint location, GLsizei count, const GLint64EXT *value)
{
	D(bug("nfosmesa: glUniform3i64vNV(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORM3I64VNV may need conversion */
	fn.glUniform3i64vNV(location, count, value);
}

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);
}

void OSMesaDriver::nfglUniform3iv(GLint location, GLsizei count, const GLint *value)
{
	D(bug("nfosmesa: glUniform3iv(%d, %d, %p)", location, count, value));
FN_GLUNIFORM3IV(location, count, value);
}

void OSMesaDriver::nfglUniform3ivARB(GLint location, GLsizei count, const GLint *value)
{
	D(bug("nfosmesa: glUniform3ivARB(%d, %d, %p)", location, count, value));
FN_GLUNIFORM3IVARB(location, count, value);
}

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::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);
}

void OSMesaDriver::nfglUniform3ui64vNV(GLint location, GLsizei count, const GLuint64EXT *value)
{
	D(bug("nfosmesa: glUniform3ui64vNV(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORM3UI64VNV may need conversion */
	fn.glUniform3ui64vNV(location, count, value);
}

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);
}

void OSMesaDriver::nfglUniform3uiv(GLint location, GLsizei count, const GLuint *value)
{
	D(bug("nfosmesa: glUniform3uiv(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORM3UIV may need conversion */
	fn.glUniform3uiv(location, count, value);
}

void OSMesaDriver::nfglUniform3uivEXT(GLint location, GLsizei count, const GLuint *value)
{
	D(bug("nfosmesa: glUniform3uivEXT(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORM3UIVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglUniform4dv(GLint location, GLsizei count, const GLdouble *value)
{
	D(bug("nfosmesa: glUniform4dv(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORM4DV may need conversion */
	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);
}

void OSMesaDriver::nfglUniform4fv(GLint location, GLsizei count, const GLfloat *value)
{
	D(bug("nfosmesa: glUniform4fv(%d, %d, %p)", location, count, value));
FN_GLUNIFORM4FV(location, count, value);
}

void OSMesaDriver::nfglUniform4fvARB(GLint location, GLsizei count, const GLfloat *value)
{
	D(bug("nfosmesa: glUniform4fvARB(%d, %d, %p)", location, count, value));
FN_GLUNIFORM4FVARB(location, count, value);
}

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::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);
}

void OSMesaDriver::nfglUniform4i64vNV(GLint location, GLsizei count, const GLint64EXT *value)
{
	D(bug("nfosmesa: glUniform4i64vNV(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORM4I64VNV may need conversion */
	fn.glUniform4i64vNV(location, count, value);
}

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);
}

void OSMesaDriver::nfglUniform4iv(GLint location, GLsizei count, const GLint *value)
{
	D(bug("nfosmesa: glUniform4iv(%d, %d, %p)", location, count, value));
FN_GLUNIFORM4IV(location, count, value);
}

void OSMesaDriver::nfglUniform4ivARB(GLint location, GLsizei count, const GLint *value)
{
	D(bug("nfosmesa: glUniform4ivARB(%d, %d, %p)", location, count, value));
FN_GLUNIFORM4IVARB(location, count, value);
}

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::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);
}

void OSMesaDriver::nfglUniform4ui64vNV(GLint location, GLsizei count, const GLuint64EXT *value)
{
	D(bug("nfosmesa: glUniform4ui64vNV(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORM4UI64VNV may need conversion */
	fn.glUniform4ui64vNV(location, count, value);
}

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);
}

void OSMesaDriver::nfglUniform4uiv(GLint location, GLsizei count, const GLuint *value)
{
	D(bug("nfosmesa: glUniform4uiv(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORM4UIV may need conversion */
	fn.glUniform4uiv(location, count, value);
}

void OSMesaDriver::nfglUniform4uivEXT(GLint location, GLsizei count, const GLuint *value)
{
	D(bug("nfosmesa: glUniform4uivEXT(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORM4UIVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglUniformHandleui64vARB(GLint location, GLsizei count, const GLuint64 *value)
{
	D(bug("nfosmesa: glUniformHandleui64vARB(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORMHANDLEUI64VARB may need conversion */
	fn.glUniformHandleui64vARB(location, count, value);
}

void OSMesaDriver::nfglUniformHandleui64vNV(GLint location, GLsizei count, const GLuint64 *value)
{
	D(bug("nfosmesa: glUniformHandleui64vNV(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORMHANDLEUI64VNV may need conversion */
	fn.glUniformHandleui64vNV(location, count, value);
}

void OSMesaDriver::nfglUniformMatrix2dv(GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glUniformMatrix2dv(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX2DV may need conversion */
	fn.glUniformMatrix2dv(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformMatrix2fv(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glUniformMatrix2fv(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX2FV may need conversion */
	fn.glUniformMatrix2fv(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformMatrix2fvARB(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glUniformMatrix2fvARB(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX2FVARB may need conversion */
	fn.glUniformMatrix2fvARB(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformMatrix2x3dv(GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glUniformMatrix2x3dv(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX2X3DV may need conversion */
	fn.glUniformMatrix2x3dv(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformMatrix2x3fv(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glUniformMatrix2x3fv(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX2X3FV may need conversion */
	fn.glUniformMatrix2x3fv(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformMatrix2x4dv(GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glUniformMatrix2x4dv(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX2X4DV may need conversion */
	fn.glUniformMatrix2x4dv(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformMatrix2x4fv(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glUniformMatrix2x4fv(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX2X4FV may need conversion */
	fn.glUniformMatrix2x4fv(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformMatrix3dv(GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glUniformMatrix3dv(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX3DV may need conversion */
	fn.glUniformMatrix3dv(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformMatrix3fv(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glUniformMatrix3fv(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX3FV may need conversion */
	fn.glUniformMatrix3fv(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformMatrix3fvARB(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glUniformMatrix3fvARB(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX3FVARB may need conversion */
	fn.glUniformMatrix3fvARB(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformMatrix3x2dv(GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glUniformMatrix3x2dv(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX3X2DV may need conversion */
	fn.glUniformMatrix3x2dv(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformMatrix3x2fv(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glUniformMatrix3x2fv(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX3X2FV may need conversion */
	fn.glUniformMatrix3x2fv(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformMatrix3x4dv(GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glUniformMatrix3x4dv(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX3X4DV may need conversion */
	fn.glUniformMatrix3x4dv(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformMatrix3x4fv(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glUniformMatrix3x4fv(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX3X4FV may need conversion */
	fn.glUniformMatrix3x4fv(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformMatrix4dv(GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glUniformMatrix4dv(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX4DV may need conversion */
	fn.glUniformMatrix4dv(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformMatrix4fv(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glUniformMatrix4fv(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX4FV may need conversion */
	fn.glUniformMatrix4fv(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformMatrix4fvARB(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glUniformMatrix4fvARB(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX4FVARB may need conversion */
	fn.glUniformMatrix4fvARB(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformMatrix4x2dv(GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glUniformMatrix4x2dv(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX4X2DV may need conversion */
	fn.glUniformMatrix4x2dv(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformMatrix4x2fv(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glUniformMatrix4x2fv(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX4X2FV may need conversion */
	fn.glUniformMatrix4x2fv(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformMatrix4x3dv(GLint location, GLsizei count, GLboolean32 transpose, const GLdouble *value)
{
	D(bug("nfosmesa: glUniformMatrix4x3dv(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX4X3DV may need conversion */
	fn.glUniformMatrix4x3dv(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformMatrix4x3fv(GLint location, GLsizei count, GLboolean32 transpose, const GLfloat *value)
{
	D(bug("nfosmesa: glUniformMatrix4x3fv(%d, %d, %d, %p)", location, count, transpose, value));
	/* TODO: NFOSMESA_GLUNIFORMMATRIX4X3FV may need conversion */
	fn.glUniformMatrix4x3fv(location, count, transpose, value);
}

void OSMesaDriver::nfglUniformSubroutinesuiv(GLenum shadertype, GLsizei count, const GLuint *indices)
{
	D(bug("nfosmesa: glUniformSubroutinesuiv(0x%x, %d, %p)", shadertype, count, indices));
	/* TODO: NFOSMESA_GLUNIFORMSUBROUTINESUIV may need conversion */
	fn.glUniformSubroutinesuiv(shadertype, count, indices);
}

void OSMesaDriver::nfglUniformui64NV(GLint location, GLuint64EXT value)
{
	D(bug("nfosmesa: glUniformui64NV(%d, %" PRIu64 ")", location, value));
	fn.glUniformui64NV(location, value);
}

void OSMesaDriver::nfglUniformui64vNV(GLint location, GLsizei count, const GLuint64EXT *value)
{
	D(bug("nfosmesa: glUniformui64vNV(%d, %d, %p)", location, count, value));
	/* TODO: NFOSMESA_GLUNIFORMUI64VNV may need conversion */
	fn.glUniformui64vNV(location, count, value);
}

void OSMesaDriver::nfglUnlockArraysEXT(void)
{
	D(bug("nfosmesa: glUnlockArraysEXT()"));
	fn.glUnlockArraysEXT();
}

GLboolean OSMesaDriver::nfglUnmapBuffer(GLenum target)
{
	D(bug("nfosmesa: glUnmapBuffer(0x%x)", target));
	return fn.glUnmapBuffer(target);
}

GLboolean OSMesaDriver::nfglUnmapBufferARB(GLenum target)
{
	D(bug("nfosmesa: glUnmapBufferARB(0x%x)", target));
	return fn.glUnmapBufferARB(target);
}

GLboolean OSMesaDriver::nfglUnmapNamedBufferEXT(GLuint buffer)
{
	D(bug("nfosmesa: glUnmapNamedBufferEXT(%u)", buffer));
	return fn.glUnmapNamedBufferEXT(buffer);
}

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);
}

void OSMesaDriver::nfglUpdateObjectBufferATI(GLuint buffer, GLuint offset, GLsizei size, const void *pointer, GLenum preserve)
{
	D(bug("nfosmesa: glUpdateObjectBufferATI(%u, %u, %d, %p, 0x%x)", buffer, offset, size, pointer, preserve));
	/* TODO: NFOSMESA_GLUPDATEOBJECTBUFFERATI may need conversion */
	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)", 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(0x%x, %u)", type, program));
	fn.glUseShaderProgramEXT(type, program);
}

void OSMesaDriver::nfglVDPAUFiniNV(void)
{
	D(bug("nfosmesa: glVDPAUFiniNV()"));
	fn.glVDPAUFiniNV();
}

void OSMesaDriver::nfglVDPAUGetSurfaceivNV(GLvdpauSurfaceNV surface, GLenum pname, GLsizei bufSize, GLsizei *length, GLint *values)
{
	D(bug("nfosmesa: glVDPAUGetSurfaceivNV(%ld, 0x%x, %d, %p, %p)", surface, pname, bufSize, length, values));
	/* TODO: NFOSMESA_GLVDPAUGETSURFACEIVNV may need conversion */
	fn.glVDPAUGetSurfaceivNV(surface, pname, bufSize, length, values);
}

void OSMesaDriver::nfglVDPAUInitNV(const void *vdpDevice, const void *getProcAddress)
{
	D(bug("nfosmesa: glVDPAUInitNV(%p, %p)", vdpDevice, getProcAddress));
	/* TODO: NFOSMESA_GLVDPAUINITNV may need conversion */
	fn.glVDPAUInitNV(vdpDevice, getProcAddress);
}

GLboolean OSMesaDriver::nfglVDPAUIsSurfaceNV(GLvdpauSurfaceNV surface)
{
	D(bug("nfosmesa: glVDPAUIsSurfaceNV(%ld)", surface));
	return fn.glVDPAUIsSurfaceNV(surface);
}

void OSMesaDriver::nfglVDPAUMapSurfacesNV(GLsizei numSurfaces, const GLvdpauSurfaceNV *surfaces)
{
	D(bug("nfosmesa: glVDPAUMapSurfacesNV(%d, %p)", numSurfaces, surfaces));
	/* TODO: NFOSMESA_GLVDPAUMAPSURFACESNV may need conversion */
	fn.glVDPAUMapSurfacesNV(numSurfaces, surfaces);
}

GLvdpauSurfaceNV OSMesaDriver::nfglVDPAURegisterOutputSurfaceNV(const void *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames)
{
	D(bug("nfosmesa: glVDPAURegisterOutputSurfaceNV(%p, 0x%x, %d, %p)", vdpSurface, target, numTextureNames, textureNames));
	/* TODO: NFOSMESA_GLVDPAUREGISTEROUTPUTSURFACENV may need conversion */
	return fn.glVDPAURegisterOutputSurfaceNV(vdpSurface, target, numTextureNames, textureNames);
}

GLvdpauSurfaceNV OSMesaDriver::nfglVDPAURegisterVideoSurfaceNV(const void *vdpSurface, GLenum target, GLsizei numTextureNames, const GLuint *textureNames)
{
	D(bug("nfosmesa: glVDPAURegisterVideoSurfaceNV(%p, 0x%x, %d, %p)", vdpSurface, target, numTextureNames, textureNames));
	/* TODO: NFOSMESA_GLVDPAUREGISTERVIDEOSURFACENV may need conversion */
	return fn.glVDPAURegisterVideoSurfaceNV(vdpSurface, target, numTextureNames, textureNames);
}

void OSMesaDriver::nfglVDPAUSurfaceAccessNV(GLvdpauSurfaceNV surface, GLenum access)
{
	D(bug("nfosmesa: glVDPAUSurfaceAccessNV(%ld, 0x%x)", surface, access));
	fn.glVDPAUSurfaceAccessNV(surface, access);
}

void OSMesaDriver::nfglVDPAUUnmapSurfacesNV(GLsizei numSurface, const GLvdpauSurfaceNV *surfaces)
{
	D(bug("nfosmesa: glVDPAUUnmapSurfacesNV(%d, %p)", numSurface, surfaces));
	/* TODO: NFOSMESA_GLVDPAUUNMAPSURFACESNV may need conversion */
	fn.glVDPAUUnmapSurfacesNV(numSurface, surfaces);
}

void OSMesaDriver::nfglVDPAUUnregisterSurfaceNV(GLvdpauSurfaceNV surface)
{
	D(bug("nfosmesa: glVDPAUUnregisterSurfaceNV(%ld)", surface));
	fn.glVDPAUUnregisterSurfaceNV(surface);
}

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

void OSMesaDriver::nfglValidateProgramARB(GLhandleARB programObj)
{
	D(bug("nfosmesa: glValidateProgramARB(%u)", 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, 0x%x, %d, %u, %u)", id, type, stride, buffer, offset));
	fn.glVariantArrayObjectATI(id, type, stride, buffer, offset);
}

void OSMesaDriver::nfglVariantPointerEXT(GLuint id, GLenum type, GLuint stride, const void *addr)
{
	D(bug("nfosmesa: glVariantPointerEXT(%u, 0x%x, %u, %p)", id, type, stride, addr));
	/* TODO: NFOSMESA_GLVARIANTPOINTEREXT may need conversion */
	fn.glVariantPointerEXT(id, type, stride, addr);
}

void OSMesaDriver::nfglVariantbvEXT(GLuint id, const GLbyte *addr)
{
	D(bug("nfosmesa: glVariantbvEXT(%u, %p)", id, addr));
	/* TODO: NFOSMESA_GLVARIANTBVEXT may need conversion */
	fn.glVariantbvEXT(id, addr);
}

void OSMesaDriver::nfglVariantdvEXT(GLuint id, const GLdouble *addr)
{
	D(bug("nfosmesa: glVariantdvEXT(%u, %p)", id, addr));
	/* TODO: NFOSMESA_GLVARIANTDVEXT may need conversion */
	fn.glVariantdvEXT(id, addr);
}

void OSMesaDriver::nfglVariantfvEXT(GLuint id, const GLfloat *addr)
{
	D(bug("nfosmesa: glVariantfvEXT(%u, %p)", id, addr));
	/* TODO: NFOSMESA_GLVARIANTFVEXT may need conversion */
	fn.glVariantfvEXT(id, addr);
}

void OSMesaDriver::nfglVariantivEXT(GLuint id, const GLint *addr)
{
	D(bug("nfosmesa: glVariantivEXT(%u, %p)", id, addr));
	/* TODO: NFOSMESA_GLVARIANTIVEXT may need conversion */
	fn.glVariantivEXT(id, addr);
}

void OSMesaDriver::nfglVariantsvEXT(GLuint id, const GLshort *addr)
{
	D(bug("nfosmesa: glVariantsvEXT(%u, %p)", id, addr));
	/* TODO: NFOSMESA_GLVARIANTSVEXT may need conversion */
	fn.glVariantsvEXT(id, addr);
}

void OSMesaDriver::nfglVariantubvEXT(GLuint id, const GLubyte *addr)
{
	D(bug("nfosmesa: glVariantubvEXT(%u, %p)", id, addr));
	/* TODO: NFOSMESA_GLVARIANTUBVEXT may need conversion */
	fn.glVariantubvEXT(id, addr);
}

void OSMesaDriver::nfglVariantuivEXT(GLuint id, const GLuint *addr)
{
	D(bug("nfosmesa: glVariantuivEXT(%u, %p)", id, addr));
	/* TODO: NFOSMESA_GLVARIANTUIVEXT may need conversion */
	fn.glVariantuivEXT(id, addr);
}

void OSMesaDriver::nfglVariantusvEXT(GLuint id, const GLushort *addr)
{
	D(bug("nfosmesa: glVariantusvEXT(%u, %p)", id, addr));
	/* TODO: NFOSMESA_GLVARIANTUSVEXT may need conversion */
	fn.glVariantusvEXT(id, addr);
}

void OSMesaDriver::nfglVertex2bOES(GLbyte32 x)
{
	D(bug("nfosmesa: glVertex2bOES(%d)", x));
	fn.glVertex2bOES(x);
}

void OSMesaDriver::nfglVertex2bvOES(const GLbyte *coords)
{
	D(bug("nfosmesa: glVertex2bvOES(%p)", coords));
	/* TODO: NFOSMESA_GLVERTEX2BVOES may need conversion */
	fn.glVertex2bvOES(coords);
}

void OSMesaDriver::nfglVertex2d(GLdouble x, GLdouble y)
{
	D(bug("nfosmesa: glVertex2d(%f, %f)", x, y));
	fn.glVertex2d(x, y);
}

void OSMesaDriver::nfglVertex2dv(const GLdouble *v)
{
	D(bug("nfosmesa: glVertex2dv(%p)", v));
FN_GLVERTEX2DV(v);
}

void OSMesaDriver::nfglVertex2f(GLfloat x, GLfloat y)
{
	D(bug("nfosmesa: glVertex2f(%f, %f)", x, y));
	fn.glVertex2f(x, y);
}

void OSMesaDriver::nfglVertex2fv(const GLfloat *v)
{
	D(bug("nfosmesa: glVertex2fv(%p)", v));
FN_GLVERTEX2FV(v);
}

void OSMesaDriver::nfglVertex2hNV(GLhalfNV32 x, GLhalfNV32 y)
{
	D(bug("nfosmesa: glVertex2hNV(%u, %u)", x, y));
	fn.glVertex2hNV(x, y);
}

void OSMesaDriver::nfglVertex2hvNV(const GLhalfNV *v)
{
	D(bug("nfosmesa: glVertex2hvNV(%p)", v));
FN_GLVERTEX2HVNV(v);
}

void OSMesaDriver::nfglVertex2i(GLint x, GLint y)
{
	D(bug("nfosmesa: glVertex2i(%d, %d)", x, y));
	fn.glVertex2i(x, y);
}

void OSMesaDriver::nfglVertex2iv(const GLint *v)
{
	D(bug("nfosmesa: glVertex2iv(%p)", v));
FN_GLVERTEX2IV(v);
}

void OSMesaDriver::nfglVertex2s(GLshort32 x, GLshort32 y)
{
	D(bug("nfosmesa: glVertex2s(%d, %d)", x, y));
	fn.glVertex2s(x, y);
}

void OSMesaDriver::nfglVertex2sv(const GLshort *v)
{
	D(bug("nfosmesa: glVertex2sv(%p)", v));
FN_GLVERTEX2SV(v);
}

void OSMesaDriver::nfglVertex2xOES(GLfixed x)
{
	D(bug("nfosmesa: glVertex2xOES(0x%x)", x));
	fn.glVertex2xOES(x);
}

void OSMesaDriver::nfglVertex2xvOES(const GLfixed *coords)
{
	D(bug("nfosmesa: glVertex2xvOES(%p)", coords));
	/* TODO: NFOSMESA_GLVERTEX2XVOES may need conversion */
	fn.glVertex2xvOES(coords);
}

void OSMesaDriver::nfglVertex3bOES(GLbyte32 x, GLbyte32 y)
{
	D(bug("nfosmesa: glVertex3bOES(%d, %d)", x, y));
	fn.glVertex3bOES(x, y);
}

void OSMesaDriver::nfglVertex3bvOES(const GLbyte *coords)
{
	D(bug("nfosmesa: glVertex3bvOES(%p)", coords));
	/* TODO: NFOSMESA_GLVERTEX3BVOES may need conversion */
	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);
}

void OSMesaDriver::nfglVertex3dv(const GLdouble *v)
{
	D(bug("nfosmesa: glVertex3dv(%p)", 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);
}

void OSMesaDriver::nfglVertex3fv(const GLfloat *v)
{
	D(bug("nfosmesa: glVertex3fv(%p)", 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);
}

void OSMesaDriver::nfglVertex3hvNV(const GLhalfNV *v)
{
	D(bug("nfosmesa: glVertex3hvNV(%p)", 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);
}

void OSMesaDriver::nfglVertex3iv(const GLint *v)
{
	D(bug("nfosmesa: glVertex3iv(%p)", 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);
}

void OSMesaDriver::nfglVertex3sv(const GLshort *v)
{
	D(bug("nfosmesa: glVertex3sv(%p)", 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);
}

void OSMesaDriver::nfglVertex3xvOES(const GLfixed *coords)
{
	D(bug("nfosmesa: glVertex3xvOES(%p)", coords));
	/* TODO: NFOSMESA_GLVERTEX3XVOES may need conversion */
	fn.glVertex3xvOES(coords);
}

void OSMesaDriver::nfglVertex4bOES(GLbyte32 x, GLbyte32 y, GLbyte32 z)
{
	D(bug("nfosmesa: glVertex4bOES(%d, %d, %d)", x, y, z));
	fn.glVertex4bOES(x, y, z);
}

void OSMesaDriver::nfglVertex4bvOES(const GLbyte *coords)
{
	D(bug("nfosmesa: glVertex4bvOES(%p)", coords));
	/* TODO: NFOSMESA_GLVERTEX4BVOES may need conversion */
	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);
}

void OSMesaDriver::nfglVertex4dv(const GLdouble *v)
{
	D(bug("nfosmesa: glVertex4dv(%p)", 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);
}

void OSMesaDriver::nfglVertex4fv(const GLfloat *v)
{
	D(bug("nfosmesa: glVertex4fv(%p)", 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);
}

void OSMesaDriver::nfglVertex4hvNV(const GLhalfNV *v)
{
	D(bug("nfosmesa: glVertex4hvNV(%p)", 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);
}

void OSMesaDriver::nfglVertex4iv(const GLint *v)
{
	D(bug("nfosmesa: glVertex4iv(%p)", 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);
}

void OSMesaDriver::nfglVertex4sv(const GLshort *v)
{
	D(bug("nfosmesa: glVertex4sv(%p)", 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);
}

void OSMesaDriver::nfglVertex4xvOES(const GLfixed *coords)
{
	D(bug("nfosmesa: glVertex4xvOES(%p)", coords));
	/* TODO: NFOSMESA_GLVERTEX4XVOES may need conversion */
	fn.glVertex4xvOES(coords);
}

void OSMesaDriver::nfglVertexArrayBindVertexBufferEXT(GLuint vaobj, GLuint bindingindex, GLuint buffer, GLintptr offset, GLsizei stride)
{
	D(bug("nfosmesa: glVertexArrayBindVertexBufferEXT(%u, %u, %u, %ld, %d)", vaobj, bindingindex, buffer, offset, stride));
	fn.glVertexArrayBindVertexBufferEXT(vaobj, bindingindex, buffer, offset, stride);
}

void OSMesaDriver::nfglVertexArrayColorOffsetEXT(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset)
{
	D(bug("nfosmesa: glVertexArrayColorOffsetEXT(%u, %u, %d, 0x%x, %d, %ld)", vaobj, buffer, size, 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, %ld)", vaobj, buffer, stride, offset));
	fn.glVertexArrayEdgeFlagOffsetEXT(vaobj, buffer, stride, offset);
}

void OSMesaDriver::nfglVertexArrayFogCoordOffsetEXT(GLuint vaobj, GLuint buffer, GLenum type, GLsizei stride, GLintptr offset)
{
	D(bug("nfosmesa: glVertexArrayFogCoordOffsetEXT(%u, %u, 0x%x, %d, %ld)", vaobj, buffer, 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, 0x%x, %d, %ld)", vaobj, buffer, 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, 0x%x, %d, 0x%x, %d, %ld)", vaobj, buffer, texunit, size, 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, 0x%x, %d, %ld)", vaobj, buffer, type, stride, offset));
	fn.glVertexArrayNormalOffsetEXT(vaobj, buffer, type, stride, offset);
}

void OSMesaDriver::nfglVertexArrayParameteriAPPLE(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glVertexArrayParameteriAPPLE(0x%x, %d)", pname, param));
	fn.glVertexArrayParameteriAPPLE(pname, param);
}

void OSMesaDriver::nfglVertexArrayRangeAPPLE(GLsizei length, void *pointer)
{
	D(bug("nfosmesa: glVertexArrayRangeAPPLE(%d, %p)", length, pointer));
	/* TODO: NFOSMESA_GLVERTEXARRAYRANGEAPPLE may need conversion */
	fn.glVertexArrayRangeAPPLE(length, pointer);
}

void OSMesaDriver::nfglVertexArrayRangeNV(GLsizei length, const void *pointer)
{
	D(bug("nfosmesa: glVertexArrayRangeNV(%d, %p)", length, pointer));
	/* TODO: NFOSMESA_GLVERTEXARRAYRANGENV may need conversion */
	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, 0x%x, %d, %ld)", vaobj, buffer, size, 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, 0x%x, %d, %ld)", vaobj, buffer, size, 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, 0x%x, %d, %u)", vaobj, attribindex, size, 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, 0x%x, %u)", vaobj, attribindex, size, 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, 0x%x, %d, %ld)", vaobj, buffer, index, size, 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, 0x%x, %u)", vaobj, attribindex, size, 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, 0x%x, %d, %ld)", vaobj, buffer, index, size, 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, 0x%x, %d, %d, %ld)", vaobj, buffer, index, size, 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::nfglVertexArrayVertexOffsetEXT(GLuint vaobj, GLuint buffer, GLint size, GLenum type, GLsizei stride, GLintptr offset)
{
	D(bug("nfosmesa: glVertexArrayVertexOffsetEXT(%u, %u, %d, 0x%x, %d, %ld)", vaobj, buffer, size, 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);
}

void OSMesaDriver::nfglVertexAttrib1dv(GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttrib1dv(%u, %p)", index, v));
FN_GLVERTEXATTRIB1DV(index, v);
}

void OSMesaDriver::nfglVertexAttrib1dvARB(GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttrib1dvARB(%u, %p)", index, v));
FN_GLVERTEXATTRIB1DVARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib1dvNV(GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttrib1dvNV(%u, %p)", index, 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);
}

void OSMesaDriver::nfglVertexAttrib1fv(GLuint index, const GLfloat *v)
{
	D(bug("nfosmesa: glVertexAttrib1fv(%u, %p)", index, v));
FN_GLVERTEXATTRIB1FV(index, v);
}

void OSMesaDriver::nfglVertexAttrib1fvARB(GLuint index, const GLfloat *v)
{
	D(bug("nfosmesa: glVertexAttrib1fvARB(%u, %p)", index, v));
FN_GLVERTEXATTRIB1FVARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib1fvNV(GLuint index, const GLfloat *v)
{
	D(bug("nfosmesa: glVertexAttrib1fvNV(%u, %p)", index, v));
FN_GLVERTEXATTRIB1FVNV(index, v);
}

void OSMesaDriver::nfglVertexAttrib1hNV(GLuint index, GLhalfNV32 x)
{
	D(bug("nfosmesa: glVertexAttrib1hNV(%u, %u)", index, x));
	fn.glVertexAttrib1hNV(index, x);
}

void OSMesaDriver::nfglVertexAttrib1hvNV(GLuint index, const GLhalfNV *v)
{
	D(bug("nfosmesa: glVertexAttrib1hvNV(%u, %p)", index, 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);
}

void OSMesaDriver::nfglVertexAttrib1sv(GLuint index, const GLshort *v)
{
	D(bug("nfosmesa: glVertexAttrib1sv(%u, %p)", index, v));
FN_GLVERTEXATTRIB1SV(index, v);
}

void OSMesaDriver::nfglVertexAttrib1svARB(GLuint index, const GLshort *v)
{
	D(bug("nfosmesa: glVertexAttrib1svARB(%u, %p)", index, v));
FN_GLVERTEXATTRIB1SVARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib1svNV(GLuint index, const GLshort *v)
{
	D(bug("nfosmesa: glVertexAttrib1svNV(%u, %p)", index, 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);
}

void OSMesaDriver::nfglVertexAttrib2dv(GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttrib2dv(%u, %p)", index, v));
FN_GLVERTEXATTRIB2DV(index, v);
}

void OSMesaDriver::nfglVertexAttrib2dvARB(GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttrib2dvARB(%u, %p)", index, v));
FN_GLVERTEXATTRIB2DVARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib2dvNV(GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttrib2dvNV(%u, %p)", index, 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);
}

void OSMesaDriver::nfglVertexAttrib2fv(GLuint index, const GLfloat *v)
{
	D(bug("nfosmesa: glVertexAttrib2fv(%u, %p)", index, v));
FN_GLVERTEXATTRIB2FV(index, v);
}

void OSMesaDriver::nfglVertexAttrib2fvARB(GLuint index, const GLfloat *v)
{
	D(bug("nfosmesa: glVertexAttrib2fvARB(%u, %p)", index, v));
FN_GLVERTEXATTRIB2FVARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib2fvNV(GLuint index, const GLfloat *v)
{
	D(bug("nfosmesa: glVertexAttrib2fvNV(%u, %p)", index, 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);
}

void OSMesaDriver::nfglVertexAttrib2hvNV(GLuint index, const GLhalfNV *v)
{
	D(bug("nfosmesa: glVertexAttrib2hvNV(%u, %p)", index, 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);
}

void OSMesaDriver::nfglVertexAttrib2sv(GLuint index, const GLshort *v)
{
	D(bug("nfosmesa: glVertexAttrib2sv(%u, %p)", index, v));
FN_GLVERTEXATTRIB2SV(index, v);
}

void OSMesaDriver::nfglVertexAttrib2svARB(GLuint index, const GLshort *v)
{
	D(bug("nfosmesa: glVertexAttrib2svARB(%u, %p)", index, v));
FN_GLVERTEXATTRIB2SVARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib2svNV(GLuint index, const GLshort *v)
{
	D(bug("nfosmesa: glVertexAttrib2svNV(%u, %p)", index, 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);
}

void OSMesaDriver::nfglVertexAttrib3dv(GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttrib3dv(%u, %p)", index, v));
FN_GLVERTEXATTRIB3DV(index, v);
}

void OSMesaDriver::nfglVertexAttrib3dvARB(GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttrib3dvARB(%u, %p)", index, v));
FN_GLVERTEXATTRIB3DVARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib3dvNV(GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttrib3dvNV(%u, %p)", index, 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);
}

void OSMesaDriver::nfglVertexAttrib3fv(GLuint index, const GLfloat *v)
{
	D(bug("nfosmesa: glVertexAttrib3fv(%u, %p)", index, v));
FN_GLVERTEXATTRIB3FV(index, v);
}

void OSMesaDriver::nfglVertexAttrib3fvARB(GLuint index, const GLfloat *v)
{
	D(bug("nfosmesa: glVertexAttrib3fvARB(%u, %p)", index, v));
FN_GLVERTEXATTRIB3FVARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib3fvNV(GLuint index, const GLfloat *v)
{
	D(bug("nfosmesa: glVertexAttrib3fvNV(%u, %p)", index, 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);
}

void OSMesaDriver::nfglVertexAttrib3hvNV(GLuint index, const GLhalfNV *v)
{
	D(bug("nfosmesa: glVertexAttrib3hvNV(%u, %p)", index, 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);
}

void OSMesaDriver::nfglVertexAttrib3sv(GLuint index, const GLshort *v)
{
	D(bug("nfosmesa: glVertexAttrib3sv(%u, %p)", index, v));
FN_GLVERTEXATTRIB3SV(index, v);
}

void OSMesaDriver::nfglVertexAttrib3svARB(GLuint index, const GLshort *v)
{
	D(bug("nfosmesa: glVertexAttrib3svARB(%u, %p)", index, v));
FN_GLVERTEXATTRIB3SVARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib3svNV(GLuint index, const GLshort *v)
{
	D(bug("nfosmesa: glVertexAttrib3svNV(%u, %p)", index, v));
FN_GLVERTEXATTRIB3SVNV(index, v);
}

void OSMesaDriver::nfglVertexAttrib4Nbv(GLuint index, const GLbyte *v)
{
	D(bug("nfosmesa: glVertexAttrib4Nbv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIB4NBV may need conversion */
	fn.glVertexAttrib4Nbv(index, v);
}

void OSMesaDriver::nfglVertexAttrib4NbvARB(GLuint index, const GLbyte *v)
{
	D(bug("nfosmesa: glVertexAttrib4NbvARB(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIB4NBVARB may need conversion */
	fn.glVertexAttrib4NbvARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib4Niv(GLuint index, const GLint *v)
{
	D(bug("nfosmesa: glVertexAttrib4Niv(%u, %p)", index, v));
FN_GLVERTEXATTRIB4NIV(index, v);
}

void OSMesaDriver::nfglVertexAttrib4NivARB(GLuint index, const GLint *v)
{
	D(bug("nfosmesa: glVertexAttrib4NivARB(%u, %p)", index, v));
FN_GLVERTEXATTRIB4NIVARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib4Nsv(GLuint index, const GLshort *v)
{
	D(bug("nfosmesa: glVertexAttrib4Nsv(%u, %p)", index, v));
FN_GLVERTEXATTRIB4NSV(index, v);
}

void OSMesaDriver::nfglVertexAttrib4NsvARB(GLuint index, const GLshort *v)
{
	D(bug("nfosmesa: glVertexAttrib4NsvARB(%u, %p)", index, 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);
}

void OSMesaDriver::nfglVertexAttrib4Nubv(GLuint index, const GLubyte *v)
{
	D(bug("nfosmesa: glVertexAttrib4Nubv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIB4NUBV may need conversion */
	fn.glVertexAttrib4Nubv(index, v);
}

void OSMesaDriver::nfglVertexAttrib4NubvARB(GLuint index, const GLubyte *v)
{
	D(bug("nfosmesa: glVertexAttrib4NubvARB(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIB4NUBVARB may need conversion */
	fn.glVertexAttrib4NubvARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib4Nuiv(GLuint index, const GLuint *v)
{
	D(bug("nfosmesa: glVertexAttrib4Nuiv(%u, %p)", index, v));
FN_GLVERTEXATTRIB4NUIV(index, v);
}

void OSMesaDriver::nfglVertexAttrib4NuivARB(GLuint index, const GLuint *v)
{
	D(bug("nfosmesa: glVertexAttrib4NuivARB(%u, %p)", index, v));
FN_GLVERTEXATTRIB4NUIVARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib4Nusv(GLuint index, const GLushort *v)
{
	D(bug("nfosmesa: glVertexAttrib4Nusv(%u, %p)", index, v));
FN_GLVERTEXATTRIB4NUSV(index, v);
}

void OSMesaDriver::nfglVertexAttrib4NusvARB(GLuint index, const GLushort *v)
{
	D(bug("nfosmesa: glVertexAttrib4NusvARB(%u, %p)", index, v));
FN_GLVERTEXATTRIB4NUSVARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib4bv(GLuint index, const GLbyte *v)
{
	D(bug("nfosmesa: glVertexAttrib4bv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIB4BV may need conversion */
	fn.glVertexAttrib4bv(index, v);
}

void OSMesaDriver::nfglVertexAttrib4bvARB(GLuint index, const GLbyte *v)
{
	D(bug("nfosmesa: glVertexAttrib4bvARB(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIB4BVARB may need conversion */
	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);
}

void OSMesaDriver::nfglVertexAttrib4dv(GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttrib4dv(%u, %p)", index, v));
FN_GLVERTEXATTRIB4DV(index, v);
}

void OSMesaDriver::nfglVertexAttrib4dvARB(GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttrib4dvARB(%u, %p)", index, v));
FN_GLVERTEXATTRIB4DVARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib4dvNV(GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttrib4dvNV(%u, %p)", index, 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);
}

void OSMesaDriver::nfglVertexAttrib4fv(GLuint index, const GLfloat *v)
{
	D(bug("nfosmesa: glVertexAttrib4fv(%u, %p)", index, v));
FN_GLVERTEXATTRIB4FV(index, v);
}

void OSMesaDriver::nfglVertexAttrib4fvARB(GLuint index, const GLfloat *v)
{
	D(bug("nfosmesa: glVertexAttrib4fvARB(%u, %p)", index, v));
FN_GLVERTEXATTRIB4FVARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib4fvNV(GLuint index, const GLfloat *v)
{
	D(bug("nfosmesa: glVertexAttrib4fvNV(%u, %p)", index, 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);
}

void OSMesaDriver::nfglVertexAttrib4hvNV(GLuint index, const GLhalfNV *v)
{
	D(bug("nfosmesa: glVertexAttrib4hvNV(%u, %p)", index, v));
FN_GLVERTEXATTRIB4HVNV(index, v);
}

void OSMesaDriver::nfglVertexAttrib4iv(GLuint index, const GLint *v)
{
	D(bug("nfosmesa: glVertexAttrib4iv(%u, %p)", index, v));
FN_GLVERTEXATTRIB4IV(index, v);
}

void OSMesaDriver::nfglVertexAttrib4ivARB(GLuint index, const GLint *v)
{
	D(bug("nfosmesa: glVertexAttrib4ivARB(%u, %p)", index, 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);
}

void OSMesaDriver::nfglVertexAttrib4sv(GLuint index, const GLshort *v)
{
	D(bug("nfosmesa: glVertexAttrib4sv(%u, %p)", index, v));
FN_GLVERTEXATTRIB4SV(index, v);
}

void OSMesaDriver::nfglVertexAttrib4svARB(GLuint index, const GLshort *v)
{
	D(bug("nfosmesa: glVertexAttrib4svARB(%u, %p)", index, v));
FN_GLVERTEXATTRIB4SVARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib4svNV(GLuint index, const GLshort *v)
{
	D(bug("nfosmesa: glVertexAttrib4svNV(%u, %p)", index, 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);
}

void OSMesaDriver::nfglVertexAttrib4ubv(GLuint index, const GLubyte *v)
{
	D(bug("nfosmesa: glVertexAttrib4ubv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIB4UBV may need conversion */
	fn.glVertexAttrib4ubv(index, v);
}

void OSMesaDriver::nfglVertexAttrib4ubvARB(GLuint index, const GLubyte *v)
{
	D(bug("nfosmesa: glVertexAttrib4ubvARB(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIB4UBVARB may need conversion */
	fn.glVertexAttrib4ubvARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib4ubvNV(GLuint index, const GLubyte *v)
{
	D(bug("nfosmesa: glVertexAttrib4ubvNV(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIB4UBVNV may need conversion */
	fn.glVertexAttrib4ubvNV(index, v);
}

void OSMesaDriver::nfglVertexAttrib4uiv(GLuint index, const GLuint *v)
{
	D(bug("nfosmesa: glVertexAttrib4uiv(%u, %p)", index, v));
FN_GLVERTEXATTRIB4UIV(index, v);
}

void OSMesaDriver::nfglVertexAttrib4uivARB(GLuint index, const GLuint *v)
{
	D(bug("nfosmesa: glVertexAttrib4uivARB(%u, %p)", index, v));
FN_GLVERTEXATTRIB4UIVARB(index, v);
}

void OSMesaDriver::nfglVertexAttrib4usv(GLuint index, const GLushort *v)
{
	D(bug("nfosmesa: glVertexAttrib4usv(%u, %p)", index, v));
FN_GLVERTEXATTRIB4USV(index, v);
}

void OSMesaDriver::nfglVertexAttrib4usvARB(GLuint index, const GLushort *v)
{
	D(bug("nfosmesa: glVertexAttrib4usvARB(%u, %p)", index, 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, 0x%x, %d, %d, %u, %u)", index, size, 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, 0x%x, %d, %u)", attribindex, size, 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, 0x%x, %d, %d)", index, size, 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);
}

void OSMesaDriver::nfglVertexAttribI1iv(GLuint index, const GLint *v)
{
	D(bug("nfosmesa: glVertexAttribI1iv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI1IV may need conversion */
	fn.glVertexAttribI1iv(index, v);
}

void OSMesaDriver::nfglVertexAttribI1ivEXT(GLuint index, const GLint *v)
{
	D(bug("nfosmesa: glVertexAttribI1ivEXT(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI1IVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglVertexAttribI1uiv(GLuint index, const GLuint *v)
{
	D(bug("nfosmesa: glVertexAttribI1uiv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI1UIV may need conversion */
	fn.glVertexAttribI1uiv(index, v);
}

void OSMesaDriver::nfglVertexAttribI1uivEXT(GLuint index, const GLuint *v)
{
	D(bug("nfosmesa: glVertexAttribI1uivEXT(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI1UIVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglVertexAttribI2iv(GLuint index, const GLint *v)
{
	D(bug("nfosmesa: glVertexAttribI2iv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI2IV may need conversion */
	fn.glVertexAttribI2iv(index, v);
}

void OSMesaDriver::nfglVertexAttribI2ivEXT(GLuint index, const GLint *v)
{
	D(bug("nfosmesa: glVertexAttribI2ivEXT(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI2IVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglVertexAttribI2uiv(GLuint index, const GLuint *v)
{
	D(bug("nfosmesa: glVertexAttribI2uiv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI2UIV may need conversion */
	fn.glVertexAttribI2uiv(index, v);
}

void OSMesaDriver::nfglVertexAttribI2uivEXT(GLuint index, const GLuint *v)
{
	D(bug("nfosmesa: glVertexAttribI2uivEXT(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI2UIVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglVertexAttribI3iv(GLuint index, const GLint *v)
{
	D(bug("nfosmesa: glVertexAttribI3iv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI3IV may need conversion */
	fn.glVertexAttribI3iv(index, v);
}

void OSMesaDriver::nfglVertexAttribI3ivEXT(GLuint index, const GLint *v)
{
	D(bug("nfosmesa: glVertexAttribI3ivEXT(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI3IVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglVertexAttribI3uiv(GLuint index, const GLuint *v)
{
	D(bug("nfosmesa: glVertexAttribI3uiv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI3UIV may need conversion */
	fn.glVertexAttribI3uiv(index, v);
}

void OSMesaDriver::nfglVertexAttribI3uivEXT(GLuint index, const GLuint *v)
{
	D(bug("nfosmesa: glVertexAttribI3uivEXT(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI3UIVEXT may need conversion */
	fn.glVertexAttribI3uivEXT(index, v);
}

void OSMesaDriver::nfglVertexAttribI4bv(GLuint index, const GLbyte *v)
{
	D(bug("nfosmesa: glVertexAttribI4bv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI4BV may need conversion */
	fn.glVertexAttribI4bv(index, v);
}

void OSMesaDriver::nfglVertexAttribI4bvEXT(GLuint index, const GLbyte *v)
{
	D(bug("nfosmesa: glVertexAttribI4bvEXT(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI4BVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglVertexAttribI4iv(GLuint index, const GLint *v)
{
	D(bug("nfosmesa: glVertexAttribI4iv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI4IV may need conversion */
	fn.glVertexAttribI4iv(index, v);
}

void OSMesaDriver::nfglVertexAttribI4ivEXT(GLuint index, const GLint *v)
{
	D(bug("nfosmesa: glVertexAttribI4ivEXT(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI4IVEXT may need conversion */
	fn.glVertexAttribI4ivEXT(index, v);
}

void OSMesaDriver::nfglVertexAttribI4sv(GLuint index, const GLshort *v)
{
	D(bug("nfosmesa: glVertexAttribI4sv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI4SV may need conversion */
	fn.glVertexAttribI4sv(index, v);
}

void OSMesaDriver::nfglVertexAttribI4svEXT(GLuint index, const GLshort *v)
{
	D(bug("nfosmesa: glVertexAttribI4svEXT(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI4SVEXT may need conversion */
	fn.glVertexAttribI4svEXT(index, v);
}

void OSMesaDriver::nfglVertexAttribI4ubv(GLuint index, const GLubyte *v)
{
	D(bug("nfosmesa: glVertexAttribI4ubv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI4UBV may need conversion */
	fn.glVertexAttribI4ubv(index, v);
}

void OSMesaDriver::nfglVertexAttribI4ubvEXT(GLuint index, const GLubyte *v)
{
	D(bug("nfosmesa: glVertexAttribI4ubvEXT(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI4UBVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglVertexAttribI4uiv(GLuint index, const GLuint *v)
{
	D(bug("nfosmesa: glVertexAttribI4uiv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI4UIV may need conversion */
	fn.glVertexAttribI4uiv(index, v);
}

void OSMesaDriver::nfglVertexAttribI4uivEXT(GLuint index, const GLuint *v)
{
	D(bug("nfosmesa: glVertexAttribI4uivEXT(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI4UIVEXT may need conversion */
	fn.glVertexAttribI4uivEXT(index, v);
}

void OSMesaDriver::nfglVertexAttribI4usv(GLuint index, const GLushort *v)
{
	D(bug("nfosmesa: glVertexAttribI4usv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI4USV may need conversion */
	fn.glVertexAttribI4usv(index, v);
}

void OSMesaDriver::nfglVertexAttribI4usvEXT(GLuint index, const GLushort *v)
{
	D(bug("nfosmesa: glVertexAttribI4usvEXT(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBI4USVEXT may need conversion */
	fn.glVertexAttribI4usvEXT(index, v);
}

void OSMesaDriver::nfglVertexAttribIFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
{
	D(bug("nfosmesa: glVertexAttribIFormat(%u, %d, 0x%x, %u)", attribindex, size, 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, 0x%x, %d)", index, size, type, stride));
	fn.glVertexAttribIFormatNV(index, size, type, stride);
}

void OSMesaDriver::nfglVertexAttribIPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
{
	D(bug("nfosmesa: glVertexAttribIPointer(%u, %d, 0x%x, %d, %p)", index, size, type, stride, pointer));
	/* TODO: NFOSMESA_GLVERTEXATTRIBIPOINTER may need conversion */
	fn.glVertexAttribIPointer(index, size, type, stride, pointer);
}

void OSMesaDriver::nfglVertexAttribIPointerEXT(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
{
	D(bug("nfosmesa: glVertexAttribIPointerEXT(%u, %d, 0x%x, %d, %p)", index, size, type, stride, pointer));
	/* TODO: NFOSMESA_GLVERTEXATTRIBIPOINTEREXT may need conversion */
	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);
}

void OSMesaDriver::nfglVertexAttribL1dv(GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttribL1dv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBL1DV may need conversion */
	fn.glVertexAttribL1dv(index, v);
}

void OSMesaDriver::nfglVertexAttribL1dvEXT(GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttribL1dvEXT(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBL1DVEXT may need conversion */
	fn.glVertexAttribL1dvEXT(index, v);
}

void OSMesaDriver::nfglVertexAttribL1i64NV(GLuint index, GLint64EXT x)
{
	D(bug("nfosmesa: glVertexAttribL1i64NV(%u, %" PRId64 ")", index, x));
	fn.glVertexAttribL1i64NV(index, x);
}

void OSMesaDriver::nfglVertexAttribL1i64vNV(GLuint index, const GLint64EXT *v)
{
	D(bug("nfosmesa: glVertexAttribL1i64vNV(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBL1I64VNV may need conversion */
	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);
}

void OSMesaDriver::nfglVertexAttribL1ui64vARB(GLuint index, const GLuint64EXT *v)
{
	D(bug("nfosmesa: glVertexAttribL1ui64vARB(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBL1UI64VARB may need conversion */
	fn.glVertexAttribL1ui64vARB(index, v);
}

void OSMesaDriver::nfglVertexAttribL1ui64vNV(GLuint index, const GLuint64EXT *v)
{
	D(bug("nfosmesa: glVertexAttribL1ui64vNV(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBL1UI64VNV may need conversion */
	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);
}

void OSMesaDriver::nfglVertexAttribL2dv(GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttribL2dv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBL2DV may need conversion */
	fn.glVertexAttribL2dv(index, v);
}

void OSMesaDriver::nfglVertexAttribL2dvEXT(GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttribL2dvEXT(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBL2DVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglVertexAttribL2i64vNV(GLuint index, const GLint64EXT *v)
{
	D(bug("nfosmesa: glVertexAttribL2i64vNV(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBL2I64VNV may need conversion */
	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);
}

void OSMesaDriver::nfglVertexAttribL2ui64vNV(GLuint index, const GLuint64EXT *v)
{
	D(bug("nfosmesa: glVertexAttribL2ui64vNV(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBL2UI64VNV may need conversion */
	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);
}

void OSMesaDriver::nfglVertexAttribL3dv(GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttribL3dv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBL3DV may need conversion */
	fn.glVertexAttribL3dv(index, v);
}

void OSMesaDriver::nfglVertexAttribL3dvEXT(GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttribL3dvEXT(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBL3DVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglVertexAttribL3i64vNV(GLuint index, const GLint64EXT *v)
{
	D(bug("nfosmesa: glVertexAttribL3i64vNV(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBL3I64VNV may need conversion */
	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);
}

void OSMesaDriver::nfglVertexAttribL3ui64vNV(GLuint index, const GLuint64EXT *v)
{
	D(bug("nfosmesa: glVertexAttribL3ui64vNV(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBL3UI64VNV may need conversion */
	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);
}

void OSMesaDriver::nfglVertexAttribL4dv(GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttribL4dv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBL4DV may need conversion */
	fn.glVertexAttribL4dv(index, v);
}

void OSMesaDriver::nfglVertexAttribL4dvEXT(GLuint index, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttribL4dvEXT(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBL4DVEXT may need conversion */
	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);
}

void OSMesaDriver::nfglVertexAttribL4i64vNV(GLuint index, const GLint64EXT *v)
{
	D(bug("nfosmesa: glVertexAttribL4i64vNV(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBL4I64VNV may need conversion */
	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);
}

void OSMesaDriver::nfglVertexAttribL4ui64vNV(GLuint index, const GLuint64EXT *v)
{
	D(bug("nfosmesa: glVertexAttribL4ui64vNV(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBL4UI64VNV may need conversion */
	fn.glVertexAttribL4ui64vNV(index, v);
}

void OSMesaDriver::nfglVertexAttribLFormat(GLuint attribindex, GLint size, GLenum type, GLuint relativeoffset)
{
	D(bug("nfosmesa: glVertexAttribLFormat(%u, %d, 0x%x, %u)", attribindex, size, 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, 0x%x, %d)", index, size, type, stride));
	fn.glVertexAttribLFormatNV(index, size, type, stride);
}

void OSMesaDriver::nfglVertexAttribLPointer(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
{
	D(bug("nfosmesa: glVertexAttribLPointer(%u, %d, 0x%x, %d, %p)", index, size, type, stride, pointer));
	/* TODO: NFOSMESA_GLVERTEXATTRIBLPOINTER may need conversion */
	fn.glVertexAttribLPointer(index, size, type, stride, pointer);
}

void OSMesaDriver::nfglVertexAttribLPointerEXT(GLuint index, GLint size, GLenum type, GLsizei stride, const void *pointer)
{
	D(bug("nfosmesa: glVertexAttribLPointerEXT(%u, %d, 0x%x, %d, %p)", index, size, type, stride, pointer));
	/* TODO: NFOSMESA_GLVERTEXATTRIBLPOINTEREXT may need conversion */
	fn.glVertexAttribLPointerEXT(index, size, type, stride, pointer);
}

void OSMesaDriver::nfglVertexAttribP1ui(GLuint index, GLenum type, GLboolean32 normalized, GLuint value)
{
	D(bug("nfosmesa: glVertexAttribP1ui(%u, 0x%x, %d, %u)", index, type, normalized, value));
	fn.glVertexAttribP1ui(index, type, normalized, value);
}

void OSMesaDriver::nfglVertexAttribP1uiv(GLuint index, GLenum type, GLboolean32 normalized, const GLuint *value)
{
	D(bug("nfosmesa: glVertexAttribP1uiv(%u, 0x%x, %d, %p)", index, type, normalized, value));
	/* TODO: NFOSMESA_GLVERTEXATTRIBP1UIV may need conversion */
	fn.glVertexAttribP1uiv(index, type, normalized, value);
}

void OSMesaDriver::nfglVertexAttribP2ui(GLuint index, GLenum type, GLboolean32 normalized, GLuint value)
{
	D(bug("nfosmesa: glVertexAttribP2ui(%u, 0x%x, %d, %u)", index, type, normalized, value));
	fn.glVertexAttribP2ui(index, type, normalized, value);
}

void OSMesaDriver::nfglVertexAttribP2uiv(GLuint index, GLenum type, GLboolean32 normalized, const GLuint *value)
{
	D(bug("nfosmesa: glVertexAttribP2uiv(%u, 0x%x, %d, %p)", index, type, normalized, value));
	/* TODO: NFOSMESA_GLVERTEXATTRIBP2UIV may need conversion */
	fn.glVertexAttribP2uiv(index, type, normalized, value);
}

void OSMesaDriver::nfglVertexAttribP3ui(GLuint index, GLenum type, GLboolean32 normalized, GLuint value)
{
	D(bug("nfosmesa: glVertexAttribP3ui(%u, 0x%x, %d, %u)", index, type, normalized, value));
	fn.glVertexAttribP3ui(index, type, normalized, value);
}

void OSMesaDriver::nfglVertexAttribP3uiv(GLuint index, GLenum type, GLboolean32 normalized, const GLuint *value)
{
	D(bug("nfosmesa: glVertexAttribP3uiv(%u, 0x%x, %d, %p)", index, type, normalized, value));
	/* TODO: NFOSMESA_GLVERTEXATTRIBP3UIV may need conversion */
	fn.glVertexAttribP3uiv(index, type, normalized, value);
}

void OSMesaDriver::nfglVertexAttribP4ui(GLuint index, GLenum type, GLboolean32 normalized, GLuint value)
{
	D(bug("nfosmesa: glVertexAttribP4ui(%u, 0x%x, %d, %u)", index, type, normalized, value));
	fn.glVertexAttribP4ui(index, type, normalized, value);
}

void OSMesaDriver::nfglVertexAttribP4uiv(GLuint index, GLenum type, GLboolean32 normalized, const GLuint *value)
{
	D(bug("nfosmesa: glVertexAttribP4uiv(%u, 0x%x, %d, %p)", index, type, normalized, value));
	/* TODO: NFOSMESA_GLVERTEXATTRIBP4UIV may need conversion */
	fn.glVertexAttribP4uiv(index, type, normalized, value);
}

void OSMesaDriver::nfglVertexAttribParameteriAMD(GLuint index, GLenum pname, GLint param)
{
	D(bug("nfosmesa: glVertexAttribParameteriAMD(%u, 0x%x, %d)", index, pname, param));
	fn.glVertexAttribParameteriAMD(index, pname, param);
}

void OSMesaDriver::nfglVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean32 normalized, GLsizei stride, const void *pointer)
{
	D(bug("nfosmesa: glVertexAttribPointer(%u, %d, 0x%x, %d, %d, %p)", index, size, type, normalized, stride, pointer));
	/* TODO: NFOSMESA_GLVERTEXATTRIBPOINTER may need conversion */
	fn.glVertexAttribPointer(index, size, type, normalized, stride, pointer);
}

void OSMesaDriver::nfglVertexAttribPointerARB(GLuint index, GLint size, GLenum type, GLboolean32 normalized, GLsizei stride, const void *pointer)
{
	D(bug("nfosmesa: glVertexAttribPointerARB(%u, %d, 0x%x, %d, %d, %p)", index, size, type, normalized, stride, pointer));
	/* TODO: NFOSMESA_GLVERTEXATTRIBPOINTERARB may need conversion */
	fn.glVertexAttribPointerARB(index, size, type, normalized, stride, pointer);
}

void OSMesaDriver::nfglVertexAttribPointerNV(GLuint index, GLint fsize, GLenum type, GLsizei stride, const void *pointer)
{
	D(bug("nfosmesa: glVertexAttribPointerNV(%u, %d, 0x%x, %d, %p)", index, fsize, type, stride, pointer));
	/* TODO: NFOSMESA_GLVERTEXATTRIBPOINTERNV may need conversion */
	fn.glVertexAttribPointerNV(index, fsize, type, stride, pointer);
}

void OSMesaDriver::nfglVertexAttribs1dvNV(GLuint index, GLsizei count, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttribs1dvNV(%u, %d, %p)", index, count, v));
FN_GLVERTEXATTRIBS1DVNV(index, count, v);
}

void OSMesaDriver::nfglVertexAttribs1fvNV(GLuint index, GLsizei count, const GLfloat *v)
{
	D(bug("nfosmesa: glVertexAttribs1fvNV(%u, %d, %p)", index, count, v));
FN_GLVERTEXATTRIBS1FVNV(index, count, v);
}

void OSMesaDriver::nfglVertexAttribs1hvNV(GLuint index, GLsizei n, const GLhalfNV *v)
{
	D(bug("nfosmesa: glVertexAttribs1hvNV(%u, %d, %p)", index, n, v));
FN_GLVERTEXATTRIBS1HVNV(index, n, v);
}

void OSMesaDriver::nfglVertexAttribs1svNV(GLuint index, GLsizei count, const GLshort *v)
{
	D(bug("nfosmesa: glVertexAttribs1svNV(%u, %d, %p)", index, count, v));
FN_GLVERTEXATTRIBS1SVNV(index, count, v);
}

void OSMesaDriver::nfglVertexAttribs2dvNV(GLuint index, GLsizei count, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttribs2dvNV(%u, %d, %p)", index, count, v));
FN_GLVERTEXATTRIBS2DVNV(index, count, v);
}

void OSMesaDriver::nfglVertexAttribs2fvNV(GLuint index, GLsizei count, const GLfloat *v)
{
	D(bug("nfosmesa: glVertexAttribs2fvNV(%u, %d, %p)", index, count, v));
FN_GLVERTEXATTRIBS2FVNV(index, count, v);
}

void OSMesaDriver::nfglVertexAttribs2hvNV(GLuint index, GLsizei n, const GLhalfNV *v)
{
	D(bug("nfosmesa: glVertexAttribs2hvNV(%u, %d, %p)", index, n, v));
FN_GLVERTEXATTRIBS2HVNV(index, n, v);
}

void OSMesaDriver::nfglVertexAttribs2svNV(GLuint index, GLsizei count, const GLshort *v)
{
	D(bug("nfosmesa: glVertexAttribs2svNV(%u, %d, %p)", index, count, v));
FN_GLVERTEXATTRIBS2SVNV(index, count, v);
}

void OSMesaDriver::nfglVertexAttribs3dvNV(GLuint index, GLsizei count, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttribs3dvNV(%u, %d, %p)", index, count, v));
FN_GLVERTEXATTRIBS3DVNV(index, count, v);
}

void OSMesaDriver::nfglVertexAttribs3fvNV(GLuint index, GLsizei count, const GLfloat *v)
{
	D(bug("nfosmesa: glVertexAttribs3fvNV(%u, %d, %p)", index, count, v));
FN_GLVERTEXATTRIBS3FVNV(index, count, v);
}

void OSMesaDriver::nfglVertexAttribs3hvNV(GLuint index, GLsizei n, const GLhalfNV *v)
{
	D(bug("nfosmesa: glVertexAttribs3hvNV(%u, %d, %p)", index, n, v));
FN_GLVERTEXATTRIBS3HVNV(index, n, v);
}

void OSMesaDriver::nfglVertexAttribs3svNV(GLuint index, GLsizei count, const GLshort *v)
{
	D(bug("nfosmesa: glVertexAttribs3svNV(%u, %d, %p)", index, count, v));
FN_GLVERTEXATTRIBS3SVNV(index, count, v);
}

void OSMesaDriver::nfglVertexAttribs4dvNV(GLuint index, GLsizei count, const GLdouble *v)
{
	D(bug("nfosmesa: glVertexAttribs4dvNV(%u, %d, %p)", index, count, v));
FN_GLVERTEXATTRIBS4DVNV(index, count, v);
}

void OSMesaDriver::nfglVertexAttribs4fvNV(GLuint index, GLsizei count, const GLfloat *v)
{
	D(bug("nfosmesa: glVertexAttribs4fvNV(%u, %d, %p)", index, count, v));
FN_GLVERTEXATTRIBS4FVNV(index, count, v);
}

void OSMesaDriver::nfglVertexAttribs4hvNV(GLuint index, GLsizei n, const GLhalfNV *v)
{
	D(bug("nfosmesa: glVertexAttribs4hvNV(%u, %d, %p)", index, n, v));
FN_GLVERTEXATTRIBS4HVNV(index, n, v);
}

void OSMesaDriver::nfglVertexAttribs4svNV(GLuint index, GLsizei count, const GLshort *v)
{
	D(bug("nfosmesa: glVertexAttribs4svNV(%u, %d, %p)", index, count, v));
FN_GLVERTEXATTRIBS4SVNV(index, count, v);
}

void OSMesaDriver::nfglVertexAttribs4ubvNV(GLuint index, GLsizei count, const GLubyte *v)
{
	D(bug("nfosmesa: glVertexAttribs4ubvNV(%u, %d, %p)", index, count, v));
	/* TODO: NFOSMESA_GLVERTEXATTRIBS4UBVNV may need conversion */
	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(0x%x, %f)", pname, param));
	fn.glVertexBlendEnvfATI(pname, param);
}

void OSMesaDriver::nfglVertexBlendEnviATI(GLenum pname, GLint param)
{
	D(bug("nfosmesa: glVertexBlendEnviATI(0x%x, %d)", pname, param));
	fn.glVertexBlendEnviATI(pname, param);
}

void OSMesaDriver::nfglVertexFormatNV(GLint size, GLenum type, GLsizei stride)
{
	D(bug("nfosmesa: glVertexFormatNV(%d, 0x%x, %d)", size, type, stride));
	fn.glVertexFormatNV(size, type, stride);
}

void OSMesaDriver::nfglVertexP2ui(GLenum type, GLuint value)
{
	D(bug("nfosmesa: glVertexP2ui(0x%x, %u)", type, value));
	fn.glVertexP2ui(type, value);
}

void OSMesaDriver::nfglVertexP2uiv(GLenum type, const GLuint *value)
{
	D(bug("nfosmesa: glVertexP2uiv(0x%x, %p)", type, value));
	/* TODO: NFOSMESA_GLVERTEXP2UIV may need conversion */
	fn.glVertexP2uiv(type, value);
}

void OSMesaDriver::nfglVertexP3ui(GLenum type, GLuint value)
{
	D(bug("nfosmesa: glVertexP3ui(0x%x, %u)", type, value));
	fn.glVertexP3ui(type, value);
}

void OSMesaDriver::nfglVertexP3uiv(GLenum type, const GLuint *value)
{
	D(bug("nfosmesa: glVertexP3uiv(0x%x, %p)", type, value));
	/* TODO: NFOSMESA_GLVERTEXP3UIV may need conversion */
	fn.glVertexP3uiv(type, value);
}

void OSMesaDriver::nfglVertexP4ui(GLenum type, GLuint value)
{
	D(bug("nfosmesa: glVertexP4ui(0x%x, %u)", type, value));
	fn.glVertexP4ui(type, value);
}

void OSMesaDriver::nfglVertexP4uiv(GLenum type, const GLuint *value)
{
	D(bug("nfosmesa: glVertexP4uiv(0x%x, %p)", type, value));
	/* TODO: NFOSMESA_GLVERTEXP4UIV may need conversion */
	fn.glVertexP4uiv(type, value);
}

void OSMesaDriver::nfglVertexPointSizefAPPLE(GLfloat size)
{
	D(bug("nfosmesa: glVertexPointSizefAPPLE(%f)", size));
	fn.glVertexPointSizefAPPLE(size);
}

void OSMesaDriver::nfglVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
{
	D(bug("nfosmesa: glVertexPointer(%d, 0x%x, %d, %p)", size, type, stride, pointer));
FN_GLVERTEXPOINTER(size, type, stride, pointer);
}

void OSMesaDriver::nfglVertexPointerEXT(GLint size, GLenum type, GLsizei stride, GLsizei count, const void *pointer)
{
	D(bug("nfosmesa: glVertexPointerEXT(%d, 0x%x, %d, %d, %p)", size, type, stride, count, pointer));
FN_GLVERTEXPOINTEREXT(size, type, stride, count, pointer);
}

void OSMesaDriver::nfglVertexPointerListIBM(GLint size, GLenum type, GLint stride, const void * *pointer, GLint ptrstride)
{
	D(bug("nfosmesa: glVertexPointerListIBM(%d, 0x%x, %d, %p, %d)", size, type, stride, pointer, ptrstride));
	/* TODO: NFOSMESA_GLVERTEXPOINTERLISTIBM may need conversion */
	fn.glVertexPointerListIBM(size, type, stride, pointer, ptrstride);
}

void OSMesaDriver::nfglVertexPointervINTEL(GLint size, GLenum type, const void * *pointer)
{
	D(bug("nfosmesa: glVertexPointervINTEL(%d, 0x%x, %p)", size, type, pointer));
	/* TODO: NFOSMESA_GLVERTEXPOINTERVINTEL may need conversion */
	fn.glVertexPointervINTEL(size, type, pointer);
}

void OSMesaDriver::nfglVertexStream1dATI(GLenum stream, GLdouble x)
{
	D(bug("nfosmesa: glVertexStream1dATI(0x%x, %f)", stream, x));
	fn.glVertexStream1dATI(stream, x);
}

void OSMesaDriver::nfglVertexStream1dvATI(GLenum stream, const GLdouble *coords)
{
	D(bug("nfosmesa: glVertexStream1dvATI(0x%x, %p)", stream, coords));
FN_GLVERTEXSTREAM1DVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream1fATI(GLenum stream, GLfloat x)
{
	D(bug("nfosmesa: glVertexStream1fATI(0x%x, %f)", stream, x));
	fn.glVertexStream1fATI(stream, x);
}

void OSMesaDriver::nfglVertexStream1fvATI(GLenum stream, const GLfloat *coords)
{
	D(bug("nfosmesa: glVertexStream1fvATI(0x%x, %p)", stream, coords));
FN_GLVERTEXSTREAM1FVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream1iATI(GLenum stream, GLint x)
{
	D(bug("nfosmesa: glVertexStream1iATI(0x%x, %d)", stream, x));
	fn.glVertexStream1iATI(stream, x);
}

void OSMesaDriver::nfglVertexStream1ivATI(GLenum stream, const GLint *coords)
{
	D(bug("nfosmesa: glVertexStream1ivATI(0x%x, %p)", stream, coords));
FN_GLVERTEXSTREAM1IVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream1sATI(GLenum stream, GLshort32 x)
{
	D(bug("nfosmesa: glVertexStream1sATI(0x%x, %d)", stream, x));
	fn.glVertexStream1sATI(stream, x);
}

void OSMesaDriver::nfglVertexStream1svATI(GLenum stream, const GLshort *coords)
{
	D(bug("nfosmesa: glVertexStream1svATI(0x%x, %p)", stream, coords));
FN_GLVERTEXSTREAM1SVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream2dATI(GLenum stream, GLdouble x, GLdouble y)
{
	D(bug("nfosmesa: glVertexStream2dATI(0x%x, %f, %f)", stream, x, y));
	fn.glVertexStream2dATI(stream, x, y);
}

void OSMesaDriver::nfglVertexStream2dvATI(GLenum stream, const GLdouble *coords)
{
	D(bug("nfosmesa: glVertexStream2dvATI(0x%x, %p)", stream, coords));
FN_GLVERTEXSTREAM2DVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream2fATI(GLenum stream, GLfloat x, GLfloat y)
{
	D(bug("nfosmesa: glVertexStream2fATI(0x%x, %f, %f)", stream, x, y));
	fn.glVertexStream2fATI(stream, x, y);
}

void OSMesaDriver::nfglVertexStream2fvATI(GLenum stream, const GLfloat *coords)
{
	D(bug("nfosmesa: glVertexStream2fvATI(0x%x, %p)", stream, coords));
FN_GLVERTEXSTREAM2FVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream2iATI(GLenum stream, GLint x, GLint y)
{
	D(bug("nfosmesa: glVertexStream2iATI(0x%x, %d, %d)", stream, x, y));
	fn.glVertexStream2iATI(stream, x, y);
}

void OSMesaDriver::nfglVertexStream2ivATI(GLenum stream, const GLint *coords)
{
	D(bug("nfosmesa: glVertexStream2ivATI(0x%x, %p)", stream, coords));
FN_GLVERTEXSTREAM2IVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream2sATI(GLenum stream, GLshort32 x, GLshort32 y)
{
	D(bug("nfosmesa: glVertexStream2sATI(0x%x, %d, %d)", stream, x, y));
	fn.glVertexStream2sATI(stream, x, y);
}

void OSMesaDriver::nfglVertexStream2svATI(GLenum stream, const GLshort *coords)
{
	D(bug("nfosmesa: glVertexStream2svATI(0x%x, %p)", stream, coords));
FN_GLVERTEXSTREAM2SVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream3dATI(GLenum stream, GLdouble x, GLdouble y, GLdouble z)
{
	D(bug("nfosmesa: glVertexStream3dATI(0x%x, %f, %f, %f)", stream, x, y, z));
	fn.glVertexStream3dATI(stream, x, y, z);
}

void OSMesaDriver::nfglVertexStream3dvATI(GLenum stream, const GLdouble *coords)
{
	D(bug("nfosmesa: glVertexStream3dvATI(0x%x, %p)", stream, coords));
FN_GLVERTEXSTREAM3DVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream3fATI(GLenum stream, GLfloat x, GLfloat y, GLfloat z)
{
	D(bug("nfosmesa: glVertexStream3fATI(0x%x, %f, %f, %f)", stream, x, y, z));
	fn.glVertexStream3fATI(stream, x, y, z);
}

void OSMesaDriver::nfglVertexStream3fvATI(GLenum stream, const GLfloat *coords)
{
	D(bug("nfosmesa: glVertexStream3fvATI(0x%x, %p)", stream, coords));
FN_GLVERTEXSTREAM3FVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream3iATI(GLenum stream, GLint x, GLint y, GLint z)
{
	D(bug("nfosmesa: glVertexStream3iATI(0x%x, %d, %d, %d)", stream, x, y, z));
	fn.glVertexStream3iATI(stream, x, y, z);
}

void OSMesaDriver::nfglVertexStream3ivATI(GLenum stream, const GLint *coords)
{
	D(bug("nfosmesa: glVertexStream3ivATI(0x%x, %p)", stream, coords));
FN_GLVERTEXSTREAM3IVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream3sATI(GLenum stream, GLshort32 x, GLshort32 y, GLshort32 z)
{
	D(bug("nfosmesa: glVertexStream3sATI(0x%x, %d, %d, %d)", stream, x, y, z));
	fn.glVertexStream3sATI(stream, x, y, z);
}

void OSMesaDriver::nfglVertexStream3svATI(GLenum stream, const GLshort *coords)
{
	D(bug("nfosmesa: glVertexStream3svATI(0x%x, %p)", stream, coords));
FN_GLVERTEXSTREAM3SVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream4dATI(GLenum stream, GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
	D(bug("nfosmesa: glVertexStream4dATI(0x%x, %f, %f, %f, %f)", stream, x, y, z, w));
	fn.glVertexStream4dATI(stream, x, y, z, w);
}

void OSMesaDriver::nfglVertexStream4dvATI(GLenum stream, const GLdouble *coords)
{
	D(bug("nfosmesa: glVertexStream4dvATI(0x%x, %p)", stream, coords));
FN_GLVERTEXSTREAM4DVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream4fATI(GLenum stream, GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
	D(bug("nfosmesa: glVertexStream4fATI(0x%x, %f, %f, %f, %f)", stream, x, y, z, w));
	fn.glVertexStream4fATI(stream, x, y, z, w);
}

void OSMesaDriver::nfglVertexStream4fvATI(GLenum stream, const GLfloat *coords)
{
	D(bug("nfosmesa: glVertexStream4fvATI(0x%x, %p)", stream, coords));
FN_GLVERTEXSTREAM4FVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream4iATI(GLenum stream, GLint x, GLint y, GLint z, GLint w)
{
	D(bug("nfosmesa: glVertexStream4iATI(0x%x, %d, %d, %d, %d)", stream, x, y, z, w));
	fn.glVertexStream4iATI(stream, x, y, z, w);
}

void OSMesaDriver::nfglVertexStream4ivATI(GLenum stream, const GLint *coords)
{
	D(bug("nfosmesa: glVertexStream4ivATI(0x%x, %p)", stream, coords));
FN_GLVERTEXSTREAM4IVATI(stream, coords);
}

void OSMesaDriver::nfglVertexStream4sATI(GLenum stream, GLshort32 x, GLshort32 y, GLshort32 z, GLshort32 w)
{
	D(bug("nfosmesa: glVertexStream4sATI(0x%x, %d, %d, %d, %d)", stream, x, y, z, w));
	fn.glVertexStream4sATI(stream, x, y, z, w);
}

void OSMesaDriver::nfglVertexStream4svATI(GLenum stream, const GLshort *coords)
{
	D(bug("nfosmesa: glVertexStream4svATI(0x%x, %p)", stream, coords));
FN_GLVERTEXSTREAM4SVATI(stream, coords);
}

void OSMesaDriver::nfglVertexWeightPointerEXT(GLint size, GLenum type, GLsizei stride, const void *pointer)
{
	D(bug("nfosmesa: glVertexWeightPointerEXT(%d, 0x%x, %d, %p)", size, type, stride, pointer));
	/* TODO: NFOSMESA_GLVERTEXWEIGHTPOINTEREXT may need conversion */
	fn.glVertexWeightPointerEXT(size, type, stride, pointer);
}

void OSMesaDriver::nfglVertexWeightfEXT(GLfloat weight)
{
	D(bug("nfosmesa: glVertexWeightfEXT(%f)", weight));
	fn.glVertexWeightfEXT(weight);
}

void OSMesaDriver::nfglVertexWeightfvEXT(const GLfloat *weight)
{
	D(bug("nfosmesa: glVertexWeightfvEXT(%p)", weight));
FN_GLVERTEXWEIGHTFVEXT(weight);
}

void OSMesaDriver::nfglVertexWeighthNV(GLhalfNV32 weight)
{
	D(bug("nfosmesa: glVertexWeighthNV(%u)", weight));
	fn.glVertexWeighthNV(weight);
}

void OSMesaDriver::nfglVertexWeighthvNV(const GLhalfNV *weight)
{
	D(bug("nfosmesa: glVertexWeighthvNV(%p)", weight));
FN_GLVERTEXWEIGHTHVNV(weight);
}

GLenum OSMesaDriver::nfglVideoCaptureNV(GLuint video_capture_slot, GLuint *sequence_num, GLuint64EXT *capture_time)
{
	D(bug("nfosmesa: glVideoCaptureNV(%u, %p, %p)", video_capture_slot, sequence_num, capture_time));
	/* TODO: NFOSMESA_GLVIDEOCAPTURENV may need conversion */
	return fn.glVideoCaptureNV(video_capture_slot, sequence_num, capture_time);
}

void OSMesaDriver::nfglVideoCaptureStreamParameterdvNV(GLuint video_capture_slot, GLuint stream, GLenum pname, const GLdouble *params)
{
	D(bug("nfosmesa: glVideoCaptureStreamParameterdvNV(%u, %u, 0x%x, %p)", video_capture_slot, stream, pname, params));
	/* TODO: NFOSMESA_GLVIDEOCAPTURESTREAMPARAMETERDVNV may need conversion */
	fn.glVideoCaptureStreamParameterdvNV(video_capture_slot, stream, pname, params);
}

void OSMesaDriver::nfglVideoCaptureStreamParameterfvNV(GLuint video_capture_slot, GLuint stream, GLenum pname, const GLfloat *params)
{
	D(bug("nfosmesa: glVideoCaptureStreamParameterfvNV(%u, %u, 0x%x, %p)", video_capture_slot, stream, pname, params));
	/* TODO: NFOSMESA_GLVIDEOCAPTURESTREAMPARAMETERFVNV may need conversion */
	fn.glVideoCaptureStreamParameterfvNV(video_capture_slot, stream, pname, params);
}

void OSMesaDriver::nfglVideoCaptureStreamParameterivNV(GLuint video_capture_slot, GLuint stream, GLenum pname, const GLint *params)
{
	D(bug("nfosmesa: glVideoCaptureStreamParameterivNV(%u, %u, 0x%x, %p)", video_capture_slot, stream, pname, params));
	/* TODO: NFOSMESA_GLVIDEOCAPTURESTREAMPARAMETERIVNV may need conversion */
	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);
}

void OSMesaDriver::nfglViewportArrayv(GLuint first, GLsizei count, const GLfloat *v)
{
	D(bug("nfosmesa: glViewportArrayv(%u, %d, %p)", first, count, v));
	/* TODO: NFOSMESA_GLVIEWPORTARRAYV may need conversion */
	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);
}

void OSMesaDriver::nfglViewportIndexedfv(GLuint index, const GLfloat *v)
{
	D(bug("nfosmesa: glViewportIndexedfv(%u, %p)", index, v));
	/* TODO: NFOSMESA_GLVIEWPORTINDEXEDFV may need conversion */
	fn.glViewportIndexedfv(index, v);
}

void OSMesaDriver::nfglWaitSync(GLsync sync, GLbitfield flags, GLuint64 timeout)
{
	D(bug("nfosmesa: glWaitSync(%p, 0x%x, %" PRIu64 ")", sync, flags, timeout));
	fn.glWaitSync(sync, flags, timeout);
}

void OSMesaDriver::nfglWeightPathsNV(GLuint resultPath, GLsizei numPaths, const GLuint *paths, const GLfloat *weights)
{
	D(bug("nfosmesa: glWeightPathsNV(%u, %d, %p, %p)", resultPath, numPaths, paths, weights));
	/* TODO: NFOSMESA_GLWEIGHTPATHSNV may need conversion */
	fn.glWeightPathsNV(resultPath, numPaths, paths, weights);
}

void OSMesaDriver::nfglWeightPointerARB(GLint size, GLenum type, GLsizei stride, const void *pointer)
{
	D(bug("nfosmesa: glWeightPointerARB(%d, 0x%x, %d, %p)", size, type, stride, pointer));
	/* TODO: NFOSMESA_GLWEIGHTPOINTERARB may need conversion */
	fn.glWeightPointerARB(size, type, stride, pointer);
}

void OSMesaDriver::nfglWeightbvARB(GLint size, const GLbyte *weights)
{
	D(bug("nfosmesa: glWeightbvARB(%d, %p)", size, weights));
	/* TODO: NFOSMESA_GLWEIGHTBVARB may need conversion */
	fn.glWeightbvARB(size, weights);
}

void OSMesaDriver::nfglWeightdvARB(GLint size, const GLdouble *weights)
{
	D(bug("nfosmesa: glWeightdvARB(%d, %p)", size, weights));
	/* TODO: NFOSMESA_GLWEIGHTDVARB may need conversion */
	fn.glWeightdvARB(size, weights);
}

void OSMesaDriver::nfglWeightfvARB(GLint size, const GLfloat *weights)
{
	D(bug("nfosmesa: glWeightfvARB(%d, %p)", size, weights));
	/* TODO: NFOSMESA_GLWEIGHTFVARB may need conversion */
	fn.glWeightfvARB(size, weights);
}

void OSMesaDriver::nfglWeightivARB(GLint size, const GLint *weights)
{
	D(bug("nfosmesa: glWeightivARB(%d, %p)", size, weights));
	/* TODO: NFOSMESA_GLWEIGHTIVARB may need conversion */
	fn.glWeightivARB(size, weights);
}

void OSMesaDriver::nfglWeightsvARB(GLint size, const GLshort *weights)
{
	D(bug("nfosmesa: glWeightsvARB(%d, %p)", size, weights));
	/* TODO: NFOSMESA_GLWEIGHTSVARB may need conversion */
	fn.glWeightsvARB(size, weights);
}

void OSMesaDriver::nfglWeightubvARB(GLint size, const GLubyte *weights)
{
	D(bug("nfosmesa: glWeightubvARB(%d, %p)", size, weights));
	/* TODO: NFOSMESA_GLWEIGHTUBVARB may need conversion */
	fn.glWeightubvARB(size, weights);
}

void OSMesaDriver::nfglWeightuivARB(GLint size, const GLuint *weights)
{
	D(bug("nfosmesa: glWeightuivARB(%d, %p)", size, weights));
	/* TODO: NFOSMESA_GLWEIGHTUIVARB may need conversion */
	fn.glWeightuivARB(size, weights);
}

void OSMesaDriver::nfglWeightusvARB(GLint size, const GLushort *weights)
{
	D(bug("nfosmesa: glWeightusvARB(%d, %p)", size, weights));
	/* TODO: NFOSMESA_GLWEIGHTUSVARB may need conversion */
	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);
}

void OSMesaDriver::nfglWindowPos2dv(const GLdouble *v)
{
	D(bug("nfosmesa: glWindowPos2dv(%p)", v));
FN_GLWINDOWPOS2DV(v);
}

void OSMesaDriver::nfglWindowPos2dvARB(const GLdouble *v)
{
	D(bug("nfosmesa: glWindowPos2dvARB(%p)", v));
FN_GLWINDOWPOS2DVARB(v);
}

void OSMesaDriver::nfglWindowPos2dvMESA(const GLdouble *v)
{
	D(bug("nfosmesa: glWindowPos2dvMESA(%p)", 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);
}

void OSMesaDriver::nfglWindowPos2fv(const GLfloat *v)
{
	D(bug("nfosmesa: glWindowPos2fv(%p)", v));
FN_GLWINDOWPOS2FV(v);
}

void OSMesaDriver::nfglWindowPos2fvARB(const GLfloat *v)
{
	D(bug("nfosmesa: glWindowPos2fvARB(%p)", v));
FN_GLWINDOWPOS2FVARB(v);
}

void OSMesaDriver::nfglWindowPos2fvMESA(const GLfloat *v)
{
	D(bug("nfosmesa: glWindowPos2fvMESA(%p)", 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);
}

void OSMesaDriver::nfglWindowPos2iv(const GLint *v)
{
	D(bug("nfosmesa: glWindowPos2iv(%p)", v));
FN_GLWINDOWPOS2IV(v);
}

void OSMesaDriver::nfglWindowPos2ivARB(const GLint *v)
{
	D(bug("nfosmesa: glWindowPos2ivARB(%p)", v));
FN_GLWINDOWPOS2IVARB(v);
}

void OSMesaDriver::nfglWindowPos2ivMESA(const GLint *v)
{
	D(bug("nfosmesa: glWindowPos2ivMESA(%p)", 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);
}

void OSMesaDriver::nfglWindowPos2sv(const GLshort *v)
{
	D(bug("nfosmesa: glWindowPos2sv(%p)", v));
FN_GLWINDOWPOS2SV(v);
}

void OSMesaDriver::nfglWindowPos2svARB(const GLshort *v)
{
	D(bug("nfosmesa: glWindowPos2svARB(%p)", v));
FN_GLWINDOWPOS2SVARB(v);
}

void OSMesaDriver::nfglWindowPos2svMESA(const GLshort *v)
{
	D(bug("nfosmesa: glWindowPos2svMESA(%p)", 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);
}

void OSMesaDriver::nfglWindowPos3dv(const GLdouble *v)
{
	D(bug("nfosmesa: glWindowPos3dv(%p)", v));
FN_GLWINDOWPOS3DV(v);
}

void OSMesaDriver::nfglWindowPos3dvARB(const GLdouble *v)
{
	D(bug("nfosmesa: glWindowPos3dvARB(%p)", v));
FN_GLWINDOWPOS3DVARB(v);
}

void OSMesaDriver::nfglWindowPos3dvMESA(const GLdouble *v)
{
	D(bug("nfosmesa: glWindowPos3dvMESA(%p)", 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);
}

void OSMesaDriver::nfglWindowPos3fv(const GLfloat *v)
{
	D(bug("nfosmesa: glWindowPos3fv(%p)", v));
FN_GLWINDOWPOS3FV(v);
}

void OSMesaDriver::nfglWindowPos3fvARB(const GLfloat *v)
{
	D(bug("nfosmesa: glWindowPos3fvARB(%p)", v));
FN_GLWINDOWPOS3FVARB(v);
}

void OSMesaDriver::nfglWindowPos3fvMESA(const GLfloat *v)
{
	D(bug("nfosmesa: glWindowPos3fvMESA(%p)", 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);
}

void OSMesaDriver::nfglWindowPos3iv(const GLint *v)
{
	D(bug("nfosmesa: glWindowPos3iv(%p)", v));
FN_GLWINDOWPOS3IV(v);
}

void OSMesaDriver::nfglWindowPos3ivARB(const GLint *v)
{
	D(bug("nfosmesa: glWindowPos3ivARB(%p)", v));
FN_GLWINDOWPOS3IVARB(v);
}

void OSMesaDriver::nfglWindowPos3ivMESA(const GLint *v)
{
	D(bug("nfosmesa: glWindowPos3ivMESA(%p)", 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);
}

void OSMesaDriver::nfglWindowPos3sv(const GLshort *v)
{
	D(bug("nfosmesa: glWindowPos3sv(%p)", v));
FN_GLWINDOWPOS3SV(v);
}

void OSMesaDriver::nfglWindowPos3svARB(const GLshort *v)
{
	D(bug("nfosmesa: glWindowPos3svARB(%p)", v));
FN_GLWINDOWPOS3SVARB(v);
}

void OSMesaDriver::nfglWindowPos3svMESA(const GLshort *v)
{
	D(bug("nfosmesa: glWindowPos3svMESA(%p)", 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);
}

void OSMesaDriver::nfglWindowPos4dvMESA(const GLdouble *v)
{
	D(bug("nfosmesa: glWindowPos4dvMESA(%p)", 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);
}

void OSMesaDriver::nfglWindowPos4fvMESA(const GLfloat *v)
{
	D(bug("nfosmesa: glWindowPos4fvMESA(%p)", 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);
}

void OSMesaDriver::nfglWindowPos4ivMESA(const GLint *v)
{
	D(bug("nfosmesa: glWindowPos4ivMESA(%p)", 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);
}

void OSMesaDriver::nfglWindowPos4svMESA(const GLshort *v)
{
	D(bug("nfosmesa: glWindowPos4svMESA(%p)", v));
FN_GLWINDOWPOS4SVMESA(v);
}

void OSMesaDriver::nfglWriteMaskEXT(GLuint res, GLuint in, GLenum outX, GLenum outY, GLenum outZ, GLenum outW)
{
	D(bug("nfosmesa: glWriteMaskEXT(%u, %u, 0x%x, 0x%x, 0x%x, 0x%x)", res, in, outX, outY, outZ, 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: 2664 GL + 1 GLU */
