Subversion Repositories Kolibri OS

/*

 * Mesa 3-D graphics library

 *

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

 * Copyright (C) 2008  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 context.c

 * Mesa context/visual/framebuffer management functions.

 * \author Brian Paul

 */

/**

 * \mainpage Mesa Main Module

 *

 * \section MainIntroduction Introduction

 *

 * The Mesa Main module consists of all the files in the main/ directory.

 * Among the features of this module are:

 * 

 * 
 Structures to represent most GL state 

 * 
 State set/get functions 

 * 
 Display lists 

 * 
 Texture unit, object and image handling 

 * 
 Matrix and attribute stacks 

 * 

 *

 * Other modules are responsible for API dispatch, vertex transformation,

 * point/line/triangle setup, rasterization, vertex array caching,

 * vertex/fragment programs/shaders, etc.

 *

 *

 * \section AboutDoxygen About Doxygen

 *

 * If you're viewing this information as Doxygen-generated HTML you'll

 * see the documentation index at the top of this page.

 *

 * The first line lists the Mesa source code modules.

 * The second line lists the indexes available for viewing the documentation

 * for each module.

 *

 * Selecting the Main page link will display a summary of the module

 * (this page).

 *

 * Selecting Data Structures will list all C structures.

 *

 * Selecting the File List link will list all the source files in

 * the module.

 * Selecting a filename will show a list of all functions defined in that file.

 *

 * Selecting the Data Fields link will display a list of all

 * documented structure members.

 *

 * Selecting the Globals link will display a list

 * of all functions, structures, global variables and macros in the module.

 *

 */

#include "glheader.h"

#include "imports.h"

#include "accum.h"

#include "api_exec.h"

#include "api_loopback.h"

#include "arrayobj.h"

#include "attrib.h"

#include "blend.h"

#include "buffers.h"

#include "bufferobj.h"

#include "context.h"

#include "cpuinfo.h"

#include "debug.h"

#include "depth.h"

#include "dlist.h"

#include "eval.h"

#include "extensions.h"

#include "fbobject.h"

#include "feedback.h"

#include "fog.h"

#include "formats.h"

#include "framebuffer.h"

#include "hint.h"

#include "hash.h"

#include "light.h"

#include "lines.h"

#include "macros.h"

#include "matrix.h"

#include "multisample.h"

#include "performance_monitor.h"

#include "pipelineobj.h"

#include "pixel.h"

#include "pixelstore.h"

#include "points.h"

#include "polygon.h"

#include "queryobj.h"

#include "syncobj.h"

#include "rastpos.h"

#include "remap.h"

#include "scissor.h"

#include "shared.h"

#include "shaderobj.h"

#include "shaderimage.h"

#include "util/simple_list.h"

#include "state.h"

#include "stencil.h"

#include "texcompress_s3tc.h"

#include "texstate.h"

#include "transformfeedback.h"

#include "mtypes.h"

#include "varray.h"

#include "version.h"

#include "viewport.h"

#include "vtxfmt.h"

#include "program/program.h"

#include "program/prog_print.h"

#include "math/m_matrix.h"

#include "main/dispatch.h" /* for _gloffset_COUNT */

#include "uniforms.h"

#include "macros.h"

#ifdef USE_SPARC_ASM

#include "sparc/sparc.h"

#endif

#include "glsl_parser_extras.h"

#include 

#ifndef MESA_VERBOSE

int MESA_VERBOSE = 0;

#endif

#ifndef MESA_DEBUG_FLAGS

int MESA_DEBUG_FLAGS = 0;

#endif

/* ubyte -> float conversion */

GLfloat _mesa_ubyte_to_float_color_tab[256];

/**

 * Swap buffers notification callback.

 *

 * \param ctx GL context.

 *

 * Called by window system just before swapping buffers.

 * We have to finish any pending rendering.

 */

void

_mesa_notifySwapBuffers(struct gl_context *ctx)

{

   if (MESA_VERBOSE & VERBOSE_SWAPBUFFERS)

      _mesa_debug(ctx, "SwapBuffers\n");

   FLUSH_CURRENT( ctx, 0 );

   if (ctx->Driver.Flush) {

      ctx->Driver.Flush(ctx);

   }

}

/**********************************************************************/

/** \name GL Visual allocation/destruction                            */

/**********************************************************************/

/*@{*/

/**

 * Allocates a struct gl_config structure and initializes it via

 * _mesa_initialize_visual().

 *

 * \param dbFlag double buffering

 * \param stereoFlag stereo buffer

 * \param depthBits requested bits per depth buffer value. Any value in [0, 32]

 * is acceptable but the actual depth type will be GLushort or GLuint as

 * needed.

 * \param stencilBits requested minimum bits per stencil buffer value

 * \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number

 * of bits per color component in accum buffer.

 * \param indexBits number of bits per pixel if \p rgbFlag is GL_FALSE

 * \param redBits number of bits per color component in frame buffer for RGB(A)

 * mode.  We always use 8 in core Mesa though.

 * \param greenBits same as above.

 * \param blueBits same as above.

 * \param alphaBits same as above.

 * \param numSamples not really used.

 *

 * \return pointer to new struct gl_config or NULL if requested parameters

 * can't be met.

 *

 * \note Need to add params for level and numAuxBuffers (at least)

 */

struct gl_config *

_mesa_create_visual( GLboolean dbFlag,

                     GLboolean stereoFlag,

                     GLint redBits,

                     GLint greenBits,

                     GLint blueBits,

                     GLint alphaBits,

                     GLint depthBits,

                     GLint stencilBits,

                     GLint accumRedBits,

                     GLint accumGreenBits,

                     GLint accumBlueBits,

                     GLint accumAlphaBits,

                     GLint numSamples )

{

   struct gl_config *vis = CALLOC_STRUCT(gl_config);

   if (vis) {

      if (!_mesa_initialize_visual(vis, dbFlag, stereoFlag,

                                   redBits, greenBits, blueBits, alphaBits,

                                   depthBits, stencilBits,

                                   accumRedBits, accumGreenBits,

                                   accumBlueBits, accumAlphaBits,

                                   numSamples)) {

         free(vis);

         return NULL;

      }

   }

   return vis;

}

/**

 * Makes some sanity checks and fills in the fields of the struct

 * gl_config object with the given parameters.  If the caller needs to

 * set additional fields, he should just probably init the whole

 * gl_config object himself.

 *

 * \return GL_TRUE on success, or GL_FALSE on failure.

 *

 * \sa _mesa_create_visual() above for the parameter description.

 */

GLboolean

_mesa_initialize_visual( struct gl_config *vis,

                         GLboolean dbFlag,

                         GLboolean stereoFlag,

                         GLint redBits,

                         GLint greenBits,

                         GLint blueBits,

                         GLint alphaBits,

                         GLint depthBits,

                         GLint stencilBits,

                         GLint accumRedBits,

                         GLint accumGreenBits,

                         GLint accumBlueBits,

                         GLint accumAlphaBits,

                         GLint numSamples )

{

   assert(vis);

   if (depthBits < 0 || depthBits > 32) {

      return GL_FALSE;

   }

   if (stencilBits < 0 || stencilBits > 8) {

      return GL_FALSE;

   }

   assert(accumRedBits >= 0);

   assert(accumGreenBits >= 0);

   assert(accumBlueBits >= 0);

   assert(accumAlphaBits >= 0);

   vis->rgbMode          = GL_TRUE;

   vis->doubleBufferMode = dbFlag;

   vis->stereoMode       = stereoFlag;

   vis->redBits          = redBits;

   vis->greenBits        = greenBits;

   vis->blueBits         = blueBits;

   vis->alphaBits        = alphaBits;

   vis->rgbBits          = redBits + greenBits + blueBits;

   vis->indexBits      = 0;

   vis->depthBits      = depthBits;

   vis->stencilBits    = stencilBits;

   vis->accumRedBits   = accumRedBits;

   vis->accumGreenBits = accumGreenBits;

   vis->accumBlueBits  = accumBlueBits;

   vis->accumAlphaBits = accumAlphaBits;

   vis->haveAccumBuffer   = accumRedBits > 0;

   vis->haveDepthBuffer   = depthBits > 0;

   vis->haveStencilBuffer = stencilBits > 0;

   vis->numAuxBuffers = 0;

   vis->level = 0;

   vis->sampleBuffers = numSamples > 0 ? 1 : 0;

   vis->samples = numSamples;

   return GL_TRUE;

}

/**

 * Destroy a visual and free its memory.

 *

 * \param vis visual.

 *

 * Frees the visual structure.

 */

void

_mesa_destroy_visual( struct gl_config *vis )

{

   free(vis);

}

/*@}*/

/**********************************************************************/

/** \name Context allocation, initialization, destroying

 *

 * The purpose of the most initialization functions here is to provide the

 * default state values according to the OpenGL specification.

 */

/**********************************************************************/

/*@{*/

/**

 * This is lame.  gdb only seems to recognize enum types that are

 * actually used somewhere.  We want to be able to print/use enum

 * values such as TEXTURE_2D_INDEX in gdb.  But we don't actually use

 * the gl_texture_index type anywhere.  Thus, this lame function.

 */

static void

dummy_enum_func(void)

{

   gl_buffer_index bi = BUFFER_FRONT_LEFT;

   gl_face_index fi = FACE_POS_X;

   gl_frag_result fr = FRAG_RESULT_DEPTH;

   gl_texture_index ti = TEXTURE_2D_ARRAY_INDEX;

   gl_vert_attrib va = VERT_ATTRIB_POS;

   gl_varying_slot vs = VARYING_SLOT_POS;

   (void) bi;

   (void) fi;

   (void) fr;

   (void) ti;

   (void) va;

   (void) vs;

}

/**

 * One-time initialization mutex lock.

 *

 * \sa Used by one_time_init().

 */

mtx_t OneTimeLock = _MTX_INITIALIZER_NP;

/**

 * Calls all the various one-time-init functions in Mesa.

 *

 * While holding a global mutex lock, calls several initialization functions,

 * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is

 * defined.

 *

 * \sa _math_init().

 */

static void

one_time_init( struct gl_context *ctx )

{

   static GLbitfield api_init_mask = 0x0;

   mtx_lock(&OneTimeLock);

   /* truly one-time init */

   if (!api_init_mask) {

      GLuint i;

      /* do some implementation tests */

      assert( sizeof(GLbyte) == 1 );

      assert( sizeof(GLubyte) == 1 );

      assert( sizeof(GLshort) == 2 );

      assert( sizeof(GLushort) == 2 );

      assert( sizeof(GLint) == 4 );

      assert( sizeof(GLuint) == 4 );

      _mesa_one_time_init_extension_overrides();

      _mesa_get_cpu_features();

      for (i = 0; i < 256; i++) {

         _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;

      }

#if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)

      if (MESA_VERBOSE != 0) {

	 _mesa_debug(ctx, "Mesa %s DEBUG build %s %s\n",

		     PACKAGE_VERSION, __DATE__, __TIME__);

      }

#endif

#ifdef DEBUG

      _mesa_test_formats();

#endif

   }

   /* per-API one-time init */

   if (!(api_init_mask & (1 << ctx->API))) {

      _mesa_init_get_hash(ctx);

      _mesa_init_remap_table();

   }

   api_init_mask |= 1 << ctx->API;

   mtx_unlock(&OneTimeLock);

   /* Hopefully atexit() is widely available.  If not, we may need some

    * #ifdef tests here.

    */

   atexit(_mesa_destroy_shader_compiler);

   dummy_enum_func();

}

/**

 * Initialize fields of gl_current_attrib (aka ctx->Current.*)

 */

static void

_mesa_init_current(struct gl_context *ctx)

{

   GLuint i;

   /* Init all to (0,0,0,1) */

   for (i = 0; i < ARRAY_SIZE(ctx->Current.Attrib); i++) {

      ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );

   }

   /* redo special cases: */

   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 0.0 );

   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );

   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );

   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );

   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 );

   ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 );

}

/**

 * Init vertex/fragment/geometry program limits.

 * Important: drivers should override these with actual limits.

 */

static void

init_program_limits(struct gl_constants *consts, gl_shader_stage stage,

                    struct gl_program_constants *prog)

{

   prog->MaxInstructions = MAX_PROGRAM_INSTRUCTIONS;

   prog->MaxAluInstructions = MAX_PROGRAM_INSTRUCTIONS;

   prog->MaxTexInstructions = MAX_PROGRAM_INSTRUCTIONS;

   prog->MaxTexIndirections = MAX_PROGRAM_INSTRUCTIONS;

   prog->MaxTemps = MAX_PROGRAM_TEMPS;

   prog->MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;

   prog->MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;

   prog->MaxAddressOffset = MAX_PROGRAM_LOCAL_PARAMS;

   switch (stage) {

   case MESA_SHADER_VERTEX:

      prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;

      prog->MaxAttribs = MAX_VERTEX_GENERIC_ATTRIBS;

      prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;

      prog->MaxUniformComponents = 4 * MAX_UNIFORMS;

      prog->MaxInputComponents = 0; /* value not used */

      prog->MaxOutputComponents = 16 * 4; /* old limit not to break tnl and swrast */

      break;

   case MESA_SHADER_FRAGMENT:

      prog->MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS;

      prog->MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;

      prog->MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;

      prog->MaxUniformComponents = 4 * MAX_UNIFORMS;

      prog->MaxInputComponents = 16 * 4; /* old limit not to break tnl and swrast */

      prog->MaxOutputComponents = 0; /* value not used */

      break;

   case MESA_SHADER_GEOMETRY:

      prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;

      prog->MaxAttribs = MAX_VERTEX_GENERIC_ATTRIBS;

      prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;

      prog->MaxUniformComponents = 4 * MAX_UNIFORMS;

      prog->MaxInputComponents = 16 * 4; /* old limit not to break tnl and swrast */

      prog->MaxOutputComponents = 16 * 4; /* old limit not to break tnl and swrast */

      break;

   case MESA_SHADER_COMPUTE:

      prog->MaxParameters = 0; /* not meaningful for compute shaders */

      prog->MaxAttribs = 0; /* not meaningful for compute shaders */

      prog->MaxAddressRegs = 0; /* not meaningful for compute shaders */

      prog->MaxUniformComponents = 4 * MAX_UNIFORMS;

      prog->MaxInputComponents = 0; /* not meaningful for compute shaders */

      prog->MaxOutputComponents = 0; /* not meaningful for compute shaders */

      break;

   default:

      assert(0 && "Bad shader stage in init_program_limits()");

   }

   /* Set the native limits to zero.  This implies that there is no native

    * support for shaders.  Let the drivers fill in the actual values.

    */

   prog->MaxNativeInstructions = 0;

   prog->MaxNativeAluInstructions = 0;

   prog->MaxNativeTexInstructions = 0;

   prog->MaxNativeTexIndirections = 0;

   prog->MaxNativeAttribs = 0;

   prog->MaxNativeTemps = 0;

   prog->MaxNativeAddressRegs = 0;

   prog->MaxNativeParameters = 0;

   /* Set GLSL datatype range/precision info assuming IEEE float values.

    * Drivers should override these defaults as needed.

    */

   prog->MediumFloat.RangeMin = 127;

   prog->MediumFloat.RangeMax = 127;

   prog->MediumFloat.Precision = 23;

   prog->LowFloat = prog->HighFloat = prog->MediumFloat;

   /* Assume ints are stored as floats for now, since this is the least-common

    * denominator.  The OpenGL ES spec implies (page 132) that the precision

    * of integer types should be 0.  Practically speaking, IEEE

    * single-precision floating point values can only store integers in the

    * range [-0x01000000, 0x01000000] without loss of precision.

    */

   prog->MediumInt.RangeMin = 24;

   prog->MediumInt.RangeMax = 24;

   prog->MediumInt.Precision = 0;

   prog->LowInt = prog->HighInt = prog->MediumInt;

   prog->MaxUniformBlocks = 12;

   prog->MaxCombinedUniformComponents = (prog->MaxUniformComponents +

                                         consts->MaxUniformBlockSize / 4 *

                                         prog->MaxUniformBlocks);

   prog->MaxAtomicBuffers = 0;

   prog->MaxAtomicCounters = 0;

}

/**

 * Initialize fields of gl_constants (aka ctx->Const.*).

 * Use defaults from config.h.  The device drivers will often override

 * some of these values (such as number of texture units).

 */

void

_mesa_init_constants(struct gl_constants *consts, gl_api api)

{

   int i;

   assert(consts);

   /* Constants, may be overriden (usually only reduced) by device drivers */

   consts->MaxTextureMbytes = MAX_TEXTURE_MBYTES;

   consts->MaxTextureLevels = MAX_TEXTURE_LEVELS;

   consts->Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;

   consts->MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;

   consts->MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;

   consts->MaxArrayTextureLayers = MAX_ARRAY_TEXTURE_LAYERS;

   consts->MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;

   consts->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;

   consts->MaxTextureUnits = MIN2(consts->MaxTextureCoordUnits,

                                     consts->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits);

   consts->MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;

   consts->MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;

   consts->MaxTextureBufferSize = 65536;

   consts->TextureBufferOffsetAlignment = 1;

   consts->MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;

   consts->SubPixelBits = SUB_PIXEL_BITS;

   consts->MinPointSize = MIN_POINT_SIZE;

   consts->MaxPointSize = MAX_POINT_SIZE;

   consts->MinPointSizeAA = MIN_POINT_SIZE;

   consts->MaxPointSizeAA = MAX_POINT_SIZE;

   consts->PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;

   consts->MinLineWidth = MIN_LINE_WIDTH;

   consts->MaxLineWidth = MAX_LINE_WIDTH;

   consts->MinLineWidthAA = MIN_LINE_WIDTH;

   consts->MaxLineWidthAA = MAX_LINE_WIDTH;

   consts->LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;

   consts->MaxClipPlanes = 6;

   consts->MaxLights = MAX_LIGHTS;

   consts->MaxShininess = 128.0;

   consts->MaxSpotExponent = 128.0;

   consts->MaxViewportWidth = MAX_VIEWPORT_WIDTH;

   consts->MaxViewportHeight = MAX_VIEWPORT_HEIGHT;

   consts->MinMapBufferAlignment = 64;

   /* Driver must override these values if ARB_viewport_array is supported. */

   consts->MaxViewports = 1;

   consts->ViewportSubpixelBits = 0;

   consts->ViewportBounds.Min = 0;

   consts->ViewportBounds.Max = 0;

   /** GL_ARB_uniform_buffer_object */

   consts->MaxCombinedUniformBlocks = 36;

   consts->MaxUniformBufferBindings = 36;

   consts->MaxUniformBlockSize = 16384;

   consts->UniformBufferOffsetAlignment = 1;

   /* GL_ARB_explicit_uniform_location, GL_MAX_UNIFORM_LOCATIONS */

   consts->MaxUserAssignableUniformLocations =

      4 * MESA_SHADER_STAGES * MAX_UNIFORMS;

   for (i = 0; i < MESA_SHADER_STAGES; i++)

      init_program_limits(consts, i, &consts->Program[i]);

   consts->MaxProgramMatrices = MAX_PROGRAM_MATRICES;

   consts->MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;

   /* Assume that if GLSL 1.30+ (or GLSL ES 3.00+) is supported that

    * gl_VertexID is implemented using a native hardware register with OpenGL

    * semantics.

    */

   consts->VertexID_is_zero_based = false;

   /* GL_ARB_draw_buffers */

   consts->MaxDrawBuffers = MAX_DRAW_BUFFERS;

   consts->MaxColorAttachments = MAX_COLOR_ATTACHMENTS;

   consts->MaxRenderbufferSize = MAX_RENDERBUFFER_SIZE;

   consts->Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;

   consts->MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;

   consts->MaxVarying = 16; /* old limit not to break tnl and swrast */

   consts->Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;

   consts->MaxGeometryOutputVertices = MAX_GEOMETRY_OUTPUT_VERTICES;

   consts->MaxGeometryTotalOutputComponents = MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS;

   /* Shading language version */

   consts->GLSLVersion = 120;

   _mesa_override_glsl_version(consts);

#ifdef DEBUG

   consts->GenerateTemporaryNames = true;

#else

   consts->GenerateTemporaryNames = false;

#endif

   /* GL_ARB_framebuffer_object */

   consts->MaxSamples = 0;

   /* GLSL default if NativeIntegers == FALSE */

   consts->UniformBooleanTrue = FLOAT_AS_UNION(1.0f).u;

   /* GL_ARB_sync */

   consts->MaxServerWaitTimeout = 0x1fff7fffffffULL;

   /* GL_EXT_provoking_vertex */

   consts->QuadsFollowProvokingVertexConvention = GL_TRUE;

   /* GL_EXT_transform_feedback */

   consts->MaxTransformFeedbackBuffers = MAX_FEEDBACK_BUFFERS;

   consts->MaxTransformFeedbackSeparateComponents = 4 * MAX_FEEDBACK_ATTRIBS;

   consts->MaxTransformFeedbackInterleavedComponents = 4 * MAX_FEEDBACK_ATTRIBS;

   consts->MaxVertexStreams = 1;

   /* GL 3.2  */

   consts->ProfileMask = api == API_OPENGL_CORE

                          ? GL_CONTEXT_CORE_PROFILE_BIT

                          : GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;

   /* GL 4.4 */

   consts->MaxVertexAttribStride = 2048;

   /** GL_EXT_gpu_shader4 */

   consts->MinProgramTexelOffset = -8;

   consts->MaxProgramTexelOffset = 7;

   /* GL_ARB_texture_gather */

   consts->MinProgramTextureGatherOffset = -8;

   consts->MaxProgramTextureGatherOffset = 7;

   /* GL_ARB_robustness */

   consts->ResetStrategy = GL_NO_RESET_NOTIFICATION_ARB;

   /* ES 3.0 or ARB_ES3_compatibility */

   consts->MaxElementIndex = 0xffffffffu;

   /* GL_ARB_texture_multisample */

   consts->MaxColorTextureSamples = 1;

   consts->MaxDepthTextureSamples = 1;

   consts->MaxIntegerSamples = 1;

   /* GL_ARB_shader_atomic_counters */

   consts->MaxAtomicBufferBindings = MAX_COMBINED_ATOMIC_BUFFERS;

   consts->MaxAtomicBufferSize = MAX_ATOMIC_COUNTERS * ATOMIC_COUNTER_SIZE;

   consts->MaxCombinedAtomicBuffers = MAX_COMBINED_ATOMIC_BUFFERS;

   consts->MaxCombinedAtomicCounters = MAX_ATOMIC_COUNTERS;

   /* GL_ARB_vertex_attrib_binding */

   consts->MaxVertexAttribRelativeOffset = 2047;

   consts->MaxVertexAttribBindings = MAX_VERTEX_GENERIC_ATTRIBS;

   /* GL_ARB_compute_shader */

   consts->MaxComputeWorkGroupCount[0] = 65535;

   consts->MaxComputeWorkGroupCount[1] = 65535;

   consts->MaxComputeWorkGroupCount[2] = 65535;

   consts->MaxComputeWorkGroupSize[0] = 1024;

   consts->MaxComputeWorkGroupSize[1] = 1024;

   consts->MaxComputeWorkGroupSize[2] = 64;

   consts->MaxComputeWorkGroupInvocations = 1024;

   /** GL_ARB_gpu_shader5 */

   consts->MinFragmentInterpolationOffset = MIN_FRAGMENT_INTERPOLATION_OFFSET;

   consts->MaxFragmentInterpolationOffset = MAX_FRAGMENT_INTERPOLATION_OFFSET;

   /** GL_KHR_context_flush_control */

   consts->ContextReleaseBehavior = GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH;

}

/**

 * Do some sanity checks on the limits/constants for the given context.

 * Only called the first time a context is bound.

 */

static void

check_context_limits(struct gl_context *ctx)

{

   (void) ctx;

   /* check that we don't exceed the size of various bitfields */

   assert(VARYING_SLOT_MAX <=

	  (8 * sizeof(ctx->VertexProgram._Current->Base.OutputsWritten)));

   assert(VARYING_SLOT_MAX <=

	  (8 * sizeof(ctx->FragmentProgram._Current->Base.InputsRead)));

   /* shader-related checks */

   assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);

   assert(ctx->Const.Program[MESA_SHADER_VERTEX].MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);

   /* Texture unit checks */

   assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits > 0);

   assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS);

   assert(ctx->Const.MaxTextureCoordUnits > 0);

   assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS);

   assert(ctx->Const.MaxTextureUnits > 0);

   assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS);

   assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS);

   assert(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits,

                                             ctx->Const.MaxTextureCoordUnits));

   assert(ctx->Const.MaxCombinedTextureImageUnits > 0);

   assert(ctx->Const.MaxCombinedTextureImageUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);

   assert(ctx->Const.MaxTextureCoordUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);

   /* number of coord units cannot be greater than number of image units */

   assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits);

   /* Texture size checks */

   assert(ctx->Const.MaxTextureLevels <= MAX_TEXTURE_LEVELS);

   assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS);

   assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS);

   assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE);

   /* Texture level checks */

   assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);

   assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);

   /* Max texture size should be <= max viewport size (render to texture) */

   assert((1U << (ctx->Const.MaxTextureLevels - 1))

          <= ctx->Const.MaxViewportWidth);

   assert((1U << (ctx->Const.MaxTextureLevels - 1))

          <= ctx->Const.MaxViewportHeight);

   assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);

   /* if this fails, add more enum values to gl_buffer_index */

   assert(BUFFER_COLOR0 + MAX_DRAW_BUFFERS <= BUFFER_COUNT);

   /* XXX probably add more tests */

}

/**

 * Initialize the attribute groups in a GL context.

 *

 * \param ctx GL context.

 *

 * Initializes all the attributes, calling the respective init*

 * functions for the more complex data structures.

 */

static GLboolean

init_attrib_groups(struct gl_context *ctx)

{

   assert(ctx);

   /* Constants */

   _mesa_init_constants(&ctx->Const, ctx->API);

   /* Extensions */

   _mesa_init_extensions(&ctx->Extensions);

   /* Attribute Groups */

   _mesa_init_accum( ctx );

   _mesa_init_attrib( ctx );

   _mesa_init_buffer_objects( ctx );

   _mesa_init_color( ctx );

   _mesa_init_current( ctx );

   _mesa_init_depth( ctx );

   _mesa_init_debug( ctx );

   _mesa_init_display_list( ctx );

   _mesa_init_errors( ctx );

   _mesa_init_eval( ctx );

   _mesa_init_fbobjects( ctx );

   _mesa_init_feedback( ctx );

   _mesa_init_fog( ctx );

   _mesa_init_hint( ctx );

   _mesa_init_image_units( ctx );

   _mesa_init_line( ctx );

   _mesa_init_lighting( ctx );

   _mesa_init_matrix( ctx );

   _mesa_init_multisample( ctx );

   _mesa_init_performance_monitors( ctx );

   _mesa_init_pipeline( ctx );

   _mesa_init_pixel( ctx );

   _mesa_init_pixelstore( ctx );

   _mesa_init_point( ctx );

   _mesa_init_polygon( ctx );

   _mesa_init_program( ctx );

   _mesa_init_queryobj( ctx );

   _mesa_init_sync( ctx );

   _mesa_init_rastpos( ctx );

   _mesa_init_scissor( ctx );

   _mesa_init_shader_state( ctx );

   _mesa_init_stencil( ctx );

   _mesa_init_transform( ctx );

   _mesa_init_transform_feedback( ctx );

   _mesa_init_varray( ctx );

   _mesa_init_viewport( ctx );

   if (!_mesa_init_texture( ctx ))

      return GL_FALSE;

   _mesa_init_texture_s3tc( ctx );

   /* Miscellaneous */

   ctx->NewState = _NEW_ALL;

   ctx->NewDriverState = ~0;

   ctx->ErrorValue = GL_NO_ERROR;

   ctx->ShareGroupReset = false;

   ctx->varying_vp_inputs = VERT_BIT_ALL;

   return GL_TRUE;

}

/**

 * Update default objects in a GL context with respect to shared state.

 *

 * \param ctx GL context.

 *

 * Removes references to old default objects, (texture objects, program

 * objects, etc.) and changes to reference those from the current shared

 * state.

 */

static GLboolean

update_default_objects(struct gl_context *ctx)

{

   assert(ctx);

   _mesa_update_default_objects_program(ctx);

   _mesa_update_default_objects_texture(ctx);

   _mesa_update_default_objects_buffer_objects(ctx);

   return GL_TRUE;

}

/* XXX this is temporary and should be removed at some point in the

 * future when there's a reasonable expectation that the libGL library

 * contains the _glapi_new_nop_table() and _glapi_set_nop_handler()

 * functions which were added in Mesa 10.6.

 */

#if !defined(_WIN32)

/* Avoid libGL / driver ABI break */

#define USE_GLAPI_NOP_FEATURES 0

#else

#define USE_GLAPI_NOP_FEATURES 1

#endif

/**

 * This function is called by the glapi no-op functions.  For each OpenGL

 * function/entrypoint there's a simple no-op function.  These "no-op"

 * functions call this function.

 *

 * If there's a current OpenGL context for the calling thread, we record a

 * GL_INVALID_OPERATION error.  This can happen either because the app's

 * calling an unsupported extension function, or calling an illegal function

 * (such as glClear between glBegin/glEnd).

 *

 * If there's no current OpenGL context for the calling thread, we can

 * print a message to stderr.

 *

 * \param name  the name of the OpenGL function

 */

#if USE_GLAPI_NOP_FEATURES

static void

nop_handler(const char *name)

{

   GET_CURRENT_CONTEXT(ctx);

   if (ctx) {

      _mesa_error(ctx, GL_INVALID_OPERATION, "%s(invalid call)", name);

   }

#if defined(DEBUG)

   else if (getenv("MESA_DEBUG") || getenv("LIBGL_DEBUG")) {

      fprintf(stderr,

              "GL User Error: gl%s called without a rendering context\n",

              name);

      fflush(stderr);

   }

#endif

}

#endif

/**

 * Special no-op glFlush, see below.

 */

#if defined(_WIN32)

static void GLAPIENTRY

nop_glFlush(void)

{

   /* don't record an error like we do in nop_handler() */

}

#endif

#if !USE_GLAPI_NOP_FEATURES

static int

generic_nop(void)

{

   GET_CURRENT_CONTEXT(ctx);

   _mesa_error(ctx, GL_INVALID_OPERATION,

               "unsupported function called "

               "(unsupported extension or deprecated function?)");

   return 0;

}

#endif

/**

 * Create a new API dispatch table in which all entries point to the

 * generic_nop() function.  This will not work on Windows because of

 * the __stdcall convention which requires the callee to clean up the

 * call stack.  That's impossible with one generic no-op function.

 */

struct _glapi_table *

_mesa_new_nop_table(unsigned numEntries)

{

   struct _glapi_table *table;

#if !USE_GLAPI_NOP_FEATURES

   table = malloc(numEntries * sizeof(_glapi_proc));

   if (table) {

      _glapi_proc *entry = (_glapi_proc *) table;

      unsigned i;

      for (i = 0; i < numEntries; i++) {

         entry[i] = (_glapi_proc) generic_nop;

      }

   }

#else

   table = _glapi_new_nop_table(numEntries);

#endif

   return table;

}

/**

 * Allocate and initialize a new dispatch table.  The table will be

 * populated with pointers to "no-op" functions.  In turn, the no-op

 * functions will call nop_handler() above.

 */

static struct _glapi_table *

alloc_dispatch_table(void)

{

   /* Find the larger of Mesa's dispatch table and libGL's dispatch table.

    * In practice, this'll be the same for stand-alone Mesa.  But for DRI

    * Mesa we do this to accommodate different versions of libGL and various

    * DRI drivers.

    */

   int numEntries = MAX2(_glapi_get_dispatch_table_size(), _gloffset_COUNT);

   struct _glapi_table *table = _mesa_new_nop_table(numEntries);

#if defined(_WIN32)

   if (table) {

      /* This is a special case for Windows in the event that

       * wglGetProcAddress is called between glBegin/End().

       *

       * The MS opengl32.dll library apparently calls glFlush from

       * wglGetProcAddress().  If we're inside glBegin/End(), glFlush

       * will dispatch to _mesa_generic_nop() and we'll generate a

       * GL_INVALID_OPERATION error.

       *

       * The specific case which hits this is piglit's primitive-restart

       * test which calls glPrimitiveRestartNV() inside glBegin/End.  The

       * first time we call glPrimitiveRestartNV() Piglit's API dispatch

       * code will try to resolve the function by calling wglGetProcAddress.

       * This raises GL_INVALID_OPERATION and an assert(glGetError()==0)

       * will fail causing the test to fail.  By suppressing the error, the

       * assertion passes and the test continues.

       */

      SET_Flush(table, nop_glFlush);

   }

#endif

#if USE_GLAPI_NOP_FEATURES

   _glapi_set_nop_handler(nop_handler);

#endif

   return table;

}

/**

 * Creates a minimal dispatch table for use within glBegin()/glEnd().

 *

 * This ensures that we generate GL_INVALID_OPERATION errors from most

 * functions, since the set of functions that are valid within Begin/End is

 * very small.

 *

 * From the GL 1.0 specification section 2.6.3, "GL Commands within

 * Begin/End"

 *

 *     "The only GL commands that are allowed within any Begin/End pairs are

 *      the commands for specifying vertex coordinates, vertex color, normal

 *      coordinates, and texture coordinates (Vertex, Color, Index, Normal,

 *      TexCoord), EvalCoord and EvalPoint commands (see section 5.1),

 *      commands for specifying lighting material parameters (Material

 *      commands see section 2.12.2), display list invocation commands

 *      (CallList and CallLists see section 5.4), and the EdgeFlag

 *      command. Executing Begin after Begin has already been executed but

 *      before an End is issued generates the INVALID OPERATION error, as does

 *      executing End without a previous corresponding Begin. Executing any

 *      other GL command within Begin/End results in the error INVALID

 *      OPERATION."

 *

 * The table entries for specifying vertex attributes are set up by

 * install_vtxfmt() and _mesa_loopback_init_api_table(), and End() and dlists

 * are set by install_vtxfmt() as well.

 */

static struct _glapi_table *

create_beginend_table(const struct gl_context *ctx)

{

   struct _glapi_table *table;

   table = alloc_dispatch_table();

   if (!table)

      return NULL;

   /* Fill in functions which return a value, since they should return some

    * specific value even if they emit a GL_INVALID_OPERATION error from them

    * being called within glBegin()/glEnd().

    */

#define COPY_DISPATCH(func) SET_##func(table, GET_##func(ctx->Exec))

   COPY_DISPATCH(GenLists);

   COPY_DISPATCH(IsProgram);

   COPY_DISPATCH(IsVertexArray);

   COPY_DISPATCH(IsBuffer);

   COPY_DISPATCH(IsEnabled);

   COPY_DISPATCH(IsEnabledi);

   COPY_DISPATCH(IsRenderbuffer);

   COPY_DISPATCH(IsFramebuffer);

   COPY_DISPATCH(CheckFramebufferStatus);

   COPY_DISPATCH(RenderMode);

   COPY_DISPATCH(GetString);

   COPY_DISPATCH(GetStringi);

   COPY_DISPATCH(GetPointerv);

   COPY_DISPATCH(IsQuery);

   COPY_DISPATCH(IsSampler);

   COPY_DISPATCH(IsSync);

   COPY_DISPATCH(IsTexture);

   COPY_DISPATCH(IsTransformFeedback);

   COPY_DISPATCH(DeleteQueries);

   COPY_DISPATCH(AreTexturesResident);

   COPY_DISPATCH(FenceSync);

   COPY_DISPATCH(ClientWaitSync);

   COPY_DISPATCH(MapBuffer);

   COPY_DISPATCH(UnmapBuffer);

   COPY_DISPATCH(MapBufferRange);

   COPY_DISPATCH(ObjectPurgeableAPPLE);

   COPY_DISPATCH(ObjectUnpurgeableAPPLE);

   _mesa_loopback_init_api_table(ctx, table);

   return table;

}

void

_mesa_initialize_dispatch_tables(struct gl_context *ctx)

{

   /* Do the code-generated setup of the exec table in api_exec.c. */

   _mesa_initialize_exec_table(ctx);

   if (ctx->Save)

      _mesa_initialize_save_table(ctx);

}

/**

 * Initialize a struct gl_context struct (rendering context).

 *

 * This includes allocating all the other structs and arrays which hang off of

 * the context by pointers.

 * Note that the driver needs to pass in its dd_function_table here since

 * we need to at least call driverFunctions->NewTextureObject to create the

 * default texture objects.

 *

 * Called by _mesa_create_context().

 *