/src/regal/RegalDispatchMissing.cpp

Large files files are truncated, but you can click here to view the full file

/* NOTE: Do not edit this file, it is generated by a script:
   Export.py --api gl 4.4 --api wgl 4.4 --api glx 4.4 --api cgl 1.4 --api egl 1.0 --outdir .
*/

/*
  Copyright (c) 2011-2013 NVIDIA Corporation
  Copyright (c) 2011-2013 Cass Everitt
  Copyright (c) 2012-2013 Scott Nations
  Copyright (c) 2012 Mathias Schott
  Copyright (c) 2012-2013 Nigel Stewart
  Copyright (c) 2012-2013 Google Inc.
  All rights reserved.

  Redistribution and use in source and binary forms, with or without modification,
  are permitted provided that the following conditions are met:

    Redistributions of source code must retain the above copyright notice, this
    list of conditions and the following disclaimer.

    Redistributions in binary form must reproduce the above copyright notice,
    this list of conditions and the following disclaimer in the documentation
    and/or other materials provided with the distribution.

  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
  OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  OF THE POSSIBILITY OF SUCH DAMAGE.
*/

/*
  Intended formatting conventions:
  $ astyle --style=allman --indent=spaces=2 --indent-switches
*/

#include "pch.h" /* For MS precompiled header support */

#include "RegalUtil.h"

#if REGAL_MISSING

REGAL_GLOBAL_BEGIN

#include <string>
using namespace std;

#include "RegalLog.h"
#include "RegalBreak.h"
#include "RegalPush.h"
#include "RegalToken.h"
#include "RegalHelper.h"
#include "RegalPrivate.h"
#include "RegalContext.h"
#include "RegalDispatcherGL.h"
#include "RegalDispatcherGlobal.h"

REGAL_GLOBAL_END

REGAL_NAMESPACE_BEGIN

using namespace ::REGAL_NAMESPACE_INTERNAL::Logging;
using namespace ::REGAL_NAMESPACE_INTERNAL::Token;

namespace Missing
{

// GL_VERSION_1_0

  static void REGAL_CALL glAccum(GLenum op, GLfloat value)
{
    UNUSED_PARAMETER(op);
    UNUSED_PARAMETER(value);
    Warning( "glAccum", " not available." );
  }

  static void REGAL_CALL glAlphaFunc(GLenum func, GLclampf ref)
{
    UNUSED_PARAMETER(func);
    UNUSED_PARAMETER(ref);
    Warning( "glAlphaFunc", " not available." );
  }

  static void REGAL_CALL glBegin(GLenum mode)
{
    UNUSED_PARAMETER(mode);
    Warning( "glBegin", " not available." );
  }

  static void REGAL_CALL glBitmap(GLsizei width, GLsizei height, GLfloat xorig, GLfloat yorig, GLfloat xmove, GLfloat ymove, const GLubyte *bitmap)
{
    UNUSED_PARAMETER(width);
    UNUSED_PARAMETER(height);
    UNUSED_PARAMETER(xorig);
    UNUSED_PARAMETER(yorig);
    UNUSED_PARAMETER(xmove);
    UNUSED_PARAMETER(ymove);
    UNUSED_PARAMETER(bitmap);
    Warning( "glBitmap", " not available." );
  }

  static void REGAL_CALL glBlendFunc(GLenum sfactor, GLenum dfactor)
{
    UNUSED_PARAMETER(sfactor);
    UNUSED_PARAMETER(dfactor);
    Warning( "glBlendFunc", " not available." );
  }

  static void REGAL_CALL glCallList(GLuint list)
{
    UNUSED_PARAMETER(list);
    Warning( "glCallList", " not available." );
  }

  static void REGAL_CALL glCallLists(GLsizei n, GLenum type, const GLvoid *lists)
{
    UNUSED_PARAMETER(n);
    UNUSED_PARAMETER(type);
    UNUSED_PARAMETER(lists);
    Warning( "glCallLists", " not available." );
  }

  static void REGAL_CALL glClear(GLbitfield mask)
{
    UNUSED_PARAMETER(mask);
    Warning( "glClear", " not available." );
  }

  static void REGAL_CALL glClearAccum(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
    UNUSED_PARAMETER(red);
    UNUSED_PARAMETER(green);
    UNUSED_PARAMETER(blue);
    UNUSED_PARAMETER(alpha);
    Warning( "glClearAccum", " not available." );
  }

  static void REGAL_CALL glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha)
{
    UNUSED_PARAMETER(red);
    UNUSED_PARAMETER(green);
    UNUSED_PARAMETER(blue);
    UNUSED_PARAMETER(alpha);
    Warning( "glClearColor", " not available." );
  }

  static void REGAL_CALL glClearDepth(GLclampd depth)
{
    UNUSED_PARAMETER(depth);
    Warning( "glClearDepth", " not available." );
  }

  static void REGAL_CALL glClearIndex(GLfloat c)
{
    UNUSED_PARAMETER(c);
    Warning( "glClearIndex", " not available." );
  }

  static void REGAL_CALL glClearStencil(GLint s)
{
    UNUSED_PARAMETER(s);
    Warning( "glClearStencil", " not available." );
  }

  static void REGAL_CALL glClipPlane(GLenum plane, const GLdouble *equation)
{
    UNUSED_PARAMETER(plane);
    UNUSED_PARAMETER(equation);
    Warning( "glClipPlane", " not available." );
  }

  static void REGAL_CALL glColor3b(GLbyte red, GLbyte green, GLbyte blue)
{
    UNUSED_PARAMETER(red);
    UNUSED_PARAMETER(green);
    UNUSED_PARAMETER(blue);
    Warning( "glColor3b", " not available." );
  }

  static void REGAL_CALL glColor3bv(const GLbyte *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glColor3bv", " not available." );
  }

  static void REGAL_CALL glColor3d(GLdouble red, GLdouble green, GLdouble blue)
{
    UNUSED_PARAMETER(red);
    UNUSED_PARAMETER(green);
    UNUSED_PARAMETER(blue);
    Warning( "glColor3d", " not available." );
  }

  static void REGAL_CALL glColor3dv(const GLdouble *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glColor3dv", " not available." );
  }

  static void REGAL_CALL glColor3f(GLfloat red, GLfloat green, GLfloat blue)
{
    UNUSED_PARAMETER(red);
    UNUSED_PARAMETER(green);
    UNUSED_PARAMETER(blue);
    Warning( "glColor3f", " not available." );
  }

  static void REGAL_CALL glColor3fv(const GLfloat *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glColor3fv", " not available." );
  }

  static void REGAL_CALL glColor3i(GLint red, GLint green, GLint blue)
{
    UNUSED_PARAMETER(red);
    UNUSED_PARAMETER(green);
    UNUSED_PARAMETER(blue);
    Warning( "glColor3i", " not available." );
  }

  static void REGAL_CALL glColor3iv(const GLint *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glColor3iv", " not available." );
  }

  static void REGAL_CALL glColor3s(GLshort red, GLshort green, GLshort blue)
{
    UNUSED_PARAMETER(red);
    UNUSED_PARAMETER(green);
    UNUSED_PARAMETER(blue);
    Warning( "glColor3s", " not available." );
  }

  static void REGAL_CALL glColor3sv(const GLshort *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glColor3sv", " not available." );
  }

  static void REGAL_CALL glColor3ub(GLubyte red, GLubyte green, GLubyte blue)
{
    UNUSED_PARAMETER(red);
    UNUSED_PARAMETER(green);
    UNUSED_PARAMETER(blue);
    Warning( "glColor3ub", " not available." );
  }

  static void REGAL_CALL glColor3ubv(const GLubyte *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glColor3ubv", " not available." );
  }

  static void REGAL_CALL glColor3ui(GLuint red, GLuint green, GLuint blue)
{
    UNUSED_PARAMETER(red);
    UNUSED_PARAMETER(green);
    UNUSED_PARAMETER(blue);
    Warning( "glColor3ui", " not available." );
  }

  static void REGAL_CALL glColor3uiv(const GLuint *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glColor3uiv", " not available." );
  }

  static void REGAL_CALL glColor3us(GLushort red, GLushort green, GLushort blue)
{
    UNUSED_PARAMETER(red);
    UNUSED_PARAMETER(green);
    UNUSED_PARAMETER(blue);
    Warning( "glColor3us", " not available." );
  }

  static void REGAL_CALL glColor3usv(const GLushort *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glColor3usv", " not available." );
  }

  static void REGAL_CALL glColor4b(GLbyte red, GLbyte green, GLbyte blue, GLbyte alpha)
{
    UNUSED_PARAMETER(red);
    UNUSED_PARAMETER(green);
    UNUSED_PARAMETER(blue);
    UNUSED_PARAMETER(alpha);
    Warning( "glColor4b", " not available." );
  }

  static void REGAL_CALL glColor4bv(const GLbyte *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glColor4bv", " not available." );
  }

  static void REGAL_CALL glColor4d(GLdouble red, GLdouble green, GLdouble blue, GLdouble alpha)
{
    UNUSED_PARAMETER(red);
    UNUSED_PARAMETER(green);
    UNUSED_PARAMETER(blue);
    UNUSED_PARAMETER(alpha);
    Warning( "glColor4d", " not available." );
  }

  static void REGAL_CALL glColor4dv(const GLdouble *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glColor4dv", " not available." );
  }

  static void REGAL_CALL glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha)
{
    UNUSED_PARAMETER(red);
    UNUSED_PARAMETER(green);
    UNUSED_PARAMETER(blue);
    UNUSED_PARAMETER(alpha);
    Warning( "glColor4f", " not available." );
  }

  static void REGAL_CALL glColor4fv(const GLfloat *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glColor4fv", " not available." );
  }

  static void REGAL_CALL glColor4i(GLint red, GLint green, GLint blue, GLint alpha)
{
    UNUSED_PARAMETER(red);
    UNUSED_PARAMETER(green);
    UNUSED_PARAMETER(blue);
    UNUSED_PARAMETER(alpha);
    Warning( "glColor4i", " not available." );
  }

  static void REGAL_CALL glColor4iv(const GLint *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glColor4iv", " not available." );
  }

  static void REGAL_CALL glColor4s(GLshort red, GLshort green, GLshort blue, GLshort alpha)
{
    UNUSED_PARAMETER(red);
    UNUSED_PARAMETER(green);
    UNUSED_PARAMETER(blue);
    UNUSED_PARAMETER(alpha);
    Warning( "glColor4s", " not available." );
  }

  static void REGAL_CALL glColor4sv(const GLshort *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glColor4sv", " not available." );
  }

  static void REGAL_CALL glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha)
{
    UNUSED_PARAMETER(red);
    UNUSED_PARAMETER(green);
    UNUSED_PARAMETER(blue);
    UNUSED_PARAMETER(alpha);
    Warning( "glColor4ub", " not available." );
  }

  static void REGAL_CALL glColor4ubv(const GLubyte *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glColor4ubv", " not available." );
  }

  static void REGAL_CALL glColor4ui(GLuint red, GLuint green, GLuint blue, GLuint alpha)
{
    UNUSED_PARAMETER(red);
    UNUSED_PARAMETER(green);
    UNUSED_PARAMETER(blue);
    UNUSED_PARAMETER(alpha);
    Warning( "glColor4ui", " not available." );
  }

  static void REGAL_CALL glColor4uiv(const GLuint *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glColor4uiv", " not available." );
  }

  static void REGAL_CALL glColor4us(GLushort red, GLushort green, GLushort blue, GLushort alpha)
{
    UNUSED_PARAMETER(red);
    UNUSED_PARAMETER(green);
    UNUSED_PARAMETER(blue);
    UNUSED_PARAMETER(alpha);
    Warning( "glColor4us", " not available." );
  }

  static void REGAL_CALL glColor4usv(const GLushort *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glColor4usv", " not available." );
  }

  static void REGAL_CALL glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha)
{
    UNUSED_PARAMETER(red);
    UNUSED_PARAMETER(green);
    UNUSED_PARAMETER(blue);
    UNUSED_PARAMETER(alpha);
    Warning( "glColorMask", " not available." );
  }

  static void REGAL_CALL glColorMaterial(GLenum face, GLenum mode)
{
    UNUSED_PARAMETER(face);
    UNUSED_PARAMETER(mode);
    Warning( "glColorMaterial", " not available." );
  }

  static void REGAL_CALL glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
{
    UNUSED_PARAMETER(x);
    UNUSED_PARAMETER(y);
    UNUSED_PARAMETER(width);
    UNUSED_PARAMETER(height);
    UNUSED_PARAMETER(type);
    Warning( "glCopyPixels", " not available." );
  }

  static void REGAL_CALL glCullFace(GLenum mode)
{
    UNUSED_PARAMETER(mode);
    Warning( "glCullFace", " not available." );
  }

  static void REGAL_CALL glDeleteLists(GLuint list, GLsizei range)
{
    UNUSED_PARAMETER(list);
    UNUSED_PARAMETER(range);
    Warning( "glDeleteLists", " not available." );
  }

  static void REGAL_CALL glDepthFunc(GLenum func)
{
    UNUSED_PARAMETER(func);
    Warning( "glDepthFunc", " not available." );
  }

  static void REGAL_CALL glDepthMask(GLboolean flag)
{
    UNUSED_PARAMETER(flag);
    Warning( "glDepthMask", " not available." );
  }

  static void REGAL_CALL glDepthRange(GLclampd zNear, GLclampd zFar)
{
    UNUSED_PARAMETER(zNear);
    UNUSED_PARAMETER(zFar);
    Warning( "glDepthRange", " not available." );
  }

  static void REGAL_CALL glDisable(GLenum cap)
{
    UNUSED_PARAMETER(cap);
    Warning( "glDisable", " not available." );
  }

  static void REGAL_CALL glDrawBuffer(GLenum mode)
{
    UNUSED_PARAMETER(mode);
    Warning( "glDrawBuffer", " not available." );
  }

  static void REGAL_CALL glDrawPixels(GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels)
{
    UNUSED_PARAMETER(width);
    UNUSED_PARAMETER(height);
    UNUSED_PARAMETER(format);
    UNUSED_PARAMETER(type);
    UNUSED_PARAMETER(pixels);
    Warning( "glDrawPixels", " not available." );
  }

  static void REGAL_CALL glEdgeFlag(GLboolean flag)
{
    UNUSED_PARAMETER(flag);
    Warning( "glEdgeFlag", " not available." );
  }

  static void REGAL_CALL glEdgeFlagv(const GLboolean *flag)
{
    UNUSED_PARAMETER(flag);
    Warning( "glEdgeFlagv", " not available." );
  }

  static void REGAL_CALL glEnable(GLenum cap)
{
    UNUSED_PARAMETER(cap);
    Warning( "glEnable", " not available." );
  }

  static void REGAL_CALL glEnd(void)
{
    Warning( "glEnd", " not available." );
  }

  static void REGAL_CALL glEndList(void)
{
    Warning( "glEndList", " not available." );
  }

  static void REGAL_CALL glEvalCoord1d(GLdouble u)
{
    UNUSED_PARAMETER(u);
    Warning( "glEvalCoord1d", " not available." );
  }

  static void REGAL_CALL glEvalCoord1dv(const GLdouble *u)
{
    UNUSED_PARAMETER(u);
    Warning( "glEvalCoord1dv", " not available." );
  }

  static void REGAL_CALL glEvalCoord1f(GLfloat u)
{
    UNUSED_PARAMETER(u);
    Warning( "glEvalCoord1f", " not available." );
  }

  static void REGAL_CALL glEvalCoord1fv(const GLfloat *u)
{
    UNUSED_PARAMETER(u);
    Warning( "glEvalCoord1fv", " not available." );
  }

  static void REGAL_CALL glEvalCoord2d(GLdouble u, GLdouble v)
{
    UNUSED_PARAMETER(u);
    UNUSED_PARAMETER(v);
    Warning( "glEvalCoord2d", " not available." );
  }

  static void REGAL_CALL glEvalCoord2dv(const GLdouble *u)
{
    UNUSED_PARAMETER(u);
    Warning( "glEvalCoord2dv", " not available." );
  }

  static void REGAL_CALL glEvalCoord2f(GLfloat u, GLfloat v)
{
    UNUSED_PARAMETER(u);
    UNUSED_PARAMETER(v);
    Warning( "glEvalCoord2f", " not available." );
  }

  static void REGAL_CALL glEvalCoord2fv(const GLfloat *u)
{
    UNUSED_PARAMETER(u);
    Warning( "glEvalCoord2fv", " not available." );
  }

  static void REGAL_CALL glEvalMesh1(GLenum mode, GLint i1, GLint i2)
{
    UNUSED_PARAMETER(mode);
    UNUSED_PARAMETER(i1);
    UNUSED_PARAMETER(i2);
    Warning( "glEvalMesh1", " not available." );
  }

  static void REGAL_CALL glEvalMesh2(GLenum mode, GLint i1, GLint i2, GLint j1, GLint j2)
{
    UNUSED_PARAMETER(mode);
    UNUSED_PARAMETER(i1);
    UNUSED_PARAMETER(i2);
    UNUSED_PARAMETER(j1);
    UNUSED_PARAMETER(j2);
    Warning( "glEvalMesh2", " not available." );
  }

  static void REGAL_CALL glEvalPoint1(GLint i)
{
    UNUSED_PARAMETER(i);
    Warning( "glEvalPoint1", " not available." );
  }

  static void REGAL_CALL glEvalPoint2(GLint i, GLint j)
{
    UNUSED_PARAMETER(i);
    UNUSED_PARAMETER(j);
    Warning( "glEvalPoint2", " not available." );
  }

  static void REGAL_CALL glFeedbackBuffer(GLsizei size, GLenum type, GLfloat *buffer)
{
    UNUSED_PARAMETER(size);
    UNUSED_PARAMETER(type);
    UNUSED_PARAMETER(buffer);
    Warning( "glFeedbackBuffer", " not available." );
  }

  static void REGAL_CALL glFinish(void)
{
    Warning( "glFinish", " not available." );
  }

  static void REGAL_CALL glFlush(void)
{
    Warning( "glFlush", " not available." );
  }

  static void REGAL_CALL glFogf(GLenum pname, GLfloat param)
{
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(param);
    Warning( "glFogf", " not available." );
  }

  static void REGAL_CALL glFogfv(GLenum pname, const GLfloat *params)
{
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glFogfv", " not available." );
  }

  static void REGAL_CALL glFogi(GLenum pname, GLint param)
{
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(param);
    Warning( "glFogi", " not available." );
  }

  static void REGAL_CALL glFogiv(GLenum pname, const GLint *params)
{
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glFogiv", " not available." );
  }

  static void REGAL_CALL glFrontFace(GLenum mode)
{
    UNUSED_PARAMETER(mode);
    Warning( "glFrontFace", " not available." );
  }

  static void REGAL_CALL glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
    UNUSED_PARAMETER(left);
    UNUSED_PARAMETER(right);
    UNUSED_PARAMETER(bottom);
    UNUSED_PARAMETER(top);
    UNUSED_PARAMETER(zNear);
    UNUSED_PARAMETER(zFar);
    Warning( "glFrustum", " not available." );
  }

  static GLuint REGAL_CALL glGenLists(GLsizei range)
{
    UNUSED_PARAMETER(range);
    Warning( "glGenLists", " not available." );
    return 0;
  }

  static void REGAL_CALL glGetBooleanv(GLenum pname, GLboolean *params)
{
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glGetBooleanv", " not available." );
  }

  static void REGAL_CALL glGetClipPlane(GLenum plane, GLdouble *equation)
{
    UNUSED_PARAMETER(plane);
    UNUSED_PARAMETER(equation);
    Warning( "glGetClipPlane", " not available." );
  }

  static void REGAL_CALL glGetDoublev(GLenum pname, GLdouble *params)
{
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glGetDoublev", " not available." );
  }

  static GLenum REGAL_CALL glGetError(void)
{
    Warning( "glGetError", " not available." );
    return 0;
  }

  static void REGAL_CALL glGetFloatv(GLenum pname, GLfloat *params)
{
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glGetFloatv", " not available." );
  }

  static void REGAL_CALL glGetIntegerv(GLenum pname, GLint *params)
{
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glGetIntegerv", " not available." );
  }

  static void REGAL_CALL glGetLightfv(GLenum light, GLenum pname, GLfloat *params)
{
    UNUSED_PARAMETER(light);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glGetLightfv", " not available." );
  }

  static void REGAL_CALL glGetLightiv(GLenum light, GLenum pname, GLint *params)
{
    UNUSED_PARAMETER(light);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glGetLightiv", " not available." );
  }

  static void REGAL_CALL glGetMapdv(GLenum target, GLenum query, GLdouble *v)
{
    UNUSED_PARAMETER(target);
    UNUSED_PARAMETER(query);
    UNUSED_PARAMETER(v);
    Warning( "glGetMapdv", " not available." );
  }

  static void REGAL_CALL glGetMapfv(GLenum target, GLenum query, GLfloat *v)
{
    UNUSED_PARAMETER(target);
    UNUSED_PARAMETER(query);
    UNUSED_PARAMETER(v);
    Warning( "glGetMapfv", " not available." );
  }

  static void REGAL_CALL glGetMapiv(GLenum target, GLenum query, GLint *v)
{
    UNUSED_PARAMETER(target);
    UNUSED_PARAMETER(query);
    UNUSED_PARAMETER(v);
    Warning( "glGetMapiv", " not available." );
  }

  static void REGAL_CALL glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params)
{
    UNUSED_PARAMETER(face);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glGetMaterialfv", " not available." );
  }

  static void REGAL_CALL glGetMaterialiv(GLenum face, GLenum pname, GLint *params)
{
    UNUSED_PARAMETER(face);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glGetMaterialiv", " not available." );
  }

  static void REGAL_CALL glGetPixelMapfv(GLenum map, GLfloat *values)
{
    UNUSED_PARAMETER(map);
    UNUSED_PARAMETER(values);
    Warning( "glGetPixelMapfv", " not available." );
  }

  static void REGAL_CALL glGetPixelMapuiv(GLenum map, GLuint *values)
{
    UNUSED_PARAMETER(map);
    UNUSED_PARAMETER(values);
    Warning( "glGetPixelMapuiv", " not available." );
  }

  static void REGAL_CALL glGetPixelMapusv(GLenum map, GLushort *values)
{
    UNUSED_PARAMETER(map);
    UNUSED_PARAMETER(values);
    Warning( "glGetPixelMapusv", " not available." );
  }

  static void REGAL_CALL glGetPolygonStipple(GLubyte *mask)
{
    UNUSED_PARAMETER(mask);
    Warning( "glGetPolygonStipple", " not available." );
  }

  static const GLubyte *REGAL_CALL glGetString(GLenum name)
{
    UNUSED_PARAMETER(name);
    Warning( "glGetString", " not available." );
    return NULL;
  }

  static void REGAL_CALL glGetTexEnvfv(GLenum target, GLenum pname, GLfloat *params)
{
    UNUSED_PARAMETER(target);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glGetTexEnvfv", " not available." );
  }

  static void REGAL_CALL glGetTexEnviv(GLenum target, GLenum pname, GLint *params)
{
    UNUSED_PARAMETER(target);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glGetTexEnviv", " not available." );
  }

  static void REGAL_CALL glGetTexGendv(GLenum coord, GLenum pname, GLdouble *params)
{
    UNUSED_PARAMETER(coord);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glGetTexGendv", " not available." );
  }

  static void REGAL_CALL glGetTexGenfv(GLenum coord, GLenum pname, GLfloat *params)
{
    UNUSED_PARAMETER(coord);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glGetTexGenfv", " not available." );
  }

  static void REGAL_CALL glGetTexGeniv(GLenum coord, GLenum pname, GLint *params)
{
    UNUSED_PARAMETER(coord);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glGetTexGeniv", " not available." );
  }

  static void REGAL_CALL glGetTexImage(GLenum target, GLint level, GLenum format, GLenum type, GLvoid *pixels)
{
    UNUSED_PARAMETER(target);
    UNUSED_PARAMETER(level);
    UNUSED_PARAMETER(format);
    UNUSED_PARAMETER(type);
    UNUSED_PARAMETER(pixels);
    Warning( "glGetTexImage", " not available." );
  }

  static void REGAL_CALL glGetTexLevelParameterfv(GLenum target, GLint level, GLenum pname, GLfloat *params)
{
    UNUSED_PARAMETER(target);
    UNUSED_PARAMETER(level);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glGetTexLevelParameterfv", " not available." );
  }

  static void REGAL_CALL glGetTexLevelParameteriv(GLenum target, GLint level, GLenum pname, GLint *params)
{
    UNUSED_PARAMETER(target);
    UNUSED_PARAMETER(level);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glGetTexLevelParameteriv", " not available." );
  }

  static void REGAL_CALL glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params)
{
    UNUSED_PARAMETER(target);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glGetTexParameterfv", " not available." );
  }

  static void REGAL_CALL glGetTexParameteriv(GLenum target, GLenum pname, GLint *params)
{
    UNUSED_PARAMETER(target);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glGetTexParameteriv", " not available." );
  }

  static void REGAL_CALL glHint(GLenum target, GLenum mode)
{
    UNUSED_PARAMETER(target);
    UNUSED_PARAMETER(mode);
    Warning( "glHint", " not available." );
  }

  static void REGAL_CALL glIndexMask(GLuint mask)
{
    UNUSED_PARAMETER(mask);
    Warning( "glIndexMask", " not available." );
  }

  static void REGAL_CALL glIndexd(GLdouble c)
{
    UNUSED_PARAMETER(c);
    Warning( "glIndexd", " not available." );
  }

  static void REGAL_CALL glIndexdv(const GLdouble *c)
{
    UNUSED_PARAMETER(c);
    Warning( "glIndexdv", " not available." );
  }

  static void REGAL_CALL glIndexf(GLfloat c)
{
    UNUSED_PARAMETER(c);
    Warning( "glIndexf", " not available." );
  }

  static void REGAL_CALL glIndexfv(const GLfloat *c)
{
    UNUSED_PARAMETER(c);
    Warning( "glIndexfv", " not available." );
  }

  static void REGAL_CALL glIndexi(GLint c)
{
    UNUSED_PARAMETER(c);
    Warning( "glIndexi", " not available." );
  }

  static void REGAL_CALL glIndexiv(const GLint *c)
{
    UNUSED_PARAMETER(c);
    Warning( "glIndexiv", " not available." );
  }

  static void REGAL_CALL glIndexs(GLshort c)
{
    UNUSED_PARAMETER(c);
    Warning( "glIndexs", " not available." );
  }

  static void REGAL_CALL glIndexsv(const GLshort *c)
{
    UNUSED_PARAMETER(c);
    Warning( "glIndexsv", " not available." );
  }

  static void REGAL_CALL glInitNames(void)
{
    Warning( "glInitNames", " not available." );
  }

  static GLboolean REGAL_CALL glIsEnabled(GLenum cap)
{
    UNUSED_PARAMETER(cap);
    Warning( "glIsEnabled", " not available." );
    return GL_FALSE;
  }

  static GLboolean REGAL_CALL glIsList(GLuint list)
{
    UNUSED_PARAMETER(list);
    Warning( "glIsList", " not available." );
    return GL_FALSE;
  }

  static void REGAL_CALL glLightModelf(GLenum pname, GLfloat param)
{
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(param);
    Warning( "glLightModelf", " not available." );
  }

  static void REGAL_CALL glLightModelfv(GLenum pname, const GLfloat *params)
{
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glLightModelfv", " not available." );
  }

  static void REGAL_CALL glLightModeli(GLenum pname, GLint param)
{
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(param);
    Warning( "glLightModeli", " not available." );
  }

  static void REGAL_CALL glLightModeliv(GLenum pname, const GLint *params)
{
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glLightModeliv", " not available." );
  }

  static void REGAL_CALL glLightf(GLenum light, GLenum pname, GLfloat param)
{
    UNUSED_PARAMETER(light);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(param);
    Warning( "glLightf", " not available." );
  }

  static void REGAL_CALL glLightfv(GLenum light, GLenum pname, const GLfloat *params)
{
    UNUSED_PARAMETER(light);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glLightfv", " not available." );
  }

  static void REGAL_CALL glLighti(GLenum light, GLenum pname, GLint param)
{
    UNUSED_PARAMETER(light);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(param);
    Warning( "glLighti", " not available." );
  }

  static void REGAL_CALL glLightiv(GLenum light, GLenum pname, const GLint *params)
{
    UNUSED_PARAMETER(light);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glLightiv", " not available." );
  }

  static void REGAL_CALL glLineStipple(GLint factor, GLushort pattern)
{
    UNUSED_PARAMETER(factor);
    UNUSED_PARAMETER(pattern);
    Warning( "glLineStipple", " not available." );
  }

  static void REGAL_CALL glLineWidth(GLfloat width)
{
    UNUSED_PARAMETER(width);
    Warning( "glLineWidth", " not available." );
  }

  static void REGAL_CALL glListBase(GLuint base)
{
    UNUSED_PARAMETER(base);
    Warning( "glListBase", " not available." );
  }

  static void REGAL_CALL glLoadIdentity(void)
{
    Warning( "glLoadIdentity", " not available." );
  }

  static void REGAL_CALL glLoadMatrixd(const GLdouble *m)
{
    UNUSED_PARAMETER(m);
    Warning( "glLoadMatrixd", " not available." );
  }

  static void REGAL_CALL glLoadMatrixf(const GLfloat *m)
{
    UNUSED_PARAMETER(m);
    Warning( "glLoadMatrixf", " not available." );
  }

  static void REGAL_CALL glLoadName(GLuint name)
{
    UNUSED_PARAMETER(name);
    Warning( "glLoadName", " not available." );
  }

  static void REGAL_CALL glLogicOp(GLenum opcode)
{
    UNUSED_PARAMETER(opcode);
    Warning( "glLogicOp", " not available." );
  }

  static void REGAL_CALL glMap1d(GLenum target, GLdouble u1, GLdouble u2, GLint stride, GLint order, const GLdouble *points)
{
    UNUSED_PARAMETER(target);
    UNUSED_PARAMETER(u1);
    UNUSED_PARAMETER(u2);
    UNUSED_PARAMETER(stride);
    UNUSED_PARAMETER(order);
    UNUSED_PARAMETER(points);
    Warning( "glMap1d", " not available." );
  }

  static void REGAL_CALL glMap1f(GLenum target, GLfloat u1, GLfloat u2, GLint stride, GLint order, const GLfloat *points)
{
    UNUSED_PARAMETER(target);
    UNUSED_PARAMETER(u1);
    UNUSED_PARAMETER(u2);
    UNUSED_PARAMETER(stride);
    UNUSED_PARAMETER(order);
    UNUSED_PARAMETER(points);
    Warning( "glMap1f", " not available." );
  }

  static void REGAL_CALL glMap2d(GLenum target, GLdouble u1, GLdouble u2, GLint ustride, GLint uorder, GLdouble v1, GLdouble v2, GLint vstride, GLint vorder, const GLdouble *points)
{
    UNUSED_PARAMETER(target);
    UNUSED_PARAMETER(u1);
    UNUSED_PARAMETER(u2);
    UNUSED_PARAMETER(ustride);
    UNUSED_PARAMETER(uorder);
    UNUSED_PARAMETER(v1);
    UNUSED_PARAMETER(v2);
    UNUSED_PARAMETER(vstride);
    UNUSED_PARAMETER(vorder);
    UNUSED_PARAMETER(points);
    Warning( "glMap2d", " not available." );
  }

  static void REGAL_CALL glMap2f(GLenum target, GLfloat u1, GLfloat u2, GLint ustride, GLint uorder, GLfloat v1, GLfloat v2, GLint vstride, GLint vorder, const GLfloat *points)
{
    UNUSED_PARAMETER(target);
    UNUSED_PARAMETER(u1);
    UNUSED_PARAMETER(u2);
    UNUSED_PARAMETER(ustride);
    UNUSED_PARAMETER(uorder);
    UNUSED_PARAMETER(v1);
    UNUSED_PARAMETER(v2);
    UNUSED_PARAMETER(vstride);
    UNUSED_PARAMETER(vorder);
    UNUSED_PARAMETER(points);
    Warning( "glMap2f", " not available." );
  }

  static void REGAL_CALL glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
{
    UNUSED_PARAMETER(un);
    UNUSED_PARAMETER(u1);
    UNUSED_PARAMETER(u2);
    Warning( "glMapGrid1d", " not available." );
  }

  static void REGAL_CALL glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
{
    UNUSED_PARAMETER(un);
    UNUSED_PARAMETER(u1);
    UNUSED_PARAMETER(u2);
    Warning( "glMapGrid1f", " not available." );
  }

  static void REGAL_CALL glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
{
    UNUSED_PARAMETER(un);
    UNUSED_PARAMETER(u1);
    UNUSED_PARAMETER(u2);
    UNUSED_PARAMETER(vn);
    UNUSED_PARAMETER(v1);
    UNUSED_PARAMETER(v2);
    Warning( "glMapGrid2d", " not available." );
  }

  static void REGAL_CALL glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
{
    UNUSED_PARAMETER(un);
    UNUSED_PARAMETER(u1);
    UNUSED_PARAMETER(u2);
    UNUSED_PARAMETER(vn);
    UNUSED_PARAMETER(v1);
    UNUSED_PARAMETER(v2);
    Warning( "glMapGrid2f", " not available." );
  }

  static void REGAL_CALL glMaterialf(GLenum face, GLenum pname, GLfloat param)
{
    UNUSED_PARAMETER(face);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(param);
    Warning( "glMaterialf", " not available." );
  }

  static void REGAL_CALL glMaterialfv(GLenum face, GLenum pname, const GLfloat *params)
{
    UNUSED_PARAMETER(face);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glMaterialfv", " not available." );
  }

  static void REGAL_CALL glMateriali(GLenum face, GLenum pname, GLint param)
{
    UNUSED_PARAMETER(face);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(param);
    Warning( "glMateriali", " not available." );
  }

  static void REGAL_CALL glMaterialiv(GLenum face, GLenum pname, const GLint *params)
{
    UNUSED_PARAMETER(face);
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(params);
    Warning( "glMaterialiv", " not available." );
  }

  static void REGAL_CALL glMatrixMode(GLenum mode)
{
    UNUSED_PARAMETER(mode);
    Warning( "glMatrixMode", " not available." );
  }

  static void REGAL_CALL glMultMatrixd(const GLdouble *m)
{
    UNUSED_PARAMETER(m);
    Warning( "glMultMatrixd", " not available." );
  }

  static void REGAL_CALL glMultMatrixf(const GLfloat *m)
{
    UNUSED_PARAMETER(m);
    Warning( "glMultMatrixf", " not available." );
  }

  static void REGAL_CALL glNewList(GLuint list, GLenum mode)
{
    UNUSED_PARAMETER(list);
    UNUSED_PARAMETER(mode);
    Warning( "glNewList", " not available." );
  }

  static void REGAL_CALL glNormal3b(GLbyte nx, GLbyte ny, GLbyte nz)
{
    UNUSED_PARAMETER(nx);
    UNUSED_PARAMETER(ny);
    UNUSED_PARAMETER(nz);
    Warning( "glNormal3b", " not available." );
  }

  static void REGAL_CALL glNormal3bv(const GLbyte *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glNormal3bv", " not available." );
  }

  static void REGAL_CALL glNormal3d(GLdouble nx, GLdouble ny, GLdouble nz)
{
    UNUSED_PARAMETER(nx);
    UNUSED_PARAMETER(ny);
    UNUSED_PARAMETER(nz);
    Warning( "glNormal3d", " not available." );
  }

  static void REGAL_CALL glNormal3dv(const GLdouble *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glNormal3dv", " not available." );
  }

  static void REGAL_CALL glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz)
{
    UNUSED_PARAMETER(nx);
    UNUSED_PARAMETER(ny);
    UNUSED_PARAMETER(nz);
    Warning( "glNormal3f", " not available." );
  }

  static void REGAL_CALL glNormal3fv(const GLfloat *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glNormal3fv", " not available." );
  }

  static void REGAL_CALL glNormal3i(GLint nx, GLint ny, GLint nz)
{
    UNUSED_PARAMETER(nx);
    UNUSED_PARAMETER(ny);
    UNUSED_PARAMETER(nz);
    Warning( "glNormal3i", " not available." );
  }

  static void REGAL_CALL glNormal3iv(const GLint *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glNormal3iv", " not available." );
  }

  static void REGAL_CALL glNormal3s(GLshort nx, GLshort ny, GLshort nz)
{
    UNUSED_PARAMETER(nx);
    UNUSED_PARAMETER(ny);
    UNUSED_PARAMETER(nz);
    Warning( "glNormal3s", " not available." );
  }

  static void REGAL_CALL glNormal3sv(const GLshort *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glNormal3sv", " not available." );
  }

  static void REGAL_CALL glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble zNear, GLdouble zFar)
{
    UNUSED_PARAMETER(left);
    UNUSED_PARAMETER(right);
    UNUSED_PARAMETER(bottom);
    UNUSED_PARAMETER(top);
    UNUSED_PARAMETER(zNear);
    UNUSED_PARAMETER(zFar);
    Warning( "glOrtho", " not available." );
  }

  static void REGAL_CALL glPassThrough(GLfloat token)
{
    UNUSED_PARAMETER(token);
    Warning( "glPassThrough", " not available." );
  }

  static void REGAL_CALL glPixelMapfv(GLenum map, GLsizei mapsize, const GLfloat *values)
{
    UNUSED_PARAMETER(map);
    UNUSED_PARAMETER(mapsize);
    UNUSED_PARAMETER(values);
    Warning( "glPixelMapfv", " not available." );
  }

  static void REGAL_CALL glPixelMapuiv(GLenum map, GLsizei mapsize, const GLuint *values)
{
    UNUSED_PARAMETER(map);
    UNUSED_PARAMETER(mapsize);
    UNUSED_PARAMETER(values);
    Warning( "glPixelMapuiv", " not available." );
  }

  static void REGAL_CALL glPixelMapusv(GLenum map, GLsizei mapsize, const GLushort *values)
{
    UNUSED_PARAMETER(map);
    UNUSED_PARAMETER(mapsize);
    UNUSED_PARAMETER(values);
    Warning( "glPixelMapusv", " not available." );
  }

  static void REGAL_CALL glPixelStoref(GLenum pname, GLfloat param)
{
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(param);
    Warning( "glPixelStoref", " not available." );
  }

  static void REGAL_CALL glPixelStorei(GLenum pname, GLint param)
{
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(param);
    Warning( "glPixelStorei", " not available." );
  }

  static void REGAL_CALL glPixelTransferf(GLenum pname, GLfloat param)
{
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(param);
    Warning( "glPixelTransferf", " not available." );
  }

  static void REGAL_CALL glPixelTransferi(GLenum pname, GLint param)
{
    UNUSED_PARAMETER(pname);
    UNUSED_PARAMETER(param);
    Warning( "glPixelTransferi", " not available." );
  }

  static void REGAL_CALL glPixelZoom(GLfloat xfactor, GLfloat yfactor)
{
    UNUSED_PARAMETER(xfactor);
    UNUSED_PARAMETER(yfactor);
    Warning( "glPixelZoom", " not available." );
  }

  static void REGAL_CALL glPointSize(GLfloat size)
{
    UNUSED_PARAMETER(size);
    Warning( "glPointSize", " not available." );
  }

  static void REGAL_CALL glPolygonMode(GLenum face, GLenum mode)
{
    UNUSED_PARAMETER(face);
    UNUSED_PARAMETER(mode);
    Warning( "glPolygonMode", " not available." );
  }

  static void REGAL_CALL glPolygonStipple(const GLubyte *mask)
{
    UNUSED_PARAMETER(mask);
    Warning( "glPolygonStipple", " not available." );
  }

  static void REGAL_CALL glPopAttrib(void)
{
    Warning( "glPopAttrib", " not available." );
  }

  static void REGAL_CALL glPopMatrix(void)
{
    Warning( "glPopMatrix", " not available." );
  }

  static void REGAL_CALL glPopName(void)
{
    Warning( "glPopName", " not available." );
  }

  static void REGAL_CALL glPushAttrib(GLbitfield mask)
{
    UNUSED_PARAMETER(mask);
    Warning( "glPushAttrib", " not available." );
  }

  static void REGAL_CALL glPushMatrix(void)
{
    Warning( "glPushMatrix", " not available." );
  }

  static void REGAL_CALL glPushName(GLuint name)
{
    UNUSED_PARAMETER(name);
    Warning( "glPushName", " not available." );
  }

  static void REGAL_CALL glRasterPos2d(GLdouble x, GLdouble y)
{
    UNUSED_PARAMETER(x);
    UNUSED_PARAMETER(y);
    Warning( "glRasterPos2d", " not available." );
  }

  static void REGAL_CALL glRasterPos2dv(const GLdouble *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glRasterPos2dv", " not available." );
  }

  static void REGAL_CALL glRasterPos2f(GLfloat x, GLfloat y)
{
    UNUSED_PARAMETER(x);
    UNUSED_PARAMETER(y);
    Warning( "glRasterPos2f", " not available." );
  }

  static void REGAL_CALL glRasterPos2fv(const GLfloat *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glRasterPos2fv", " not available." );
  }

  static void REGAL_CALL glRasterPos2i(GLint x, GLint y)
{
    UNUSED_PARAMETER(x);
    UNUSED_PARAMETER(y);
    Warning( "glRasterPos2i", " not available." );
  }

  static void REGAL_CALL glRasterPos2iv(const GLint *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glRasterPos2iv", " not available." );
  }

  static void REGAL_CALL glRasterPos2s(GLshort x, GLshort y)
{
    UNUSED_PARAMETER(x);
    UNUSED_PARAMETER(y);
    Warning( "glRasterPos2s", " not available." );
  }

  static void REGAL_CALL glRasterPos2sv(const GLshort *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glRasterPos2sv", " not available." );
  }

  static void REGAL_CALL glRasterPos3d(GLdouble x, GLdouble y, GLdouble z)
{
    UNUSED_PARAMETER(x);
    UNUSED_PARAMETER(y);
    UNUSED_PARAMETER(z);
    Warning( "glRasterPos3d", " not available." );
  }

  static void REGAL_CALL glRasterPos3dv(const GLdouble *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glRasterPos3dv", " not available." );
  }

  static void REGAL_CALL glRasterPos3f(GLfloat x, GLfloat y, GLfloat z)
{
    UNUSED_PARAMETER(x);
    UNUSED_PARAMETER(y);
    UNUSED_PARAMETER(z);
    Warning( "glRasterPos3f", " not available." );
  }

  static void REGAL_CALL glRasterPos3fv(const GLfloat *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glRasterPos3fv", " not available." );
  }

  static void REGAL_CALL glRasterPos3i(GLint x, GLint y, GLint z)
{
    UNUSED_PARAMETER(x);
    UNUSED_PARAMETER(y);
    UNUSED_PARAMETER(z);
    Warning( "glRasterPos3i", " not available." );
  }

  static void REGAL_CALL glRasterPos3iv(const GLint *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glRasterPos3iv", " not available." );
  }

  static void REGAL_CALL glRasterPos3s(GLshort x, GLshort y, GLshort z)
{
    UNUSED_PARAMETER(x);
    UNUSED_PARAMETER(y);
    UNUSED_PARAMETER(z);
    Warning( "glRasterPos3s", " not available." );
  }

  static void REGAL_CALL glRasterPos3sv(const GLshort *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glRasterPos3sv", " not available." );
  }

  static void REGAL_CALL glRasterPos4d(GLdouble x, GLdouble y, GLdouble z, GLdouble w)
{
    UNUSED_PARAMETER(x);
    UNUSED_PARAMETER(y);
    UNUSED_PARAMETER(z);
    UNUSED_PARAMETER(w);
    Warning( "glRasterPos4d", " not available." );
  }

  static void REGAL_CALL glRasterPos4dv(const GLdouble *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glRasterPos4dv", " not available." );
  }

  static void REGAL_CALL glRasterPos4f(GLfloat x, GLfloat y, GLfloat z, GLfloat w)
{
    UNUSED_PARAMETER(x);
    UNUSED_PARAMETER(y);
    UNUSED_PARAMETER(z);
    UNUSED_PARAMETER(w);
    Warning( "glRasterPos4f", " not available." );
  }

  static void REGAL_CALL glRasterPos4fv(const GLfloat *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glRasterPos4fv", " not available." );
  }

  static void REGAL_CALL glRasterPos4i(GLint x, GLint y, GLint z, GLint w)
{
    UNUSED_PARAMETER(x);
    UNUSED_PARAMETER(y);
    UNUSED_PARAMETER(z);
    UNUSED_PARAMETER(w);
    Warning( "glRasterPos4i", " not available." );
  }

  static void REGAL_CALL glRasterPos4iv(const GLint *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glRasterPos4iv", " not available." );
  }

  static void REGAL_CALL glRasterPos4s(GLshort x, GLshort y, GLshort z, GLshort w)
{
    UNUSED_PARAMETER(x);
    UNUSED_PARAMETER(y);
    UNUSED_PARAMETER(z);
    UNUSED_PARAMETER(w);
    Warning( "glRasterPos4s", " not available." );
  }

  static void REGAL_CALL glRasterPos4sv(const GLshort *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glRasterPos4sv", " not available." );
  }

  static void REGAL_CALL glReadBuffer(GLenum mode)
{
    UNUSED_PARAMETER(mode);
    Warning( "glReadBuffer", " not available." );
  }

  static void REGAL_CALL glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels)
{
    UNUSED_PARAMETER(x);
    UNUSED_PARAMETER(y);
    UNUSED_PARAMETER(width);
    UNUSED_PARAMETER(height);
    UNUSED_PARAMETER(format);
    UNUSED_PARAMETER(type);
    UNUSED_PARAMETER(pixels);
    Warning( "glReadPixels", " not available." );
  }

  static void REGAL_CALL glRectd(GLdouble x1, GLdouble y1, GLdouble x2, GLdouble y2)
{
    UNUSED_PARAMETER(x1);
    UNUSED_PARAMETER(y1);
    UNUSED_PARAMETER(x2);
    UNUSED_PARAMETER(y2);
    Warning( "glRectd", " not available." );
  }

  static void REGAL_CALL glRectdv(const GLdouble *v1, const GLdouble *v2)
{
    UNUSED_PARAMETER(v1);
    UNUSED_PARAMETER(v2);
    Warning( "glRectdv", " not available." );
  }

  static void REGAL_CALL glRectf(GLfloat x1, GLfloat y1, GLfloat x2, GLfloat y2)
{
    UNUSED_PARAMETER(x1);
    UNUSED_PARAMETER(y1);
    UNUSED_PARAMETER(x2);
    UNUSED_PARAMETER(y2);
    Warning( "glRectf", " not available." );
  }

  static void REGAL_CALL glRectfv(const GLfloat *v1, const GLfloat *v2)
{
    UNUSED_PARAMETER(v1);
    UNUSED_PARAMETER(v2);
    Warning( "glRectfv", " not available." );
  }

  static void REGAL_CALL glRecti(GLint x1, GLint y1, GLint x2, GLint y2)
{
    UNUSED_PARAMETER(x1);
    UNUSED_PARAMETER(y1);
    UNUSED_PARAMETER(x2);
    UNUSED_PARAMETER(y2);
    Warning( "glRecti", " not available." );
  }

  static void REGAL_CALL glRectiv(const GLint *v1, const GLint *v2)
{
    UNUSED_PARAMETER(v1);
    UNUSED_PARAMETER(v2);
    Warning( "glRectiv", " not available." );
  }

  static void REGAL_CALL glRects(GLshort x1, GLshort y1, GLshort x2, GLshort y2)
{
    UNUSED_PARAMETER(x1);
    UNUSED_PARAMETER(y1);
    UNUSED_PARAMETER(x2);
    UNUSED_PARAMETER(y2);
    Warning( "glRects", " not available." );
  }

  static void REGAL_CALL glRectsv(const GLshort *v1, const GLshort *v2)
{
    UNUSED_PARAMETER(v1);
    UNUSED_PARAMETER(v2);
    Warning( "glRectsv", " not available." );
  }

  static GLint REGAL_CALL glRenderMode(GLenum mode)
{
    UNUSED_PARAMETER(mode);
    Warning( "glRenderMode", " not available." );
    return 0;
  }

  static void REGAL_CALL glRotated(GLdouble angle, GLdouble x, GLdouble y, GLdouble z)
{
    UNUSED_PARAMETER(angle);
    UNUSED_PARAMETER(x);
    UNUSED_PARAMETER(y);
    UNUSED_PARAMETER(z);
    Warning( "glRotated", " not available." );
  }

  static void REGAL_CALL glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z)
{
    UNUSED_PARAMETER(angle);
    UNUSED_PARAMETER(x);
    UNUSED_PARAMETER(y);
    UNUSED_PARAMETER(z);
    Warning( "glRotatef", " not available." );
  }

  static void REGAL_CALL glScaled(GLdouble x, GLdouble y, GLdouble z)
{
    UNUSED_PARAMETER(x);
    UNUSED_PARAMETER(y);
    UNUSED_PARAMETER(z);
    Warning( "glScaled", " not available." );
  }

  static void REGAL_CALL glScalef(GLfloat x, GLfloat y, GLfloat z)
{
    UNUSED_PARAMETER(x);
    UNUSED_PARAMETER(y);
    UNUSED_PARAMETER(z);
    Warning( "glScalef", " not available." );
  }

  static void REGAL_CALL glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
{
    UNUSED_PARAMETER(x);
    UNUSED_PARAMETER(y);
    UNUSED_PARAMETER(width);
    UNUSED_PARAMETER(height);
    Warning( "glScissor", " not available." );
  }

  static void REGAL_CALL glSelectBuffer(GLsizei size, GLuint *buffer)
{
    UNUSED_PARAMETER(size);
    UNUSED_PARAMETER(buffer);
    Warning( "glSelectBuffer", " not available." );
  }

  static void REGAL_CALL glShadeModel(GLenum mode)
{
    UNUSED_PARAMETER(mode);
    Warning( "glShadeModel", " not available." );
  }

  static void REGAL_CALL glStencilFunc(GLenum func, GLint ref, GLuint mask)
{
    UNUSED_PARAMETER(func);
    UNUSED_PARAMETER(ref);
    UNUSED_PARAMETER(mask);
    Warning( "glStencilFunc", " not available." );
  }

  static void REGAL_CALL glStencilMask(GLuint mask)
{
    UNUSED_PARAMETER(mask);
    Warning( "glStencilMask", " not available." );
  }

  static void REGAL_CALL glStencilOp(GLenum fail, GLenum zfail, GLenum zpass)
{
    UNUSED_PARAMETER(fail);
    UNUSED_PARAMETER(zfail);
    UNUSED_PARAMETER(zpass);
    Warning( "glStencilOp", " not available." );
  }

  static void REGAL_CALL glTexCoord1d(GLdouble s)
{
    UNUSED_PARAMETER(s);
    Warning( "glTexCoord1d", " not available." );
  }

  static void REGAL_CALL glTexCoord1dv(const GLdouble *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glTexCoord1dv", " not available." );
  }

  static void REGAL_CALL glTexCoord1f(GLfloat s)
{
    UNUSED_PARAMETER(s);
    Warning( "glTexCoord1f", " not available." );
  }

  static void REGAL_CALL glTexCoord1fv(const GLfloat *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glTexCoord1fv", " not available." );
  }

  static void REGAL_CALL glTexCoord1i(GLint s)
{
    UNUSED_PARAMETER(s);
    Warning( "glTexCoord1i", " not available." );
  }

  static void REGAL_CALL glTexCoord1iv(const GLint *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glTexCoord1iv", " not available." );
  }

  static void REGAL_CALL glTexCoord1s(GLshort s)
{
    UNUSED_PARAMETER(s);
    Warning( "glTexCoord1s", " not available." );
  }

  static void REGAL_CALL glTexCoord1sv(const GLshort *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glTexCoord1sv", " not available." );
  }

  static void REGAL_CALL glTexCoord2d(GLdouble s, GLdouble t)
{
    UNUSED_PARAMETER(s);
    UNUSED_PARAMETER(t);
    Warning( "glTexCoord2d", " not available." );
  }

  static void REGAL_CALL glTexCoord2dv(const GLdouble *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glTexCoord2dv", " not available." );
  }

  static void REGAL_CALL glTexCoord2f(GLfloat s, GLfloat t)
{
    UNUSED_PARAMETER(s);
    UNUSED_PARAMETER(t);
    Warning( "glTexCoord2f", " not available." );
  }

  static void REGAL_CALL glTexCoord2fv(const GLfloat *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glTexCoord2fv", " not available." );
  }

  static void REGAL_CALL glTexCoord2i(GLint s, GLint t)
{
    UNUSED_PARAMETER(s);
    UNUSED_PARAMETER(t);
    Warning( "glTexCoord2i", " not available." );
  }

  static void REGAL_CALL glTexCoord2iv(const GLint *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glTexCoord2iv", " not available." );
  }

  static void REGAL_CALL glTexCoord2s(GLshort s, GLshort t)
{
    UNUSED_PARAMETER(s);
    UNUSED_PARAMETER(t);
    Warning( "glTexCoord2s", " not available." );
  }

  static void REGAL_CALL glTexCoord2sv(const GLshort *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glTexCoord2sv", " not available." );
  }

  static void REGAL_CALL glTexCoord3d(GLdouble s, GLdouble t, GLdouble r)
{
    UNUSED_PARAMETER(s);
    UNUSED_PARAMETER(t);
    UNUSED_PARAMETER(r);
    Warning( "glTexCoord3d", " not available." );
  }

  static void REGAL_CALL glTexCoord3dv(const GLdouble *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glTexCoord3dv", " not available." );
  }

  static void REGAL_CALL glTexCoord3f(GLfloat s, GLfloat t, GLfloat r)
{
    UNUSED_PARAMETER(s);
    UNUSED_PARAMETER(t);
    UNUSED_PARAMETER(r);
    Warning( "glTexCoord3f", " not available." );
  }

  static void REGAL_CALL glTexCoord3fv(const GLfloat *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glTexCoord3fv", " not available." );
  }

  static void REGAL_CALL glTexCoord3i(GLint s, GLint t, GLint r)
{
    UNUSED_PARAMETER(s);
    UNUSED_PARAMETER(t);
    UNUSED_PARAMETER(r);
    Warning( "glTexCoord3i", " not available." );
  }

  static void REGAL_CALL glTexCoord3iv(const GLint *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glTexCoord3iv", " not available." );
  }

  static void REGAL_CALL glTexCoord3s(GLshort s, GLshort t, GLshort r)
{
    UNUSED_PARAMETER(s);
    UNUSED_PARAMETER(t);
    UNUSED_PARAMETER(r);
    Warning( "glTexCoord3s", " not available." );
  }

  static void REGAL_CALL glTexCoord3sv(const GLshort *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glTexCoord3sv", " not available." );
  }

  static void REGAL_CALL glTexCoord4d(GLdouble s, GLdouble t, GLdouble r, GLdouble q)
{
    UNUSED_PARAMETER(s);
    UNUSED_PARAMETER(t);
    UNUSED_PARAMETER(r);
    UNUSED_PARAMETER(q);
    Warning( "glTexCoord4d", " not available." );
  }

  static void REGAL_CALL glTexCoord4dv(const GLdouble *v)
{
    UNUSED_PARAMETER(v);
    Warning( "glTexCoord4dv", " not available." );
  }

  static void REGAL_CALL glTexCoord4f(GLfloat s, GLfloat t, GLfloat r, GLfloat q)
{
    UNUSED_PARAMETER(s);
    UNUSED_PARAMETER(t);
    UNUSED_PARAMETER(r);
    UNUSED_PARAMETER(q);
    Warning( "glTexCoord4f", " not available." );
  }

  static void REGAL_CALL glTexCoord4fv(const GLfloat *v)
…