Subversion Repositories Kolibri OS

Rev

Rev 1901 | Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Mesa 3-D graphics library
  3.  * Version:  7.3
  4.  *
  5.  * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.
  6.  * Copyright (C) 2008  VMware, Inc.  All Rights Reserved.
  7.  *
  8.  * Permission is hereby granted, free of charge, to any person obtaining a
  9.  * copy of this software and associated documentation files (the "Software"),
  10.  * to deal in the Software without restriction, including without limitation
  11.  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
  12.  * and/or sell copies of the Software, and to permit persons to whom the
  13.  * Software is furnished to do so, subject to the following conditions:
  14.  *
  15.  * The above copyright notice and this permission notice shall be included
  16.  * in all copies or substantial portions of the Software.
  17.  *
  18.  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  19.  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  20.  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  21.  * BRIAN PAUL BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
  22.  * AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  23.  * CONNECTION WITH THE SOFTWARE OR THE USE OR 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 "mfeatures.h"
  81. #include "imports.h"
  82. #include "accum.h"
  83. #include "api_exec.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 "framebuffer.h"
  100. #include "hint.h"
  101. #include "hash.h"
  102. #include "light.h"
  103. #include "lines.h"
  104. #include "macros.h"
  105. #include "matrix.h"
  106. #include "multisample.h"
  107. #include "pixel.h"
  108. #include "pixelstore.h"
  109. #include "points.h"
  110. #include "polygon.h"
  111. #include "queryobj.h"
  112. #include "syncobj.h"
  113. #include "rastpos.h"
  114. #include "remap.h"
  115. #include "scissor.h"
  116. #include "shared.h"
  117. #include "shaderobj.h"
  118. #include "simple_list.h"
  119. #include "state.h"
  120. #include "stencil.h"
  121. #include "texcompress_s3tc.h"
  122. #include "texstate.h"
  123. #include "transformfeedback.h"
  124. #include "mtypes.h"
  125. #include "varray.h"
  126. #include "version.h"
  127. #include "viewport.h"
  128. #include "vtxfmt.h"
  129. #include "program/program.h"
  130. #include "program/prog_print.h"
  131. #if _HAVE_FULL_GL
  132. #include "math/m_matrix.h"
  133. #endif
  134. #include "main/dispatch.h" /* for _gloffset_COUNT */
  135.  
  136. #ifdef USE_SPARC_ASM
  137. #include "sparc/sparc.h"
  138. #endif
  139.  
  140. #include "glsl_parser_extras.h"
  141. #include <stdbool.h>
  142.  
  143.  
  144. #ifndef MESA_VERBOSE
  145. int MESA_VERBOSE = 0;
  146. #endif
  147.  
  148. #ifndef MESA_DEBUG_FLAGS
  149. int MESA_DEBUG_FLAGS = 0;
  150. #endif
  151.  
  152.  
  153. /* ubyte -> float conversion */
  154. GLfloat _mesa_ubyte_to_float_color_tab[256];
  155.  
  156.  
  157.  
  158. /**
  159.  * Swap buffers notification callback.
  160.  *
  161.  * \param ctx GL context.
  162.  *
  163.  * Called by window system just before swapping buffers.
  164.  * We have to finish any pending rendering.
  165.  */
  166. void
  167. _mesa_notifySwapBuffers(struct gl_context *ctx)
  168. {
  169.    if (MESA_VERBOSE & VERBOSE_SWAPBUFFERS)
  170.       _mesa_debug(ctx, "SwapBuffers\n");
  171.    FLUSH_CURRENT( ctx, 0 );
  172.    if (ctx->Driver.Flush) {
  173.       ctx->Driver.Flush(ctx);
  174.    }
  175. }
  176.  
  177.  
  178. /**********************************************************************/
  179. /** \name GL Visual allocation/destruction                            */
  180. /**********************************************************************/
  181. /*@{*/
  182.  
  183. /**
  184.  * Allocates a struct gl_config structure and initializes it via
  185.  * _mesa_initialize_visual().
  186.  *
  187.  * \param dbFlag double buffering
  188.  * \param stereoFlag stereo buffer
  189.  * \param depthBits requested bits per depth buffer value. Any value in [0, 32]
  190.  * is acceptable but the actual depth type will be GLushort or GLuint as
  191.  * needed.
  192.  * \param stencilBits requested minimum bits per stencil buffer value
  193.  * \param accumRedBits, accumGreenBits, accumBlueBits, accumAlphaBits number of bits per color component in accum buffer.
  194.  * \param indexBits number of bits per pixel if \p rgbFlag is GL_FALSE
  195.  * \param redBits number of bits per color component in frame buffer for RGB(A)
  196.  * mode.  We always use 8 in core Mesa though.
  197.  * \param greenBits same as above.
  198.  * \param blueBits same as above.
  199.  * \param alphaBits same as above.
  200.  * \param numSamples not really used.
  201.  *
  202.  * \return pointer to new struct gl_config or NULL if requested parameters can't be
  203.  * met.
  204.  *
  205.  * \note Need to add params for level and numAuxBuffers (at least)
  206.  */
  207. struct gl_config *
  208. _mesa_create_visual( GLboolean dbFlag,
  209.                      GLboolean stereoFlag,
  210.                      GLint redBits,
  211.                      GLint greenBits,
  212.                      GLint blueBits,
  213.                      GLint alphaBits,
  214.                      GLint depthBits,
  215.                      GLint stencilBits,
  216.                      GLint accumRedBits,
  217.                      GLint accumGreenBits,
  218.                      GLint accumBlueBits,
  219.                      GLint accumAlphaBits,
  220.                      GLint numSamples )
  221. {
  222.    struct gl_config *vis = CALLOC_STRUCT(gl_config);
  223.    if (vis) {
  224.       if (!_mesa_initialize_visual(vis, dbFlag, stereoFlag,
  225.                                    redBits, greenBits, blueBits, alphaBits,
  226.                                    depthBits, stencilBits,
  227.                                    accumRedBits, accumGreenBits,
  228.                                    accumBlueBits, accumAlphaBits,
  229.                                    numSamples)) {
  230.          free(vis);
  231.          return NULL;
  232.       }
  233.    }
  234.    return vis;
  235. }
  236.  
  237.  
  238. /**
  239.  * Makes some sanity checks and fills in the fields of the struct
  240.  * gl_config object with the given parameters.  If the caller needs to
  241.  * set additional fields, he should just probably init the whole
  242.  * gl_config object himself.
  243.  *
  244.  * \return GL_TRUE on success, or GL_FALSE on failure.
  245.  *
  246.  * \sa _mesa_create_visual() above for the parameter description.
  247.  */
  248. GLboolean
  249. _mesa_initialize_visual( struct gl_config *vis,
  250.                          GLboolean dbFlag,
  251.                          GLboolean stereoFlag,
  252.                          GLint redBits,
  253.                          GLint greenBits,
  254.                          GLint blueBits,
  255.                          GLint alphaBits,
  256.                          GLint depthBits,
  257.                          GLint stencilBits,
  258.                          GLint accumRedBits,
  259.                          GLint accumGreenBits,
  260.                          GLint accumBlueBits,
  261.                          GLint accumAlphaBits,
  262.                          GLint numSamples )
  263. {
  264.    assert(vis);
  265.  
  266.    if (depthBits < 0 || depthBits > 32) {
  267.       return GL_FALSE;
  268.    }
  269.    if (stencilBits < 0 || stencilBits > STENCIL_BITS) {
  270.       return GL_FALSE;
  271.    }
  272.    assert(accumRedBits >= 0);
  273.    assert(accumGreenBits >= 0);
  274.    assert(accumBlueBits >= 0);
  275.    assert(accumAlphaBits >= 0);
  276.  
  277.    vis->rgbMode          = GL_TRUE;
  278.    vis->doubleBufferMode = dbFlag;
  279.    vis->stereoMode       = stereoFlag;
  280.  
  281.    vis->redBits          = redBits;
  282.    vis->greenBits        = greenBits;
  283.    vis->blueBits         = blueBits;
  284.    vis->alphaBits        = alphaBits;
  285.    vis->rgbBits          = redBits + greenBits + blueBits;
  286.  
  287.    vis->indexBits      = 0;
  288.    vis->depthBits      = depthBits;
  289.    vis->stencilBits    = stencilBits;
  290.  
  291.    vis->accumRedBits   = accumRedBits;
  292.    vis->accumGreenBits = accumGreenBits;
  293.    vis->accumBlueBits  = accumBlueBits;
  294.    vis->accumAlphaBits = accumAlphaBits;
  295.  
  296.    vis->haveAccumBuffer   = accumRedBits > 0;
  297.    vis->haveDepthBuffer   = depthBits > 0;
  298.    vis->haveStencilBuffer = stencilBits > 0;
  299.  
  300.    vis->numAuxBuffers = 0;
  301.    vis->level = 0;
  302.    vis->sampleBuffers = numSamples > 0 ? 1 : 0;
  303.    vis->samples = numSamples;
  304.  
  305.    return GL_TRUE;
  306. }
  307.  
  308.  
  309. /**
  310.  * Destroy a visual and free its memory.
  311.  *
  312.  * \param vis visual.
  313.  *
  314.  * Frees the visual structure.
  315.  */
  316. void
  317. _mesa_destroy_visual( struct gl_config *vis )
  318. {
  319.    free(vis);
  320. }
  321.  
  322. /*@}*/
  323.  
  324.  
  325. /**********************************************************************/
  326. /** \name Context allocation, initialization, destroying
  327.  *
  328.  * The purpose of the most initialization functions here is to provide the
  329.  * default state values according to the OpenGL specification.
  330.  */
  331. /**********************************************************************/
  332. /*@{*/
  333.  
  334.  
  335. /**
  336.  * This is lame.  gdb only seems to recognize enum types that are
  337.  * actually used somewhere.  We want to be able to print/use enum
  338.  * values such as TEXTURE_2D_INDEX in gdb.  But we don't actually use
  339.  * the gl_texture_index type anywhere.  Thus, this lame function.
  340.  */
  341. static void
  342. dummy_enum_func(void)
  343. {
  344.    gl_buffer_index bi = BUFFER_FRONT_LEFT;
  345.    gl_face_index fi = FACE_POS_X;
  346.    gl_frag_attrib fa = FRAG_ATTRIB_WPOS;
  347.    gl_frag_result fr = FRAG_RESULT_DEPTH;
  348.    gl_texture_index ti = TEXTURE_2D_ARRAY_INDEX;
  349.    gl_vert_attrib va = VERT_ATTRIB_POS;
  350.    gl_vert_result vr = VERT_RESULT_HPOS;
  351.    gl_geom_attrib ga = GEOM_ATTRIB_POSITION;
  352.    gl_geom_result gr = GEOM_RESULT_POS;
  353.  
  354.    (void) bi;
  355.    (void) fi;
  356.    (void) fa;
  357.    (void) fr;
  358.    (void) ti;
  359.    (void) va;
  360.    (void) vr;
  361.    (void) ga;
  362.    (void) gr;
  363. }
  364.  
  365.  
  366. /**
  367.  * One-time initialization mutex lock.
  368.  *
  369.  * \sa Used by one_time_init().
  370.  */
  371. _glthread_DECLARE_STATIC_MUTEX(OneTimeLock);
  372.  
  373.  
  374.  
  375. /**
  376.  * Calls all the various one-time-init functions in Mesa.
  377.  *
  378.  * While holding a global mutex lock, calls several initialization functions,
  379.  * and sets the glapi callbacks if the \c MESA_DEBUG environment variable is
  380.  * defined.
  381.  *
  382.  * \sa _math_init().
  383.  */
  384. static void
  385. one_time_init( struct gl_context *ctx )
  386. {
  387.    static GLbitfield api_init_mask = 0x0;
  388.  
  389.    _glthread_LOCK_MUTEX(OneTimeLock);
  390.  
  391.    /* truly one-time init */
  392.    if (!api_init_mask) {
  393.       GLuint i;
  394.  
  395.       /* do some implementation tests */
  396.       assert( sizeof(GLbyte) == 1 );
  397.       assert( sizeof(GLubyte) == 1 );
  398.       assert( sizeof(GLshort) == 2 );
  399.       assert( sizeof(GLushort) == 2 );
  400.       assert( sizeof(GLint) == 4 );
  401.       assert( sizeof(GLuint) == 4 );
  402.  
  403.       _mesa_get_cpu_features();
  404.  
  405.       _mesa_init_sqrt_table();
  406.  
  407.       /* context dependence is never a one-time thing... */
  408.       _mesa_init_get_hash(ctx);
  409.  
  410.       for (i = 0; i < 256; i++) {
  411.          _mesa_ubyte_to_float_color_tab[i] = (float) i / 255.0F;
  412.       }
  413.  
  414. #if defined(DEBUG) && defined(__DATE__) && defined(__TIME__)
  415.       if (MESA_VERBOSE != 0) {
  416.          _mesa_debug(ctx, "Mesa %s DEBUG build %s %s\n",
  417.                      MESA_VERSION_STRING, __DATE__, __TIME__);
  418.       }
  419. #endif
  420.    }
  421.  
  422.    /* per-API one-time init */
  423.    if (!(api_init_mask & (1 << ctx->API))) {
  424.       /*
  425.        * This is fine as ES does not use the remap table, but it may not be
  426.        * future-proof.  We cannot always initialize the remap table because
  427.        * when an app is linked to libGLES*, there are not enough dynamic
  428.        * entries.
  429.        */
  430.       if (ctx->API == API_OPENGL)
  431.          _mesa_init_remap_table();
  432.    }
  433.  
  434.    api_init_mask |= 1 << ctx->API;
  435.  
  436.    _glthread_UNLOCK_MUTEX(OneTimeLock);
  437.  
  438.    /* Hopefully atexit() is widely available.  If not, we may need some
  439.     * #ifdef tests here.
  440.     */
  441.    atexit(_mesa_destroy_shader_compiler);
  442.  
  443.    dummy_enum_func();
  444. }
  445.  
  446.  
  447. /**
  448.  * Initialize fields of gl_current_attrib (aka ctx->Current.*)
  449.  */
  450. static void
  451. _mesa_init_current(struct gl_context *ctx)
  452. {
  453.    GLuint i;
  454.  
  455.    /* Init all to (0,0,0,1) */
  456.    for (i = 0; i < Elements(ctx->Current.Attrib); i++) {
  457.       ASSIGN_4V( ctx->Current.Attrib[i], 0.0, 0.0, 0.0, 1.0 );
  458.    }
  459.  
  460.    /* redo special cases: */
  461.    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_WEIGHT], 1.0, 0.0, 0.0, 0.0 );
  462.    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_NORMAL], 0.0, 0.0, 1.0, 1.0 );
  463.    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR0], 1.0, 1.0, 1.0, 1.0 );
  464.    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR1], 0.0, 0.0, 0.0, 1.0 );
  465.    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_COLOR_INDEX], 1.0, 0.0, 0.0, 1.0 );
  466.    ASSIGN_4V( ctx->Current.Attrib[VERT_ATTRIB_EDGEFLAG], 1.0, 0.0, 0.0, 1.0 );
  467. }
  468.  
  469.  
  470. /**
  471.  * Init vertex/fragment/geometry program limits.
  472.  * Important: drivers should override these with actual limits.
  473.  */
  474. static void
  475. init_program_limits(GLenum type, struct gl_program_constants *prog)
  476. {
  477.    prog->MaxInstructions = MAX_PROGRAM_INSTRUCTIONS;
  478.    prog->MaxAluInstructions = MAX_PROGRAM_INSTRUCTIONS;
  479.    prog->MaxTexInstructions = MAX_PROGRAM_INSTRUCTIONS;
  480.    prog->MaxTexIndirections = MAX_PROGRAM_INSTRUCTIONS;
  481.    prog->MaxTemps = MAX_PROGRAM_TEMPS;
  482.    prog->MaxEnvParams = MAX_PROGRAM_ENV_PARAMS;
  483.    prog->MaxLocalParams = MAX_PROGRAM_LOCAL_PARAMS;
  484.    prog->MaxUniformComponents = 4 * MAX_UNIFORMS;
  485.  
  486.    switch (type) {
  487.    case GL_VERTEX_PROGRAM_ARB:
  488.       prog->MaxParameters = MAX_VERTEX_PROGRAM_PARAMS;
  489.       prog->MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
  490.       prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
  491.       break;
  492.    case GL_FRAGMENT_PROGRAM_ARB:
  493.       prog->MaxParameters = MAX_NV_FRAGMENT_PROGRAM_PARAMS;
  494.       prog->MaxAttribs = MAX_NV_FRAGMENT_PROGRAM_INPUTS;
  495.       prog->MaxAddressRegs = MAX_FRAGMENT_PROGRAM_ADDRESS_REGS;
  496.       break;
  497.    case MESA_GEOMETRY_PROGRAM:
  498.       prog->MaxParameters = MAX_NV_VERTEX_PROGRAM_PARAMS;
  499.       prog->MaxAttribs = MAX_NV_VERTEX_PROGRAM_INPUTS;
  500.       prog->MaxAddressRegs = MAX_VERTEX_PROGRAM_ADDRESS_REGS;
  501.  
  502.       prog->MaxGeometryTextureImageUnits = MAX_GEOMETRY_TEXTURE_IMAGE_UNITS;
  503.       prog->MaxGeometryVaryingComponents = MAX_GEOMETRY_VARYING_COMPONENTS;
  504.       prog->MaxVertexVaryingComponents = MAX_VERTEX_VARYING_COMPONENTS;
  505.       prog->MaxGeometryUniformComponents = MAX_GEOMETRY_UNIFORM_COMPONENTS;
  506.       prog->MaxGeometryOutputVertices = MAX_GEOMETRY_OUTPUT_VERTICES;
  507.       prog->MaxGeometryTotalOutputComponents = MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS;
  508.       break;
  509.    default:
  510.       assert(0 && "Bad program type in init_program_limits()");
  511.    }
  512.  
  513.    /* Set the native limits to zero.  This implies that there is no native
  514.     * support for shaders.  Let the drivers fill in the actual values.
  515.     */
  516.    prog->MaxNativeInstructions = 0;
  517.    prog->MaxNativeAluInstructions = 0;
  518.    prog->MaxNativeTexInstructions = 0;
  519.    prog->MaxNativeTexIndirections = 0;
  520.    prog->MaxNativeAttribs = 0;
  521.    prog->MaxNativeTemps = 0;
  522.    prog->MaxNativeAddressRegs = 0;
  523.    prog->MaxNativeParameters = 0;
  524.  
  525.    /* Set GLSL datatype range/precision info assuming IEEE float values.
  526.     * Drivers should override these defaults as needed.
  527.     */
  528.    prog->MediumFloat.RangeMin = 127;
  529.    prog->MediumFloat.RangeMax = 127;
  530.    prog->MediumFloat.Precision = 23;
  531.    prog->LowFloat = prog->HighFloat = prog->MediumFloat;
  532.    /* assume ints are stored as floats for now */
  533.    prog->LowInt = prog->MediumInt = prog->HighInt = prog->MediumFloat;
  534. }
  535.  
  536.  
  537. /**
  538.  * Initialize fields of gl_constants (aka ctx->Const.*).
  539.  * Use defaults from config.h.  The device drivers will often override
  540.  * some of these values (such as number of texture units).
  541.  */
  542. static void
  543. _mesa_init_constants(struct gl_context *ctx)
  544. {
  545.    assert(ctx);
  546.  
  547.    /* Constants, may be overriden (usually only reduced) by device drivers */
  548.    ctx->Const.MaxTextureMbytes = MAX_TEXTURE_MBYTES;
  549.    ctx->Const.MaxTextureLevels = MAX_TEXTURE_LEVELS;
  550.    ctx->Const.Max3DTextureLevels = MAX_3D_TEXTURE_LEVELS;
  551.    ctx->Const.MaxCubeTextureLevels = MAX_CUBE_TEXTURE_LEVELS;
  552.    ctx->Const.MaxTextureRectSize = MAX_TEXTURE_RECT_SIZE;
  553.    ctx->Const.MaxArrayTextureLayers = MAX_ARRAY_TEXTURE_LAYERS;
  554.    ctx->Const.MaxTextureCoordUnits = MAX_TEXTURE_COORD_UNITS;
  555.    ctx->Const.MaxTextureImageUnits = MAX_TEXTURE_IMAGE_UNITS;
  556.    ctx->Const.MaxTextureUnits = MIN2(ctx->Const.MaxTextureCoordUnits,
  557.                                      ctx->Const.MaxTextureImageUnits);
  558.    ctx->Const.MaxTextureMaxAnisotropy = MAX_TEXTURE_MAX_ANISOTROPY;
  559.    ctx->Const.MaxTextureLodBias = MAX_TEXTURE_LOD_BIAS;
  560.    ctx->Const.MaxArrayLockSize = MAX_ARRAY_LOCK_SIZE;
  561.    ctx->Const.SubPixelBits = SUB_PIXEL_BITS;
  562.    ctx->Const.MinPointSize = MIN_POINT_SIZE;
  563.    ctx->Const.MaxPointSize = MAX_POINT_SIZE;
  564.    ctx->Const.MinPointSizeAA = MIN_POINT_SIZE;
  565.    ctx->Const.MaxPointSizeAA = MAX_POINT_SIZE;
  566.    ctx->Const.PointSizeGranularity = (GLfloat) POINT_SIZE_GRANULARITY;
  567.    ctx->Const.MinLineWidth = MIN_LINE_WIDTH;
  568.    ctx->Const.MaxLineWidth = MAX_LINE_WIDTH;
  569.    ctx->Const.MinLineWidthAA = MIN_LINE_WIDTH;
  570.    ctx->Const.MaxLineWidthAA = MAX_LINE_WIDTH;
  571.    ctx->Const.LineWidthGranularity = (GLfloat) LINE_WIDTH_GRANULARITY;
  572.    ctx->Const.MaxColorTableSize = MAX_COLOR_TABLE_SIZE;
  573.    ctx->Const.MaxClipPlanes = MAX_CLIP_PLANES;
  574.    ctx->Const.MaxLights = MAX_LIGHTS;
  575.    ctx->Const.MaxShininess = 128.0;
  576.    ctx->Const.MaxSpotExponent = 128.0;
  577.    ctx->Const.MaxViewportWidth = MAX_WIDTH;
  578.    ctx->Const.MaxViewportHeight = MAX_HEIGHT;
  579. #if FEATURE_ARB_vertex_program
  580.    init_program_limits(GL_VERTEX_PROGRAM_ARB, &ctx->Const.VertexProgram);
  581. #endif
  582. #if FEATURE_ARB_fragment_program
  583.    init_program_limits(GL_FRAGMENT_PROGRAM_ARB, &ctx->Const.FragmentProgram);
  584. #endif
  585. #if FEATURE_ARB_geometry_shader4
  586.    init_program_limits(MESA_GEOMETRY_PROGRAM, &ctx->Const.GeometryProgram);
  587. #endif
  588.    ctx->Const.MaxProgramMatrices = MAX_PROGRAM_MATRICES;
  589.    ctx->Const.MaxProgramMatrixStackDepth = MAX_PROGRAM_MATRIX_STACK_DEPTH;
  590.  
  591.    /* CheckArrayBounds is overriden by drivers/x11 for X server */
  592.    ctx->Const.CheckArrayBounds = GL_FALSE;
  593.  
  594.    /* GL_ARB_draw_buffers */
  595.    ctx->Const.MaxDrawBuffers = MAX_DRAW_BUFFERS;
  596.  
  597. #if FEATURE_EXT_framebuffer_object
  598.    ctx->Const.MaxColorAttachments = MAX_COLOR_ATTACHMENTS;
  599.    ctx->Const.MaxRenderbufferSize = MAX_WIDTH;
  600. #endif
  601.  
  602. #if FEATURE_ARB_vertex_shader
  603.    ctx->Const.MaxVertexTextureImageUnits = MAX_VERTEX_TEXTURE_IMAGE_UNITS;
  604.    ctx->Const.MaxCombinedTextureImageUnits = MAX_COMBINED_TEXTURE_IMAGE_UNITS;
  605.    ctx->Const.MaxVarying = MAX_VARYING;
  606. #endif
  607.  
  608.    /* Shading language version */
  609.    if (ctx->API == API_OPENGL) {
  610.       ctx->Const.GLSLVersion = 120;
  611.    }
  612.    else if (ctx->API == API_OPENGLES2) {
  613.       ctx->Const.GLSLVersion = 100;
  614.    }
  615.    else if (ctx->API == API_OPENGLES) {
  616.       ctx->Const.GLSLVersion = 0; /* GLSL not supported */
  617.    }
  618.  
  619.    /* GL_ARB_framebuffer_object */
  620.    ctx->Const.MaxSamples = 0;
  621.  
  622.    /* GL_ARB_sync */
  623.    ctx->Const.MaxServerWaitTimeout = (GLuint64) ~0;
  624.  
  625.    /* GL_ATI_envmap_bumpmap */
  626.    ctx->Const.SupportedBumpUnits = SUPPORTED_ATI_BUMP_UNITS;
  627.  
  628.    /* GL_EXT_provoking_vertex */
  629.    ctx->Const.QuadsFollowProvokingVertexConvention = GL_TRUE;
  630.  
  631.    /* GL_EXT_transform_feedback */
  632.    ctx->Const.MaxTransformFeedbackSeparateAttribs = MAX_FEEDBACK_ATTRIBS;
  633.    ctx->Const.MaxTransformFeedbackSeparateComponents = 4 * MAX_FEEDBACK_ATTRIBS;
  634.    ctx->Const.MaxTransformFeedbackInterleavedComponents = 4 * MAX_FEEDBACK_ATTRIBS;
  635.  
  636.    /* GL 3.2: hard-coded for now: */
  637.    ctx->Const.ProfileMask = GL_CONTEXT_COMPATIBILITY_PROFILE_BIT;
  638.  
  639.    /** GL_EXT_gpu_shader4 */
  640.    ctx->Const.MinProgramTexelOffset = -8;
  641.    ctx->Const.MaxProgramTexelOffset = 7;
  642. }
  643.  
  644.  
  645. /**
  646.  * Do some sanity checks on the limits/constants for the given context.
  647.  * Only called the first time a context is bound.
  648.  */
  649. static void
  650. check_context_limits(struct gl_context *ctx)
  651. {
  652.    /* check that we don't exceed the size of various bitfields */
  653.    assert(VERT_RESULT_MAX <=
  654.           (8 * sizeof(ctx->VertexProgram._Current->Base.OutputsWritten)));
  655.    assert(FRAG_ATTRIB_MAX <=
  656.           (8 * sizeof(ctx->FragmentProgram._Current->Base.InputsRead)));
  657.  
  658.    assert(MAX_COMBINED_TEXTURE_IMAGE_UNITS <= 8 * sizeof(GLbitfield));
  659.  
  660.    /* shader-related checks */
  661.    assert(ctx->Const.FragmentProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
  662.    assert(ctx->Const.VertexProgram.MaxLocalParams <= MAX_PROGRAM_LOCAL_PARAMS);
  663.  
  664.    assert(MAX_NV_FRAGMENT_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
  665.    assert(MAX_NV_VERTEX_PROGRAM_TEMPS <= MAX_PROGRAM_TEMPS);
  666.    assert(MAX_NV_VERTEX_PROGRAM_INPUTS <= VERT_ATTRIB_MAX);
  667.    assert(MAX_NV_VERTEX_PROGRAM_OUTPUTS <= VERT_RESULT_MAX);
  668.  
  669.    /* Texture unit checks */
  670.    assert(ctx->Const.MaxTextureImageUnits > 0);
  671.    assert(ctx->Const.MaxTextureImageUnits <= MAX_TEXTURE_IMAGE_UNITS);
  672.    assert(ctx->Const.MaxTextureCoordUnits > 0);
  673.    assert(ctx->Const.MaxTextureCoordUnits <= MAX_TEXTURE_COORD_UNITS);
  674.    assert(ctx->Const.MaxTextureUnits > 0);
  675.    assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_IMAGE_UNITS);
  676.    assert(ctx->Const.MaxTextureUnits <= MAX_TEXTURE_COORD_UNITS);
  677.    assert(ctx->Const.MaxTextureUnits == MIN2(ctx->Const.MaxTextureImageUnits,
  678.                                              ctx->Const.MaxTextureCoordUnits));
  679.    assert(ctx->Const.MaxCombinedTextureImageUnits > 0);
  680.    assert(ctx->Const.MaxCombinedTextureImageUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
  681.    assert(ctx->Const.MaxTextureCoordUnits <= MAX_COMBINED_TEXTURE_IMAGE_UNITS);
  682.    /* number of coord units cannot be greater than number of image units */
  683.    assert(ctx->Const.MaxTextureCoordUnits <= ctx->Const.MaxTextureImageUnits);
  684.  
  685.  
  686.    /* Texture size checks */
  687.    assert(ctx->Const.MaxTextureLevels <= MAX_TEXTURE_LEVELS);
  688.    assert(ctx->Const.Max3DTextureLevels <= MAX_3D_TEXTURE_LEVELS);
  689.    assert(ctx->Const.MaxCubeTextureLevels <= MAX_CUBE_TEXTURE_LEVELS);
  690.    assert(ctx->Const.MaxTextureRectSize <= MAX_TEXTURE_RECT_SIZE);
  691.  
  692.    /* make sure largest texture image is <= MAX_WIDTH in size */
  693.    assert((1 << (ctx->Const.MaxTextureLevels - 1)) <= MAX_WIDTH);
  694.    assert((1 << (ctx->Const.MaxCubeTextureLevels - 1)) <= MAX_WIDTH);
  695.    assert((1 << (ctx->Const.Max3DTextureLevels - 1)) <= MAX_WIDTH);
  696.  
  697.    /* Texture level checks */
  698.    assert(MAX_TEXTURE_LEVELS >= MAX_3D_TEXTURE_LEVELS);
  699.    assert(MAX_TEXTURE_LEVELS >= MAX_CUBE_TEXTURE_LEVELS);
  700.  
  701.    /* Max texture size should be <= max viewport size (render to texture) */
  702.    assert((1 << (MAX_TEXTURE_LEVELS - 1)) <= MAX_WIDTH);
  703.  
  704.    assert(ctx->Const.MaxViewportWidth <= MAX_WIDTH);
  705.    assert(ctx->Const.MaxViewportHeight <= MAX_WIDTH);
  706.  
  707.    assert(ctx->Const.MaxDrawBuffers <= MAX_DRAW_BUFFERS);
  708.  
  709.    /* if this fails, add more enum values to gl_buffer_index */
  710.    assert(BUFFER_COLOR0 + MAX_DRAW_BUFFERS <= BUFFER_COUNT);
  711.  
  712.    /* XXX probably add more tests */
  713. }
  714.  
  715.  
  716. /**
  717.  * Initialize the attribute groups in a GL context.
  718.  *
  719.  * \param ctx GL context.
  720.  *
  721.  * Initializes all the attributes, calling the respective <tt>init*</tt>
  722.  * functions for the more complex data structures.
  723.  */
  724. static GLboolean
  725. init_attrib_groups(struct gl_context *ctx)
  726. {
  727.    assert(ctx);
  728.  
  729.    /* Constants */
  730.    _mesa_init_constants( ctx );
  731.  
  732.    /* Extensions */
  733.    _mesa_init_extensions( ctx );
  734.  
  735.    /* Attribute Groups */
  736.    _mesa_init_accum( ctx );
  737.    _mesa_init_attrib( ctx );
  738.    _mesa_init_buffer_objects( ctx );
  739.    _mesa_init_color( ctx );
  740.    _mesa_init_current( ctx );
  741.    _mesa_init_depth( ctx );
  742.    _mesa_init_debug( ctx );
  743.    _mesa_init_display_list( ctx );
  744.    _mesa_init_eval( ctx );
  745.    _mesa_init_fbobjects( ctx );
  746.    _mesa_init_feedback( ctx );
  747.    _mesa_init_fog( ctx );
  748.    _mesa_init_hint( ctx );
  749.    _mesa_init_line( ctx );
  750.    _mesa_init_lighting( ctx );
  751.    _mesa_init_matrix( ctx );
  752.    _mesa_init_multisample( ctx );
  753.    _mesa_init_pixel( ctx );
  754.    _mesa_init_pixelstore( ctx );
  755.    _mesa_init_point( ctx );
  756.    _mesa_init_polygon( ctx );
  757.    _mesa_init_program( ctx );
  758.    _mesa_init_queryobj( ctx );
  759.    _mesa_init_sync( ctx );
  760.    _mesa_init_rastpos( ctx );
  761.    _mesa_init_scissor( ctx );
  762.    _mesa_init_shader_state( ctx );
  763.    _mesa_init_stencil( ctx );
  764.    _mesa_init_transform( ctx );
  765.    _mesa_init_transform_feedback( ctx );
  766.    _mesa_init_varray( ctx );
  767.    _mesa_init_viewport( ctx );
  768.  
  769.    if (!_mesa_init_texture( ctx ))
  770.       return GL_FALSE;
  771.  
  772.    _mesa_init_texture_s3tc( ctx );
  773.  
  774.    /* Miscellaneous */
  775.    ctx->NewState = _NEW_ALL;
  776.    ctx->ErrorValue = (GLenum) GL_NO_ERROR;
  777.    ctx->varying_vp_inputs = ~0;
  778.  
  779.    return GL_TRUE;
  780. }
  781.  
  782.  
  783. /**
  784.  * Update default objects in a GL context with respect to shared state.
  785.  *
  786.  * \param ctx GL context.
  787.  *
  788.  * Removes references to old default objects, (texture objects, program
  789.  * objects, etc.) and changes to reference those from the current shared
  790.  * state.
  791.  */
  792. static GLboolean
  793. update_default_objects(struct gl_context *ctx)
  794. {
  795.    assert(ctx);
  796.  
  797.    _mesa_update_default_objects_program(ctx);
  798.    _mesa_update_default_objects_texture(ctx);
  799.    _mesa_update_default_objects_buffer_objects(ctx);
  800.  
  801.    return GL_TRUE;
  802. }
  803.  
  804.  
  805. /**
  806.  * This is the default function we plug into all dispatch table slots
  807.  * This helps prevents a segfault when someone calls a GL function without
  808.  * first checking if the extension's supported.
  809.  */
  810. static int
  811. generic_nop(void)
  812. {
  813.    _mesa_warning(NULL, "User called no-op dispatch function (an unsupported extension function?)");
  814.    return 0;
  815. }
  816.  
  817.  
  818. /**
  819.  * Allocate and initialize a new dispatch table.
  820.  */
  821. struct _glapi_table *
  822. _mesa_alloc_dispatch_table(int size)
  823. {
  824.    /* Find the larger of Mesa's dispatch table and libGL's dispatch table.
  825.     * In practice, this'll be the same for stand-alone Mesa.  But for DRI
  826.     * Mesa we do this to accomodate different versions of libGL and various
  827.     * DRI drivers.
  828.     */
  829.    GLint numEntries = MAX2(_glapi_get_dispatch_table_size(), _gloffset_COUNT);
  830.    struct _glapi_table *table;
  831.  
  832.    /* should never happen, but just in case */
  833.    numEntries = MAX2(numEntries, size);
  834.  
  835.    table = (struct _glapi_table *) malloc(numEntries * sizeof(_glapi_proc));
  836.    if (table) {
  837.       _glapi_proc *entry = (_glapi_proc *) table;
  838.       GLint i;
  839.       for (i = 0; i < numEntries; i++) {
  840.          entry[i] = (_glapi_proc) generic_nop;
  841.       }
  842.    }
  843.    return table;
  844. }
  845.  
  846.  
  847. /**
  848.  * Initialize a struct gl_context struct (rendering context).
  849.  *
  850.  * This includes allocating all the other structs and arrays which hang off of
  851.  * the context by pointers.
  852.  * Note that the driver needs to pass in its dd_function_table here since
  853.  * we need to at least call driverFunctions->NewTextureObject to create the
  854.  * default texture objects.
  855.  *
  856.  * Called by _mesa_create_context().
  857.  *
  858.  * Performs the imports and exports callback tables initialization, and
  859.  * miscellaneous one-time initializations. If no shared context is supplied one
  860.  * is allocated, and increase its reference count.  Setups the GL API dispatch
  861.  * tables.  Initialize the TNL module. Sets the maximum Z buffer depth.
  862.  * Finally queries the \c MESA_DEBUG and \c MESA_VERBOSE environment variables
  863.  * for debug flags.
  864.  *
  865.  * \param ctx the context to initialize
  866.  * \param api the GL API type to create the context for
  867.  * \param visual describes the visual attributes for this context
  868.  * \param share_list points to context to share textures, display lists,
  869.  *        etc with, or NULL
  870.  * \param driverFunctions table of device driver functions for this context
  871.  *        to use
  872.  * \param driverContext pointer to driver-specific context data
  873.  */
  874. GLboolean
  875. _mesa_initialize_context_for_api(struct gl_context *ctx,
  876.                                  gl_api api,
  877.                                  const struct gl_config *visual,
  878.                                  struct gl_context *share_list,
  879.                                  const struct dd_function_table *driverFunctions,
  880.                                  void *driverContext)
  881. {
  882.    struct gl_shared_state *shared;
  883.    int i;
  884.  
  885.    /*ASSERT(driverContext);*/
  886.    assert(driverFunctions->NewTextureObject);
  887.    assert(driverFunctions->FreeTexImageData);
  888.  
  889.    ctx->API = api;
  890.    ctx->Visual = *visual;
  891.    ctx->DrawBuffer = NULL;
  892.    ctx->ReadBuffer = NULL;
  893.    ctx->WinSysDrawBuffer = NULL;
  894.    ctx->WinSysReadBuffer = NULL;
  895.  
  896.    /* misc one-time initializations */
  897.    one_time_init(ctx);
  898.  
  899.    /* Plug in driver functions and context pointer here.
  900.     * This is important because when we call alloc_shared_state() below
  901.     * we'll call ctx->Driver.NewTextureObject() to create the default
  902.     * textures.
  903.     */
  904.    ctx->Driver = *driverFunctions;
  905.    ctx->DriverCtx = driverContext;
  906.  
  907.    if (share_list) {
  908.       /* share state with another context */
  909.       shared = share_list->Shared;
  910.    }
  911.    else {
  912.       /* allocate new, unshared state */
  913.       shared = _mesa_alloc_shared_state(ctx);
  914.       if (!shared)
  915.          return GL_FALSE;
  916.    }
  917.  
  918.    _glthread_LOCK_MUTEX(shared->Mutex);
  919.    ctx->Shared = shared;
  920.    shared->RefCount++;
  921.    _glthread_UNLOCK_MUTEX(shared->Mutex);
  922.  
  923.    if (!init_attrib_groups( ctx )) {
  924.       _mesa_release_shared_state(ctx, ctx->Shared);
  925.       return GL_FALSE;
  926.    }
  927.  
  928. #if FEATURE_dispatch
  929.    /* setup the API dispatch tables */
  930.    switch (ctx->API) {
  931. #if FEATURE_GL
  932.    case API_OPENGL:
  933.       ctx->Exec = _mesa_create_exec_table();
  934.       break;
  935. #endif
  936. #if FEATURE_ES1
  937.    case API_OPENGLES:
  938.       ctx->Exec = _mesa_create_exec_table_es1();
  939.       break;
  940. #endif
  941. #if FEATURE_ES2
  942.    case API_OPENGLES2:
  943.       ctx->Exec = _mesa_create_exec_table_es2();
  944.       break;
  945. #endif
  946.    default:
  947.       _mesa_problem(ctx, "unknown or unsupported API");
  948.       break;
  949.    }
  950.  
  951.    if (!ctx->Exec) {
  952.       _mesa_release_shared_state(ctx, ctx->Shared);
  953.       return GL_FALSE;
  954.    }
  955. #endif
  956.    ctx->CurrentDispatch = ctx->Exec;
  957.  
  958.    ctx->FragmentProgram._MaintainTexEnvProgram
  959.       = (_mesa_getenv("MESA_TEX_PROG") != NULL);
  960.  
  961.    ctx->VertexProgram._MaintainTnlProgram
  962.       = (_mesa_getenv("MESA_TNL_PROG") != NULL);
  963.    if (ctx->VertexProgram._MaintainTnlProgram) {
  964.       /* this is required... */
  965.       ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
  966.    }
  967.  
  968.    switch (ctx->API) {
  969.    case API_OPENGL:
  970. #if FEATURE_dlist
  971.       ctx->Save = _mesa_create_save_table();
  972.       if (!ctx->Save) {
  973.          _mesa_release_shared_state(ctx, ctx->Shared);
  974.          free(ctx->Exec);
  975.          return GL_FALSE;
  976.       }
  977.  
  978.       _mesa_install_save_vtxfmt( ctx, &ctx->ListState.ListVtxfmt );
  979. #endif
  980.       break;
  981.    case API_OPENGLES:
  982.       /**
  983.        * GL_OES_texture_cube_map says
  984.        * "Initially all texture generation modes are set to REFLECTION_MAP_OES"
  985.        */
  986.       for (i = 0; i < MAX_TEXTURE_UNITS; i++) {
  987.          struct gl_texture_unit *texUnit = &ctx->Texture.Unit[i];
  988.          texUnit->GenS.Mode = GL_REFLECTION_MAP_NV;
  989.          texUnit->GenT.Mode = GL_REFLECTION_MAP_NV;
  990.          texUnit->GenR.Mode = GL_REFLECTION_MAP_NV;
  991.          texUnit->GenS._ModeBit = TEXGEN_REFLECTION_MAP_NV;
  992.          texUnit->GenT._ModeBit = TEXGEN_REFLECTION_MAP_NV;
  993.          texUnit->GenR._ModeBit = TEXGEN_REFLECTION_MAP_NV;
  994.       }
  995.       break;
  996.    case API_OPENGLES2:
  997.       ctx->FragmentProgram._MaintainTexEnvProgram = GL_TRUE;
  998.       ctx->VertexProgram._MaintainTnlProgram = GL_TRUE;
  999.       ctx->Point.PointSprite = GL_TRUE;  /* always on for ES 2.x */
  1000.       break;
  1001.    }
  1002.  
  1003.    ctx->FirstTimeCurrent = GL_TRUE;
  1004.  
  1005.    return GL_TRUE;
  1006. }
  1007.  
  1008.  
  1009. /**
  1010.  * Initialize an OpenGL context.
  1011.  */
  1012. GLboolean
  1013. _mesa_initialize_context(struct gl_context *ctx,
  1014.                          const struct gl_config *visual,
  1015.                          struct gl_context *share_list,
  1016.                          const struct dd_function_table *driverFunctions,
  1017.                          void *driverContext)
  1018. {
  1019.    return _mesa_initialize_context_for_api(ctx,
  1020.                                            API_OPENGL,
  1021.                                            visual,
  1022.                                            share_list,
  1023.                                            driverFunctions,
  1024.                                            driverContext);
  1025. }
  1026.  
  1027.  
  1028. /**
  1029.  * Allocate and initialize a struct gl_context structure.
  1030.  * Note that the driver needs to pass in its dd_function_table here since
  1031.  * we need to at least call driverFunctions->NewTextureObject to initialize
  1032.  * the rendering context.
  1033.  *
  1034.  * \param api the GL API type to create the context for
  1035.  * \param visual a struct gl_config pointer (we copy the struct contents)
  1036.  * \param share_list another context to share display lists with or NULL
  1037.  * \param driverFunctions points to the dd_function_table into which the
  1038.  *        driver has plugged in all its special functions.
  1039.  * \param driverContext points to the device driver's private context state
  1040.  *
  1041.  * \return pointer to a new __struct gl_contextRec or NULL if error.
  1042.  */
  1043. struct gl_context *
  1044. _mesa_create_context_for_api(gl_api api,
  1045.                              const struct gl_config *visual,
  1046.                              struct gl_context *share_list,
  1047.                              const struct dd_function_table *driverFunctions,
  1048.                              void *driverContext)
  1049. {
  1050.    struct gl_context *ctx;
  1051.  
  1052.    ASSERT(visual);
  1053.    /*ASSERT(driverContext);*/
  1054.  
  1055.    ctx = (struct gl_context *) calloc(1, sizeof(struct gl_context));
  1056.    if (!ctx)
  1057.       return NULL;
  1058.  
  1059.    if (_mesa_initialize_context_for_api(ctx, api, visual, share_list,
  1060.                                         driverFunctions, driverContext)) {
  1061.       return ctx;
  1062.    }
  1063.    else {
  1064.       free(ctx);
  1065.       return NULL;
  1066.    }
  1067. }
  1068.  
  1069.  
  1070. /**
  1071.  * Create an OpenGL context.
  1072.  */
  1073. struct gl_context *
  1074. _mesa_create_context(const struct gl_config *visual,
  1075.                      struct gl_context *share_list,
  1076.                      const struct dd_function_table *driverFunctions,
  1077.                      void *driverContext)
  1078. {
  1079.    return _mesa_create_context_for_api(API_OPENGL, visual,
  1080.                                        share_list,
  1081.                                        driverFunctions,
  1082.                                        driverContext);
  1083. }
  1084.  
  1085.  
  1086. /**
  1087.  * Free the data associated with the given context.
  1088.  *
  1089.  * But doesn't free the struct gl_context struct itself.
  1090.  *
  1091.  * \sa _mesa_initialize_context() and init_attrib_groups().
  1092.  */
  1093. void
  1094. _mesa_free_context_data( struct gl_context *ctx )
  1095. {
  1096.    if (!_mesa_get_current_context()){
  1097.       /* No current context, but we may need one in order to delete
  1098.        * texture objs, etc.  So temporarily bind the context now.
  1099.        */
  1100.       _mesa_make_current(ctx, NULL, NULL);
  1101.    }
  1102.  
  1103.    /* unreference WinSysDraw/Read buffers */
  1104.    _mesa_reference_framebuffer(&ctx->WinSysDrawBuffer, NULL);
  1105.    _mesa_reference_framebuffer(&ctx->WinSysReadBuffer, NULL);
  1106.    _mesa_reference_framebuffer(&ctx->DrawBuffer, NULL);
  1107.    _mesa_reference_framebuffer(&ctx->ReadBuffer, NULL);
  1108.  
  1109.    _mesa_reference_vertprog(ctx, &ctx->VertexProgram.Current, NULL);
  1110.    _mesa_reference_vertprog(ctx, &ctx->VertexProgram._Current, NULL);
  1111.    _mesa_reference_vertprog(ctx, &ctx->VertexProgram._TnlProgram, NULL);
  1112.  
  1113.    _mesa_reference_fragprog(ctx, &ctx->FragmentProgram.Current, NULL);
  1114.    _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._Current, NULL);
  1115.    _mesa_reference_fragprog(ctx, &ctx->FragmentProgram._TexEnvProgram, NULL);
  1116.  
  1117.    _mesa_free_attrib_data(ctx);
  1118.    _mesa_free_buffer_objects(ctx);
  1119.    _mesa_free_lighting_data( ctx );
  1120.    _mesa_free_eval_data( ctx );
  1121.    _mesa_free_texture_data( ctx );
  1122.    _mesa_free_matrix_data( ctx );
  1123.    _mesa_free_viewport_data( ctx );
  1124.    _mesa_free_program_data(ctx);
  1125.    _mesa_free_shader_state(ctx);
  1126.    _mesa_free_queryobj_data(ctx);
  1127.    _mesa_free_sync_data(ctx);
  1128.    _mesa_free_varray_data(ctx);
  1129.    _mesa_free_transform_feedback(ctx);
  1130.  
  1131.    _mesa_delete_array_object(ctx, ctx->Array.DefaultArrayObj);
  1132.  
  1133. #if FEATURE_ARB_pixel_buffer_object
  1134.    _mesa_reference_buffer_object(ctx, &ctx->Pack.BufferObj, NULL);
  1135.    _mesa_reference_buffer_object(ctx, &ctx->Unpack.BufferObj, NULL);
  1136.    _mesa_reference_buffer_object(ctx, &ctx->DefaultPacking.BufferObj, NULL);
  1137. #endif
  1138.  
  1139. #if FEATURE_ARB_vertex_buffer_object
  1140.    _mesa_reference_buffer_object(ctx, &ctx->Array.ArrayBufferObj, NULL);
  1141.    _mesa_reference_buffer_object(ctx, &ctx->Array.ElementArrayBufferObj, NULL);
  1142. #endif
  1143.  
  1144.    /* free dispatch tables */
  1145.    free(ctx->Exec);
  1146.    free(ctx->Save);
  1147.  
  1148.    /* Shared context state (display lists, textures, etc) */
  1149.    _mesa_release_shared_state( ctx, ctx->Shared );
  1150.  
  1151.    /* needs to be after freeing shared state */
  1152.    _mesa_free_display_list_data(ctx);
  1153.  
  1154.    if (ctx->Extensions.String)
  1155.       free((void *) ctx->Extensions.String);
  1156.  
  1157.    if (ctx->VersionString)
  1158.       free(ctx->VersionString);
  1159.  
  1160.    /* unbind the context if it's currently bound */
  1161.    if (ctx == _mesa_get_current_context()) {
  1162.       _mesa_make_current(NULL, NULL, NULL);
  1163.    }
  1164. }
  1165.  
  1166.  
  1167. /**
  1168.  * Destroy a struct gl_context structure.
  1169.  *
  1170.  * \param ctx GL context.
  1171.  *
  1172.  * Calls _mesa_free_context_data() and frees the gl_context object itself.
  1173.  */
  1174. void
  1175. _mesa_destroy_context( struct gl_context *ctx )
  1176. {
  1177.    if (ctx) {
  1178.       _mesa_free_context_data(ctx);
  1179.       free( (void *) ctx );
  1180.    }
  1181. }
  1182.  
  1183.  
  1184. #if _HAVE_FULL_GL
  1185. /**
  1186.  * Copy attribute groups from one context to another.
  1187.  *
  1188.  * \param src source context
  1189.  * \param dst destination context
  1190.  * \param mask bitwise OR of GL_*_BIT flags
  1191.  *
  1192.  * According to the bits specified in \p mask, copies the corresponding
  1193.  * attributes from \p src into \p dst.  For many of the attributes a simple \c
  1194.  * memcpy is not enough due to the existence of internal pointers in their data
  1195.  * structures.
  1196.  */
  1197. void
  1198. _mesa_copy_context( const struct gl_context *src, struct gl_context *dst, GLuint mask )
  1199. {
  1200.    if (mask & GL_ACCUM_BUFFER_BIT) {
  1201.       /* OK to memcpy */
  1202.       dst->Accum = src->Accum;
  1203.    }
  1204.    if (mask & GL_COLOR_BUFFER_BIT) {
  1205.       /* OK to memcpy */
  1206.       dst->Color = src->Color;
  1207.    }
  1208.    if (mask & GL_CURRENT_BIT) {
  1209.       /* OK to memcpy */
  1210.       dst->Current = src->Current;
  1211.    }
  1212.    if (mask & GL_DEPTH_BUFFER_BIT) {
  1213.       /* OK to memcpy */
  1214.       dst->Depth = src->Depth;
  1215.    }
  1216.    if (mask & GL_ENABLE_BIT) {
  1217.       /* no op */
  1218.    }
  1219.    if (mask & GL_EVAL_BIT) {
  1220.       /* OK to memcpy */
  1221.       dst->Eval = src->Eval;
  1222.    }
  1223.    if (mask & GL_FOG_BIT) {
  1224.       /* OK to memcpy */
  1225.       dst->Fog = src->Fog;
  1226.    }
  1227.    if (mask & GL_HINT_BIT) {
  1228.       /* OK to memcpy */
  1229.       dst->Hint = src->Hint;
  1230.    }
  1231.    if (mask & GL_LIGHTING_BIT) {
  1232.       GLuint i;
  1233.       /* begin with memcpy */
  1234.       dst->Light = src->Light;
  1235.       /* fixup linked lists to prevent pointer insanity */
  1236.       make_empty_list( &(dst->Light.EnabledList) );
  1237.       for (i = 0; i < MAX_LIGHTS; i++) {
  1238.          if (dst->Light.Light[i].Enabled) {
  1239.             insert_at_tail(&(dst->Light.EnabledList), &(dst->Light.Light[i]));
  1240.          }
  1241.       }
  1242.    }
  1243.    if (mask & GL_LINE_BIT) {
  1244.       /* OK to memcpy */
  1245.       dst->Line = src->Line;
  1246.    }
  1247.    if (mask & GL_LIST_BIT) {
  1248.       /* OK to memcpy */
  1249.       dst->List = src->List;
  1250.    }
  1251.    if (mask & GL_PIXEL_MODE_BIT) {
  1252.       /* OK to memcpy */
  1253.       dst->Pixel = src->Pixel;
  1254.    }
  1255.    if (mask & GL_POINT_BIT) {
  1256.       /* OK to memcpy */
  1257.       dst->Point = src->Point;
  1258.    }
  1259.    if (mask & GL_POLYGON_BIT) {
  1260.       /* OK to memcpy */
  1261.       dst->Polygon = src->Polygon;
  1262.    }
  1263.    if (mask & GL_POLYGON_STIPPLE_BIT) {
  1264.       /* Use loop instead of memcpy due to problem with Portland Group's
  1265.        * C compiler.  Reported by John Stone.
  1266.        */
  1267.       GLuint i;
  1268.       for (i = 0; i < 32; i++) {
  1269.          dst->PolygonStipple[i] = src->PolygonStipple[i];
  1270.       }
  1271.    }
  1272.    if (mask & GL_SCISSOR_BIT) {
  1273.       /* OK to memcpy */
  1274.       dst->Scissor = src->Scissor;
  1275.    }
  1276.    if (mask & GL_STENCIL_BUFFER_BIT) {
  1277.       /* OK to memcpy */
  1278.       dst->Stencil = src->Stencil;
  1279.    }
  1280.    if (mask & GL_TEXTURE_BIT) {
  1281.       /* Cannot memcpy because of pointers */
  1282.       _mesa_copy_texture_state(src, dst);
  1283.    }
  1284.    if (mask & GL_TRANSFORM_BIT) {
  1285.       /* OK to memcpy */
  1286.       dst->Transform = src->Transform;
  1287.    }
  1288.    if (mask & GL_VIEWPORT_BIT) {
  1289.       /* Cannot use memcpy, because of pointers in GLmatrix _WindowMap */
  1290.       dst->Viewport.X = src->Viewport.X;
  1291.       dst->Viewport.Y = src->Viewport.Y;
  1292.       dst->Viewport.Width = src->Viewport.Width;
  1293.       dst->Viewport.Height = src->Viewport.Height;
  1294.       dst->Viewport.Near = src->Viewport.Near;
  1295.       dst->Viewport.Far = src->Viewport.Far;
  1296.       _math_matrix_copy(&dst->Viewport._WindowMap, &src->Viewport._WindowMap);
  1297.    }
  1298.  
  1299.    /* XXX FIXME:  Call callbacks?
  1300.     */
  1301.    dst->NewState = _NEW_ALL;
  1302. }
  1303. #endif
  1304.  
  1305.  
  1306. /**
  1307.  * Check if the given context can render into the given framebuffer
  1308.  * by checking visual attributes.
  1309.  *
  1310.  * Most of these tests could go away because Mesa is now pretty flexible
  1311.  * in terms of mixing rendering contexts with framebuffers.  As long
  1312.  * as RGB vs. CI mode agree, we're probably good.
  1313.  *
  1314.  * \return GL_TRUE if compatible, GL_FALSE otherwise.
  1315.  */
  1316. static GLboolean
  1317. check_compatible(const struct gl_context *ctx,
  1318.                  const struct gl_framebuffer *buffer)
  1319. {
  1320.    const struct gl_config *ctxvis = &ctx->Visual;
  1321.    const struct gl_config *bufvis = &buffer->Visual;
  1322.  
  1323.    if (buffer == _mesa_get_incomplete_framebuffer())
  1324.       return GL_TRUE;
  1325.  
  1326. #if 0
  1327.    /* disabling this fixes the fgl_glxgears pbuffer demo */
  1328.    if (ctxvis->doubleBufferMode && !bufvis->doubleBufferMode)
  1329.       return GL_FALSE;
  1330. #endif
  1331.    if (ctxvis->stereoMode && !bufvis->stereoMode)
  1332.       return GL_FALSE;
  1333.    if (ctxvis->haveAccumBuffer && !bufvis->haveAccumBuffer)
  1334.       return GL_FALSE;
  1335.    if (ctxvis->haveDepthBuffer && !bufvis->haveDepthBuffer)
  1336.       return GL_FALSE;
  1337.    if (ctxvis->haveStencilBuffer && !bufvis->haveStencilBuffer)
  1338.       return GL_FALSE;
  1339.    if (ctxvis->redMask && ctxvis->redMask != bufvis->redMask)
  1340.       return GL_FALSE;
  1341.    if (ctxvis->greenMask && ctxvis->greenMask != bufvis->greenMask)
  1342.       return GL_FALSE;
  1343.    if (ctxvis->blueMask && ctxvis->blueMask != bufvis->blueMask)
  1344.       return GL_FALSE;
  1345. #if 0
  1346.    /* disabled (see bug 11161) */
  1347.    if (ctxvis->depthBits && ctxvis->depthBits != bufvis->depthBits)
  1348.       return GL_FALSE;
  1349. #endif
  1350.    if (ctxvis->stencilBits && ctxvis->stencilBits != bufvis->stencilBits)
  1351.       return GL_FALSE;
  1352.  
  1353.    return GL_TRUE;
  1354. }
  1355.  
  1356.  
  1357. /**
  1358.  * Do one-time initialization for the given framebuffer.  Specifically,
  1359.  * ask the driver for the window's current size and update the framebuffer
  1360.  * object to match.
  1361.  * Really, the device driver should totally take care of this.
  1362.  */
  1363. static void
  1364. initialize_framebuffer_size(struct gl_context *ctx, struct gl_framebuffer *fb)
  1365. {
  1366.    GLuint width, height;
  1367.    if (ctx->Driver.GetBufferSize) {
  1368.       ctx->Driver.GetBufferSize(fb, &width, &height);
  1369.       if (ctx->Driver.ResizeBuffers)
  1370.          ctx->Driver.ResizeBuffers(ctx, fb, width, height);
  1371.       fb->Initialized = GL_TRUE;
  1372.    }
  1373. }
  1374.  
  1375.  
  1376. /**
  1377.  * Check if the viewport/scissor size has not yet been initialized.
  1378.  * Initialize the size if the given width and height are non-zero.
  1379.  */
  1380. void
  1381. _mesa_check_init_viewport(struct gl_context *ctx, GLuint width, GLuint height)
  1382. {
  1383.    if (!ctx->ViewportInitialized && width > 0 && height > 0) {
  1384.       /* Note: set flag here, before calling _mesa_set_viewport(), to prevent
  1385.        * potential infinite recursion.
  1386.        */
  1387.       ctx->ViewportInitialized = GL_TRUE;
  1388.       _mesa_set_viewport(ctx, 0, 0, width, height);
  1389.       _mesa_set_scissor(ctx, 0, 0, width, height);
  1390.    }
  1391. }
  1392.  
  1393.  
  1394. /**
  1395.  * Bind the given context to the given drawBuffer and readBuffer and
  1396.  * make it the current context for the calling thread.
  1397.  * We'll render into the drawBuffer and read pixels from the
  1398.  * readBuffer (i.e. glRead/CopyPixels, glCopyTexImage, etc).
  1399.  *
  1400.  * We check that the context's and framebuffer's visuals are compatible
  1401.  * and return immediately if they're not.
  1402.  *
  1403.  * \param newCtx  the new GL context. If NULL then there will be no current GL
  1404.  *                context.
  1405.  * \param drawBuffer  the drawing framebuffer
  1406.  * \param readBuffer  the reading framebuffer
  1407.  */
  1408. GLboolean
  1409. _mesa_make_current( struct gl_context *newCtx,
  1410.                     struct gl_framebuffer *drawBuffer,
  1411.                     struct gl_framebuffer *readBuffer )
  1412. {
  1413.    GET_CURRENT_CONTEXT(curCtx);
  1414.  
  1415.    if (MESA_VERBOSE & VERBOSE_API)
  1416.       _mesa_debug(newCtx, "_mesa_make_current()\n");
  1417.  
  1418.    /* Check that the context's and framebuffer's visuals are compatible.
  1419.     */
  1420.    if (newCtx && drawBuffer && newCtx->WinSysDrawBuffer != drawBuffer) {
  1421.       if (!check_compatible(newCtx, drawBuffer)) {
  1422.          _mesa_warning(newCtx,
  1423.               "MakeCurrent: incompatible visuals for context and drawbuffer");
  1424.          return GL_FALSE;
  1425.       }
  1426.    }
  1427.    if (newCtx && readBuffer && newCtx->WinSysReadBuffer != readBuffer) {
  1428.       if (!check_compatible(newCtx, readBuffer)) {
  1429.          _mesa_warning(newCtx,
  1430.               "MakeCurrent: incompatible visuals for context and readbuffer");
  1431.          return GL_FALSE;
  1432.       }
  1433.    }
  1434.  
  1435.    if (curCtx &&
  1436.       (curCtx->WinSysDrawBuffer || curCtx->WinSysReadBuffer) && /* make sure this context is valid for flushing */
  1437.       curCtx != newCtx)
  1438.       _mesa_flush(curCtx);
  1439.  
  1440.    /* We used to call _glapi_check_multithread() here.  Now do it in drivers */
  1441.    _glapi_set_context((void *) newCtx);
  1442.    ASSERT(_mesa_get_current_context() == newCtx);
  1443.  
  1444.    if (!newCtx) {
  1445.       _glapi_set_dispatch(NULL);  /* none current */
  1446.    }
  1447.    else {
  1448.       _glapi_set_dispatch(newCtx->CurrentDispatch);
  1449.  
  1450.       if (drawBuffer && readBuffer) {
  1451.          /* TODO: check if newCtx and buffer's visual match??? */
  1452.  
  1453.          ASSERT(drawBuffer->Name == 0);
  1454.          ASSERT(readBuffer->Name == 0);
  1455.          _mesa_reference_framebuffer(&newCtx->WinSysDrawBuffer, drawBuffer);
  1456.          _mesa_reference_framebuffer(&newCtx->WinSysReadBuffer, readBuffer);
  1457.  
  1458.          /*
  1459.           * Only set the context's Draw/ReadBuffer fields if they're NULL
  1460.           * or not bound to a user-created FBO.
  1461.           */
  1462.          if (!newCtx->DrawBuffer || newCtx->DrawBuffer->Name == 0) {
  1463.             /* KW: merge conflict here, revisit.
  1464.              */
  1465.             /* fix up the fb fields - these will end up wrong otherwise
  1466.              * if the DRIdrawable changes, and everything relies on them.
  1467.              * This is a bit messy (same as needed in _mesa_BindFramebufferEXT)
  1468.              */
  1469.             unsigned int i;
  1470.             GLenum buffers[MAX_DRAW_BUFFERS];
  1471.  
  1472.             _mesa_reference_framebuffer(&newCtx->DrawBuffer, drawBuffer);
  1473.  
  1474.             for(i = 0; i < newCtx->Const.MaxDrawBuffers; i++) {
  1475.                buffers[i] = newCtx->Color.DrawBuffer[i];
  1476.             }
  1477.  
  1478.             _mesa_drawbuffers(newCtx, newCtx->Const.MaxDrawBuffers,
  1479.                               buffers, NULL);
  1480.          }
  1481.          if (!newCtx->ReadBuffer || newCtx->ReadBuffer->Name == 0) {
  1482.             _mesa_reference_framebuffer(&newCtx->ReadBuffer, readBuffer);
  1483.          }
  1484.  
  1485.          /* XXX only set this flag if we're really changing the draw/read
  1486.           * framebuffer bindings.
  1487.           */
  1488.          newCtx->NewState |= _NEW_BUFFERS;
  1489.  
  1490. #if 1
  1491.          /* We want to get rid of these lines: */
  1492.  
  1493. #if _HAVE_FULL_GL
  1494.          if (!drawBuffer->Initialized) {
  1495.             initialize_framebuffer_size(newCtx, drawBuffer);
  1496.          }
  1497.          if (readBuffer != drawBuffer && !readBuffer->Initialized) {
  1498.             initialize_framebuffer_size(newCtx, readBuffer);
  1499.          }
  1500.  
  1501.          _mesa_resizebuffers(newCtx);
  1502. #endif
  1503.  
  1504. #else
  1505.          /* We want the drawBuffer and readBuffer to be initialized by
  1506.           * the driver.
  1507.           * This generally means the Width and Height match the actual
  1508.           * window size and the renderbuffers (both hardware and software
  1509.           * based) are allocated to match.  The later can generally be
  1510.           * done with a call to _mesa_resize_framebuffer().
  1511.           *
  1512.           * It's theoretically possible for a buffer to have zero width
  1513.           * or height, but for now, assert check that the driver did what's
  1514.           * expected of it.
  1515.           */
  1516.          ASSERT(drawBuffer->Width > 0);
  1517.          ASSERT(drawBuffer->Height > 0);
  1518. #endif
  1519.  
  1520.          if (drawBuffer) {
  1521.             _mesa_check_init_viewport(newCtx,
  1522.                                       drawBuffer->Width, drawBuffer->Height);
  1523.          }
  1524.       }
  1525.  
  1526.       if (newCtx->FirstTimeCurrent) {
  1527.          _mesa_compute_version(newCtx);
  1528.  
  1529.          newCtx->Extensions.String = _mesa_make_extension_string(newCtx);
  1530.  
  1531.          check_context_limits(newCtx);
  1532.  
  1533.          /* We can use this to help debug user's problems.  Tell them to set
  1534.           * the MESA_INFO env variable before running their app.  Then the
  1535.           * first time each context is made current we'll print some useful
  1536.           * information.
  1537.           */
  1538.          if (_mesa_getenv("MESA_INFO")) {
  1539.             _mesa_print_info();
  1540.          }
  1541.  
  1542.          newCtx->FirstTimeCurrent = GL_FALSE;
  1543.       }
  1544.    }
  1545.  
  1546.    return GL_TRUE;
  1547. }
  1548.  
  1549.  
  1550. /**
  1551.  * Make context 'ctx' share the display lists, textures and programs
  1552.  * that are associated with 'ctxToShare'.
  1553.  * Any display lists, textures or programs associated with 'ctx' will
  1554.  * be deleted if nobody else is sharing them.
  1555.  */
  1556. GLboolean
  1557. _mesa_share_state(struct gl_context *ctx, struct gl_context *ctxToShare)
  1558. {
  1559.    if (ctx && ctxToShare && ctx->Shared && ctxToShare->Shared) {
  1560.       struct gl_shared_state *oldSharedState = ctx->Shared;
  1561.  
  1562.       ctx->Shared = ctxToShare->Shared;
  1563.  
  1564.       _glthread_LOCK_MUTEX(ctx->Shared->Mutex);
  1565.       ctx->Shared->RefCount++;
  1566.       _glthread_UNLOCK_MUTEX(ctx->Shared->Mutex);
  1567.  
  1568.       update_default_objects(ctx);
  1569.  
  1570.       _mesa_release_shared_state(ctx, oldSharedState);
  1571.  
  1572.       return GL_TRUE;
  1573.    }
  1574.    else {
  1575.       return GL_FALSE;
  1576.    }
  1577. }
  1578.  
  1579.  
  1580.  
  1581. /**
  1582.  * \return pointer to the current GL context for this thread.
  1583.  *
  1584.  * Calls _glapi_get_context(). This isn't the fastest way to get the current
  1585.  * context.  If you need speed, see the #GET_CURRENT_CONTEXT macro in
  1586.  * context.h.
  1587.  */
  1588. struct gl_context *
  1589. _mesa_get_current_context( void )
  1590. {
  1591.    return (struct gl_context *) _glapi_get_context();
  1592. }
  1593.  
  1594.  
  1595. /**
  1596.  * Get context's current API dispatch table.
  1597.  *
  1598.  * It'll either be the immediate-mode execute dispatcher or the display list
  1599.  * compile dispatcher.
  1600.  *
  1601.  * \param ctx GL context.
  1602.  *
  1603.  * \return pointer to dispatch_table.
  1604.  *
  1605.  * Simply returns __struct gl_contextRec::CurrentDispatch.
  1606.  */
  1607. struct _glapi_table *
  1608. _mesa_get_dispatch(struct gl_context *ctx)
  1609. {
  1610.    return ctx->CurrentDispatch;
  1611. }
  1612.  
  1613. /*@}*/
  1614.  
  1615.  
  1616. /**********************************************************************/
  1617. /** \name Miscellaneous functions                                     */
  1618. /**********************************************************************/
  1619. /*@{*/
  1620.  
  1621. /**
  1622.  * Record an error.
  1623.  *
  1624.  * \param ctx GL context.
  1625.  * \param error error code.
  1626.  *
  1627.  * Records the given error code and call the driver's dd_function_table::Error
  1628.  * function if defined.
  1629.  *
  1630.  * \sa
  1631.  * This is called via _mesa_error().
  1632.  */
  1633. void
  1634. _mesa_record_error(struct gl_context *ctx, GLenum error)
  1635. {
  1636.    if (!ctx)
  1637.       return;
  1638.  
  1639.    if (ctx->ErrorValue == GL_NO_ERROR) {
  1640.       ctx->ErrorValue = error;
  1641.    }
  1642.  
  1643.    /* Call device driver's error handler, if any.  This is used on the Mac. */
  1644.    if (ctx->Driver.Error) {
  1645.       ctx->Driver.Error(ctx);
  1646.    }
  1647. }
  1648.  
  1649.  
  1650. /**
  1651.  * Flush commands and wait for completion.
  1652.  */
  1653. void
  1654. _mesa_finish(struct gl_context *ctx)
  1655. {
  1656.    FLUSH_CURRENT( ctx, 0 );
  1657.    if (ctx->Driver.Finish) {
  1658.       ctx->Driver.Finish(ctx);
  1659.    }
  1660. }
  1661.  
  1662.  
  1663. /**
  1664.  * Flush commands.
  1665.  */
  1666. void
  1667. _mesa_flush(struct gl_context *ctx)
  1668. {
  1669.    FLUSH_CURRENT( ctx, 0 );
  1670.    if (ctx->Driver.Flush) {
  1671.       ctx->Driver.Flush(ctx);
  1672.    }
  1673. }
  1674.  
  1675.  
  1676.  
  1677. /**
  1678.  * Execute glFinish().
  1679.  *
  1680.  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
  1681.  * dd_function_table::Finish driver callback, if not NULL.
  1682.  */
  1683. void GLAPIENTRY
  1684. _mesa_Finish(void)
  1685. {
  1686.    GET_CURRENT_CONTEXT(ctx);
  1687.    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
  1688.    _mesa_finish(ctx);
  1689. }
  1690.  
  1691.  
  1692. /**
  1693.  * Execute glFlush().
  1694.  *
  1695.  * Calls the #ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH macro and the
  1696.  * dd_function_table::Flush driver callback, if not NULL.
  1697.  */
  1698. void GLAPIENTRY
  1699. _mesa_Flush(void)
  1700. {
  1701.    GET_CURRENT_CONTEXT(ctx);
  1702.    ASSERT_OUTSIDE_BEGIN_END_AND_FLUSH(ctx);
  1703.    _mesa_flush(ctx);
  1704. }
  1705.  
  1706.  
  1707. /**
  1708.  * Set mvp_with_dp4 flag.  If a driver has a preference for DP4 over
  1709.  * MUL/MAD, or vice versa, call this function to register that.
  1710.  * Otherwise we default to MUL/MAD.
  1711.  */
  1712. void
  1713. _mesa_set_mvp_with_dp4( struct gl_context *ctx,
  1714.                         GLboolean flag )
  1715. {
  1716.    ctx->mvp_with_dp4 = flag;
  1717. }
  1718.  
  1719.  
  1720.  
  1721. /**
  1722.  * Prior to drawing anything with glBegin, glDrawArrays, etc. this function
  1723.  * is called to see if it's valid to render.  This involves checking that
  1724.  * the current shader is valid and the framebuffer is complete.
  1725.  * If an error is detected it'll be recorded here.
  1726.  * \return GL_TRUE if OK to render, GL_FALSE if not
  1727.  */
  1728. GLboolean
  1729. _mesa_valid_to_render(struct gl_context *ctx, const char *where)
  1730. {
  1731.    bool vert_from_glsl_shader = false;
  1732.    bool geom_from_glsl_shader = false;
  1733.    bool frag_from_glsl_shader = false;
  1734.  
  1735.    /* This depends on having up to date derived state (shaders) */
  1736.    if (ctx->NewState)
  1737.       _mesa_update_state(ctx);
  1738.  
  1739.    if (ctx->Shader.CurrentVertexProgram) {
  1740.       vert_from_glsl_shader = true;
  1741.  
  1742.       if (!ctx->Shader.CurrentVertexProgram->LinkStatus) {
  1743.          _mesa_error(ctx, GL_INVALID_OPERATION,
  1744.                      "%s(shader not linked)", where);
  1745.          return GL_FALSE;
  1746.       }
  1747. #if 0 /* not normally enabled */
  1748.       {
  1749.          char errMsg[100];
  1750.          if (!_mesa_validate_shader_program(ctx,
  1751.                                             ctx->Shader.CurrentVertexProgram,
  1752.                                             errMsg)) {
  1753.             _mesa_warning(ctx, "Shader program %u is invalid: %s",
  1754.                           ctx->Shader.CurrentVertexProgram->Name, errMsg);
  1755.          }
  1756.       }
  1757. #endif
  1758.    }
  1759.  
  1760.    if (ctx->Shader.CurrentGeometryProgram) {
  1761.       geom_from_glsl_shader = true;
  1762.  
  1763.       if (!ctx->Shader.CurrentGeometryProgram->LinkStatus) {
  1764.          _mesa_error(ctx, GL_INVALID_OPERATION,
  1765.                      "%s(shader not linked)", where);
  1766.          return GL_FALSE;
  1767.       }
  1768. #if 0 /* not normally enabled */
  1769.       {
  1770.          char errMsg[100];
  1771.          if (!_mesa_validate_shader_program(ctx,
  1772.                                             ctx->Shader.CurrentGeometryProgram,
  1773.                                             errMsg)) {
  1774.             _mesa_warning(ctx, "Shader program %u is invalid: %s",
  1775.                           ctx->Shader.CurrentGeometryProgram->Name, errMsg);
  1776.          }
  1777.       }
  1778. #endif
  1779.    }
  1780.  
  1781.    if (ctx->Shader.CurrentFragmentProgram) {
  1782.       frag_from_glsl_shader = true;
  1783.  
  1784.       if (!ctx->Shader.CurrentFragmentProgram->LinkStatus) {
  1785.          _mesa_error(ctx, GL_INVALID_OPERATION,
  1786.                      "%s(shader not linked)", where);
  1787.          return GL_FALSE;
  1788.       }
  1789. #if 0 /* not normally enabled */
  1790.       {
  1791.          char errMsg[100];
  1792.          if (!_mesa_validate_shader_program(ctx,
  1793.                                             ctx->Shader.CurrentFragmentProgram,
  1794.                                             errMsg)) {
  1795.             _mesa_warning(ctx, "Shader program %u is invalid: %s",
  1796.                           ctx->Shader.CurrentFragmentProgram->Name, errMsg);
  1797.          }
  1798.       }
  1799. #endif
  1800.    }
  1801.  
  1802.    /* Any shader stages that are not supplied by the GLSL shader and have
  1803.     * assembly shaders enabled must now be validated.
  1804.     */
  1805.    if (!vert_from_glsl_shader
  1806.        && ctx->VertexProgram.Enabled && !ctx->VertexProgram._Enabled) {
  1807.       _mesa_error(ctx, GL_INVALID_OPERATION,
  1808.                   "%s(vertex program not valid)", where);
  1809.       return GL_FALSE;
  1810.    }
  1811.  
  1812.    /* FINISHME: If GL_NV_geometry_program4 is ever supported, the current
  1813.     * FINISHME: geometry program should validated here.
  1814.     */
  1815.    (void) geom_from_glsl_shader;
  1816.  
  1817.    if (!frag_from_glsl_shader) {
  1818.       if (ctx->FragmentProgram.Enabled && !ctx->FragmentProgram._Enabled) {
  1819.          _mesa_error(ctx, GL_INVALID_OPERATION,
  1820.                      "%s(fragment program not valid)", where);
  1821.          return GL_FALSE;
  1822.       }
  1823.  
  1824.       /* If drawing to integer-valued color buffers, there must be an
  1825.        * active fragment shader (GL_EXT_texture_integer).
  1826.        */
  1827.       if (ctx->DrawBuffer && ctx->DrawBuffer->_IntegerColor) {
  1828.          _mesa_error(ctx, GL_INVALID_OPERATION,
  1829.                      "%s(integer format but no fragment shader)", where);
  1830.          return GL_FALSE;
  1831.       }
  1832.    }
  1833.  
  1834.    if (ctx->DrawBuffer->_Status != GL_FRAMEBUFFER_COMPLETE_EXT) {
  1835.       _mesa_error(ctx, GL_INVALID_FRAMEBUFFER_OPERATION_EXT,
  1836.                   "%s(incomplete framebuffer)", where);
  1837.       return GL_FALSE;
  1838.    }
  1839.  
  1840. #ifdef DEBUG
  1841.    if (ctx->Shader.Flags & GLSL_LOG) {
  1842.       struct gl_shader_program *shProg[MESA_SHADER_TYPES];
  1843.       gl_shader_type i;
  1844.  
  1845.       shProg[MESA_SHADER_VERTEX] = ctx->Shader.CurrentVertexProgram;
  1846.       shProg[MESA_SHADER_GEOMETRY] = ctx->Shader.CurrentGeometryProgram;
  1847.       shProg[MESA_SHADER_FRAGMENT] = ctx->Shader.CurrentFragmentProgram;
  1848.  
  1849.       for (i = 0; i < MESA_SHADER_TYPES; i++) {
  1850.          struct gl_shader *sh;
  1851.  
  1852.          if (shProg[i] == NULL || shProg[i]->_Used
  1853.              || shProg[i]->_LinkedShaders[i] == NULL)
  1854.             continue;
  1855.  
  1856.          /* This is the first time this shader is being used.
  1857.           * Append shader's constants/uniforms to log file.
  1858.           *
  1859.           * The logic is a little odd here.  We only want to log data for each
  1860.           * shader target that will actually be used, and we only want to log
  1861.           * it once.  It's possible to have a program bound to the vertex
  1862.           * shader target that also supplied a fragment shader.  If that
  1863.           * program isn't also bound to the fragment shader target we don't
  1864.           * want to log its fragment data.
  1865.           */
  1866.          sh = shProg[i]->_LinkedShaders[i];
  1867.          switch (sh->Type) {
  1868.          case GL_VERTEX_SHADER:
  1869.             _mesa_append_uniforms_to_file(sh, &shProg[i]->VertexProgram->Base);
  1870.             break;
  1871.  
  1872.          case GL_GEOMETRY_SHADER_ARB:
  1873.             _mesa_append_uniforms_to_file(sh,
  1874.                                           &shProg[i]->GeometryProgram->Base);
  1875.             break;
  1876.  
  1877.          case GL_FRAGMENT_SHADER:
  1878.             _mesa_append_uniforms_to_file(sh,
  1879.                                           &shProg[i]->FragmentProgram->Base);
  1880.             break;
  1881.          }
  1882.       }
  1883.  
  1884.       for (i = 0; i < MESA_SHADER_TYPES; i++) {
  1885.          if (shProg[i] != NULL)
  1886.             shProg[i]->_Used = GL_TRUE;
  1887.       }
  1888.    }
  1889. #endif
  1890.  
  1891.    return GL_TRUE;
  1892. }
  1893.  
  1894.  
  1895. /*@}*/
  1896.