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