Initial revision

1 files changed, 635 insertions, 0 deletions

diff --git a/src/mesa/main/dd.h b/src/mesa/main/dd.h
new file mode 100644
index 00000000000..479d73edd12
--- /dev/null
+++ b/src/mesa/main/dd.h
@@ -0,0 +1,635 @@
+/* $Id: dd.h,v 1.1 1999/08/19 00:55:41 jtg Exp $ */
+
+/*
+ * Mesa 3-D graphics library
+ * Version:  3.1
+ * 
+ * Copyright (C) 1999  Brian Paul   All Rights Reserved.
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a
+ * copy of this software and associated documentation files (the "Software"),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included
+ * in all copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+ * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
+ * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+ * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+
+
+#ifndef DD_INCLUDED
+#define DD_INCLUDED
+
+
+#include "macros.h"
+
+
+struct gl_pixelstore_attrib;
+
+
+struct vertex_buffer;
+struct immediate;
+struct gl_pipeline_stage;
+
+
+/* THIS FILE ONLY INCLUDED BY types.h !!!!! */
+
+
+/*
+ *                      Device Driver (DD) interface
+ *
+ *
+ * All device driver functions are accessed through pointers in the
+ * dd_function_table struct (defined below) which is stored in the GLcontext
+ * struct.  Since the device driver is strictly accessed trough a table of
+ * function pointers we can:
+ *   1. switch between a number of different device drivers at runtime.
+ *   2. use optimized functions dependant on current rendering state or
+ *      frame buffer configuration.
+ *
+ * The function pointers in the dd_function_table struct are divided into
+ * two groups:  mandatory and optional.
+ * Mandatory functions have to be implemented by every device driver.
+ * Optional functions may or may not be implemented by the device driver.
+ * The optional functions provide ways to take advantage of special hardware
+ * or optimized algorithms.
+ *
+ * The function pointers in the dd_function_table struct are first
+ * initialized in the "MakeCurrent" function.  The "MakeCurrent" function
+ * is a little different in each device driver.  See the X/Mesa, GLX, or
+ * OS/Mesa drivers for examples.
+ *
+ * Later, Mesa may call the dd_function_table's UpdateState() function.
+ * This function should initialize the dd_function_table's pointers again.
+ * The UpdateState() function is called whenever the core (GL) rendering
+ * state is changed in a way which may effect rasterization.  For example,
+ * the TriangleFunc() pointer may have to point to different functions
+ * depending on whether smooth or flat shading is enabled.
+ *
+ * Note that the first argument to every device driver function is a
+ * GLcontext *.  In turn, the GLcontext->DriverCtx pointer points to
+ * the driver-specific context struct.  See the X/Mesa or OS/Mesa interface
+ * for an example.
+ *
+ * For more information about writing a device driver see the ddsample.c
+ * file and other device drivers (xmesa[123].c, osmesa.c, etc) for examples.
+ *
+ *
+ * Look below in the dd_function_table struct definition for descriptions
+ * of each device driver function.
+ * 
+ *
+ * In the future more function pointers may be added for glReadPixels
+ * glCopyPixels, etc.
+ *
+ *
+ * Notes:
+ * ------
+ *   RGBA = red/green/blue/alpha
+ *   CI = color index (color mapped mode)
+ *   mono = all pixels have the same color or index
+ *
+ *   The write_ functions all take an array of mask flags which indicate
+ *   whether or not the pixel should be written.  One special case exists
+ *   in the write_color_span function: if the mask array is NULL, then
+ *   draw all pixels.  This is an optimization used for glDrawPixels().
+ *
+ * IN ALL CASES:
+ *      X coordinates start at 0 at the left and increase to the right
+ *      Y coordinates start at 0 at the bottom and increase upward
+ *
+ */
+
+
+
+
+/* Used by the GetParameteri device driver function */
+#define DD_HAVE_HARDWARE_FOG         3
+
+
+
+
+
+/*
+ * Device Driver function table.
+ */
+struct dd_function_table {
+
+   /**********************************************************************
+    *** Mandatory functions:  these functions must be implemented by   ***
+    *** every device driver.                                           ***
+    **********************************************************************/
+
+   const char * (*RendererString)(void);
+   /*
+    * Return a string which uniquely identifies this device driver.
+    * The string should contain no whitespace.  Examples: "X11" "OffScreen"
+    * "MSWindows" "SVGA".
+    * NOTE: This function will be obsolete in favor of GetString in the future!
+    */
+
+   void (*UpdateState)( GLcontext *ctx );
+   /*
+    * UpdateState() is called whenver Mesa thinks the device driver should
+    * update its state and/or the other pointers (such as PointsFunc,
+    * LineFunc, or TriangleFunc).
+    */
+
+   void (*ClearIndex)( GLcontext *ctx, GLuint index );
+   /*
+    * Called whenever glClearIndex() is called.  Set the index for clearing
+    * the color buffer.
+    */
+
+   void (*ClearColor)( GLcontext *ctx, GLubyte red, GLubyte green,
+                                        GLubyte blue, GLubyte alpha );
+   /*
+    * Called whenever glClearColor() is called.  Set the color for clearing
+    * the color buffer.
+    */
+
+   GLbitfield (*Clear)( GLcontext *ctx, GLbitfield mask, GLboolean all,
+                        GLint x, GLint y, GLint width, GLint height );
+   /* Clear the color/depth/stencil/accum buffer(s).
+    * 'mask' indicates which buffers need to be cleared.  Return a bitmask
+    *    indicating which buffers weren't cleared by the driver function.
+    * If 'all' is true then the clear the whole buffer, else clear the
+    *    region defined by (x,y,width,height).
+    */
+
+   void (*Index)( GLcontext *ctx, GLuint index );
+   /*
+    * Sets current color index for drawing flat-shaded primitives.
+    */
+
+   void (*Color)( GLcontext *ctx,
+                  GLubyte red, GLubyte green, GLubyte glue, GLubyte alpha );
+   /*
+    * Sets current color for drawing flat-shaded primitives.
+    */
+
+   GLboolean (*SetBuffer)( GLcontext *ctx, GLenum buffer );
+   /*
+    * Selects the color buffer(s) for reading and writing.
+    * The following values must be accepted when applicable:
+    *    GL_FRONT_LEFT - this buffer always exists
+    *    GL_BACK_LEFT - when double buffering
+    *    GL_FRONT_RIGHT - when using stereo
+    *    GL_BACK_RIGHT - when using stereo and double buffering
+    * The folowing values may optionally be accepted.  Return GL_TRUE
+    * if accepted, GL_FALSE if not accepted.  In practice, only drivers
+    * which can write to multiple color buffers at once should accept
+    * these values.
+    *    GL_FRONT - write to front left and front right if it exists
+    *    GL_BACK - write to back left and back right if it exists
+    *    GL_LEFT - write to front left and back left if it exists
+    *    GL_RIGHT - write to right left and back right if they exist
+    *    GL_FRONT_AND_BACK - write to all four buffers if they exist
+    *    GL_NONE - disable buffer write in device driver.
+    */
+
+   void (*GetBufferSize)( GLcontext *ctx,
+                          GLuint *width, GLuint *height );
+   /*
+    * Returns the width and height of the current color buffer.
+    */
+
+
+   /***
+    *** Functions for writing pixels to the frame buffer:
+    ***/
+
+   void (*WriteRGBASpan)( const GLcontext *ctx,
+                          GLuint n, GLint x, GLint y,
+                          CONST GLubyte rgba[][4], const GLubyte mask[] );
+   void (*WriteRGBSpan)( const GLcontext *ctx,
+                         GLuint n, GLint x, GLint y,
+                         CONST GLubyte rgb[][3], const GLubyte mask[] );
+   /* Write a horizontal run of RGB[A] pixels.  The later version is only
+    * used to accelerate GL_RGB, GL_UNSIGNED_BYTE glDrawPixels() calls.
+    */
+
+   void (*WriteMonoRGBASpan)( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                              const GLubyte mask[] );
+   /* Write a horizontal run of mono-RGBA pixels.
+    */
+
+   void (*WriteRGBAPixels)( const GLcontext *ctx,
+                            GLuint n, const GLint x[], const GLint y[],
+                            CONST GLubyte rgba[][4], const GLubyte mask[] );
+   /* Write array of RGBA pixels at random locations.
+    */
+
+   void (*WriteMonoRGBAPixels)( const GLcontext *ctx,
+                                GLuint n, const GLint x[], const GLint y[],
+                                const GLubyte mask[] );
+   /* Write an array of mono-RGBA pixels at random locations.
+    */
+
+   void (*WriteCI32Span)( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                          const GLuint index[], const GLubyte mask[] );
+   void (*WriteCI8Span)( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                         const GLubyte index[], const GLubyte mask[] );
+   /* Write a horizontal run of CI pixels.  32 or 8bpp.
+    */
+
+   void (*WriteMonoCISpan)( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                            const GLubyte mask[] );
+   /* Write a horizontal run of mono-CI pixels.
+    */
+
+   void (*WriteCI32Pixels)( const GLcontext *ctx,
+                            GLuint n, const GLint x[], const GLint y[],
+                            const GLuint index[], const GLubyte mask[] );
+   /*
+    * Write a random array of CI pixels.
+    */
+
+   void (*WriteMonoCIPixels)( const GLcontext *ctx,
+                              GLuint n, const GLint x[], const GLint y[],
+                              const GLubyte mask[] );
+   /*
+    * Write a random array of mono-CI pixels.
+    */
+
+
+   /***
+    *** Functions to read pixels from frame buffer:
+    ***/
+
+   void (*ReadCI32Span)( const GLcontext *ctx,
+                         GLuint n, GLint x, GLint y, GLuint index[] );
+   /* Read a horizontal run of color index pixels.
+    */
+
+   void (*ReadRGBASpan)( const GLcontext *ctx, GLuint n, GLint x, GLint y,
+                         GLubyte rgba[][4] );
+   /* Read a horizontal run of RGBA pixels.
+    */
+
+   void (*ReadCI32Pixels)( const GLcontext *ctx,
+                           GLuint n, const GLint x[], const GLint y[],
+                           GLuint indx[], const GLubyte mask[] );
+   /* Read a random array of CI pixels.
+    */
+
+   void (*ReadRGBAPixels)( const GLcontext *ctx,
+                           GLuint n, const GLint x[], const GLint y[],
+                           GLubyte rgba[][4], const GLubyte mask[] );
+   /* Read a random array of RGBA pixels.
+    */
+
+
+   /**********************************************************************
+    *** Optional functions:  these functions may or may not be         ***
+    *** implemented by the device driver.  If the device driver        ***
+    *** doesn't implement them it should never touch these pointers    ***
+    *** since Mesa will either set them to NULL or point them at a     ***
+    *** fall-back function.                                            ***
+    **********************************************************************/
+
+   const char * (*ExtensionString)( GLcontext *ctx );
+   /* Return a space-separated list of extensions for this driver.
+    * NOTE: This function will be obsolete in favor of GetString in the future!
+    */
+
+   const GLubyte * (*GetString)( GLcontext *ctx, GLenum name );
+   /* Return a string as needed by glGetString().
+    * NOTE: This will replace the ExtensionString and RendererString
+    * functions in the future!
+    */
+
+   void (*Finish)( GLcontext *ctx );
+   /*
+    * Called whenever glFinish() is called.
+    */
+
+   void (*Flush)( GLcontext *ctx );
+   /*
+    * Called whenever glFlush() is called.
+    */
+
+   GLboolean (*IndexMask)( GLcontext *ctx, GLuint mask );
+   /*
+    * Implements glIndexMask() if possible, else return GL_FALSE.
+    */
+
+   GLboolean (*ColorMask)( GLcontext *ctx,
+                           GLboolean rmask, GLboolean gmask,
+                           GLboolean bmask, GLboolean amask );
+   /*
+    * Implements glColorMask() if possible, else return GL_FALSE.
+    */
+
+   GLboolean (*LogicOp)( GLcontext *ctx, GLenum op );
+   /*
+    * Implements glLogicOp() if possible, else return GL_FALSE.
+    */
+
+   void (*Dither)( GLcontext *ctx, GLboolean enable );
+   /*
+    * Enable/disable dithering.
+    * NOTE: This function will be removed in the future in favor
+    * of the "Enable" driver function.
+    */
+
+   void (*Error)( GLcontext *ctx );
+   /*
+    * Called whenever an error is generated.  ctx->ErrorValue contains
+    * the error value.
+    */
+
+   void (*NearFar)( GLcontext *ctx, GLfloat nearVal, GLfloat farVal );
+   /*
+    * Called from glFrustum and glOrtho to tell device driver the
+    * near and far clipping plane Z values.  The 3Dfx driver, for example,
+    * uses this.
+    */
+
+   GLint (*GetParameteri)( const GLcontext *ctx, GLint param );
+   /* Query the device driver to get an integer parameter.
+    * Current parameters:
+    *     DD_MAX_TEXTURE_SIZE         return maximum texture size
+    *
+    *     DD_MAX_TEXTURES             number of texture sets/stages, usually 1
+    *
+    *     DD_HAVE_HARDWARE_FOG        the driver should return 1 (0 otherwise)
+    *                                 when the hardware support per fragment
+    *                                 fog for free (like the Voodoo Graphics)
+    *                                 so the Mesa core will start to ever use
+    *                                 per fragment fog
+    */
+
+
+   /***
+    *** For supporting hardware Z buffers:
+    ***/
+
+   void (*AllocDepthBuffer)( GLcontext *ctx );
+   /*
+    * Called when the depth buffer must be allocated or possibly resized.
+    */
+
+   GLuint (*DepthTestSpan)( GLcontext *ctx,
+                            GLuint n, GLint x, GLint y, const GLdepth z[],
+                            GLubyte mask[] );
+   void (*DepthTestPixels)( GLcontext *ctx,
+                            GLuint n, const GLint x[], const GLint y[],
+                            const GLdepth z[], GLubyte mask[] );
+   /*
+    * Apply the depth buffer test to an span/array of pixels and return
+    * an updated pixel mask.  This function is not used when accelerated
+    * point, line, polygon functions are used.
+    */
+
+   void (*ReadDepthSpanFloat)( GLcontext *ctx,
+                               GLuint n, GLint x, GLint y, GLfloat depth[]);
+   void (*ReadDepthSpanInt)( GLcontext *ctx,
+                             GLuint n, GLint x, GLint y, GLdepth depth[] );
+   /*
+    * Return depth values as integers for glReadPixels.
+    * Floats should be returned in the range [0,1].
+    * Ints (GLdepth) values should be in the range [0,MAXDEPTH].
+    */
+
+
+   /***
+    *** Accelerated point, line, polygon, glDrawPixels and glBitmap functions:
+    ***/
+
+   points_func   PointsFunc;
+   line_func     LineFunc;
+   triangle_func TriangleFunc;
+   quad_func     QuadFunc;
+   rect_func     RectFunc;    
+   
+
+   GLboolean (*DrawPixels)( GLcontext *ctx,
+                            GLint x, GLint y, GLsizei width, GLsizei height,
+                            GLenum format, GLenum type,
+                            const struct gl_pixelstore_attrib *unpack,
+                            const GLvoid *pixels );
+   /* Device driver hook for optimized glDrawPixels.  'unpack' describes how
+    * to unpack the source image data.
+    */
+
+   GLboolean (*Bitmap)( GLcontext *ctx,
+                        GLint x, GLint y, GLsizei width, GLsizei height,
+                        const struct gl_pixelstore_attrib *unpack,
+                        const GLubyte *bitmap );
+   /* Device driver hook for optimized glBitmap.  'unpack' describes how
+    * to unpack the source image data.
+    */
+
+   void (*RenderStart)( GLcontext *ctx );
+   void (*RenderFinish)( GLcontext *ctx );
+    /* KW: These replace Begin and End, and have more relaxed semantics.
+     * They are called prior-to and after one or more vb flush, and are
+     * thus decoupled from the gl_begin/gl_end pairs, which are possibly 
+     * more frequent.  If a begin/end pair covers >1 vertex buffer, these
+     * are called at most once for the pair. (a bit broken at present)
+     */
+
+   void (*RasterSetup)( struct vertex_buffer *VB, GLuint start, GLuint end );
+   /* This function, if not NULL, is called whenever new window coordinates
+    * are put in the vertex buffer.  The vertices in question are those n
+    * such that start <= n < end.
+    * The device driver can convert the window coords to its own specialized
+    * format.  The 3Dfx driver uses this.
+    *
+    * Note: Deprecated in favour of RegisterPipelineStages, below.
+    */
+
+
+   render_func *RenderVBClippedTab;
+   render_func *RenderVBCulledTab;
+   render_func *RenderVBRawTab;
+   /* These function tables allow the device driver to rasterize an
+    * entire begin/end group of primitives at once.  See the
+    * gl_render_vb() function in vbrender.c for more details.  
+    */
+
+
+   GLuint TriangleCaps;
+   /* Holds a list of the reasons why we might normally want to call
+    * render_triangle, but which are in fact implemented by the
+    * driver.  The FX driver sets this to DD_TRI_CULL, and will soon
+    * implement DD_TRI_OFFSET.
+    */
+
+
+   GLboolean (*MultipassFunc)( struct vertex_buffer *VB, GLuint passno );
+   /* Driver may request additional render passes by returning GL_TRUE
+    * when this function is called.  This function will be called
+    * after the first pass, and passes will be made until the function
+    * returns GL_FALSE.  If no function is registered, only one pass
+    * is made.  
+    * 
+    * This function will be first invoked with passno == 1.
+    */
+
+   /***
+    *** Texture mapping functions:
+    ***/
+
+   void (*TexEnv)( GLcontext *ctx, GLenum pname, const GLfloat *param );
+   /*
+    * Called whenever glTexEnv*() is called.
+    * Pname will be one of GL_TEXTURE_ENV_MODE or GL_TEXTURE_ENV_COLOR.
+    * If pname is GL_TEXTURE_ENV_MODE then param will be one
+    * of GL_MODULATE, GL_BLEND, GL_DECAL, or GL_REPLACE.
+    */
+
+   void (*TexImage)( GLcontext *ctx, GLenum target,
+                     struct gl_texture_object *tObj, GLint level,
+                     GLint internalFormat,
+                     const struct gl_texture_image *image );
+   /*
+    * Called whenever a texture object's image is changed.
+    *    texObject is the number of the texture object being changed.
+    *    level indicates the mipmap level.
+    *    internalFormat is the format in which the texture is to be stored.
+    *    image is a pointer to a gl_texture_image struct which contains
+    *       the actual image data.
+    */
+
+   void (*TexSubImage)( GLcontext *ctx, GLenum target,
+                        struct gl_texture_object *tObj, GLint level,
+                        GLint xoffset, GLint yoffset,
+                        GLsizei width, GLsizei height,
+                        GLint internalFormat,
+                        const struct gl_texture_image *image );
+   /*
+    * Called from glTexSubImage() to define a sub-region of a texture.
+    */
+
+   void (*TexParameter)( GLcontext *ctx, GLenum target,
+                         struct gl_texture_object *tObj,
+                         GLenum pname, const GLfloat *params );
+   /*
+    * Called whenever glTexParameter*() is called.
+    *    target is GL_TEXTURE_1D or GL_TEXTURE_2D
+    *    texObject is the texture object to modify
+    *    pname is one of GL_TEXTURE_MIN_FILTER, GL_TEXTURE_MAG_FILTER,
+    *       GL_TEXTURE_WRAP_S, GL_TEXTURE_WRAP_T, or GL_TEXTURE_BORDER_COLOR.
+    *    params is dependant on pname.  See man glTexParameter.
+    */
+
+   void (*BindTexture)( GLcontext *ctx, GLenum target,
+                        struct gl_texture_object *tObj );
+   /*
+    * Called whenever glBindTexture() is called.  This specifies which
+    * texture is to be the current one.  No dirty flags will be set.
+    */
+
+   void (*DeleteTexture)( GLcontext *ctx, struct gl_texture_object *tObj );
+   /*
+    * Called when a texture object is about to be deallocated.  Driver
+    * should free anything attached to the DriverData pointers.
+    */
+
+   void (*UpdateTexturePalette)( GLcontext *ctx,
+                                 struct gl_texture_object *tObj );
+   /*
+    * Called when the texture's color lookup table is changed.
+    * If tObj is NULL then the shared texture palette ctx->Texture.Palette
+    * was changed.
+    */
+
+   void (*UseGlobalTexturePalette)( GLcontext *ctx, GLboolean state );
+   /*
+    * Called via glEnable/Disable(GL_SHARED_TEXTURE_PALETTE_EXT)
+    */
+
+   void (*ActiveTexture)( GLcontext *ctx, GLuint texUnitNumber );
+   /*
+    * Called by glActiveTextureARB to set current texture unit.
+    */
+
+
+   /***
+    *** NEW in Mesa 3.x
+    ***/
+
+   void (*RegisterVB)( struct vertex_buffer *VB );
+   void (*UnregisterVB)( struct vertex_buffer *VB );
+   /* Do any processing (eg allocate memory) required to set up a new
+    * vertex_buffer.  
+    */
+
+
+   void (*ResetVB)( struct vertex_buffer *VB );
+   void (*ResetCvaVB)( struct vertex_buffer *VB, GLuint stages );
+   /* Do any reset operations necessary to the driver data associated
+    * with these vertex buffers.
+    */
+
+   GLuint RenderVectorFlags;
+   /* What do the render tables require of the vectors they deal
+    * with?  
+    */
+
+   GLuint (*RegisterPipelineStages)( struct gl_pipeline_stage *out,
+				     const struct gl_pipeline_stage *in,
+				     GLuint nr );
+   /* Register new pipeline stages, or modify existing ones.  See also
+    * the OptimizePipeline() functions.
+    */
+
+
+   GLboolean (*BuildPrecalcPipeline)( GLcontext *ctx );
+   GLboolean (*BuildEltPipeline)( GLcontext *ctx );
+   /* Perform the full pipeline build, or return false.
+    */
+
+
+   void (*OptimizePrecalcPipeline)( GLcontext *ctx, struct gl_pipeline *pipe );
+   void (*OptimizeImmediatePipeline)( GLcontext *ctx, struct gl_pipeline *pipe);
+   /* Check to see if a fast path exists for this combination of stages 
+    * in the precalc and immediate (elt) pipelines.
+    */
+
+
+   /*
+    * State-changing functions (drawing functions are above)
+    *
+    * These functions are called by their corresponding OpenGL API functions.
+    * They're ALSO called by the gl_PopAttrib() function!!!
+    * May add more functions like these to the device driver in the future.
+    * This should reduce the amount of state checking that
+    * the driver's UpdateState() function must do.
+    */
+   void (*AlphaFunc)(GLcontext *ctx, GLenum func, GLclampf ref);
+   void (*BlendFunc)(GLcontext *ctx, GLenum sfactor, GLenum dfactor);
+   void (*ClearDepth)(GLcontext *ctx, GLclampd d);
+   void (*CullFace)(GLcontext *ctx, GLenum mode);
+   void (*FrontFace)(GLcontext *ctx, GLenum mode);
+   void (*DepthFunc)(GLcontext *ctx, GLenum func);
+   void (*DepthMask)(GLcontext *ctx, GLboolean flag);
+   void (*DepthRange)(GLcontext *ctx, GLclampd nearval, GLclampd farval);
+   void (*Enable)(GLcontext* ctx, GLenum cap, GLboolean state);
+   void (*Fogfv)(GLcontext *ctx, GLenum pname, const GLfloat *params);
+   void (*Hint)(GLcontext *ctx, GLenum target, GLenum mode);
+   void (*PolygonMode)(GLcontext *ctx, GLenum face, GLenum mode);
+   void (*Scissor)(GLcontext *ctx, GLint x, GLint y, GLsizei w, GLsizei h);
+   void (*ShadeModel)(GLcontext *ctx, GLenum mode);
+   void (*ClearStencil)(GLcontext *ctx, GLint s);
+   void (*StencilFunc)(GLcontext *ctx, GLenum func, GLint ref, GLuint mask);
+   void (*StencilMask)(GLcontext *ctx, GLuint mask);
+   void (*StencilOp)(GLcontext *ctx, GLenum fail, GLenum zfail, GLenum zpass);
+   void (*Viewport)(GLcontext *ctx, GLint x, GLint y, GLsizei w, GLsizei h);
+};
+
+
+
+#endif
+