Import the GLX client side library, formerly from xc/lib/GL/glx. Build it

by adding 'glx/x11' to SRC_DIRS in your build config.

1 files changed, 819 insertions, 0 deletions

diff --git a/src/glx/x11/g_render.c b/src/glx/x11/g_render.c
new file mode 100644
index 00000000000..f632321a1de
--- /dev/null
+++ b/src/glx/x11/g_render.c
@@ -0,0 +1,819 @@
+/* $XFree86: xc/lib/GL/glx/g_render.c,v 1.8 2004/01/28 18:11:38 alanh Exp $ */
+/*
+** License Applicability. Except to the extent portions of this file are
+** made subject to an alternative license as permitted in the SGI Free
+** Software License B, Version 1.1 (the "License"), the contents of this
+** file are subject only to the provisions of the License. You may not use
+** this file except in compliance with the License. You may obtain a copy
+** of the License at Silicon Graphics, Inc., attn: Legal Services, 1600
+** Amphitheatre Parkway, Mountain View, CA 94043-1351, or at:
+** 
+** http://oss.sgi.com/projects/FreeB
+** 
+** Note that, as provided in the License, the Software is distributed on an
+** "AS IS" basis, with ALL EXPRESS AND IMPLIED WARRANTIES AND CONDITIONS
+** DISCLAIMED, INCLUDING, WITHOUT LIMITATION, ANY IMPLIED WARRANTIES AND
+** CONDITIONS OF MERCHANTABILITY, SATISFACTORY QUALITY, FITNESS FOR A
+** PARTICULAR PURPOSE, AND NON-INFRINGEMENT.
+** 
+** Original Code. The Original Code is: OpenGL Sample Implementation,
+** Version 1.2.1, released January 26, 2000, developed by Silicon Graphics,
+** Inc. The Original Code is Copyright (c) 1991-2000 Silicon Graphics, Inc.
+** Copyright in any portions created by third parties is as indicated
+** elsewhere herein. All Rights Reserved.
+** 
+** Additional Notice Provisions: This software was created using the
+** OpenGL(R) version 1.2.1 Sample Implementation published by SGI, but has
+** not been independently verified as being compliant with the OpenGL(R)
+** version 1.2.1 Specification.
+*/
+
+#include "packrender.h"
+#include "size.h"
+
+#define GLdouble_SIZE   8
+#define GLclampd_SIZE   8
+#define GLfloat_SIZE    4
+#define GLclampf_SIZE   4
+#define GLint_SIZE      4
+#define GLuint_SIZE     4
+#define GLenum_SIZE     4
+#define GLbitfield_SIZE 4
+#define GLshort_SIZE    2
+#define GLushort_SIZE   2
+#define GLbyte_SIZE     1
+#define GLubyte_SIZE    1
+#define GLboolean_SIZE  1
+
+#define __GLX_PUT_GLdouble(offset,value)   __GLX_PUT_DOUBLE(offset,value)
+#define __GLX_PUT_GLclampd(offset,value)   __GLX_PUT_DOUBLE(offset,value)
+#define __GLX_PUT_GLfloat(offset,value)    __GLX_PUT_FLOAT(offset,value)
+#define __GLX_PUT_GLclampf(offset,value)   __GLX_PUT_FLOAT(offset,value)
+#define __GLX_PUT_GLint(offset,value)      __GLX_PUT_LONG(offset,value)
+#define __GLX_PUT_GLuint(offset,value)     __GLX_PUT_LONG(offset,value)
+#define __GLX_PUT_GLenum(offset,value)     __GLX_PUT_LONG(offset,value)
+#define __GLX_PUT_GLbitfield(offset,value) __GLX_PUT_LONG(offset,value)
+#define __GLX_PUT_GLshort(offset,value)    __GLX_PUT_SHORT(offset,value)
+#define __GLX_PUT_GLushort(offset,value)   __GLX_PUT_SHORT(offset,value)
+#define __GLX_PUT_GLbyte(offset,value)     __GLX_PUT_CHAR(offset,value)
+#define __GLX_PUT_GLubyte(offset,value)    __GLX_PUT_CHAR(offset,value)
+#define __GLX_PUT_GLboolean(offset,value)  __GLX_PUT_CHAR(offset,value)
+
+#define __GLX_PUT_GLdouble_ARRAY(offset,ptr,count)   __GLX_PUT_DOUBLE_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLclampd_ARRAY(offset,ptr,count)   __GLX_PUT_DOUBLE_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLfloat_ARRAY(offset,ptr,count)    __GLX_PUT_FLOAT_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLclampf_ARRAY(offset,ptr,count)   __GLX_PUT_FLOAT_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLint_ARRAY(offset,ptr,count)      __GLX_PUT_LONG_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLuint_ARRAY(offset,ptr,count)     __GLX_PUT_LONG_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLenum_ARRAY(offset,ptr,count)     __GLX_PUT_LONG_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLshort_ARRAY(offset,ptr,count)    __GLX_PUT_SHORT_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLushort_ARRAY(offset,ptr,count)   __GLX_PUT_SHORT_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLbyte_ARRAY(offset,ptr,count)     __GLX_PUT_CHAR_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLubyte_ARRAY(offset,ptr,count)    __GLX_PUT_CHAR_ARRAY(offset,ptr,count)
+#define __GLX_PUT_GLboolean_ARRAY(offset,ptr,count)  __GLX_PUT_CHAR_ARRAY(offset,ptr,count)
+
+#define RENDER_SIZE(t,c)  (__GLX_PAD(4 + (t ## _SIZE * c)))
+
+/* GLX protocol templates are named in the following manner.  All templates
+ * begin with the string 'glxproto_'.  Following is an optional list of
+ * scalar parameters.  The scalars are listed as type and number.  The most
+ * common being \c enum1 (one scalar enum) and \c enum2 (two scalar enums).
+ *
+ * The final part of the name describes the number of named-type parameters
+ * and how they are passed.
+ * - One or more digits followed by the letter s means
+ *   that the specified number of parameters are passed as scalars.  The macro
+ *   \c glxproto_3s generates a function that takes 3 scalars, such as
+ *   \c glVertex3f.
+ * - A capital C follwed by a lower-case v means that a constant
+ *   sized vector is passed.  Macros of this type take an extra parameter,
+ *   which is the size of the vector.  The invocation
+ *   'glxproto_Cv(Vertex3fv, X_GLrop_Vertexfv, GLfloat, 3)' would generate the
+ *   correct protocol for the \c glVertex3fv function.
+ * - A capital V followed by a lower-case v means that a variable sized
+ *   vector is passed.  The function generated by these macros will call
+ *   a co-function to determine the size of the vector.  The name of the
+ *   co-function is generated by prepending \c __gl and appending \c _size
+ *   to the base name of the function.  The invocation
+ *   'glxproto_enum1_Vv(Fogiv, X_GLrop_Fogiv, GLint)' would generate the
+ *   correct protocol for the \c glFogiv function.
+ * - One or more digits without a following letter means that a function
+ *   taking the specified number of scalar parameters and a function with a
+ *   vector parameter of the specified size should be generated.  The letter
+ *   v is automatically appended to the name of the vector-based function in
+ *   this case.  The invocation
+ *   'glxproto_3(Vertex3f, X_GLrop_Vertex3fv, GLfloat)' would generate the
+ *   correct protocol for both \c glVertex3f and \c glVertex3fv.
+ *
+ * glxproto_void is a special case for functions that take no parameters
+ * (i.e., glEnd).
+ *
+ * An addition form is 'glxvendr_'.  This is identical to the other forms
+ * with the exception of taking an additional parameter (to the macro) which
+ * is a vendor string to append to the function name.  The invocation
+ * 'glxproto_3(Foo3f, X_GLrop_Foo3fv, GLfloat)' would generate the functions
+ * 'glFoo3fv' and 'glFoo3f', and the invocation
+ * 'glxvendr_3(Foo3f, X_GLrop_Foo3fv, GLfloat, EXT)' would generate the
+ * functions 'glFoo3fvEXT' and 'glFoo3fEXT'.
+ */
+
+#define glxproto_void(name, rop) \
+   void __indirect_gl ## name (void) \
+   { \
+	__GLX_DECLARE_VARIABLES(); \
+	__GLX_LOAD_VARIABLES(); \
+	__GLX_BEGIN(rop, 4); \
+	__GLX_END(4); \
+   }
+
+#define glxproto_Cv(name, rop, type, count) \
+   void __indirect_gl ## name (const type * v) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = RENDER_SIZE(type, count); \
+      __GLX_BEGIN(rop, cmdlen); \
+      if (count <= 4) { \
+	                  __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v[0]); \
+	 if (count > 1) { __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v[1]); } \
+	 if (count > 2) { __GLX_PUT_ ## type (4 + (2 * type ## _SIZE), v[2]); } \
+	 if (count > 3) { __GLX_PUT_ ## type (4 + (3 * type ## _SIZE), v[3]); } \
+      } else { \
+	 __GLX_PUT_ ## type ## _ARRAY(4, v, count); \
+      } \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_Cv_transpose(name, rop, type, w) \
+   void __indirect_gl ## name (const type * v) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      type t[ w * w ]; unsigned i, j; \
+      for (i = 0; i < w; i++) { \
+	 for (j = 0; j < w; j++) { \
+	    t[i*w+j] = v[j*w+i]; \
+	 } \
+      } \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = RENDER_SIZE(type, (w * w)); \
+      __GLX_BEGIN(rop, cmdlen); \
+      __GLX_PUT_ ## type ## _ARRAY(4, t, (w * w)); \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_1s(name, rop, type) \
+   void __indirect_gl ## name (type v1) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = RENDER_SIZE(type, 1); \
+      __GLX_BEGIN(rop, cmdlen); \
+      __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v1); \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_2s(name, rop, type) \
+   void __indirect_gl ## name (type v1, type v2) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = RENDER_SIZE(type, 2); \
+      __GLX_BEGIN(rop, cmdlen); \
+      __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v1); \
+      __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v2); \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_3s(name, rop, type) \
+   void __indirect_gl ## name (type v1, type v2, type v3) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = RENDER_SIZE(type, 3); \
+      __GLX_BEGIN(rop, cmdlen); \
+      __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v1); \
+      __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v2); \
+      __GLX_PUT_ ## type (4 + (2 * type ## _SIZE), v3); \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_4s(name, rop, type) \
+   void __indirect_gl ## name (type v1, type v2, type v3, type v4) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = RENDER_SIZE(type, 4); \
+      __GLX_BEGIN(rop, cmdlen); \
+      __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v1); \
+      __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v2); \
+      __GLX_PUT_ ## type (4 + (2 * type ## _SIZE), v3); \
+      __GLX_PUT_ ## type (4 + (3 * type ## _SIZE), v4); \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_6s(name, rop, type) \
+   void __indirect_gl ## name (type v1, type v2, type v3, type v4, type v5, type v6) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = RENDER_SIZE(type, 6); \
+      __GLX_BEGIN(rop, cmdlen); \
+      __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v1); \
+      __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v2); \
+      __GLX_PUT_ ## type (4 + (2 * type ## _SIZE), v3); \
+      __GLX_PUT_ ## type (4 + (3 * type ## _SIZE), v4); \
+      __GLX_PUT_ ## type (4 + (4 * type ## _SIZE), v5); \
+      __GLX_PUT_ ## type (4 + (5 * type ## _SIZE), v6); \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_enum1_1s(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, type v1) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = 4 + RENDER_SIZE(type, 1); \
+      __GLX_BEGIN(rop, cmdlen); \
+      if (type ## _SIZE == 8) { \
+	 __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v1); \
+	 __GLX_PUT_LONG     (4 + (1 * type ## _SIZE), e); \
+      } else { \
+	 __GLX_PUT_LONG(4, e); \
+	 __GLX_PUT_ ## type (8 + (0 * type ## _SIZE), v1); \
+      } \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_enum1_1v(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, const type * v) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = 4 + RENDER_SIZE(type, 1); \
+      __GLX_BEGIN(rop, cmdlen); \
+      if (type ## _SIZE == 8) { \
+	 __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v[0]); \
+	 __GLX_PUT_LONG     (4 + (1 * type ## _SIZE), e); \
+      } else { \
+	 __GLX_PUT_LONG(4, e); \
+	 __GLX_PUT_ ## type (8 + (0 * type ## _SIZE), v[0]); \
+      } \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_enum1_2s(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, type v1, type v2) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = 4 + RENDER_SIZE(type, 2); \
+      __GLX_BEGIN(rop, cmdlen); \
+      if (type ## _SIZE == 8) { \
+	 __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v1); \
+	 __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v2); \
+	 __GLX_PUT_LONG     (4 + (2 * type ## _SIZE), e); \
+      } else { \
+	 __GLX_PUT_LONG(4, e); \
+	 __GLX_PUT_ ## type (8 + (0 * type ## _SIZE), v1); \
+	 __GLX_PUT_ ## type (8 + (1 * type ## _SIZE), v2); \
+      } \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_enum1_2v(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, const type * v) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = 4 + RENDER_SIZE(type, 2); \
+      __GLX_BEGIN(rop, cmdlen); \
+      if (type ## _SIZE == 8) { \
+	 __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v[0]); \
+	 __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v[1]); \
+	 __GLX_PUT_LONG     (4 + (2 * type ## _SIZE), e); \
+      } else { \
+	 __GLX_PUT_LONG(4, e); \
+	 __GLX_PUT_ ## type (8 + (0 * type ## _SIZE), v[0]); \
+	 __GLX_PUT_ ## type (8 + (1 * type ## _SIZE), v[1]); \
+      } \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_enum1_3s(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, type v1, type v2, type v3) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = 4 + RENDER_SIZE(type, 3); \
+      __GLX_BEGIN(rop, cmdlen); \
+      if (type ## _SIZE == 8) { \
+	 __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v1); \
+	 __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v2); \
+	 __GLX_PUT_ ## type (4 + (2 * type ## _SIZE), v3); \
+	 __GLX_PUT_LONG     (4 + (3 * type ## _SIZE), e); \
+      } else { \
+	 __GLX_PUT_LONG(4, e); \
+	 __GLX_PUT_ ## type (8 + (0 * type ## _SIZE), v1); \
+	 __GLX_PUT_ ## type (8 + (1 * type ## _SIZE), v2); \
+	 __GLX_PUT_ ## type (8 + (2 * type ## _SIZE), v3); \
+      } \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_enum1_3v(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, const type * v) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = 4 + RENDER_SIZE(type, 3); \
+      __GLX_BEGIN(rop, cmdlen); \
+      if (type ## _SIZE == 8) { \
+	 __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v[0]); \
+	 __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v[1]); \
+	 __GLX_PUT_ ## type (4 + (2 * type ## _SIZE), v[2]); \
+	 __GLX_PUT_LONG     (4 + (3 * type ## _SIZE), e); \
+      } else { \
+	 __GLX_PUT_LONG(4, e); \
+	 __GLX_PUT_ ## type (8 + (0 * type ## _SIZE), v[0]); \
+	 __GLX_PUT_ ## type (8 + (1 * type ## _SIZE), v[1]); \
+	 __GLX_PUT_ ## type (8 + (2 * type ## _SIZE), v[2]); \
+      } \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_enum1_4s(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, type v1, type v2, type v3, type v4) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = 4 + RENDER_SIZE(type, 4); \
+      __GLX_BEGIN(rop, cmdlen); \
+      if (type ## _SIZE == 8) { \
+	 __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v1); \
+	 __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v2); \
+	 __GLX_PUT_ ## type (4 + (2 * type ## _SIZE), v3); \
+	 __GLX_PUT_ ## type (4 + (3 * type ## _SIZE), v4); \
+	 __GLX_PUT_LONG     (4 + (4 * type ## _SIZE), e); \
+      } else { \
+	 __GLX_PUT_LONG(4, e); \
+	 __GLX_PUT_ ## type (8 + (0 * type ## _SIZE), v1); \
+	 __GLX_PUT_ ## type (8 + (1 * type ## _SIZE), v2); \
+	 __GLX_PUT_ ## type (8 + (2 * type ## _SIZE), v3); \
+	 __GLX_PUT_ ## type (8 + (3 * type ## _SIZE), v4); \
+      } \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_enum1_4v(name, rop, type) \
+   void __indirect_gl ## name (GLenum e, const type * v) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = 4 + RENDER_SIZE(type, 4); \
+      __GLX_BEGIN(rop, cmdlen); \
+      if (type ## _SIZE == 8) { \
+	 __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v[0]); \
+	 __GLX_PUT_ ## type (4 + (1 * type ## _SIZE), v[1]); \
+	 __GLX_PUT_ ## type (4 + (2 * type ## _SIZE), v[2]); \
+	 __GLX_PUT_ ## type (4 + (3 * type ## _SIZE), v[3]); \
+	 __GLX_PUT_LONG     (4 + (4 * type ## _SIZE), e); \
+      } else { \
+	 __GLX_PUT_LONG(4, e); \
+	 __GLX_PUT_ ## type (8 + (0 * type ## _SIZE), v[0]); \
+	 __GLX_PUT_ ## type (8 + (1 * type ## _SIZE), v[1]); \
+	 __GLX_PUT_ ## type (8 + (2 * type ## _SIZE), v[2]); \
+	 __GLX_PUT_ ## type (8 + (3 * type ## _SIZE), v[3]); \
+      } \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_enum1_Vv(name, rop, type) \
+   void __indirect_gl ## name (GLenum pname, const type * v) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      compsize = __gl ## name ## _size(pname); \
+      cmdlen = 4 + RENDER_SIZE(type, compsize); \
+      __GLX_BEGIN(rop, cmdlen); \
+      __GLX_PUT_LONG(4, pname); \
+      __GLX_PUT_ ## type ## _ARRAY(8, v, compsize); \
+      __GLX_END(cmdlen); \
+   }
+    
+#define glxproto_enum2_1s(name, rop, type) \
+   void __indirect_gl ## name (GLenum target, GLenum pname, type v1) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      cmdlen = 8 + RENDER_SIZE(type, 1); \
+      __GLX_BEGIN(rop, cmdlen); \
+      if (type ## _SIZE == 8) { \
+	 __GLX_PUT_ ## type (4 + (0 * type ## _SIZE), v1); \
+	 __GLX_PUT_LONG     (4 + (1 * type ## _SIZE), target); \
+	 __GLX_PUT_LONG     (8 + (1 * type ## _SIZE), pname); \
+      } else { \
+	 __GLX_PUT_LONG(4, target); \
+	 __GLX_PUT_LONG(8, pname); \
+	 __GLX_PUT_ ## type (12 + (0 * type ## _SIZE), v1); \
+      } \
+      __GLX_END(cmdlen); \
+   }
+
+#define glxproto_enum2_Vv(name, rop, type) \
+   void __indirect_gl ## name (GLenum target, GLenum pname, const type * v) \
+   { \
+      __GLX_DECLARE_VARIABLES(); \
+      __GLX_LOAD_VARIABLES(); \
+      compsize = __gl ## name ## _size(pname); \
+      cmdlen =  8 + RENDER_SIZE(type, compsize); \
+      __GLX_BEGIN(rop, cmdlen); \
+      __GLX_PUT_LONG(4, target); \
+      __GLX_PUT_LONG(8, pname); \
+      __GLX_PUT_ ## type ## _ARRAY(12, v, compsize); \
+      __GLX_END(cmdlen); \
+   }
+
+#define GENERATE_GLX_PROTOCOL_FUNCTIONS
+#include "indirect.h"
+
+void __indirect_glRectdv(const GLdouble *v1, const GLdouble *v2)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_Rectdv,36);
+	__GLX_PUT_DOUBLE(4,v1[0]);
+	__GLX_PUT_DOUBLE(12,v1[1]);
+	__GLX_PUT_DOUBLE(20,v2[0]);
+	__GLX_PUT_DOUBLE(28,v2[1]);
+	__GLX_END(36);
+}
+
+void __indirect_glRectfv(const GLfloat *v1, const GLfloat *v2)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_Rectfv,20);
+	__GLX_PUT_FLOAT(4,v1[0]);
+	__GLX_PUT_FLOAT(8,v1[1]);
+	__GLX_PUT_FLOAT(12,v2[0]);
+	__GLX_PUT_FLOAT(16,v2[1]);
+	__GLX_END(20);
+}
+
+void __indirect_glRectiv(const GLint *v1, const GLint *v2)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_Rectiv,20);
+	__GLX_PUT_LONG(4,v1[0]);
+	__GLX_PUT_LONG(8,v1[1]);
+	__GLX_PUT_LONG(12,v2[0]);
+	__GLX_PUT_LONG(16,v2[1]);
+	__GLX_END(20);
+}
+
+void __indirect_glRectsv(const GLshort *v1, const GLshort *v2)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_Rectsv,12);
+	__GLX_PUT_SHORT(4,v1[0]);
+	__GLX_PUT_SHORT(6,v1[1]);
+	__GLX_PUT_SHORT(8,v2[0]);
+	__GLX_PUT_SHORT(10,v2[1]);
+	__GLX_END(12);
+}
+
+void __indirect_glLineStipple(GLint factor, GLushort pattern)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_LineStipple,12);
+	__GLX_PUT_LONG(4,factor);
+	__GLX_PUT_SHORT(8,pattern);
+	__GLX_END(12);
+}
+
+void __indirect_glScissor(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_Scissor,20);
+	__GLX_PUT_LONG(4,x);
+	__GLX_PUT_LONG(8,y);
+	__GLX_PUT_LONG(12,width);
+	__GLX_PUT_LONG(16,height);
+	__GLX_END(20);
+}
+
+void __indirect_glMapGrid1d(GLint un, GLdouble u1, GLdouble u2)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_MapGrid1d,24);
+	__GLX_PUT_DOUBLE(4,u1);
+	__GLX_PUT_DOUBLE(12,u2);
+	__GLX_PUT_LONG(20,un);
+	__GLX_END(24);
+}
+
+void __indirect_glMapGrid1f(GLint un, GLfloat u1, GLfloat u2)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_MapGrid1f,16);
+	__GLX_PUT_LONG(4,un);
+	__GLX_PUT_FLOAT(8,u1);
+	__GLX_PUT_FLOAT(12,u2);
+	__GLX_END(16);
+}
+
+void __indirect_glMapGrid2d(GLint un, GLdouble u1, GLdouble u2, GLint vn, GLdouble v1, GLdouble v2)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_MapGrid2d,44);
+	__GLX_PUT_DOUBLE(4,u1);
+	__GLX_PUT_DOUBLE(12,u2);
+	__GLX_PUT_DOUBLE(20,v1);
+	__GLX_PUT_DOUBLE(28,v2);
+	__GLX_PUT_LONG(36,un);
+	__GLX_PUT_LONG(40,vn);
+	__GLX_END(44);
+}
+
+void __indirect_glMapGrid2f(GLint un, GLfloat u1, GLfloat u2, GLint vn, GLfloat v1, GLfloat v2)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_MapGrid2f,28);
+	__GLX_PUT_LONG(4,un);
+	__GLX_PUT_FLOAT(8,u1);
+	__GLX_PUT_FLOAT(12,u2);
+	__GLX_PUT_LONG(16,vn);
+	__GLX_PUT_FLOAT(20,v1);
+	__GLX_PUT_FLOAT(24,v2);
+	__GLX_END(28);
+}
+
+void __indirect_glStencilFunc(GLenum func, GLint ref, GLuint mask)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_StencilFunc,16);
+	__GLX_PUT_LONG(4,func);
+	__GLX_PUT_LONG(8,ref);
+	__GLX_PUT_LONG(12,mask);
+	__GLX_END(16);
+}
+
+void __indirect_glCopyPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum type)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_CopyPixels,24);
+	__GLX_PUT_LONG(4,x);
+	__GLX_PUT_LONG(8,y);
+	__GLX_PUT_LONG(12,width);
+	__GLX_PUT_LONG(16,height);
+	__GLX_PUT_LONG(20,type);
+	__GLX_END(24);
+}
+
+void __indirect_glViewport(GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_Viewport,20);
+	__GLX_PUT_LONG(4,x);
+	__GLX_PUT_LONG(8,y);
+	__GLX_PUT_LONG(12,width);
+	__GLX_PUT_LONG(16,height);
+	__GLX_END(20);
+}
+
+void __indirect_glCopyTexImage1D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLint border)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_CopyTexImage1D,32);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_LONG(8,level);
+	__GLX_PUT_LONG(12,internalformat);
+	__GLX_PUT_LONG(16,x);
+	__GLX_PUT_LONG(20,y);
+	__GLX_PUT_LONG(24,width);
+	__GLX_PUT_LONG(28,border);
+	__GLX_END(32);
+}
+
+void __indirect_glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_CopyTexImage2D,36);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_LONG(8,level);
+	__GLX_PUT_LONG(12,internalformat);
+	__GLX_PUT_LONG(16,x);
+	__GLX_PUT_LONG(20,y);
+	__GLX_PUT_LONG(24,width);
+	__GLX_PUT_LONG(28,height);
+	__GLX_PUT_LONG(32,border);
+	__GLX_END(36);
+}
+
+void __indirect_glCopyTexSubImage1D(GLenum target, GLint level, GLint xoffset, GLint x, GLint y, GLsizei width)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_CopyTexSubImage1D,28);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_LONG(8,level);
+	__GLX_PUT_LONG(12,xoffset);
+	__GLX_PUT_LONG(16,x);
+	__GLX_PUT_LONG(20,y);
+	__GLX_PUT_LONG(24,width);
+	__GLX_END(28);
+}
+
+void __indirect_glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_CopyTexSubImage2D,36);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_LONG(8,level);
+	__GLX_PUT_LONG(12,xoffset);
+	__GLX_PUT_LONG(16,yoffset);
+	__GLX_PUT_LONG(20,x);
+	__GLX_PUT_LONG(24,y);
+	__GLX_PUT_LONG(28,width);
+	__GLX_PUT_LONG(32,height);
+	__GLX_END(36);
+}
+
+void __indirect_glPrioritizeTextures(GLsizei n, const GLuint *textures, const GLclampf *priorities)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	if (n < 0) return;
+	cmdlen = 8+n*4+n*4;
+	__GLX_BEGIN(X_GLrop_PrioritizeTextures,cmdlen);
+	__GLX_PUT_LONG(4,n);
+	__GLX_PUT_LONG_ARRAY(8,textures,n);
+	__GLX_PUT_FLOAT_ARRAY(8+n*4,priorities,n);
+	__GLX_END(cmdlen);
+}
+
+void __indirect_glCopyColorTable(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_CopyColorTable,24);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_LONG(8,internalformat);
+	__GLX_PUT_LONG(12,x);
+	__GLX_PUT_LONG(16,y);
+	__GLX_PUT_LONG(20,width);
+	__GLX_END(24);
+}
+
+void __indirect_glCopyColorSubTable(GLenum target, GLsizei start, GLint x, GLint y, GLsizei width)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_CopyColorSubTable,24);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_LONG(8,start);
+	__GLX_PUT_LONG(12,x);
+	__GLX_PUT_LONG(16,y);
+	__GLX_PUT_LONG(20,width);
+	__GLX_END(24);
+}
+
+void __indirect_glCopyConvolutionFilter1D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_CopyConvolutionFilter1D,24);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_LONG(8,internalformat);
+	__GLX_PUT_LONG(12,x);
+	__GLX_PUT_LONG(16,y);
+	__GLX_PUT_LONG(20,width);
+	__GLX_END(24);
+}
+
+void __indirect_glCopyConvolutionFilter2D(GLenum target, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_CopyConvolutionFilter2D,28);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_LONG(8,internalformat);
+	__GLX_PUT_LONG(12,x);
+	__GLX_PUT_LONG(16,y);
+	__GLX_PUT_LONG(20,width);
+	__GLX_PUT_LONG(24,height);
+	__GLX_END(28);
+}
+
+void __indirect_glHistogram(GLenum target, GLsizei width, GLenum internalformat, GLboolean sink)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_Histogram,20);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_LONG(8,width);
+	__GLX_PUT_LONG(12,internalformat);
+	__GLX_PUT_CHAR(16,sink);
+	__GLX_END(20);
+}
+
+void __indirect_glCopyTexSubImage3D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLint x, GLint y, GLsizei width, GLsizei height)
+{
+	__GLX_DECLARE_VARIABLES();
+	__GLX_LOAD_VARIABLES();
+	__GLX_BEGIN(X_GLrop_CopyTexSubImage3D,40);
+	__GLX_PUT_LONG(4,target);
+	__GLX_PUT_LONG(8,level);
+	__GLX_PUT_LONG(12,xoffset);
+	__GLX_PUT_LONG(16,yoffset);
+	__GLX_PUT_LONG(20,zoffset);
+	__GLX_PUT_LONG(24,x);
+	__GLX_PUT_LONG(28,y);
+	__GLX_PUT_LONG(32,width);
+	__GLX_PUT_LONG(36,height);
+	__GLX_END(40);
+}
+
+void __indirect_glWindowPos2dARB(GLdouble x, GLdouble y)
+{
+	__indirect_glWindowPos3fARB(x, y, 0.0);
+}
+
+void __indirect_glWindowPos2iARB(GLint x, GLint y)
+{
+	__indirect_glWindowPos3fARB(x, y, 0.0);
+}
+
+void __indirect_glWindowPos2fARB(GLfloat x, GLfloat y)
+{
+	__indirect_glWindowPos3fARB(x, y, 0.0);
+}
+
+void __indirect_glWindowPos2sARB(GLshort x, GLshort y)
+{
+	__indirect_glWindowPos3fARB(x, y, 0.0);
+}
+
+void __indirect_glWindowPos2dvARB(const GLdouble * p)
+{
+	__indirect_glWindowPos3fARB(p[0], p[1], 0.0);
+}
+
+void __indirect_glWindowPos2fvARB(const GLfloat * p)
+{
+	__indirect_glWindowPos3fARB(p[0], p[1], 0.0);
+}
+
+void __indirect_glWindowPos2ivARB(const GLint * p)
+{
+	__indirect_glWindowPos3fARB(p[0], p[1], 0.0);
+}
+
+void __indirect_glWindowPos2svARB(const GLshort * p)
+{
+	__indirect_glWindowPos3fARB(p[0], p[1], 0.0);
+}
+
+void __indirect_glWindowPos3dARB(GLdouble x, GLdouble y, GLdouble z)
+{
+	__indirect_glWindowPos3fARB(x, y, z);
+}
+
+void __indirect_glWindowPos3iARB(GLint x, GLint y, GLint z)
+{
+	__indirect_glWindowPos3fARB(x, y, z);
+}
+
+void __indirect_glWindowPos3sARB(GLshort x, GLshort y, GLshort z)
+{
+	__indirect_glWindowPos3fARB(x, y, z);
+}
+
+void __indirect_glWindowPos3dvARB(const GLdouble * p)
+{
+	__indirect_glWindowPos3fARB(p[0], p[1], p[2]);
+}
+
+void __indirect_glWindowPos3ivARB(const GLint * p)
+{
+	__indirect_glWindowPos3fARB(p[0], p[1], p[2]);
+}
+
+void __indirect_glWindowPos3svARB(const GLshort * p)
+{
+	__indirect_glWindowPos3fARB(p[0], p[1], p[2]);
+}