Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * Mesa 3-D graphics library
  3.  *
  4.  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
  5.  * Copyright (C) 2008  VMware, Inc.  All Rights Reserved.
  6.  *
  7.  * Permission is hereby granted, free of charge, to any person obtaining a
  8.  * copy of this software and associated documentation files (the "Software"),
  9.  * to deal in the Software without restriction, including without limitation
  10.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  11.  * and/or sell copies of the Software, and to permit persons to whom the
  12.  * Software is furnished to do so, subject to the following conditions:
  13.  *
  14.  * The above copyright notice and this permission notice shall be included
  15.  * in all copies or substantial portions of the Software.
  16.  *
  17.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  18.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  19.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  20.  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
  21.  * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
  22.  * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
  23.  * OTHER DEALINGS IN THE SOFTWARE.
  24.  */
  25.  
  26. /**
  27.  * \file context.c
  28.  * Mesa context/visual/framebuffer management functions.
  29.  * \author Brian Paul
  30.  */
  31.  
  32. /**
  33.  * \mainpage Mesa Main Module
  34.  *
  35.  * \section MainIntroduction Introduction
  36.  *
  37.  * The Mesa Main module consists of all the files in the main/ directory.
  38.  * Among the features of this module are:
  39.  * <UL>
  40.  * <LI> Structures to represent most GL state </LI>
  41.  * <LI> State set/get functions </LI>
  42.  * <LI> Display lists </LI>
  43.  * <LI> Texture unit, object and image handling </LI>
  44.  * <LI> Matrix and attribute stacks </LI>
  45.  * </UL>
  46.  *
  47.  * Other modules are responsible for API dispatch, vertex transformation,
  48.  * point/line/triangle setup, rasterization, vertex array caching,
  49.  * vertex/fragment programs/shaders, etc.
  50.  *
  51.  *
  52.  * \section AboutDoxygen About Doxygen
  53.  *
  54.  * If you're viewing this information as Doxygen-generated HTML you'll
  55.  * see the documentation index at the top of this page.
  56.  *
  57.  * The first line lists the Mesa source code modules.
  58.  * The second line lists the indexes available for viewing the documentation
  59.  * for each module.
  60.  *
  61.  * Selecting the <b>Main page</b> link will display a summary of the module
  62.  * (this page).
  63.  *
  64.  * Selecting <b>Data Structures</b> will list all C structures.
  65.  *
  66.  * Selecting the <b>File List</b> link will list all the source files in
  67.  * the module.
  68.  * Selecting a filename will show a list of all functions defined in that file.
  69.  *
  70.  * Selecting the <b>Data Fields</b> link will display a list of all
  71.  * documented structure members.
  72.  *
  73.  * Selecting the <b>Globals</b> link will display a list
  74.  * of all functions, structures, global variables and macros in the module.
  75.  *
  76.  */
  77.  
  78.  
  79. #include "glheader.h"
  80. #include "imports.h"
  81. #include "accum.h"
  82. #include "api_exec.h"
  83. #include "api_loopback.h"
  84. #include "arrayobj.h"
  85. #include "attrib.h"
  86. #include "blend.h"
  87. #include "buffers.h"
  88. #include "bufferobj.h"
  89. #include "context.h"
  90. #include "cpuinfo.h"
  91. #include "debug.h"
  92. #include "depth.h"
  93. #include "dlist.h"
  94. #include "eval.h"
  95. #include "extensions.h"
  96. #include "fbobject.h"
  97. #include "feedback.h"
  98. #include "fog.h"
  99. #include "formats.h"
  100. #include "framebuffer.h"
  101. #include "hint.h"
  102. #include "hash.h"
  103. #include "light.h"
  104. #include "lines.h"
  105. #include "macros.h"
  106. #include "matrix.h"
  107. #include "multisample.h"
  108. #include "performance_monitor.h"
  109. #include "pipelineobj.h"
  110. #include "pixel.h"
  111. #include "pixelstore.h"
  112. #include "points.h"
  113. #include "polygon.h"
  114. #include "queryobj.h"
  115. #include "syncobj.h"
  116. #include "rastpos.h"
  117. #include "remap.h"
  118. #include "scissor.h"
  119. #include "shared.h"
  120. #include "shaderobj.h"
  121. #include "shaderimage.h"
  122. #include "util/simple_list.h"
  123. #include "state.h"
  124. #include "stencil.h"
  125. #include "texcompress_s3tc.h"
  126. #include "texstate.h"
  127. #include "transformfeedback.h"
  128. #include "mtypes.h"
  129. #include "varray.h"
  130. #include "version.h"
  131. #include "viewport.h"
  132. #include "vtxfmt.h"
  133. #include "program/program.h"
  134. #include "program/prog_print.h"
  135. #include "math/m_matrix.h"
  136. #include "main/dispatch.h" /* for _gloffset_COUNT */
  137. #include "uniforms.h"
  138. #include "macros.h"
  139.  
  140. #ifdef USE_SPARC_ASM
  141. #include "sparc/sparc.h"
  142. #endif
  143.  
  144. #include "glsl_parser_extras.h"
  145. #include <stdbool.h>
  146.  
  147.  
  148. #ifndef MESA_VERBOSE
  149. int MESA_VERBOSE = 0;
  150. #endif
  151.  
  152. #ifndef MESA_DEBUG_FLAGS
  153. int MESA_DEBUG_FLAGS = 0;
  154. #endif
  155.  
  156.  
  157. /* ubyte -> float conversion */
  158. GLfloat _mesa_ubyte_to_float_color_tab[256];
  159.  
  160.  
  161.  
  162. /**
  163.  * Swap buffers notification callback.
  164.  *
  165.  * \param ctx GL context.
  166.  *
  167.  * Called by window system just before swapping buffers.
  168.  * We have to finish any pending rendering.
  169.  */
  170. void
  171. _mesa_notifySwapBuffers(struct gl_context *ctx)
  172. {
  173.    if (MESA_VERBOSE & VERBOSE_SWAPBUFFERS)
  174.       _mesa_debug(ctx, "SwapBuffers\n");
  175.    FLUSH_CURRENT( ctx, 0 );
  176.    if (ctx->Driver.Flush) {
  177.       ctx->Driver.Flush(ctx);
  178.    }
  179. }
  180.  
  181.  
  182. /**********************************************************************/
  183. /** \name GL Visual allocation/destruction                            */
  184. /**********************************************************************/
  185. /*@{*/
  186.  
  187. /**
  188.  * Allocates a struct gl_config structure and initializes it via
  189.  * _mesa_initialize_visual().
  190.  *
  191.  * \param dbFlag double buffering
  192.  * \param stereoFlag stereo buffer
  193.  * \param depthBits requested bits per depth buffer value. Any value in [0, 32]
  194.  * is acceptable but the actual depth type will be GLushort or GLuint as
  195.  * needed.
  196.  * \param stencilBits requested minimum bits per stencil buffer value
  197.  * \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number
  198.  * of bits per color component in accum buffer.
  199.  * \param indexBits number of bits per pixel if \p rgbFlag is GL_FALSE
  200.  * \param redBits number of bits per color component in frame buffer for RGB(A)
  201.  * mode.  We always use 8 in core Mesa though.
  202.  * \param greenBits same as above.
  203.  * \param blueBits same as above.
  204.  * \param alphaBits same as above.
  205.  * \param numSamples not really used.
  206.  *
  207.  * \return pointer to new struct gl_config or NULL if requested parameters
  208.  * can't be met.
  209.  *
  210.  * \note Need to add params for level and numAuxBuffers (at least)
  211.  */
  212. struct gl_config *
  213. _mesa_create_visual( GLboolean dbFlag,
  214.                      GLboolean stereoFlag,
  215.                      GLint redBits,
  216.                      GLint greenBits,
  217.                      GLint blueBits,
  218.                      GLint alphaBits,
  219.                      GLint depthBits,
  220.                      GLint stencilBits,
  221.                      GLint accumRedBits,
  222.                      GLint accumGreenBits,
  223.                      GLint accumBlueBits,
  224.                      GLint accumAlphaBits,
  225.                      GLint numSamples )
  226. {
  227.    struct gl_config *vis = CALLOC_STRUCT(gl_config);
  228.    if (vis) {
  229.       if (!_mesa_initialize_visual(vis, dbFlag, stereoFlag,
  230.                                    redBits, greenBits, blueBits, alphaBits,
  231.                                    depthBits, stencilBits,
  232.                                    accumRedBits, accumGreenBits,
  233.                                    accumBlueBits, accumAlphaBits,
  234.                                    numSamples)) {
  235.          free(vis);
  236.          return NULL;
  237.       }
  238.    }
  239.    return vis;
  240. }
  241.  
  242.  
  243. /**
  244.  * Makes some sanity checks and fills in the fields of the struct
  245.  * gl_config object with the given parameters.  If the caller needs to
  246.  * set additional fields, he should just probably init the whole
  247.  * gl_config object himself.
  248.  *
  249.  * \return GL_TRUE on success, or GL_FALSE on failure.
  250.  *
  251.  * \sa _mesa_create_visual() above for the parameter description.
  252.  */
  253. GLboolean
  254. _mesa_initialize_visual( struct gl_config *vis,
  255.                          GLboolean dbFlag,
  256.                          GLboolean stereoFlag,
  257.                          GLint redBits,
  258.                          GLint greenBits,
  259.                          GLint blueBits,
  260.                          GLint alphaBits,
  261.                          GLint depthBits,
  262.                          GLint stencilBits,
  263.                          GLint accumRedBits,
  264.                          GLint accumGreenBits,
  265.                          GLint accumBlueBits,
  266.                          GLint accumAlphaBits,
  267.                          GLint numSamples )
  268. {
  269.    assert(vis);
  270.  
  271.    if (depthBits < 0 || depthBits > 32) {
  272.       return GL_FALSE;
  273.    }
  274.    if (stencilBits < 0 || stencilBits > 8) {
  275.       return GL_FALSE;
  276.    }
  277.    assert(accumRedBits >= 0);
  278.    assert(accumGreenBits >= 0);
  279.    assert(accumBlueBits >= 0);
  280.    assert(accumAlphaBits >= 0);
  281.  
  282.    vis->rgbMode          = GL_TRUE;
  283.    vis->doubleBufferMode = dbFlag;
  284.    vis->stereoMode       = stereoFlag;
  285.  
  286.    vis->redBits          = redBits;
  287.    vis->greenBits        = greenBits;
  288.    vis->blueBits         = blueBits;
  289.    vis->alphaBits        = alphaBits;
  290.    vis->rgbBits          = redBits + greenBits + blueBits;
  291.  
  292.    vis->indexBits      = 0;
  293.    vis->depthBits      = depthBits;
  294.    vis->stencilBits    = stencilBits;
  295.  
  296.    vis->accumRedBits   = accumRedBits;
  297.    vis->accumGreenBits = accumGreenBits;
  298.    vis->accumBlueBits  = accumBlueBits;
  299.    vis->accumAlphaBits = accumAlphaBits;
  300.  
  301.    vis->haveAccumBuffer   = accumRedBits > 0;
  302.    vis->haveDepthBuffer   = depthBits > 0;
  303.    vis->haveStencilBuffer = stencilBits > 0;
  304.  
  305.    vis->numAuxBuffers = 0;
  306.    vis->level = 0;
  307.    vis->sampleBuffers = numSamples > 0 ? 1 : 0;
  308.    vis->samples = numSamples;
  309.  
  310.    return GL_TRUE;
  311. }
  312.  
  313.  
  314. /**
  315.  * Destroy a visual and free its memory.
  316.  *
  317.  * \param vis visual.
  318.  *
  319.  * Frees the visual structure.
  320.  */
  321. void
  322. _mesa_destroy_visual( struct gl_config *vis )
  323. {
  324.    free(vis);
  325. }
  326.  
  327. /*@}*/
  328.  
  329.  
  330. /**********************************************************************/
  331. /** \name Context allocation, initialization, destroying
  332.  *
  333.  * The purpose of the most initialization functions here is to provide the
  334.  * default state values according to the OpenGL specification.
  335.  */
  336. /**********************************************************************/
  337. /*@{*/
  338.  
  339.  
  340. /**
  341.  * This is lame.  gdb only seems to recognize enum types that are
  342.  * actually used somewhere.  We want to be able to print/use enum
  343.  * values such as TEXTURE_2D_INDEX in gdb.  But we don't actually use
  344.  * the gl_texture_index type anywhere.  Thus, this lame function.
  345.  */
  346. static void
  347. dummy_enum_func(void)
  348. {
  349.    gl_buffer_index bi = BUFFER_FRONT_LEFT;
  350.    gl_face_index fi = FACE_POS_X;
  351.    gl_frag_result fr = FRAG_RESULT_DEPTH;
  352.    gl_texture_index ti = TEXTURE_2D_ARRAY_INDEX;
  353.    gl_vert_attrib va = VERT_ATTRIB_POS;
  354.    gl_varying_slot vs = VARYING_SLOT_POS;
  355.  
  356.    (void) bi;
  357.    (void) fi;
  358.    (void) fr;
  359.    (void) ti;
  360.    (void) va;
  361.    (void) vs;
  362. }
  363.  
  364.  
  365. /**
  366.  * One-time initialization mutex lock.
  367.  *
  368.  * \sa Used by one_time_init().
  369.  */
  370. mtx_t OneTimeLock = _MTX_INITIALIZER_NP;
  371.  
  372.  
  373.  
  374. /**
  375.  * Calls all the various one-time-init functions in Mesa.
  376.  *
  377.  * While holding a global mutex lock, calls several initialization functions,
  378.  * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is
  379.  * defined.
  380.  *
  381.  * \sa _math_init().
  382.  */
  383. static void
  384. one_time_init( struct gl_context *ctx )
  385. {
  386.    static GLbitfield api_init_mask = 0x0;
  387.  
  388.    mtx_lock(&OneTimeLock);
  389.  
  390.    /* truly one-time init */
  391.    if (!api_init_mask) {
  392.       GLuint i;
  393.  
  394.       /* do some implementation tests */
  395.       assert( sizeof(GLbyte) == 1 );
  396.       assert( sizeof(GLubyte) == 1 );
  397.       assert( sizeof(GLshort) == 2 );
  398.       assert( sizeof(GLushort) == 2 );
  399.       assert( sizeof(GLint) == 4 );
  400.       assert( sizeof(GLuint) == 4 );
  401.  
  402.       _mesa_one_time_init_extension_overrides();
  403.  
  404.       _mesa_get_cpu_features();
  405.  
  406.       for (i = 0; i < 256; i++) {
  407.          _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
  408.       }
  409.  
  410. #if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
  411.       if (MESA_VERBOSE != 0) {
  412.          _mesa_debug(ctx, "Mesa %s DEBUG build %s %s\n",
  413.                      PACKAGE_VERSION, __DATE__, __TIME__);
  414.       }
  415. #endif
  416.  
  417. #ifdef DEBUG
  418.       _mesa_test_formats();
  419. #endif
  420.    }
  421.  
  422.    /* per-API one-time init */
  423.    if (!(api_init_mask & (1 << ctx->API))) {
  424.       _mesa_init_get_hash(ctx);
  425.  
  426.       _mesa_init_remap_table();
  427.    }
  428.  
  429.    api_init_mask |= 1 << ctx->API;
  430.  
  431.    mtx_unlock(&OneTimeLock);
  432.  
  433.    /* Hopefully atexit() is widely available.  If not, we may need some
  434.     * #ifdef tests here.
  435.     */
  436.    atexit(_mesa_destroy_shader_compiler);
  437.  
  438.    dummy_enum_func();
  439. }
  440.  
  441.  
  442. /**
  443.  * Initialize fields of gl_current_attrib (aka ctx->Current.*)
  444.  */
  445. static void
  446. _mesa_init_current(struct gl_context *ctx)
  447. {
  448.    GLuint i;
  449.  
  450.    /* Init all to (0,0,0,1) */
  451.    for (i = 0; i < ARRAY_SIZE(ctx->Current.Attrib); i++) {
  452.       ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );
  453.    }
  454.  
  455.    /* redo special cases: */
  456.    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 0.0 );
  457.    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );
  458.    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
  459.    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );
  460.    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 );
  461.    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 );
  462. }
  463.  
  464.  
  465. /**
  466.  * Init vertex/fragment/geometry program limits.
  467.  * Important: drivers should override these with actual limits.
  468.  */
  469. static void
  470. init_program_limits(struct gl_constants *consts, gl_shader_stage stage,
  471.                     struct gl_program_constants *prog)
  472. {
  473.    prog->MaxInstructions = MAX_PROGRAM_INSTRUCTIONS;
  474.    prog->MaxAluInstructions = MAX_PROGRAM_INSTRUCTIONS;
  475.    prog->MaxTexInstructions = MAX_PROGRAM_INSTRUCTIONS;
  476.    prog->MaxTexIndirections = MAX_PROGRAM_INSTRUCTIONS;
  477.    prog->MaxTemps = MAX_PROGRAM_TEMPS;
  478.    prog->MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
  479.    prog->MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
  480.    prog->MaxAddressOffset = MAX_PROGRAM_LOCAL_PARAMS;
  481.  
  482.    switch (stage) {
  483.    case MESA_SHADER_VERTEX:
  484.       prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;
  485.       prog->MaxAttribs = MAX_VERTEX_GENERIC_ATTRIBS;
  486.       prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
  487.       prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
  488.       prog->MaxInputComponents = 0; /* value not used */
  489.       prog->MaxOutputComponents = 16 * 4; /* old limit not to break tnl and swrast */
  490.       break;
  491.    case MESA_SHADER_FRAGMENT:
  492.       prog->MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
  493.       prog->MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;
  494.       prog->MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
  495.       prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
  496.       prog->MaxInputComponents = 16 * 4; /* old limit not to break tnl and swrast */
  497.       prog->MaxOutputComponents = 0; /* value not used */
  498.       break;
  499.    case MESA_SHADER_GEOMETRY:
  500.       prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;
  501.       prog->MaxAttribs = MAX_VERTEX_GENERIC_ATTRIBS;
  502.       prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
  503.       prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
  504.       prog->MaxInputComponents = 16 * 4; /* old limit not to break tnl and swrast */
  505.       prog->MaxOutputComponents = 16 * 4; /* old limit not to break tnl and swrast */
  506.       break;
  507.    case MESA_SHADER_COMPUTE:
  508.       prog->MaxParameters = 0; /* not meaningful for compute shaders */
  509.       prog->MaxAttribs = 0; /* not meaningful for compute shaders */
  510.       prog->MaxAddressRegs = 0; /* not meaningful for compute shaders */
  511.       prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
  512.       prog->MaxInputComponents = 0; /* not meaningful for compute shaders */
  513.       prog->MaxOutputComponents = 0; /* not meaningful for compute shaders */
  514.       break;
  515.    default:
  516.       assert(0 && "Bad shader stage in init_program_limits()");
  517.    }
  518.  
  519.    /* Set the native limits to zero.  This implies that there is no native
  520.     * support for shaders.  Let the drivers fill in the actual values.
  521.     */
  522.    prog->MaxNativeInstructions = 0;
  523.    prog->MaxNativeAluInstructions = 0;
  524.    prog->MaxNativeTexInstructions = 0;
  525.    prog->MaxNativeTexIndirections = 0;
  526.    prog->MaxNativeAttribs = 0;
  527.    prog->MaxNativeTemps = 0;
  528.    prog->MaxNativeAddressRegs = 0;
  529.    prog->MaxNativeParameters = 0;
  530.  
  531.    /* Set GLSL datatype range/precision info assuming IEEE float values.
  532.     * Drivers should override these defaults as needed.
  533.     */
  534.    prog->MediumFloat.RangeMin = 127;
  535.    prog->MediumFloat.RangeMax = 127;
  536.    prog->MediumFloat.Precision = 23;
  537.    prog->LowFloat = prog->HighFloat = prog->MediumFloat;
  538.  
  539.    /* Assume ints are stored as floats for now, since this is the least-common
  540.     * denominator.  The OpenGL ES spec implies (page 132) that the precision
  541.     * of integer types should be 0.  Practically speaking, IEEE
  542.     * single-precision floating point values can only store integers in the
  543.     * range [-0x01000000, 0x01000000] without loss of precision.
  544.     */
  545.    prog->MediumInt.RangeMin = 24;
  546.    prog->MediumInt.RangeMax = 24;
  547.    prog->MediumInt.Precision = 0;
  548.    prog->LowInt = prog->HighInt = prog->MediumInt;
  549.  
  550.    prog->MaxUniformBlocks = 12;
  551.    prog->MaxCombinedUniformComponents = (prog->MaxUniformComponents +
  552.                                          consts->MaxUniformBlockSize / 4 *
  553.                                          prog->MaxUniformBlocks);
  554.  
  555.    prog->MaxAtomicBuffers = 0;
  556.    prog->MaxAtomicCounters = 0;
  557. }
  558.  
  559.  
  560. /**
  561.  * Initialize fields of gl_constants (aka ctx->Const.*).
  562.  * Use defaults from config.h.  The device drivers will often override
  563.  * some of these values (such as number of texture units).
  564.  */
  565. void
  566. _mesa_init_constants(struct gl_constants *consts, gl_api api)
  567. {
  568.    int i;
  569.    assert(consts);
  570.  
  571.    /* Constants, may be overriden (usually only reduced) by device drivers */
  572.    consts->MaxTextureMbytes = MAX_TEXTURE_MBYTES;
  573.    consts->MaxTextureLevels = MAX_TEXTURE_LEVELS;
  574.    consts->Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
  575.    consts->MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
  576.    consts->MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
  577.    consts->MaxArrayTextureLayers = MAX_ARRAY_TEXTURE_LAYERS;
  578.    consts->MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;
  579.    consts->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
  580.    consts->MaxTextureUnits = MIN2(consts->MaxTextureCoordUnits,
  581.                                      consts->Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits);
  582.    consts->MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
  583.    consts->MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
  584.    consts->MaxTextureBufferSize = 65536;
  585.    consts->TextureBufferOffsetAlignment = 1;
  586.    consts->MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
  587.    consts->SubPixelBits = SUB_PIXEL_BITS;
  588.    consts->MinPointSize = MIN_POINT_SIZE;
  589.    consts->MaxPointSize = MAX_POINT_SIZE;
  590.    consts->MinPointSizeAA = MIN_POINT_SIZE;
  591.    consts->MaxPointSizeAA = MAX_POINT_SIZE;
  592.    consts->PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
  593.    consts->MinLineWidth = MIN_LINE_WIDTH;
  594.    consts->MaxLineWidth = MAX_LINE_WIDTH;
  595.    consts->MinLineWidthAA = MIN_LINE_WIDTH;
  596.    consts->MaxLineWidthAA = MAX_LINE_WIDTH;
  597.    consts->LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
  598.    consts->MaxClipPlanes = 6;
  599.    consts->MaxLights = MAX_LIGHTS;
  600.    consts->MaxShininess = 128.0;
  601.    consts->MaxSpotExponent = 128.0;
  602.    consts->MaxViewportWidth = MAX_VIEWPORT_WIDTH;
  603.    consts->MaxViewportHeight = MAX_VIEWPORT_HEIGHT;
  604.    consts->MinMapBufferAlignment = 64;
  605.  
  606.    /* Driver must override these values if ARB_viewport_array is supported. */
  607.    consts->MaxViewports = 1;
  608.    consts->ViewportSubpixelBits = 0;
  609.    consts->ViewportBounds.Min = 0;
  610.    consts->ViewportBounds.Max = 0;
  611.  
  612.    /** GL_ARB_uniform_buffer_object */
  613.    consts->MaxCombinedUniformBlocks = 36;
  614.    consts->MaxUniformBufferBindings = 36;
  615.    consts->MaxUniformBlockSize = 16384;
  616.    consts->UniformBufferOffsetAlignment = 1;
  617.  
  618.    /* GL_ARB_explicit_uniform_location, GL_MAX_UNIFORM_LOCATIONS */
  619.    consts->MaxUserAssignableUniformLocations =
  620.       4 * MESA_SHADER_STAGES * MAX_UNIFORMS;
  621.  
  622.    for (i = 0; i < MESA_SHADER_STAGES; i++)
  623.       init_program_limits(consts, i, &consts->Program[i]);
  624.  
  625.    consts->MaxProgramMatrices = MAX_PROGRAM_MATRICES;
  626.    consts->MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
  627.  
  628.    /* Assume that if GLSL 1.30+ (or GLSL ES 3.00+) is supported that
  629.     * gl_VertexID is implemented using a native hardware register with OpenGL
  630.     * semantics.
  631.     */
  632.    consts->VertexID_is_zero_based = false;
  633.  
  634.    /* GL_ARB_draw_buffers */
  635.    consts->MaxDrawBuffers = MAX_DRAW_BUFFERS;
  636.  
  637.    consts->MaxColorAttachments = MAX_COLOR_ATTACHMENTS;
  638.    consts->MaxRenderbufferSize = MAX_RENDERBUFFER_SIZE;
  639.  
  640.    consts->Program[MESA_SHADER_VERTEX].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
  641.    consts->MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
  642.    consts->MaxVarying = 16; /* old limit not to break tnl and swrast */
  643.    consts->Program[MESA_SHADER_GEOMETRY].MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
  644.    consts->MaxGeometryOutputVertices = MAX_GEOMETRY_OUTPUT_VERTICES;
  645.    consts->MaxGeometryTotalOutputComponents = MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS;
  646.  
  647.    /* Shading language version */
  648.    consts->GLSLVersion = 120;
  649.    _mesa_override_glsl_version(consts);
  650.  
  651. #ifdef DEBUG
  652.    consts->GenerateTemporaryNames = true;
  653. #else
  654.    consts->GenerateTemporaryNames = false;
  655. #endif
  656.  
  657.    /* GL_ARB_framebuffer_object */
  658.    consts->MaxSamples = 0;
  659.  
  660.    /* GLSL default if NativeIntegers == FALSE */
  661.    consts->UniformBooleanTrue = FLOAT_AS_UNION(1.0f).u;
  662.  
  663.    /* GL_ARB_sync */
  664.    consts->MaxServerWaitTimeout = 0x1fff7fffffffULL;
  665.  
  666.    /* GL_EXT_provoking_vertex */
  667.    consts->QuadsFollowProvokingVertexConvention = GL_TRUE;
  668.  
  669.    /* GL_EXT_transform_feedback */
  670.    consts->MaxTransformFeedbackBuffers = MAX_FEEDBACK_BUFFERS;
  671.    consts->MaxTransformFeedbackSeparateComponents = 4 * MAX_FEEDBACK_ATTRIBS;
  672.    consts->MaxTransformFeedbackInterleavedComponents = 4 * MAX_FEEDBACK_ATTRIBS;
  673.    consts->MaxVertexStreams = 1;
  674.  
  675.    /* GL 3.2  */
  676.    consts->ProfileMask = api == API_OPENGL_CORE
  677.                           ? GL_CONTEXT_CORE_PROFILE_BIT
  678.                           : GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;
  679.  
  680.    /* GL 4.4 */
  681.    consts->MaxVertexAttribStride = 2048;
  682.  
  683.    /** GL_EXT_gpu_shader4 */
  684.    consts->MinProgramTexelOffset = -8;
  685.    consts->MaxProgramTexelOffset = 7;
  686.  
  687.    /* GL_ARB_texture_gather */
  688.    consts->MinProgramTextureGatherOffset = -8;
  689.    consts->MaxProgramTextureGatherOffset = 7;
  690.  
  691.    /* GL_ARB_robustness */
  692.    consts->ResetStrategy = GL_NO_RESET_NOTIFICATION_ARB;
  693.  
  694.    /* ES 3.0 or ARB_ES3_compatibility */
  695.    consts->MaxElementIndex = 0xffffffffu;
  696.  
  697.    /* GL_ARB_texture_multisample */
  698.    consts->MaxColorTextureSamples = 1;
  699.    consts->MaxDepthTextureSamples = 1;
  700.    consts->MaxIntegerSamples = 1;
  701.  
  702.    /* GL_ARB_shader_atomic_counters */
  703.    consts->MaxAtomicBufferBindings = MAX_COMBINED_ATOMIC_BUFFERS;
  704.    consts->MaxAtomicBufferSize = MAX_ATOMIC_COUNTERS * ATOMIC_COUNTER_SIZE;
  705.    consts->MaxCombinedAtomicBuffers = MAX_COMBINED_ATOMIC_BUFFERS;
  706.    consts->MaxCombinedAtomicCounters = MAX_ATOMIC_COUNTERS;
  707.  
  708.    /* GL_ARB_vertex_attrib_binding */
  709.    consts->MaxVertexAttribRelativeOffset = 2047;
  710.    consts->MaxVertexAttribBindings = MAX_VERTEX_GENERIC_ATTRIBS;
  711.  
  712.    /* GL_ARB_compute_shader */
  713.    consts->MaxComputeWorkGroupCount[0] = 65535;
  714.    consts->MaxComputeWorkGroupCount[1] = 65535;
  715.    consts->MaxComputeWorkGroupCount[2] = 65535;
  716.    consts->MaxComputeWorkGroupSize[0] = 1024;
  717.    consts->MaxComputeWorkGroupSize[1] = 1024;
  718.    consts->MaxComputeWorkGroupSize[2] = 64;
  719.    consts->MaxComputeWorkGroupInvocations = 1024;
  720.  
  721.    /** GL_ARB_gpu_shader5 */
  722.    consts->MinFragmentInterpolationOffset = MIN_FRAGMENT_INTERPOLATION_OFFSET;
  723.    consts->MaxFragmentInterpolationOffset = MAX_FRAGMENT_INTERPOLATION_OFFSET;
  724.  
  725.    /** GL_KHR_context_flush_control */
  726.    consts->ContextReleaseBehavior = GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH;
  727. }
  728.  
  729.  
  730. /**
  731.  * Do some sanity checks on the limits/constants for the given context.
  732.  * Only called the first time a context is bound.
  733.  */
  734. static void
  735. check_context_limits(struct gl_context *ctx)
  736. {
  737.    (void) ctx;
  738.  
  739.    /* check that we don't exceed the size of various bitfields */
  740.    assert(VARYING_SLOT_MAX <=
  741.           (8 * sizeof(ctx->VertexProgram._Current->Base.OutputsWritten)));
  742.    assert(VARYING_SLOT_MAX <=
  743.           (8 * sizeof(ctx->FragmentProgram._Current->Base.InputsRead)));
  744.  
  745.    /* shader-related checks */
  746.    assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
  747.    assert(ctx->Const.Program[MESA_SHADER_VERTEX].MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
  748.  
  749.    /* Texture unit checks */
  750.    assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits > 0);
  751.    assert(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS);
  752.    assert(ctx->Const.MaxTextureCoordUnits > 0);
  753.    assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS);
  754.    assert(ctx->Const.MaxTextureUnits > 0);
  755.    assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS);
  756.    assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS);
  757.    assert(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits,
  758.                                              ctx->Const.MaxTextureCoordUnits));
  759.    assert(ctx->Const.MaxCombinedTextureImageUnits > 0);
  760.    assert(ctx->Const.MaxCombinedTextureImageUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
  761.    assert(ctx->Const.MaxTextureCoordUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
  762.    /* number of coord units cannot be greater than number of image units */
  763.    assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.Program[MESA_SHADER_FRAGMENT].MaxTextureImageUnits);
  764.  
  765.  
  766.    /* Texture size checks */
  767.    assert(ctx->Const.MaxTextureLevels <= MAX_TEXTURE_LEVELS);
  768.    assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS);
  769.    assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS);
  770.    assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE);
  771.  
  772.    /* Texture level checks */
  773.    assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
  774.    assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
  775.  
  776.    /* Max texture size should be <= max viewport size (render to texture) */
  777.    assert((1U << (ctx->Const.MaxTextureLevels - 1))
  778.           <= ctx->Const.MaxViewportWidth);
  779.    assert((1U << (ctx->Const.MaxTextureLevels - 1))
  780.           <= ctx->Const.MaxViewportHeight);
  781.  
  782.    assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);
  783.  
  784.    /* if this fails, add more enum values to gl_buffer_index */
  785.    assert(BUFFER_COLOR0 + MAX_DRAW_BUFFERS <= BUFFER_COUNT);
  786.  
  787.    /* XXX probably add more tests */
  788. }
  789.  
  790.  
  791. /**
  792.  * Initialize the attribute groups in a GL context.
  793.  *
  794.  * \param ctx GL context.
  795.  *
  796.  * Initializes all the attributes, calling the respective <tt>init*</tt>
  797.  * functions for the more complex data structures.
  798.  */
  799. static GLboolean
  800. init_attrib_groups(struct gl_context *ctx)
  801. {
  802.    assert(ctx);
  803.  
  804.    /* Constants */
  805.    _mesa_init_constants(&ctx->Const, ctx->API);
  806.  
  807.    /* Extensions */
  808.    _mesa_init_extensions(&ctx->Extensions);
  809.  
  810.    /* Attribute Groups */
  811.    _mesa_init_accum( ctx );
  812.    _mesa_init_attrib( ctx );
  813.    _mesa_init_buffer_objects( ctx );
  814.    _mesa_init_color( ctx );
  815.    _mesa_init_current( ctx );
  816.    _mesa_init_depth( ctx );
  817.    _mesa_init_debug( ctx );
  818.    _mesa_init_display_list( ctx );
  819.    _mesa_init_errors( ctx );
  820.    _mesa_init_eval( ctx );
  821.    _mesa_init_fbobjects( ctx );
  822.    _mesa_init_feedback( ctx );
  823.    _mesa_init_fog( ctx );
  824.    _mesa_init_hint( ctx );
  825.    _mesa_init_image_units( ctx );
  826.    _mesa_init_line( ctx );
  827.    _mesa_init_lighting( ctx );
  828.    _mesa_init_matrix( ctx );
  829.    _mesa_init_multisample( ctx );
  830.    _mesa_init_performance_monitors( ctx );
  831.    _mesa_init_pipeline( ctx );
  832.    _mesa_init_pixel( ctx );
  833.    _mesa_init_pixelstore( ctx );
  834.    _mesa_init_point( ctx );
  835.    _mesa_init_polygon( ctx );
  836.    _mesa_init_program( ctx );
  837.    _mesa_init_queryobj( ctx );
  838.    _mesa_init_sync( ctx );
  839.    _mesa_init_rastpos( ctx );
  840.    _mesa_init_scissor( ctx );
  841.    _mesa_init_shader_state( ctx );
  842.    _mesa_init_stencil( ctx );
  843.    _mesa_init_transform( ctx );
  844.    _mesa_init_transform_feedback( ctx );
  845.    _mesa_init_varray( ctx );
  846.    _mesa_init_viewport( ctx );
  847.  
  848.    if (!_mesa_init_texture( ctx ))
  849.       return GL_FALSE;
  850.  
  851.    _mesa_init_texture_s3tc( ctx );
  852.  
  853.    /* Miscellaneous */
  854.    ctx->NewState = _NEW_ALL;
  855.    ctx->NewDriverState = ~0;
  856.    ctx->ErrorValue = GL_NO_ERROR;
  857.    ctx->ShareGroupReset = false;
  858.    ctx->varying_vp_inputs = VERT_BIT_ALL;
  859.  
  860.    return GL_TRUE;
  861. }
  862.  
  863.  
  864. /**
  865.  * Update default objects in a GL context with respect to shared state.
  866.  *
  867.  * \param ctx GL context.
  868.  *
  869.  * Removes references to old default objects, (texture objects, program
  870.  * objects, etc.) and changes to reference those from the current shared
  871.  * state.
  872.  */
  873. static GLboolean
  874. update_default_objects(struct gl_context *ctx)
  875. {
  876.    assert(ctx);
  877.  
  878.    _mesa_update_default_objects_program(ctx);
  879.    _mesa_update_default_objects_texture(ctx);
  880.    _mesa_update_default_objects_buffer_objects(ctx);
  881.  
  882.    return GL_TRUE;
  883. }
  884.  
  885.  
  886. /* XXX this is temporary and should be removed at some point in the
  887.  * future when there's a reasonable expectation that the libGL library
  888.  * contains the _glapi_new_nop_table() and _glapi_set_nop_handler()
  889.  * functions which were added in Mesa 10.6.
  890.  */
  891. #if !defined(_WIN32)
  892. /* Avoid libGL / driver ABI break */
  893. #define USE_GLAPI_NOP_FEATURES 0
  894. #else
  895. #define USE_GLAPI_NOP_FEATURES 1
  896. #endif
  897.  
  898.  
  899. /**
  900.  * This function is called by the glapi no-op functions.  For each OpenGL
  901.  * function/entrypoint there's a simple no-op function.  These "no-op"
  902.  * functions call this function.
  903.  *
  904.  * If there's a current OpenGL context for the calling thread, we record a
  905.  * GL_INVALID_OPERATION error.  This can happen either because the app's
  906.  * calling an unsupported extension function, or calling an illegal function
  907.  * (such as glClear between glBegin/glEnd).
  908.  *
  909.  * If there's no current OpenGL context for the calling thread, we can
  910.  * print a message to stderr.
  911.  *
  912.  * \param name  the name of the OpenGL function
  913.  */
  914. #if USE_GLAPI_NOP_FEATURES
  915. static void
  916. nop_handler(const char *name)
  917. {
  918.    GET_CURRENT_CONTEXT(ctx);
  919.    if (ctx) {
  920.       _mesa_error(ctx, GL_INVALID_OPERATION, "%s(invalid call)", name);
  921.    }
  922. #if defined(DEBUG)
  923.    else if (getenv("MESA_DEBUG") || getenv("LIBGL_DEBUG")) {
  924.       fprintf(stderr,
  925.               "GL User Error: gl%s called without a rendering context\n",
  926.               name);
  927.       fflush(stderr);
  928.    }
  929. #endif
  930. }
  931. #endif
  932.  
  933.  
  934. /**
  935.  * Special no-op glFlush, see below.
  936.  */
  937. #if defined(_WIN32)
  938. static void GLAPIENTRY
  939. nop_glFlush(void)
  940. {
  941.    /* don't record an error like we do in nop_handler() */
  942. }
  943. #endif
  944.  
  945.  
  946. #if !USE_GLAPI_NOP_FEATURES
  947. static int
  948. generic_nop(void)
  949. {
  950.    GET_CURRENT_CONTEXT(ctx);
  951.    _mesa_error(ctx, GL_INVALID_OPERATION,
  952.                "unsupported function called "
  953.                "(unsupported extension or deprecated function?)");
  954.    return 0;
  955. }
  956. #endif
  957.  
  958.  
  959. /**
  960.  * Create a new API dispatch table in which all entries point to the
  961.  * generic_nop() function.  This will not work on Windows because of
  962.  * the __stdcall convention which requires the callee to clean up the
  963.  * call stack.  That's impossible with one generic no-op function.
  964.  */
  965. struct _glapi_table *
  966. _mesa_new_nop_table(unsigned numEntries)
  967. {
  968.    struct _glapi_table *table;
  969.  
  970. #if !USE_GLAPI_NOP_FEATURES
  971.    table = malloc(numEntries * sizeof(_glapi_proc));
  972.    if (table) {
  973.       _glapi_proc *entry = (_glapi_proc *) table;
  974.       unsigned i;
  975.       for (i = 0; i < numEntries; i++) {
  976.          entry[i] = (_glapi_proc) generic_nop;
  977.       }
  978.    }
  979. #else
  980.    table = _glapi_new_nop_table(numEntries);
  981. #endif
  982.    return table;
  983. }
  984.  
  985.  
  986. /**
  987.  * Allocate and initialize a new dispatch table.  The table will be
  988.  * populated with pointers to "no-op" functions.  In turn, the no-op
  989.  * functions will call nop_handler() above.
  990.  */
  991. static struct _glapi_table *
  992. alloc_dispatch_table(void)
  993. {
  994.    /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
  995.     * In practice, this'll be the same for stand-alone Mesa.  But for DRI
  996.     * Mesa we do this to accommodate different versions of libGL and various
  997.     * DRI drivers.
  998.     */
  999.    int numEntries = MAX2(_glapi_get_dispatch_table_size(), _gloffset_COUNT);
  1000.  
  1001.    struct _glapi_table *table = _mesa_new_nop_table(numEntries);
  1002.  
  1003. #if defined(_WIN32)
  1004.    if (table) {
  1005.       /* This is a special case for Windows in the event that
  1006.        * wglGetProcAddress is called between glBegin/End().
  1007.        *
  1008.        * The MS opengl32.dll library apparently calls glFlush from
  1009.        * wglGetProcAddress().  If we're inside glBegin/End(), glFlush
  1010.        * will dispatch to _mesa_generic_nop() and we'll generate a
  1011.        * GL_INVALID_OPERATION error.
  1012.        *
  1013.        * The specific case which hits this is piglit's primitive-restart
  1014.        * test which calls glPrimitiveRestartNV() inside glBegin/End.  The
  1015.        * first time we call glPrimitiveRestartNV() Piglit's API dispatch
  1016.        * code will try to resolve the function by calling wglGetProcAddress.
  1017.        * This raises GL_INVALID_OPERATION and an assert(glGetError()==0)
  1018.        * will fail causing the test to fail.  By suppressing the error, the
  1019.        * assertion passes and the test continues.
  1020.        */
  1021.       SET_Flush(table, nop_glFlush);
  1022.    }
  1023. #endif
  1024.  
  1025. #if USE_GLAPI_NOP_FEATURES
  1026.    _glapi_set_nop_handler(nop_handler);
  1027. #endif
  1028.  
  1029.    return table;
  1030. }
  1031.  
  1032. /**
  1033.  * Creates a minimal dispatch table for use within glBegin()/glEnd().
  1034.  *
  1035.  * This ensures that we generate GL_INVALID_OPERATION errors from most
  1036.  * functions, since the set of functions that are valid within Begin/End is
  1037.  * very small.
  1038.  *
  1039.  * From the GL 1.0 specification section 2.6.3, "GL Commands within
  1040.  * Begin/End"
  1041.  *
  1042.  *     "The only GL commands that are allowed within any Begin/End pairs are
  1043.  *      the commands for specifying vertex coordinates, vertex color, normal
  1044.  *      coordinates, and texture coordinates (Vertex, Color, Index, Normal,
  1045.  *      TexCoord), EvalCoord and EvalPoint commands (see section 5.1),
  1046.  *      commands for specifying lighting material parameters (Material
  1047.  *      commands see section 2.12.2), display list invocation commands
  1048.  *      (CallList and CallLists see section 5.4), and the EdgeFlag
  1049.  *      command. Executing Begin after Begin has already been executed but
  1050.  *      before an End is issued generates the INVALID OPERATION error, as does
  1051.  *      executing End without a previous corresponding Begin. Executing any
  1052.  *      other GL command within Begin/End results in the error INVALID
  1053.  *      OPERATION."
  1054.  *
  1055.  * The table entries for specifying vertex attributes are set up by
  1056.  * install_vtxfmt() and _mesa_loopback_init_api_table(), and End() and dlists
  1057.  * are set by install_vtxfmt() as well.
  1058.  */
  1059. static struct _glapi_table *
  1060. create_beginend_table(const struct gl_context *ctx)
  1061. {
  1062.    struct _glapi_table *table;
  1063.  
  1064.    table = alloc_dispatch_table();
  1065.    if (!table)
  1066.       return NULL;
  1067.  
  1068.    /* Fill in functions which return a value, since they should return some
  1069.     * specific value even if they emit a GL_INVALID_OPERATION error from them
  1070.     * being called within glBegin()/glEnd().
  1071.     */
  1072. #define COPY_DISPATCH(func) SET_##func(table, GET_##func(ctx->Exec))
  1073.  
  1074.    COPY_DISPATCH(GenLists);
  1075.    COPY_DISPATCH(IsProgram);
  1076.    COPY_DISPATCH(IsVertexArray);
  1077.    COPY_DISPATCH(IsBuffer);
  1078.    COPY_DISPATCH(IsEnabled);
  1079.    COPY_DISPATCH(IsEnabledi);
  1080.    COPY_DISPATCH(IsRenderbuffer);
  1081.    COPY_DISPATCH(IsFramebuffer);
  1082.    COPY_DISPATCH(CheckFramebufferStatus);
  1083.    COPY_DISPATCH(RenderMode);
  1084.    COPY_DISPATCH(GetString);
  1085.    COPY_DISPATCH(GetStringi);
  1086.    COPY_DISPATCH(GetPointerv);
  1087.    COPY_DISPATCH(IsQuery);
  1088.    COPY_DISPATCH(IsSampler);
  1089.    COPY_DISPATCH(IsSync);
  1090.    COPY_DISPATCH(IsTexture);
  1091.    COPY_DISPATCH(IsTransformFeedback);
  1092.    COPY_DISPATCH(DeleteQueries);
  1093.    COPY_DISPATCH(AreTexturesResident);
  1094.    COPY_DISPATCH(FenceSync);
  1095.    COPY_DISPATCH(ClientWaitSync);
  1096.    COPY_DISPATCH(MapBuffer);
  1097.    COPY_DISPATCH(UnmapBuffer);
  1098.    COPY_DISPATCH(MapBufferRange);
  1099.    COPY_DISPATCH(ObjectPurgeableAPPLE);
  1100.    COPY_DISPATCH(ObjectUnpurgeableAPPLE);
  1101.  
  1102.    _mesa_loopback_init_api_table(ctx, table);
  1103.  
  1104.    return table;
  1105. }
  1106.  
  1107. void
  1108. _mesa_initialize_dispatch_tables(struct gl_context *ctx)
  1109. {
  1110.    /* Do the code-generated setup of the exec table in api_exec.c. */
  1111.    _mesa_initialize_exec_table(ctx);
  1112.  
  1113.    if (ctx->Save)
  1114.       _mesa_initialize_save_table(ctx);
  1115. }
  1116.  
  1117. /**
  1118.  * Initialize a struct gl_context struct (rendering context).
  1119.  *
  1120.  * This includes allocating all the other structs and arrays which hang off of
  1121.  * the context by pointers.
  1122.  * Note that the driver needs to pass in its dd_function_table here since
  1123.  * we need to at least call driverFunctions->NewTextureObject to create the
  1124.  * default texture objects.
  1125.  *
  1126.  * Called by _mesa_create_context().
  1127.  *
  1128.  * Performs the imports and exports callback tables initialization, and
  1129.  * miscellaneous one-time initializations. If no shared context is supplied one
  1130.  * is allocated, and increase its reference count.  Setups the GL API dispatch
  1131.  * tables.  Initialize the TNL module. Sets the maximum Z buffer depth.
  1132.  * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
  1133.  * for debug flags.
  1134.  *
  1135.  * \param ctx the context to initialize
  1136.  * \param api the GL API type to create the context for
  1137.  * \param visual describes the visual attributes for this context or NULL to
  1138.  *               create a configless context
  1139.  * \param share_list points to context to share textures, display lists,
  1140.  *        etc with, or NULL
  1141.  * \param driverFunctions table of device driver functions for this context
  1142.  *        to use
  1143.  */
  1144. GLboolean
  1145. _mesa_initialize_context(struct gl_context *ctx,
  1146.                          gl_api api,
  1147.                          const struct gl_config *visual,
  1148.                          struct gl_context *share_list,
  1149.                          const struct dd_function_table *driverFunctions)
  1150. {
  1151.    struct gl_shared_state *shared;
  1152.    int i;
  1153.  
  1154.    assert(driverFunctions->NewTextureObject);
  1155.    assert(driverFunctions->FreeTextureImageBuffer);
  1156.  
  1157.    ctx->API = api;
  1158.    ctx->DrawBuffer = NULL;
  1159.    ctx->ReadBuffer = NULL;
  1160.    ctx->WinSysDrawBuffer = NULL;
  1161.    ctx->WinSysReadBuffer = NULL;
  1162.  
  1163.    if (visual) {
  1164.       ctx->Visual = *visual;
  1165.       ctx->HasConfig = GL_TRUE;
  1166.    }
  1167.    else {
  1168.       memset(&ctx->Visual, 0, sizeof ctx->Visual);
  1169.       ctx->HasConfig = GL_FALSE;
  1170.    }
  1171.  
  1172.    if (_mesa_is_desktop_gl(ctx)) {
  1173.       _mesa_override_gl_version(ctx);
  1174.    }
  1175.  
  1176.    /* misc one-time initializations */
  1177.    one_time_init(ctx);
  1178.  
  1179.    /* Plug in driver functions and context pointer here.
  1180.     * This is important because when we call alloc_shared_state() below
  1181.     * we'll call ctx->Driver.NewTextureObject() to create the default
  1182.     * textures.
  1183.     */
  1184.    ctx->Driver = *driverFunctions;
  1185.  
  1186.    if (share_list) {
  1187.       /* share state with another context */
  1188.       shared = share_list->Shared;
  1189.    }
  1190.    else {
  1191.       /* allocate new, unshared state */
  1192.       shared = _mesa_alloc_shared_state(ctx);
  1193.       if (!shared)
  1194.          return GL_FALSE;
  1195.    }
  1196.  
  1197.    _mesa_reference_shared_state(ctx, &ctx->Shared, shared);
  1198.  
  1199.    if (!init_attrib_groups( ctx ))
  1200.       goto fail;
  1201.  
  1202.    /* setup the API dispatch tables with all nop functions */
  1203.    ctx->OutsideBeginEnd = alloc_dispatch_table();
  1204.    if (!ctx->OutsideBeginEnd)
  1205.       goto fail;
  1206.    ctx->Exec = ctx->OutsideBeginEnd;
  1207.    ctx->CurrentDispatch = ctx->OutsideBeginEnd;
  1208.  
  1209.    ctx->FragmentProgram._MaintainTexEnvProgram
  1210.       = (getenv("MESA_TEX_PROG") != NULL);
  1211.  
  1212.    ctx->VertexProgram._MaintainTnlProgram
  1213.       = (getenv("MESA_TNL_PROG") != NULL);
  1214.    if (ctx->VertexProgram._MaintainTnlProgram) {
  1215.       /* this is required... */
  1216.       ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
  1217.    }
  1218.  
  1219.    /* Mesa core handles all the formats that mesa core knows about.
  1220.     * Drivers will want to override this list with just the formats
  1221.     * they can handle, and confirm that appropriate fallbacks exist in
  1222.     * _mesa_choose_tex_format().
  1223.     */
  1224.    memset(&ctx->TextureFormatSupported, GL_TRUE,
  1225.           sizeof(ctx->TextureFormatSupported));
  1226.  
  1227.    switch (ctx->API) {
  1228.    case API_OPENGL_COMPAT:
  1229.       ctx->BeginEnd = create_beginend_table(ctx);
  1230.       ctx->Save = alloc_dispatch_table();
  1231.       if (!ctx->BeginEnd || !ctx->Save)
  1232.          goto fail;
  1233.  
  1234.       /* fall-through */
  1235.    case API_OPENGL_CORE:
  1236.       break;
  1237.    case API_OPENGLES:
  1238.       /**
  1239.        * GL_OES_texture_cube_map says
  1240.        * "Initially all texture generation modes are set to REFLECTION_MAP_OES"
  1241.        */
  1242.       for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
  1243.          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
  1244.          texUnit->GenS.Mode = GL_REFLECTION_MAP_NV;
  1245.          texUnit->GenT.Mode = GL_REFLECTION_MAP_NV;
  1246.          texUnit->GenR.Mode = GL_REFLECTION_MAP_NV;
  1247.          texUnit->GenS._ModeBit = TEXGEN_REFLECTION_MAP_NV;
  1248.          texUnit->GenT._ModeBit = TEXGEN_REFLECTION_MAP_NV;
  1249.          texUnit->GenR._ModeBit = TEXGEN_REFLECTION_MAP_NV;
  1250.       }
  1251.       break;
  1252.    case API_OPENGLES2:
  1253.       ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
  1254.       ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
  1255.       break;
  1256.    }
  1257.  
  1258.    ctx->FirstTimeCurrent = GL_TRUE;
  1259.  
  1260.    return GL_TRUE;
  1261.  
  1262. fail:
  1263.    _mesa_reference_shared_state(ctx, &ctx->Shared, NULL);
  1264.    free(ctx->BeginEnd);
  1265.    free(ctx->OutsideBeginEnd);
  1266.    free(ctx->Save);
  1267.    return GL_FALSE;
  1268. }
  1269.  
  1270.  
  1271. /**
  1272.  * Allocate and initialize a struct gl_context structure.
  1273.  * Note that the driver needs to pass in its dd_function_table here since
  1274.  * we need to at least call driverFunctions->NewTextureObject to initialize
  1275.  * the rendering context.
  1276.  *
  1277.  * \param api the GL API type to create the context for
  1278.  * \param visual a struct gl_config pointer (we copy the struct contents) or
  1279.  *               NULL to create a configless context
  1280.  * \param share_list another context to share display lists with or NULL
  1281.  * \param driverFunctions points to the dd_function_table into which the
  1282.  *        driver has plugged in all its special functions.
  1283.  *
  1284.  * \return pointer to a new __struct gl_contextRec or NULL if error.
  1285.  */
  1286. struct gl_context *
  1287. _mesa_create_context(gl_api api,
  1288.                      const struct gl_config *visual,
  1289.                      struct gl_context *share_list,
  1290.                      const struct dd_function_table *driverFunctions)
  1291. {
  1292.    struct gl_context *ctx;
  1293.  
  1294.    ctx = calloc(1, sizeof(struct gl_context));
  1295.    if (!ctx)
  1296.       return NULL;
  1297.  
  1298.    if (_mesa_initialize_context(ctx, api, visual, share_list,
  1299.                                 driverFunctions)) {
  1300.       return ctx;
  1301.    }
  1302.    else {
  1303.       free(ctx);
  1304.       return NULL;
  1305.    }
  1306. }
  1307.  
  1308.  
  1309. /**
  1310.  * Free the data associated with the given context.
  1311.  *
  1312.  * But doesn't free the struct gl_context struct itself.
  1313.  *
  1314.  * \sa _mesa_initialize_context() and init_attrib_groups().
  1315.  */
  1316. void
  1317. _mesa_free_context_data( struct gl_context *ctx )
  1318. {
  1319.    if (!_mesa_get_current_context()){
  1320.       /* No current context, but we may need one in order to delete
  1321.        * texture objs, etc.  So temporarily bind the context now.
  1322.        */
  1323.       _mesa_make_current(ctx, NULL, NULL);
  1324.    }
  1325.  
  1326.    /* unreference WinSysDraw/Read buffers */
  1327.    _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL);
  1328.    _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL);
  1329.    _mesa_reference_framebuffer(&ctx->DrawBuffer, NULL);
  1330.    _mesa_reference_framebuffer(&ctx->ReadBuffer, NULL);
  1331.  
  1332.    _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, NULL);
  1333.    _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL);
  1334.    _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram, NULL);
  1335.  
  1336.    _mesa_reference_geomprog(ctx, &ctx->GeometryProgram.Current, NULL);
  1337.    _mesa_reference_geomprog(ctx, &ctx->GeometryProgram._Current, NULL);
  1338.  
  1339.    _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current, NULL);
  1340.    _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL);
  1341.    _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL);
  1342.  
  1343.    _mesa_reference_vao(ctx, &ctx->Array.VAO, NULL);
  1344.    _mesa_reference_vao(ctx, &ctx->Array.DefaultVAO, NULL);
  1345.  
  1346.    _mesa_free_attrib_data(ctx);
  1347.    _mesa_free_buffer_objects(ctx);
  1348.    _mesa_free_eval_data( ctx );
  1349.    _mesa_free_texture_data( ctx );
  1350.    _mesa_free_matrix_data( ctx );
  1351.    _mesa_free_pipeline_data(ctx);
  1352.    _mesa_free_program_data(ctx);
  1353.    _mesa_free_shader_state(ctx);
  1354.    _mesa_free_queryobj_data(ctx);
  1355.    _mesa_free_sync_data(ctx);
  1356.    _mesa_free_varray_data(ctx);
  1357.    _mesa_free_transform_feedback(ctx);
  1358.    _mesa_free_performance_monitors(ctx);
  1359.  
  1360.    _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL);
  1361.    _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL);
  1362.    _mesa_reference_buffer_object(ctx, &ctx->DefaultPacking.BufferObj, NULL);
  1363.    _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);
  1364.  
  1365.    /* free dispatch tables */
  1366.    free(ctx->BeginEnd);
  1367.    free(ctx->OutsideBeginEnd);
  1368.    free(ctx->Save);
  1369.  
  1370.    /* Shared context state (display lists, textures, etc) */
  1371.    _mesa_reference_shared_state(ctx, &ctx->Shared, NULL);
  1372.  
  1373.    /* needs to be after freeing shared state */
  1374.    _mesa_free_display_list_data(ctx);
  1375.  
  1376.    _mesa_free_errors_data(ctx);
  1377.  
  1378.    free((void *)ctx->Extensions.String);
  1379.  
  1380.    free(ctx->VersionString);
  1381.  
  1382.    /* unbind the context if it's currently bound */
  1383.    if (ctx == _mesa_get_current_context()) {
  1384.       _mesa_make_current(NULL, NULL, NULL);
  1385.    }
  1386. }
  1387.  
  1388.  
  1389. /**
  1390.  * Destroy a struct gl_context structure.
  1391.  *
  1392.  * \param ctx GL context.
  1393.  *
  1394.  * Calls _mesa_free_context_data() and frees the gl_context object itself.
  1395.  */
  1396. void
  1397. _mesa_destroy_context( struct gl_context *ctx )
  1398. {
  1399.    if (ctx) {
  1400.       _mesa_free_context_data(ctx);
  1401.       free( (void *) ctx );
  1402.    }
  1403. }
  1404.  
  1405.  
  1406. /**
  1407.  * Copy attribute groups from one context to another.
  1408.  *
  1409.  * \param src source context
  1410.  * \param dst destination context
  1411.  * \param mask bitwise OR of GL_*_BIT flags
  1412.  *
  1413.  * According to the bits specified in \p mask, copies the corresponding
  1414.  * attributes from \p src into \p dst.  For many of the attributes a simple \c
  1415.  * memcpy is not enough due to the existence of internal pointers in their data
  1416.  * structures.
  1417.  */
  1418. void
  1419. _mesa_copy_context( const struct gl_context *src, struct gl_context *dst,
  1420.                     GLuint mask )
  1421. {
  1422.    if (mask & GL_ACCUM_BUFFER_BIT) {
  1423.       /* OK to memcpy */
  1424.       dst->Accum = src->Accum;
  1425.    }
  1426.    if (mask & GL_COLOR_BUFFER_BIT) {
  1427.       /* OK to memcpy */
  1428.       dst->Color = src->Color;
  1429.    }
  1430.    if (mask & GL_CURRENT_BIT) {
  1431.       /* OK to memcpy */
  1432.       dst->Current = src->Current;
  1433.    }
  1434.    if (mask & GL_DEPTH_BUFFER_BIT) {
  1435.       /* OK to memcpy */
  1436.       dst->Depth = src->Depth;
  1437.    }
  1438.    if (mask & GL_ENABLE_BIT) {
  1439.       /* no op */
  1440.    }
  1441.    if (mask & GL_EVAL_BIT) {
  1442.       /* OK to memcpy */
  1443.       dst->Eval = src->Eval;
  1444.    }
  1445.    if (mask & GL_FOG_BIT) {
  1446.       /* OK to memcpy */
  1447.       dst->Fog = src->Fog;
  1448.    }
  1449.    if (mask & GL_HINT_BIT) {
  1450.       /* OK to memcpy */
  1451.       dst->Hint = src->Hint;
  1452.    }
  1453.    if (mask & GL_LIGHTING_BIT) {
  1454.       GLuint i;
  1455.       /* begin with memcpy */
  1456.       dst->Light = src->Light;
  1457.       /* fixup linked lists to prevent pointer insanity */
  1458.       make_empty_list( &(dst->Light.EnabledList) );
  1459.       for (i = 0; i < MAX_LIGHTS; i++) {
  1460.          if (dst->Light.Light[i].Enabled) {
  1461.             insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));
  1462.          }
  1463.       }
  1464.    }
  1465.    if (mask & GL_LINE_BIT) {
  1466.       /* OK to memcpy */
  1467.       dst->Line = src->Line;
  1468.    }
  1469.    if (mask & GL_LIST_BIT) {
  1470.       /* OK to memcpy */
  1471.       dst->List = src->List;
  1472.    }
  1473.    if (mask & GL_PIXEL_MODE_BIT) {
  1474.       /* OK to memcpy */
  1475.       dst->Pixel = src->Pixel;
  1476.    }
  1477.    if (mask & GL_POINT_BIT) {
  1478.       /* OK to memcpy */
  1479.       dst->Point = src->Point;
  1480.    }
  1481.    if (mask & GL_POLYGON_BIT) {
  1482.       /* OK to memcpy */
  1483.       dst->Polygon = src->Polygon;
  1484.    }
  1485.    if (mask & GL_POLYGON_STIPPLE_BIT) {
  1486.       /* Use loop instead of memcpy due to problem with Portland Group's
  1487.        * C compiler.  Reported by John Stone.
  1488.        */
  1489.       GLuint i;
  1490.       for (i = 0; i < 32; i++) {
  1491.          dst->PolygonStipple[i] = src->PolygonStipple[i];
  1492.       }
  1493.    }
  1494.    if (mask & GL_SCISSOR_BIT) {
  1495.       /* OK to memcpy */
  1496.       dst->Scissor = src->Scissor;
  1497.    }
  1498.    if (mask & GL_STENCIL_BUFFER_BIT) {
  1499.       /* OK to memcpy */
  1500.       dst->Stencil = src->Stencil;
  1501.    }
  1502.    if (mask & GL_TEXTURE_BIT) {
  1503.       /* Cannot memcpy because of pointers */
  1504.       _mesa_copy_texture_state(src, dst);
  1505.    }
  1506.    if (mask & GL_TRANSFORM_BIT) {
  1507.       /* OK to memcpy */
  1508.       dst->Transform = src->Transform;
  1509.    }
  1510.    if (mask & GL_VIEWPORT_BIT) {
  1511.       unsigned i;
  1512.       for (i = 0; i < src->Const.MaxViewports; i++) {
  1513.          /* OK to memcpy */
  1514.          dst->ViewportArray[i] = src->ViewportArray[i];
  1515.       }
  1516.    }
  1517.  
  1518.    /* XXX FIXME:  Call callbacks?
  1519.     */
  1520.    dst->NewState = _NEW_ALL;
  1521.    dst->NewDriverState = ~0;
  1522. }
  1523.  
  1524.  
  1525. /**
  1526.  * Check if the given context can render into the given framebuffer
  1527.  * by checking visual attributes.
  1528.  *
  1529.  * Most of these tests could go away because Mesa is now pretty flexible
  1530.  * in terms of mixing rendering contexts with framebuffers.  As long
  1531.  * as RGB vs. CI mode agree, we're probably good.
  1532.  *
  1533.  * \return GL_TRUE if compatible, GL_FALSE otherwise.
  1534.  */
  1535. static GLboolean
  1536. check_compatible(const struct gl_context *ctx,
  1537.                  const struct gl_framebuffer *buffer)
  1538. {
  1539.    const struct gl_config *ctxvis = &ctx->Visual;
  1540.    const struct gl_config *bufvis = &buffer->Visual;
  1541.  
  1542.    if (buffer == _mesa_get_incomplete_framebuffer())
  1543.       return GL_TRUE;
  1544.  
  1545. #if 0
  1546.    /* disabling this fixes the fgl_glxgears pbuffer demo */
  1547.    if (ctxvis->doubleBufferMode && !bufvis->doubleBufferMode)
  1548.       return GL_FALSE;
  1549. #endif
  1550.    if (ctxvis->stereoMode && !bufvis->stereoMode)
  1551.       return GL_FALSE;
  1552.    if (ctxvis->haveAccumBuffer && !bufvis->haveAccumBuffer)
  1553.       return GL_FALSE;
  1554.    if (ctxvis->haveDepthBuffer && !bufvis->haveDepthBuffer)
  1555.       return GL_FALSE;
  1556.    if (ctxvis->haveStencilBuffer && !bufvis->haveStencilBuffer)
  1557.       return GL_FALSE;
  1558.    if (ctxvis->redMask && ctxvis->redMask != bufvis->redMask)
  1559.       return GL_FALSE;
  1560.    if (ctxvis->greenMask && ctxvis->greenMask != bufvis->greenMask)
  1561.       return GL_FALSE;
  1562.    if (ctxvis->blueMask && ctxvis->blueMask != bufvis->blueMask)
  1563.       return GL_FALSE;
  1564. #if 0
  1565.    /* disabled (see bug 11161) */
  1566.    if (ctxvis->depthBits && ctxvis->depthBits != bufvis->depthBits)
  1567.       return GL_FALSE;
  1568. #endif
  1569.    if (ctxvis->stencilBits && ctxvis->stencilBits != bufvis->stencilBits)
  1570.       return GL_FALSE;
  1571.  
  1572.    return GL_TRUE;
  1573. }
  1574.  
  1575.  
  1576. /**
  1577.  * Check if the viewport/scissor size has not yet been initialized.
  1578.  * Initialize the size if the given width and height are non-zero.
  1579.  */
  1580. void
  1581. _mesa_check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height)
  1582. {
  1583.    if (!ctx->ViewportInitialized && width > 0 && height > 0) {
  1584.       unsigned i;
  1585.  
  1586.       /* Note: set flag here, before calling _mesa_set_viewport(), to prevent
  1587.        * potential infinite recursion.
  1588.        */
  1589.       ctx->ViewportInitialized = GL_TRUE;
  1590.  
  1591.       /* Note: ctx->Const.MaxViewports may not have been set by the driver
  1592.        * yet, so just initialize all of them.
  1593.        */
  1594.       for (i = 0; i < MAX_VIEWPORTS; i++) {
  1595.          _mesa_set_viewport(ctx, i, 0, 0, width, height);
  1596.          _mesa_set_scissor(ctx, i, 0, 0, width, height);
  1597.       }
  1598.    }
  1599. }
  1600.  
  1601. static void
  1602. handle_first_current(struct gl_context *ctx)
  1603. {
  1604.    GLenum buffer;
  1605.    GLint bufferIndex;
  1606.  
  1607.    if (ctx->Version == 0) {
  1608.       /* probably in the process of tearing down the context */
  1609.       return;
  1610.    }
  1611.  
  1612.    ctx->Extensions.String = _mesa_make_extension_string(ctx);
  1613.  
  1614.    check_context_limits(ctx);
  1615.  
  1616.    /* According to GL_MESA_configless_context the default value of
  1617.     * glDrawBuffers depends on the config of the first surface it is bound to.
  1618.     * For GLES it is always GL_BACK which has a magic interpretation */
  1619.    if (!ctx->HasConfig && _mesa_is_desktop_gl(ctx)) {
  1620.       if (ctx->DrawBuffer != _mesa_get_incomplete_framebuffer()) {
  1621.          if (ctx->DrawBuffer->Visual.doubleBufferMode)
  1622.             buffer = GL_BACK;
  1623.          else
  1624.             buffer = GL_FRONT;
  1625.  
  1626.          _mesa_drawbuffers(ctx, ctx->DrawBuffer, 1, &buffer,
  1627.                            NULL /* destMask */);
  1628.       }
  1629.  
  1630.       if (ctx->ReadBuffer != _mesa_get_incomplete_framebuffer()) {
  1631.          if (ctx->ReadBuffer->Visual.doubleBufferMode) {
  1632.             buffer = GL_BACK;
  1633.             bufferIndex = BUFFER_BACK_LEFT;
  1634.          }
  1635.          else {
  1636.             buffer = GL_FRONT;
  1637.             bufferIndex = BUFFER_FRONT_LEFT;
  1638.          }
  1639.  
  1640.          _mesa_readbuffer(ctx, ctx->ReadBuffer, buffer, bufferIndex);
  1641.       }
  1642.    }
  1643.  
  1644.    /* We can use this to help debug user's problems.  Tell them to set
  1645.     * the MESA_INFO env variable before running their app.  Then the
  1646.     * first time each context is made current we'll print some useful
  1647.     * information.
  1648.     */
  1649.    if (getenv("MESA_INFO")) {
  1650.       _mesa_print_info(ctx);
  1651.    }
  1652. }
  1653.  
  1654. /**
  1655.  * Bind the given context to the given drawBuffer and readBuffer and
  1656.  * make it the current context for the calling thread.
  1657.  * We'll render into the drawBuffer and read pixels from the
  1658.  * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
  1659.  *
  1660.  * We check that the context's and framebuffer's visuals are compatible
  1661.  * and return immediately if they're not.
  1662.  *
  1663.  * \param newCtx  the new GL context. If NULL then there will be no current GL
  1664.  *                context.
  1665.  * \param drawBuffer  the drawing framebuffer
  1666.  * \param readBuffer  the reading framebuffer
  1667.  */
  1668. GLboolean
  1669. _mesa_make_current( struct gl_context *newCtx,
  1670.                     struct gl_framebuffer *drawBuffer,
  1671.                     struct gl_framebuffer *readBuffer )
  1672. {
  1673.    GET_CURRENT_CONTEXT(curCtx);
  1674.  
  1675.    if (MESA_VERBOSE & VERBOSE_API)
  1676.       _mesa_debug(newCtx, "_mesa_make_current()\n");
  1677.  
  1678.    /* Check that the context's and framebuffer's visuals are compatible.
  1679.     */
  1680.    if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {
  1681.       if (!check_compatible(newCtx, drawBuffer)) {
  1682.          _mesa_warning(newCtx,
  1683.               "MakeCurrent: incompatible visuals for context and drawbuffer");
  1684.          return GL_FALSE;
  1685.       }
  1686.    }
  1687.    if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {
  1688.       if (!check_compatible(newCtx, readBuffer)) {
  1689.          _mesa_warning(newCtx,
  1690.               "MakeCurrent: incompatible visuals for context and readbuffer");
  1691.          return GL_FALSE;
  1692.       }
  1693.    }
  1694.  
  1695.    if (curCtx &&
  1696.        (curCtx->WinSysDrawBuffer || curCtx->WinSysReadBuffer) &&
  1697.        /* make sure this context is valid for flushing */
  1698.        curCtx != newCtx &&
  1699.        curCtx->Const.ContextReleaseBehavior ==
  1700.        GL_CONTEXT_RELEASE_BEHAVIOR_FLUSH)
  1701.       _mesa_flush(curCtx);
  1702.  
  1703.    /* We used to call _glapi_check_multithread() here.  Now do it in drivers */
  1704.    _glapi_set_context((void *) newCtx);
  1705.    assert(_mesa_get_current_context() == newCtx);
  1706.  
  1707.    if (!newCtx) {
  1708.       _glapi_set_dispatch(NULL);  /* none current */
  1709.    }
  1710.    else {
  1711.       _glapi_set_dispatch(newCtx->CurrentDispatch);
  1712.  
  1713.       if (drawBuffer && readBuffer) {
  1714.          assert(_mesa_is_winsys_fbo(drawBuffer));
  1715.          assert(_mesa_is_winsys_fbo(readBuffer));
  1716.          _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);
  1717.          _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);
  1718.  
  1719.          /*
  1720.           * Only set the context's Draw/ReadBuffer fields if they're NULL
  1721.           * or not bound to a user-created FBO.
  1722.           */
  1723.          if (!newCtx->DrawBuffer || _mesa_is_winsys_fbo(newCtx->DrawBuffer)) {
  1724.             _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
  1725.             /* Update the FBO's list of drawbuffers/renderbuffers.
  1726.              * For winsys FBOs this comes from the GL state (which may have
  1727.              * changed since the last time this FBO was bound).
  1728.              */
  1729.             _mesa_update_draw_buffers(newCtx);
  1730.          }
  1731.          if (!newCtx->ReadBuffer || _mesa_is_winsys_fbo(newCtx->ReadBuffer)) {
  1732.             _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
  1733.          }
  1734.  
  1735.          /* XXX only set this flag if we're really changing the draw/read
  1736.           * framebuffer bindings.
  1737.           */
  1738.          newCtx->NewState |= _NEW_BUFFERS;
  1739.  
  1740.          if (drawBuffer) {
  1741.             _mesa_check_init_viewport(newCtx,
  1742.                                       drawBuffer->Width, drawBuffer->Height);
  1743.          }
  1744.       }
  1745.  
  1746.       if (newCtx->FirstTimeCurrent) {
  1747.          handle_first_current(newCtx);
  1748.          newCtx->FirstTimeCurrent = GL_FALSE;
  1749.       }
  1750.    }
  1751.    
  1752.    return GL_TRUE;
  1753. }
  1754.  
  1755.  
  1756. /**
  1757.  * Make context 'ctx' share the display lists, textures and programs
  1758.  * that are associated with 'ctxToShare'.
  1759.  * Any display lists, textures or programs associated with 'ctx' will
  1760.  * be deleted if nobody else is sharing them.
  1761.  */
  1762. GLboolean
  1763. _mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare)
  1764. {
  1765.    if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
  1766.       struct gl_shared_state *oldShared = NULL;
  1767.  
  1768.       /* save ref to old state to prevent it from being deleted immediately */
  1769.       _mesa_reference_shared_state(ctx, &oldShared, ctx->Shared);
  1770.  
  1771.       /* update ctx's Shared pointer */
  1772.       _mesa_reference_shared_state(ctx, &ctx->Shared, ctxToShare->Shared);
  1773.  
  1774.       update_default_objects(ctx);
  1775.  
  1776.       /* release the old shared state */
  1777.       _mesa_reference_shared_state(ctx, &oldShared, NULL);
  1778.  
  1779.       return GL_TRUE;
  1780.    }
  1781.    else {
  1782.       return GL_FALSE;
  1783.    }
  1784. }
  1785.  
  1786.  
  1787.  
  1788. /**
  1789.  * \return pointer to the current GL context for this thread.
  1790.  *
  1791.  * Calls _glapi_get_context(). This isn't the fastest way to get the current
  1792.  * context.  If you need speed, see the #GET_CURRENT_CONTEXT macro in
  1793.  * context.h.
  1794.  */
  1795. struct gl_context *
  1796. _mesa_get_current_context( void )
  1797. {
  1798.    return (struct gl_context *) _glapi_get_context();
  1799. }
  1800.  
  1801.  
  1802. /**
  1803.  * Get context's current API dispatch table.
  1804.  *
  1805.  * It'll either be the immediate-mode execute dispatcher or the display list
  1806.  * compile dispatcher.
  1807.  *
  1808.  * \param ctx GL context.
  1809.  *
  1810.  * \return pointer to dispatch_table.
  1811.  *
  1812.  * Simply returns __struct gl_contextRec::CurrentDispatch.
  1813.  */
  1814. struct _glapi_table *
  1815. _mesa_get_dispatch(struct gl_context *ctx)
  1816. {
  1817.    return ctx->CurrentDispatch;
  1818. }
  1819.  
  1820. /*@}*/
  1821.  
  1822.  
  1823. /**********************************************************************/
  1824. /** \name Miscellaneous functions                                     */
  1825. /**********************************************************************/
  1826. /*@{*/
  1827.  
  1828. /**
  1829.  * Record an error.
  1830.  *
  1831.  * \param ctx GL context.
  1832.  * \param error error code.
  1833.  *
  1834.  * Records the given error code and call the driver's dd_function_table::Error
  1835.  * function if defined.
  1836.  *
  1837.  * \sa
  1838.  * This is called via _mesa_error().
  1839.  */
  1840. void
  1841. _mesa_record_error(struct gl_context *ctx, GLenum error)
  1842. {
  1843.    if (!ctx)
  1844.       return;
  1845.  
  1846.    if (ctx->ErrorValue == GL_NO_ERROR) {
  1847.       ctx->ErrorValue = error;
  1848.    }
  1849. }
  1850.  
  1851.  
  1852. /**
  1853.  * Flush commands and wait for completion.
  1854.  */
  1855. void
  1856. _mesa_finish(struct gl_context *ctx)
  1857. {
  1858.    FLUSH_VERTICES( ctx, 0 );
  1859.    FLUSH_CURRENT( ctx, 0 );
  1860.    if (ctx->Driver.Finish) {
  1861.       ctx->Driver.Finish(ctx);
  1862.    }
  1863. }
  1864.  
  1865.  
  1866. /**
  1867.  * Flush commands.
  1868.  */
  1869. void
  1870. _mesa_flush(struct gl_context *ctx)
  1871. {
  1872.    FLUSH_VERTICES( ctx, 0 );
  1873.    FLUSH_CURRENT( ctx, 0 );
  1874.    if (ctx->Driver.Flush) {
  1875.       ctx->Driver.Flush(ctx);
  1876.    }
  1877. }
  1878.  
  1879.  
  1880.  
  1881. /**
  1882.  * Execute glFinish().
  1883.  *
  1884.  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
  1885.  * dd_function_table::Finish driver callback, if not NULL.
  1886.  */
  1887. void GLAPIENTRY
  1888. _mesa_Finish(void)
  1889. {
  1890.    GET_CURRENT_CONTEXT(ctx);
  1891.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  1892.    _mesa_finish(ctx);
  1893. }
  1894.  
  1895.  
  1896. /**
  1897.  * Execute glFlush().
  1898.  *
  1899.  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
  1900.  * dd_function_table::Flush driver callback, if not NULL.
  1901.  */
  1902. void GLAPIENTRY
  1903. _mesa_Flush(void)
  1904. {
  1905.    GET_CURRENT_CONTEXT(ctx);
  1906.    ASSERT_OUTSIDE_BEGIN_END(ctx);
  1907.    _mesa_flush(ctx);
  1908. }
  1909.  
  1910.  
  1911. /*
  1912.  * ARB_blend_func_extended - ERRORS section
  1913.  * "The error INVALID_OPERATION is generated by Begin or any procedure that
  1914.  *  implicitly calls Begin if any draw buffer has a blend function requiring the
  1915.  *  second color input (SRC1_COLOR, ONE_MINUS_SRC1_COLOR, SRC1_ALPHA or
  1916.  *  ONE_MINUS_SRC1_ALPHA), and a framebuffer is bound that has more than
  1917.  *  the value of MAX_DUAL_SOURCE_DRAW_BUFFERS-1 active color attachements."
  1918.  */
  1919. static GLboolean
  1920. _mesa_check_blend_func_error(struct gl_context *ctx)
  1921. {
  1922.    GLuint i;
  1923.    for (i = ctx->Const.MaxDualSourceDrawBuffers;
  1924.         i < ctx->DrawBuffer->_NumColorDrawBuffers;
  1925.         i++) {
  1926.       if (ctx->Color.Blend[i]._UsesDualSrc) {
  1927.          _mesa_error(ctx, GL_INVALID_OPERATION,
  1928.                      "dual source blend on illegal attachment");
  1929.          return GL_FALSE;
  1930.       }
  1931.    }
  1932.    return GL_TRUE;
  1933. }
  1934.  
  1935. static bool
  1936. shader_linked_or_absent(struct gl_context *ctx,
  1937.                         const struct gl_shader_program *shProg,
  1938.                         bool *shader_present, const char *where)
  1939. {
  1940.    if (shProg) {
  1941.       *shader_present = true;
  1942.  
  1943.       if (!shProg->LinkStatus) {
  1944.          _mesa_error(ctx, GL_INVALID_OPERATION, "%s(shader not linked)", where);
  1945.          return false;
  1946.       }
  1947. #if 0 /* not normally enabled */
  1948.       {
  1949.          char errMsg[100];
  1950.          if (!_mesa_validate_shader_program(ctx, shProg, errMsg)) {
  1951.             _mesa_warning(ctx, "Shader program %u is invalid: %s",
  1952.                           shProg->Name, errMsg);
  1953.          }
  1954.       }
  1955. #endif
  1956.    }
  1957.  
  1958.    return true;
  1959. }
  1960.  
  1961. /**
  1962.  * Prior to drawing anything with glBegin, glDrawArrays, etc. this function
  1963.  * is called to see if it's valid to render.  This involves checking that
  1964.  * the current shader is valid and the framebuffer is complete.
  1965.  * It also check the current pipeline object is valid if any.
  1966.  * If an error is detected it'll be recorded here.
  1967.  * \return GL_TRUE if OK to render, GL_FALSE if not
  1968.  */
  1969. GLboolean
  1970. _mesa_valid_to_render(struct gl_context *ctx, const char *where)
  1971. {
  1972.    unsigned i;
  1973.  
  1974.    /* This depends on having up to date derived state (shaders) */
  1975.    if (ctx->NewState)
  1976.       _mesa_update_state(ctx);
  1977.  
  1978.    if (ctx->API == API_OPENGL_CORE || ctx->API == API_OPENGLES2) {
  1979.       bool from_glsl_shader[MESA_SHADER_COMPUTE] = { false };
  1980.  
  1981.       for (i = 0; i < MESA_SHADER_COMPUTE; i++) {
  1982.          if (!shader_linked_or_absent(ctx, ctx->_Shader->CurrentProgram[i],
  1983.                                       &from_glsl_shader[i], where))
  1984.             return GL_FALSE;
  1985.       }
  1986.  
  1987.       /* In OpenGL Core Profile and OpenGL ES 2.0 / 3.0, there are no assembly
  1988.        * shaders.  Don't check state related to those.
  1989.        */
  1990.    } else {
  1991.       bool has_vertex_shader = false;
  1992.       bool has_fragment_shader = false;
  1993.  
  1994.       /* In OpenGL Compatibility Profile, there is only vertex shader and
  1995.        * fragment shader.  We take this path also for API_OPENGLES because
  1996.        * optimizing that path would make the other (more common) paths
  1997.        * slightly slower.
  1998.        */
  1999.       if (!shader_linked_or_absent(ctx,
  2000.                                    ctx->_Shader->CurrentProgram[MESA_SHADER_VERTEX],
  2001.                                    &has_vertex_shader, where))
  2002.          return GL_FALSE;
  2003.  
  2004.       if (!shader_linked_or_absent(ctx,
  2005.                                    ctx->_Shader->CurrentProgram[MESA_SHADER_FRAGMENT],
  2006.                                    &has_fragment_shader, where))
  2007.          return GL_FALSE;
  2008.  
  2009.       /* Any shader stages that are not supplied by the GLSL shader and have
  2010.        * assembly shaders enabled must now be validated.
  2011.        */
  2012.       if (!has_vertex_shader
  2013.           && ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) {
  2014.          _mesa_error(ctx, GL_INVALID_OPERATION,
  2015.                      "%s(vertex program not valid)", where);
  2016.          return GL_FALSE;
  2017.       }
  2018.  
  2019.       if (!has_fragment_shader) {
  2020.          if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) {
  2021.             _mesa_error(ctx, GL_INVALID_OPERATION,
  2022.                         "%s(fragment program not valid)", where);
  2023.             return GL_FALSE;
  2024.          }
  2025.  
  2026.          /* If drawing to integer-valued color buffers, there must be an
  2027.           * active fragment shader (GL_EXT_texture_integer).
  2028.           */
  2029.          if (ctx->DrawBuffer && ctx->DrawBuffer->_IntegerColor) {
  2030.             _mesa_error(ctx, GL_INVALID_OPERATION,
  2031.                         "%s(integer format but no fragment shader)", where);
  2032.             return GL_FALSE;
  2033.          }
  2034.       }
  2035.    }
  2036.  
  2037.    /* A pipeline object is bound */
  2038.    if (ctx->_Shader->Name && !ctx->_Shader->Validated) {
  2039.       /* Error message will be printed inside _mesa_validate_program_pipeline.
  2040.        */
  2041.       if (!_mesa_validate_program_pipeline(ctx, ctx->_Shader, GL_TRUE)) {
  2042.          return GL_FALSE;
  2043.       }
  2044.    }
  2045.  
  2046.    /* If a program is active and SSO not in use, check if validation of
  2047.     * samplers succeeded for the active program. */
  2048.    if (ctx->_Shader->ActiveProgram && ctx->_Shader != ctx->Pipeline.Current) {
  2049.       char errMsg[100];
  2050.       if (!_mesa_sampler_uniforms_are_valid(ctx->_Shader->ActiveProgram,
  2051.                                             errMsg, 100)) {
  2052.          _mesa_error(ctx, GL_INVALID_OPERATION, "%s", errMsg);
  2053.          return GL_FALSE;
  2054.       }
  2055.    }
  2056.  
  2057.    if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
  2058.       _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
  2059.                   "%s(incomplete framebuffer)", where);
  2060.       return GL_FALSE;
  2061.    }
  2062.  
  2063.    if (_mesa_check_blend_func_error(ctx) == GL_FALSE) {
  2064.       return GL_FALSE;
  2065.    }
  2066.  
  2067. #ifdef DEBUG
  2068.    if (ctx->_Shader->Flags & GLSL_LOG) {
  2069.       struct gl_shader_program **shProg = ctx->_Shader->CurrentProgram;
  2070.       gl_shader_stage i;
  2071.  
  2072.       for (i = 0; i < MESA_SHADER_STAGES; i++) {
  2073.          if (shProg[i] == NULL || shProg[i]->_Used
  2074.              || shProg[i]->_LinkedShaders[i] == NULL)
  2075.             continue;
  2076.  
  2077.          /* This is the first time this shader is being used.
  2078.           * Append shader's constants/uniforms to log file.
  2079.           *
  2080.           * Only log data for the program target that matches the shader
  2081.           * target.  It's possible to have a program bound to the vertex
  2082.           * shader target that also supplied a fragment shader.  If that
  2083.           * program isn't also bound to the fragment shader target we don't
  2084.           * want to log its fragment data.
  2085.           */
  2086.          _mesa_append_uniforms_to_file(shProg[i]->_LinkedShaders[i]);
  2087.       }
  2088.  
  2089.       for (i = 0; i < MESA_SHADER_STAGES; i++) {
  2090.          if (shProg[i] != NULL)
  2091.             shProg[i]->_Used = GL_TRUE;
  2092.       }
  2093.    }
  2094. #endif
  2095.  
  2096.    return GL_TRUE;
  2097. }
  2098.  
  2099.  
  2100. /*@}*/
  2101.