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