Subversion Repositories Kolibri OS

/*

 * Mesa 3-D graphics library

 *

 * Copyright (C) 1999-2008  Brian Paul   All Rights Reserved.

 * Copyright (C) 2009  VMware, Inc.  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

 * THE AUTHORS OR COPYRIGHT HOLDERS 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.

 */

/**

 * \file mtypes.h

 * Main Mesa data structures.

 *

 * Please try to mark derived values with a leading underscore ('_').

 */

#ifndef MTYPES_H

#define MTYPES_H

#include "main/glheader.h"

#include "main/config.h"

#include "glapi/glapi.h"

#include "math/m_matrix.h"	/* GLmatrix */

#include "main/simple_list.h"	/* struct simple_node */

#include "main/formats.h"       /* MESA_FORMAT_COUNT */

#ifdef __cplusplus

extern "C" {

#endif

/**

 * \name 64-bit extension of GLbitfield.

 */

/*@{*/

typedef GLuint64 GLbitfield64;

/** Set a single bit */

#define BITFIELD64_BIT(b)      ((GLbitfield64)1 << (b))

/** Set all bits up to excluding bit b */

#define BITFIELD64_MASK(b)      \

   ((b) == 64 ? (~(GLbitfield64)0) : BITFIELD64_BIT(b) - 1)

/** Set count bits starting from bit b  */

#define BITFIELD64_RANGE(b, count) \

   (BITFIELD64_MASK((b) + (count)) & ~BITFIELD64_MASK(b))

/**

 * \name Some forward type declarations

 */

/*@{*/

struct _mesa_HashTable;

struct gl_attrib_node;

struct gl_list_extensions;

struct gl_meta_state;

struct gl_program_cache;

struct gl_texture_object;

struct gl_context;

struct st_context;

struct gl_uniform_storage;

struct prog_instruction;

struct gl_program_parameter_list;

struct set;

struct set_entry;

/*@}*/

/** Extra draw modes beyond GL_POINTS, GL_TRIANGLE_FAN, etc */

#define PRIM_MAX                 GL_TRIANGLE_STRIP_ADJACENCY

#define PRIM_OUTSIDE_BEGIN_END   (PRIM_MAX + 1)

#define PRIM_UNKNOWN             (PRIM_MAX + 2)

/**

 * Indexes for vertex program attributes.

 * GL_NV_vertex_program aliases generic attributes over the conventional

 * attributes.  In GL_ARB_vertex_program shader the aliasing is optional.

 * In GL_ARB_vertex_shader / OpenGL 2.0 the aliasing is disallowed (the

 * generic attributes are distinct/separate).

 */

typedef enum

{

   VERT_ATTRIB_POS = 0,

   VERT_ATTRIB_WEIGHT = 1,

   VERT_ATTRIB_NORMAL = 2,

   VERT_ATTRIB_COLOR0 = 3,

   VERT_ATTRIB_COLOR1 = 4,

   VERT_ATTRIB_FOG = 5,

   VERT_ATTRIB_COLOR_INDEX = 6,

   VERT_ATTRIB_EDGEFLAG = 7,

   VERT_ATTRIB_TEX0 = 8,

   VERT_ATTRIB_TEX1 = 9,

   VERT_ATTRIB_TEX2 = 10,

   VERT_ATTRIB_TEX3 = 11,

   VERT_ATTRIB_TEX4 = 12,

   VERT_ATTRIB_TEX5 = 13,

   VERT_ATTRIB_TEX6 = 14,

   VERT_ATTRIB_TEX7 = 15,

   VERT_ATTRIB_POINT_SIZE = 16,

   VERT_ATTRIB_GENERIC0 = 17,

   VERT_ATTRIB_GENERIC1 = 18,

   VERT_ATTRIB_GENERIC2 = 19,

   VERT_ATTRIB_GENERIC3 = 20,

   VERT_ATTRIB_GENERIC4 = 21,

   VERT_ATTRIB_GENERIC5 = 22,

   VERT_ATTRIB_GENERIC6 = 23,

   VERT_ATTRIB_GENERIC7 = 24,

   VERT_ATTRIB_GENERIC8 = 25,

   VERT_ATTRIB_GENERIC9 = 26,

   VERT_ATTRIB_GENERIC10 = 27,

   VERT_ATTRIB_GENERIC11 = 28,

   VERT_ATTRIB_GENERIC12 = 29,

   VERT_ATTRIB_GENERIC13 = 30,

   VERT_ATTRIB_GENERIC14 = 31,

   VERT_ATTRIB_GENERIC15 = 32,

   VERT_ATTRIB_MAX = 33

} gl_vert_attrib;

/**

 * Symbolic constats to help iterating over

 * specific blocks of vertex attributes.

 *

 * VERT_ATTRIB_FF

 *   includes all fixed function attributes as well as

 *   the aliased GL_NV_vertex_program shader attributes.

 * VERT_ATTRIB_TEX

 *   include the classic texture coordinate attributes.

 *   Is a subset of VERT_ATTRIB_FF.

 * VERT_ATTRIB_GENERIC

 *   include the OpenGL 2.0+ GLSL generic shader attributes.

 *   These alias the generic GL_ARB_vertex_shader attributes.

 */

#define VERT_ATTRIB_FF(i)           (VERT_ATTRIB_POS + (i))

#define VERT_ATTRIB_FF_MAX          VERT_ATTRIB_GENERIC0

#define VERT_ATTRIB_TEX(i)          (VERT_ATTRIB_TEX0 + (i))

#define VERT_ATTRIB_TEX_MAX         MAX_TEXTURE_COORD_UNITS

#define VERT_ATTRIB_GENERIC(i)      (VERT_ATTRIB_GENERIC0 + (i))

#define VERT_ATTRIB_GENERIC_MAX     MAX_VERTEX_GENERIC_ATTRIBS

/**

 * Bitflags for vertex attributes.

 * These are used in bitfields in many places.

 */

/*@{*/

#define VERT_BIT_POS             BITFIELD64_BIT(VERT_ATTRIB_POS)

#define VERT_BIT_WEIGHT          BITFIELD64_BIT(VERT_ATTRIB_WEIGHT)

#define VERT_BIT_NORMAL          BITFIELD64_BIT(VERT_ATTRIB_NORMAL)

#define VERT_BIT_COLOR0          BITFIELD64_BIT(VERT_ATTRIB_COLOR0)

#define VERT_BIT_COLOR1          BITFIELD64_BIT(VERT_ATTRIB_COLOR1)

#define VERT_BIT_FOG             BITFIELD64_BIT(VERT_ATTRIB_FOG)

#define VERT_BIT_COLOR_INDEX     BITFIELD64_BIT(VERT_ATTRIB_COLOR_INDEX)

#define VERT_BIT_EDGEFLAG        BITFIELD64_BIT(VERT_ATTRIB_EDGEFLAG)

#define VERT_BIT_TEX0            BITFIELD64_BIT(VERT_ATTRIB_TEX0)

#define VERT_BIT_TEX1            BITFIELD64_BIT(VERT_ATTRIB_TEX1)

#define VERT_BIT_TEX2            BITFIELD64_BIT(VERT_ATTRIB_TEX2)

#define VERT_BIT_TEX3            BITFIELD64_BIT(VERT_ATTRIB_TEX3)

#define VERT_BIT_TEX4            BITFIELD64_BIT(VERT_ATTRIB_TEX4)

#define VERT_BIT_TEX5            BITFIELD64_BIT(VERT_ATTRIB_TEX5)

#define VERT_BIT_TEX6            BITFIELD64_BIT(VERT_ATTRIB_TEX6)

#define VERT_BIT_TEX7            BITFIELD64_BIT(VERT_ATTRIB_TEX7)

#define VERT_BIT_POINT_SIZE      BITFIELD64_BIT(VERT_ATTRIB_POINT_SIZE)

#define VERT_BIT_GENERIC0        BITFIELD64_BIT(VERT_ATTRIB_GENERIC0)

#define VERT_BIT(i)              BITFIELD64_BIT(i)

#define VERT_BIT_ALL             BITFIELD64_RANGE(0, VERT_ATTRIB_MAX)

#define VERT_BIT_FF(i)           VERT_BIT(i)

#define VERT_BIT_FF_ALL          BITFIELD64_RANGE(0, VERT_ATTRIB_FF_MAX)

#define VERT_BIT_TEX(i)          VERT_BIT(VERT_ATTRIB_TEX(i))

#define VERT_BIT_TEX_ALL         \

   BITFIELD64_RANGE(VERT_ATTRIB_TEX(0), VERT_ATTRIB_TEX_MAX)

#define VERT_BIT_GENERIC(i)      VERT_BIT(VERT_ATTRIB_GENERIC(i))

#define VERT_BIT_GENERIC_ALL     \

   BITFIELD64_RANGE(VERT_ATTRIB_GENERIC(0), VERT_ATTRIB_GENERIC_MAX)

/*@}*/

/**

 * Indexes for vertex shader outputs, geometry shader inputs/outputs, and

 * fragment shader inputs.

 *

 * Note that some of these values are not available to all pipeline stages.

 *

 * When this enum is updated, the following code must be updated too:

 * - vertResults (in prog_print.c's arb_output_attrib_string())

 * - fragAttribs (in prog_print.c's arb_input_attrib_string())

 * - _mesa_varying_slot_in_fs()

 */

typedef enum

{

   VARYING_SLOT_POS,

   VARYING_SLOT_COL0, /* COL0 and COL1 must be contiguous */

   VARYING_SLOT_COL1,

   VARYING_SLOT_FOGC,

   VARYING_SLOT_TEX0, /* TEX0-TEX7 must be contiguous */

   VARYING_SLOT_TEX1,

   VARYING_SLOT_TEX2,

   VARYING_SLOT_TEX3,

   VARYING_SLOT_TEX4,

   VARYING_SLOT_TEX5,

   VARYING_SLOT_TEX6,

   VARYING_SLOT_TEX7,

   VARYING_SLOT_PSIZ, /* Does not appear in FS */

   VARYING_SLOT_BFC0, /* Does not appear in FS */

   VARYING_SLOT_BFC1, /* Does not appear in FS */

   VARYING_SLOT_EDGE, /* Does not appear in FS */

   VARYING_SLOT_CLIP_VERTEX, /* Does not appear in FS */

   VARYING_SLOT_CLIP_DIST0,

   VARYING_SLOT_CLIP_DIST1,

   VARYING_SLOT_PRIMITIVE_ID, /* Does not appear in VS */

   VARYING_SLOT_LAYER, /* Appears as VS or GS output */

   VARYING_SLOT_FACE, /* FS only */

   VARYING_SLOT_PNTC, /* FS only */

   VARYING_SLOT_VAR0, /* First generic varying slot */

   VARYING_SLOT_MAX = VARYING_SLOT_VAR0 + MAX_VARYING

} gl_varying_slot;

/**

 * Bitflags for varying slots.

 */

/*@{*/

#define VARYING_BIT_POS BITFIELD64_BIT(VARYING_SLOT_POS)

#define VARYING_BIT_COL0 BITFIELD64_BIT(VARYING_SLOT_COL0)

#define VARYING_BIT_COL1 BITFIELD64_BIT(VARYING_SLOT_COL1)

#define VARYING_BIT_FOGC BITFIELD64_BIT(VARYING_SLOT_FOGC)

#define VARYING_BIT_TEX0 BITFIELD64_BIT(VARYING_SLOT_TEX0)

#define VARYING_BIT_TEX1 BITFIELD64_BIT(VARYING_SLOT_TEX1)

#define VARYING_BIT_TEX2 BITFIELD64_BIT(VARYING_SLOT_TEX2)

#define VARYING_BIT_TEX3 BITFIELD64_BIT(VARYING_SLOT_TEX3)

#define VARYING_BIT_TEX4 BITFIELD64_BIT(VARYING_SLOT_TEX4)

#define VARYING_BIT_TEX5 BITFIELD64_BIT(VARYING_SLOT_TEX5)

#define VARYING_BIT_TEX6 BITFIELD64_BIT(VARYING_SLOT_TEX6)

#define VARYING_BIT_TEX7 BITFIELD64_BIT(VARYING_SLOT_TEX7)

#define VARYING_BIT_TEX(U) BITFIELD64_BIT(VARYING_SLOT_TEX0 + (U))

#define VARYING_BITS_TEX_ANY BITFIELD64_RANGE(VARYING_SLOT_TEX0, \

                                              MAX_TEXTURE_COORD_UNITS)

#define VARYING_BIT_PSIZ BITFIELD64_BIT(VARYING_SLOT_PSIZ)

#define VARYING_BIT_BFC0 BITFIELD64_BIT(VARYING_SLOT_BFC0)

#define VARYING_BIT_BFC1 BITFIELD64_BIT(VARYING_SLOT_BFC1)

#define VARYING_BIT_EDGE BITFIELD64_BIT(VARYING_SLOT_EDGE)

#define VARYING_BIT_CLIP_VERTEX BITFIELD64_BIT(VARYING_SLOT_CLIP_VERTEX)

#define VARYING_BIT_CLIP_DIST0 BITFIELD64_BIT(VARYING_SLOT_CLIP_DIST0)

#define VARYING_BIT_CLIP_DIST1 BITFIELD64_BIT(VARYING_SLOT_CLIP_DIST1)

#define VARYING_BIT_PRIMITIVE_ID BITFIELD64_BIT(VARYING_SLOT_PRIMITIVE_ID)

#define VARYING_BIT_LAYER BITFIELD64_BIT(VARYING_SLOT_LAYER)

#define VARYING_BIT_FACE BITFIELD64_BIT(VARYING_SLOT_FACE)

#define VARYING_BIT_PNTC BITFIELD64_BIT(VARYING_SLOT_PNTC)

#define VARYING_BIT_VAR(V) BITFIELD64_BIT(VARYING_SLOT_VAR0 + (V))

/*@}*/

/**

 * Determine if the given gl_varying_slot appears in the fragment shader.

 */

static inline GLboolean

_mesa_varying_slot_in_fs(gl_varying_slot slot)

{

   switch (slot) {

   case VARYING_SLOT_PSIZ:

   case VARYING_SLOT_BFC0:

   case VARYING_SLOT_BFC1:

   case VARYING_SLOT_EDGE:

   case VARYING_SLOT_CLIP_VERTEX:

   case VARYING_SLOT_LAYER:

      return GL_FALSE;

   default:

      return GL_TRUE;

   }

}

/**

 * Fragment program results

 */

typedef enum

{

   FRAG_RESULT_DEPTH = 0,

   FRAG_RESULT_STENCIL = 1,

   /* If a single color should be written to all render targets, this

    * register is written.  No FRAG_RESULT_DATAn will be written.

    */

   FRAG_RESULT_COLOR = 2,

   /* FRAG_RESULT_DATAn are the per-render-target (GLSL gl_FragData[n]

    * or ARB_fragment_program fragment.color[n]) color results.  If

    * any are written, FRAG_RESULT_COLOR will not be written.

    */

   FRAG_RESULT_DATA0 = 3,

   FRAG_RESULT_MAX = (FRAG_RESULT_DATA0 + MAX_DRAW_BUFFERS)

} gl_frag_result;

/**

 * Indexes for all renderbuffers

 */

typedef enum

{

   /* the four standard color buffers */

   BUFFER_FRONT_LEFT,

   BUFFER_BACK_LEFT,

   BUFFER_FRONT_RIGHT,

   BUFFER_BACK_RIGHT,

   BUFFER_DEPTH,

   BUFFER_STENCIL,

   BUFFER_ACCUM,

   /* optional aux buffer */

   BUFFER_AUX0,

   /* generic renderbuffers */

   BUFFER_COLOR0,

   BUFFER_COLOR1,

   BUFFER_COLOR2,

   BUFFER_COLOR3,

   BUFFER_COLOR4,

   BUFFER_COLOR5,

   BUFFER_COLOR6,

   BUFFER_COLOR7,

   BUFFER_COUNT

} gl_buffer_index;

/**

 * Bit flags for all renderbuffers

 */

#define BUFFER_BIT_FRONT_LEFT   (1 << BUFFER_FRONT_LEFT)

#define BUFFER_BIT_BACK_LEFT    (1 << BUFFER_BACK_LEFT)

#define BUFFER_BIT_FRONT_RIGHT  (1 << BUFFER_FRONT_RIGHT)

#define BUFFER_BIT_BACK_RIGHT   (1 << BUFFER_BACK_RIGHT)

#define BUFFER_BIT_AUX0         (1 << BUFFER_AUX0)

#define BUFFER_BIT_AUX1         (1 << BUFFER_AUX1)

#define BUFFER_BIT_AUX2         (1 << BUFFER_AUX2)

#define BUFFER_BIT_AUX3         (1 << BUFFER_AUX3)

#define BUFFER_BIT_DEPTH        (1 << BUFFER_DEPTH)

#define BUFFER_BIT_STENCIL      (1 << BUFFER_STENCIL)

#define BUFFER_BIT_ACCUM        (1 << BUFFER_ACCUM)

#define BUFFER_BIT_COLOR0       (1 << BUFFER_COLOR0)

#define BUFFER_BIT_COLOR1       (1 << BUFFER_COLOR1)

#define BUFFER_BIT_COLOR2       (1 << BUFFER_COLOR2)

#define BUFFER_BIT_COLOR3       (1 << BUFFER_COLOR3)

#define BUFFER_BIT_COLOR4       (1 << BUFFER_COLOR4)

#define BUFFER_BIT_COLOR5       (1 << BUFFER_COLOR5)

#define BUFFER_BIT_COLOR6       (1 << BUFFER_COLOR6)

#define BUFFER_BIT_COLOR7       (1 << BUFFER_COLOR7)

/**

 * Mask of all the color buffer bits (but not accum).

 */

#define BUFFER_BITS_COLOR  (BUFFER_BIT_FRONT_LEFT | \

                            BUFFER_BIT_BACK_LEFT | \

                            BUFFER_BIT_FRONT_RIGHT | \

                            BUFFER_BIT_BACK_RIGHT | \

                            BUFFER_BIT_AUX0 | \

                            BUFFER_BIT_COLOR0 | \

                            BUFFER_BIT_COLOR1 | \

                            BUFFER_BIT_COLOR2 | \

                            BUFFER_BIT_COLOR3 | \

                            BUFFER_BIT_COLOR4 | \

                            BUFFER_BIT_COLOR5 | \

                            BUFFER_BIT_COLOR6 | \

                            BUFFER_BIT_COLOR7)

/**

 * Framebuffer configuration (aka visual / pixelformat)

 * Note: some of these fields should be boolean, but it appears that

 * code in drivers/dri/common/util.c requires int-sized fields.

 */

struct gl_config

{

   GLboolean rgbMode;

   GLboolean floatMode;

   GLboolean colorIndexMode;  /* XXX is this used anywhere? */

   GLuint doubleBufferMode;

   GLuint stereoMode;

   GLboolean haveAccumBuffer;

   GLboolean haveDepthBuffer;

   GLboolean haveStencilBuffer;

   GLint redBits, greenBits, blueBits, alphaBits;	/* bits per comp */

   GLuint redMask, greenMask, blueMask, alphaMask;

   GLint rgbBits;		/* total bits for rgb */

   GLint indexBits;		/* total bits for colorindex */

   GLint accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits;

   GLint depthBits;

   GLint stencilBits;

   GLint numAuxBuffers;

   GLint level;

   /* EXT_visual_rating / GLX 1.2 */

   GLint visualRating;

   /* EXT_visual_info / GLX 1.2 */

   GLint transparentPixel;

   /*    colors are floats scaled to ints */

   GLint transparentRed, transparentGreen, transparentBlue, transparentAlpha;

   GLint transparentIndex;

   /* ARB_multisample / SGIS_multisample */

   GLint sampleBuffers;

   GLint samples;

   /* SGIX_pbuffer / GLX 1.3 */

   GLint maxPbufferWidth;

   GLint maxPbufferHeight;

   GLint maxPbufferPixels;

   GLint optimalPbufferWidth;   /* Only for SGIX_pbuffer. */

   GLint optimalPbufferHeight;  /* Only for SGIX_pbuffer. */

   /* OML_swap_method */

   GLint swapMethod;

   /* EXT_texture_from_pixmap */

   GLint bindToTextureRgb;

   GLint bindToTextureRgba;

   GLint bindToMipmapTexture;

   GLint bindToTextureTargets;

   GLint yInverted;

   /* EXT_framebuffer_sRGB */

   GLint sRGBCapable;

};

/**

 * \name Bit flags used for updating material values.

 */

/*@{*/

#define MAT_ATTRIB_FRONT_AMBIENT           0

#define MAT_ATTRIB_BACK_AMBIENT            1

#define MAT_ATTRIB_FRONT_DIFFUSE           2

#define MAT_ATTRIB_BACK_DIFFUSE            3

#define MAT_ATTRIB_FRONT_SPECULAR          4

#define MAT_ATTRIB_BACK_SPECULAR           5

#define MAT_ATTRIB_FRONT_EMISSION          6

#define MAT_ATTRIB_BACK_EMISSION           7

#define MAT_ATTRIB_FRONT_SHININESS         8

#define MAT_ATTRIB_BACK_SHININESS          9

#define MAT_ATTRIB_FRONT_INDEXES           10

#define MAT_ATTRIB_BACK_INDEXES            11

#define MAT_ATTRIB_MAX                     12

#define MAT_ATTRIB_AMBIENT(f)  (MAT_ATTRIB_FRONT_AMBIENT+(f))

#define MAT_ATTRIB_DIFFUSE(f)  (MAT_ATTRIB_FRONT_DIFFUSE+(f))

#define MAT_ATTRIB_SPECULAR(f) (MAT_ATTRIB_FRONT_SPECULAR+(f))

#define MAT_ATTRIB_EMISSION(f) (MAT_ATTRIB_FRONT_EMISSION+(f))

#define MAT_ATTRIB_SHININESS(f)(MAT_ATTRIB_FRONT_SHININESS+(f))

#define MAT_ATTRIB_INDEXES(f)  (MAT_ATTRIB_FRONT_INDEXES+(f))

#define MAT_INDEX_AMBIENT  0

#define MAT_INDEX_DIFFUSE  1

#define MAT_INDEX_SPECULAR 2

#define MAT_BIT_FRONT_AMBIENT         (1<

#define MAT_BIT_BACK_AMBIENT          (1<

#define MAT_BIT_FRONT_DIFFUSE         (1<

#define MAT_BIT_BACK_DIFFUSE          (1<

#define MAT_BIT_FRONT_SPECULAR        (1<

#define MAT_BIT_BACK_SPECULAR         (1<

#define MAT_BIT_FRONT_EMISSION        (1<

#define MAT_BIT_BACK_EMISSION         (1<

#define MAT_BIT_FRONT_SHININESS       (1<

#define MAT_BIT_BACK_SHININESS        (1<

#define MAT_BIT_FRONT_INDEXES         (1<

#define MAT_BIT_BACK_INDEXES          (1<

#define FRONT_MATERIAL_BITS	(MAT_BIT_FRONT_EMISSION | 	\

				 MAT_BIT_FRONT_AMBIENT |	\

				 MAT_BIT_FRONT_DIFFUSE | 	\

				 MAT_BIT_FRONT_SPECULAR |	\

				 MAT_BIT_FRONT_SHININESS | 	\

				 MAT_BIT_FRONT_INDEXES)

#define BACK_MATERIAL_BITS	(MAT_BIT_BACK_EMISSION |	\

				 MAT_BIT_BACK_AMBIENT |		\

				 MAT_BIT_BACK_DIFFUSE |		\

				 MAT_BIT_BACK_SPECULAR |	\

				 MAT_BIT_BACK_SHININESS |	\

				 MAT_BIT_BACK_INDEXES)

#define ALL_MATERIAL_BITS	(FRONT_MATERIAL_BITS | BACK_MATERIAL_BITS)

/*@}*/

/**

 * Material state.

 */

struct gl_material

{

   GLfloat Attrib[MAT_ATTRIB_MAX][4];

};

/**

 * Light state flags.

 */

/*@{*/

#define LIGHT_SPOT         0x1

#define LIGHT_LOCAL_VIEWER 0x2

#define LIGHT_POSITIONAL   0x4

#define LIGHT_NEED_VERTICES (LIGHT_POSITIONAL|LIGHT_LOCAL_VIEWER)

/*@}*/

/**

 * Light source state.

 */

struct gl_light

{

   struct gl_light *next;	/**< double linked list with sentinel */

   struct gl_light *prev;

   GLfloat Ambient[4];		/**< ambient color */

   GLfloat Diffuse[4];		/**< diffuse color */

   GLfloat Specular[4];		/**< specular color */

   GLfloat EyePosition[4];	/**< position in eye coordinates */

   GLfloat SpotDirection[4];	/**< spotlight direction in eye coordinates */

   GLfloat SpotExponent;

   GLfloat SpotCutoff;		/**< in degrees */

   GLfloat _CosCutoff;		/**< = MAX(0, cos(SpotCutoff)) */

   GLfloat ConstantAttenuation;

   GLfloat LinearAttenuation;

   GLfloat QuadraticAttenuation;

   GLboolean Enabled;		/**< On/off flag */

   /**

    * \name Derived fields

    */

   /*@{*/

   GLbitfield _Flags;		/**< Mask of LIGHT_x bits defined above */

   GLfloat _Position[4];	/**< position in eye/obj coordinates */

   GLfloat _VP_inf_norm[3];	/**< Norm direction to infinite light */

   GLfloat _h_inf_norm[3];	/**< Norm( _VP_inf_norm + <0,0,1> ) */

   GLfloat _NormSpotDirection[4]; /**< normalized spotlight direction */

   GLfloat _VP_inf_spot_attenuation;

   GLfloat _MatAmbient[2][3];	/**< material ambient * light ambient */

   GLfloat _MatDiffuse[2][3];	/**< material diffuse * light diffuse */

   GLfloat _MatSpecular[2][3];	/**< material spec * light specular */

   /*@}*/

};

/**

 * Light model state.

 */

struct gl_lightmodel

{

   GLfloat Ambient[4];		/**< ambient color */

   GLboolean LocalViewer;	/**< Local (or infinite) view point? */

   GLboolean TwoSide;		/**< Two (or one) sided lighting? */

   GLenum ColorControl;		/**< either GL_SINGLE_COLOR

				 *    or GL_SEPARATE_SPECULAR_COLOR */

};

/**

 * Accumulation buffer attribute group (GL_ACCUM_BUFFER_BIT)

 */

struct gl_accum_attrib

{

   GLfloat ClearColor[4];	/**< Accumulation buffer clear color */

};

/**

 * Used for storing clear color, texture border color, etc.

 * The float values are typically unclamped.

 */

union gl_color_union

{

   GLfloat f[4];

   GLint i[4];

   GLuint ui[4];

};

/**

 * Color buffer attribute group (GL_COLOR_BUFFER_BIT).

 */

struct gl_colorbuffer_attrib

{

   GLuint ClearIndex;                      /**< Index for glClear */

   union gl_color_union ClearColor;        /**< Color for glClear, unclamped */

   GLuint IndexMask;                       /**< Color index write mask */

   GLubyte ColorMask[MAX_DRAW_BUFFERS][4]; /**< Each flag is 0xff or 0x0 */

   GLenum DrawBuffer[MAX_DRAW_BUFFERS];	/**< Which buffer to draw into */

   /**

    * \name alpha testing

    */

   /*@{*/

   GLboolean AlphaEnabled;		/**< Alpha test enabled flag */

   GLenum AlphaFunc;			/**< Alpha test function */

   GLfloat AlphaRefUnclamped;

   GLclampf AlphaRef;			/**< Alpha reference value */

   /*@}*/

   /**

    * \name Blending

    */

   /*@{*/

   GLbitfield BlendEnabled;		/**< Per-buffer blend enable flags */

   /* NOTE: this does _not_ depend on fragment clamping or any other clamping

    * control, only on the fixed-pointness of the render target.

    * The query does however depend on fragment color clamping.

    */

   GLfloat BlendColorUnclamped[4];               /**< Blending color */

   GLfloat BlendColor[4];		/**< Blending color */

   struct

   {

      GLenum SrcRGB;             /**< RGB blend source term */

      GLenum DstRGB;             /**< RGB blend dest term */

      GLenum SrcA;               /**< Alpha blend source term */

      GLenum DstA;               /**< Alpha blend dest term */

      GLenum EquationRGB;        /**< GL_ADD, GL_SUBTRACT, etc. */

      GLenum EquationA;          /**< GL_ADD, GL_SUBTRACT, etc. */

      /**

       * Set if any blend factor uses SRC1.  Computed at the time blend factors

       * get set.

       */

      GLboolean _UsesDualSrc;

   } Blend[MAX_DRAW_BUFFERS];

   /** Are the blend func terms currently different for each buffer/target? */

   GLboolean _BlendFuncPerBuffer;

   /** Are the blend equations currently different for each buffer/target? */

   GLboolean _BlendEquationPerBuffer;

   /*@}*/

   /**

    * \name Logic op

    */

   /*@{*/

   GLenum LogicOp;			/**< Logic operator */

   GLboolean IndexLogicOpEnabled;	/**< Color index logic op enabled flag */

   GLboolean ColorLogicOpEnabled;	/**< RGBA logic op enabled flag */

   /*@}*/

   GLboolean DitherFlag;		/**< Dither enable flag */

   GLenum ClampFragmentColor; /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */

   GLboolean _ClampFragmentColor; /** < with GL_FIXED_ONLY_ARB resolved */

   GLenum ClampReadColor;     /**< GL_TRUE, GL_FALSE or GL_FIXED_ONLY_ARB */

   GLboolean sRGBEnabled;    /**< Framebuffer sRGB blending/updating requested */

};

/**

 * Current attribute group (GL_CURRENT_BIT).

 */

struct gl_current_attrib

{

   /**

    * \name Current vertex attributes.

    * \note Values are valid only after FLUSH_VERTICES has been called.

    * \note Index and Edgeflag current values are stored as floats in the

    * SIX and SEVEN attribute slots.

    */

   GLfloat Attrib[VERT_ATTRIB_MAX][4];	/**< Position, color, texcoords, etc */

   /**

    * \name Current raster position attributes (always valid).

    * \note This set of attributes is very similar to the SWvertex struct.

    */

   /*@{*/

   GLfloat RasterPos[4];

   GLfloat RasterDistance;

   GLfloat RasterColor[4];

   GLfloat RasterSecondaryColor[4];

   GLfloat RasterTexCoords[MAX_TEXTURE_COORD_UNITS][4];

   GLboolean RasterPosValid;

   /*@}*/

};

/**

 * Depth buffer attribute group (GL_DEPTH_BUFFER_BIT).

 */

struct gl_depthbuffer_attrib

{

   GLenum Func;			/**< Function for depth buffer compare */

   GLclampd Clear;		/**< Value to clear depth buffer to */

   GLboolean Test;		/**< Depth buffering enabled flag */

   GLboolean Mask;		/**< Depth buffer writable? */

   GLboolean BoundsTest;        /**< GL_EXT_depth_bounds_test */

   GLfloat BoundsMin, BoundsMax;/**< GL_EXT_depth_bounds_test */

};

/**

 * Evaluator attribute group (GL_EVAL_BIT).

 */

struct gl_eval_attrib

{

   /**

    * \name Enable bits

    */

   /*@{*/

   GLboolean Map1Color4;

   GLboolean Map1Index;

   GLboolean Map1Normal;

   GLboolean Map1TextureCoord1;

   GLboolean Map1TextureCoord2;

   GLboolean Map1TextureCoord3;

   GLboolean Map1TextureCoord4;

   GLboolean Map1Vertex3;

   GLboolean Map1Vertex4;

   GLboolean Map2Color4;

   GLboolean Map2Index;

   GLboolean Map2Normal;

   GLboolean Map2TextureCoord1;

   GLboolean Map2TextureCoord2;

   GLboolean Map2TextureCoord3;

   GLboolean Map2TextureCoord4;

   GLboolean Map2Vertex3;

   GLboolean Map2Vertex4;

   GLboolean AutoNormal;

   /*@}*/

   /**

    * \name Map Grid endpoints and divisions and calculated du values

    */

   /*@{*/

   GLint MapGrid1un;

   GLfloat MapGrid1u1, MapGrid1u2, MapGrid1du;

   GLint MapGrid2un, MapGrid2vn;

   GLfloat MapGrid2u1, MapGrid2u2, MapGrid2du;

   GLfloat MapGrid2v1, MapGrid2v2, MapGrid2dv;

   /*@}*/

};

/**

 * Fog attribute group (GL_FOG_BIT).

 */

struct gl_fog_attrib

{

   GLboolean Enabled;		/**< Fog enabled flag */

   GLfloat ColorUnclamped[4];            /**< Fog color */

   GLfloat Color[4];		/**< Fog color */

   GLfloat Density;		/**< Density >= 0.0 */

   GLfloat Start;		/**< Start distance in eye coords */

   GLfloat End;			/**< End distance in eye coords */

   GLfloat Index;		/**< Fog index */

   GLenum Mode;			/**< Fog mode */

   GLboolean ColorSumEnabled;

   GLenum FogCoordinateSource;  /**< GL_EXT_fog_coord */

   GLfloat _Scale;		/**< (End == Start) ? 1.0 : 1.0 / (End - Start) */

   GLenum FogDistanceMode;     /**< GL_NV_fog_distance */

};

/**

 * Hint attribute group (GL_HINT_BIT).

 *

 * Values are always one of GL_FASTEST, GL_NICEST, or GL_DONT_CARE.

 */

struct gl_hint_attrib

{

   GLenum PerspectiveCorrection;

   GLenum PointSmooth;

   GLenum LineSmooth;

   GLenum PolygonSmooth;

   GLenum Fog;

   GLenum TextureCompression;   /**< GL_ARB_texture_compression */

   GLenum GenerateMipmap;       /**< GL_SGIS_generate_mipmap */

   GLenum FragmentShaderDerivative; /**< GL_ARB_fragment_shader */

};

/**

 * Lighting attribute group (GL_LIGHT_BIT).

 */

struct gl_light_attrib

{

   struct gl_light Light[MAX_LIGHTS];	/**< Array of light sources */

   struct gl_lightmodel Model;		/**< Lighting model */

   /**

    * Front and back material values.

    * Note: must call FLUSH_VERTICES() before using.

    */

   struct gl_material Material;

   GLboolean Enabled;			/**< Lighting enabled flag */

   GLenum ShadeModel;			/**< GL_FLAT or GL_SMOOTH */

   GLenum ProvokingVertex;              /**< GL_EXT_provoking_vertex */

   GLenum ColorMaterialFace;		/**< GL_FRONT, BACK or FRONT_AND_BACK */

   GLenum ColorMaterialMode;		/**< GL_AMBIENT, GL_DIFFUSE, etc */

   GLbitfield _ColorMaterialBitmask;	/**< bitmask formed from Face and Mode */

   GLboolean ColorMaterialEnabled;

   GLenum ClampVertexColor;             /**< GL_TRUE, GL_FALSE, GL_FIXED_ONLY */

   GLboolean _ClampVertexColor;

   struct gl_light EnabledList;         /**< List sentinel */

   /**

    * Derived state for optimizations:

    */

   /*@{*/

   GLboolean _NeedEyeCoords;

   GLboolean _NeedVertices;		/**< Use fast shader? */

   GLfloat _BaseColor[2][3];

   /*@}*/

};

/**

 * Line attribute group (GL_LINE_BIT).

 */

struct gl_line_attrib

{

   GLboolean SmoothFlag;	/**< GL_LINE_SMOOTH enabled? */

   GLboolean StippleFlag;	/**< GL_LINE_STIPPLE enabled? */

   GLushort StipplePattern;	/**< Stipple pattern */

   GLint StippleFactor;		/**< Stipple repeat factor */

   GLfloat Width;		/**< Line width */

};

/**

 * Display list attribute group (GL_LIST_BIT).

 */

struct gl_list_attrib

{

   GLuint ListBase;

};

/**

 * Multisample attribute group (GL_MULTISAMPLE_BIT).

 */

struct gl_multisample_attrib

{

   GLboolean Enabled;

   GLboolean _Enabled;   /**< true if Enabled and multisample buffer */

   GLboolean SampleAlphaToCoverage;

   GLboolean SampleAlphaToOne;

   GLboolean SampleCoverage;

   GLfloat SampleCoverageValue;

   GLboolean SampleCoverageInvert;

   /* ARB_texture_multisample / GL3.2 additions */

   GLboolean SampleMask;

   /** The GL spec defines this as an array but >32x MSAA is madness */

   GLbitfield SampleMaskValue;

};

/**

 * A pixelmap (see glPixelMap)

 */

struct gl_pixelmap

{

   GLint Size;

   GLfloat Map[MAX_PIXEL_MAP_TABLE];

};

/**

 * Collection of all pixelmaps

 */

struct gl_pixelmaps

{

   struct gl_pixelmap RtoR;  /**< i.e. GL_PIXEL_MAP_R_TO_R */

   struct gl_pixelmap GtoG;

   struct gl_pixelmap BtoB;

   struct gl_pixelmap AtoA;

   struct gl_pixelmap ItoR;

   struct gl_pixelmap ItoG;

   struct gl_pixelmap ItoB;

   struct gl_pixelmap ItoA;

   struct gl_pixelmap ItoI;

   struct gl_pixelmap StoS;

};

/**

 * Pixel attribute group (GL_PIXEL_MODE_BIT).

 */

struct gl_pixel_attrib

{

   GLenum ReadBuffer;		/**< source buffer for glRead/CopyPixels() */

   /*--- Begin Pixel Transfer State ---*/

   /* Fields are in the order in which they're applied... */

   /** Scale & Bias (index shift, offset) */

   /*@{*/

   GLfloat RedBias, RedScale;

   GLfloat GreenBias, GreenScale;

   GLfloat BlueBias, BlueScale;

   GLfloat AlphaBias, AlphaScale;

   GLfloat DepthBias, DepthScale;

   GLint IndexShift, IndexOffset;

   /*@}*/

   /* Pixel Maps */

   /* Note: actual pixel maps are not part of this attrib group */

   GLboolean MapColorFlag;

   GLboolean MapStencilFlag;

   /*--- End Pixel Transfer State ---*/

   /** glPixelZoom */

   GLfloat ZoomX, ZoomY;

};

/**

 * Point attribute group (GL_POINT_BIT).

 */

struct gl_point_attrib

{

   GLboolean SmoothFlag;	/**< True if GL_POINT_SMOOTH is enabled */

   GLfloat Size;		/**< User-specified point size */

   GLfloat Params[3];		/**< GL_EXT_point_parameters */

   GLfloat MinSize, MaxSize;	/**< GL_EXT_point_parameters */

   GLfloat Threshold;		/**< GL_EXT_point_parameters */

   GLboolean _Attenuated;	/**< True if Params != [1, 0, 0] */

   GLboolean PointSprite;	/**< GL_NV/ARB_point_sprite */

   GLboolean CoordReplace[MAX_TEXTURE_COORD_UNITS]; /**< GL_ARB_point_sprite*/

   GLenum SpriteRMode;		/**< GL_NV_point_sprite (only!) */

   GLenum SpriteOrigin;		/**< GL_ARB_point_sprite */

};

/**

 * Polygon attribute group (GL_POLYGON_BIT).

 */

struct gl_polygon_attrib

{

   GLenum FrontFace;		/**< Either GL_CW or GL_CCW */

   GLenum FrontMode;		/**< Either GL_POINT, GL_LINE or GL_FILL */

   GLenum BackMode;		/**< Either GL_POINT, GL_LINE or GL_FILL */

   GLboolean _FrontBit;		/**< 0=GL_CCW, 1=GL_CW */

   GLboolean CullFlag;		/**< Culling on/off flag */

   GLboolean SmoothFlag;	/**< True if GL_POLYGON_SMOOTH is enabled */

   GLboolean StippleFlag;	/**< True if GL_POLYGON_STIPPLE is enabled */

   GLenum CullFaceMode;		/**< Culling mode GL_FRONT or GL_BACK */

   GLfloat OffsetFactor;	/**< Polygon offset factor, from user */

   GLfloat OffsetUnits;		/**< Polygon offset units, from user */

   GLboolean OffsetPoint;	/**< Offset in GL_POINT mode */

   GLboolean OffsetLine;	/**< Offset in GL_LINE mode */

   GLboolean OffsetFill;	/**< Offset in GL_FILL mode */

};

/**

 * Scissor attributes (GL_SCISSOR_BIT).

 */

struct gl_scissor_attrib

{

   GLboolean Enabled;		/**< Scissor test enabled? */

   GLint X, Y;			/**< Lower left corner of box */

   GLsizei Width, Height;	/**< Size of box */

};

/**

 * Stencil attribute group (GL_STENCIL_BUFFER_BIT).

 *

 * Three sets of stencil data are tracked so that OpenGL 2.0,

 * GL_EXT_stencil_two_side, and GL_ATI_separate_stencil can all be supported

 * simultaneously.  In each of the stencil state arrays, element 0 corresponds

 * to GL_FRONT.  Element 1 corresponds to the OpenGL 2.0 /

 * GL_ATI_separate_stencil GL_BACK state.  Element 2 corresponds to the

 * GL_EXT_stencil_two_side GL_BACK state.

 *

 * The derived value \c _BackFace is either 1 or 2 depending on whether or

 * not GL_STENCIL_TEST_TWO_SIDE_EXT is enabled.

 *

 * The derived value \c _TestTwoSide is set when the front-face and back-face

 * stencil state are different.

 */

struct gl_stencil_attrib

{

   GLboolean Enabled;		/**< Enabled flag */

   GLboolean TestTwoSide;	/**< GL_EXT_stencil_two_side */

   GLubyte ActiveFace;		/**< GL_EXT_stencil_two_side (0 or 2) */

   GLboolean _Enabled;          /**< Enabled and stencil buffer present */

   GLboolean _WriteEnabled;     /**< _Enabled and non-zero writemasks */

   GLboolean _TestTwoSide;

   GLubyte _BackFace;           /**< Current back stencil state (1 or 2) */

   GLenum Function[3];		/**< Stencil function */

   GLenum FailFunc[3];		/**< Fail function */

   GLenum ZPassFunc[3];		/**< Depth buffer pass function */

   GLenum ZFailFunc[3];		/**< Depth buffer fail function */

   GLint Ref[3];		/**< Reference value */

   GLuint ValueMask[3];		/**< Value mask */

   GLuint WriteMask[3];		/**< Write mask */

   GLuint Clear;		/**< Clear value */

};

/**

 * An index for each type of texture object.  These correspond to the GL

 * texture target enums, such as GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP, etc.

 * Note: the order is from highest priority to lowest priority.

 */

typedef enum

{

   TEXTURE_2D_MULTISAMPLE_INDEX,

   TEXTURE_2D_MULTISAMPLE_ARRAY_INDEX,

   TEXTURE_CUBE_ARRAY_INDEX,

   TEXTURE_BUFFER_INDEX,

   TEXTURE_2D_ARRAY_INDEX,

   TEXTURE_1D_ARRAY_INDEX,

   TEXTURE_EXTERNAL_INDEX,

   TEXTURE_CUBE_INDEX,

   TEXTURE_3D_INDEX,

   TEXTURE_RECT_INDEX,

   TEXTURE_2D_INDEX,

   TEXTURE_1D_INDEX,

   NUM_TEXTURE_TARGETS

} gl_texture_index;

/**

 * Bit flags for each type of texture object

 * Used for Texture.Unit[]._ReallyEnabled flags.

 */

/*@{*/

#define TEXTURE_2D_MULTISAMPLE_BIT (1 << TEXTURE_2D_MULTISAMPLE_INDEX)

#define TEXTURE_2D_MULTISAMPLE_ARRAY_BIT (1 << TEXTURE_2D_MULTISAMPLE_ARRAY_INDEX)

#define TEXTURE_CUBE_ARRAY_BIT (1 << TEXTURE_CUBE_ARRAY_INDEX)

#define TEXTURE_BUFFER_BIT   (1 << TEXTURE_BUFFER_INDEX)

#define TEXTURE_2D_ARRAY_BIT (1 << TEXTURE_2D_ARRAY_INDEX)

#define TEXTURE_1D_ARRAY_BIT (1 << TEXTURE_1D_ARRAY_INDEX)

#define TEXTURE_EXTERNAL_BIT (1 << TEXTURE_EXTERNAL_INDEX)

#define TEXTURE_CUBE_BIT     (1 << TEXTURE_CUBE_INDEX)

#define TEXTURE_3D_BIT       (1 << TEXTURE_3D_INDEX)

#define TEXTURE_RECT_BIT     (1 << TEXTURE_RECT_INDEX)

#define TEXTURE_2D_BIT       (1 << TEXTURE_2D_INDEX)

#define TEXTURE_1D_BIT       (1 << TEXTURE_1D_INDEX)

/*@}*/

/**

 * Texture image state.  Drivers will typically create a subclass of this

 * with extra fields for memory buffers, etc.

 */

struct gl_texture_image

{

   GLint InternalFormat;	/**< Internal format as given by the user */

   GLenum _BaseFormat;		/**< Either GL_RGB, GL_RGBA, GL_ALPHA,

				 *   GL_LUMINANCE, GL_LUMINANCE_ALPHA,

				 *   GL_INTENSITY, GL_DEPTH_COMPONENT or

				 *   GL_DEPTH_STENCIL_EXT only. Used for

				 *   choosing TexEnv arithmetic.

				 */

   gl_format TexFormat;         /**< The actual texture memory format */

   GLuint Border;		/**< 0 or 1 */

   GLuint Width;		/**< = 2^WidthLog2 + 2*Border */

   GLuint Height;		/**< = 2^HeightLog2 + 2*Border */

   GLuint Depth;		/**< = 2^DepthLog2 + 2*Border */

   GLuint Width2;		/**< = Width - 2*Border */

   GLuint Height2;		/**< = Height - 2*Border */

   GLuint Depth2;		/**< = Depth - 2*Border */

   GLuint WidthLog2;		/**< = log2(Width2) */

   GLuint HeightLog2;		/**< = log2(Height2) */

   GLuint DepthLog2;		/**< = log2(Depth2) */

   GLuint MaxNumLevels;		/**< = maximum possible number of mipmap

                                       levels, computed from the dimensions */

   struct gl_texture_object *TexObject;  /**< Pointer back to parent object */

   GLuint Level;                /**< Which mipmap level am I? */

   /** Cube map face: index into gl_texture_object::Image[] array */

   GLuint Face;

   /** GL_ARB_texture_multisample */

   GLuint NumSamples;            /**< Sample count, or 0 for non-multisample */

   GLboolean FixedSampleLocations; /**< Same sample locations for all pixels? */

};

/**

 * Indexes for cube map faces.

 */

typedef enum

{

   FACE_POS_X = 0,

   FACE_NEG_X = 1,

   FACE_POS_Y = 2,

   FACE_NEG_Y = 3,

   FACE_POS_Z = 4,

   FACE_NEG_Z = 5,

   MAX_FACES = 6

} gl_face_index;

/**

 * Sampler object state.  These objects are new with GL_ARB_sampler_objects

 * and OpenGL 3.3.  Legacy texture objects also contain a sampler object.

 */

struct gl_sampler_object